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

#include "hsTemplates.h"
#include "MaxMain/plPluginResManager.h"
#include "MaxMain/plMaxNode.h"
#include "pnSceneObject/plSceneObject.h"
#include "pnKeyedObject/plKey.h"

#include "plMiscComponents.h"

#include "resource.h"

void DummyCodeIncludeFuncTemplate()
{
}

static const char *GetPBString(IParamBlock2 *pb, ParamID id)
{
    const char *str = pb->GetStr(id, 0);
    if (str && *str == '\0')
        return nil;
    return str;
}

class plTemplateComponent : public plComponent
{
protected:
    const char* IGetAgeName(plMaxNode *node);

public:
    plTemplateComponent();

    // 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 Convert(plMaxNode *node, plErrorMsg *pErrMsg);
};

CLASS_DESC(plTemplateComponent, gTemplateDesc, "Template", "CloneTemplate", "Clone", Class_ID(0x6742590b, 0x14fd2135))

enum
{
    kTemplateName
};

ParamBlockDesc2 gTemplateBlk
(
    plComponent::kBlkComp, _T("Template"), 0, &gTemplateDesc, P_AUTO_CONSTRUCT, plComponent::kRefComp,

    end
);


plTemplateComponent::plTemplateComponent()
{
    fClassDesc = &gTemplateDesc;
    fClassDesc->MakeAutoParamBlocks(this);
}

const char* plTemplateComponent::IGetAgeName(plMaxNode *node)
{
    UInt32 numComps = node->NumAttachedComponents();
    for (UInt32 i = 0; i < numComps; i++)
    {
        plComponentBase* comp = node->GetAttachedComponent(i);
        if (comp->ClassID() == PAGEINFO_CID)
        {
            plPageInfoComponent* pageInfo = (plPageInfoComponent*)comp;
            return pageInfo->GetAgeName();
        }
    }

    return nil;
}

#include "MaxMain/plMaxNodeData.h"

// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool plTemplateComponent::SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg)
{
    const char* ageName = IGetAgeName(node);
    if (!ageName)
        return false;

#if 0
    const char *templateName = node->GetName();
    plKey roomKey = plPluginResManager::ResMgr()->NameToLoc(ageName, "District", "BuiltIn", (UInt32)-1);

    // Set this object and all its children to be in the special template age
    node->SetRoomKey(roomKey);
    for (int i = 0; i < node->NumberOfChildren(); i++)
    {
        plMaxNode* childNode = (plMaxNode*)node->GetChildNode(i);
        childNode->SetRoomKey(roomKey);
    }
#endif

    // We need a coordinate interface so we can move to the clone position
    node->SetForceLocal(true);

    node->GetMaxNodeData()->SetItinerant(true);

    return true;
}

hsBool plTemplateComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
    if (node->GetSceneObject())
        node->GetSceneObject()->SetSynchFlagsBit(plSynchedObject::kAllStateIsVolatile);

    for (int i = 0; i < node->NumberOfChildren(); i++)
    {
        plMaxNode* childNode = (plMaxNode*)node->GetChildNode(i);

        if (childNode->GetSceneObject())
            childNode->GetSceneObject()->SetSynchFlagsBit(plSynchedObject::kAllStateIsVolatile);
    }

    return true;
}


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

#include "plModifier/plCloneSpawnModifier.h"

class plSpawnComponent : public plComponent
{
public:
    plSpawnComponent();

    // 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 Convert(plMaxNode *node, plErrorMsg *pErrMsg);
};

CLASS_DESC(plSpawnComponent, gSpawnDesc, "Instance", "CloneInst", "Clone", Class_ID(0x5702450d, 0x2c636131))

ParamBlockDesc2 gSpawnBlk
(
    plComponent::kBlkComp, _T("Spawn"), 0, &gSpawnDesc, P_AUTO_CONSTRUCT + P_AUTO_UI, plComponent::kRefComp,

    IDD_COMP_TEMPLATE, IDS_COMP_CLONE_INST, 0, 0, NULL,

    kTemplateName,  _T("name"),     TYPE_STRING,    0, 0,
        p_ui,       TYPE_EDITBOX, IDC_NAME,
        end,

    end
);


plSpawnComponent::plSpawnComponent()
{
    fClassDesc = &gSpawnDesc;
    fClassDesc->MakeAutoParamBlocks(this);
}

// SetupProperties - Internal setup and write-only set properties on the MaxNode. No reading
// of properties on the MaxNode, as it's still indeterminant.
hsBool plSpawnComponent::SetupProperties(plMaxNode *node, plErrorMsg *pErrMsg)
{
    if (!GetPBString(fCompPB, kTemplateName))
    {
        pErrMsg->Set(true, "Clone Instance Component", "Clone Instance component on node %s can't convert because it doesn't have a name", node->GetName());
        pErrMsg->Set(false);
        return false;
    }
    
    // We need a coordinate interface to find the point to warp the clone to.
    node->SetForceLocal(true);

    return true;
}

hsBool plSpawnComponent::Convert(plMaxNode *node, plErrorMsg *pErrMsg)
{
    const char *templateName = GetPBString(fCompPB, kTemplateName);
    if (!templateName)
        return false;

    plCloneSpawnModifier* mod = TRACKED_NEW plCloneSpawnModifier;
    mod->SetExportTime();
    mod->SetTemplateName(templateName);
    node->AddModifier(mod, IGetUniqueName(node));

    return true;
}