fixed some dynamic lighting bugs related to glowing self
[xonotic/darkplaces.git] / model_shared.h
index d5af37a..776b1af 100644 (file)
@@ -8,7 +8,7 @@ of the License, or (at your option) any later version.
 
 This program 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.  
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 See the GNU General Public License for more details.
 
@@ -33,7 +33,7 @@ m*_t structures are in-memory
 
 */
 
-typedef enum {mod_brush, mod_sprite, mod_alias} modtype_t;
+typedef enum {mod_invalid, mod_brush, mod_sprite, mod_alias} modtype_t;
 
 typedef struct animscene_s
 {
@@ -45,8 +45,32 @@ typedef struct animscene_s
 }
 animscene_t;
 
+typedef struct skinframe_s
+{
+       rtexture_t *base; // original texture minus pants/shirt/glow
+       rtexture_t *pants; // pants only (in greyscale)
+       rtexture_t *shirt; // shirt only (in greyscale)
+       rtexture_t *glow; // glow only
+       rtexture_t *merged; // original texture minus glow
+       rtexture_t *fog; // white texture with alpha of the base texture, NULL if not transparent
+       rtexture_t *nmap; // normalmap (bumpmap for dot3)
+       rtexture_t *gloss; // glossmap (for dot3)
+}
+skinframe_t;
+
 #define MAX_SKINS 256
 
+typedef struct shadowmesh_s
+{
+       struct shadowmesh_s *next;
+       int numverts, maxverts;
+       int numtriangles, maxtriangles;
+       float *verts;
+       int *elements;
+       int *neighbors;
+}
+shadowmesh_t;
+
 
 #include "model_brush.h"
 #include "model_sprite.h"
@@ -54,108 +78,225 @@ animscene_t;
 
 typedef struct model_s
 {
-       char            name[MAX_QPATH];
-       qboolean        needload;               // bmodels don't cache normally
-
-       modtype_t       type;
-       int                     aliastype; // LordHavoc: Q2 model support
-       int                     fullbright; // LordHavoc: if true (normally only for sprites) the model/sprite/bmodel is always rendered fullbright
-       int                     numframes;
-       synctype_t      synctype;
-       
-       int                     flags;
-
-// volume occupied by the model graphics
-       vec3_t          mins, maxs;
-       float           radius;
-
-// solid volume for clipping 
-       qboolean        clipbox;
-       vec3_t          clipmins, clipmaxs;
-
-// brush model
-       int                     firstmodelsurface, nummodelsurfaces;
-
-       int                     numsubmodels;
-       dmodel_t        *submodels;
-
-       int                     numplanes;
-       mplane_t        *planes;
-
-       int                     numleafs;               // number of visible leafs, not counting 0
-       mleaf_t         *leafs;
-
-       int                     numvertexes;
-       mvertex_t       *vertexes;
+       char                    name[MAX_QPATH];
+       // model needs to be loaded if this is true
+       qboolean                needload;
+       // set if the model is used in current map, models which are not, are purged
+       qboolean                used;
+       // CRC of the file this model was loaded from, to reload if changed
+       qboolean                crc;
+       // true if this is the world model (I.E. defines what sky to use, and may contain submodels)
+       qboolean                isworldmodel;
+       // true if this model is a HalfLife .bsp file
+       qboolean                ishlbsp;
+
+       // mod_brush, mod_alias, mod_sprite
+       modtype_t               type;
+       // LordHavoc: Q2/ZYM model support
+       int                             aliastype;
+       // LordHavoc: if true (normally only for sprites) the model/sprite/bmodel is always rendered fullbright
+       int                             fullbright;
+       // number of QC accessable frame(group)s in the model
+       int                             numframes;
+       // whether to randomize animated framegroups
+       synctype_t              synctype;
+
+       // used for sprites and models
+       int                             numtris;
+       // used for models
+       int                             numskins;
+       // used by models
+       int                             numverts;
+
+       // flags from the model file
+       int                             flags;
+       // engine calculated flags, ones that can not be set in the file
+       int                             flags2;
+
+       // all models use textures...
+       rtexturepool_t  *texturepool;
+
+       // volume occupied by the model
+       // bounding box at angles '0 0 0'
+       vec3_t                  normalmins, normalmaxs;
+       // bounding box if yaw angle is not 0, but pitch and roll are
+       vec3_t                  yawmins, yawmaxs;
+       // bounding box if pitch or roll are used
+       vec3_t                  rotatedmins, rotatedmaxs;
+       // sphere radius, usable at any angles
+       float                   radius;
+       // squared sphere radius for easier comparisons
+       float                   radius2;
+
+       // brush model specific
+       int                             firstmodelsurface, nummodelsurfaces;
+
+       // lightmap format, set to r_lightmaprgba when model is loaded
+       int                             lightmaprgba;
+
+       int                             numsubmodels;
+       dmodel_t                *submodels;
+
+       int                             numplanes;
+       mplane_t                *planes;
+
+       // number of visible leafs, not counting 0 (solid)
+       int                             numleafs;
+       mleaf_t                 *leafs;
+
+       int                             numvertexes;
+       mvertex_t               *vertexes;
+
+       int                             numedges;
+       medge_t                 *edges;
+
+       int                             numnodes;
+       mnode_t                 *nodes;
+
+       int                             numtexinfo;
+       mtexinfo_t              *texinfo;
+
+       int                             numsurfaces;
+       msurface_t              *surfaces;
+       int                             *surfacevisframes;
+       int                             *surfacepvsframes;
+       msurface_t              *surfacepvsnext;
+
+       int                             numsurfedges;
+       int                             *surfedges;
+
+       int                             numclipnodes;
+       dclipnode_t             *clipnodes;
+
+       int                             nummarksurfaces;
+       int                             *marksurfaces;
+
+       hull_t                  hulls[MAX_MAP_HULLS];
+
+       int                             numtextures;
+       texture_t               *textures;
+
+       msurface_t              **texturesurfacechains;
+
+       qbyte                   *visdata;
+       qbyte                   *lightdata;
+       char                    *entities;
+
+       int                             numportals;
+       mportal_t               *portals;
+
+       int                             numportalpoints;
+       mvertex_t               *portalpoints;
+
+       int                             numlights;
+       mlight_t                *lights;
+
+       // used only for casting dynamic shadow volumes
+       shadowmesh_t    *shadowmesh;
+       vec3_t                  shadowmesh_mins, shadowmesh_maxs, shadowmesh_center;
+       float                   shadowmesh_radius;
+
+       // pvs visibility marking
+       mleaf_t                 *pvsviewleaf;
+       int                             pvsviewleafnovis;
+       int                             pvsframecount;
+
+       // skin animation info
+       animscene_t             *skinscenes; // [numskins]
+       // skin frame info
+       skinframe_t             *skinframes;
+
+       animscene_t             *animscenes; // [numframes]
+
+       // Q1 and Q2 models are the same after loading
+       int                             *mdlmd2data_indices;
+       float                   *mdlmd2data_texcoords;
+       md2frame_t              *mdlmd2data_frames;
+       trivertx_t              *mdlmd2data_pose;
+       int                             *mdlmd2data_triangleneighbors;
+
+       // for Zymotic models
+       int                             zymnum_verts;
+       int                             zymnum_tris;
+       int                             zymnum_shaders;
+       int                             zymnum_bones;
+       int                             zymnum_scenes;
+       float                   *zymdata_texcoords;
+       rtexture_t              **zymdata_textures;
+       qbyte                   *zymdata_trizone;
+       zymbone_t               *zymdata_bones;
+       unsigned int    *zymdata_vertbonecounts;
+       zymvertex_t             *zymdata_verts;
+       unsigned int    *zymdata_renderlist;
+       float                   *zymdata_poses;
 
-       int                     numedges;
-       medge_t         *edges;
+       int                             sprnum_type;
+       mspriteframe_t  *sprdata_frames;
 
-       int                     numnodes;
-       mnode_t         *nodes;
 
-       int                     numtexinfo;
-       mtexinfo_t      *texinfo;
+       // functions used in both rendering modes
+       // draw the model's sky polygons (only used by brush models)
+       void(*DrawSky)(struct entity_render_s *ent);
 
-       int                     numsurfaces;
-       msurface_t      *surfaces;
+       // functions used only in normal rendering mode
+       // draw the model
+       void(*Draw)(struct entity_render_s *ent);
+       // draw a fake shadow for the model
+       void(*DrawFakeShadow)(struct entity_render_s *ent);
 
-       int                     numsurfedges;
-       int                     *surfedges;
+       // functions used only in shadow volume rendering mode
+       // draw a shadow volume for the model based on light source
+       void(*DrawShadowVolume)(struct entity_render_s *ent, vec3_t relativelightorigin, float lightradius);
+       // draw the lighting on a model (through stencil)
+       void(*DrawLight)(struct entity_render_s *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float lightdistbias, float lightsubtract, float *lightcolor);
 
-       int                     numclipnodes;
-       dclipnode_t     *clipnodes;
-
-       int                     nummarksurfaces;
-       msurface_t      **marksurfaces;
-
-       hull_t          hulls[MAX_MAP_HULLS];
-
-       int                     numtextures;
-       texture_t       **textures;
-
-       byte            *visdata;
-       byte            *lightdata;
-       char            *entities;
-
-       int                     numportals;
-       mportal_t       *portals;
-
-       int                     numportalpoints;
-       mvertex_t       *portalpoints;
-
-       // LordHavoc: useful for sprites and models
-       int                     numtris;
-       int                     numskins;
-       int                     skinanimrange[MAX_SKINS*2]; // array of start and length pairs
-       rtexture_t      *skinanim[MAX_SKINS*5]; // texture numbers for each frame (indexed by animrange), note: normal pants shirt glow body (normal contains no shirt/pants/glow colors and body is normal + pants + shirt, but not glow)
-       int                     ofs_scenes; // offset from Mod_ExtraData(model) memory to array of animscene_t structs
-       // these are used simply to simplify model/sprite/whatever processing and are specific to each type
-       int                     ofs_frames; // offset from Mod_ExtraData(model) memory to array of model specific frame structs
-       int                     framesize; // size of model specific frame structs
-
-// additional model data
-       cache_user_t    cache;          // only access through Mod_Extradata
-       int                     cachesize;              // size of cached data (zero if not cached)
-
-} model_t;
+       // memory pool for allocations
+       mempool_t               *mempool;
+}
+model_t;
 
 //============================================================================
 
-void   Mod_Init (void);
-void   Mod_ClearAll (void);
-model_t *Mod_ForName (char *name, qboolean crash);
-void   *Mod_Extradata (model_t *mod);  // handles caching
-void   Mod_TouchModel (char *name);
-
-mleaf_t *Mod_PointInLeaf (float *p, model_t *model);
-byte   *Mod_LeafPVS (mleaf_t *leaf, model_t *model);
+// this can be used for anything without a valid texture
+extern rtexture_t *r_notexture;
+// every texture must be in a pool...
+extern rtexturepool_t *r_notexturepool;
+
+// model loading
+extern model_t *loadmodel;
+extern qbyte *mod_base;
+// sky/water subdivision
+//extern cvar_t gl_subdivide_size;
+// texture fullbrights
+extern cvar_t r_fullbrights;
+
+void Mod_Init (void);
+void Mod_CheckLoaded (model_t *mod);
+void Mod_ClearAll (void);
+model_t *Mod_FindName (const char *name);
+model_t *Mod_ForName (const char *name, qboolean crash, qboolean checkdisk, qboolean isworldmodel);
+void Mod_TouchModel (const char *name);
+void Mod_UnloadModel (model_t *mod);
+
+void Mod_ClearUsed(void);
+void Mod_PurgeUnused(void);
+void Mod_LoadModels(void);
+
+extern model_t *loadmodel;
+extern char loadname[32];      // for hunk tags
+
+int Mod_FindTriangleWithEdge(const int *elements, int numtriangles, int start, int end);
+void Mod_BuildTriangleNeighbors(int *neighbors, const int *elements, int numtriangles);
+void Mod_BuildTextureVectorsAndNormals(int numverts, int numtriangles, const float *vertex, const float *texcoord, const int *elements, float *svectors, float *tvectors, float *normals);
+
+shadowmesh_t *Mod_ShadowMesh_Alloc(mempool_t *mempool, int maxverts);
+shadowmesh_t *Mod_ShadowMesh_ReAlloc(mempool_t *mempool, shadowmesh_t *oldmesh);
+int Mod_ShadowMesh_AddVertex(shadowmesh_t *mesh, float *v);
+void Mod_ShadowMesh_AddPolygon(mempool_t *mempool, shadowmesh_t *mesh, int numverts, float *verts);
+shadowmesh_t *Mod_ShadowMesh_Begin(mempool_t *mempool);
+shadowmesh_t *Mod_ShadowMesh_Finish(mempool_t *mempool, shadowmesh_t *firstmesh);
+void Mod_ShadowMesh_CalcBBox(shadowmesh_t *firstmesh, vec3_t mins, vec3_t maxs, vec3_t center, float *radius);
+void Mod_ShadowMesh_Free(shadowmesh_t *mesh);
 
-extern model_t *loadmodel;
-extern char    loadname[32];   // for hunk tags
-
-extern model_t *Mod_LoadModel (model_t *mod, qboolean crash);
-
-extern float RadiusFromBounds (vec3_t mins, vec3_t maxs);
-extern model_t *Mod_FindName (char *name);
 #endif // __MODEL__
+