Public API Reference

cstool/meshobjtmpl.h

Go to the documentation of this file.

/*
    Copyright (C) 2003 by Martin Geisse <[email protected]>

    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_MESHOBJTMPL_H__
#define __CS_MESHOBJTMPL_H__

#include "csextern.h"

#include "csgeom/box.h"
#include "cstool/objmodel.h"
#include "csutil/flags.h"
#include "csutil/refarr.h"
#include "csutil/scf_implementation.h"

#include "ivideo/graph3d.h"
#include "imesh/object.h"
#include "iutil/comp.h"

struct iEngine;
struct iMaterialWrapper;

//Deprecate these when possible!
#define CS_DECLARE_SIMPLE_MESH_FACTORY(name,meshclass)                      \
  class name : public csMeshFactory {                                       \
  public:                                                                   \
    name (iEngine *e, iObjectRegistry* reg, iMeshObjectType* type)          \
    : csMeshFactory (e, reg, type) {}                                       \
    virtual csPtr<iMeshObject> NewInstance ()                               \
    { return new meshclass (Engine, this); }                                \
    virtual csPtr<iMeshObjectFactory> Clone () { return 0; }                \
  };

#define CS_DECLARE_SIMPLE_MESH_PLUGIN(name,factclass)                       \
  class name : public csMeshType {                                          \
  public:                                                                   \
    name (iBase *p) : csMeshType (p) {}                                     \
    virtual csPtr<iMeshObjectFactory> NewFactory ()                         \
    { return new factclass (Engine, object_reg, this); }                    \
  };

#include "csutil/win32/msvc_deprecated_warn_off.h"

class CS_CRYSTALSPACE_EXPORT csMeshObject : 
  public scfImplementationExt1<csMeshObject, csObjectModel, iMeshObject>
{
protected:
  csRef<iMeshObjectDrawCallback> VisCallback;

  iMeshWrapper *LogParent;

  iEngine *Engine;

  void WantToDie ();

  csFlags flags;

  csBox3 boundingbox;

public:

  csMeshObject (iEngine *engine);

  virtual ~csMeshObject ();

  virtual iMeshObjectFactory* GetFactory () const = 0;

  virtual csPtr<iMeshObject> Clone () { return 0; }
  
  virtual csFlags& GetFlags () { return flags; }

  virtual csRenderMesh** GetRenderMeshes (int& num, iRenderView*, iMovable*,
        uint32)
  {
    num = 0;
    return 0;
  }

  virtual void SetVisibleCallback (iMeshObjectDrawCallback* cb);

  virtual iMeshObjectDrawCallback* GetVisibleCallback () const;

  virtual void NextFrame (csTicks current_time,const csVector3& pos,
    uint currentFrame);

  virtual void HardTransform (const csReversibleTransform& t);

  virtual bool SupportsHardTransform () const;

  virtual bool HitBeamOutline (const csVector3& start,
        const csVector3& end, csVector3& isect, float* pr);

  virtual bool HitBeamObject (const csVector3& start, const csVector3& end,
        csVector3& isect, float* pr, int* polygon_idx = 0,
        iMaterialWrapper** = 0);

  virtual void SetMeshWrapper (iMeshWrapper* logparent);

  virtual iMeshWrapper* GetMeshWrapper () const;

  virtual iObjectModel* GetObjectModel () { return this; }

  virtual bool SetColor (const csColor& color);

  virtual bool GetColor (csColor& color) const;

  virtual bool SetMaterialWrapper (iMaterialWrapper* material);

  virtual iMaterialWrapper* GetMaterialWrapper () const;

  virtual void SetMixMode (uint) { }
  virtual uint GetMixMode () const { return CS_FX_COPY; }

  virtual void InvalidateMaterialHandles () { }

  virtual void PositionChild (iMeshObject* /*child*/,csTicks /*current_time*/) { }

  virtual void GetObjectBoundingBox (csBox3& bbox);

  virtual const csBox3& GetObjectBoundingBox ();

  virtual void SetObjectBoundingBox (const csBox3& bbox);

  virtual void GetRadius (float& radius, csVector3& center);

  virtual iTerraFormer* GetTerraFormerColldet () { return 0; }

};

#include "csutil/win32/msvc_deprecated_warn_on.h"

class CS_CRYSTALSPACE_EXPORT csMeshFactory : 
  public scfImplementation1<csMeshFactory, iMeshObjectFactory>
{
protected:
  iMeshFactoryWrapper *LogParent;

  iMeshObjectType* mesh_type;

  iEngine *Engine;

  iObjectRegistry* object_reg;

  csFlags flags;

public:

  csMeshFactory (iEngine *engine, iObjectRegistry* object_reg,
    iMeshObjectType* parent);

  iObjectRegistry* GetObjectRegistry () { return object_reg; }

  virtual ~csMeshFactory ();

  virtual csFlags& GetFlags () { return flags; }

  virtual csPtr<iMeshObject> NewInstance () = 0;

  virtual void HardTransform (const csReversibleTransform& t);

  virtual bool SupportsHardTransform () const;

  virtual void SetMeshFactoryWrapper (iMeshFactoryWrapper* logparent);

  virtual iMeshFactoryWrapper* GetMeshFactoryWrapper () const;

  virtual iMeshObjectType* GetMeshObjectType () const;

  virtual iObjectModel* GetObjectModel () { return 0; }

  virtual bool SetMaterialWrapper (iMaterialWrapper*) { return false; }
  virtual iMaterialWrapper* GetMaterialWrapper () const { return 0; }
  virtual void SetMixMode (uint) { }
  virtual uint GetMixMode () const { return 0; }
};

class CS_CRYSTALSPACE_EXPORT csMeshType : 
  public scfImplementation2<csMeshType, iMeshObjectType, iComponent>
{
protected:
  iEngine *Engine;

  iObjectRegistry* object_reg;

public:

  csMeshType (iBase *p);

  virtual ~csMeshType ();

  bool Initialize (iObjectRegistry* reg);

  virtual csPtr<iMeshObjectFactory> NewFactory () = 0;

};

#endif // __CS_MESHOBJTMPL_H__

---