X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=render.h;h=b933881d65f9176d73cb27bd7d089ce3c24b11bf;hb=fc324557b79cae59f852379d64693f47d2419e96;hp=8406814a77c194b93826cce65e4082328c4fc933;hpb=48422e8fb2ac64f14ab5eb102be50d6258c72396;p=xonotic%2Fdarkplaces.git diff --git a/render.h b/render.h index 8406814a..b933881d 100644 --- a/render.h +++ b/render.h @@ -128,6 +128,14 @@ void R_RenderView(void); // must set r_refdef and call R_UpdateVariables first void R_InitSky (unsigned char *src, int bytesperpixel); // called at level load +void R_SkinFrame_PrepareForPurge(void); +void R_SkinFrame_MarkUsed(skinframe_t *skinframe); +void R_SkinFrame_Purge(void); +skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add); +skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain); +skinframe_t *R_SkinFrame_LoadInternal(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height, int bitsperpixel, const unsigned int *palette, const unsigned int *alphapalette); +skinframe_t *R_SkinFrame_LoadMissing(void); + void R_View_WorldVisibility(); void R_DrawParticles(void); void R_DrawExplosions(void); @@ -136,6 +144,7 @@ void R_DrawExplosions(void); #define gl_alpha_format 4 int R_CullBox(const vec3_t mins, const vec3_t maxs); +int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes); #include "r_modules.h" @@ -179,22 +188,10 @@ void R_TimeReport(char *name); void R_Stain(const vec3_t origin, float radius, int cr1, int cg1, int cb1, int ca1, int cr2, int cg2, int cb2, int ca2); void R_CalcBeam_Vertex3f(float *vert, const vec3_t org1, const vec3_t org2, float width); -void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, rtexture_t *fogtexture, int depthdisable, const vec3_t origin, const vec3_t left, const vec3_t up, float scalex1, float scalex2, float scaley1, float scaley2, float cr, float cg, float cb, float ca); +void R_DrawSprite(int blendfunc1, int blendfunc2, rtexture_t *texture, rtexture_t *fogtexture, qboolean depthdisable, qboolean depthshort, const vec3_t origin, const vec3_t left, const vec3_t up, float scalex1, float scalex2, float scaley1, float scaley2, float cr, float cg, float cb, float ca); extern mempool_t *r_main_mempool; -extern int rsurface_array_size; -extern float *rsurface_array_modelvertex3f; -extern float *rsurface_array_modelsvector3f; -extern float *rsurface_array_modeltvector3f; -extern float *rsurface_array_modelnormal3f; -extern float *rsurface_array_deformedvertex3f; -extern float *rsurface_array_deformedsvector3f; -extern float *rsurface_array_deformedtvector3f; -extern float *rsurface_array_deformednormal3f; -extern float *rsurface_array_color4f; -extern float *rsurface_array_texcoord3f; - typedef enum rsurfmode_e { RSURFMODE_NONE, @@ -205,20 +202,146 @@ typedef enum rsurfmode_e } rsurfmode_t; -extern float *rsurface_vertex3f; -extern float *rsurface_svector3f; -extern float *rsurface_tvector3f; -extern float *rsurface_normal3f; -extern float *rsurface_lightmapcolor4f; -extern vec3_t rsurface_modelorg; -extern qboolean rsurface_generatedvertex; -extern const entity_render_t *rsurface_entity; -extern const model_t *rsurface_model; -extern texture_t *rsurface_texture; -extern rtexture_t *rsurface_lightmaptexture; -extern rsurfmode_t rsurface_mode; - -void RSurf_ActiveEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents); +typedef struct rsurfacestate_s +{ + // processing buffers + int array_size; + float *array_modelvertex3f; + float *array_modelsvector3f; + float *array_modeltvector3f; + float *array_modelnormal3f; + float *array_deformedvertex3f; + float *array_deformedsvector3f; + float *array_deformedtvector3f; + float *array_deformednormal3f; + float *array_generatedtexcoordtexture2f; + float *array_color4f; + float *array_texcoord3f; + + // current model array pointers + // these may point to processing buffers if model is animated, + // otherwise they point to static data. + // these are not directly used for rendering, they are just another level + // of processing + // + // these either point at array_model* buffers (if the model is animated) + // or the model->surfmesh.data_* buffers (if the model is not animated) + // + // these are only set when an entity render begins, they do not change on + // a per surface basis. + // + // this indicates the model* arrays are pointed at array_model* buffers + // (in other words, the model has been animated in software) + qboolean generatedvertex; + float *modelvertex3f; + int modelvertex3f_bufferobject; + size_t modelvertex3f_bufferoffset; + float *modelsvector3f; + int modelsvector3f_bufferobject; + size_t modelsvector3f_bufferoffset; + float *modeltvector3f; + int modeltvector3f_bufferobject; + size_t modeltvector3f_bufferoffset; + float *modelnormal3f; + int modelnormal3f_bufferobject; + size_t modelnormal3f_bufferoffset; + float *modellightmapcolor4f; + int modellightmapcolor4f_bufferobject; + size_t modellightmapcolor4f_bufferoffset; + float *modeltexcoordtexture2f; + int modeltexcoordtexture2f_bufferobject; + size_t modeltexcoordtexture2f_bufferoffset; + float *modeltexcoordlightmap2f; + int modeltexcoordlightmap2f_bufferobject; + size_t modeltexcoordlightmap2f_bufferoffset; + int *modelelement3i; + int modelelement3i_bufferobject; + int *modellightmapoffsets; + int modelnum_vertices; + int modelnum_triangles; + msurface_t *modelsurfaces; + // current rendering array pointers + // these may point to any of several different buffers depending on how + // much processing was needed to prepare this model for rendering + // these usually equal the model* pointers, they only differ if + // deformvertexes is used in a q3 shader, and consequently these can + // change on a per-surface basis (according to rsurface.texture) + // + // the exception is the color array which is often generated based on + // colormod, alpha fading, and fogging, it may also come from q3bsp vertex + // lighting of certain surfaces + float *vertex3f; + int vertex3f_bufferobject; + size_t vertex3f_bufferoffset; + float *svector3f; + int svector3f_bufferobject; + size_t svector3f_bufferoffset; + float *tvector3f; + int tvector3f_bufferobject; + size_t tvector3f_bufferoffset; + float *normal3f; + int normal3f_bufferobject; + size_t normal3f_bufferoffset; + float *lightmapcolor4f; + int lightmapcolor4f_bufferobject; + size_t lightmapcolor4f_bufferoffset; + float *texcoordtexture2f; + int texcoordtexture2f_bufferobject; + size_t texcoordtexture2f_bufferoffset; + float *texcoordlightmap2f; + int texcoordlightmap2f_bufferobject; + size_t texcoordlightmap2f_bufferoffset; + // transform matrices to render this entity and effects on this entity + matrix4x4_t matrix; + matrix4x4_t inversematrix; + // animation blending state from entity + frameblend_t frameblend[4]; + // directional model shading state from entity + vec3_t modellight_ambient; + vec3_t modellight_diffuse; + vec3_t modellight_lightdir; + // colormapping state from entity (these are black if colormapping is off) + vec3_t colormap_pantscolor; + vec3_t colormap_shirtcolor; + // view location in model space + vec3_t modelorg; // TODO: rename this + // current texture in batching code + texture_t *texture; + // whether lightmapping is active on this batch + // (otherwise vertex colored) + qboolean uselightmaptexture; + // one of the RSURFMODE_ values + rsurfmode_t mode; + // type of vertex lighting being used on this batch + int lightmode; // 0 = lightmap or fullbright, 1 = color array from q3bsp, 2 = vertex shaded model + + // rtlight rendering + // light currently being rendered + rtlight_t *rtlight; + // current light's cull box (copied out of an rtlight or calculated by GetLightInfo) + vec3_t rtlight_cullmins; + vec3_t rtlight_cullmaxs; + // current light's culling planes + int rtlight_numfrustumplanes; + mplane_t rtlight_frustumplanes[12+6+6]; // see R_Shadow_ComputeShadowCasterCullingPlanes + + // this is the location of the light in entity space + vec3_t entitylightorigin; + // this transforms entity coordinates to light filter cubemap coordinates + // (also often used for other purposes) + matrix4x4_t entitytolight; + // based on entitytolight this transforms -1 to +1 to 0 to 1 for purposes + // of attenuation texturing in full 3D (Z result often ignored) + matrix4x4_t entitytoattenuationxyz; + // this transforms only the Z to S, and T is always 0.5 + matrix4x4_t entitytoattenuationz; +} +rsurfacestate_t; + +extern rsurfacestate_t rsurface; + +void RSurf_ActiveWorldEntity(void); +void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents); void RSurf_CleanUp(void); void R_Mesh_ResizeArrays(int newvertices); @@ -229,7 +352,8 @@ struct msurface_s; void R_UpdateTextureInfo(const entity_render_t *ent, texture_t *t); void R_UpdateAllTextureInfo(entity_render_t *ent); void R_QueueTextureSurfaceList(int texturenumsurfaces, msurface_t **texturesurfacelist); -void R_DrawSurfaces(entity_render_t *ent, qboolean skysurfaces); +void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly); +void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly); void RSurf_PrepareVerticesForBatch(qboolean generatenormals, qboolean generatetangents, int texturenumsurfaces, msurface_t **texturesurfacelist); void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacelist); @@ -241,13 +365,15 @@ void RSurf_DrawBatch_Simple(int texturenumsurfaces, msurface_t **texturesurfacel #define SHADERPERMUTATION_GLOW (1<<4) // (lightmap) blend in an additive glow texture #define SHADERPERMUTATION_FOG (1<<5) // tint the color by fog color or black if using additive blend mode #define SHADERPERMUTATION_COLORMAPPING (1<<6) // indicates this is a colormapped skin -#define SHADERPERMUTATION_SPECULAR (1<<7) // (lightsource or deluxemapping) render specular effects -#define SHADERPERMUTATION_CUBEFILTER (1<<8) // (lightsource) use cubemap light filter -#define SHADERPERMUTATION_OFFSETMAPPING (1<<9) // adjust texcoords to roughly simulate a displacement mapped surface -#define SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING (1<<10) // adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!) +#define SHADERPERMUTATION_DIFFUSE (1<<7) // (lightsource) whether to use directional shading +#define SHADERPERMUTATION_CONTRASTBOOST (1<<8) // r_glsl_contrastboost boosts the contrast at low color levels (similar to gamma) +#define SHADERPERMUTATION_SPECULAR (1<<9) // (lightsource or deluxemapping) render specular effects +#define SHADERPERMUTATION_CUBEFILTER (1<<10) // (lightsource) use cubemap light filter +#define SHADERPERMUTATION_OFFSETMAPPING (1<<11) // adjust texcoords to roughly simulate a displacement mapped surface +#define SHADERPERMUTATION_OFFSETMAPPING_RELIEFMAPPING (1<<12) // adjust texcoords to accurately simulate a displacement mapped surface (requires OFFSETMAPPING to also be set!) -#define SHADERPERMUTATION_COUNT (1<<11) // how many permutations are possible -#define SHADERPERMUTATION_COUNTMASK (SHADERPERMUTATION_COUNT - 1) // mask of valid indexing bits for r_glsl_permutations[] array +#define SHADERPERMUTATION_MAX (1<<13) // how many permutations are possible +#define SHADERPERMUTATION_MASK (SHADERPERMUTATION_MAX - 1) // mask of valid indexing bits for r_glsl_permutations[] array // these are additional flags used only by R_GLSL_CompilePermutation #define SHADERPERMUTATION_USES_VERTEXSHADER (1<<29) @@ -264,6 +390,7 @@ typedef struct r_glsl_permutation_s int loc_Texture_Color; int loc_Texture_Gloss; int loc_Texture_Cube; + int loc_Texture_Attenuation; int loc_Texture_FogMask; int loc_Texture_Pants; int loc_Texture_Shirt; @@ -282,22 +409,23 @@ typedef struct r_glsl_permutation_s int loc_SpecularScale; int loc_SpecularPower; int loc_GlowScale; - int loc_SceneBrightness; + int loc_SceneBrightness; // or: Scenebrightness * ContrastBoost int loc_OffsetMapping_Scale; int loc_AmbientColor; int loc_DiffuseColor; int loc_SpecularColor; int loc_LightDir; + int loc_ContrastBoostCoeff; // 1 - 1/ContrastBoost } r_glsl_permutation_t; // information about each possible shader permutation -extern r_glsl_permutation_t r_glsl_permutations[SHADERPERMUTATION_COUNT]; +extern r_glsl_permutation_t r_glsl_permutations[SHADERPERMUTATION_MAX]; // currently selected permutation extern r_glsl_permutation_t *r_glsl_permutation; void R_GLSL_CompilePermutation(const char *shaderfilename, int permutation); -int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting); +int R_SetupSurfaceShader(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale); void R_SwitchSurfaceShader(int permutation); #endif