DOOM-3-BFG

AutoRender.cpp (8016B)

---

 /*
 ===========================================================================
 
 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 int AUTO_RENDER_STACK_SIZE = 256 * 1024;
 
 idAutoRender rAutoRender;
 
 /*
 ============================
 idAutoRender::idAutoRender
 ============================
 */
 idAutoRender::idAutoRender() {
 	nextRotateTime = 0.0f;
 	currentRotation = 0.0f;
 	autoRenderIcon = AUTORENDER_DEFAULTICON;
 }
 
 /*
 ============================
 idAutoRender::Run
 ============================
 */
 int idAutoRender::Run() {
 	while ( !IsTerminating() ) {
 		RenderFrame();
 	}
 
 
 	return 0;
 }
 
 /*
 ============================
 idAutoRender::StartBackgroundAutoSwaps
 ============================
 */
 void idAutoRender::StartBackgroundAutoSwaps( autoRenderIconType_t iconType ) {
 
 
 	if ( IsRunning() ) {
 		EndBackgroundAutoSwaps();
 	}
 
 	autoRenderIcon = iconType;
 
 	idLib::Printf("Starting Background AutoSwaps\n");
 
 	const bool captureToImage = true;
 	common->UpdateScreen( captureToImage );
 
 	// unbind any shaders prior to entering the background autoswaps so we don't run 
 	// into any problems with cached vertex shader indices from the main thread
 	renderProgManager.Unbind();
 
 	// unbind all texture units so we don't run into a race condition where the device is owned
 	// by the autorender thread but an image is trying to be unset from the main thread because
 	// it is getting purged before our our first frame has been rendered.
 	globalImages->UnbindAll();
 
 
 	StartThread("BackgroundAutoSwaps", CORE_0B, THREAD_NORMAL, AUTO_RENDER_STACK_SIZE );
 }
 
 /*
 ============================
 idAutoRender::EndBackgroundAutoSwaps
 ============================
 */
 void idAutoRender::EndBackgroundAutoSwaps() {
 	idLib::Printf("End Background AutoSwaps\n");
 
 	StopThread();
 
 }
 
 /*
 ============================
 idAutoRender::RenderFrame
 ============================
 */
 void idAutoRender::RenderFrame() {
 	// values are 0 to 1
 	float loadingIconPosX = 0.5f;
 	float loadingIconPosY = 0.6f;
 	float loadingIconScale = 0.025f;
 	float loadingIconSpeed = 0.095f;
 
 	if ( autoRenderIcon == AUTORENDER_HELLICON ) {
 		loadingIconPosX = 0.85f;
 		loadingIconPosY = 0.85f;
 		loadingIconScale = 0.1f;
 		loadingIconSpeed = 0.095f;
 	} else if ( autoRenderIcon == AUTORENDER_DIALOGICON ) {
 		loadingIconPosY = 0.73f;
 	}
 
 
 	GL_SetDefaultState();
 	
 	GL_Cull( CT_TWO_SIDED );
 	
 	const bool stereoRender = false;
 
 	const int width = renderSystem->GetWidth();
 	const int height = renderSystem->GetHeight();
 	const int guardBand = height / 24;
 
 	if ( stereoRender ) {
 		for ( int viewNum = 0 ; viewNum < 2; viewNum++ ) {
 			GL_ViewportAndScissor( 0, viewNum * ( height + guardBand ), width, height );
 			RenderBackground();
 			RenderLoadingIcon( loadingIconPosX, loadingIconPosY, loadingIconScale, loadingIconSpeed );
 		}
 	} else {
 		GL_ViewportAndScissor( 0, 0, width, height );
 		RenderBackground();
 		RenderLoadingIcon( loadingIconPosX, loadingIconPosY, loadingIconScale, loadingIconSpeed );
 	}
 
 }
 
 /*
 ============================
 idAutoRender::RenderBackground
 ============================
 */
 void idAutoRender::RenderBackground() {
 	GL_SelectTexture( 0 );
 
 	globalImages->currentRenderImage->Bind();
 
 	GL_State( GLS_DEPTHFUNC_ALWAYS | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO );
 
 	float mvpMatrix[16] = { 0 };
 	mvpMatrix[0] = 1;
 	mvpMatrix[5] = 1;
 	mvpMatrix[10] = 1;
 	mvpMatrix[15] = 1;
 
 	// Set Parms
 	float texS[4] = { 1.0f, 0.0f, 0.0f, 0.0f };
 	float texT[4] = { 0.0f, 1.0f, 0.0f, 0.0f };
 	renderProgManager.SetRenderParm( RENDERPARM_TEXTUREMATRIX_S, texS );
 	renderProgManager.SetRenderParm( RENDERPARM_TEXTUREMATRIX_T, texT );
 
 	// disable texgen
 	float texGenEnabled[4] = { 0, 0, 0, 0 };
 	renderProgManager.SetRenderParm( RENDERPARM_TEXGEN_0_ENABLED, texGenEnabled );
 
 	// set matrix
 	renderProgManager.SetRenderParms( RENDERPARM_MVPMATRIX_X, mvpMatrix, 4 );
 
 	renderProgManager.BindShader_TextureVertexColor();
 
 	RB_DrawElementsWithCounters( &backEnd.unitSquareSurface );
 }
 
 /*
 ============================
 idAutoRender::RenderLoadingIcon
 ============================
 */
 void idAutoRender::RenderLoadingIcon( float fracX, float fracY, float size, float speed ) {
 
 	float s = 0.0f; 
 	float c = 1.0f;
 
 	if ( autoRenderIcon != AUTORENDER_HELLICON ) {
 		if ( Sys_Milliseconds() >= nextRotateTime ) {
 			nextRotateTime = Sys_Milliseconds() + 100;
 			currentRotation -= 90.0f;
 		}
 		float angle = DEG2RAD( currentRotation );
 		idMath::SinCos( angle, s, c );
 	}
 
 	const float pixelAspect = renderSystem->GetPixelAspect();
 	const float screenWidth = renderSystem->GetWidth();
 	const float screenHeight = renderSystem->GetHeight();
 
 	const float minSize = Min( screenWidth, screenHeight );
 	if ( minSize <= 0.0f ) {
 		return;
 	}
 
 	float scaleX = size * minSize / screenWidth;
 	float scaleY = size * minSize / screenHeight;
 
 	float scale[16] = { 0 };
 	scale[0] = c * scaleX / pixelAspect;
 	scale[1] = -s * scaleY;
 	scale[4] = s * scaleX / pixelAspect;
 	scale[5] = c * scaleY;
 	scale[10] = 1.0f;
 	scale[15] = 1.0f;
 
 	scale[12] = fracX;
 	scale[13] = fracY;
 
 	float ortho[16] = { 0 };
 	ortho[0] = 2.0f;
 	ortho[5] = -2.0f;
 	ortho[10] = -2.0f;
 	ortho[12] = -1.0f;
 	ortho[13] = 1.0f;
 	ortho[14] = -1.0f;
 	ortho[15] = 1.0f;
 
 	float finalOrtho[16];
 	R_MatrixMultiply( scale, ortho, finalOrtho );
 
 	float projMatrixTranspose[16];
 	R_MatrixTranspose( finalOrtho, projMatrixTranspose );
 	renderProgManager.SetRenderParms( RENDERPARM_MVPMATRIX_X, projMatrixTranspose, 4 );
 
 	float a = 1.0f;
 	if ( autoRenderIcon == AUTORENDER_HELLICON ) {
 		float alpha = DEG2RAD( Sys_Milliseconds() * speed );
 		a = idMath::Sin( alpha );
 		a = 0.35f + ( 0.65f * idMath::Fabs( a ) );
 	}
 
 	GL_SelectTexture( 0 );
 
 	if ( autoRenderIcon == AUTORENDER_HELLICON ) {
 		globalImages->hellLoadingIconImage->Bind();
 	} else {
 		globalImages->loadingIconImage->Bind();
 	}
 
 	GL_State( GLS_DEPTHFUNC_ALWAYS | GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
 
 	// Set Parms
 	float texS[4] = { 1.0f, 0.0f, 0.0f, 0.0f };
 	float texT[4] = { 0.0f, 1.0f, 0.0f, 0.0f };
 	renderProgManager.SetRenderParm( RENDERPARM_TEXTUREMATRIX_S, texS );
 	renderProgManager.SetRenderParm( RENDERPARM_TEXTUREMATRIX_T, texT );
 
 	if ( autoRenderIcon == AUTORENDER_HELLICON ) {
 		GL_Color( 1.0f, 1.0f, 1.0f, a );
 	}
 
 	// disable texgen
 	float texGenEnabled[4] = { 0, 0, 0, 0 };
 	renderProgManager.SetRenderParm( RENDERPARM_TEXGEN_0_ENABLED, texGenEnabled );
 
 	renderProgManager.BindShader_TextureVertexColor();
 
 	RB_DrawElementsWithCounters( &backEnd.unitSquareSurface );
 }