CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/plPythonParameter.h

/*==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==*/
#ifndef plPythonParameter_h_inc
#define plPythonParameter_h_inc

#include "pnKeyedObject/plKey.h"

//
//  This is the data for the parameters (or attributes) for the PythonFile components
//
//  What is in the records is the id of the attribute and its value
//
// NOTE: Lists of values for parameters will have a specific type that means list
// however, the list of values will not be in one record but many records, with
// the fID being the same.
//

typedef struct plPythonParameter
{
public:
    // this is a unique (within one Python mod) id for this parameter
    Int32   fID;

    // then comes the value, which is a type followed by the data

    enum valueType
    {
        kInt=1,
        kFloat,
        kBoolean,
        kString,
        kSceneObject,
        kSceneObjectList,
        kActivatorList,
        kResponderList,
        kDynamicText,
        kGUIDialog,
        kExcludeRegion,
        kAnimation,
        kAnimationName,
        kBehavior,
        kMaterial,
        kGUIPopUpMenu,
        kGUISkin,
        kWaterComponent,
        kSwimCurrentInterface,
        kClusterComponentList,
        kMaterialAnimation,
        kGrassShaderComponent,
        kNone
    };

    Int32       fValueType;     // what type of value (dataType enum)

    // the data of the value
    union
    {
        Int32       fIntNumber;

        hsScalar    fFloatNumber;

        hsBool      fBool;

        char*       fString;

    } datarecord;

    plKey       fObjectKey;     // the plKey of the scene object (should be part of the union, but unions don't allow complex types)


    plPythonParameter()
    {
        fID = 0;
        fValueType = kNone;
    }

    plPythonParameter(Int32 id)
    {
        fID = id;
        fValueType = kNone;
    }

    plPythonParameter& operator=(const plPythonParameter& other)
    {
        return Copy(other);
    }
    // copy constructor
    plPythonParameter(const plPythonParameter& other)
    {
        fID = 0;
        fValueType = kNone;

        Copy(other);
    }

    plPythonParameter& Copy(const plPythonParameter& other)
    {
        fID = other.fID;
        switch ( other.fValueType )
        {
            case kInt:
                SetToInt(other.datarecord.fIntNumber);
                break;
            case kFloat:
                SetToFloat(other.datarecord.fFloatNumber);
                break;
            case kBoolean:
                SetToBoolean(other.datarecord.fBool);
                break;
            case kString:
                SetToString(other.datarecord.fString);
                break;
            case kSceneObject:
                SetToSceneObject(other.fObjectKey);
                break;
            case kSceneObjectList:
                SetToSceneObject(other.fObjectKey,true);
                break;
            case kActivatorList:
                SetToActivator(other.fObjectKey);
                break;
            case kResponderList:
                SetToResponder(other.fObjectKey);
                break;
            case kDynamicText:
                SetToDynamicText(other.fObjectKey);
                break;
            case kGUIDialog:
                SetToGUIDialog(other.fObjectKey);
                break;
            case kExcludeRegion:
                SetToExcludeRegion(other.fObjectKey);
                break;
            case kAnimation:
                SetToAnimation(other.fObjectKey);
                break;
            case kAnimationName:
                SetToAnimationName(other.datarecord.fString);
                break;
            case kBehavior:
                SetToBehavior(other.fObjectKey);
                break;
            case kMaterial:
                SetToMaterial(other.fObjectKey);
                break;
            case kGUIPopUpMenu:
                SetToGUIPopUpMenu(other.fObjectKey);
                break;
            case kGUISkin:
                SetToGUISkin(other.fObjectKey);
                break;
            case kWaterComponent:
                SetToWaterComponent(other.fObjectKey);
                break;
            case kSwimCurrentInterface:
                SetToSwimCurrentInterface(other.fObjectKey);
                break;
            case kClusterComponentList:
                SetToClusterComponent(other.fObjectKey);
                break;
            case kMaterialAnimation:
                SetToMaterialAnimation(other.fObjectKey);
                break;
            case kGrassShaderComponent:
                SetToGrassShaderComponent(other.fObjectKey);
                break;
        }
        return *this;
    }

    ~plPythonParameter()
    {
        SetToNone();
    }

    void SetToNone()
    {
        // remove the string if one was created
        if ( fValueType == kString || fValueType == kAnimationName )
            delete [] datarecord.fString;

        fValueType = kNone;
    }

    void SetToInt(Int32 number)
    {
        SetToNone();
        fValueType = kInt;
        datarecord.fIntNumber = number;
    }
    void SetToFloat(hsScalar number)
    {
        SetToNone();
        fValueType = kFloat;
        datarecord.fFloatNumber = number;
    }
    void SetToBoolean(hsBool state)
    {
        SetToNone();
        fValueType = kBoolean;
        datarecord.fBool = state;
    }
    void SetToString(const char* string)
    {
        SetToNone();
        fValueType = kString;
        datarecord.fString = hsStrcpy(string);
    }
    void SetToSceneObject(plKey key, hsBool list=false)
    {
        SetToNone();
        if (list)
            fValueType = kSceneObjectList;
        else
            fValueType = kSceneObject;
        fObjectKey = key;
    }
    void SetToActivator(plKey key)
    {
        SetToNone();
        fValueType = kActivatorList;
        fObjectKey = key;
    }
    void SetToResponder(plKey key)
    {
        SetToNone();
        fValueType = kResponderList;
        fObjectKey = key;
    }
    void SetToDynamicText(plKey key)
    {
        SetToNone();
        fValueType = kDynamicText;
        fObjectKey = key;
    }
    void SetToGUIDialog(plKey key)
    {
        SetToNone();
        fValueType = kGUIDialog;
        fObjectKey = key;
    }
    void SetToExcludeRegion(plKey key)
    {
        SetToNone();
        fValueType = kExcludeRegion;
        fObjectKey = key;
    }
    void SetToWaterComponent(plKey key)
    {
        SetToNone();
        fValueType = kWaterComponent;
        fObjectKey = key;
    }
    void SetToSwimCurrentInterface(plKey key)
    {
        SetToNone();
        fValueType = kSwimCurrentInterface;
        fObjectKey = key;
    }
    void SetToAnimation(plKey key)
    {
        SetToNone();
        fValueType = kAnimation;
        fObjectKey = key;
    }
    void SetToAnimationName(const char* string)
    {
        SetToNone();
        fValueType = kAnimationName;
        datarecord.fString = hsStrcpy(string);
    }
    void SetToBehavior(plKey key)
    {
        SetToNone();
        fValueType = kBehavior;
        fObjectKey = key;
    }
    void SetToMaterial(plKey key)
    {
        SetToNone();
        fValueType = kMaterial;
        fObjectKey = key;
    }
    void SetToGUIPopUpMenu(plKey key)
    {
        SetToNone();
        fValueType = kGUIPopUpMenu;
        fObjectKey = key;
    }
    void SetToGUISkin(plKey key)
    {
        SetToNone();
        fValueType = kGUISkin;
        fObjectKey = key;
    }
    void SetToClusterComponent(plKey key)
    {
        SetToNone();
        fValueType = kClusterComponentList;
        fObjectKey = key;
    }
    void SetToMaterialAnimation(plKey key)
    {
        SetToNone();
        fValueType = kMaterialAnimation;
        fObjectKey = key;
    }
    void SetToGrassShaderComponent(plKey key)
    {
        SetToNone();
        fValueType = kGrassShaderComponent;
        fObjectKey = key;
    }

    // read and write routines for export and reading in at runtime
    void Read(hsStream *stream, hsResMgr* mgr)
    {
        SetToNone();

        fID = stream->ReadSwap32();
        fValueType = stream->ReadSwap32();

        // read the different types of data
        int count;
        switch ( fValueType )
        {
            case kInt:
                datarecord.fIntNumber = stream->ReadSwap32();
                break;

            case kFloat:
                stream->ReadSwap(&datarecord.fFloatNumber);
                break;

            case kBoolean:
                datarecord.fBool = stream->ReadSwap32();
                break;

            case kString:
            case kAnimationName:
                count = stream->ReadSwap32();
                if ( count != 0 )
                {
                    datarecord.fString = TRACKED_NEW char[count+1];
                    stream->ReadSwap(count,datarecord.fString);
                }
                else
                    datarecord.fString = nil;
                break;

            case kSceneObject:
            case kSceneObjectList:
            case kActivatorList:
            case kResponderList:
            case kDynamicText:
            case kGUIDialog:
            case kExcludeRegion:
            case kAnimation:
            case kBehavior:
            case kMaterial:
            case kGUIPopUpMenu:
            case kGUISkin:
            case kWaterComponent:
            case kSwimCurrentInterface:
            case kClusterComponentList:
            case kMaterialAnimation:
            case kGrassShaderComponent:
                fObjectKey = mgr->ReadKey(stream);
                break;
        }
    }

    void Write(hsStream * stream, hsResMgr* mgr)
    {
        int count;
        stream->WriteSwap32(fID);
        stream->WriteSwap32(fValueType);
        switch ( fValueType )
        {
            case kInt:
                stream->WriteSwap32(datarecord.fIntNumber);
                break;

            case kFloat:
                stream->WriteSwap(datarecord.fFloatNumber);
                break;

            case kBoolean:
                stream->WriteSwap32(datarecord.fBool);
                break;

            case kString:
            case kAnimationName:
                if ( datarecord.fString != nil )
                    count = hsStrlen(datarecord.fString)+1;
                else
                    count = 0;
                stream->WriteSwap(count);
                if ( count != 0 )
                    stream->WriteSwap(count,datarecord.fString);
                break;

            case kSceneObject:
            case kSceneObjectList:
            case kActivatorList:
            case kResponderList:
            case kDynamicText:
            case kGUIDialog:
            case kExcludeRegion:
            case kAnimation:
            case kBehavior:
            case kMaterial:
            case kGUIPopUpMenu:
            case kGUISkin:
            case kWaterComponent:
            case kSwimCurrentInterface:
            case kClusterComponentList:
            case kMaterialAnimation:
            case kGrassShaderComponent:
                mgr->WriteKey(stream, fObjectKey);
                break;

        }
    }
} plPythonParameter;

#endif // plPythonParameter_h_inc