Public API Reference

imesh/spritecal3d.h

Go to the documentation of this file.

/*
    Copyright (C) 2003 by Keith Fulton

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_IMESH_SPRITECAL3D_H__
#define __CS_IMESH_SPRITECAL3D_H__

#include "csutil/scf.h"
#include "imesh/sprite3d.h"

struct iMaterialWrapper;
struct iMeshObject;
struct iMeshWrapper;
struct iMeshObjectFactory;
struct iRenderView;
struct iShaderVariableContext;
struct iVFS;

class csColor;
class csRandomGen;
class csReversibleTransform;
class csString;

class CalModel;
class CalCoreModel;

struct iSpriteCal3DSocket : public virtual iSpriteSocket
{
  SCF_INTERFACE (iSpriteCal3DSocket, 1, 0, 0);

  virtual void SetSubmeshIndex (int subm_index) = 0;
  virtual int GetSubmeshIndex () const = 0;

  virtual void SetMeshIndex (int m_index) = 0;
  virtual int GetMeshIndex () const = 0;

  virtual void SetTransform (const csReversibleTransform & trans) = 0;
  virtual csReversibleTransform GetTransform () const = 0;

  virtual size_t GetSecondaryCount () const = 0;
  virtual iMeshWrapper * GetSecondaryMesh (size_t index) = 0;
  virtual csReversibleTransform GetSecondaryTransform (size_t index) = 0;
  virtual void SetSecondaryTransform (size_t index, csReversibleTransform) = 0;
  virtual size_t AttachSecondary (iMeshWrapper*, csReversibleTransform) = 0;
  virtual void DetachSecondary (const char* mesh_name) = 0;
  virtual void DetachSecondary (size_t index) = 0;
  virtual size_t FindSecondary (const char* mesh_name) = 0;
};


struct CalAnimationCallback;

struct iSpriteCal3DFactoryState : public virtual iBase
{
  SCF_INTERFACE (iSpriteCal3DFactoryState, 1, 0, 0);

  virtual bool Create(const char *name) = 0;

  virtual void ReportLastError () = 0;

  virtual void SetLoadFlags(int flags) = 0;

  virtual void SetBasePath(const char *path) = 0;

  virtual bool LoadCoreSkeleton(iVFS *vfs,const char *filename) = 0;

  virtual void RescaleFactory(float factor) = 0;

  virtual int LoadCoreAnimation(
        iVFS *vfs,
        const char *filename,
        const char *name,
        int type,
        float base_velocity,
        float min_velocity,
        float max_velocity,
        int min_interval,
        int max_interval,
        int idle_pct,
        bool lock) = 0;

  virtual int LoadCoreMesh(iVFS *vfs,const char *filename,
        const char *name,bool attach,iMaterialWrapper *defmat) = 0;

  virtual int LoadCoreMorphTarget(iVFS *vfs, int mesh_index,
        const char *filename, const char *name) = 0;

  virtual int AddMorphAnimation(const char *name) = 0;
  
  virtual bool AddMorphTarget(int morphanimation_index,
                              const char *mesh_name,
                              const char *morphtarget_name) = 0;
  
  virtual bool AddCoreMaterial(iMaterialWrapper *mat) = 0;

  virtual void CalculateAllBoneBoundingBoxes() = 0;

  virtual void BindMaterials() = 0;

  virtual int  GetMeshCount() = 0;

  virtual int GetMorphAnimationCount() = 0;
  
  virtual int GetMorphTargetCount(int mesh_id) = 0;

  virtual const char *GetMeshName(int idx) = 0;

  virtual int  FindMeshName(const char *meshName) = 0;

  virtual const char* GetDefaultMaterial( const char* meshName ) = 0;
  
  
  virtual const char *GetMorphAnimationName(int idx) = 0;

  virtual int  FindMorphAnimationName(const char *meshName) = 0;

  virtual bool IsMeshDefault(int idx) = 0;

  virtual iSpriteCal3DSocket* AddSocket () = 0;
  virtual iSpriteCal3DSocket* FindSocket (const char * name) const = 0;
  virtual iSpriteCal3DSocket* FindSocket (iMeshWrapper *mesh) const = 0;
  virtual int GetSocketCount () const = 0;
  virtual iSpriteCal3DSocket* GetSocket (int f) const = 0;

  virtual CalCoreModel *GetCal3DCoreModel() = 0;

  virtual bool RegisterAnimCallback(const char *anim,
        CalAnimationCallback *callback, float min_interval) = 0;

  virtual bool RemoveAnimCallback(const char *anim,
        CalAnimationCallback *callback) = 0;

};

struct iAnimTimeUpdateHandler : public virtual iBase
{
  SCF_INTERFACE (iAnimTimeUpdateHandler, 1, 0, 0); 

  virtual void UpdatePosition (float delta, CalModel*) = 0;
};

struct csSpriteCal3DActiveAnim
{
  int index;
  float weight;
};

struct iSpriteCal3DState : public virtual iBase
{
  SCF_INTERFACE (iSpriteCal3DState, 2, 0, 0);


  enum
  {
    C3D_ANIM_TYPE_NONE,
    C3D_ANIM_TYPE_IDLE,
    C3D_ANIM_TYPE_TRAVEL,
    C3D_ANIM_TYPE_CYCLE,
    C3D_ANIM_TYPE_STYLE_CYCLE,
    C3D_ANIM_TYPE_ACTION
  };

  virtual int GetAnimCount() = 0;

  virtual const char *GetAnimName(int idx) = 0;

  virtual int  GetAnimType(int idx) = 0;

  virtual int FindAnim(const char* name) = 0;

  virtual void ClearAllAnims() = 0;

  virtual bool SetAnimCycle(const char *name, float weight) = 0;

  virtual bool SetAnimCycle(int idx, float weight) = 0;

  virtual bool AddAnimCycle(const char *name, float weight, float delay) = 0;

  virtual bool AddAnimCycle(int idx, float weight, float delay) = 0;

  virtual bool ClearAnimCycle (int idx, float delay) = 0;

  virtual bool ClearAnimCycle (const char *name, float delay) = 0;

  virtual size_t GetActiveAnimCount() = 0;

  virtual bool GetActiveAnims(csSpriteCal3DActiveAnim* buffer, 
    size_t max_length) = 0;

  virtual void SetActiveAnims(const csSpriteCal3DActiveAnim* buffer,
        size_t anim_count) = 0;

  virtual bool SetAnimAction(const char *name, float delayIn,
                             float delayOut) = 0;

  virtual bool SetAnimAction(int idx, float delayIn,
                             float delayOut) = 0;

  virtual bool SetVelocity(float vel,csRandomGen *rng=0) = 0;

  virtual void SetDefaultIdleAnim(const char *name) = 0;
  virtual void SetLOD(float lod) = 0;
  virtual bool AttachCoreMesh(const char *meshname) = 0;

  virtual bool DetachCoreMesh(const char *meshname) = 0;

  virtual bool AttachCoreMesh(int mesh_id, iMaterialWrapper* iMatWrap = 0) = 0;
  virtual bool DetachCoreMesh(int mesh_id) = 0;
  virtual bool BlendMorphTarget(int morph_animation_id, float weight,
        float delay) = 0;

  virtual bool ClearMorphTarget(int morph_animation_id, float delay) = 0;

  virtual iSpriteCal3DSocket* FindSocket (iMeshWrapper *mesh) const = 0;

  virtual iSpriteCal3DSocket* FindSocket (const char* name) const = 0;

  virtual bool SetMaterial(const char *mesh_name,iMaterialWrapper *mat) = 0;


  virtual void SetTimeFactor(float timeFactor) = 0;

  virtual float GetTimeFactor() = 0;

  virtual float GetAnimationTime() = 0;

  virtual float GetAnimationDuration() = 0;

  virtual void SetAnimationTime(float animationTime) = 0;

  virtual void SetAnimTimeUpdateHandler(iAnimTimeUpdateHandler*) = 0;

  virtual void SetUserData(void *data) = 0;
  
  virtual iShaderVariableContext* GetCoreMeshShaderVarContext (
    const char* meshName) = 0;


  virtual CalModel *GetCal3DModel() = 0;
};

#endif// __CS_IMESH_SPRITECAL3D_H__

---