mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-23 21:02:11 +00:00
79ad905e05
Excluding 3rd party files.
143 lines
5.4 KiB
C++
143 lines
5.4 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 Source Code 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.
|
|
|
|
Doom 3 Source Code 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 Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
// vertex cache calls should only be made by the front end
|
|
|
|
const int NUM_VERTEX_FRAMES = 2;
|
|
|
|
typedef enum {
|
|
TAG_FREE,
|
|
TAG_USED,
|
|
TAG_FIXED, // for the temp buffers
|
|
TAG_TEMP // in frame temp area, not static area
|
|
} vertBlockTag_t;
|
|
|
|
typedef struct vertCache_s {
|
|
GLuint vbo;
|
|
void *virtMem; // only one of vbo / virtMem will be set
|
|
bool indexBuffer; // holds indexes instead of vertexes
|
|
|
|
int offset;
|
|
int size; // may be larger than the amount asked for, due
|
|
// to round up and minimum fragment sizes
|
|
int tag; // a tag of 0 is a free block
|
|
struct vertCache_s ** user; // will be set to zero when purged
|
|
struct vertCache_s *next, *prev; // may be on the static list or one of the frame lists
|
|
int frameUsed; // it can't be purged if near the current frame
|
|
} vertCache_t;
|
|
|
|
|
|
class idVertexCache {
|
|
public:
|
|
void Init();
|
|
void Shutdown();
|
|
|
|
// just for gfxinfo printing
|
|
bool IsFast();
|
|
|
|
// called when vertex programs are enabled or disabled, because
|
|
// the cached data is no longer valid
|
|
void PurgeAll();
|
|
|
|
// Tries to allocate space for the given data in fast vertex
|
|
// memory, and copies it over.
|
|
// Alloc does NOT do a touch, which allows purging of things
|
|
// created at level load time even if a frame hasn't passed yet.
|
|
// These allocations can be purged, which will zero the pointer.
|
|
void Alloc( void *data, int bytes, vertCache_t **buffer, bool indexBuffer = false );
|
|
|
|
// This will be a real pointer with virtual memory,
|
|
// but it will be an int offset cast to a pointer of ARB_vertex_buffer_object
|
|
void * Position( vertCache_t *buffer );
|
|
|
|
// if r_useIndexBuffers is enabled, but you need to draw something without
|
|
// an indexCache, this must be called to reset GL_ELEMENT_ARRAY_BUFFER_ARB
|
|
void UnbindIndex();
|
|
|
|
// automatically freed at the end of the next frame
|
|
// used for specular texture coordinates and gui drawing, which
|
|
// will change every frame.
|
|
// will return NULL if the vertex cache is completely full
|
|
// As with Position(), this may not actually be a pointer you can access.
|
|
vertCache_t * AllocFrameTemp( void *data, int bytes );
|
|
|
|
// notes that a buffer is used this frame, so it can't be purged
|
|
// out from under the GPU
|
|
void Touch( vertCache_t *buffer );
|
|
|
|
// this block won't have to zero a buffer pointer when it is purged,
|
|
// but it must still wait for the frames to pass, in case the GPU
|
|
// is still referencing it
|
|
void Free( vertCache_t *buffer );
|
|
|
|
// updates the counter for determining which temp space to use
|
|
// and which blocks can be purged
|
|
// Also prints debugging info when enabled
|
|
void EndFrame();
|
|
|
|
// listVertexCache calls this
|
|
void List();
|
|
|
|
private:
|
|
void InitMemoryBlocks( int size );
|
|
void ActuallyFree( vertCache_t *block );
|
|
|
|
static idCVar r_showVertexCache;
|
|
static idCVar r_vertexBufferMegs;
|
|
|
|
int staticCountTotal;
|
|
int staticAllocTotal; // for end of frame purging
|
|
|
|
int staticAllocThisFrame; // debug counter
|
|
int staticCountThisFrame;
|
|
int dynamicAllocThisFrame;
|
|
int dynamicCountThisFrame;
|
|
|
|
int currentFrame; // for purgable block tracking
|
|
int listNum; // currentFrame % NUM_VERTEX_FRAMES, determines which tempBuffers to use
|
|
|
|
bool virtualMemory; // not fast stuff
|
|
|
|
bool allocatingTempBuffer; // force GL_STREAM_DRAW_ARB
|
|
|
|
vertCache_t *tempBuffers[NUM_VERTEX_FRAMES]; // allocated at startup
|
|
bool tempOverflow; // had to alloc a temp in static memory
|
|
|
|
idBlockAlloc<vertCache_t,1024> headerAllocator;
|
|
|
|
vertCache_t freeStaticHeaders; // head of doubly linked list
|
|
vertCache_t freeDynamicHeaders; // head of doubly linked list
|
|
vertCache_t dynamicHeaders; // head of doubly linked list
|
|
vertCache_t deferredFreeList; // head of doubly linked list
|
|
vertCache_t staticHeaders; // head of doubly linked list in MRU order,
|
|
// staticHeaders.next is most recently used
|
|
|
|
int frameBytes; // for each of NUM_VERTEX_FRAMES frames
|
|
};
|
|
|
|
extern idVertexCache vertexCache;
|