eukara/fteqw
1
0
Fork 0
forked from fte/fteqw
Code Pull requests Activity
fteqw/engine/client/render.h

798 lines
32 KiB
C
Raw Blame History

/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
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.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// refresh.h -- public interface to refresh functions
// default soldier colors
#define TOP_DEFAULT 1
#define BOTTOM_DEFAULT 6
#define TOP_RANGE (TOP_DEFAULT<<4)
#define BOTTOM_RANGE (BOTTOM_DEFAULT<<4)
struct msurface_s;
struct batch_s;
struct model_s;
struct texnums_s;
struct texture_s;
static const texid_t r_nulltex = NULL;
//GLES2 requires GL_UNSIGNED_SHORT (gles3 or GL_OES_element_index_uint relax this requirement)
//geforce4 only does shorts. gffx can do ints, but with a performance hit (like most things on that gpu)
//ati is generally more capable, but generally also has a smaller market share
//desktop-gl will generally cope with ints, but expect a performance hit from that with old gpus (so we don't bother)
//vulkan+dx10 can cope with ints, but might be 24bit
//either way, all renderers in the same build need to use the same thing.
#ifndef sizeof_index_t
#ifdef VERTEXINDEXBYTES //maybe set in config_*.h
#define sizeof_index_t VERTEXINDEXBYTES
#elif (defined(GLQUAKE) && defined(HAVE_LEGACY)) || defined(MINIMAL) || defined(D3D8QUAKE) || defined(D3D9QUAKE) || defined(ANDROID) || defined(FTE_TARGET_WEB)
#define sizeof_index_t 2
#endif
#endif
#if sizeof_index_t == 2
#define GL_INDEX_TYPE GL_UNSIGNED_SHORT
#define D3DFMT_QINDEX D3DFMT_INDEX16
#define DXGI_FORMAT_INDEX_UINT DXGI_FORMAT_R16_UINT
#define VK_INDEX_TYPE VK_INDEX_TYPE_UINT16
typedef unsigned short index_t;
#define MAX_INDICIES 0xffffu
#else
#undef sizeof_index_t
#define sizeof_index_t 4
#define GL_INDEX_TYPE GL_UNSIGNED_INT
#define D3DFMT_QINDEX D3DFMT_INDEX32
#define DXGI_FORMAT_INDEX_UINT DXGI_FORMAT_R32_UINT
#define VK_INDEX_TYPE VK_INDEX_TYPE_UINT32
typedef unsigned int index_t;
#define MAX_INDICIES 0x00ffffffu
#endif
//=============================================================================
//the eye doesn't see different colours in the same proportion.
//must add to slightly less than 1
#define NTSC_RED 0.299
#define NTSC_GREEN 0.587
#define NTSC_BLUE 0.114
#define NTSC_SUM (NTSC_RED + NTSC_GREEN + NTSC_BLUE)
typedef enum {
RT_MODEL,
RT_POLY,
RT_SPRITE,
RT_BEAM,
RT_RAIL_CORE,
RT_RAIL_RINGS,
RT_LIGHTNING,
RT_PORTALSURFACE, // doesn't draw anything, just info for portals
//q3 ones stop here.
//fte ones start here
RT_PORTALCAMERA, // an alternative to RT_PORTALSURFACE.
RT_MAX_REF_ENTITY_TYPE
} refEntityType_t;
typedef unsigned int skinid_t; //skin 0 is 'unused'
struct dlight_s;
typedef struct entity_s
{
//FIXME: instancing somehow. separate visentity+visinstance. only viable with full glsl though.
//will need to generate a vbo somehow for the instances.
int keynum; // for matching entities in different frames
vec3_t origin;
vec3_t angles; // fixme: should be redundant.
vec3_t axis[3];
vec4_t shaderRGBAf; /*colormod+alpha, available for shaders to mix*/
float shaderTime; /*timestamp, for syncing shader times to spawns*/
vec3_t glowmod; /*meant to be a multiplier for the fullbrights*/
int light_known; /*bsp lighting has been calced*/
vec3_t light_avg; /*midpoint level*/
vec3_t light_range; /*avg + this = max, avg - this = min*/
vec3_t light_dir;
vec3_t oldorigin; /*for q2/q3 beams*/
struct model_s *model; // NULL = no model
int skinnum; // for Alias models
skinid_t customskin; // quake3 style skins
int playerindex; //for qw skins
int topcolour; //colourmapping
int bottomcolour; //colourmapping
#ifdef HEXEN2
int h2playerclass; //hexen2's quirky colourmapping
#endif
// struct efrag_s *efrag; // linked list of efrags (FIXME)
// int visframe; // last frame this entity was
// found in an active leaf
// only used for static objects
// int dlightframe; // dynamic lighting
// dlightbitmask_t dlightbits;
// FIXME: could turn these into a union
// int trivial_accept;
// struct mnode_s *topnode; // for bmodels, first world node
// that splits bmodel, or NULL if
// not split
framestate_t framestate;
int flags;
refEntityType_t rtype;
float rotation;
struct shader_s *forcedshader;
pvscache_t pvscache; //for culling of csqc ents.
#ifdef PEXT_SCALE
float scale;
#endif
#ifdef PEXT_FATNESS
float fatness;
#endif
#ifdef HEXEN2
int drawflags;
int abslight;
#endif
} entity_t;
#define MAX_GEOMSETS 32
#define Q1UNSPECIFIED 0x00ffffff //0xffRRGGBB or 0x0000000V are both valid values. so this is an otherwise-illegal value to say its not been set.
typedef struct
{
int refcount;
char skinname[MAX_QPATH];
int nummappings;
int maxmappings;
qbyte geomset[MAX_GEOMSETS]; //allows selecting a single set of geometry from alternatives. this might be a can of worms.
#ifdef QWSKINS
char qwskinname[MAX_QPATH];
struct qwskin_s *qwskin;
unsigned int q1upper; //Q1UNSPECIFIED
unsigned int q1lower; //Q1UNSPECIFIED
#endif
struct
{
char surface[MAX_QPATH];
shader_t *shader;
texnums_t texnums;
int needsfree; //which textures need to be freed.
} mappings[1];
} skinfile_t;
// plane_t structure
typedef struct mplane_s
{
vec3_t normal;
float dist;
qbyte type; // for texture axis selection and fast side tests
qbyte signbits; // signx + signy<<1 + signz<<1
qbyte pad[2];
} mplane_t;
#define MAXFRUSTUMPLANES 7 //4 side, 1 near, 1 far (fog), 1 water plane.
typedef struct
{
//note: uniforms expect specific padding/ordering. be really careful with reordering this
vec3_t colour; //w_fog[0].xyz
float alpha; //w_fog[0].w scales clamped fog value
float density; //w_fog[1].x egads, everyone has a different opinion.
float depthbias; //w_fog[1].y distance until the fog actually starts
float glslpad1; //w_fog[1].z
float glslpad2; //w_fog[1].w
// float start;
// float end;
// float height;
// float fadedepth;
float time; //timestamp for when its current.
} fogstate_t;
void CL_BlendFog(fogstate_t *result, fogstate_t *oldf, float time, fogstate_t *newf);
void CL_ResetFog(int fogtype);
typedef enum {
STEREO_OFF,
STEREO_QUAD,
STEREO_RED_CYAN,
STEREO_RED_BLUE,
STEREO_RED_GREEN,
STEREO_CROSSEYED,
//these are internal methods and do not form part of any public API
STEREO_LEFTONLY,
STEREO_RIGHTONLY
} stereomethod_t;
typedef enum
{
PROJ_STANDARD = 0,
PROJ_STEREOGRAPHIC = 1, //aka panini
PROJ_FISHEYE = 2, //standard fisheye
PROJ_PANORAMA = 3, //for nice panoramas
PROJ_LAEA = 4, //lambert azimuthal equal-area
PROJ_EQUIRECTANGULAR = 5 //projects a sphere into 2d. used by vr screenshots.
} qprojection_t;
typedef struct {
char texname[MAX_QPATH];
} rtname_t;
#define R_MAX_RENDERTARGETS 8
#ifndef R_MAX_RECURSE
#define R_MAX_RECURSE 6
#endif
#define RDFD_FOV 1
typedef struct refdef_s
{
vrect_t grect; // game rectangle. fullscreen except for csqc/splitscreen/hud.
vrect_t vrect; // subwindow in grect for 3d view. equal to grect if no hud.
vec3_t pvsorigin; /*render the view using this point for pvs (useful for mirror views)*/
vec3_t vieworg; /*logical view center*/
vec3_t viewangles;
vec3_t viewaxis[3]; /*forward, left, up (NOT RIGHT)*/
vec3_t eyeoffset; /*world space, for vr screenies*/
vec2_t projectionoffset; /*for off-centre rendering*/
qboolean base_known; /*otherwise we do some fallback behaviour (ie: viewangles.0y0 and forcing input_angles)*/
vec3_t base_angles, base_origin; /*for vr output, overrides per-eye viewangles according to that eye's matrix.*/
vec3_t weaponmatrix[4]; /*forward/left/up/origin*/
vec3_t weaponmatrix_bob[4]; /*forward/left/up/origin*/
float fov_x, fov_y, afov;
float fovv_x, fovv_y; //viewmodel fovs
float mindist, maxdist; //maxdist may be 0, for 'infinite', in which case mindist probably isn't valid either.
qboolean drawsbar;
qboolean drawcrosshair;
int flags; //(Q2)RDF_ flags
int dirty;
playerview_t *playerview;
// int currentplayernum;
float time;
// float waterheight; //updated by the renderer. stuff sitting at this height generate ripple effects
float m_projection_std[16]; //projection matrix for normal stuff
float m_projection_view[16]; //projection matrix for the viewmodel. because people are weird.
float m_view[16];
qbyte *scenevis; /*this is the vis that's currently being draw*/
int *sceneareas; /*this is the area info for the camera (should normally be count+one area, but could be two areas near an opaque water plane)*/
mplane_t frustum[MAXFRUSTUMPLANES];
int frustum_numworldplanes; //all but far, which isn't culled because this wouldn't cover the entire screen.
int frustum_numplanes; //includes far plane (which is reduced with fog).
fogstate_t globalfog;
float hdr_value;
vec3_t skyroom_pos; /*the camera position for sky rooms*/
vec4_t skyroom_spin; /*the camera spin for sky rooms*/
qboolean skyroom_enabled; /*whether a skyroom position is defined*/
int firstvisedict; /*so we can skip visedicts in skies*/
pxrect_t pxrect; /*vrect, but in pixels rather than virtual coords*/
qboolean externalview; /*draw external models and not viewmodels*/
int recurse; /*in a mirror/portal/half way through drawing something else*/
qboolean forcevis; /*if true, vis comes from the forcedvis field instead of recalculated*/
unsigned int flipcull; /*reflected/flipped view, requires inverted culling (should be set to SHADER_CULL_FLIPPED or 0 - its implemented as a xor)*/
unsigned int colourmask; /*shaderbits mask. anything not here will be forced to 0. this is for red/green type stereo*/
qboolean useperspective; /*not orthographic*/
stereomethod_t stereomethod;
rtname_t rt_destcolour[R_MAX_RENDERTARGETS]; /*used for 2d. written by 3d*/
rtname_t rt_sourcecolour; /*read by 2d. not used for 3d. */
rtname_t rt_depth; /*read by 2d. used by 3d (renderbuffer used if not set)*/
rtname_t rt_ripplemap; /*read by 2d. used by 3d (internal ripplemap buffer used if not set)*/
rtname_t nearenvmap; /*provides a fallback endmap cubemap to render with*/
qbyte *forcedvis; /*set if forcevis is set*/
qboolean areabitsknown;
qbyte areabits[MAX_MAP_AREA_BYTES];
vec4_t userdata[16]; /*for custom glsl*/
qboolean warndraw; /*buggy gamecode likes drawing outside of te drawing logic*/
} refdef_t;
extern refdef_t r_refdef;
extern vec3_t r_origin, vpn, vright, vup;
extern struct texture_s *r_notexture_mip;
extern entity_t r_worldentity;
void BE_GenModelBatches(struct batch_s **batches, const struct dlight_s *dl, unsigned int bemode, const qbyte *worldpvs, const int *worldareas); //if dl, filters based upon the dlight.
//gl_alias.c
void R_GAliasFlushSkinCache(qboolean final);
void R_GAlias_DrawBatch(struct batch_s *batch);
void R_GAlias_GenerateBatches(entity_t *e, struct batch_s **batches);
void R_LightArraysByte_BGR(const entity_t *entity, vecV_t *coords, byte_vec4_t *colours, int vertcount, vec3_t *normals, qboolean colormod);
void R_LightArrays(const entity_t *entity, vecV_t *coords, avec4_t *colours, int vertcount, vec3_t *normals, float scale, qboolean colormod);
qboolean R_DrawSkyChain (struct batch_s *batch); /*called from the backend, and calls back into it*/
void R_InitSky (shader_t *shader, const char *skyname, uploadfmt_t fmt, qbyte *src, unsigned int width, unsigned int height); /*generate q1 sky texnums*/
void R_Clutter_Emit(struct batch_s **batches);
void R_Clutter_Purge(void);
//r_surf.c
void Surf_NewMap (struct model_s *worldmodel);
void Surf_PreNewMap(void);
void Surf_SetupFrame(void); //determine pvs+viewcontents
void Surf_DrawWorld(void);
void Surf_GenBrushBatches(struct batch_s **batches, entity_t *ent);
void Surf_StainSurf(struct msurface_s *surf, float *parms);
void Surf_AddStain(vec3_t org, float red, float green, float blue, float radius);
void Surf_LessenStains(void);
void Surf_WipeStains(void);
void Surf_DeInit(void);
void Surf_Clear(struct model_s *mod);
void Surf_BuildLightmaps(void); //enables Surf_BuildModelLightmaps, calls it for each bsp.
void Surf_ClearSceneCache(void); //stops Surf_BuildModelLightmaps from working.
void Surf_BuildModelLightmaps (struct model_s *m); //rebuild lightmaps for a single bsp. beware of submodels.
void Surf_RenderDynamicLightmaps (struct msurface_s *fa);
void Surf_RenderAmbientLightmaps (struct msurface_s *fa, int ambient);
int Surf_LightmapShift (struct model_s *model);
#define LMBLOCK_SIZE_MAX 2048 //single axis
typedef struct glRect_s {
unsigned short l,t,r,b;
} glRect_t;
typedef unsigned char stmap;
struct mesh_s;
typedef struct {
texid_t lightmap_texture;
qboolean modified; //data was changed. consult rectchange to see the bounds.
qboolean external; //the data was loaded from a file (q3bsp feature where we shouldn't be blending lightmaps at all)
qboolean hasdeluxe; //says that the next lightmap index contains deluxemap info
uploadfmt_t fmt; //texture format that we're using
qbyte pixbytes; //yes, this means no compressed formats.
int width;
int height;
glRect_t rectchange;
qbyte *lightmaps; //[pixbytes*LMBLOCK_WIDTH*LMBLOCK_HEIGHT];
stmap *stainmaps; //[3*LMBLOCK_WIDTH*LMBLOCK_HEIGHT]; //rgb no a. added to lightmap for added (hopefully) speed.
#ifdef GLQUAKE
int pbo_handle; //when set, lightmaps is a persistently mapped write-only pbo for us to scribble data into, ready to be copied to the actual texture without waiting for glTexSubImage to complete.
#endif
} lightmapinfo_t;
extern lightmapinfo_t **lightmap;
extern int numlightmaps;
void QDECL Surf_RebuildLightmap_Callback (struct cvar_s *var, char *oldvalue);
void R_Sky_Register(void);
void R_SkyShutdown(void);
void R_SetSky(const char *skyname);
texid_t R_GetDefaultEnvmap(void);
#if defined(GLQUAKE)
void GLR_Init (void);
void GLR_InitTextures (void);
void GLR_InitEfrags (void);
void GLR_RenderView (void); // must set r_refdef first
// called whenever r_refdef or vid change
void GLR_DrawPortal(struct batch_s *batch, struct batch_s **blist, struct batch_s *depthmasklist[2], int portaltype);
void GLR_PushDlights (void);
void GLR_DrawWaterSurfaces (void);
void GLVID_DeInit (void);
void GLR_DeInit (void);
void GLSCR_DeInit (void);
void GLVID_Console_Resize(void);
#endif
int R_LightPoint (vec3_t p);
void R_RenderDlights (void);
typedef struct
{
int allocated[LMBLOCK_SIZE_MAX];
int firstlm;
int lmnum;
unsigned int width;
unsigned int height;
qboolean deluxe;
} lmalloc_t;
void Mod_LightmapAllocInit(lmalloc_t *lmallocator, qboolean hasdeluxe, unsigned int width, unsigned int height, int firstlm); //firstlm is for debugging stray lightmap indexes
//void Mod_LightmapAllocDone(lmalloc_t *lmallocator, model_t *mod);
void Mod_LightmapAllocBlock(lmalloc_t *lmallocator, int w, int h, unsigned short *x, unsigned short *y, int *tnum);
enum imageflags
{
/*warning: many of these flags only apply the first time it is requested*/
IF_CLAMP = 1<<0, //disable texture coord wrapping.
IF_NOMIPMAP = 1<<1, //disable mipmaps.
IF_NEAREST = 1<<2, //force nearest
IF_LINEAR = 1<<3, //force linear
IF_UIPIC = 1<<4, //subject to texturemode2d
//IF_DEPTHCMD = 1<<5, //Reserved for d3d11
IF_SRGB = 1<<6, //texture data is srgb (read-as-linear)
/*WARNING: If the above are changed, be sure to change shader pass flags*/
IF_NOPICMIP = 1<<7,
IF_NOALPHA = 1<<8, /*hint rather than requirement*/
IF_NOGAMMA = 1<<9, /*do not apply texture-based gamma*/
IF_TEXTYPEMASK = (1<<10) | (1<<11) | (1<<12), /*0=2d, 1=3d, 2=cubeface, 3=2d array texture*/
#define IF_TEXTYPESHIFT 10
#define IF_TEXTYPE_2D (PTI_2D<<IF_TEXTYPESHIFT)
#define IF_TEXTYPE_3D (PTI_3D<<IF_TEXTYPESHIFT)
#define IF_TEXTYPE_CUBE (PTI_CUBE<<IF_TEXTYPESHIFT)
#define IF_TEXTYPE_2D_ARRAY (PTI_2D_ARRAY<<IF_TEXTYPESHIFT)
#define IF_TEXTYPE_CUBE_ARRAY (PTI_CUBE_ARRAY<<IF_TEXTYPESHIFT)
#define IF_TEXTYPE_ANY (PTI_ANY<<IF_TEXTYPESHIFT)
IF_MIPCAP = 1<<13, //allow the use of d_mipcap
IF_PREMULTIPLYALPHA = 1<<14, //rgb *= alpha
IF_UNUSED15 = 1<<15, //
IF_UNUSED16 = 1<<16, //
IF_INEXACT = 1<<17, //subdir info isn't to be used for matching
IF_WORLDTEX = 1<<18, //gl_picmip_world
IF_SPRITETEX = 1<<19, //gl_picmip_sprites
IF_NOSRGB = 1<<20, //ignore srgb when loading. this is guarenteed to be linear, for normalmaps etc.
IF_PALETTIZE = 1<<21, //convert+load it as an RTI_P8 texture for the current palette/colourmap
IF_NOPURGE = 1<<22, //texture is not flushed when no more shaders refer to it (for C code that holds a permanant reference to it - still purged on vid_reloads though)
IF_HIGHPRIORITY = 1<<23, //pushed to start of worker queue instead of end...
IF_LOWPRIORITY = 1<<24, //
IF_LOADNOW = 1<<25, /*hit the disk now, and delay the gl load until its actually needed. this is used only so that the width+height are known in advance. valid on worker threads.*/
IF_NOPCX = 1<<26, /*block pcx format. meaning qw skins can use team colours and cropping*/
IF_TRYBUMP = 1<<27, /*attempt to load _bump if the specified _norm texture wasn't found*/
IF_RENDERTARGET = 1<<28, /*never loaded from disk, loading can't fail*/
IF_EXACTEXTENSION = 1<<29, /*don't mangle extensions, use what is specified and ONLY that*/
IF_NOREPLACE = 1<<30, /*don't load a replacement, for some reason*/
IF_NOWORKER = 1u<<31 /*don't pass the work to a loader thread. this gives fully synchronous loading. only valid from the main thread.*/
};
#define R_LoadTexture8(id,w,h,d,f,t) Image_GetTexture(id, NULL, f, d, NULL, w, h, t?TF_TRANS8:TF_SOLID8)
#define R_LoadTexture32(id,w,h,d,f) Image_GetTexture(id, NULL, f, d, NULL, w, h, TF_RGBA32)
#define R_LoadTextureFB(id,w,h,d,f) Image_GetTexture(id, NULL, f, d, NULL, w, h, TF_TRANS8_FULLBRIGHT)
#define R_LoadTexture(id,w,h,fmt,d,fl) Image_GetTexture(id, NULL, fl, d, NULL, w, h, fmt)
image_t *Image_TextureIsValid(qintptr_t address);
image_t *Image_FindTexture (const char *identifier, const char *subpath, unsigned int flags);
image_t *Image_CreateTexture(const char *identifier, const char *subpath, unsigned int flags);
image_t *QDECL Image_GetTexture (const char *identifier, const char *subpath, unsigned int flags, void *fallbackdata, void *fallbackpalette, int fallbackwidth, int fallbackheight, uploadfmt_t fallbackfmt);
qboolean Image_UnloadTexture(image_t *tex); //true if it did something.
void Image_DestroyTexture (image_t *tex);
qboolean Image_LoadTextureFromMemory(texid_t tex, int flags, const char *iname, const char *fname, qbyte *filedata, int filesize); //intended really for worker threads, but should be fine from the main thread too
qboolean Image_LocateHighResTexture(image_t *tex, flocation_t *bestloc, char *bestname, size_t bestnamesize, unsigned int *bestflags);
void Image_Upload (texid_t tex, uploadfmt_t fmt, void *data, void *palette, int width, int height, int depth, unsigned int flags);
void Image_Purge(void); //purge any textures which are not needed any more (releases memory, but doesn't give null pointers).
void Image_Init(void);
void Image_Shutdown(void);
void Image_PrintInputFormatVersions(void); //for version info
qboolean Image_WriteKTXFile(const char *filename, enum fs_relative fsroot, struct pendingtextureinfo *mips);
qboolean Image_WriteDDSFile(const char *filename, enum fs_relative fsroot, struct pendingtextureinfo *mips);
void Image_BlockSizeForEncoding(uploadfmt_t encoding, unsigned int *blockbytes, unsigned int *blockwidth, unsigned int *blockheight, unsigned int *blockdepth);
const char *Image_FormatName(uploadfmt_t encoding);
qboolean Image_FormatHasAlpha(uploadfmt_t encoding);
image_t *Image_LoadTexture (const char *identifier, int width, int height, uploadfmt_t fmt, void *data, unsigned int flags);
struct pendingtextureinfo *Image_LoadMipsFromMemory(int flags, const char *iname, const char *fname, qbyte *filedata, int filesize);
void Image_ChangeFormat(struct pendingtextureinfo *mips, qboolean *allowedformats, uploadfmt_t origfmt, const char *imagename);
void Image_Premultiply(struct pendingtextureinfo *mips);
void *Image_FlipImage(const void *inbuffer, void *outbuffer, int *inoutwidth, int *inoutheight, int pixelbytes, qboolean flipx, qboolean flipy, qboolean flipd);
typedef struct
{
const char *loadername;
size_t pendingtextureinfosize;
qboolean canloadcubemaps;
struct pendingtextureinfo *(*ReadImageFile)(unsigned int imgflags, const char *fname, qbyte *filedata, size_t filesize);
#define plugimageloaderfuncs_name "ImageLoader"
} plugimageloaderfuncs_t;
qboolean Image_RegisterLoader(void *module, plugimageloaderfuncs_t *loader);
#ifdef D3D8QUAKE
void D3D8_Set2D (void);
void D3D8_UpdateFiltering (image_t *imagelist, int filtermip[3], int filterpic[3], int mipcap[2], float anis);
qboolean D3D8_LoadTextureMips (texid_t tex, const struct pendingtextureinfo *mips);
void D3D8_DestroyTexture (texid_t tex);
#endif
#ifdef D3D9QUAKE
void D3D9_Set2D (void);
void D3D9_UpdateFiltering (image_t *imagelist, int filtermip[3], int filterpic[3], int mipcap[2], float lodbias, float anis);
qboolean D3D9_LoadTextureMips (texid_t tex, const struct pendingtextureinfo *mips);
void D3D9_DestroyTexture (texid_t tex);
#endif
#ifdef D3D11QUAKE
void D3D11_UpdateFiltering (image_t *imagelist, int filtermip[3], int filterpic[3], int mipcap[2], float lodbias, float anis);
qboolean D3D11_LoadTextureMips (texid_t tex, const struct pendingtextureinfo *mips);
void D3D11_DestroyTexture (texid_t tex);
#endif
//extern int image_width, image_height;
texid_t R_LoadReplacementTexture(const char *name, const char *subpath, unsigned int flags, void *lowres, int lowreswidth, int lowresheight, uploadfmt_t fmt);
texid_tf R_LoadHiResTexture(const char *name, const char *subpath, unsigned int flags);
texid_tf R_LoadBumpmapTexture(const char *name, const char *subpath);
void R_LoadNumberedLightTexture(struct dlight_s *dl, int cubetexnum);
extern texid_t particletexture;
extern texid_t particlecqtexture;
extern texid_t explosiontexture;
extern texid_t balltexture;
extern texid_t beamtexture;
extern texid_t ptritexture;
skinid_t Mod_RegisterSkinFile(const char *skinname);
skinid_t Mod_ReadSkinFile(const char *skinname, const char *skintext);
void Mod_WipeSkin(skinid_t id, qboolean force);
skinfile_t *Mod_LookupSkin(skinid_t id);
void Mod_Init (qboolean initial);
void Mod_Shutdown (qboolean final);
int Mod_TagNumForName(struct model_s *model, const char *name, int firsttag);
int Mod_SkinNumForName(struct model_s *model, int surfaceidx, const char *name);
int Mod_FrameNumForName(struct model_s *model, int surfaceidx, const char *name);
int Mod_FrameNumForAction(struct model_s *model, int surfaceidx, int actionid);
float Mod_GetFrameDuration(struct model_s *model, int surfaceidx, int frameno);
void Mod_ResortShaders(void);
void Mod_ClearAll (void);
struct model_s *Mod_FindName (const char *name);
void *Mod_Extradata (struct model_s *mod); // handles caching
void Mod_TouchModel (const char *name);
void Mod_RebuildLightmaps (void);
void Mod_NowLoadExternal(struct model_s *loadmodel);
void GLR_LoadSkys (void);
void R_BloomRegister(void);
int Mod_RegisterModelFormatText(void *module, const char *formatname, char *magictext, qboolean (QDECL *load) (struct model_s *mod, void *buffer, size_t fsize));
int Mod_RegisterModelFormatMagic(void *module, const char *formatname, qbyte *magic, size_t magicsize, qboolean (QDECL *load) (struct model_s *mod, void *buffer, size_t fsize));
void Mod_UnRegisterModelFormat(void *module, int idx);
void Mod_UnRegisterAllModelFormats(void *module);
void Mod_ModelLoaded(void *ctx, void *data, size_t a, size_t b);
void Mod_SubmodelLoaded(struct model_s *mod, int state);
#ifdef RUNTIMELIGHTING
struct relight_ctx_s;
struct llightinfo_s;
void LightPlane (struct relight_ctx_s *ctx, struct llightinfo_s *threadctx, lightstyleindex_t surf_styles[4], unsigned int *surf_expsamples, qbyte *surf_rgbsamples, qbyte *surf_deluxesamples, vec4_t surf_plane, vec4_t surf_texplanes[2], vec2_t exactmins, vec2_t exactmaxs, int texmins[2], int texsize[2], float lmscale); //special version that doesn't know what a face is or anything.
struct relight_ctx_s *LightStartup(struct relight_ctx_s *ctx, struct model_s *model, qboolean shadows, qboolean skiplit);
void LightReloadEntities(struct relight_ctx_s *ctx, const char *entstring, qboolean ignorestyles);
void LightShutdown(struct relight_ctx_s *ctx);
extern const size_t lightthreadctxsize;
qboolean RelightSetup (struct model_s *model, size_t lightsamples, qboolean generatelit);
void RelightThink (void);
const char *RelightGetProgress(float *progress); //reports filename and progress
void RelightTerminate(struct model_s *mod); //NULL acts as a wildcard
#endif
struct builddata_s
{
void (*buildfunc)(struct model_s *mod, struct msurface_s *surf, struct builddata_s *bd);
qboolean paintlightmaps;
void *facedata;
};
void Mod_Batches_Build(struct model_s *mod, struct builddata_s *bd);
shader_t *Mod_RegisterBasicShader(struct model_s *mod, const char *texname, unsigned int usageflags, const char *shadertext, uploadfmt_t pixelfmt, unsigned int width, unsigned int height, void *pixeldata, void *palettedata);
extern struct model_s *currentmodel;
void Media_CaptureDemoEnd(void);
void Media_RecordFrame (void);
qboolean Media_PausedDemo (qboolean fortiming);
int Media_Capturing (void);
double Media_TweekCaptureFrameTime(double oldtime, double time);
void Media_WriteCurrentTrack(sizebuf_t *buf);
void Media_VideoRestarting(void);
void Media_VideoRestarted(void);
void MYgluPerspective(double fovx, double fovy, double zNear, double zFar);
void R_PushDlights (void);
void R_SetFrustum (float projmat[16], float viewmat[16]);
void R_SetRenderer(rendererinfo_t *ri);
qboolean R_RegisterRenderer(void *module, rendererinfo_t *ri);
struct plugvrfuncs_s;
qboolean R_RegisterVRDriver(void *module, struct plugvrfuncs_s *vrfuncs);
qboolean R_UnRegisterModule(void *module);
void R_AnimateLight (void);
void R_UpdateHDR(vec3_t org);
void R_UpdateLightStyle(unsigned int style, const char *stylestring, float r, float g, float b);
void R_BumpLightstyles(unsigned int maxstyle); //bumps the cl_max_lightstyles array size, if needed.
qboolean R_CalcModelLighting(entity_t *e, struct model_s *clmodel);
struct texture_s *R_TextureAnimation (int frame, struct texture_s *base); //mostly deprecated, only lingers for rtlights so world only.
struct texture_s *R_TextureAnimation_Q2 (struct texture_s *base); //mostly deprecated, only lingers for rtlights so world only.
void RQ_Init(void);
void RQ_Shutdown(void);
qboolean WritePCXfile (const char *filename, enum fs_relative fsroot, qbyte *data, int width, int height, int rowbytes, qbyte *palette, qboolean upload); //data is 8bit.
qbyte *ReadPCXFile(qbyte *buf, int length, int *width, int *height);
void *ReadTargaFile(qbyte *buf, int length, int *width, int *height, uploadfmt_t *format, qboolean greyonly, uploadfmt_t forceformat);
qbyte *ReadPNGFile(const char *fname, qbyte *buf, int length, int *width, int *height, uploadfmt_t *format);
qbyte *ReadPCXPalette(qbyte *buf, int len, qbyte *out);
qbyte *ReadRawImageFile(qbyte *buf, int len, int *width, int *height, uploadfmt_t *format, qboolean force_rgba8, const char *fname);
void *Image_ResampleTexture (uploadfmt_t format, const void *in, int inwidth, int inheight, void *out, int outwidth, int outheight);
void Image_ReadExternalAlpha(qbyte *rgbadata, size_t imgwidth, size_t imgheight, const char *fname, uploadfmt_t *format);
void BoostGamma(qbyte *rgba, int width, int height, uploadfmt_t fmt);
void SaturateR8G8B8(qbyte *data, int size, float sat);
void AddOcranaLEDsIndexed (qbyte *image, int h, int w);
void Renderer_Init(void);
void Renderer_Start(void);
qboolean Renderer_Started(void);
void R_ShutdownRenderer(qboolean videotoo);
void R_RestartRenderer_f (void);//this goes here so we can save some stack when first initing the sw renderer.
//used to live in glquake.h
qbyte GetPaletteIndexRange(int first, int stop, int red, int green, int blue);
qbyte GetPaletteIndex(int red, int green, int blue);
extern cvar_t r_norefresh;
extern cvar_t r_drawentities;
extern cvar_t r_drawworld;
extern cvar_t r_drawviewmodel;
extern cvar_t r_drawviewmodelinvis;
extern cvar_t r_speeds;
extern cvar_t r_waterwarp;
extern cvar_t r_fullbright;
extern cvar_t r_lightmap;
extern cvar_t r_glsl_offsetmapping;
extern cvar_t r_skyfog; //additional fog alpha on sky
extern cvar_t r_shadow_playershadows;
extern cvar_t r_shadow_realtime_dlight, r_shadow_realtime_dlight_shadows;
extern cvar_t r_shadow_realtime_dlight_ambient;
extern cvar_t r_shadow_realtime_dlight_diffuse;
extern cvar_t r_shadow_realtime_dlight_specular;
extern cvar_t r_shadow_realtime_world, r_shadow_realtime_world_shadows, r_shadow_realtime_world_lightmaps, r_shadow_realtime_world_importlightentitiesfrommap;
extern float r_shadow_realtime_world_lightmaps_force;
extern cvar_t r_shadow_shadowmapping;
extern cvar_t r_mirroralpha;
extern cvar_t r_wateralpha;
extern cvar_t r_lavaalpha;
extern cvar_t r_slimealpha;
extern cvar_t r_telealpha;
extern cvar_t r_waterstyle;
extern cvar_t r_lavastyle;
extern cvar_t r_slimestyle;
extern cvar_t r_telestyle;
extern cvar_t r_dynamic;
extern cvar_t r_temporalscenecache;
extern cvar_t r_novis;
extern cvar_t r_netgraph;
extern cvar_t r_deluxemapping_cvar;
extern qboolean r_deluxemapping;
#ifdef RTLIGHTS
extern qboolean r_fakeshadows; //enables the use of ortho model-only shadows
#endif
extern float r_blobshadows;
extern cvar_t r_softwarebanding_cvar;
extern qboolean r_softwarebanding;
extern cvar_t r_lightprepass_cvar;
extern int r_lightprepass; //0=off,1=16bit,2=32bit
#ifdef R_XFLIP
extern cvar_t r_xflip;
#endif
extern cvar_t gl_mindist, gl_maxdist;
extern cvar_t r_clear;
extern cvar_t r_clearcolour;
extern cvar_t gl_poly;
extern cvar_t gl_affinemodels;
extern cvar_t r_renderscale;
extern cvar_t gl_nohwblend;
extern cvar_t r_coronas, r_coronas_intensity, r_coronas_occlusion, r_coronas_mindist, r_coronas_fadedist, r_flashblend, r_flashblendscale;
extern cvar_t r_lightstylesmooth;
extern cvar_t r_lightstylesmooth_limit;
extern cvar_t r_lightstylespeed;
extern cvar_t r_lightstylescale;
extern cvar_t r_lightmap_scale;
#ifdef QWSKINS
extern cvar_t gl_nocolors;
#endif
extern cvar_t gl_load24bit;
extern cvar_t gl_finish;
extern cvar_t gl_max_size;
extern cvar_t gl_playermip;
extern cvar_t r_lightmap_saturation;
extern cvar_t r_meshpitch;
extern cvar_t r_meshroll; //gah!
extern cvar_t vid_hardwaregamma;
enum {
RSPEED_TOTALREFRESH,
RSPEED_CSQCPHYSICS,
RSPEED_CSQCREDRAW,
RSPEED_LINKENTITIES,
RSPEED_WORLDNODE,
RSPEED_DYNAMIC,
RSPEED_OPAQUE,
RSPEED_RTLIGHTS,
RSPEED_TRANSPARENTS,
RSPEED_PROTOCOL,
RSPEED_PARTICLES,
RSPEED_PARTICLESDRAW,
RSPEED_PALETTEFLASHES,
RSPEED_2D,
RSPEED_SERVER,
RSPEED_SETUP,
RSPEED_SUBMIT,
RSPEED_PRESENT,
RSPEED_ACQUIRE,
RSPEED_MAX
};
extern int rspeeds[RSPEED_MAX];
enum {
RQUANT_MSECS, //old r_speeds
RQUANT_PRIMITIVEINDICIES,
RQUANT_DRAWS,
RQUANT_ENTBATCHES,
RQUANT_WORLDBATCHES,
RQUANT_2DBATCHES,
RQUANT_SHADOWINDICIES,
RQUANT_SHADOWEDGES,
RQUANT_SHADOWSIDES,
RQUANT_LITFACES,
RQUANT_RTLIGHT_DRAWN,
RQUANT_RTLIGHT_CULL_FRUSTUM,
RQUANT_RTLIGHT_CULL_PVS,
RQUANT_RTLIGHT_CULL_SCISSOR,
RQUANT_MAX
};
extern int rquant[RQUANT_MAX];
#define RQuantAdd(type,quant) rquant[type] += quant
#if 0//defined(NDEBUG) || !defined(_WIN32)
#define RSpeedLocals()
#define RSpeedMark()
#define RSpeedRemark()
#define RSpeedEnd(spt)
#else
#define RSpeedLocals() double rsp
#define RSpeedMark() double rsp = (r_speeds.ival>1)?Sys_DoubleTime()*1000000:0
#define RSpeedRemark() rsp = (r_speeds.ival>1)?Sys_DoubleTime()*1000000:0
#if defined(_WIN32) && defined(GLQUAKE)
extern void (_stdcall *qglFinish) (void);
#define RSpeedEnd(spt) do {if(r_speeds.ival > 1){if(r_speeds.ival > 2 && qglFinish)qglFinish(); rspeeds[spt] += (double)(Sys_DoubleTime()*1000000) - rsp;}}while (0)
#else
#define RSpeedEnd(spt) rspeeds[spt] += (r_speeds.ival>1)?Sys_DoubleTime()*1000000 - rsp:0
#endif
#endif
View git blame Copy permalink