CWE-ou-minkata/Sources/Tools/MaxPlasmaMtls/Layers/plLayerTex.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "hsTypes.h"
#include "plLayerTex.h"

#include "iparamb2.h"
#include "iparamm2.h"
#include "stdmat.h"

#include "../plBMSampler.h"
#include "../resource.h"
#include "plLayerTexBitmapPB.h"
#include "MaxMain/plPlasmaRefMsgs.h"

class plLayerTexClassDesc : public ClassDesc2
{
public:
    int             IsPublic()      { return TRUE; }
    void*           Create(BOOL loading = FALSE) { return TRACKED_NEW plLayerTex(); }
    const TCHAR*    ClassName()     { return GetString(IDS_LAYER); }
    SClass_ID       SuperClassID()  { return TEXMAP_CLASS_ID; }
    Class_ID        ClassID()       { return LAYER_TEX_CLASS_ID; }
    const TCHAR*    Category()      { return TEXMAP_CAT_2D; }
    const TCHAR*    InternalName()  { return _T("PlasmaLayer"); }
    HINSTANCE       HInstance()     { return hInstance; }
};
static plLayerTexClassDesc plLayerTexDesc;
ClassDesc2* GetLayerTexDesc() { return &plLayerTexDesc; }

ParamDlg* plLayerTex::fUVGenDlg = NULL;

// For initializing paramblock descriptor
//ParamBlockDesc2 *GetBasicBlk();
ParamBlockDesc2 *GetBitmapBlk();

//#include "plLayerTexBasicPB.cpp"
#include "plLayerTexBitmapPB.cpp"

void    plLayerTex::GetClassName( TSTR &s )
{
    s = GetString( IDS_LAYER );
}

plLayerTex::plLayerTex() :
    fBitmapPB(NULL),
    //fBasicPB(NULL),
    fUVGen(NULL),
    fTexHandle(NULL),
    fTexTime(0),
    fBM(NULL),
    fIValid(NEVER)
{
#if 0
    // Initialize the paramblock descriptors only once
    static bool descInit = false;
    if (!descInit)
    {
        descInit = true;
        //GetBasicBlk()->SetClassDesc(GetLayerTexDesc());
        GetBitmapBlk()->SetClassDesc(GetLayerTexDesc());
    }
#endif

    plLayerTexDesc.MakeAutoParamBlocks(this);
    ReplaceReference(kRefUVGen, GetNewDefaultUVGen());  
}

plLayerTex::~plLayerTex()
{
    if (fBM)
        fBM->DeleteThis();

    IDiscardTexHandle();
}

//From MtlBase
void plLayerTex::Reset() 
{
    GetLayerTexDesc()->Reset(this, TRUE);   // reset all pb2's
    SetBitmap(NULL);

    fIValid.SetEmpty();
}

void plLayerTex::Update(TimeValue t, Interval& valid) 
{
    if (!fIValid.InInterval(t))
    {
        fIValid.SetInfinite();

        fUVGen->Update(t,fIValid);
        fBitmapPB->GetValidity(t, fIValid);

//      Interval clipValid;
//      clipValid.SetInfinite();
//      float temp;
//      fBitmapPB->GetValue(kBmpClipU, t, temp, clipValid);
//      fBitmapPB->GetValue(kBmpClipV, t, temp, clipValid);
//      fBitmapPB->GetValue(kBmpClipW, t, temp, clipValid);
//      fBitmapPB->GetValue(kBmpClipH, t, temp, clipValid);
    }

    // Gonna need to do this when we support animated bm's
#if 0
    if (fBM)
    {
        if (bi.FirstFrame()!=bi.LastFrame())
            ivalid.SetInstant(t);
    }
#endif

    valid &= fIValid;
}

Interval plLayerTex::Validity(TimeValue t)
{
    //TODO: Update fIValid here

    // mf horse - Hacking this in just to get animations working.
    // No warranty on this not being stupid.
    Interval v = FOREVER;
    fBitmapPB->GetValidity(t, v);
    //fBasicPB->GetValidity(t, v);
    v &= fUVGen->Validity(t);
    return v;
}

ParamDlg* plLayerTex::CreateParamDlg(HWND hwMtlEdit, IMtlParams *imp) 
{
    fMtlParams = imp;

    IAutoMParamDlg* masterDlg = plLayerTexDesc.CreateParamDlgs(hwMtlEdit, imp, this);

    fUVGenDlg = fUVGen->CreateParamDlg(hwMtlEdit, imp);
    masterDlg->AddDlg(fUVGenDlg);

    return masterDlg;   
}

BOOL plLayerTex::SetDlgThing(ParamDlg* dlg)
{   
    if (dlg == fUVGenDlg)
    {
        fUVGenDlg->SetThing(fUVGen);
        return TRUE;
    }

    return FALSE;
}

int plLayerTex::NumRefs()
{
    return 3;
}

//From ReferenceMaker
RefTargetHandle plLayerTex::GetReference(int i) 
{
    switch (i)
    {
        case kRefUVGen:     return fUVGen;
        case kRefBitmap:    return fBitmapPB;
        //case kRefBasic:       return fBasicPB;
        default: return NULL;
    }
}

void plLayerTex::SetReference(int i, RefTargetHandle rtarg) 
{
    Interval    garbage;

    switch (i)
    {
        case kRefUVGen:  
            fUVGen = (UVGen *)rtarg; 
            if( fUVGen )
                fUVGen->Update( TimeValue( 0 ), garbage );
            break;
        case kRefBitmap:
            fBitmapPB = (IParamBlock2 *)rtarg;
            // KLUDGE: If the paramblock is being set chances are we are being created or
            // loaded.  In the case of load, we want to refresh our texture.
            if (fBitmapPB)
                RefreshBitmaps();
            break;
    }
}

int plLayerTex::NumParamBlocks()
{
    return 2;
}

IParamBlock2* plLayerTex::GetParamBlock(int i)
{
    switch (i)
    {
    case 0: return fBitmapPB;
    //case 1:   return fBasicPB;
    default: return NULL;
    }
}

IParamBlock2* plLayerTex::GetParamBlockByID(BlockID id)
{
    if (fBitmapPB->ID() == id)
        return fBitmapPB;
    //else if (fBasicPB->ID() == id)
    //  return fBasicPB;
    else
        return NULL;
}

//From ReferenceTarget 
RefTargetHandle plLayerTex::Clone(RemapDir &remap) 
{
    plLayerTex *mnew = TRACKED_NEW plLayerTex();
    *((MtlBase*)mnew) = *((MtlBase*)this); // copy superclass stuff
    //mnew->ReplaceReference(kRefBasic, remap.CloneRef(fBasicPB));
    mnew->ReplaceReference(kRefBitmap, remap.CloneRef(fBitmapPB));
    mnew->ReplaceReference(kRefUVGen, remap.CloneRef(fUVGen));
    BaseClone(this, mnew, remap);
    return (RefTargetHandle)mnew;
}

int plLayerTex::NumSubs()
{
    return 3;
}

Animatable* plLayerTex::SubAnim(int i) 
{
    //TODO: Return 'i-th' sub-anim
    switch (i)
    {
        case kRefUVGen:     return fUVGen;
        case kRefBitmap:    return fBitmapPB;
        //case kRefBasic:       return fBasicPB;
        default: return NULL;
    }
}

TSTR plLayerTex::SubAnimName(int i) 
{
    switch (i)
    {
        case kRefUVGen:     return "UVGen";
        case kRefBitmap:    return fBitmapPB->GetLocalName();
        //case kRefBasic:       return fBasicPB->GetLocalName();
        default: return "";
    }
}

RefResult plLayerTex::NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, 
   PartID& partID, RefMessage message) 
{
    switch (message)
    {
    case REFMSG_CHANGE:
        {
            fIValid.SetEmpty();

            if (hTarget == fBitmapPB)
            {
                // see if this message came from a changing parameter in the pblock,
                // if so, limit rollout update to the changing item and update any active viewport texture
                ParamID changingParam = fBitmapPB->LastNotifyParamID();
                fBitmapPB->GetDesc()->InvalidateUI(changingParam);

                if (changingParam != -1)
                    IChanged();
            }
        }
        break;

    case REFMSG_UV_SYM_CHANGE:
        IDiscardTexHandle();  
        break;
    }

    return REF_SUCCEED;
}

BOOL plLayerTex::DiscardColor() 
{ 
    return fBitmapPB->GetInt(kBmpDiscardColor); 
}

BOOL plLayerTex::DiscardAlpha() 
{ 
    return fBitmapPB->GetInt(kBmpDiscardAlpha); 
}

void plLayerTex::IChanged()
{
    IDiscardTexHandle();
    // Texture wasn't getting updated in the viewports, and this fixes it.
    // Don't know if it's the right way though.
    NotifyDependents(FOREVER, PART_ALL, REFMSG_CHANGE);

    // And this is so the SceneWatcher gets notified that the material on some of it's
    // referenced objects changed.
    NotifyDependents(FOREVER, PART_ALL, REFMSG_USER_MAT);
}

#define TEX_HDR_CHUNK 0x5000
#define MAX_ASS_CHUNK 0x5500

IOResult plLayerTex::Save(ISave *isave) 
{
    IOResult res;
    isave->BeginChunk(TEX_HDR_CHUNK);
    res = MtlBase::Save(isave);
    if (res != IO_OK)
        return res;
    isave->EndChunk();

    return IO_OK;
}   

IOResult plLayerTex::Load(ILoad *iload) 
{
    IOResult res;
    while (IO_OK == (res = iload->OpenChunk()))
    {
        if (iload->CurChunkID() == TEX_HDR_CHUNK)
        {
            res = MtlBase::Load(iload);
        }
        iload->CloseChunk();
        if (res != IO_OK) 
            return res;
    }

   return IO_OK;
}

bool plLayerTex::HasAlpha()
{
   return (fBM != NULL && fBM->HasAlpha() != 0);
}

Bitmap* plLayerTex::GetBitmap(TimeValue t)
{
    return fBM;
}

AColor plLayerTex::EvalColor(ShadeContext& sc)
{
    if (!sc.doMaps) 
        return AColor(0.0f, 0.0f, 0.0f, 1.0f);

    AColor color;
    if (sc.GetCache(this, color)) 
        return color;

    if (gbufID) 
        sc.SetGBufferID(gbufID);

    //
    // Evaluate the Bitmap
    //
    if (fBitmapPB->GetInt(kBmpUseBitmap) && fBM)
    {
        plBMSampler mysamp(this, fBM);
        color = fUVGen->EvalUVMap(sc, &mysamp, FALSE);
        // We'd like to pass TRUE and actually filter the image, but that seems to be
        // tripping an odd crash in Max internals. *shrug*
    }
    else
        color.White();

    // Invert color if specified
    if (fBitmapPB->GetInt(kBmpInvertColor))
    {
        color.r = 1.0f - color.r;
        color.g = 1.0f - color.g;
        color.b = 1.0f - color.b;
    }
    // Discard color if specified
    if (fBitmapPB->GetInt(kBmpDiscardColor))
        color.r = color.g = color.b = 1.0f;

    // Invert alpha if specified
    if (fBitmapPB->GetInt(kBmpInvertAlpha))
        color.a = 1.0f - color.a;
    // Discard alpha if specified
    if (fBitmapPB->GetInt(kBmpDiscardAlpha))
        color.a = 1.0f;

    // If RGB output is set to alpha, show RGB as grayscale of the alpha
    if (fBitmapPB->GetInt(kBmpRGBOutput) == 1)
        color = AColor(color.a, color.a, color.a, 1.0f);

    sc.PutCache(this, color); 
    return color;
}

float plLayerTex::EvalMono(ShadeContext& sc)
{
    if (fBitmapPB->GetInt(kBmpMonoOutput) == 1)
        return EvalColor(sc).a;

    return Intens(EvalColor(sc));
}

Point3 plLayerTex::EvalNormalPerturb(ShadeContext& sc)
{
    // Return the perturbation to apply to a normal for bump mapping
    return Point3(0, 0, 0);
}

ULONG plLayerTex::LocalRequirements(int subMtlNum)
{
    return fUVGen->Requirements(subMtlNum); 
}

#if 0
int plLayerTex::ICalcFrame(TimeValue t) 
{
    PBBitmap *pbbm = fBitmapPB->GetBitmap(kBmpBitmap);
    if (!pbbm || !pbbm->bi)
        return 0;
    BitmapInfo *bi = pbbm->bi;

    TimeValue tm, dur, td;
    int frameStart = bi->FirstFrame();
    int frameEnd = bi->LastFrame();
    int tpf = GetTicksPerFrame();
    tm = TimeValue(float(t - startTime) * pbRate);
    dur = (fend-fstart+1)*GetTicksPerFrame();

    switch (endCond)
    {
    case END_HOLD:
        if (tm <= 0)
            return frameStart;
        if (tm >= dur)
            return frameEnd;
        return tm/tpf;

    case END_PINGPONG:
        if (((tm >= 0) && ((tm / dur) & 1)) || ((tm < 0) && !(tm / dur)))
        {
            td = modt(tm, dur);
            return frameStart + frameEnd - td / tpf;
        }
        // else fall through
    case END_LOOP:
        td = modt(tm, dur);
        return td / tpf;
    }

    return 0;
}
#endif

void plLayerTex::IDiscardTexHandle() 
{
    if (fTexHandle)
    {
        fTexHandle->DeleteThis();
        fTexHandle = NULL;
    }
}

void plLayerTex::ActivateTexDisplay(BOOL onoff)
{
    if (!onoff)
        IDiscardTexHandle();
}

BITMAPINFO *plLayerTex::GetVPDisplayDIB(TimeValue t, TexHandleMaker& thmaker, Interval &valid, BOOL mono, BOOL forceW, BOOL forceH)
{
                        // FIXME
    fTexTime = 0;//CalcFrame(t);
//  texValid = clipValid;
    BITMAPINFO *bmi = NULL;
    int xflags = 0;

    if (fBitmapPB->GetInt(kBmpApply))
    {
        float clipu = fBitmapPB->GetFloat(kBmpClipU);
        float clipv = fBitmapPB->GetFloat(kBmpClipV);
        float clipw = fBitmapPB->GetFloat(kBmpClipW);
        float cliph = fBitmapPB->GetFloat(kBmpClipH);
        int discardAlpha = fBitmapPB->GetInt(kBmpDiscardAlpha);
        int alphaAsRGB = (fBitmapPB->GetInt(kBmpRGBOutput) == 1);

        int w = fBM->Width();
        int h = fBM->Height();

        Bitmap *newBM;
        BitmapInfo bi;
        bi.SetName(_T("y8798734"));
        bi.SetType(BMM_TRUE_32);
        bi.SetFlags(MAP_HAS_ALPHA);

        if (fBitmapPB->GetInt(kBmpCropPlace) == 1)
        {
            int x0, y0, nw, nh;
            int bmw = thmaker.Size();
            int bmh = int(float(bmw)*float(h)/float(w));
            bi.SetWidth(bmw);
            bi.SetHeight(bmh);
            newBM = TheManager->Create(&bi);
            newBM->Fill(0,0,0,0);
            nw = int(float(bmw)*clipw);
            nh = int(float(bmh)*cliph);
            x0 = int(float(bmw-1)*clipu);
            y0 = int(float(bmh-1)*clipv);
            
            if (nw<1) nw = 1;
            if (nh<1) nh = 1;
            PixelBuf row(nw);
            
            Bitmap *tmpBM;
            BitmapInfo bif2;
            bif2.SetName(_T("xxxx67878"));
            bif2.SetType(BMM_TRUE_32);
            bif2.SetFlags(MAP_HAS_ALPHA);
            bif2.SetWidth(nw);              
            bif2.SetHeight(nh);
            tmpBM = TheManager->Create(&bif2);
            tmpBM->CopyImage(fBM, COPY_IMAGE_RESIZE_LO_QUALITY, 0);
            BMM_Color_64*  p1 = row.Ptr();
            for (int y = 0; y<nh; y++)
            {
                tmpBM->GetLinearPixels(0,y, nw, p1);
                if (alphaAsRGB)
                {
                    for (int ix =0; ix<nw; ix++) 
                        p1[ix].r = p1[ix].g = p1[ix].b = p1[ix].a;
                }
                if (discardAlpha)
                {
                    for (int ix = 0; ix < nw; ix++) 
                        p1[ix].a = 0xffff;
                }
                newBM->PutPixels(x0, y+y0, nw, p1);
            }
            tmpBM->DeleteThis();
            bmi = thmaker.BitmapToDIB(newBM, fUVGen->SymFlags(), xflags, forceW, forceH);
            newBM->DeleteThis();
        }
        else
        {
            int x0,y0,nw,nh;
            x0 = int(float(w-1)*clipu);
            y0 = int(float(h-1)*clipv);
            nw = int(float(w)*clipw);
            nh = int(float(h)*cliph);
            if (nw<1) nw = 1;
            if (nh<1) nh = 1;
            bi.SetWidth(nw);
            bi.SetHeight(nh);
            PixelBuf row(nw);
            newBM = TheManager->Create(&bi);
            BMM_Color_64*  p1 = row.Ptr();
            for (int y = 0; y<nh; y++)
            {
                fBM->GetLinearPixels(x0,y+y0, nw, p1);
                if (alphaAsRGB)
                {
                    for (int ix = 0; ix < nw; ix++) 
                        p1[ix].r = p1[ix].g = p1[ix].b = p1[ix].a;
                }
                if (discardAlpha)
                {
                    for (int ix = 0; ix < nw; ix++) 
                        p1[ix].a = 0xffff;
                }
                newBM->PutPixels(0, y, nw, p1);
            }
            bmi = thmaker.BitmapToDIB(newBM, fUVGen->SymFlags(), xflags, forceW, forceH);
            newBM->DeleteThis();
        }
    }
    else
    {
        if (fBitmapPB->GetInt(kBmpRGBOutput) == 1)
            xflags |= EX_RGB_FROM_ALPHA;
        bmi = thmaker.BitmapToDIB(fBM, fUVGen->SymFlags(), xflags, forceW, forceH);
    }

    return bmi;
}

DWORD plLayerTex::GetActiveTexHandle(TimeValue t, TexHandleMaker& thmaker) 
{
    // FIXME: ignore validity for now
    if (fTexHandle && fIValid.InInterval(t))// && texTime == CalcFrame(t)) 
        return fTexHandle->GetHandle();
    else
    {
        IDiscardTexHandle();
        
        fTexTime = 0;//CalcFrame(t);
        fTexHandle = thmaker.MakeHandle(GetVPDisplayDIB(t, thmaker, fIValid));
        if (fTexHandle)
            return fTexHandle->GetHandle();
        else
            return 0;
    }
}

const char *plLayerTex::GetTextureName()
{
//  if (fBitmapPB->GetInt(kBmpUseBitmap))
    {
        PBBitmap *pbbm = fBitmapPB->GetBitmap(kBmpBitmap);
        if (pbbm)
            return pbbm->bi.Name();
    }

    return NULL;
}

void plLayerTex::ISetPBBitmap(PBBitmap *pbbm, int index /* = 0 */)
{ 
    fBitmapPB->SetValue(ParamID(kBmpBitmap), 0, pbbm, index); 
}

PBBitmap *plLayerTex::GetPBBitmap(int index /* = 0 */)
{ 
    return fBitmapPB->GetBitmap(ParamID(kBmpBitmap)); 
}

//// GetSamplerInfo ///////////////////////////////////////////////////////////
//  Virtual function called by plBMSampler to get various things while sampling 
//  the layer's image

bool    plLayerTex::GetSamplerInfo( plBMSamplerData *samplerData )
{
    samplerData->fClipU = fBitmapPB->GetFloat( (ParamID)kBmpClipU );
    samplerData->fClipV = fBitmapPB->GetFloat( (ParamID)kBmpClipV );
    samplerData->fClipW = fBitmapPB->GetFloat( (ParamID)kBmpClipW );
    samplerData->fClipH = fBitmapPB->GetFloat( (ParamID)kBmpClipH );

    samplerData->fEnableCrop = fBitmapPB->GetInt( (ParamID)kBmpApply ) ? true : false;
    samplerData->fCropPlacement = fBitmapPB->GetInt( (ParamID)kBmpCropPlace );

    if( fBitmapPB->GetInt( (ParamID)kBmpDiscardAlpha ) )
        samplerData->fAlphaSource = plBMSamplerData::kDiscard;
    else if( fBitmapPB->GetInt( (ParamID)kBmpRGBOutput ) == 1 )
        samplerData->fAlphaSource = plBMSamplerData::kFromRGB;
    else
        samplerData->fAlphaSource = plBMSamplerData::kFromTexture;

    return true;
}

void plLayerTex::SetExportSize(int x, int y)
{
    fBitmapPB->SetValue(kBmpExportWidth, 0, x);
    fBitmapPB->SetValue(kBmpExportLastWidth, 0, x);
    fBitmapPB->SetValue(kBmpExportHeight, 0, y);
    fBitmapPB->SetValue(kBmpExportLastHeight, 0, y);
}