IGameObject.h

Go to the documentation of this file.

/**********************************************************************
 *<
    FILE: IGameObject.h

    DESCRIPTION: Object interfaces for IGame

    CREATED BY: Neil Hazzard, Discreet

    HISTORY: created 02/02/02

    IGame Version: 1.122

 *> Copyright (c) 2002, All Rights Reserved.
 **********************************************************************/
#pragma once

#include "..\maxheap.h"
#include "IGameProperty.h"
#include "IGameStd.h"
#include "..\point2.h"

// forward declarations
class IGameNode;
class IGameModifier;
class IGameSkin;
class IGameMaterial;
class Object;
class Box3;
class Mesh;
class Color;
class ShapeObject;


class IGameObject : public IExportEntity
{
    Tab <IGameModifier *> gameModTab;

protected:
    INode * gameNode;
    Object * gameObject;
    void SetNode (INode * n);
public:
    IGameObject();
    

    enum ObjectTypes{
        IGAME_UNKNOWN,  
        IGAME_LIGHT,    
        IGAME_MESH,     
        IGAME_SPLINE,   
        IGAME_CAMERA,   
        IGAME_HELPER,   
        IGAME_BONE,     
        IGAME_IKCHAIN,  
        IGAME_XREF      
    };


    enum MaxType{
        IGAME_MAX_UNKNOWN,  
        IGAME_MAX_GEOM,     
        IGAME_MAX_SHAPE,    
        IGAME_MAX_LIGHT,    
        IGAME_MAX_CAMERA,   
        IGAME_MAX_BONE,     
        IGAME_MAX_HELPER,   
    };


    IGAMEEXPORT void GetBoundingBox(Box3 & bb);


    IGAMEEXPORT bool IsRenderable();


    virtual ObjectTypes GetIGameType() =0;
    

    IGAMEEXPORT Object * GetMaxObject();


    IGAMEEXPORT MaxType GetMaxType() ;
    

    IGAMEEXPORT int GetNumModifiers();


    IGAMEEXPORT IGameModifier * GetIGameModifier(int index);


    IGAMEEXPORT IGameObject(INode  * node);


    IGAMEEXPORT bool CastShadows();
    

    IGAMEEXPORT bool IsObjectSkinned();


    IGAMEEXPORT IGameSkin * GetIGameSkin();


    IGAMEEXPORT bool IsObjectXRef();


    IGAMEEXPORT GMatrix GetIGameObjectTM();


    virtual bool InitializeData(){return false;}

    virtual ~IGameObject() = 0;
};


class IGameLight : public IGameObject  {
public:
    enum LightType{
        IGAME_OMNI,     
        IGAME_TSPOT,    
        IGAME_DIR,      
        IGAME_FSPOT,    
        IGAME_TDIR,     
        IGAME_UNKNOWN,  
    };


    virtual IGameProperty * GetLightColor()=0;


    virtual IGameProperty * GetLightMultiplier()=0;


    virtual IGameProperty * GetLightAttenEnd()=0;


    virtual IGameProperty * GetLightAttenStart()=0;


    virtual IGameProperty * GetLightFallOff()=0;


    virtual IGameProperty * GetLightHotSpot()=0;


    virtual IGameProperty * GetLightAspectRatio()=0;
    

    virtual IGameProperty * GetLightDecayStart()=0;
    

    virtual LightType GetLightType()=0;



    virtual int GetLightOvershoot()=0;


    virtual int GetLightDecayType()=0;


    virtual int GetSpotLightShape()=0;


    virtual IGameNode * GetLightTarget()=0;


    virtual bool IsLightOn() = 0;


    virtual bool IsExcludeListReversed()=0;


    virtual int GetExcludedNodesCount() = 0;


    virtual IGameNode * GetExcludedNode(int index) = 0;



};


class IGameCamera : public IGameObject {

public:


    virtual IGameProperty * GetCameraFOV()=0;


    virtual IGameProperty * GetCameraFarClip()=0;


    virtual IGameProperty * GetCameraNearClip()=0;


    virtual IGameProperty * GetCameraTargetDist()=0;


    virtual IGameNode *  GetCameraTarget()=0;


};




class FaceEx: public MaxHeapOperators
{
public:

    DWORD vert[3];
    DWORD texCoord[3];
    DWORD norm[3];
    DWORD color[3];
    DWORD illum[3];
    DWORD alpha[3];
    DWORD smGrp;
    int matID;
    DWORD flags;
    int meshFaceIndex;

    DWORD edgeVis[3];  


};


class IGameMesh: public IGameObject {
public:
    

    virtual bool InitializeBinormalData()=0;
    

    virtual int GetNumberOfVerts()=0;


    virtual int GetNumberOfTexVerts()=0;


    virtual Point3 GetVertex(int index, bool ObjectSpace = false)=0;


    virtual bool GetVertex(int index, Point3 & vert, bool ObjectSpace = false) = 0;


    virtual Point2 GetTexVertex(int index)=0;


    virtual bool GetTexVertex(int index, Point2 & tex) = 0;


    virtual void SetUseWeightedNormals() = 0;
    

    virtual int GetNumberOfNormals()=0;


    virtual int GetNormalVertexIndex (int index)=0;
    

    virtual Point3 GetNormal(int index, bool ObjectSpace = false)=0;


    virtual bool GetNormal(int index, Point3 & norm, bool ObjectSpace = false) = 0;


    virtual bool GetNormal(int faceIndex, int corner, Point3 & norm, bool ObjectSpace = false) = 0;


    virtual Point3 GetNormal ( FaceEx * face, int corner, bool ObjectSpace = false) = 0;


    virtual bool GetNormal(FaceEx * face, int corner, Point3 &norm, bool ObjectSpace = false) =0;
    

    virtual Point3 GetNormal(int faceIndex, int corner, bool ObjectSpace = false) = 0;
    

    virtual int GetNumberOfIllumVerts()=0;


    virtual int GetNumberOfAlphaVerts()=0;


    virtual int GetNumberOfColorVerts()=0;


    virtual Point3 GetColorVertex(int index)=0;


    virtual bool GetColorVertex(int index, Point3 & col) = 0;


    virtual float  GetAlphaVertex(int index)=0;



    virtual bool GetAlphaVertex(int index, float & alpha) = 0;


    virtual float  GetIllumVertex(int index)=0;
    

    virtual bool GetIllumVertex(int index, float &illum) = 0;


    virtual int GetNumberOfFaces()=0;
    

    virtual FaceEx * GetFace(int index)=0;
    

    virtual int GetNumberOfMapVerts(int ch) = 0;


    virtual Point3 GetMapVertex(int ch, int index) = 0;


    virtual bool GetMapVertex(int ch, int index, Point3 & mVert) = 0;


    virtual int GetNumberOfBinormals(int mapChannel = 1) = 0;


    virtual Point3 GetBinormal(int index, int mapChannel = 1)=0;


    virtual bool GetBinormal(int index, Point3 & biNormal, int mapChannel = 1) = 0;


    virtual int GetNumberOfTangents(int mapChannel = 1) = 0;


    virtual Point3 GetTangent(int index, int mapChannel = 1) = 0;


    virtual bool GetTangent(int index, Point3 & Tangent, int mapChannel = 1) = 0;


    virtual Tab<int> GetActiveMapChannelNum() = 0;
    

    virtual bool GetMapFaceIndex(int ch, int faceNum, DWORD *index) = 0;
    

    virtual Tab<DWORD> GetActiveSmgrps() = 0;


    virtual Tab<int> GetActiveMatIDs() = 0;


    virtual Tab<FaceEx *> GetFacesFromSmgrp(DWORD smgrp) = 0;


    virtual Tab<int> GetFaceIndexFromSmgrp(DWORD smgrp)=0;


    virtual Tab<FaceEx *> GetFacesFromMatID(int matID) = 0;


    virtual IGameMaterial * GetMaterialFromFace(int FaceNum) = 0;


    virtual IGameMaterial * GetMaterialFromFace(FaceEx * face) = 0;



    virtual Mesh * GetMaxMesh()=0;





    virtual int GetFaceVertex (int faceIndex, int corner)=0;
    

    virtual int GetFaceTextureVertex (int faceIndex, int corner, int mapChannel = 1)=0;


    virtual int GetFaceVertexNormal (int faceIndex, int corner)=0;
    

    virtual int GetFaceVertexTangentBinormal (int faceIndex, int corner, int mapChannel = 1)=0;
    

    virtual DWORD GetFaceSmoothingGroup (int faceIndex)=0;
    

    virtual int GetFaceMaterialID (int faceIndex)=0;
    

    virtual int GetFaceEdgeVisibility (int faceIndex, int edge)=0;


    virtual bool EvaluateSurface(int FaceIndex, Color * result) = 0;



    virtual void SetCreateOptimizedNormalList() = 0;




    virtual int GetNumberOfPolygons()=0;


    virtual int GetNumberOfPolygonNormals()=0;


    virtual int GetNumberOfPolygonCorners(int PolyIndex)=0;


    virtual Tab<INT> GetPolygonVertices(int PolyIndex)=0;



    virtual Tab<INT> GetPolygonNormals(int PolyIndex)=0;


    virtual Tab<Point3> GetPolygonNormalsArray(int PolyIndex = -1)=0;


    virtual Tab<INT> GetPolygonMapVertices(int PolyIndex, int MapChannel)=0;


    virtual Tab<INT> GetPolygonEgdesVisibility(int PolyIndex)=0;


    virtual DWORD GetPolygonSmoothingGroup (int PolyIndex)=0;


    virtual int GetPolygonMaterialID (int PolyIndex)=0;
    

    virtual Tab<INT> GetPolygonIndexFromMatID(int MatID)=0;


    virtual IGameMaterial* GetMaterialFromPolygon(int PolyIndex)= 0;

};


class IGameKnot: public MaxHeapOperators
{
public:
    enum KnotType{
        KNOT_AUTO,              
        KNOT_CORNER,            
        KNOT_BEZIER,            
        KNOT_BEZIER_CORNER,     
    };

    enum KnotData{
        KNOT_INVEC,             
        KNOT_OUTVEC,            
        KNOT_POINT,             
    };
    virtual ~IGameKnot() {;}


    virtual Point3 GetInVec()=0;
    

    virtual Point3 GetOutVec()=0;


    virtual Point3 GetKnotPoint()=0;


    virtual KnotType GetKnotType()=0;
    

    virtual IGameControl * GetKnotControl(KnotData kd)=0;
};


class IGameSpline3D: public MaxHeapOperators
{
public:
    virtual ~IGameSpline3D() {;}


    virtual IGameKnot * GetIGameKnot(int index) = 0;
    

    virtual int GetIGameKnotCount()=0;

};


class IGameSpline : public IGameObject
{
public:

    virtual int GetNumberOfSplines()=0;


    virtual IGameSpline3D * GetIGameSpline3D(int index) =0;


    virtual ShapeObject * GetMaxShape()=0;

};



class IGameIKChain : public IGameObject
{
public:


    virtual int GetNumberofBonesinChain() =0;


    virtual IGameNode * GetIGameNodeInChain(int index) =0;


    virtual IGameProperty * GetSwivelData() = 0;


    virtual IGameControl * GetIKEnabledController() = 0;


};



class IGameSupportObject : public IGameObject
{
public:

    virtual IGameMesh * GetMeshObject() = 0;


    virtual bool PreR4Bone() = 0;

    
};

class IGameXRefObject : public IGameObject
{
public:

    virtual const MCHAR * GetOriginalFileName() = 0;

    
};


class IGameGenObject : public IGameObject
{
public:
    

    virtual IPropertyContainer * GetIPropertyContainer()=0;
};