1326 lines
40 KiB
C
1326 lines
40 KiB
C
/*
|
|
gl_local.h - renderer local declarations
|
|
Copyright (C) 2010 Uncle Mike
|
|
|
|
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 3 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.
|
|
*/
|
|
|
|
#ifndef GL_LOCAL_H
|
|
#define GL_LOCAL_H
|
|
#include "port.h"
|
|
#include "xash3d_types.h"
|
|
#include "cvardef.h"
|
|
#include "const.h"
|
|
#include "com_model.h"
|
|
#include "cl_entity.h"
|
|
#include "render_api.h"
|
|
#include "protocol.h"
|
|
#include "dlight.h"
|
|
#include "ref_api.h"
|
|
#include "xash3d_mathlib.h"
|
|
#include "ref_params.h"
|
|
#include "enginefeatures.h"
|
|
#include "com_strings.h"
|
|
#include "pm_movevars.h"
|
|
//#include "cvar.h"
|
|
typedef struct mip_s mip_t;
|
|
|
|
typedef int fixed8_t;
|
|
typedef int fixed16_t;
|
|
|
|
#define ASSERT(x) if(!( x )) gEngfuncs.Host_Error( "assert failed at %s:%i\n", __FILE__, __LINE__ )
|
|
#define Assert(x) if(!( x )) gEngfuncs.Host_Error( "assert failed at %s:%i\n", __FILE__, __LINE__ )
|
|
|
|
#include <stdio.h>
|
|
|
|
#define CVAR_DEFINE( cv, cvname, cvstr, cvflags, cvdesc ) cvar_t cv = { cvname, cvstr, cvflags, 0.0f, (void *)CVAR_SENTINEL, cvdesc }
|
|
#define CVAR_DEFINE_AUTO( cv, cvstr, cvflags, cvdesc ) cvar_t cv = { #cv, cvstr, cvflags, 0.0f, (void *)CVAR_SENTINEL, cvdesc }
|
|
#define CVAR_TO_BOOL( x ) ((x) && ((x)->value != 0.0f) ? true : false )
|
|
|
|
#define WORLD (gEngfuncs.GetWorld())
|
|
#define WORLDMODEL (gEngfuncs.pfnGetModelByIndex( 1 ))
|
|
#define MOVEVARS (gEngfuncs.pfnGetMoveVars())
|
|
|
|
// make mod_ref.h?
|
|
#define LM_SAMPLE_SIZE 16
|
|
|
|
|
|
extern poolhandle_t r_temppool;
|
|
|
|
#define BLOCK_SIZE tr.block_size // lightmap blocksize
|
|
#define BLOCK_SIZE_DEFAULT 128 // for keep backward compatibility
|
|
#define BLOCK_SIZE_MAX 1024
|
|
|
|
#define MAX_TEXTURES 4096
|
|
#define MAX_DECAL_SURFS 4096
|
|
|
|
#if XASH_LOW_MEMORY
|
|
#undef MAX_TEXTURES
|
|
#undef MAX_DECAL_SURFS
|
|
#define MAX_TEXTURES 1024
|
|
#define MAX_DECAL_SURFS 256
|
|
#endif
|
|
|
|
#define MAX_DETAIL_TEXTURES 256
|
|
#define MAX_LIGHTMAPS 256
|
|
#define SUBDIVIDE_SIZE 64
|
|
#define MAX_DRAW_STACK 2 // normal view and menu view
|
|
|
|
#define SHADEDOT_QUANT 16 // precalculated dot products for quantized angles
|
|
#define SHADE_LAMBERT 1.495f
|
|
#define DEFAULT_ALPHATEST 0.0f
|
|
|
|
// refparams
|
|
#define RP_NONE 0
|
|
#define RP_ENVVIEW BIT( 0 ) // used for cubemapshot
|
|
#define RP_OLDVIEWLEAF BIT( 1 )
|
|
#define RP_CLIPPLANE BIT( 2 )
|
|
|
|
#define RP_NONVIEWERREF (RP_ENVVIEW)
|
|
#define R_ModelOpaque( rm ) ( rm == kRenderNormal )
|
|
#define R_StaticEntity( ent ) ( VectorIsNull( ent->origin ) && VectorIsNull( ent->angles ))
|
|
#define RP_LOCALCLIENT( e ) ((e) != NULL && (e)->index == gEngfuncs.GetPlayerIndex() && e->player )
|
|
#define RP_NORMALPASS() ( FBitSet( RI.params, RP_NONVIEWERREF ) == 0 )
|
|
|
|
#define CL_IsViewEntityLocalPlayer() ( ENGINE_GET_PARM( PARM_VIEWENT_INDEX ) == ENGINE_GET_PARM( PARM_PLAYER_INDEX ) )
|
|
|
|
#define CULL_VISIBLE 0 // not culled
|
|
#define CULL_BACKSIDE 1 // backside of transparent wall
|
|
#define CULL_FRUSTUM 2 // culled by frustum
|
|
#define CULL_VISFRAME 3 // culled by PVS
|
|
#define CULL_OTHER 4 // culled by other reason
|
|
|
|
// bit operation helpers
|
|
#define MASK(x) (BIT(x)-1)
|
|
#define GET_BIT(s,b) ((s & (1 << b)) >> b)
|
|
#define MOVE_BIT(s, f, t) (GET_BIT(s,f) << t )
|
|
|
|
|
|
/*
|
|
skins will be outline flood filled and mip mapped
|
|
pics and sprites with alpha will be outline flood filled
|
|
pic won't be mip mapped
|
|
model skin
|
|
sprite frame
|
|
wall texture
|
|
pic
|
|
*/
|
|
|
|
typedef enum
|
|
{
|
|
it_skin,
|
|
it_sprite,
|
|
it_wall,
|
|
it_pic,
|
|
it_sky
|
|
} imagetype_t;
|
|
|
|
|
|
//===================================================================
|
|
|
|
typedef unsigned short pixel_t;
|
|
|
|
typedef struct vrect_s
|
|
{
|
|
int x,y,width,height;
|
|
struct vrect_s *pnext;
|
|
} vrect_t;
|
|
|
|
#define COLOR_WHITE 0xFFFF
|
|
//#define SEPARATE_BLIT
|
|
typedef struct
|
|
{
|
|
pixel_t *buffer; // invisible buffer
|
|
pixel_t colormap[32*8192]; // 8192 * light levels
|
|
//pixel_t *alphamap; // 256 * 256 translucency map
|
|
#ifdef SEPARATE_BLIT
|
|
pixel_t screen_minor[256];
|
|
pixel_t screen_major[256];
|
|
#else
|
|
pixel_t screen[256*256];
|
|
unsigned int screen32[256*256];
|
|
#endif
|
|
byte addmap[256*256];
|
|
byte modmap[256*256];
|
|
pixel_t alphamap[3*1024*256];
|
|
pixel_t color;
|
|
qboolean is2d;
|
|
byte alpha;
|
|
|
|
// maybe compute colormask for minor byte?
|
|
int rendermode;
|
|
int rowbytes; // may be > width if displayed in a window
|
|
// can be negative for stupid dibs
|
|
int width;
|
|
int height;
|
|
} viddef_t;
|
|
|
|
extern viddef_t vid;
|
|
|
|
typedef struct
|
|
{
|
|
int params; // rendering parameters
|
|
|
|
qboolean drawWorld; // ignore world for drawing PlayerModel
|
|
qboolean isSkyVisible; // sky is visible
|
|
qboolean onlyClientDraw; // disabled by client request
|
|
qboolean drawOrtho; // draw world as orthogonal projection
|
|
|
|
float fov_x, fov_y; // current view fov
|
|
|
|
cl_entity_t *currententity;
|
|
model_t *currentmodel;
|
|
cl_entity_t *currentbeam; // same as above but for beams
|
|
|
|
int viewport[4];
|
|
//gl_frustum_t frustum;
|
|
|
|
mleaf_t *viewleaf;
|
|
mleaf_t *oldviewleaf;
|
|
vec3_t pvsorigin;
|
|
vec3_t vieworg; // locked vieworigin
|
|
vec3_t viewangles;
|
|
vec3_t vforward;
|
|
vec3_t vright;
|
|
vec3_t vup;
|
|
vec3_t base_vup;
|
|
vec3_t base_vpn;
|
|
vec3_t base_vright;
|
|
|
|
vec3_t cullorigin;
|
|
vec3_t cull_vforward;
|
|
vec3_t cull_vright;
|
|
vec3_t cull_vup;
|
|
|
|
int cached_contents; // in water
|
|
int cached_waterlevel; // was in water
|
|
float farClip;
|
|
|
|
float skyMins[2][6];
|
|
float skyMaxs[2][6];
|
|
|
|
matrix4x4 objectMatrix; // currententity matrix
|
|
matrix4x4 worldviewMatrix; // modelview for world
|
|
matrix4x4 modelviewMatrix; // worldviewMatrix * objectMatrix
|
|
|
|
matrix4x4 projectionMatrix;
|
|
matrix4x4 worldviewProjectionMatrix; // worldviewMatrix * projectionMatrix
|
|
byte visbytes[(MAX_MAP_LEAFS+7)/8];// actual PVS for current frame
|
|
|
|
float viewplanedist;
|
|
|
|
// q2 oldrefdef
|
|
vrect_t vrect; // subwindow in video for refresh
|
|
// FIXME: not need vrect next field here?
|
|
vrect_t aliasvrect; // scaled Alias version
|
|
int vrectright, vrectbottom; // right & bottom screen coords
|
|
int aliasvrectright, aliasvrectbottom; // scaled Alias versions
|
|
float vrectrightedge; // rightmost right edge we care about,
|
|
// for use in edge list
|
|
float fvrectx, fvrecty; // for floating-point compares
|
|
float fvrectx_adj, fvrecty_adj; // left and top edges, for clamping
|
|
int vrect_x_adj_shift20; // (vrect.x + 0.5 - epsilon) << 20
|
|
int vrectright_adj_shift20; // (vrectright + 0.5 - epsilon) << 20
|
|
float fvrectright_adj, fvrectbottom_adj;
|
|
// right and bottom edges, for clamping
|
|
float fvrectright; // rightmost edge, for Alias clamping
|
|
float fvrectbottom; // bottommost edge, for Alias clampin
|
|
|
|
|
|
} ref_instance_t;
|
|
|
|
typedef struct
|
|
{
|
|
cl_entity_t *edge_entities[MAX_VISIBLE_PACKET]; // brush edge drawing
|
|
cl_entity_t *solid_entities[MAX_VISIBLE_PACKET]; // opaque moving or alpha brushes
|
|
cl_entity_t *trans_entities[MAX_VISIBLE_PACKET]; // translucent brushes
|
|
cl_entity_t *beam_entities[MAX_VISIBLE_PACKET];
|
|
uint num_edge_entities;
|
|
uint num_solid_entities;
|
|
uint num_trans_entities;
|
|
uint num_beam_entities;
|
|
} draw_list_t;
|
|
|
|
typedef struct
|
|
{
|
|
int defaultTexture; // use for bad textures
|
|
int particleTexture;
|
|
int whiteTexture;
|
|
int grayTexture;
|
|
int blackTexture;
|
|
int solidskyTexture; // quake1 solid-sky layer
|
|
int alphaskyTexture; // quake1 alpha-sky layer
|
|
int lightmapTextures[MAX_LIGHTMAPS];
|
|
int dlightTexture; // custom dlight texture
|
|
int skyboxTextures[6]; // skybox sides
|
|
int cinTexture; // cinematic texture
|
|
|
|
// entity lists
|
|
draw_list_t draw_stack[MAX_DRAW_STACK];
|
|
int draw_stack_pos;
|
|
draw_list_t *draw_list;
|
|
|
|
msurface_t *draw_decals[MAX_DECAL_SURFS];
|
|
int num_draw_decals;
|
|
|
|
// OpenGL matrix states
|
|
qboolean modelviewIdentity;
|
|
|
|
int visframecount; // PVS frame
|
|
int dlightframecount; // dynamic light frame
|
|
int realframecount; // not including viewpasses
|
|
int framecount;
|
|
|
|
qboolean ignore_lightgamma;
|
|
qboolean fCustomRendering;
|
|
qboolean fResetVis;
|
|
qboolean fFlipViewModel;
|
|
|
|
// tree visualization stuff
|
|
int recursion_level;
|
|
int max_recursion;
|
|
|
|
byte visbytes[(MAX_MAP_LEAFS+7)/8]; // member custom PVS
|
|
int lightstylevalue[MAX_LIGHTSTYLES]; // value 0 - 65536
|
|
int block_size; // lightmap blocksize
|
|
|
|
double frametime; // special frametime for multipass rendering (will set to 0 on a nextview)
|
|
float blend; // global blend value
|
|
|
|
// cull info
|
|
vec3_t modelorg; // relative to viewpoint
|
|
|
|
qboolean fCustomSkybox;
|
|
int sample_size;
|
|
uint sample_bits;
|
|
qboolean map_unload;
|
|
} gl_globals_t;
|
|
|
|
typedef struct
|
|
{
|
|
uint c_world_polys;
|
|
uint c_studio_polys;
|
|
uint c_sprite_polys;
|
|
uint c_alias_polys;
|
|
uint c_world_leafs;
|
|
|
|
uint c_view_beams_count;
|
|
uint c_active_tents_count;
|
|
uint c_alias_models_drawn;
|
|
uint c_studio_models_drawn;
|
|
uint c_sprite_models_drawn;
|
|
uint c_particle_count;
|
|
|
|
uint c_client_ents; // entities that moved to client
|
|
double t_world_node;
|
|
double t_world_draw;
|
|
} ref_speeds_t;
|
|
|
|
extern ref_speeds_t r_stats;
|
|
extern ref_instance_t RI;
|
|
extern gl_globals_t tr;
|
|
|
|
#define r_numEntities (tr.draw_list->num_solid_entities + tr.draw_list->num_trans_entities)
|
|
#define r_numStatics (r_stats.c_client_ents)
|
|
|
|
typedef struct image_s
|
|
{
|
|
char name[256]; // game path, including extension (can be store image programs)
|
|
word srcWidth; // keep unscaled sizes
|
|
word srcHeight;
|
|
word width; // upload width\height
|
|
word height;
|
|
word depth; // texture depth or count of layers for 2D_ARRAY
|
|
byte numMips; // mipmap count
|
|
|
|
|
|
texFlags_t flags;
|
|
|
|
rgba_t fogParams; // some water textures
|
|
// contain info about underwater fog
|
|
rgbdata_t *original; // keep original image
|
|
|
|
// debug info
|
|
size_t size; // upload size for debug targets
|
|
|
|
// detail textures stuff
|
|
float xscale;
|
|
float yscale;
|
|
|
|
imagetype_t type;
|
|
pixel_t *pixels[4]; // mip levels
|
|
pixel_t *alpha_pixels; // mip levels
|
|
|
|
|
|
int servercount;
|
|
uint hashValue;
|
|
struct image_s *nextHash;
|
|
} image_t;
|
|
|
|
#if 0
|
|
|
|
//
|
|
// gl_backend.c
|
|
//
|
|
void GL_BackendStartFrame( void );
|
|
void GL_BackendEndFrame( void );
|
|
void GL_CleanUpTextureUnits( int last );
|
|
void GL_Bind( int tmu, unsigned int texnum );
|
|
void GL_LoadTexMatrix( const matrix4x4 m );
|
|
void GL_LoadTexMatrixExt( const float *glmatrix );
|
|
void GL_LoadMatrix( const matrix4x4 source );
|
|
void GL_TexGen( unsigned int coord, unsigned int mode );
|
|
void GL_SelectTexture( int texture );
|
|
void GL_CleanupAllTextureUnits( void );
|
|
void GL_LoadIdentityTexMatrix( void );
|
|
void GL_DisableAllTexGens( void );
|
|
void GL_SetRenderMode( int mode );
|
|
void GL_TextureTarget( uint target );
|
|
void GL_Cull( unsigned int cull );
|
|
void R_ShowTextures( void );
|
|
void R_ShowTree( void );
|
|
void SCR_TimeRefresh_f( void );
|
|
#endif
|
|
//
|
|
// gl_beams.c
|
|
//
|
|
void CL_DrawBeams( int fTrans, BEAM *active_beams );
|
|
qboolean R_BeamCull( const vec3_t start, const vec3_t end, qboolean pvsOnly );
|
|
#if 0
|
|
//
|
|
// gl_cull.c
|
|
//
|
|
int R_CullModel( cl_entity_t *e, const vec3_t absmin, const vec3_t absmax );
|
|
qboolean R_CullBox( const vec3_t mins, const vec3_t maxs );
|
|
qboolean R_CullSphere( const vec3_t centre, const float radius );
|
|
//int R_CullSurface( msurface_t *surf, gl_frustum_t *frustum, uint clipflags );
|
|
#endif
|
|
//
|
|
// gl_decals.c
|
|
//
|
|
void DrawSurfaceDecals( msurface_t *fa, qboolean single, qboolean reverse );
|
|
float *R_DecalSetupVerts( decal_t *pDecal, msurface_t *surf, int texture, int *outCount );
|
|
//void DrawSingleDecal( decal_t *pDecal, msurface_t *fa );
|
|
void R_EntityRemoveDecals( model_t *mod );
|
|
//void DrawDecalsBatch( void );
|
|
void R_ClearDecals( void );
|
|
|
|
#if 0
|
|
|
|
//
|
|
// gl_drawhulls.c
|
|
//
|
|
void R_DrawWorldHull( void );
|
|
void R_DrawModelHull( void );
|
|
#endif
|
|
|
|
void GL_Bind( int tmu, unsigned int texnum );
|
|
|
|
//
|
|
// gl_draw.cM_PI
|
|
//
|
|
void R_Set2DMode( qboolean enable );
|
|
void R_DrawTileClear( int texnum, int x, int y, int w, int h );
|
|
void R_UploadStretchRaw( int texture, int cols, int rows, int width, int height, const byte *data );//
|
|
|
|
// gl_image.c
|
|
//
|
|
void R_SetTextureParameters( void );
|
|
image_t *R_GetTexture( unsigned int texnum );
|
|
#define GL_LoadTextureInternal( name, pic, flags ) GL_LoadTextureFromBuffer( name, pic, flags, false )
|
|
#define GL_UpdateTextureInternal( name, pic, flags ) GL_LoadTextureFromBuffer( name, pic, flags, true )
|
|
int GL_LoadTexture( const char *name, const byte *buf, size_t size, int flags );
|
|
int GL_LoadTextureArray( const char **names, int flags );
|
|
int GL_LoadTextureFromBuffer( const char *name, rgbdata_t *pic, texFlags_t flags, qboolean update );
|
|
byte *GL_ResampleTexture( const byte *source, int in_w, int in_h, int out_w, int out_h, qboolean isNormalMap );
|
|
int GL_CreateTexture( const char *name, int width, int height, const void *buffer, texFlags_t flags );
|
|
int GL_CreateTextureArray( const char *name, int width, int height, int depth, const void *buffer, texFlags_t flags );
|
|
void GL_ProcessTexture( int texnum, float gamma, int topColor, int bottomColor );
|
|
void GL_UpdateTexSize( int texnum, int width, int height, int depth );
|
|
void GL_ApplyTextureParams( image_t *tex );
|
|
int GL_FindTexture( const char *name );
|
|
void GL_FreeTexture( unsigned int texnum );
|
|
const char *GL_Target( unsigned int target );
|
|
void R_InitDlightTexture( void );
|
|
void R_TextureList_f( void );
|
|
void R_InitImages( void );
|
|
void R_ShutdownImages( void );
|
|
#if 1
|
|
//
|
|
// gl_rlight.c
|
|
//
|
|
void CL_RunLightStyles( void );
|
|
void R_PushDlights( void );
|
|
void R_AnimateLight( void );
|
|
void R_GetLightSpot( vec3_t lightspot );
|
|
void R_MarkLights( dlight_t *light, int bit, mnode_t *node );
|
|
colorVec R_LightVec( const vec3_t start, const vec3_t end, vec3_t lightspot, vec3_t lightvec );
|
|
int R_CountSurfaceDlights( msurface_t *surf );
|
|
colorVec R_LightPoint( const vec3_t p0 );
|
|
int R_CountDlights( void );
|
|
#endif
|
|
//
|
|
// gl_rmain.c
|
|
//
|
|
void R_ClearScene( void );
|
|
void R_LoadIdentity( void );
|
|
void R_RenderScene( void );
|
|
void R_DrawCubemapView( const vec3_t origin, const vec3_t angles, int size );
|
|
void R_SetupRefParams( const struct ref_viewpass_s *rvp );
|
|
void R_TranslateForEntity( cl_entity_t *e );
|
|
void R_RotateForEntity( cl_entity_t *e );
|
|
void R_SetupGL( qboolean set_gl_state );
|
|
void R_AllowFog( qboolean allowed );
|
|
void R_SetupFrustum( void );
|
|
void R_FindViewLeaf( void );
|
|
void R_PushScene( void );
|
|
void R_PopScene( void );
|
|
void R_DrawFog( void );
|
|
|
|
//
|
|
// gl_rmath.c
|
|
//
|
|
void Matrix4x4_ToArrayFloatGL( const matrix4x4 in, float out[16] );
|
|
void Matrix4x4_FromArrayFloatGL( matrix4x4 out, const float in[16] );
|
|
void Matrix4x4_Concat( matrix4x4 out, const matrix4x4 in1, const matrix4x4 in2 );
|
|
void Matrix4x4_ConcatTranslate( matrix4x4 out, float x, float y, float z );
|
|
void Matrix4x4_ConcatRotate( matrix4x4 out, float angle, float x, float y, float z );
|
|
void Matrix4x4_ConcatScale( matrix4x4 out, float x );
|
|
void Matrix4x4_ConcatScale3( matrix4x4 out, float x, float y, float z );
|
|
void Matrix4x4_CreateTranslate( matrix4x4 out, float x, float y, float z );
|
|
void Matrix4x4_CreateRotate( matrix4x4 out, float angle, float x, float y, float z );
|
|
void Matrix4x4_CreateScale( matrix4x4 out, float x );
|
|
void Matrix4x4_CreateScale3( matrix4x4 out, float x, float y, float z );
|
|
void Matrix4x4_CreateProjection(matrix4x4 out, float xMax, float xMin, float yMax, float yMin, float zNear, float zFar);
|
|
void Matrix4x4_CreateOrtho(matrix4x4 m, float xLeft, float xRight, float yBottom, float yTop, float zNear, float zFar);
|
|
void Matrix4x4_CreateModelview( matrix4x4 out );
|
|
#if 0
|
|
//
|
|
// gl_rmisc.c
|
|
//
|
|
void R_ClearStaticEntities( void );
|
|
|
|
//
|
|
// gl_rsurf.c
|
|
//
|
|
void R_MarkLeaves( void );
|
|
void R_DrawWorld( void );
|
|
void R_DrawWaterSurfaces( void );
|
|
void R_DrawBrushModel( cl_entity_t *e );
|
|
void GL_SubdivideSurface( msurface_t *fa );
|
|
void GL_BuildPolygonFromSurface( model_t *mod, msurface_t *fa );
|
|
void DrawGLPoly( glpoly_t *p, float xScale, float yScale );
|
|
texture_t *R_TextureAnimation( msurface_t *s );
|
|
void GL_SetupFogColorForSurfaces( void );
|
|
void R_DrawAlphaTextureChains( void );
|
|
void GL_RebuildLightmaps( void );
|
|
void GL_InitRandomTable( void );
|
|
void GL_BuildLightmaps( void );
|
|
void GL_ResetFogColor( void );
|
|
void R_GenerateVBO();
|
|
void R_ClearVBO();
|
|
void R_AddDecalVBO( decal_t *pdecal, msurface_t *surf );
|
|
#endif
|
|
//
|
|
// gl_rpart.c
|
|
//
|
|
void CL_DrawParticlesExternal( const ref_viewpass_t *rvp, qboolean trans_pass, float frametime );
|
|
void CL_DrawParticles( double frametime, particle_t *cl_active_particles, float partsize );
|
|
void CL_DrawTracers( double frametime, particle_t *cl_active_tracers );
|
|
|
|
|
|
//
|
|
// gl_sprite.c
|
|
//
|
|
void R_SpriteInit( void );
|
|
void Mod_LoadSpriteModel( model_t *mod, const void *buffer, qboolean *loaded, uint texFlags );
|
|
mspriteframe_t *R_GetSpriteFrame( const model_t *pModel, int frame, float yaw );
|
|
void R_DrawSpriteModel( cl_entity_t *e );
|
|
|
|
//
|
|
// gl_studio.c
|
|
//
|
|
void R_StudioInit( void );
|
|
void Mod_LoadStudioModel( model_t *mod, const void *buffer, qboolean *loaded );
|
|
void R_StudioLerpMovement( cl_entity_t *e, double time, vec3_t origin, vec3_t angles );
|
|
float CL_GetSequenceDuration( cl_entity_t *ent, int sequence );
|
|
struct mstudiotex_s *R_StudioGetTexture( cl_entity_t *e );
|
|
float CL_GetStudioEstimatedFrame( cl_entity_t *ent );
|
|
int R_GetEntityRenderMode( cl_entity_t *ent );
|
|
void R_DrawStudioModel( cl_entity_t *e );
|
|
player_info_t *pfnPlayerInfo( int index );
|
|
void R_GatherPlayerLight( void );
|
|
float R_StudioEstimateFrame( cl_entity_t *e, mstudioseqdesc_t *pseqdesc );
|
|
void R_StudioLerpMovement( cl_entity_t *e, double time, vec3_t origin, vec3_t angles );
|
|
void R_StudioResetPlayerModels( void );
|
|
void CL_InitStudioAPI( void );
|
|
void Mod_StudioLoadTextures( model_t *mod, void *data );
|
|
void Mod_StudioUnloadTextures( void *data );
|
|
#if 0
|
|
//
|
|
// gl_alias.c
|
|
//
|
|
void Mod_LoadAliasModel( model_t *mod, const void *buffer, qboolean *loaded );
|
|
void R_DrawAliasModel( cl_entity_t *e );
|
|
void R_AliasInit( void );
|
|
|
|
//
|
|
// gl_warp.c
|
|
//
|
|
|
|
void R_InitSkyClouds( mip_t *mt, struct texture_s *tx, qboolean custom_palette );
|
|
void R_AddSkyBoxSurface( msurface_t *fa );
|
|
void R_ClearSkyBox( void );
|
|
void R_DrawSkyBox( void );
|
|
void R_DrawClouds( void );
|
|
void EmitWaterPolys( msurface_t *warp, qboolean reverse );
|
|
#endif
|
|
|
|
void GAME_EXPORT R_InitSkyClouds( struct mip_s *mt, struct texture_s *tx, qboolean custom_palette );
|
|
//
|
|
// gl_vgui.c
|
|
//
|
|
void VGUI_DrawInit( void );
|
|
void VGUI_DrawShutdown( void );
|
|
void VGUI_SetupDrawingText( int *pColor );
|
|
void VGUI_SetupDrawingRect( int *pColor );
|
|
void VGUI_SetupDrawingImage( int *pColor );
|
|
void VGUI_BindTexture( int id );
|
|
void VGUI_EnableTexture( qboolean enable );
|
|
void VGUI_CreateTexture( int id, int width, int height );
|
|
void VGUI_UploadTexture( int id, const char *buffer, int width, int height );
|
|
void VGUI_UploadTextureBlock( int id, int drawX, int drawY, const byte *rgba, int blockWidth, int blockHeight );
|
|
void VGUI_DrawQuad( const vpoint_t *ul, const vpoint_t *lr );
|
|
void VGUI_GetTextureSizes( int *width, int *height );
|
|
int VGUI_GenerateTexture( void );
|
|
|
|
//#include "vid_common.h"
|
|
|
|
//
|
|
// renderer exports
|
|
//
|
|
qboolean R_Init( void );
|
|
void R_Shutdown( void );
|
|
void GL_SetupAttributes( int safegl );
|
|
void GL_InitExtensions( void );
|
|
void GL_ClearExtensions( void );
|
|
void VID_CheckChanges( void );
|
|
int GL_LoadTexture( const char *name, const byte *buf, size_t size, int flags );
|
|
void GL_FreeImage( const char *name );
|
|
qboolean VID_ScreenShot( const char *filename, int shot_type );
|
|
qboolean VID_CubemapShot( const char *base, uint size, const float *vieworg, qboolean skyshot );
|
|
void R_BeginFrame( qboolean clearScene );
|
|
void R_RenderFrame( const struct ref_viewpass_s *vp );
|
|
void R_EndFrame( void );
|
|
void R_ClearScene( void );
|
|
void R_GetTextureParms( int *w, int *h, int texnum );
|
|
void R_GetSpriteParms( int *frameWidth, int *frameHeight, int *numFrames, int curFrame, const struct model_s *pSprite );
|
|
void R_DrawStretchRaw( float x, float y, float w, float h, int cols, int rows, const byte *data, qboolean dirty );
|
|
void R_DrawStretchPic( float x, float y, float w, float h, float s1, float t1, float s2, float t2, int texnum );
|
|
qboolean R_SpeedsMessage( char *out, size_t size );
|
|
void R_SetupSky( const char *skyboxname );
|
|
qboolean R_CullBox( const vec3_t mins, const vec3_t maxs );
|
|
int R_WorldToScreen( const vec3_t point, vec3_t screen );
|
|
void R_ScreenToWorld( const vec3_t screen, vec3_t point );
|
|
qboolean R_AddEntity( struct cl_entity_s *pRefEntity, int entityType );
|
|
void Mod_LoadMapSprite( struct model_s *mod, const void *buffer, size_t size, qboolean *loaded );
|
|
void Mod_SpriteUnloadTextures( void *data );
|
|
void Mod_UnloadAliasModel( struct model_s *mod );
|
|
void Mod_AliasUnloadTextures( void *data );
|
|
void GL_SetRenderMode( int mode );
|
|
void R_RunViewmodelEvents( void );
|
|
void R_DrawViewModel( void );
|
|
int R_GetSpriteTexture( const struct model_s *m_pSpriteModel, int frame );
|
|
void R_DecalShoot( int textureIndex, int entityIndex, int modelIndex, vec3_t pos, int flags, float scale );
|
|
void R_RemoveEfrags( struct cl_entity_s *ent );
|
|
void R_AddEfrags( struct cl_entity_s *ent );
|
|
void R_DecalRemoveAll( int texture );
|
|
int R_CreateDecalList( decallist_t *pList );
|
|
void R_ClearAllDecals( void );
|
|
byte *Mod_GetCurrentVis( void );
|
|
void Mod_SetOrthoBounds( const float *mins, const float *maxs );
|
|
void R_NewMap( void );
|
|
void CL_AddCustomBeam( cl_entity_t *pEnvBeam );
|
|
#if 0
|
|
//
|
|
// gl_opengl.c
|
|
//
|
|
#define GL_CheckForErrors() GL_CheckForErrors_( __FILE__, __LINE__ )
|
|
void GL_CheckForErrors_( const char *filename, const int fileline );
|
|
const char *GL_ErrorString( int err );
|
|
qboolean GL_Support( int r_ext );
|
|
int GL_MaxTextureUnits( void );
|
|
void GL_CheckExtension( const char *name, const dllfunc_t *funcs, const char *cvarname, int r_ext );
|
|
void GL_SetExtension( int r_ext, int enable );
|
|
#endif
|
|
//
|
|
// gl_triapi.c
|
|
//
|
|
void TriRenderMode( int mode );
|
|
void TriBegin( int mode );
|
|
void TriEnd( void );
|
|
void TriTexCoord2f( float u, float v );
|
|
void TriVertex3fv( const float *v );
|
|
void TriVertex3f( float x, float y, float z );
|
|
void _TriColor4f( float r, float g, float b, float a );
|
|
void TriColor4ub( byte r, byte g, byte b, byte a );
|
|
void _TriColor4ub( byte r, byte g, byte b, byte a );
|
|
int TriWorldToScreen( const float *world, float *screen );
|
|
int TriSpriteTexture( model_t *pSpriteModel, int frame );
|
|
void TriFog( float flFogColor[3], float flStart, float flEnd, int bOn );
|
|
void TriGetMatrix( const int pname, float *matrix );
|
|
void TriFogParams( float flDensity, int iFogSkybox );
|
|
void TriCullFace( TRICULLSTYLE mode );
|
|
void TriBrightness( float brightness );
|
|
|
|
#define ENGINE_GET_PARM_ (*gEngfuncs.EngineGetParm)
|
|
#define ENGINE_GET_PARM( parm ) ENGINE_GET_PARM_( (parm), 0 )
|
|
|
|
extern ref_api_t gEngfuncs;
|
|
extern ref_globals_t *gpGlobals;
|
|
extern cvar_t *gl_emboss_scale;
|
|
extern cvar_t *r_drawentities;
|
|
extern cvar_t *vid_brightness;
|
|
extern cvar_t *vid_gamma;
|
|
extern cvar_t *r_norefresh;
|
|
extern cvar_t *r_dynamic;
|
|
extern cvar_t *r_lightmap;
|
|
|
|
// todo: gl_cull.c
|
|
#define R_CullModel(...) 0
|
|
|
|
#if 0
|
|
//
|
|
// renderer cvars
|
|
//
|
|
extern cvar_t *gl_texture_anisotropy;
|
|
extern cvar_t *gl_extensions;
|
|
extern cvar_t *gl_check_errors;
|
|
extern cvar_t *gl_texture_lodbias;
|
|
extern cvar_t *gl_texture_nearest;
|
|
extern cvar_t *gl_lightmap_nearest;
|
|
extern cvar_t *gl_keeptjunctions;
|
|
|
|
extern cvar_t *gl_round_down;
|
|
extern cvar_t *gl_wireframe;
|
|
extern cvar_t *gl_polyoffset;
|
|
extern cvar_t *gl_finish;
|
|
extern cvar_t *gl_nosort;
|
|
extern cvar_t *gl_clear;
|
|
extern cvar_t *gl_test; // cvar to testify new effects
|
|
extern cvar_t *gl_msaa;
|
|
extern cvar_t *gl_stencilbits;
|
|
|
|
extern cvar_t *r_speeds;
|
|
extern cvar_t *r_fullbright;
|
|
extern cvar_t *r_showtree; // build graph of visible hull
|
|
extern cvar_t *r_lighting_extended;
|
|
extern cvar_t *r_lighting_modulate;
|
|
extern cvar_t *r_lighting_ambient;
|
|
extern cvar_t *r_studio_lambert;
|
|
extern cvar_t *r_detailtextures;
|
|
extern cvar_t *r_drawentities;
|
|
extern cvar_t *r_decals;
|
|
extern cvar_t *r_novis;
|
|
extern cvar_t *r_nocull;
|
|
extern cvar_t *r_lockpvs;
|
|
extern cvar_t *r_lockfrustum;
|
|
extern cvar_t *r_traceglow;
|
|
extern cvar_t *r_dynamic;
|
|
extern cvar_t *r_lightmap;
|
|
extern cvar_t *r_vbo;
|
|
extern cvar_t *r_vbo_dlightmode;
|
|
|
|
extern cvar_t *vid_brightness;
|
|
extern cvar_t *vid_gamma;
|
|
|
|
//
|
|
// engine shared convars
|
|
//
|
|
extern cvar_t *gl_showtextures;
|
|
extern cvar_t *tracerred;
|
|
extern cvar_t *tracergreen;
|
|
extern cvar_t *tracerblue;
|
|
extern cvar_t *traceralpha;
|
|
extern cvar_t *cl_lightstyle_lerping;
|
|
extern cvar_t *r_showhull;
|
|
#endif
|
|
// softrender defs
|
|
|
|
#define CACHE_SIZE 32
|
|
|
|
/*
|
|
====================================================
|
|
CONSTANTS
|
|
====================================================
|
|
*/
|
|
|
|
#define VID_CBITS 6
|
|
#define VID_GRADES (1 << VID_CBITS)
|
|
|
|
|
|
// r_shared.h: general refresh-related stuff shared between the refresh and the
|
|
// driver
|
|
|
|
|
|
#define MAXVERTS 64 // max points in a surface polygon
|
|
#define MAXWORKINGVERTS (MAXVERTS+4) // max points in an intermediate
|
|
// polygon (while processing)
|
|
// !!! if this is changed, it must be changed in d_ifacea.h too !!!
|
|
#define MAXHEIGHT 1200
|
|
#define MAXWIDTH 1920
|
|
|
|
#define INFINITE_DISTANCE 0x10000 // distance that's always guaranteed to
|
|
// be farther away than anything in
|
|
// the scene
|
|
|
|
|
|
// d_iface.h: interface header file for rasterization driver modules
|
|
|
|
#define WARP_WIDTH 320
|
|
#define WARP_HEIGHT 240
|
|
|
|
#define MAX_LBM_HEIGHT 480
|
|
|
|
|
|
#define PARTICLE_Z_CLIP 8.0
|
|
|
|
// !!! must be kept the same as in quakeasm.h !!!
|
|
#define TRANSPARENT_COLOR 0x0349 //0xFF
|
|
|
|
|
|
// !!! if this is changed, it must be changed in d_ifacea.h too !!!
|
|
#define TURB_TEX_SIZE 64 // base turbulent texture size
|
|
|
|
// !!! if this is changed, it must be changed in d_ifacea.h too !!!
|
|
#define CYCLE 128 // turbulent cycle size
|
|
|
|
#define SCANBUFFERPAD 0x1000
|
|
|
|
#define DS_SPAN_LIST_END -128
|
|
|
|
#define NUMSTACKEDGES 4000
|
|
#define MINEDGES NUMSTACKEDGES
|
|
#define NUMSTACKSURFACES 2000
|
|
#define MINSURFACES NUMSTACKSURFACES
|
|
#define MAXSPANS 6000
|
|
|
|
// flags in finalvert_t.flags
|
|
#define ALIAS_LEFT_CLIP 0x0001
|
|
#define ALIAS_TOP_CLIP 0x0002
|
|
#define ALIAS_RIGHT_CLIP 0x0004
|
|
#define ALIAS_BOTTOM_CLIP 0x0008
|
|
#define ALIAS_Z_CLIP 0x0010
|
|
#define ALIAS_XY_CLIP_MASK 0x000F
|
|
|
|
#define SURFCACHE_SIZE_AT_320X240 1024*768
|
|
|
|
#define BMODEL_FULLY_CLIPPED 0x10 // value returned by R_BmodelCheckBBox ()
|
|
// if bbox is trivially rejected
|
|
|
|
#define XCENTERING (1.0f / 2.0f)
|
|
#define YCENTERING (1.0f / 2.0f)
|
|
|
|
#define CLIP_EPSILON 0.001f
|
|
|
|
// !!! if this is changed, it must be changed in asm_draw.h too !!!
|
|
#define NEAR_CLIP 0.01f
|
|
|
|
|
|
//#define MAXALIASVERTS 2000 // TODO: tune this
|
|
#define ALIAS_Z_CLIP_PLANE 4
|
|
|
|
// turbulence stuff
|
|
|
|
#define AMP 8*0x10000
|
|
#define AMP2 3
|
|
#define SPEED 20
|
|
|
|
|
|
/*
|
|
====================================================
|
|
TYPES
|
|
====================================================
|
|
*/
|
|
|
|
typedef struct
|
|
{
|
|
float u, v;
|
|
float s, t;
|
|
float zi;
|
|
} emitpoint_t;
|
|
|
|
/*
|
|
** if you change this structure be sure to change the #defines
|
|
** listed after it!
|
|
*/
|
|
#define SMALL_FINALVERT 0
|
|
|
|
#if SMALL_FINALVERT
|
|
|
|
typedef struct finalvert_s {
|
|
short u, v, s, t;
|
|
int l;
|
|
int zi;
|
|
int flags;
|
|
float xyz[3]; // eye space
|
|
} finalvert_t;
|
|
|
|
#define FINALVERT_V0 0
|
|
#define FINALVERT_V1 2
|
|
#define FINALVERT_V2 4
|
|
#define FINALVERT_V3 6
|
|
#define FINALVERT_V4 8
|
|
#define FINALVERT_V5 12
|
|
#define FINALVERT_FLAGS 16
|
|
#define FINALVERT_X 20
|
|
#define FINALVERT_Y 24
|
|
#define FINALVERT_Z 28
|
|
#define FINALVERT_SIZE 32
|
|
|
|
#else
|
|
|
|
typedef struct finalvert_s {
|
|
int u, v, s, t;
|
|
int l;
|
|
int zi;
|
|
int flags;
|
|
float xyz[3]; // eye space
|
|
} finalvert_t;
|
|
|
|
#define FINALVERT_V0 0
|
|
#define FINALVERT_V1 4
|
|
#define FINALVERT_V2 8
|
|
#define FINALVERT_V3 12
|
|
#define FINALVERT_V4 16
|
|
#define FINALVERT_V5 20
|
|
#define FINALVERT_FLAGS 24
|
|
#define FINALVERT_X 28
|
|
#define FINALVERT_Y 32
|
|
#define FINALVERT_Z 36
|
|
#define FINALVERT_SIZE 40
|
|
|
|
#endif
|
|
|
|
|
|
typedef struct
|
|
{
|
|
short s;
|
|
short t;
|
|
} dstvert_t;
|
|
|
|
typedef struct
|
|
{
|
|
short index_xyz[3];
|
|
short index_st[3];
|
|
} dtriangle_t;
|
|
|
|
typedef struct
|
|
{
|
|
byte v[3]; // scaled byte to fit in frame mins/maxs
|
|
byte lightnormalindex;
|
|
} dtrivertx_t;
|
|
|
|
#define DTRIVERTX_V0 0
|
|
#define DTRIVERTX_V1 1
|
|
#define DTRIVERTX_V2 2
|
|
#define DTRIVERTX_LNI 3
|
|
#define DTRIVERTX_SIZE 4
|
|
|
|
typedef struct
|
|
{
|
|
void *pskin;
|
|
int pskindesc;
|
|
int skinwidth;
|
|
int skinheight;
|
|
dtriangle_t *ptriangles;
|
|
finalvert_t *pfinalverts;
|
|
int numtriangles;
|
|
int drawtype;
|
|
int seamfixupX16;
|
|
qboolean do_vis_thresh;
|
|
int vis_thresh;
|
|
} affinetridesc_t;
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
pixel_t *surfdat; // destination for generated surface
|
|
int rowbytes; // destination logical width in bytes
|
|
msurface_t *surf; // description for surface to generate
|
|
fixed8_t lightadj[MAXLIGHTMAPS];
|
|
// adjust for lightmap levels for dynamic lighting
|
|
image_t *image;
|
|
int surfmip; // mipmapped ratio of surface texels / world pixels
|
|
int surfwidth; // in mipmapped texels
|
|
int surfheight; // in mipmapped texels
|
|
} drawsurf_t;
|
|
|
|
|
|
#if 0
|
|
typedef struct {
|
|
int ambientlight;
|
|
int shadelight;
|
|
float *plightvec;
|
|
} alight_t;
|
|
|
|
#endif
|
|
|
|
// clipped bmodel edges
|
|
|
|
typedef struct bedge_s
|
|
{
|
|
mvertex_t *v[2];
|
|
struct bedge_s *pnext;
|
|
} bedge_t;
|
|
|
|
|
|
// !!! if this is changed, it must be changed in asm_draw.h too !!!
|
|
typedef struct clipplane_s
|
|
{
|
|
vec3_t normal;
|
|
float dist;
|
|
struct clipplane_s *next;
|
|
byte leftedge;
|
|
byte rightedge;
|
|
byte reserved[2];
|
|
} clipplane_t;
|
|
|
|
|
|
typedef struct surfcache_s
|
|
{
|
|
struct surfcache_s *next;
|
|
struct surfcache_s **owner; // NULL is an empty chunk of memory
|
|
int lightadj[MAXLIGHTMAPS]; // checked for strobe flush
|
|
int dlight;
|
|
int size; // including header
|
|
unsigned width;
|
|
unsigned height; // DEBUG only needed for debug
|
|
float mipscale;
|
|
image_t *image;
|
|
byte data[4]; // width*height elements
|
|
} surfcache_t;
|
|
|
|
// !!! if this is changed, it must be changed in asm_draw.h too !!!
|
|
typedef struct espan_s
|
|
{
|
|
int u, v, count;
|
|
struct espan_s *pnext;
|
|
} espan_t;
|
|
|
|
|
|
// FIXME: compress, make a union if that will help
|
|
// insubmodel is only 1, flags is fewer than 32, spanstate could be a byte
|
|
typedef struct surf_s
|
|
{
|
|
struct surf_s *next; // active surface stack in r_edge.c
|
|
struct surf_s *prev; // used in r_edge.c for active surf stack
|
|
struct espan_s *spans; // pointer to linked list of spans to draw
|
|
int key; // sorting key (BSP order)
|
|
int last_u; // set during tracing
|
|
int spanstate; // 0 = not in span
|
|
// 1 = in span
|
|
// -1 = in inverted span (end before
|
|
// start)
|
|
int flags; // currentface flags
|
|
msurface_t *msurf;
|
|
cl_entity_t *entity;
|
|
float nearzi; // nearest 1/z on surface, for mipmapping
|
|
qboolean insubmodel;
|
|
float d_ziorigin, d_zistepu, d_zistepv;
|
|
|
|
int pad[2]; // to 64 bytes
|
|
} surf_t;
|
|
|
|
// !!! if this is changed, it must be changed in asm_draw.h too !!!
|
|
typedef struct edge_s
|
|
{
|
|
fixed16_t u;
|
|
fixed16_t u_step;
|
|
struct edge_s *prev, *next;
|
|
unsigned short surfs[2];
|
|
struct edge_s *nextremove;
|
|
float nearzi;
|
|
medge_t *owner;
|
|
} edge_t;
|
|
|
|
|
|
/*
|
|
====================================================
|
|
VARS
|
|
====================================================
|
|
*/
|
|
|
|
// started
|
|
extern float r_aliasuvscale; // scale-up factor for screen u and v
|
|
// on Alias vertices passed to driver
|
|
|
|
extern affinetridesc_t r_affinetridesc;
|
|
|
|
void D_DrawSurfaces (void);
|
|
void R_DrawParticle( void );
|
|
void D_ViewChanged (void);
|
|
void D_WarpScreen (void);
|
|
void R_PolysetUpdateTables (void);
|
|
|
|
//=======================================================================//
|
|
|
|
// callbacks to Quake
|
|
|
|
extern drawsurf_t r_drawsurf;
|
|
|
|
void R_DrawSurface (void);
|
|
|
|
//extern int c_surf;
|
|
|
|
extern byte r_warpbuffer[WARP_WIDTH * WARP_HEIGHT];
|
|
|
|
|
|
|
|
|
|
extern float scale_for_mip;
|
|
|
|
extern qboolean d_roverwrapped;
|
|
extern surfcache_t *sc_rover;
|
|
extern surfcache_t *d_initial_rover;
|
|
|
|
extern float d_sdivzstepu, d_tdivzstepu, d_zistepu;
|
|
extern float d_sdivzstepv, d_tdivzstepv, d_zistepv;
|
|
extern float d_sdivzorigin, d_tdivzorigin, d_ziorigin;
|
|
|
|
extern fixed16_t sadjust, tadjust;
|
|
extern fixed16_t bbextents, bbextentt;
|
|
|
|
|
|
void D_DrawSpans16 (espan_t *pspans);
|
|
void D_DrawZSpans (espan_t *pspans);
|
|
void Turbulent8 (espan_t *pspan);
|
|
void NonTurbulent8 (espan_t *pspan); //PGM
|
|
|
|
surfcache_t *D_CacheSurface (msurface_t *surface, int miplevel);
|
|
|
|
|
|
extern pixel_t *d_viewbuffer;
|
|
extern short *d_pzbuffer;
|
|
extern unsigned int d_zrowbytes, d_zwidth;
|
|
extern short *zspantable[MAXHEIGHT];
|
|
extern int d_scantable[MAXHEIGHT];
|
|
|
|
extern int d_minmip;
|
|
extern float d_scalemip[3];
|
|
|
|
//===================================================================
|
|
|
|
extern int cachewidth;
|
|
extern pixel_t *cacheblock;
|
|
extern int r_screenwidth;
|
|
|
|
|
|
extern int sintable[1280];
|
|
extern int intsintable[1280];
|
|
extern int blanktable[1280]; // PGM
|
|
|
|
extern surf_t *surfaces, *surface_p, *surf_max;
|
|
|
|
// surfaces are generated in back to front order by the bsp, so if a surf
|
|
// pointer is greater than another one, it should be drawn in front
|
|
// surfaces[1] is the background, and is used as the active surface stack.
|
|
// surfaces[0] is a dummy, because index 0 is used to indicate no surface
|
|
// attached to an edge_t
|
|
|
|
//===================================================================
|
|
|
|
//extern vec3_t sxformaxis[4]; // s axis transformed into viewspace
|
|
//extern vec3_t txformaxis[4]; // t axis transformed into viewspac
|
|
|
|
extern float xcenter, ycenter;
|
|
extern float xscale, yscale;
|
|
extern float xscaleinv, yscaleinv;
|
|
//extern float xscaleshrink, yscaleshrink;
|
|
|
|
|
|
extern edge_t *auxedges;
|
|
extern int r_numallocatededges;
|
|
extern edge_t *r_edges, *edge_p, *edge_max;
|
|
|
|
extern edge_t *newedges[MAXHEIGHT];
|
|
extern edge_t *removeedges[MAXHEIGHT];
|
|
|
|
extern int r_viewcluster, r_oldviewcluster;
|
|
|
|
extern int r_clipflags;
|
|
//extern qboolean r_fov_greater_than_90;
|
|
|
|
|
|
extern cvar_t *sw_aliasstats;
|
|
extern cvar_t *sw_clearcolor;
|
|
extern cvar_t *sw_drawflat;
|
|
extern cvar_t *sw_draworder;
|
|
extern cvar_t *sw_maxedges;
|
|
extern cvar_t *sw_maxsurfs;
|
|
extern cvar_t *sw_mipcap;
|
|
extern cvar_t *sw_mipscale;
|
|
extern cvar_t *sw_reportsurfout;
|
|
extern cvar_t *sw_reportedgeout;
|
|
extern cvar_t *sw_stipplealpha;
|
|
extern cvar_t *sw_surfcacheoverride;
|
|
extern cvar_t *sw_waterwarp;
|
|
extern cvar_t *sw_texfilt;
|
|
extern cvar_t *r_decals;
|
|
extern cvar_t *r_traceglow;
|
|
extern cvar_t *sw_notransbrushes;
|
|
extern cvar_t *sw_noalphabrushes;
|
|
|
|
extern cvar_t *tracerred;
|
|
extern cvar_t *tracergreen;
|
|
extern cvar_t *tracerblue;
|
|
extern cvar_t *traceralpha;
|
|
|
|
|
|
extern struct qfrustum_s {
|
|
mplane_t screenedge[4];
|
|
clipplane_t view_clipplanes[4];
|
|
int frustum_indexes[4*6];
|
|
int *pfrustum_indexes[4];
|
|
} qfrustum;
|
|
|
|
extern cvar_t *r_fullbright;
|
|
|
|
#define CACHESPOT(surf) ((surfcache_t**)surf->info->reserved)
|
|
extern int r_currentkey;
|
|
extern int r_currentbkey;
|
|
extern qboolean insubmodel;
|
|
|
|
extern vec3_t r_entorigin;
|
|
#if XASH_LOW_MEMORY
|
|
extern unsigned short r_leafkeys[MAX_MAP_LEAFS];
|
|
#else
|
|
extern int r_leafkeys[MAX_MAP_LEAFS];
|
|
#endif
|
|
#define LEAF_KEY(pleaf) r_leafkeys[(pleaf - WORLDMODEL->leafs)]
|
|
|
|
|
|
|
|
extern mvertex_t *r_pcurrentvertbase;
|
|
//extern int r_maxvalidedgeoffset;
|
|
|
|
typedef struct
|
|
{
|
|
finalvert_t *a, *b, *c;
|
|
} aliastriangleparms_t;
|
|
|
|
extern aliastriangleparms_t aliastriangleparms;
|
|
|
|
|
|
extern int r_aliasblendcolor;
|
|
|
|
extern float aliasxscale, aliasyscale, aliasxcenter, aliasycenter;
|
|
extern float s_ziscale;
|
|
|
|
void R_DrawTriangle( void );
|
|
//void R_DrawTriangle (finalvert_t *index0, finalvert_t *index1, finalvert_t *index2);
|
|
void R_AliasClipTriangle (finalvert_t *index0, finalvert_t *index1, finalvert_t *index2);
|
|
|
|
//
|
|
// r_bsp.c
|
|
//
|
|
void R_RotateBmodel (void);
|
|
void R_DrawSolidClippedSubmodelPolygons (model_t *pmodel, mnode_t *topnode);
|
|
void R_DrawSubmodelPolygons (model_t *pmodel, int clipflags, mnode_t *topnode);
|
|
void R_DrawBrushModel(cl_entity_t *pent);
|
|
|
|
//
|
|
// r_blitscreen.c
|
|
//
|
|
void R_InitCaches (void);
|
|
void R_BlitScreen( void );
|
|
void R_InitBlit( qboolean gl );
|
|
qboolean R_SetDisplayTransform( ref_screen_rotation_t rotate, int offset_x, int offset_y, float scale_x, float scale_y );
|
|
|
|
//
|
|
// r_edge.c
|
|
//
|
|
void R_SurfacePatch (void);
|
|
void R_BeginEdgeFrame (void);
|
|
void R_RenderWorld (void);
|
|
void R_ScanEdges (void);
|
|
|
|
|
|
//
|
|
// r_surf.c
|
|
//
|
|
void D_FlushCaches( void );
|
|
|
|
//
|
|
// r_draw.c
|
|
//
|
|
void Draw_Fill (int x, int y, int w, int h);
|
|
|
|
//
|
|
// r_misc.c
|
|
//
|
|
void R_SetupFrameQ (void);
|
|
void R_TransformFrustum (void);
|
|
void TransformVector (vec3_t in, vec3_t out);
|
|
|
|
//
|
|
// r_rast.c
|
|
//
|
|
void R_RenderBmodelFace (bedge_t *pedges, msurface_t *psurf);
|
|
void R_RenderFace (msurface_t *fa, int clipflags);
|
|
|
|
//
|
|
// r_main.c
|
|
//
|
|
|
|
void R_RenderTriangle( finalvert_t *fv1 , finalvert_t *fv2, finalvert_t *fv3 );
|
|
void R_SetupFinalVert( finalvert_t *fv, float x, float y, float z, int light, int s, int t );
|
|
void RotatedBBox (vec3_t mins, vec3_t maxs, vec3_t angles, vec3_t tmins, vec3_t tmaxs);
|
|
int R_BmodelCheckBBox (float *minmaxs);
|
|
int CL_FxBlend( cl_entity_t *e );
|
|
|
|
|
|
void R_SetUpWorldTransform (void);
|
|
|
|
#define BLEND_ALPHA_LOW(alpha, src, screen) (vid.alphamap[((alpha) << 18) | (((src) & 0xff00) << 2) | ((screen) >> 6)] | ((screen) & 0x3f))
|
|
#define BLEND_ALPHA(alpha, src, dst) (alpha) > 3?BLEND_ALPHA_LOW(7 - 1 - (alpha), (dst), (src)) : BLEND_ALPHA_LOW((alpha)-1, (src), (dst))
|
|
#define BLEND_ADD(src, screen) vid.addmap[((src)& 0xff00)|((screen)>>8)] << 8 | ((screen) & 0xff) | (((src) & 0xff) >> 0);
|
|
#define BLEND_COLOR(src, color) vid.modmap[((src) & 0xff00)|((color)>>8)] << 8 | ((src) & (color) & 0xff) | (((src) & 0xff) >> 3);
|
|
|
|
#define LM_SAMPLE_SIZE_AUTO(surf) (tr.sample_size == -1?gEngfuncs.Mod_SampleSizeForFace( surf ): tr.sample_size)
|
|
|
|
|
|
|
|
//
|
|
// engine callbacks
|
|
//
|
|
#include "crtlib.h"
|
|
#include "crclib.h"
|
|
#if 1
|
|
#define Mem_Malloc( pool, size ) gEngfuncs._Mem_Alloc( pool, size, false, __FILE__, __LINE__ )
|
|
#define Mem_Calloc( pool, size ) gEngfuncs._Mem_Alloc( pool, size, true, __FILE__, __LINE__ )
|
|
#define Mem_Realloc( pool, ptr, size ) gEngfuncs._Mem_Realloc( pool, ptr, size, true, __FILE__, __LINE__ )
|
|
#define Mem_Free( mem ) gEngfuncs._Mem_Free( mem, __FILE__, __LINE__ )
|
|
#define Mem_AllocPool( name ) gEngfuncs._Mem_AllocPool( name, __FILE__, __LINE__ )
|
|
#define Mem_FreePool( pool ) gEngfuncs._Mem_FreePool( pool, __FILE__, __LINE__ )
|
|
#define Mem_EmptyPool( pool ) gEngfuncs._Mem_EmptyPool( pool, __FILE__, __LINE__ )
|
|
#else
|
|
#define Mem_Malloc( pool, size ) malloc(size)
|
|
#define Mem_Calloc( pool, size ) calloc(1,size)
|
|
#define Mem_Realloc( pool, ptr, size ) realloc(ptr, size)
|
|
#define Mem_Free( mem ) free(mem)
|
|
#define Mem_AllocPool( name ) gEngfuncs._Mem_AllocPool( name, __FILE__, __LINE__ )
|
|
#define Mem_FreePool( pool ) gEngfuncs._Mem_FreePool( pool, __FILE__, __LINE__ )
|
|
#define Mem_EmptyPool( pool ) gEngfuncs._Mem_EmptyPool( pool, __FILE__, __LINE__ )
|
|
#endif
|
|
#endif // GL_LOCAL_H
|