Enter your search terms GNU-Darwin Web Submit search form

curve.h /* Copyright (C) 1998-2001 by Jorrit Tyberghein 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_CURVE_H__ #define __CS_CURVE_H__ #include "csutil/scf.h" #include "csutil/csvector.h" #include "csgeom/math3d.h" #include "csgeom/math2d.h" #include "csgeom/box.h" #include "csengine/bezier.h" #include "csengine/texture.h" #include "csengine/material.h" #include "csengine/lghtmap.h" #include "csengine/rview.h" #include "csutil/csobject.h" #include "ivideo/graph3d.h" #include "ivideo/vbufmgr.h" #include "imesh/thing/curve.h" class csThing; class csCurveTemplate; class csLightPatch; class csSector; class csRadCurve; class csBspContainer; class csFrustumView; struct csCoverageMatrix; struct iMaterialHandle; struct iCacheManager; class csCurveTesselated { private: // Object space coordinates. csVector3* ObjectCoords; // Texture coordinates. csVector2* TextureCoords; // Original control points. csVector2* ControlPoints; // Colors for the vertices. csColor* Colors; // Triangles. csTriangle* Triangles; // Number of vertices int NumVertices; // Number of triangles int NumTriangles; // A flag which indicates if the color table is filled in. bool ColorsValid; public: csCurveTesselated (int NumVertices, int NumTriangles); ~csCurveTesselated (); inline int GetVertexCount () const; inline int GetTriangleCount () const; inline csVector3* GetVertices (); inline csVector2* GetTxtCoords (); inline csVector2* GetControlPoints (); inline csColor* GetColors (); inline csTriangle* GetTriangles (); inline csTriangle& GetTriangle (int i); inline bool AreColorsValid () const; void UpdateColors (csLightMap* lightmap); }; class csCurve : public csObject { friend class csRadCurve; private: unsigned long CurveID; static unsigned long LastCurveID; iMaterialWrapper* Material; csCurveTemplate* CurveTemplate; csLightPatch* LightPatches; csReversibleTransform* O2W; /* * Position Buffer: this is an array which coordinates u,v lightmap * pixel coordinates to the position on the curve in world space * coordinates. * i.e. in a 10x10 lightmap uv2World[5][5] is the world space coordinate * of the lightmap texel 5,5 on the lightmap */ csVector3* uv2World; /* * Normal Buffer: this is an array which coordinates u,v lightmap * pixel coordinates to the normal of the curve * i.e. in a 10x10 lightmap uv2Normal[5][5] is the normal vector which * corresponds to the lightmap texel 5,5 on the lightmap */ csVector3* uv2Normal; iVertexBuffer* vbuf; iVertexBufferManager* vbufmgr; void SetupVertexBuffer (); struct eiVertexBufferManagerClient : public iVertexBufferManagerClient { SCF_DECLARE_EMBEDDED_IBASE (csCurve); virtual void ManagerClosing (); }scfiVertexBufferManagerClient; friend struct eiVertexBufferManagerClient; public: csThing* ParentThing; csLightMap* LightMap; bool LightmapUpToDate; public: csCurve (csCurveTemplate* parent_tmpl); virtual ~csCurve (); inline unsigned long GetCurveID () const; iVertexBuffer* GetVertexBuffer () const { return vbuf; } inline iMaterialHandle* GetMaterialHandle () const; inline iMaterialWrapper* GetMaterial () const; void SetMaterial (iMaterialWrapper* h); inline csCurveTemplate* GetParentTemplate () const; void MakeDirtyDynamicLights (); void AddLightPatch (csLightPatch* lp); void UnlinkLightPatch (csLightPatch* lp); bool RecalculateDynamicLights (); void ShineDynLight (csLightPatch* lp); void SetObject2World (const csReversibleTransform *o2w); inline const csReversibleTransform *GetObject2World () const; inline void SetParentThing (csThing* p); inline csThing* GetParentThing () const; inline csLightMap* GetLightMap () const; void CalculateLightingStatic (csFrustumView* lview, bool vis); void CalculateLightingDynamic (csFrustumView* lview); void InitializeDefaultLighting (); bool ReadFromCache (iCacheManager* cache_mgr, int id); bool WriteToCache (iCacheManager* cache_mgr, int id); void PrepareLighting (); void GetCoverageMatrix (csFrustumView& lview, csCoverageMatrix &cm) const; float GetArea(); void CalcUVBuffers(); virtual csCurveTesselated* Tesselate (int res) = 0; virtual void SetControlPoint (int index, int control_id) = 0; virtual void GetObjectBoundingBox (csBox3& bbox) = 0; void GetCameraBoundingBox (const csTransform& obj2cam, csBox3& cbox); float GetScreenBoundingBox (const csTransform& obj2cam, iCamera* camera, csBox3& cameraBox, csBox2& boundingBox); virtual bool IsLightable (); virtual void PosInSpace (csVector3& vec, double u, double v); virtual void Normal (csVector3& vec, double u, double v); virtual void HardTransform (const csReversibleTransform& trans); SCF_DECLARE_IBASE_EXT (csObject); //----------------------- iCurve interface implementation ----------------- struct Curve : public iCurve { SCF_DECLARE_EMBEDDED_IBASE (csCurve); virtual csCurve* GetOriginalObject () { return scfParent; } virtual iObject *QueryObject() { return scfParent; } virtual iCurveTemplate* GetParentTemplate (); virtual void SetMaterial (iMaterialWrapper* mat) { scfParent->SetMaterial (mat); } virtual iMaterialWrapper* GetMaterial () { return scfParent->GetMaterial (); } virtual void SetName (const char* name) { scfParent->SetName (name); } virtual const char* GetName () const { return scfParent->GetName (); } virtual void SetControlPoint (int idx, int control_id) { scfParent->SetControlPoint (idx, control_id); } } scfiCurve; friend struct Curve; }; SCF_VERSION (csCurveTemplate, 0, 0, 1); class csCurveTemplate : public csObject { protected: iMaterialWrapper* Material; protected: virtual ~csCurveTemplate (); public: csCurveTemplate(); virtual csCurve* MakeCurve () = 0; virtual void SetVertex (int index, int ver_ind) = 0; virtual int GetVertex (int index) = 0; virtual int GetVertexCount () = 0; iMaterialWrapper* GetMaterial () { return Material; } void SetMaterial (iMaterialWrapper* h); SCF_DECLARE_IBASE_EXT (csObject); //------------------ iCurveTemplate interface implementation -------------- struct CurveTemplate : public iCurveTemplate { SCF_DECLARE_EMBEDDED_IBASE (csCurveTemplate); virtual iObject *QueryObject() { return scfParent; } virtual void SetMaterial (iMaterialWrapper* mat) { scfParent->SetMaterial (mat); } virtual iMaterialWrapper* GetMaterial () { return scfParent->GetMaterial (); } virtual iCurve* MakeCurve () { return &(scfParent->MakeCurve ()->scfiCurve); } virtual int GetVertexCount () const { return scfParent->GetVertexCount (); } virtual int GetVertex (int idx) const { return scfParent->GetVertex (idx); } virtual void SetVertex (int idx, int vt) { scfParent->SetVertex (idx, vt); } } scfiCurveTemplate; friend struct CurveTemplate; }; class csBezierTemplate : public csCurveTemplate { private: int ver_id[9]; public: csBezierTemplate(); virtual csCurve* MakeCurve(); virtual void SetVertex (int index, int ver_ind); virtual int GetVertex (int index); virtual int GetVertexCount (); // Should not be necessary, but without this buggy NextStep compiler // incorrectly calls csObject::QueryInterface() rather than correctly // calling csCurveTemplate::QueryInterface(). SCF_DECLARE_IBASE_EXT(csCurveTemplate); }; class csBezierCurve : public csCurve { private: csVector3 points[3][3]; csVector2 texture_coords[3][3]; double cpt[9][5]; csCurveTesselated* previous_tesselation; int previous_resolution; csBox3 object_bbox; bool valid_bbox; public: csBezierCurve (csBezierTemplate* parent_tmpl); ~csBezierCurve (); virtual csCurveTesselated* Tesselate (int res); virtual void GetObjectBoundingBox (csBox3& bbox); void Load (char* buf); virtual void SetControlPoint (int index, int control_id); inline csVector3& GetControlPoint (int i) { return points[i/3][i-(i/3)*3]; } inline csVector2& GetTextureCoord (int i) { return texture_coords[i/3][i-(i/3)*3]; } virtual bool IsLightable (); virtual void PosInSpace (csVector3& vec, double u, double v); virtual void Normal (csVector3& vec, double u, double v); virtual void HardTransform (const csReversibleTransform& trans); }; /* * Implementation of inline functions */ inline int csCurveTesselated::GetVertexCount () const { return NumVertices; } inline int csCurveTesselated::GetTriangleCount () const { return NumTriangles; } inline csVector3* csCurveTesselated::GetVertices () { return ObjectCoords; } inline csVector2* csCurveTesselated::GetTxtCoords () { return TextureCoords; } inline csVector2* csCurveTesselated::GetControlPoints () { return ControlPoints; } inline csColor* csCurveTesselated::GetColors () { return Colors; } inline csTriangle* csCurveTesselated::GetTriangles () { return Triangles; } inline csTriangle& csCurveTesselated::GetTriangle (int i) { return Triangles[i]; } inline bool csCurveTesselated::AreColorsValid () const { return ColorsValid; } inline unsigned long csCurve::GetCurveID () const { return CurveID; } inline iMaterialHandle* csCurve::GetMaterialHandle () const { return Material ? Material->GetMaterialHandle() : NULL; } inline iMaterialWrapper* csCurve::GetMaterial () const { return Material; } inline csCurveTemplate* csCurve::GetParentTemplate () const { return CurveTemplate; } inline csLightMap* csCurve::GetLightMap () const { return LightMap; } inline void csCurve::SetParentThing (csThing* p) { ParentThing = p; } inline csThing* csCurve::GetParentThing () const { return ParentThing; } inline const csReversibleTransform *csCurve::GetObject2World () const { return O2W; } #endif // __CS_CURVE_H__ Generated for Crystal Space by doxygen 1.2.5 written by Dimitri van Heesch, ©1997-2000