CWE-ou-minkata/Sources/Tools/MaxComponent/plRepComponent.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 "HeadSpin.h"

#include "max.h"
#include "dummy.h"
#include "resource.h"
#include "plComponent.h"
#include "plComponentReg.h"
#include "plMiscComponents.h"

#include "MaxMain/plPlasmaRefMsgs.h"
#include "MaxMain/plMaxNode.h"
#include "MaxExport/plExportErrorMsg.h"

#include "hsResMgr.h"

#include "plLoadMask.h"

#include "plPickNode.h"


void DummyCodeIncludeFuncRepComp()
{
}

const Class_ID REPCOMP_CID(0x157c29f3, 0x18fa54cd);
const Class_ID REPGROUP_CID(0x20ce74a2, 0x471b2386);

static const int kNumQualities = 4;
static const char* kQualityStrings[kNumQualities] = {
    "Low",
    "Medium",
    "High",
    "Ultra"
};

class plRepresentComp : public plComponent
{
public:
    enum {
        kQuality
    };
public:
    plRepresentComp();
    void DeleteThis() { delete this; }
    
    // SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
    // of properties on the MaxNode, as it's still indeterminant.
    virtual hsBool SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg);
    virtual hsBool PreConvert(plMaxNode *node, plErrorMsg *pErrMsg);
    virtual hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
    virtual hsBool DeInit(plMaxNode *node, plErrorMsg *pErrMsg);

    int GetQuality();
    int GetCapability();

    void SetLoadMask(const plLoadMask& m);

    static plRepresentComp* GetComp(INode* node);
};

#define WM_ROLLOUT_OPEN WM_USER+1

class plRepresentProc : public ParamMap2UserDlgProc
{
public:
    BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
        switch (msg)
        {
        case WM_INITDIALOG:
            {
                PostMessage(hWnd, WM_ROLLOUT_OPEN, 0, 0);

                HWND cbox = GetDlgItem(hWnd, IDC_COMP_REPRESENT_QUALITY);
                int i;
                for( i = 0; i < kNumQualities; i++ )
                {
                    SendMessage(cbox, CB_ADDSTRING, 0, (LPARAM)kQualityStrings[i]);
                }
                SendMessage(cbox, CB_SETCURSEL, map->GetParamBlock()->GetInt(plRepresentComp::kQuality), 0);

            }
            return true;

        case WM_COMMAND:
            switch( LOWORD(wParam) )
            {
            case IDC_COMP_REPRESENT_QUALITY:
                map->GetParamBlock()->SetValue(plRepresentComp::kQuality, t, SendMessage(GetDlgItem(hWnd, LOWORD(wParam)), CB_GETCURSEL, 0, 0));
                return TRUE;
            }
            break;
        }

        return false;
    }
    void DeleteThis() {}
};
static plRepresentProc gRepresentProc;


CLASS_DESC(plRepresentComp, gRepresentDesc, "Representation",  "Rep", COMP_TYPE_GRAPHICS, REPCOMP_CID)

ParamBlockDesc2 gRepresentBk
(   
    plComponent::kBlkComp, _T("Represent"), 0, &gRepresentDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

    IDD_COMP_REPRESENT, IDS_COMP_REPRESENT, 0, 0, &gRepresentProc,

    plRepresentComp::kQuality,  _T("Quality"),  TYPE_INT,   0, 0,
        p_default, 0,
        end,

    end
);

plRepresentComp::plRepresentComp()
{
    fClassDesc = &gRepresentDesc;
    fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plRepresentComp::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
    return true;
}

hsBool plRepresentComp::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
    return true;
}

hsBool plRepresentComp::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
    return true;
}

hsBool plRepresentComp::DeInit(plMaxNode* node, plErrorMsg* pErrMsg)
{
    return true;
}

int plRepresentComp::GetQuality()
{
    return fCompPB->GetInt(kQuality);
}

int plRepresentComp::GetCapability()
{
    int maxCap = 0;
    int numTarg = NumTargets();
    int iTarg;
    for( iTarg = 0; iTarg < numTarg; iTarg++ )
    {
        plMaxNodeBase* node = GetTarget(iTarg);
        if( node )
        {
            const char* name = node->GetName();
            int numComp = node->NumAttachedComponents();
            int iComp;
            for( iComp = 0; iComp < numComp; iComp++ )
            {
                plComponentBase* comp = node->GetAttachedComponent(iComp);
                if( comp )
                {
                    const char* compName = comp->GetINode()->GetName();
                    int cap = comp->GetMinCap();
                    if( cap > maxCap )
                        maxCap = cap;
                }
            }
        }
    }
    return maxCap;
}

void plRepresentComp::SetLoadMask(const plLoadMask& m)
{
    int numTarg = NumTargets();
    int iTarg;
    for( iTarg = 0; iTarg < numTarg; iTarg++ )
    {
        plMaxNodeBase* node = GetTarget(iTarg);
        if( node )
        {
            const char* nodeName = node->GetName();
            node->AddLoadMask(m);
            plLoadMask x = node->GetLoadMask();
            x |= m;
        }
    }
}

plRepresentComp* plRepresentComp::GetComp(INode* node)
{
    if( node == nil )
        return nil;

    plComponentBase *comp = ((plMaxNodeBase*)node)->ConvertToComponent();
    if( comp == nil )
        return nil;

    if( comp->ClassID() == REPCOMP_CID )
        return (plRepresentComp*) comp;

    return nil;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

class plRepGroupComp : public plComponent
{
public:
    enum {
        kReps
    };

    void    IGetQC(int quals[], int caps[]);

    hsBool ComputeAndValidate(plErrorMsg* pErrMsg, int quals[], int caps[], plLoadMask masks[]);

    void CleanDeadNodes();
public:
    plRepGroupComp();
    void DeleteThis() { delete this; }
    
    // SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
    // of properties on the MaxNode, as it's still indeterminant.
    virtual hsBool SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg);
    virtual hsBool PreConvert(plMaxNode *node, plErrorMsg *pErrMsg);
    virtual hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg);
    virtual hsBool DeInit(plMaxNode *node, plErrorMsg *pErrMsg);

    hsBool Validate(plErrorMsg* pErrMsg);
};

void plRepGroupComp::CleanDeadNodes()
{
    int i = fCompPB->Count(kReps) - 1;
    while( i >= 0 )
    {
        if( !fCompPB->GetINode(kReps, TimeValue(0), i) )
            fCompPB->Delete(kReps, i, 1);
        i--;
    }
}

class plRepGroupProc : public ParamMap2UserDlgProc
{
public:
    BOOL DlgProc(TimeValue t, IParamMap2 *map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
        switch (msg)
        {
        case WM_INITDIALOG:
            {
            }
            return true;

        case WM_COMMAND:
            if( HIWORD(wParam) == BN_CLICKED )
            {
                switch( LOWORD(wParam) )
                {
                case IDC_ADD_REPS:
                    {
                        std::vector<Class_ID> cids;
                        cids.push_back(REPCOMP_CID);
                        IParamBlock2 *pb = map->GetParamBlock();
                        plPick::Node(pb, plRepGroupComp::kReps, &cids, false, false);

                        map->Invalidate(plRepGroupComp::kReps);
                    }
                    return TRUE;
                case IDC_UP_REPS:
                    {
                        HWND hNode = GetDlgItem(hWnd, IDC_LIST_REPS);
                        int idx = ListBox_GetCurSel(hNode);
                        if( (idx != LB_ERR) && (idx > 0) )
                        {
                            IParamBlock2 *pb = map->GetParamBlock();
                            INode* node = pb->GetINode(plRepGroupComp::kReps, TimeValue(0), idx);
                            pb->Delete(plRepGroupComp::kReps, idx, 1);
                            if( node )
                                pb->Insert(plRepGroupComp::kReps, idx-1, 1, &node);
                            ListBox_SetCurSel(hNode, idx-1);

                            map->Invalidate(plRepGroupComp::kReps);
                        }
                    }
                    return TRUE;
                case IDC_DOWN_REPS:
                    {
                        HWND hNode = GetDlgItem(hWnd, IDC_LIST_REPS);
                        IParamBlock2 *pb = map->GetParamBlock();
                        int idx = ListBox_GetCurSel(hNode);
                        if( (idx != LB_ERR) && (idx < pb->Count(plRepGroupComp::kReps)-1) )
                        {
                            INode* node = pb->GetINode(plRepGroupComp::kReps, TimeValue(0), idx);
                            pb->Delete(plRepGroupComp::kReps, idx, 1);
                            if( node )
                                pb->Insert(plRepGroupComp::kReps, idx+1, 1, &node);
                            ListBox_SetCurSel(hNode, idx+1);

                            map->Invalidate(plRepGroupComp::kReps);
                        }
                    }
                    return TRUE;
                case IDC_VAL_REPS:
                    {
                        plRepGroupComp* repGroup = (plRepGroupComp*)map->GetParamBlock()->GetOwner();
                        plExportErrorMsg errMsg;
                        repGroup->Validate(&errMsg);
                    }
                    return TRUE;
                }
            }
            break;
        }

        return false;
    }
    void DeleteThis() {}
};
static plRepGroupProc gRepGroupProc;

CLASS_DESC(plRepGroupComp, gRepGroupDesc, "Representation Group",  "RepGroup", COMP_TYPE_GRAPHICS, REPGROUP_CID)

ParamBlockDesc2 gRepGroupBk
(   
    plComponent::kBlkComp, _T("RepGroup"), 0, &gRepGroupDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

    IDD_COMP_REPGROUP, IDS_COMP_REPGROUP, 0, 0, &gRepGroupProc,

    plRepGroupComp::kReps,  _T("Reps"), TYPE_INODE_TAB, 0,      0, 0,
        p_ui,           TYPE_NODELISTBOX, IDC_LIST_REPS, 0, 0, IDC_DEL_REPS,
        end,

    end
);

plRepGroupComp::plRepGroupComp()
{
    fClassDesc = &gRepGroupDesc;
    fClassDesc->MakeAutoParamBlocks(this);
}

void plRepGroupComp::IGetQC(int quals[], int caps[])
{
    const int numReps = fCompPB->Count(kReps);
    int i;
    for( i = 0; i < numReps; i++ )
    {
        plRepresentComp* rep = plRepresentComp::GetComp(fCompPB->GetINode(kReps, TimeValue(0), i));
        quals[i] = rep->GetQuality();
        caps[i] = rep->GetCapability();
    }
}
hsBool plRepGroupComp::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
    const int numReps = fCompPB->Count(kReps);
    hsTArray<int> quals(numReps);
    hsTArray<int> caps(numReps);
    hsTArray<plLoadMask> masks(numReps);

    IGetQC(quals.AcquireArray(), caps.AcquireArray());

    ComputeAndValidate(pErrMsg, quals.AcquireArray(), caps.AcquireArray(), masks.AcquireArray());

    int i;
    for( i = 0; i < numReps; i++ )
    {
        plRepresentComp* rep = plRepresentComp::GetComp(fCompPB->GetINode(kReps, TimeValue(0), i));
        rep->SetLoadMask(masks[i]);
    }

    return true;
}

hsBool plRepGroupComp::PreConvert(plMaxNode* node, plErrorMsg* pErrMsg)
{
    return true;
}

hsBool plRepGroupComp::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
    return true;
}

hsBool plRepGroupComp::DeInit(plMaxNode* node, plErrorMsg* pErrMsg)
{
    return true;
}

hsBool plRepGroupComp::ComputeAndValidate(plErrorMsg* pErrMsg, int quals[], int caps[], plLoadMask masks[])
{
    const int numReps = fCompPB->Count(kReps);
    UInt32 preVal = plLoadMask::ValidateReps(numReps, quals, caps);

    if( preVal )
    {
        int i;
        for( i = 0; i < 32; i++ )
        {
            if( preVal & (1 << i) )
            {
                char buff[256];
                INode* rep = fCompPB->GetINode(kReps, TimeValue(0), i);
                sprintf(buff, "Rep %d - %s is obscured by an earlier representation in preVal", i, rep ? rep->GetName() : "Unknown");
                pErrMsg->Set(true, GetINode()->GetName(), buff).Show();
                pErrMsg->Set(false);
            }
        }
    }

    hsBool val = plLoadMask::ComputeRepMasks(numReps, quals, caps, masks);

    UInt32 postVal = plLoadMask::ValidateMasks(numReps, masks);

    if( postVal )
    {
        int i;
        for( i = 0; i < 32; i++ )
        {
            if( !(preVal & (1 << i)) && (postVal & (1 << i)) )
            {
                char buff[256];
                INode* rep = fCompPB->GetINode(kReps, TimeValue(0), i);
                sprintf(buff, "Rep %d - %s is obscured by an earlier representation in postVal", i, rep ? rep->GetName() : "Unknown");
                pErrMsg->Set(true, GetINode()->GetName(), buff).Show();
                pErrMsg->Set(false);
            }
        }
    }

    return !(preVal || val || postVal);
}

hsBool plRepGroupComp::Validate(plErrorMsg* pErrMsg)
{
    CleanDeadNodes();

    const int numReps = fCompPB->Count(kReps);
    hsTArray<int> quals(numReps);
    hsTArray<int> caps(numReps);
    hsTArray<plLoadMask> masks(numReps);

    IGetQC(quals.AcquireArray(), caps.AcquireArray());

    return ComputeAndValidate(pErrMsg, quals.AcquireArray(), caps.AcquireArray(), masks.AcquireArray());
}