CWE-ou-minkata/Sources/Tools/MaxComponent/plXImposter.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 "resource.h"
#include "plComponent.h"
#include "plComponentReg.h"
#include "../MaxMain/plPlasmaRefMsgs.h"

#include "../MaxMain/plMaxNode.h"
#include "../MaxExport/plExportProgressBar.h"

#include "plXImposter.h"

#include "../pfAnimation/plFilterCoordInterface.h"

#include "../pnSceneObject/plSimulationInterface.h"
#include "plPhysical.h"

const Class_ID FILTERINHERIT_COMP_CID(0x263928d8, 0x548456da);

void DummyCodeIncludeFuncXImposter()
{

}

//Class that accesses the paramblock below.
//////////////////////////////////////////////////////////////////////////////////////////////////////

//Max desc stuff necessary below.
CLASS_DESC(plXImposterComp, gXImposterDesc, "X-Form",  "X-Form", COMP_TYPE_DISTRIBUTOR, XIMPOSTER_COMP_CID)

ParamBlockDesc2 gXImposterBk
(   
    plComponent::kBlkComp, _T("X-Form"), 0, &gXImposterDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

    IDD_COMP_XFORM, IDS_COMP_XFORMS, 0, 0, NULL,

    end
);

plXImposterComp::plXImposterComp()
{
    fClassDesc = &gXImposterDesc;
    fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plXImposterComp::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
    node->SetRadiateNorms(true);
    return true;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
const Class_ID FORCE_CTT_COMP_CID(0x30ee73b7, 0x4cdd551b);

class plForceCTTComp : public plComponent
{
public:
    plForceCTTComp();
    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)     { return true; }
    virtual hsBool Convert(plMaxNode *node, plErrorMsg *pErrMsg) { return true; }
};

//Max desc stuff necessary below.
CLASS_DESC(plForceCTTComp, gForceCTTDesc, "ForceClick2Turn",  "ForceCTT", COMP_TYPE_MISC, FORCE_CTT_COMP_CID)

ParamBlockDesc2 gForceCTTBk
(   
    plComponent::kBlkComp, _T("ForceCTT"), 0, &gForceCTTDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

    IDD_COMP_FORCE_CTT, IDS_COMP_FORCE_CTT, 0, 0, NULL,

    end
);

plForceCTTComp::plForceCTTComp()
{
    fClassDesc = &gForceCTTDesc;
    fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plForceCTTComp::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
    node->SetForceVisLOS(true);
    return true;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////
//
// The filter inheritance component doesn't have anything to do with the XImposter, but there's
// plenty of space here, so blow me.

class plFilterInheritComp : public plComponent
{
public:
    enum
    {
        kActive,
        kNoX,
        kNoY,
        kNoZ
    };
public:
    plFilterInheritComp();
    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);

    hsBool  SetMaxInherit();
    hsBool  SetMaxInherit(plMaxNodeBase* targ);
    hsBool  KillMaxInherit();
    hsBool  KillMaxInherit(plMaxNodeBase* targ);

    hsBool  Bail(plMaxNode* node, const char* msg, plErrorMsg* pErrMsg);

    virtual void AddTarget(plMaxNodeBase *target);
    virtual void DeleteTarget(plMaxNodeBase *target);
    virtual void DeleteAllTargets();
};

class FilterInheritCompDlgProc : public ParamMap2UserDlgProc
{
protected:
    void ISetTransEnable(IParamMap2* map)
    {
        IParamBlock2* pb = map->GetParamBlock();
        if( !pb->GetInt(plFilterInheritComp::kActive) )
        {
            map->Enable(plFilterInheritComp::kNoX, FALSE);
            map->Enable(plFilterInheritComp::kNoY, FALSE);
            map->Enable(plFilterInheritComp::kNoZ, FALSE);
        }
        else
        {
            map->Enable(plFilterInheritComp::kNoX, TRUE);
            map->Enable(plFilterInheritComp::kNoY, TRUE);
            map->Enable(plFilterInheritComp::kNoZ, TRUE);
        }
        plFilterInheritComp* comp = (plFilterInheritComp*)map->GetParamBlock()->GetOwner();
        comp->SetMaxInherit();
    }
public:
    FilterInheritCompDlgProc() {}
    ~FilterInheritCompDlgProc() {}

    BOOL DlgProc(TimeValue t, IParamMap2* map, HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
    {
        switch (msg)
        {
        case WM_INITDIALOG:
            ISetTransEnable(map);
            break;
        case WM_COMMAND: 
            ISetTransEnable(map);
            break;
        }
        return FALSE;
    }
    void DeleteThis() {}
};
static FilterInheritCompDlgProc gFilterInheritCompDlgProc;



CLASS_DESC(plFilterInheritComp, gFilterInheritDesc, "Filter Inherit",  "FiltInherit", COMP_TYPE_MISC, FILTERINHERIT_COMP_CID)

ParamBlockDesc2 gFilterInheritBk
(   
    plComponent::kBlkComp, _T("FilterInherit"), 0, &gFilterInheritDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

    IDD_COMP_FILTERINHERIT, IDS_COMP_FILTER, 0, 0, &gFilterInheritCompDlgProc,

    plFilterInheritComp::kActive,   _T("Active"),   TYPE_BOOL,      0, 0,
        p_default,  TRUE,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_COMP_FILTER_ACTIVE,
        end,

    plFilterInheritComp::kNoX,  _T("NoX"),  TYPE_BOOL,      0, 0,
        p_default,  TRUE,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_COMP_FILTER_NOX,
        end,

    plFilterInheritComp::kNoY,  _T("NoY"),  TYPE_BOOL,      0, 0,
        p_default,  TRUE,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_COMP_FILTER_NOY,
        end,

    plFilterInheritComp::kNoZ,  _T("NoZ"),  TYPE_BOOL,      0, 0,
        p_default,  TRUE,
        p_ui,   TYPE_SINGLECHEKBOX, IDC_COMP_FILTER_NOZ,
        end,

    end
);

plFilterInheritComp::plFilterInheritComp()
{
    fClassDesc = &gFilterInheritDesc;
    fClassDesc->MakeAutoParamBlocks(this);
}

hsBool plFilterInheritComp::SetupProperties(plMaxNode* node, plErrorMsg* pErrMsg)
{
    if( !fCompPB->GetInt(kActive) )
        return true;

    if( node->GetParentNode()->IsRootNode() )
        return true;

    node->SetFilterInherit(true);
    node->SetForceLocal(true);
    plMaxNode* parent = (plMaxNode*)node->GetParentNode();
    parent->SetForceLocal(true);

    // Okay, everything works fine as long as you set up your heirarchy, and THEN
    // add this component. But if you put this component on the as yet unlinked child,
    // and THEN link the child to the parent, Max starts reporting bogus local TM info.
    // If you turn off the component (uncheck the disable rotation checkbox), and turn
    // it back on, Max is happy again.
    // However, if I just turn off the component and turn it right back on again here,
    // (a KillMaxInherit() followed by a SetMaxInherit()), apparently Max hasn't had
    // enough time to think in between, and so stays confused.
    // Soooo, here at the last minute before conversion, we kill all those inherit
    // checkboxes for this node, then after we've finished converting, we turn them
    // back on. Note that we don't currently give a rat's patooties whether the check
    // boxes are set or not, we just want to turn them off and turn them back on
    // sometime before export, with enough time in between for Max to get on to the fact.
    // See the matching SetMaxInherit() at the end of Convert().
    KillMaxInherit(node);

    return true;
}

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

hsBool plFilterInheritComp::Bail(plMaxNode* node, const char* msg, plErrorMsg* pErrMsg)
{
    pErrMsg->Set(true, node->GetName(), msg).CheckAndAsk();
    pErrMsg->Set(false);
    return true;
}

hsBool plFilterInheritComp::Convert(plMaxNode* node, plErrorMsg* pErrMsg)
{
    if( !fCompPB->GetInt(kActive) )
        return true;

    if( node->GetParentNode()->IsRootNode() )
        return true;

    plSceneObject* so = node->GetSceneObject();
    if( !so )
    {
        return Bail(node, "Error finding scene object for filtered inheritance", pErrMsg);
    }

    const plCoordinateInterface* co = so->GetCoordinateInterface();
    if( !co )
    {
        return Bail(node, "Error setting filtered inheritance - no coordinate interface", pErrMsg);
    }
    
    plFilterCoordInterface* filt = plFilterCoordInterface::ConvertNoRef(const_cast<plCoordinateInterface*>(co));
    if( !filt )
    {
        return Bail(node, "Error setting filtered inheritance - wrong coordinate interface", pErrMsg);
    }

    const plSimulationInterface* si = so->GetSimulationInterface();
    if (si)
    {
        plPhysical* phys = si->GetPhysical();
        // tell the physical not to send transforms back -- they'll be wrong if it tries to compose w/a subworld
        // this rules out using transform filters on dynamically simulated objects....
        phys->SetProperty(plSimulationInterface::kPassive, true);
    }

    UInt32 mask = plFilterCoordInterface::kNoRotation;
    if( fCompPB->GetInt(kNoX) )
        mask |= plFilterCoordInterface::kNoTransX;
    if( fCompPB->GetInt(kNoY) )
        mask |= plFilterCoordInterface::kNoTransY;
    if( fCompPB->GetInt(kNoZ) )
        mask |= plFilterCoordInterface::kNoTransZ;

    plMaxNode* parent = (plMaxNode*)node->GetParentNode();
    hsMatrix44 parL2W = parent->GetLocalToWorld44(TimeValue(0));

    filt->SetFilterMask(mask);
    filt->SetRefLocalToWorld(parL2W);

    // See the matching KillMaxInherit() in SetupProperties().
    SetMaxInherit(node);
    
    return true;
}

hsBool plFilterInheritComp::SetMaxInherit(plMaxNodeBase* targ)
{
    if( !fCompPB->GetInt(kActive) )
        return KillMaxInherit(targ);

    DWORD mask = INHERIT_ROT_X
        | INHERIT_ROT_Y
        | INHERIT_ROT_Z
        | INHERIT_SCL_X
        | INHERIT_SCL_Y
        | INHERIT_SCL_Z;

    if( fCompPB->GetInt(kNoX) )
        mask |= INHERIT_POS_X;
    if( fCompPB->GetInt(kNoY) )
        mask |= INHERIT_POS_Y;
    if( fCompPB->GetInt(kNoZ) )
        mask |= INHERIT_POS_Z;

    // Max documentation is a big fat liar
    mask = ~mask;

    if( targ )
    {
        targ->GetTMController()->SetInheritanceFlags(mask, true);
        targ->GetTMController()->NotifyDependents(FOREVER,0,REFMSG_CHANGE);
    }

    return true;
}

hsBool plFilterInheritComp::SetMaxInherit()
{
    if( !fCompPB->GetInt(kActive) )
        return KillMaxInherit();

    DWORD mask = INHERIT_ROT_X
        | INHERIT_ROT_Y
        | INHERIT_ROT_Z
        | INHERIT_SCL_X
        | INHERIT_SCL_Y
        | INHERIT_SCL_Z;

    if( fCompPB->GetInt(kNoX) )
        mask |= INHERIT_POS_X;
    if( fCompPB->GetInt(kNoY) )
        mask |= INHERIT_POS_Y;
    if( fCompPB->GetInt(kNoZ) )
        mask |= INHERIT_POS_Z;

    // Max documentation is a big fat liar
    mask = ~mask;

    int i;
    for( i = 0; i < NumTargets(); i++ )
    {
        plMaxNodeBase* targ = GetTarget(i);
        if( targ )
        {
            targ->GetTMController()->SetInheritanceFlags(mask, true);
            targ->GetTMController()->NotifyDependents(FOREVER,0,REFMSG_CHANGE);
        }
    }
    return true;
}

hsBool plFilterInheritComp::KillMaxInherit(plMaxNodeBase* targ)
{
    // Max documentation is a big fat liar
    DWORD mask = ~0;

    targ->GetTMController()->SetInheritanceFlags(mask, true);
    targ->GetTMController()->NotifyDependents(FOREVER,0,REFMSG_CHANGE);

    return true;
}

hsBool plFilterInheritComp::KillMaxInherit()
{
    int i;
    for( i = 0; i < NumTargets(); i++ )
    {
        plMaxNodeBase* targ = GetTarget(i);
        if( targ )
        {
            KillMaxInherit(targ);
        }
    }
    return true;
}

void plFilterInheritComp::AddTarget(plMaxNodeBase *target)
{
    plComponentBase::AddTarget(target);

    SetMaxInherit();
}

void plFilterInheritComp::DeleteTarget(plMaxNodeBase *target)
{
    plComponentBase::DeleteTarget(target);

    KillMaxInherit(target);
}

void plFilterInheritComp::DeleteAllTargets()
{
    KillMaxInherit();

    plComponentBase::DeleteAllTargets();
}