Enter your search terms GNU-Darwin Web Submit search form

polygon.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_POLYGON_H__ #define __CS_POLYGON_H__ #include "csutil/scf.h" #include "csutil/cscolor.h" #include "csutil/flags.h" #include "csgeom/transfrm.h" #include "csgeom/polyclip.h" #include "csgeom/polyidx.h" #include "csengine/polyint.h" #include "csengine/polyplan.h" #include "csengine/thing.h" #include "csengine/portal.h" #include "csengine/polytext.h" #include "csengine/octree.h" #include "csengine/material.h" #include "iengine/sector.h" #include "imesh/thing/polygon.h" #include "imesh/thing/ptextype.h" class csSector; class csFrustumView; class csFrustumContext; class csMaterialWrapper; class csPolyPlane; class csPolyTxtPlane; class csPolygon2D; class csPolygon3D; class csLightMap; class csLightPatch; class csPolyTexture; class csThing; struct iLight; struct iGraphics2D; struct iGraphics3D; struct iCacheManager; struct csPolygonLightInfo { float cosinus_factor; csLightPatch *lightpatches; bool dyn_dirty; }; /*---------------------------------------------------------------------------*/ class csPolyTexType : public iPolyTexType { friend class csPolygon3D; protected: uint16 Alpha; uint MixMode; csPolyTexType (); virtual ~csPolyTexType (); public: virtual int GetTextureType () { return POLYTXT_NONE; } int GetAlpha () { return Alpha; } void SetAlpha (int a) { Alpha = a; } virtual void SetMixMode (uint m) { MixMode = m & ~CS_FX_MASK_ALPHA; } virtual uint GetMixMode () { return (MixMode | Alpha); } SCF_DECLARE_IBASE; }; class csPolyTexFlat : public csPolyTexType { friend class csPolygon3D; private: csVector2* uv_coords; protected: csPolyTexFlat () : csPolyTexType () { SCF_CONSTRUCT_EMBEDDED_IBASE(scfiPolyTexFlat); uv_coords = NULL; } virtual ~csPolyTexFlat (); public: virtual int GetTextureType () { return POLYTXT_FLAT; } void Setup (csPolygon3D *iParent); virtual void Setup (iPolygon3D *iParent); virtual void SetUV (int i, float u, float v); virtual void ClearUV (); virtual csVector2 *GetUVCoords () { return uv_coords; } SCF_DECLARE_IBASE_EXT (csPolyTexType); struct eiPolyTexFlat : public iPolyTexFlat { SCF_DECLARE_EMBEDDED_IBASE(csPolyTexFlat); virtual void Setup (iPolygon3D *p) { scfParent->Setup(p); } virtual void SetUV (int i, float u, float v) { scfParent->SetUV(i,u,v); } virtual void ClearUV () { scfParent->ClearUV(); } virtual csVector2 *GetUVCoords () { return scfParent->GetUVCoords(); } } scfiPolyTexFlat; }; class csPolyTexGouraud : public csPolyTexFlat { friend class csPolygon3D; private: csColor *colors; csColor *static_colors; bool gouraud_up_to_date; protected: csPolyTexGouraud () : csPolyTexFlat () { SCF_CONSTRUCT_EMBEDDED_IBASE(scfiPolyTexGouraud); colors = static_colors = 0; gouraud_up_to_date = false; } virtual ~csPolyTexGouraud (); public: virtual int GetTextureType () { return POLYTXT_GOURAUD; } void Setup (csPolygon3D *iParent); virtual void Setup (iPolygon3D *iParent); virtual void ClearColors (); virtual csColor *GetColors () { return colors; } virtual csColor *GetStaticColors () { return static_colors; } void AddColor (int i, float r, float g, float b); void AddDynamicColor (int i, float r, float g, float b); void SetDynamicColor (int i, float r, float g, float b); virtual void ResetDynamicColor (int i); virtual void SetDynamicColor (int i, const csColor& c) { SetDynamicColor (i, c.red, c.green, c.blue); } void SetColor (int i, float r, float g, float b); virtual void SetColor (int i, const csColor& c) { SetColor (i, c.red, c.green, c.blue); } SCF_DECLARE_IBASE_EXT (csPolyTexFlat); struct eiPolyTexGouraud : public iPolyTexGouraud { SCF_DECLARE_EMBEDDED_IBASE(csPolyTexGouraud); virtual void Setup (iPolygon3D *p) { scfParent->Setup(p); } virtual void ClearColors () { scfParent->ClearColors(); } virtual csColor *GetColors () { return scfParent->GetColors(); } virtual csColor *GetStaticColors() { return scfParent->GetStaticColors(); } virtual void ResetDynamicColor (int i) { scfParent->ResetDynamicColor(i); } virtual void SetDynamicColor (int i, const csColor& c) { scfParent->SetDynamicColor(i,c); } virtual void SetColor(int i,const csColor& c) { scfParent->SetColor(i,c); } } scfiPolyTexGouraud; }; class csPolyTexLightMap : public csPolyTexType { friend class csPolygon3D; private: csPolyTexture *tex; csPolyTxtPlane *txt_plane; bool lightmap_up_to_date; private: csPolyTexLightMap (); virtual ~csPolyTexLightMap (); public: void Setup (csPolygon3D* poly3d, csMaterialWrapper* math); virtual int GetTextureType () { return POLYTXT_LIGHTMAP; } csPolyTexture* GetPolyTex (); csPolyTxtPlane* GetTxtPlane () const { return txt_plane; } virtual iPolyTxtPlane* GetPolyTxtPlane () const; void SetTxtPlane (csPolyTxtPlane* txt_pl); void NewTxtPlane (); iLightMap* GetLightMap () { return tex->GetLightMap (); } SCF_DECLARE_IBASE_EXT (csPolyTexType); struct eiPolyTexLightMap : public iPolyTexLightMap { SCF_DECLARE_EMBEDDED_IBASE(csPolyTexLightMap); virtual iPolyTxtPlane* GetPolyTxtPlane () const { return scfParent->GetPolyTxtPlane(); } } scfiPolyTexLightMap; }; /*---------------------------------------------------------------------------*/ #define CS_POLY_DELETE_PORTAL 0x80000000 #define CS_POLY_NO_DRAW 0x40000000 #define CS_POLY_SPLIT 0x20000000 #define CS_POLY_LM_REFUSED 0x10000000 class csPolygon3D : public csPolygonInt, public csObject // NOTE: DO NOT MOVE csPolygonInt FROM FIRST PLACE! THERE ARE LOTS OF PLACES // WHERE CODE BLATANTLY SWITCHES BETWEEN csPolygon3D AND csPolygonInt TYPES // WITHOUT GIVING TO THE C++ COMPILER EVEN A CHANCE TO ADJUST THE POINTER!!! { friend class csPolyTexture; private: unsigned long polygon_id; /* * A table of indices into the vertices of the parent csThing * (container). */ csPolyIndexed vertices; csThing* thing; csPortal* portal; csPolyPlane* plane; csMaterialWrapper* material; csPolygonLightInfo light_info; csPolyTexType *txt_info; csPolygon3D *orig_poly; csPolygon3D *txt_share_list; uint32 pvs_vis_nr; void PlaneNormal (float* yz, float* zx, float* xy); #ifdef DO_HW_UVZ void SetupHWUV(); #endif void CalculateDelayedLighting (csFrustumView *lview, csFrustumContext* ctxt); public: csFlags flags; public: #ifdef DO_HW_UVZ csVector3 *uvz; bool isClipped; #endif csPolygon3D (csMaterialWrapper *mat); csPolygon3D (csPolygon3D& poly); virtual ~csPolygon3D (); unsigned long GetPolygonID () { CS_ASSERT (polygon_id != 0); return polygon_id; } void SetTextureType (int type); int GetTextureType () { return txt_info->GetTextureType (); } void CopyTextureType (iPolygon3D* other_polygon); csPolyTexType *GetTextureTypeInfo () { return txt_info; } csPolyTexLightMap *GetLightMapInfo () { if (txt_info && txt_info->GetTextureType () == POLYTXT_LIGHTMAP) return (csPolyTexLightMap *)txt_info; else return NULL; } csPolyTexGouraud *GetGouraudInfo () { if (txt_info && txt_info->GetTextureType () == POLYTXT_GOURAUD) return (csPolyTexGouraud*)txt_info; else return NULL; } csPolyTexFlat *GetFlatInfo () { if (txt_info && (txt_info->GetTextureType () == POLYTXT_FLAT || txt_info->GetTextureType () == POLYTXT_GOURAUD)) return (csPolyTexFlat*)txt_info; else return NULL; } csPolyTexType *GetNoTexInfo () { if (txt_info && txt_info->GetTextureType () != POLYTXT_LIGHTMAP) return (csPolyTexType *)txt_info; else return NULL; } void Reset (); int AddVertex (int v); int AddVertex (const csVector3& v); int AddVertex (float x, float y, float z); void ComputeNormal (); void Finish (); void SetCSPortal (csSector* sector, bool null = false); void SetPortal (csPortal* prt); csPortal* GetPortal () { return portal; } void SetParent (csThing* thing); csThing* GetParent () { return thing; } csPolyPlane* GetPlane () { return plane; } csPlane3* GetPolyPlane () { return &plane->GetWorldPlane (); } csPolyIndexed& GetVertices () { return vertices; } virtual int GetVertexCount () { return vertices.GetVertexCount (); } virtual int* GetVertexIndices () { return vertices.GetVertexIndices (); } void SetWarp (const csTransform& t) { if (portal) portal->SetWarp (t); } void SetWarp (const csMatrix3& m_w, const csVector3& v_w_before, const csVector3& v_w_after) { if (portal) portal->SetWarp (m_w, v_w_before, v_w_after); } const csVector3& Vwor (int idx) const { return thing->Vwor (vertices.GetVertexIndices ()[idx]); } const csVector3& Vobj (int idx) const { return thing->Vobj (vertices.GetVertexIndices ()[idx]); } const csVector3& Vcam (int idx) const { return thing->Vcam (vertices.GetVertexIndices ()[idx]); } void UpdateTransformation (const csTransform& c, long cam_cameranr) { thing->UpdateTransformation (c, cam_cameranr); } void WorUpdate () { thing->WorUpdate (); } void SetMaterial (csMaterialWrapper* material); csMaterialWrapper* GetMaterialWrapper () { return material; } bool IsTransparent (); float GetArea (); float GetCosinusFactor () { return light_info.cosinus_factor; } void SetCosinusFactor (float f) { light_info.cosinus_factor = f; } void SetTextureSpace (csPolygon3D* copy_from); void SetTextureSpace (csPolyTxtPlane* txt_pl); void SetTextureSpace ( const csVector3& p1, const csVector2& uv1, const csVector3& p2, const csVector2& uv2, const csVector3& p3, const csVector2& uv3); void SetTextureSpace (const csVector3& v_orig, const csVector3& v1, float len1); void SetTextureSpace ( float xo, float yo, float zo, float x1, float y1, float z1, float len1); void SetTextureSpace ( const csVector3& v_orig, const csVector3& v1, float len1, const csVector3& v2, float len2); void SetTextureSpace ( float xo, float yo, float zo, float x1, float y1, float z1, float len1, float x2, float y2, float z2, float len2); void SetTextureSpace (csMatrix3 const&, csVector3 const&); csPolygonInt* GetUnsplitPolygon () { return orig_poly; } csPolygon3D* GetBasePolygon () { return orig_poly ? (csPolygon3D*)orig_poly : this; } void MakeDirtyDynamicLights (); bool IsDirty () { return light_info.dyn_dirty; } void MakeCleanDynamicLights () { light_info.dyn_dirty = false; } void UnlinkLightpatch (csLightPatch* lp); void AddLightpatch (csLightPatch *lp); csLightPatch* GetLightpatches () { return light_info.lightpatches; } void ClipPolyPlane (csVector3* verts, int* num, bool mirror, csVector3& v1, csVector3& v2); void InitializeDefault (); bool ReadFromCache (iCacheManager* cache_mgr, int id); bool WriteToCache (iCacheManager* cache_mgr, int id); void PrepareLighting (); void FillLightMapDynamic (csFrustumView& lview); void FillLightMapStatic (csFrustumView* lview, bool vis); void UpdateVertexLighting (iLight* light, const csColor& lcol, bool dynamic, bool reset); bool MarkRelevantShadowFrustums (csFrustumView& lview, csPlane3& plane); bool MarkRelevantShadowFrustums (csFrustumView& lview); void CalculateLightingDynamic (csFrustumView* lview); void CalculateLightingStatic (csFrustumView* lview, bool vis); void ObjectToWorld (const csReversibleTransform& t, const csVector3& vwor); void HardTransform (const csReversibleTransform& t); bool ClipToPlane (csPlane3* portal_plane, const csVector3& v_w2c, csVector3*& pverts, int& num_verts, bool cw = true); bool DoPerspective (const csTransform& trans, csVector3* source, int num_verts, csPolygon2D* dest, csVector2* orig_triangle, bool mirror); virtual int Classify (const csPlane3& pl); virtual int ClassifyX (float x); virtual int ClassifyY (float y); virtual int ClassifyZ (float z); virtual void SplitWithPlane (csPolygonInt** front, csPolygonInt** back, const csPlane3& plane); virtual bool Overlaps (csPolygonInt* overlapped); virtual int GetType () { return 1; } bool IntersectSegment (const csVector3& start, const csVector3& end, csVector3& isect, float* pr = NULL); bool IntersectRay (const csVector3& start, const csVector3& end); bool IntersectRayNoBackFace (const csVector3& start, const csVector3& end); bool IntersectRayPlane (const csVector3& start, const csVector3& end, csVector3& isect); bool PointOnPolygon (const csVector3& v); virtual int GetAlpha () { return txt_info->GetAlpha (); } virtual void SetAlpha (int iAlpha) { txt_info->SetAlpha (iAlpha); } virtual iMaterialHandle *GetMaterialHandle (); virtual iPolygonTexture *GetTexture () { csPolyTexLightMap *lm = GetLightMapInfo (); return lm ? lm->GetPolyTex () : (iPolygonTexture*)NULL; } csPolygon3D *GetNextShare () { return txt_share_list; } void SetNextShare (csPolygon3D *next) { txt_share_list = next; } SCF_DECLARE_IBASE_EXT (csObject); //------------------- iPolygon3D interface implementation ------------------- struct eiPolygon3D : public iPolygon3D { SCF_DECLARE_EMBEDDED_IBASE (csPolygon3D); virtual csPolygon3D *GetPrivateObject () { return scfParent; } virtual iObject *QueryObject() {return scfParent;} virtual iThingState *GetParent (); virtual iLightMap *GetLightMap () { csPolyTexLightMap *lm = scfParent->GetLightMapInfo (); return lm ? lm->GetLightMap () : (iLightMap*)NULL; } virtual iPolygonTexture *GetTexture () { return scfParent->GetTexture(); } virtual iMaterialHandle *GetMaterialHandle () { return scfParent->GetMaterialHandle (); } virtual void SetMaterial (iMaterialWrapper* mat) { scfParent->SetMaterial ( ((csMaterialWrapper::MaterialWrapper*)(mat))->scfParent); } virtual iMaterialWrapper* GetMaterial () { // @@@ Not efficient. In future we need to store iMaterialWrapper // directly. if (!scfParent->GetMaterialWrapper ()) return NULL; else { iMaterialWrapper* wrap = SCF_QUERY_INTERFACE ( scfParent->GetMaterialWrapper (), iMaterialWrapper); wrap->DecRef (); return wrap; } } virtual int GetVertexCount () { return scfParent->vertices.GetVertexCount (); } virtual int* GetVertexIndices () { return scfParent->vertices.GetVertexIndices (); } virtual const csVector3 &GetVertex (int idx) const { return scfParent->Vobj (idx); } virtual const csVector3 &GetVertexW (int idx) const { return scfParent->Vwor (idx); } virtual const csVector3 &GetVertexC (int idx) const { return scfParent->Vcam (idx); } virtual int CreateVertex (int idx) { return scfParent->AddVertex (idx); } virtual int CreateVertex (const csVector3 &iVertex) { return scfParent->AddVertex (iVertex); } virtual int GetAlpha () { return scfParent->GetAlpha (); } virtual void SetAlpha (int iAlpha) { scfParent->SetAlpha (iAlpha); } virtual void CreatePlane (const csVector3 &iOrigin, const csMatrix3 &iMatrix); virtual bool SetPlane (const char *iName); virtual csFlags& GetFlags () { return scfParent->flags; } virtual void SetLightingMode (bool iGouraud) { scfParent->SetTextureType(iGouraud ? POLYTXT_GOURAUD:POLYTXT_LIGHTMAP); } virtual iPortal* CreateNullPortal () { scfParent->SetCSPortal (NULL, true); return &(scfParent->GetPortal ()->scfiPortal); } virtual iPortal* CreatePortal (iSector *iTarget) { scfParent->SetCSPortal (iTarget->GetPrivateObject ()); return &(scfParent->GetPortal ()->scfiPortal); } virtual iPortal* GetPortal () { csPortal* prt = scfParent->GetPortal (); if (prt) return &(prt->scfiPortal); else return NULL; } virtual void SetTextureSpace ( const csVector3& p1, const csVector2& uv1, const csVector3& p2, const csVector2& uv2, const csVector3& p3, const csVector2& uv3) { scfParent->SetTextureSpace (p1, uv1, p2, uv2, p3, uv3); } virtual void SetTextureSpace (const csVector3& v_orig, const csVector3& v1, float l1) { scfParent->SetTextureSpace (v_orig, v1, l1); } virtual void SetTextureSpace ( const csVector3& v_orig, const csVector3& v1, float len1, const csVector3& v2, float len2) { scfParent->SetTextureSpace (v_orig, v1, len1, v2, len2); } virtual void SetTextureSpace (csMatrix3 const& m, csVector3 const& v) { scfParent->SetTextureSpace (m, v); } virtual void SetTextureSpace (iPolyTxtPlane* plane); virtual void SetTextureType (int type) { scfParent->SetTextureType (type); } virtual int GetTextureType () { return scfParent->GetTextureType (); } virtual void CopyTextureType (iPolygon3D* other_polygon) { scfParent->CopyTextureType (other_polygon); } virtual const csPlane3& GetWorldPlane () { return scfParent->plane->GetWorldPlane (); } virtual const csPlane3& GetObjectPlane () { return scfParent->plane->GetObjectPlane (); } virtual const csPlane3& GetCameraPlane () { return scfParent->plane->GetCameraPlane (); } virtual bool IsTransparent () { return scfParent->IsTransparent (); } virtual float GetCosinusFactor () { return scfParent->GetCosinusFactor (); } virtual void SetCosinusFactor (float cosfact) { scfParent->SetCosinusFactor (cosfact); } virtual iPolyTexType* GetPolyTexType (); virtual void UpdateVertexLighting (iLight* light, const csColor& lcol, bool dynamic, bool reset) { scfParent->UpdateVertexLighting (light, lcol, dynamic, reset); } virtual unsigned long GetPolygonID () { return scfParent->GetPolygonID (); } virtual bool IntersectSegment (const csVector3& start, const csVector3& end, csVector3& isect, float* pr = NULL) { return scfParent->IntersectSegment (start, end, isect, pr); } virtual bool IntersectRay (const csVector3& start, const csVector3& end) { return scfParent->IntersectRay (start, end); } virtual bool IntersectRayNoBackFace (const csVector3& start, const csVector3& end) { return scfParent->IntersectRayNoBackFace (start, end); } virtual bool IntersectRayPlane (const csVector3& start, const csVector3& end, csVector3& isect) { return scfParent->IntersectRayPlane (start, end, isect); } virtual bool PointOnPolygon (const csVector3& v) { return scfParent->PointOnPolygon (v); } } scfiPolygon3D; friend struct eiPolygon3D; }; #endif // __CS_POLYGON_H__ Generated for Crystal Space by doxygen 1.2.5 written by Dimitri van Heesch, ©1997-2000