IPFAction.h

Go to the documentation of this file.

/**********************************************************************
 *<
    CREATED BY: Oleg Bayborodin

    HISTORY: created 10-12-01

 *> Copyright (c) 2001, All Rights Reserved.
 **********************************************************************/

#pragma once

#include "PFExport.h"
#include "ParticleChannelMask.h"
#include "..\ifnpub.h"
#include "..\object.h"
// forward declarations
class IParamBlock2;

PFExport Object* GetPFObject(Object* obj);
// interface ID
#define PFACTION_INTERFACE Interface_ID(0x74f93d00, 0x1eb34500) 
#define GetPFActionInterface(obj) ((IPFAction*)((GetPFObject(obj))->GetInterface(PFACTION_INTERFACE))) 

// The propID is used by a particle group to define "final update time"
// in particle actions; particle group sets object property with this id
// to define the time value; later a particle action (operator or test)
// can find out what is the final time of a particle system evaluation
// and skip some steps in order to improve performance
#define PROPID_FINALUPDATETIME  0x00635690

class IPFAction : public FPMixinInterface
{
public:

    // function IDs
    enum {  kInit, 
            kRelease,
            kChannelsUsed, // reserved for future use
            kActivityInterval,
            kIsFertile,
            kIsNonExecutable,
            kSupportRand,
            kGetRand,
            kSetRand,
            kNewRand,
            kIsMaterialHolder,
            kGetMaterial,
            kSetMaterial,
            kSupportScriptWiring,
            kGetUseScriptWiring,
            kSetUseScriptWiring
    }; 

    // Function Map for Function Publish System 
    //***********************************
    #pragma warning(push)
    #pragma warning(disable:4239 4238)
    BEGIN_FUNCTION_MAP

        FN_5(kInit, TYPE_bool, Init, TYPE_IOBJECT, TYPE_OBJECT, TYPE_INODE, TYPE_OBJECT_TAB_BR, TYPE_INODE_TAB_BR);
        FN_1(kRelease, TYPE_bool, Release, TYPE_IOBJECT);
        VFN_2(kChannelsUsed, ChannelsUsed, TYPE_INTERVAL_BR, TYPE_FPVALUE); // reserved for future use
        FN_0(kActivityInterval, TYPE_INTERVAL_BV, ActivityInterval);
        FN_0(kIsFertile, TYPE_bool, IsFertile);
        FN_0(kIsNonExecutable, TYPE_bool, IsNonExecutable);
        FN_0(kSupportRand, TYPE_bool, SupportRand);
        FN_0(kGetRand, TYPE_INT, GetRand);
        VFN_1(kSetRand, SetRand, TYPE_INT);
        FN_0(kNewRand, TYPE_INT, NewRand);
        FN_0(kIsMaterialHolder, TYPE_bool, IsMaterialHolder);
        FN_0(kGetMaterial, TYPE_MTL, GetMaterial);
        FN_1(kSetMaterial, TYPE_bool, SetMaterial, TYPE_MTL);
        FN_0(kSupportScriptWiring, TYPE_bool, SupportScriptWiring);
        FN_0(kGetUseScriptWiring, TYPE_bool, GetUseScriptWiring);
        VFN_1(kSetUseScriptWiring, SetUseScriptWiring, TYPE_bool);

    END_FUNCTION_MAP
    #pragma warning(pop)

    virtual bool    Init(IObject* pCont, Object* pSystem, INode* node, Tab<Object*>& actions, Tab<INode*>& actionNodes) = 0;

    virtual bool    Release(IObject* pCont) = 0;

    virtual const ParticleChannelMask& ChannelsUsed(const Interval& time) const = 0;

    PFExport void   ChannelsUsed(const Interval& time, FPValue* channels) const;

    virtual const Interval ActivityInterval() const = 0;

    virtual bool IsFertile() const { return false; }

    virtual bool IsNonExecutable() const { return false; }

    virtual bool Has3dIcon() const { return false; }

    virtual int IsColorCoordinated() const { return -1; }

    virtual bool    SupportRand() const = 0;

    virtual int     GetRand() = 0;

    virtual void    SetRand(int seed) = 0;

    PFExport int    NewRand(); 

    PFExport static int NewRand(IParamBlock2* pblock, ParamID randomSeedParamID);

    virtual bool    IsMaterialHolder() const    { return false; }

    virtual Mtl*    GetMaterial()               { return NULL; }
#pragma warning(push)
#pragma warning(disable:4100)

    virtual bool    SetMaterial(Mtl* mtl)       { return false; }

    virtual bool SupportScriptWiring() const { return false; }

    virtual bool GetUseScriptWiring() const { return false; }

    virtual void SetUseScriptWiring(bool useScriptWiring) { ; }

    virtual bool IsEmitterTMDependent() const { return false; }

    virtual bool IsEmitterPropDependent() const { return false; }

    virtual IObject* GetCurrentState(IObject* pContainer) { return NULL; }

    virtual void SetCurrentState(IObject* actionState, IObject* pContainer) { ; }
#pragma warning(pop)

    FPInterfaceDesc* GetDesc() { return GetDescByID(PFACTION_INTERFACE); }

};

// Codes for ClassDesc::Execute(...) method
// The Execute method is used to extract action description from the ClassDesc
enum {  kPF_GetActionDescription = 781,
// defines an action name to be shown in the action depot area in PView
// if the method is not supported then the class name of the action is used
        kPF_GetActionName,
// defines if the action is shown in ParticleView Action Depot window
// if the execute is not implemented then it is assumed that the action is
// public
        kPF_PViewPublic,
// defines a category for the action to be placed in the Action Depot
// the call is reserved for future use. If the execute is not implemented
// then the category is assigned according to the action type (operator or test)
        kPF_PViewCategory,
// defines if the action is "fertile". It means it is able to generate particles
// from nothing. If the execute is not implemented then it is assumed
// that the action is not "fertile".
        kPF_IsFertile,
// defines if the action is "non-executable". Non-executable action doesn't
// affect particle behavior. The action is present in the action schematics
// but its presence doesn't change how the particles are shown or rendered.
// If the execute is not implemented then it is assumed that the action is
// executable.
        kPF_IsNonExecutable,
// returns bitmap with icon for the depot window of ParticleView
// if the execute is not implemented then a default icon is used
        kPF_PViewDepotIcon 
    };

inline IPFAction* PFActionInterface(Object* obj) {
    return ((obj == NULL) ? NULL : GetPFActionInterface(obj));
};

inline IPFAction* PFActionInterface(INode* node) {
    return ((node == NULL) ? NULL : PFActionInterface(node->GetObjectRef()));
};

PFExport int IsPFActionActive(INode* actionNode);