mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2026-03-20 09:00:25 +01:00
Initial commit
This commit is contained in:
Brian Harris
371
neo/renderer/GuiModel.cpp
Normal file
371
neo/renderer/GuiModel.cpp
Normal file
@@ -0,0 +1,371 @@
|
||||
/*
|
||||
===========================================================================
|
||||
|
||||
Doom 3 BFG Edition GPL Source Code
|
||||
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
||||
|
||||
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
||||
|
||||
Doom 3 BFG Edition 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 BFG Edition 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 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
In addition, the Doom 3 BFG Edition 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 BFG Edition 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.
|
||||
|
||||
===========================================================================
|
||||
*/
|
||||
|
||||
#pragma hdrstop
|
||||
#include "../idlib/precompiled.h"
|
||||
|
||||
#include "tr_local.h"
|
||||
|
||||
const float idGuiModel::STEREO_DEPTH_NEAR = 0.0f;
|
||||
const float idGuiModel::STEREO_DEPTH_MID = 0.5f;
|
||||
const float idGuiModel::STEREO_DEPTH_FAR = 1.0f;
|
||||
|
||||
/*
|
||||
================
|
||||
idGuiModel::idGuiModel
|
||||
================
|
||||
*/
|
||||
idGuiModel::idGuiModel() {
|
||||
// identity color for drawsurf register evaluation
|
||||
for ( int i = 0; i < MAX_ENTITY_SHADER_PARMS; i++ ) {
|
||||
shaderParms[i] = 1.0f;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
idGuiModel::Clear
|
||||
|
||||
Begins collecting draw commands into surfaces
|
||||
================
|
||||
*/
|
||||
void idGuiModel::Clear() {
|
||||
surfaces.SetNum( 0 );
|
||||
AdvanceSurf();
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
idGuiModel::WriteToDemo
|
||||
================
|
||||
*/
|
||||
void idGuiModel::WriteToDemo( idDemoFile *demo ) {
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
idGuiModel::ReadFromDemo
|
||||
================
|
||||
*/
|
||||
void idGuiModel::ReadFromDemo( idDemoFile *demo ) {
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
idGuiModel::BeginFrame
|
||||
================
|
||||
*/
|
||||
void idGuiModel::BeginFrame() {
|
||||
vertexBlock = vertexCache.AllocVertex( NULL, ALIGN( MAX_VERTS * sizeof( idDrawVert ), VERTEX_CACHE_ALIGN ) );
|
||||
indexBlock = vertexCache.AllocIndex( NULL, ALIGN( MAX_INDEXES * sizeof( triIndex_t ), INDEX_CACHE_ALIGN ) );
|
||||
vertexPointer = (idDrawVert *)vertexCache.MappedVertexBuffer( vertexBlock );
|
||||
indexPointer = (triIndex_t *)vertexCache.MappedIndexBuffer( indexBlock );
|
||||
numVerts = 0;
|
||||
numIndexes = 0;
|
||||
Clear();
|
||||
}
|
||||
|
||||
idCVar stereoRender_defaultGuiDepth( "stereoRender_defaultGuiDepth", "0", CVAR_RENDERER, "Fraction of separation when not specified" );
|
||||
/*
|
||||
================
|
||||
EmitSurfaces
|
||||
|
||||
For full screen GUIs, we can add in per-surface stereoscopic depth effects
|
||||
================
|
||||
*/
|
||||
void idGuiModel::EmitSurfaces( float modelMatrix[16], float modelViewMatrix[16],
|
||||
bool depthHack, bool allowFullScreenStereoDepth, bool linkAsEntity ) {
|
||||
|
||||
viewEntity_t * guiSpace = (viewEntity_t *)R_ClearedFrameAlloc( sizeof( *guiSpace ), FRAME_ALLOC_VIEW_ENTITY );
|
||||
memcpy( guiSpace->modelMatrix, modelMatrix, sizeof( guiSpace->modelMatrix ) );
|
||||
memcpy( guiSpace->modelViewMatrix, modelViewMatrix, sizeof( guiSpace->modelViewMatrix ) );
|
||||
guiSpace->weaponDepthHack = depthHack;
|
||||
guiSpace->isGuiSurface = true;
|
||||
|
||||
// If this is an in-game gui, we need to be able to find the matrix again for head mounted
|
||||
// display bypass matrix fixup.
|
||||
if ( linkAsEntity ) {
|
||||
guiSpace->next = tr.viewDef->viewEntitys;
|
||||
tr.viewDef->viewEntitys = guiSpace;
|
||||
}
|
||||
|
||||
//---------------------------
|
||||
// make a tech5 renderMatrix
|
||||
//---------------------------
|
||||
idRenderMatrix viewMat;
|
||||
idRenderMatrix::Transpose( *(idRenderMatrix *)modelViewMatrix, viewMat );
|
||||
idRenderMatrix::Multiply( tr.viewDef->projectionRenderMatrix, viewMat, guiSpace->mvp );
|
||||
if ( depthHack ) {
|
||||
idRenderMatrix::ApplyDepthHack( guiSpace->mvp );
|
||||
}
|
||||
|
||||
// to allow 3D-TV effects in the menu system, we define surface flags to set
|
||||
// depth fractions between 0=screen and 1=infinity, which directly modulate the
|
||||
// screenSeparation parameter for an X offset.
|
||||
// The value is stored in the drawSurf sort value, which adjusts the matrix in the
|
||||
// backend.
|
||||
float defaultStereoDepth = stereoRender_defaultGuiDepth.GetFloat(); // default to at-screen
|
||||
|
||||
// add the surfaces to this view
|
||||
for ( int i = 0; i < surfaces.Num(); i++ ) {
|
||||
const guiModelSurface_t & guiSurf = surfaces[i];
|
||||
if ( guiSurf.numIndexes == 0 ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const idMaterial * shader = guiSurf.material;
|
||||
drawSurf_t * drawSurf = (drawSurf_t *)R_FrameAlloc( sizeof( *drawSurf ), FRAME_ALLOC_DRAW_SURFACE );
|
||||
|
||||
drawSurf->numIndexes = guiSurf.numIndexes;
|
||||
drawSurf->ambientCache = vertexBlock;
|
||||
// build a vertCacheHandle_t that points inside the allocated block
|
||||
drawSurf->indexCache = indexBlock + ( (int64)(guiSurf.firstIndex*sizeof(triIndex_t)) << VERTCACHE_OFFSET_SHIFT );
|
||||
drawSurf->shadowCache = 0;
|
||||
drawSurf->jointCache = 0;
|
||||
drawSurf->frontEndGeo = NULL;
|
||||
drawSurf->space = guiSpace;
|
||||
drawSurf->material = shader;
|
||||
drawSurf->extraGLState = guiSurf.glState;
|
||||
drawSurf->scissorRect = tr.viewDef->scissor;
|
||||
drawSurf->sort = shader->GetSort();
|
||||
drawSurf->renderZFail = 0;
|
||||
// process the shader expressions for conditionals / color / texcoords
|
||||
const float *constRegs = shader->ConstantRegisters();
|
||||
if ( constRegs ) {
|
||||
// shader only uses constant values
|
||||
drawSurf->shaderRegisters = constRegs;
|
||||
} else {
|
||||
float *regs = (float *)R_FrameAlloc( shader->GetNumRegisters() * sizeof( float ), FRAME_ALLOC_SHADER_REGISTER );
|
||||
drawSurf->shaderRegisters = regs;
|
||||
shader->EvaluateRegisters( regs, shaderParms, tr.viewDef->renderView.shaderParms, tr.viewDef->renderView.time[1] * 0.001f, NULL );
|
||||
}
|
||||
R_LinkDrawSurfToView( drawSurf, tr.viewDef );
|
||||
if ( allowFullScreenStereoDepth ) {
|
||||
// override sort with the stereoDepth
|
||||
//drawSurf->sort = stereoDepth;
|
||||
|
||||
switch ( guiSurf.stereoType ) {
|
||||
case STEREO_DEPTH_TYPE_NEAR: drawSurf->sort = STEREO_DEPTH_NEAR; break;
|
||||
case STEREO_DEPTH_TYPE_MID: drawSurf->sort = STEREO_DEPTH_MID; break;
|
||||
case STEREO_DEPTH_TYPE_FAR: drawSurf->sort = STEREO_DEPTH_FAR; break;
|
||||
case STEREO_DEPTH_TYPE_NONE:
|
||||
default:
|
||||
drawSurf->sort = defaultStereoDepth;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
EmitToCurrentView
|
||||
====================
|
||||
*/
|
||||
void idGuiModel::EmitToCurrentView( float modelMatrix[16], bool depthHack ) {
|
||||
float modelViewMatrix[16];
|
||||
|
||||
R_MatrixMultiply( modelMatrix, tr.viewDef->worldSpace.modelViewMatrix, modelViewMatrix );
|
||||
|
||||
EmitSurfaces( modelMatrix, modelViewMatrix, depthHack, false /* stereoDepthSort */, true /* link as entity */ );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
================
|
||||
idGuiModel::EmitFullScreen
|
||||
|
||||
Creates a view that covers the screen and emit the surfaces
|
||||
================
|
||||
*/
|
||||
void idGuiModel::EmitFullScreen() {
|
||||
|
||||
if ( surfaces[0].numIndexes == 0 ) {
|
||||
return;
|
||||
}
|
||||
|
||||
SCOPED_PROFILE_EVENT( "Gui::EmitFullScreen" );
|
||||
|
||||
viewDef_t * viewDef = (viewDef_t *)R_ClearedFrameAlloc( sizeof( *viewDef ), FRAME_ALLOC_VIEW_DEF );
|
||||
viewDef->is2Dgui = true;
|
||||
tr.GetCroppedViewport( &viewDef->viewport );
|
||||
|
||||
bool stereoEnabled = ( renderSystem->GetStereo3DMode() != STEREO3D_OFF );
|
||||
if ( stereoEnabled ) {
|
||||
float GetScreenSeparationForGuis();
|
||||
const float screenSeparation = GetScreenSeparationForGuis();
|
||||
|
||||
// this will be negated on the alternate eyes, both rendered each frame
|
||||
viewDef->renderView.stereoScreenSeparation = screenSeparation;
|
||||
|
||||
extern idCVar stereoRender_swapEyes;
|
||||
viewDef->renderView.viewEyeBuffer = 0; // render to both buffers
|
||||
if ( stereoRender_swapEyes.GetBool() ) {
|
||||
viewDef->renderView.stereoScreenSeparation = -screenSeparation;
|
||||
}
|
||||
}
|
||||
|
||||
viewDef->scissor.x1 = 0;
|
||||
viewDef->scissor.y1 = 0;
|
||||
viewDef->scissor.x2 = viewDef->viewport.x2 - viewDef->viewport.x1;
|
||||
viewDef->scissor.y2 = viewDef->viewport.y2 - viewDef->viewport.y1;
|
||||
|
||||
viewDef->projectionMatrix[0*4+0] = 2.0f / SCREEN_WIDTH;
|
||||
viewDef->projectionMatrix[0*4+1] = 0.0f;
|
||||
viewDef->projectionMatrix[0*4+2] = 0.0f;
|
||||
viewDef->projectionMatrix[0*4+3] = 0.0f;
|
||||
|
||||
viewDef->projectionMatrix[1*4+0] = 0.0f;
|
||||
viewDef->projectionMatrix[1*4+1] = -2.0f / SCREEN_HEIGHT;
|
||||
viewDef->projectionMatrix[1*4+2] = 0.0f;
|
||||
viewDef->projectionMatrix[1*4+3] = 0.0f;
|
||||
|
||||
viewDef->projectionMatrix[2*4+0] = 0.0f;
|
||||
viewDef->projectionMatrix[2*4+1] = 0.0f;
|
||||
viewDef->projectionMatrix[2*4+2] = -2.0f;
|
||||
viewDef->projectionMatrix[2*4+3] = 0.0f;
|
||||
|
||||
viewDef->projectionMatrix[3*4+0] = -1.0f;
|
||||
viewDef->projectionMatrix[3*4+1] = 1.0f;
|
||||
viewDef->projectionMatrix[3*4+2] = -1.0f;
|
||||
viewDef->projectionMatrix[3*4+3] = 1.0f;
|
||||
|
||||
// make a tech5 renderMatrix for faster culling
|
||||
idRenderMatrix::Transpose( *(idRenderMatrix *)viewDef->projectionMatrix, viewDef->projectionRenderMatrix );
|
||||
|
||||
viewDef->worldSpace.modelMatrix[0*4+0] = 1.0f;
|
||||
viewDef->worldSpace.modelMatrix[1*4+1] = 1.0f;
|
||||
viewDef->worldSpace.modelMatrix[2*4+2] = 1.0f;
|
||||
viewDef->worldSpace.modelMatrix[3*4+3] = 1.0f;
|
||||
|
||||
viewDef->worldSpace.modelViewMatrix[0*4+0] = 1.0f;
|
||||
viewDef->worldSpace.modelViewMatrix[1*4+1] = 1.0f;
|
||||
viewDef->worldSpace.modelViewMatrix[2*4+2] = 1.0f;
|
||||
viewDef->worldSpace.modelViewMatrix[3*4+3] = 1.0f;
|
||||
|
||||
viewDef->maxDrawSurfs = surfaces.Num();
|
||||
viewDef->drawSurfs = (drawSurf_t **)R_FrameAlloc( viewDef->maxDrawSurfs * sizeof( viewDef->drawSurfs[0] ), FRAME_ALLOC_DRAW_SURFACE_POINTER );
|
||||
viewDef->numDrawSurfs = 0;
|
||||
|
||||
viewDef_t * oldViewDef = tr.viewDef;
|
||||
tr.viewDef = viewDef;
|
||||
|
||||
EmitSurfaces( viewDef->worldSpace.modelMatrix, viewDef->worldSpace.modelViewMatrix,
|
||||
false /* depthHack */ , stereoEnabled /* stereoDepthSort */, false /* link as entity */ );
|
||||
|
||||
tr.viewDef = oldViewDef;
|
||||
|
||||
// add the command to draw this view
|
||||
R_AddDrawViewCmd( viewDef, true );
|
||||
}
|
||||
|
||||
/*
|
||||
=============
|
||||
AdvanceSurf
|
||||
=============
|
||||
*/
|
||||
void idGuiModel::AdvanceSurf() {
|
||||
guiModelSurface_t s;
|
||||
|
||||
if ( surfaces.Num() ) {
|
||||
s.material = surf->material;
|
||||
s.glState = surf->glState;
|
||||
} else {
|
||||
s.material = tr.defaultMaterial;
|
||||
s.glState = 0;
|
||||
}
|
||||
|
||||
// advance indexes so the pointer to each surface will be 16 byte aligned
|
||||
numIndexes = ALIGN( numIndexes, 8 );
|
||||
|
||||
s.numIndexes = 0;
|
||||
s.firstIndex = numIndexes;
|
||||
|
||||
surfaces.Append( s );
|
||||
surf = &surfaces[ surfaces.Num() - 1 ];
|
||||
}
|
||||
|
||||
/*
|
||||
=============
|
||||
AllocTris
|
||||
=============
|
||||
*/
|
||||
idDrawVert * idGuiModel::AllocTris( int vertCount, const triIndex_t * tempIndexes, int indexCount, const idMaterial * material, const uint64 glState, const stereoDepthType_t stereoType ) {
|
||||
if ( material == NULL ) {
|
||||
return NULL;
|
||||
}
|
||||
if ( numIndexes + indexCount > MAX_INDEXES ) {
|
||||
static int warningFrame = 0;
|
||||
if ( warningFrame != tr.frameCount ) {
|
||||
warningFrame = tr.frameCount;
|
||||
idLib::Warning( "idGuiModel::AllocTris: MAX_INDEXES exceeded" );
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
if ( numVerts + vertCount > MAX_VERTS ) {
|
||||
static int warningFrame = 0;
|
||||
if ( warningFrame != tr.frameCount ) {
|
||||
warningFrame = tr.frameCount;
|
||||
idLib::Warning( "idGuiModel::AllocTris: MAX_VERTS exceeded" );
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// break the current surface if we are changing to a new material or we can't
|
||||
// fit the data into our allocated block
|
||||
if ( material != surf->material || glState != surf->glState || stereoType != surf->stereoType ) {
|
||||
if ( surf->numIndexes ) {
|
||||
AdvanceSurf();
|
||||
}
|
||||
surf->material = material;
|
||||
surf->glState = glState;
|
||||
surf->stereoType = stereoType;
|
||||
}
|
||||
|
||||
int startVert = numVerts;
|
||||
int startIndex = numIndexes;
|
||||
|
||||
numVerts += vertCount;
|
||||
numIndexes += indexCount;
|
||||
|
||||
surf->numIndexes += indexCount;
|
||||
|
||||
if ( ( startIndex & 1 ) || ( indexCount & 1 ) ) {
|
||||
// slow for write combined memory!
|
||||
// this should be very rare, since quads are always an even index count
|
||||
for ( int i = 0; i < indexCount; i++ ) {
|
||||
indexPointer[startIndex + i] = startVert + tempIndexes[i];
|
||||
}
|
||||
} else {
|
||||
for ( int i = 0; i < indexCount; i += 2 ) {
|
||||
WriteIndexPair( indexPointer + startIndex + i, startVert + tempIndexes[i], startVert + tempIndexes[i+1] );
|
||||
}
|
||||
}
|
||||
|
||||
return vertexPointer + startVert;
|
||||
}
|
||||
Reference in New Issue
Block a user