TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-02-13 03:33:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Engine directory for ticket #1

Browse source
This commit is contained in:
DavidWyand-GG 2012-09-19 11:15:01 -04:00
parent 352279af7a
commit 7dbfe6994d
3795 changed files with 1363358 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

200
Engine/source/renderInstance/renderTerrainMgr.cpp Normal file
View file

@ -0,0 +1,200 @@
//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------
#include "platform/platform.h"
#include "renderInstance/renderTerrainMgr.h"
#include "platform/profiler.h"
#include "scene/sceneManager.h"
#include "gfx/gfxTransformSaver.h"
#include "gfx/gfxDrawUtil.h"
#include "gfx/gfxDebugEvent.h"
#include "materials/shaderData.h"
#include "materials/matInstance.h"
#include "scene/sceneRenderState.h"
#include "console/consoleTypes.h"
#include "terrain/terrCell.h"
#include "terrain/terrCellMaterial.h"
#include "math/util/matrixSet.h"
bool RenderTerrainMgr::smRenderWireframe = false;
S32 RenderTerrainMgr::smCellsRendered = 0;
S32 RenderTerrainMgr::smOverrideCells = 0;
S32 RenderTerrainMgr::smDrawCalls = 0;
IMPLEMENT_CONOBJECT(RenderTerrainMgr);
ConsoleDocClass( RenderTerrainMgr,
"@brief A render bin for terrain mesh rendering.\n\n"
"This bin renders terrain render instances from a TerrainBlock. "
"Normally a mesh would render via the RenderMeshMgr, but terrain uses "
"a TerrainMaterial designed for multi-layered surfaces which this "
"bin can processs.\n\n"
"@ingroup RenderBin\n" );
RenderTerrainMgr::RenderTerrainMgr()
: RenderBinManager( RenderPassManager::RIT_Terrain, 1.0f, 1.0f )
{
}
RenderTerrainMgr::RenderTerrainMgr( F32 renderOrder, F32 processAddOrder )
: RenderBinManager( RenderPassManager::RIT_Terrain, renderOrder, processAddOrder )
{
}
RenderTerrainMgr::~RenderTerrainMgr()
{
}
void RenderTerrainMgr::initPersistFields()
{
Con::addVariable( "RenderTerrainMgr::renderWireframe", TypeBool, &smRenderWireframe,
"Used to enable wireframe rendering on terrain for debugging.\n"
"@ingroup RenderBin\n" );
// For stats.
GFXDevice::getDeviceEventSignal().notify( &RenderTerrainMgr::_clearStats );
Con::addVariable( "$TerrainBlock::cellsRendered", TypeS32, &smCellsRendered, "@internal" );
Con::addVariable( "$TerrainBlock::overrideCells", TypeS32, &smOverrideCells, "@internal" );
Con::addVariable( "$TerrainBlock::drawCalls", TypeS32, &smDrawCalls, "@internal" );
Parent::initPersistFields();
}
bool RenderTerrainMgr::_clearStats( GFXDevice::GFXDeviceEventType type )
{
if ( type == GFXDevice::deStartOfFrame )
{
smCellsRendered = 0;
smOverrideCells = 0;
smDrawCalls = 0;
}
return true;
}
void RenderTerrainMgr::internalAddElement( RenderInst *inst_ )
{
TerrainRenderInst *inst = static_cast<TerrainRenderInst*>( inst_ );
mInstVector.push_back( inst );
}
void RenderTerrainMgr::sort()
{
// TODO: We could probably sort this in some
// manner to improve terrain rendering perf.
}
void RenderTerrainMgr::clear()
{
mInstVector.clear();
}
void RenderTerrainMgr::render( SceneRenderState *state )
{
if ( mInstVector.empty() )
return;
PROFILE_SCOPE( RenderTerrainMgr_Render );
GFXTransformSaver saver;
// Prepare the common scene graph data.
SceneData sgData;
sgData.init( state );
sgData.wireframe |= smRenderWireframe;
// Restore transforms
MatrixSet &matrixSet = getRenderPass()->getMatrixSet();
matrixSet.restoreSceneViewProjection();
GFXDEBUGEVENT_SCOPE( RenderTerrainMgr_Render, ColorI::GREEN );
const MatrixF worldViewXfm = matrixSet.getWorldToCamera();
const MatrixF &projXfm = matrixSet.getCameraToScreen();
// HACKTASTIC!
//
// If this is a shadow pass then render the terrain
// with the first material we get.
//
// In the near future terrains will operate using regular
// MatInstance materials like any other mesh in which case
// this will all be replaced by a normal mesh render bin.
//
if ( state->isShadowPass() )
{
PROFILE_SCOPE( RenderTerrainMgr_Render_Shadow );
Vector<TerrainRenderInst*>::iterator inst = mInstVector.begin();
BaseMatInstance *overideMat = (*inst)->mat;
while ( overideMat && overideMat->setupPass( state, sgData ) )
{
for ( ; inst != mInstVector.end(); inst++ )
{
smOverrideCells++;
GFX->setPrimitiveBuffer( (*inst)->primBuff );
GFX->setVertexBuffer( (*inst)->vertBuff );
matrixSet.setWorld(*(*inst)->objectToWorldXfm);
overideMat->setSceneInfo( state, sgData );
overideMat->setTransforms( matrixSet, state );
GFX->drawPrimitive( (*inst)->prim );
}
}
return;
}
// Do the detail map passes.
Vector<TerrainRenderInst*>::iterator inst = mInstVector.begin();
for ( ; inst != mInstVector.end(); inst++ )
{
TerrainCellMaterial *mat = (*inst)->cellMat;
GFX->setPrimitiveBuffer( (*inst)->primBuff );
GFX->setVertexBuffer( (*inst)->vertBuff );
++smCellsRendered;
mat->setTransformAndEye( *(*inst)->objectToWorldXfm,
worldViewXfm,
projXfm,
state->getFarPlane() );
sgData.objTrans = (*inst)->objectToWorldXfm;
dMemcpy( sgData.lights, (*inst)->lights, sizeof( sgData.lights ) );
while ( mat->setupPass( state, sgData ) )
{
++smDrawCalls;
GFX->drawPrimitive( (*inst)->prim );
}
}
}