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

#include "../MaxMain/plMaxNode.h"
#include "plComponentBase.h"

#include "plPickNode.h"
#include "plAnimComponent.h"
#include "../../PubUtilLib/plInterp/plAnimEaseTypes.h"

plAnimCompProc::plAnimCompProc() :
    fCompButtonID(0),
    fCompParamID(0),
    fNodeButtonID(0),
    fNodeParamID(0)
{
}

BOOL plAnimCompProc::DlgProc(TimeValue t, IParamMap2* pm, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_INITDIALOG:
        {
            IParamBlock2* pb = pm->GetParamBlock();

            IUpdateNodeButton(hWnd, pb);
            IUpdateCompButton(hWnd, pb);

            ILoadUser(hWnd, pb);
        }
        return TRUE;

    case WM_COMMAND:
        {
            int cmd = HIWORD(wParam);
            int resID = LOWORD(wParam);

            if (cmd == BN_CLICKED && resID == fCompButtonID)
            {
                ICompButtonPress(hWnd, pm->GetParamBlock());
                return TRUE;
            }
            else if (cmd == BN_CLICKED && resID == fNodeButtonID)
            {
                INodeButtonPress(hWnd, pm->GetParamBlock());
                return TRUE;
            }
            else if (IUserCommand(hWnd, pm->GetParamBlock(), cmd, resID))
                return TRUE;

        }
        break;
    }
    return FALSE;
}

void plAnimCompProc::ICompButtonPress(HWND hWnd, IParamBlock2* pb)
{
    IPickComponent(pb);
    
    IUpdateCompButton(hWnd, pb);
    IUpdateNodeButton(hWnd, pb);

    ILoadUser(hWnd, pb);
}

void plAnimCompProc::IPickNode(IParamBlock2* pb, plComponentBase* comp)
{
    plPick::CompTargets(pb, fNodeParamID, comp);
}

void plAnimCompProc::INodeButtonPress(HWND hWnd, IParamBlock2* pb)
{
    plComponentBase* comp = IGetComp(pb);
    if (comp)
        IPickNode(pb, comp);

    IUpdateNodeButton(hWnd, pb);
    ILoadUser(hWnd, pb);
}

void plAnimCompProc::IUpdateNodeButton(HWND hWnd, IParamBlock2* pb)
{
    HWND hButton = GetDlgItem(hWnd, fNodeButtonID);

    plComponentBase* comp = IGetComp(pb);
    if (!comp)
    {
        SetWindowText(hButton, "(none)");
        EnableWindow(hButton, FALSE);
        return;
    }

    // If this is an anim grouped component you can't pick a target
    if (comp->ClassID() == ANIM_GROUP_COMP_CID)
    {
        IClearNode(pb);
        SetWindowText(hButton, "(none)");
        EnableWindow(hButton, FALSE);
        return;
    }

    EnableWindow(hButton, TRUE);

    // Make sure the node is actually in the components target list
    plMaxNode* node = IGetNode(pb);
    if (comp->IsTarget((plMaxNodeBase*)node))
        SetWindowText(hButton, node->GetName());
    else
        SetWindowText(hButton, "(none)");
}

void plAnimCompProc::IUpdateCompButton(HWND hWnd, IParamBlock2* pb)
{
    HWND hAnim = GetDlgItem(hWnd, fCompButtonID);

    plComponentBase* comp = IGetComp(pb);
    if (comp)
        SetWindowText(hAnim, comp->GetINode()->GetName());
    else
        SetWindowText(hAnim, "(none)");
}

plComponentBase* plAnimCompProc::IGetComp(IParamBlock2* pb)
{
    plMaxNode* node = nil;
    if (pb->GetParameterType(fCompParamID) == TYPE_REFTARG)
        node = (plMaxNode*)pb->GetReferenceTarget(fCompParamID);
    else
        node = (plMaxNode*)pb->GetINode(fCompParamID);

    if (node)
        return node->ConvertToComponent();

    return nil;
}

plMaxNode* plAnimCompProc::IGetNode(IParamBlock2* pb)
{
    if (pb->GetParameterType(fNodeParamID) == TYPE_REFTARG)
        return (plMaxNode*)pb->GetReferenceTarget(fNodeParamID);
    else
        return (plMaxNode*)pb->GetINode(fNodeParamID);
}

void plAnimCompProc::IClearNode(IParamBlock2* pb)
{
    if (pb->GetParameterType(fNodeParamID) == TYPE_REFTARG)
        pb->SetValue(fNodeParamID, 0, (ReferenceTarget*)nil);
    else
        pb->SetValue(fNodeParamID, 0, (INode*)nil);
}

bool plAnimCompProc::GetCompAndNode(IParamBlock2* pb, plComponentBase*& comp, plMaxNode*& node)
{
    comp = IGetComp(pb);
    if (comp)
    {
        node = IGetNode(pb);

        // If it's an anim group component (don't need a node), or we have a node
        // and the component is attached to it, we're ok.
        if (comp->ClassID() == ANIM_GROUP_COMP_CID ||
            (node && comp->IsTarget((plMaxNodeBase*)node)))
            return true;
    }

    return false;
}


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

plMtlAnimProc::plMtlAnimProc() :
    fMtlButtonID(0),
    fMtlParamID(0),
    fNodeButtonID(0),
    fNodeParamID(0),
    fAnimComboID(0),
    fAnimParamID(0)
{
}

BOOL plMtlAnimProc::DlgProc(TimeValue t, IParamMap2* pm, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_INITDIALOG:
        {
            IParamBlock2* pb = pm->GetParamBlock();

            IOnInitDlg(hWnd, pb);

            IUpdateMtlButton(hWnd, pb);
        }
        return TRUE;

    case WM_COMMAND:
        {
            int cmd = HIWORD(wParam);
            int resID = LOWORD(wParam);

            IParamBlock2* pb = pm->GetParamBlock();

            if (cmd == BN_CLICKED && resID == fMtlButtonID)
            {
                IMtlButtonPress(hWnd, pb);
                return TRUE;
            }
            else if (cmd == BN_CLICKED && resID == fNodeButtonID)
            {
                INodeButtonPress(hWnd, pb);
                return TRUE;
            }
            else if (cmd == CBN_SELCHANGE && resID == fAnimComboID)
            {
                IAnimComboChanged(hWnd, pb);
                return TRUE;
            }
            else if (IUserCommand(hWnd, pb, cmd, resID))
                return TRUE;
        }
        break;
    }

    return FALSE;
}

void plMtlAnimProc::IUpdateMtlButton(HWND hWnd, IParamBlock2* pb)
{
    HWND hMtl = GetDlgItem(hWnd, fMtlButtonID);

    // Get the saved material
    Mtl *savedMtl = IGetMtl(pb);

    if (savedMtl)
        SetWindowText(hMtl, savedMtl->GetName());
    else
        SetWindowText(hMtl, "(none)");

    // Enable the node button if a material is selected
    EnableWindow(GetDlgItem(hWnd, fNodeButtonID), (savedMtl != nil));

    // Update the dependencies of this
    IUpdateNodeButton(hWnd, pb);
}

void plMtlAnimProc::IUpdateNodeButton(HWND hWnd, IParamBlock2* pb)
{
    ISetNodeButtonText(hWnd, pb);

    // Update the dependencies of this
    ILoadAnimCombo(hWnd, pb);
}

#include "plNotetrackAnim.h"

void plMtlAnimProc::ILoadAnimCombo(HWND hWnd, IParamBlock2* pb)
{
    HWND hAnim = GetDlgItem(hWnd, fAnimComboID);

    ComboBox_ResetContent(hAnim);
    int sel = ComboBox_AddString(hAnim, ENTIRE_ANIMATION_NAME);
    ComboBox_SetCurSel(hAnim, sel);
    
    const char* savedName = pb->GetStr(fAnimParamID);
    if (!savedName)
        savedName = "";

    Mtl* mtl = IGetMtl(pb);
    if (mtl)
    {
        plNotetrackAnim anim(mtl, nil);
        while (const char* animName = anim.GetNextAnimName())
        {
            int idx = ComboBox_AddString(hAnim, animName);
            ComboBox_SetItemData(hAnim, idx, 1);
            if (!strcmp(animName, savedName))
                ComboBox_SetCurSel(hAnim, idx);
        }

        EnableWindow(hAnim, TRUE);
    }
    else
        EnableWindow(hAnim, FALSE);

    // Update the dependencies of this
    ILoadUser(hWnd, pb);
}

#include "plPickMaterialMap.h"
#include "../MaxMain/plMtlCollector.h"

void plMtlAnimProc::IMtlButtonPress(HWND hWnd, IParamBlock2* pb)
{
    // Let the user pick a new material
    Mtl* pickedMtl = plPickMaterialMap::PickMaterial(plMtlCollector::kUsedOnly |
                                                    plMtlCollector::kPlasmaOnly);

    // Save the mtl in the pb and update the interface
    if (pickedMtl != nil)
    {
        if (pb->GetParameterType(fMtlParamID) == TYPE_REFTARG)
            pb->SetValue(fMtlParamID, 0, (ReferenceTarget*)pickedMtl);
        else
            pb->SetValue(fMtlParamID, 0, pickedMtl);
    }


    // Make sure the current node has the selected material on it (clear it otherwise)
    INode* node = pb->GetINode(fNodeParamID);
    if (!pickedMtl || !node || node->GetMtl() != pickedMtl)
        pb->SetValue(fNodeParamID, 0, (INode*)nil);

    IUpdateMtlButton(hWnd, pb);
}

void plMtlAnimProc::INodeButtonPress(HWND hWnd, IParamBlock2* pb)
{
    IPickNode(pb);

    IUpdateNodeButton(hWnd, pb);
}

void plMtlAnimProc::IAnimComboChanged(HWND hWnd, IParamBlock2* pb)
{
    HWND hCombo = GetDlgItem(hWnd, fAnimComboID);
    int idx = ComboBox_GetCurSel(hCombo);

    if (idx != CB_ERR)
    {
        if (ComboBox_GetItemData(hCombo, idx) == 0)
            pb->SetValue(fAnimParamID, 0, "");
        else
        {
            // Get the name of the animation and save it
            char buf[256];
            ComboBox_GetText(hCombo, buf, sizeof(buf));
            pb->SetValue(fAnimParamID, 0, buf);
        }
    }

    // Update the dependencies of this
    ILoadUser(hWnd, pb);
}

Mtl* plMtlAnimProc::IGetMtl(IParamBlock2* pb)
{
    if (pb->GetParameterType(fMtlParamID) == TYPE_REFTARG)
        return (Mtl*)pb->GetReferenceTarget(fMtlParamID);
    else
        return pb->GetMtl(fMtlParamID);
}


#include "plPickNodeBase.h"

static const char* kUserTypeAll = "(All)";

class plPickAllMtlNode : public plPickMtlNode
{
protected:
    void IAddUserType(HWND hList)
    {
        int idx = ListBox_AddString(hList, kUserTypeAll);
        if (!fPB->GetINode(fNodeParamID))
            ListBox_SetCurSel(hList, idx);
    }

    void ISetUserType(plMaxNode* node, const char* userType)
    {
        if (hsStrEQ(userType, kUserTypeAll))
            ISetNodeValue(nil);
    }

public:
    plPickAllMtlNode(IParamBlock2* pb, int nodeParamID, Mtl* mtl) :
      plPickMtlNode(pb, nodeParamID, mtl)
    {
    }
};

void plMtlAnimProc::IPickNode(IParamBlock2* pb)
{
    plPickAllMtlNode pick(pb, fNodeParamID, IGetMtl(pb));
    pick.DoPick();
}

void plMtlAnimProc::ISetNodeButtonText(HWND hWnd, IParamBlock2* pb)
{
    HWND hNode = GetDlgItem(hWnd, fNodeButtonID);

    INode* node = pb->GetINode(fNodeParamID);
    if (node)
        SetWindowText(hNode, node->GetName());
    else
        SetWindowText(hNode, kUserTypeAll);
}