mirror of
https://github.com/ptitSeb/Serious-Engine
synced 2024-11-26 20:25:54 +01:00
24cb244d43
This was a _ton_ of changes, made 15 years ago, so there are probably some problems to work out still. Among others: Engine/Base/Stream.* was mostly abandoned and will need to be re-ported. Still, this is a pretty good start, and probably holds a world record for lines of changes or something. :)
1023 lines
36 KiB
C++
1023 lines
36 KiB
C++
/* Copyright (c) 2002-2012 Croteam Ltd. All rights reserved. */
|
|
|
|
#include <Engine/StdH.h>
|
|
|
|
#include <Engine/Brushes/Brush.h>
|
|
#include <Engine/Brushes/BrushTransformed.h>
|
|
#include <Engine/Rendering/Render.h>
|
|
#include <Engine/Rendering/Render_internal.h>
|
|
#include <Engine/Base/Console.h>
|
|
#include <Engine/Templates/DynamicContainer.h>
|
|
#include <Engine/Templates/DynamicContainer.cpp>
|
|
|
|
#include <Engine/Light/LightSource.h>
|
|
#include <Engine/Light/Gradient.h>
|
|
#include <Engine/Base/ListIterator.inl>
|
|
#include <Engine/World/World.h>
|
|
#include <Engine/Entities/Entity.h>
|
|
#include <Engine/Templates/StaticArray.cpp>
|
|
#include <Engine/Math/Clipping.inl>
|
|
#include <Engine/Entities/EntityClass.h>
|
|
#include <Engine/World/WorldSettings.h>
|
|
#include <Engine/Entities/EntityProperties.h>
|
|
#include <Engine/Entities/FieldSettings.h>
|
|
#include <Engine/Entities/ShadingInfo.h>
|
|
#include <Engine/Light/LensFlares.h>
|
|
#include <Engine/Models/ModelObject.h>
|
|
#include <Engine/Models/RenderModel.h>
|
|
#include <Engine/Ska/Render.h>
|
|
#include <Engine/Terrain/Terrain.h>
|
|
#include <Engine/Templates/BSP.h>
|
|
#include <Engine/World/WorldEditingProfile.h>
|
|
#include <Engine/Brushes/BrushArchive.h>
|
|
#include <Engine/Math/Float.h>
|
|
#include <Engine/Math/OBBox.h>
|
|
#include <Engine/Math/Geometry.inl>
|
|
|
|
#include <Engine/Graphics/DrawPort.h>
|
|
#include <Engine/Graphics/GfxLibrary.h>
|
|
#include <Engine/Graphics/Fog_internal.h>
|
|
|
|
#include <Engine/Base/Statistics_Internal.h>
|
|
#include <Engine/Rendering/RenderProfile.h>
|
|
|
|
#include <Engine/Templates/LinearAllocator.cpp>
|
|
#include <Engine/Templates/DynamicArray.cpp>
|
|
#include <Engine/Templates/StaticStackArray.cpp>
|
|
#include <Engine/Templates/DynamicStackArray.cpp>
|
|
|
|
extern BOOL _bSomeDarkExists;
|
|
extern INDEX d3d_bAlternateDepthReads;
|
|
|
|
// general coordinate stack referenced by the scene polygons
|
|
extern CStaticStackArray<GFXVertex3> _avtxScene;
|
|
|
|
|
|
//#pragma optimize ("gt", on)
|
|
#pragma inline_depth(255)
|
|
#pragma inline_recursion(on)
|
|
|
|
#ifndef NDEBUG
|
|
//#define ASER_EXTREME_CHECKING 1
|
|
#endif
|
|
|
|
// the renderer structures used in rendering
|
|
#define MAX_RENDERERS 2
|
|
static CRenderer _areRenderers[MAX_RENDERERS];
|
|
static BOOL _bMirrorDrawn = FALSE;
|
|
|
|
extern INDEX wld_bAlwaysAddAll;
|
|
extern INDEX wld_bRenderEmptyBrushes;
|
|
extern INDEX wld_bRenderDetailPolygons;
|
|
extern INDEX gfx_bRenderParticles;
|
|
extern INDEX gfx_bRenderModels;
|
|
extern INDEX gfx_bRenderFog;
|
|
extern INDEX gfx_bRenderPredicted;
|
|
extern INDEX gfx_iLensFlareQuality;
|
|
extern BOOL _bMultiPlayer;
|
|
|
|
// variables for selection on rendering
|
|
CBrushVertexSelection *_pselbvxtSelectOnRender = NULL;
|
|
CStaticStackArray<PIX2D> *_pavpixSelectLasso = NULL;
|
|
CEntitySelection *_pselenSelectOnRender = NULL;
|
|
PIX2D _vpixSelectNearPoint = PIX2D(0,0);
|
|
BOOL _bSelectAlternative = FALSE;
|
|
PIX _pixDeltaAroundVertex = 10;
|
|
|
|
// shading info for viewer of last rendered view
|
|
FLOAT3D _vViewerLightDirection;
|
|
COLOR _colViewerLight;
|
|
COLOR _colViewerAmbient;
|
|
|
|
|
|
// handy statistic helper routines
|
|
|
|
static enum CStatForm::StatTimerIndex _stiLastStatsMode = (enum CStatForm::StatTimerIndex)-1;
|
|
|
|
void StopStatsMode(void)
|
|
{
|
|
ASSERT( (INDEX)_stiLastStatsMode != -1);
|
|
if( _stiLastStatsMode>=0) _sfStats.StopTimer(_stiLastStatsMode);
|
|
_stiLastStatsMode = (enum CStatForm::StatTimerIndex)-1;
|
|
}
|
|
|
|
void StartStatsMode( enum CStatForm::StatTimerIndex sti)
|
|
{
|
|
ASSERT( (INDEX)sti != -1);
|
|
ASSERT( (INDEX)_stiLastStatsMode == -1);
|
|
if( sti>=0) _sfStats.StartTimer(sti);
|
|
_stiLastStatsMode = sti;
|
|
}
|
|
|
|
void ChangeStatsMode( enum CStatForm::StatTimerIndex sti)
|
|
{
|
|
StopStatsMode();
|
|
StartStatsMode(sti);
|
|
}
|
|
|
|
|
|
// screen edges, polygons and trapezoids used in rasterizing
|
|
CDynamicStackArray<CAddEdge> CRenderer::re_aadeAddEdges;
|
|
CDynamicStackArray<CScreenEdge> CRenderer::re_asedScreenEdges;
|
|
// spans for current scan line
|
|
CDynamicStackArray<CSpan> CRenderer::re_aspSpans;
|
|
|
|
// vertices clipped to current clip plane
|
|
CStaticStackArray<INDEX> CRenderer::re_aiClipBuffer;
|
|
// buffers for edges of polygons
|
|
CStaticStackArray<INDEX> CRenderer::re_aiEdgeVxClipSrc;
|
|
CStaticStackArray<INDEX> CRenderer::re_aiEdgeVxClipDst;
|
|
|
|
// add and remove lists for each scan line
|
|
CStaticArray<CListHead> CRenderer::re_alhAddLists;
|
|
CStaticArray<INDEX> CRenderer::re_actAddCounts; // count of edges in given add list
|
|
CStaticArray<CScreenEdge *> CRenderer::re_apsedRemoveFirst;
|
|
CStaticStackArray<CActiveEdge> CRenderer::re_aaceActiveEdgesTmp;
|
|
CStaticStackArray<CActiveEdge> CRenderer::re_aaceActiveEdges;
|
|
|
|
// container for sorting translucent polygons
|
|
CDynamicStackArray<CTranslucentPolygon> CRenderer::re_atcTranslucentPolygons;
|
|
|
|
// container for all light influencing current model
|
|
struct ModelLight {
|
|
CLightSource *ml_plsLight; // the light source
|
|
FLOAT3D ml_vDirection; // direction from light to the model position (normalized)
|
|
FLOAT ml_fShadowIntensity; // intensity at the model position (for shadow)
|
|
FLOAT ml_fR, ml_fG, ml_fB; // light components at light source (0..255)
|
|
inline void Clear(void) {};
|
|
};
|
|
static CDynamicStackArray<struct ModelLight> _amlLights;
|
|
|
|
static INDEX _ctMaxAddEdges=0;
|
|
static INDEX _ctMaxActiveEdges=0;
|
|
|
|
void RendererInfo(void)
|
|
{
|
|
CPrintF("Renderer information:\n");
|
|
|
|
SLONG slMem = 0;
|
|
|
|
slMem += CRenderer::re_aadeAddEdges.da_Count*sizeof(CAddEdge);
|
|
slMem += CRenderer::re_asedScreenEdges.da_Count*sizeof(CScreenEdge);
|
|
|
|
slMem += CRenderer::re_aspSpans.da_Count*sizeof(CSpan);
|
|
|
|
slMem += CRenderer::re_aiClipBuffer.sa_Count*sizeof(INDEX);
|
|
slMem += CRenderer::re_aiEdgeVxClipSrc.sa_Count*sizeof(INDEX);
|
|
slMem += CRenderer::re_aiEdgeVxClipDst.sa_Count*sizeof(INDEX);
|
|
|
|
slMem += CRenderer::re_alhAddLists.sa_Count*sizeof(CListHead);
|
|
slMem += CRenderer::re_actAddCounts.sa_Count*sizeof(INDEX);
|
|
slMem += CRenderer::re_apsedRemoveFirst.sa_Count*sizeof(CScreenEdge *);
|
|
|
|
slMem += CRenderer::re_atcTranslucentPolygons.da_Count*sizeof(CTranslucentPolygon);
|
|
slMem += CRenderer::re_aaceActiveEdges.sa_Count*sizeof(CActiveEdge);
|
|
slMem += CRenderer::re_aaceActiveEdgesTmp.sa_Count*sizeof(CActiveEdge);
|
|
|
|
for (INDEX ire = 0; ire<MAX_RENDERERS; ire++) {
|
|
CRenderer &re = _areRenderers[ire];
|
|
slMem += re.re_aspoScreenPolygons.da_Count*sizeof(CScreenPolygon);
|
|
slMem += re.re_admDelayedModels.da_Count*sizeof(CDelayedModel);
|
|
slMem += re.re_cenDrawn.sa_Count*sizeof(CEntity*);
|
|
slMem += re.re_alfiLensFlares.sa_Count*sizeof(CLensFlareInfo);
|
|
slMem += re.re_amiMirrors.da_Count*sizeof(CMirror);
|
|
slMem += re.re_avvxViewVertices.sa_Count*sizeof(CViewVertex);
|
|
slMem += re.re_aiEdgeVxMain.sa_Count*sizeof(INDEX);
|
|
}
|
|
|
|
CPrintF("Temporary memory used: %dk\n", slMem/1024);
|
|
}
|
|
|
|
void ClearRenderer(void)
|
|
{
|
|
CRenderer::re_aadeAddEdges.Clear();
|
|
CRenderer::re_asedScreenEdges.Clear();
|
|
CRenderer::re_aspSpans.Clear();
|
|
|
|
CRenderer::re_aiClipBuffer.Clear();
|
|
CRenderer::re_aiEdgeVxClipSrc.Clear();
|
|
CRenderer::re_aiEdgeVxClipDst.Clear();
|
|
|
|
CRenderer::re_alhAddLists.Clear();
|
|
CRenderer::re_actAddCounts.Clear();
|
|
CRenderer::re_apsedRemoveFirst.Clear();
|
|
CRenderer::re_atcTranslucentPolygons.Clear();
|
|
CRenderer::re_aaceActiveEdges.Clear();
|
|
CRenderer::re_aaceActiveEdgesTmp.Clear();
|
|
|
|
for (INDEX ire = 0; ire<MAX_RENDERERS; ire++) {
|
|
CRenderer &re = _areRenderers[ire];
|
|
|
|
re.re_aspoScreenPolygons.Clear();
|
|
re.re_admDelayedModels.Clear();
|
|
re.re_cenDrawn.Clear();
|
|
re.re_alfiLensFlares.Clear();
|
|
re.re_amiMirrors.Clear();
|
|
re.re_avvxViewVertices.Clear();
|
|
re.re_aiEdgeVxMain.Clear();
|
|
}
|
|
|
|
CPrintF("Renderer buffers cleared.\n");
|
|
}
|
|
|
|
/*
|
|
* How much to offset left, right, top and bottom clipping towards inside (in pixels).
|
|
* This can be used to test clipping or to add an epsilon value for it.
|
|
*/
|
|
//#define CLIPMARGIN 10.0f // used for debugging clipping
|
|
#define CLIPMARGIN 0.0f
|
|
#define CLIPEPSILON 0.5f
|
|
#define CLIPMARGADD (CLIPMARGIN-CLIPEPSILON)
|
|
#define CLIPMARGSUB (CLIPMARGIN+CLIPEPSILON)
|
|
#define SENTINELEDGE_EPSILON 0.4f
|
|
|
|
#include "RendMisc.cpp"
|
|
#include "RenCache.cpp"
|
|
#include "RendClip.cpp"
|
|
#include "RendASER.cpp"
|
|
#include "RenderModels.cpp"
|
|
#include "RenderBrushes.cpp"
|
|
#include "RenderAdding.cpp"
|
|
|
|
extern FLOAT wld_fEdgeOffsetI;
|
|
extern FLOAT wld_fEdgeAdjustK;
|
|
|
|
// initialize all rendering structures
|
|
void CRenderer::Initialize(void)
|
|
{
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_INITIALIZATION);
|
|
|
|
// used for fixing problems with extra trapezoids generated on t-junctions
|
|
if( !re_bRenderingShadows) {
|
|
re_fEdgeOffsetI = wld_fEdgeOffsetI; //0.125f;
|
|
re_fEdgeAdjustK = wld_fEdgeAdjustK; //1.0001f;
|
|
} else {
|
|
re_fEdgeOffsetI = 0.0f;
|
|
re_fEdgeAdjustK = 1.0f;
|
|
}
|
|
|
|
// prepare the raw projection (used for rendering target lines and getting object distances)
|
|
re_prProjection->ObjectPlacementL() = CPlacement3D(FLOAT3D(0.0f,0.0f,0.0f), ANGLE3D(0,0,0));
|
|
re_prProjection->ObjectFaceForwardL() = FALSE;
|
|
re_prProjection->ObjectStretchL() = FLOAT3D(1.0f, 1.0f, 1.0f);
|
|
re_prProjection->DepthBufferNearL() = 0.0f;
|
|
re_prProjection->DepthBufferFarL() = 0.9f;
|
|
re_prProjection->Prepare();
|
|
|
|
re_asedScreenEdges.PopAll();
|
|
re_aadeAddEdges.PopAll();
|
|
re_aspSpans.PopAll();
|
|
re_avvxViewVertices.PopAll();
|
|
re_aiEdgeVxMain.PopAll();
|
|
|
|
// if more scan lines are needed than last time
|
|
if (re_alhAddLists.Count()<re_ctScanLines) {
|
|
re_alhAddLists.Clear();
|
|
re_alhAddLists.New(re_ctScanLines);
|
|
re_actAddCounts.Clear();
|
|
re_actAddCounts.New(re_ctScanLines);
|
|
|
|
re_apsedRemoveFirst.Clear();
|
|
re_apsedRemoveFirst.New(re_ctScanLines);
|
|
}
|
|
// clear all add/remove lists
|
|
for(INDEX iScan=0; iScan<re_ctScanLines; iScan++) {
|
|
re_actAddCounts[iScan] = 0;
|
|
re_apsedRemoveFirst[iScan] = NULL;
|
|
}
|
|
|
|
// find selection color
|
|
re_colSelection = C_RED;
|
|
if (_wrpWorldRenderPrefs.GetSelectionType() == CWorldRenderPrefs::ST_POLYGONS) {
|
|
re_colSelection = C_YELLOW;
|
|
} else if (_wrpWorldRenderPrefs.GetSelectionType() == CWorldRenderPrefs::ST_SECTORS) {
|
|
re_colSelection = C_GREEN;
|
|
} else if (_wrpWorldRenderPrefs.GetSelectionType() == CWorldRenderPrefs::ST_ENTITIES) {
|
|
re_colSelection = C_BLUE;
|
|
}
|
|
|
|
// set up renderer for first scan line
|
|
re_iCurrentScan = 0;
|
|
re_pixCurrentScanJ = re_iCurrentScan + re_pixTopScanLineJ;
|
|
re_fCurrentScanJ = FLOAT(re_pixCurrentScanJ);
|
|
|
|
// no fog or haze initially
|
|
re_bCurrentSectorHasHaze = FALSE;
|
|
re_bCurrentSectorHasFog = FALSE;
|
|
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_INITIALIZATION);
|
|
}
|
|
// add initial sectors to active lists
|
|
void CRenderer::AddInitialSectors(void)
|
|
{
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_ADDINITIAL);
|
|
|
|
re_bViewerInHaze = FALSE;
|
|
re_ulVisExclude = 0;
|
|
re_ulVisInclude = 0;
|
|
|
|
// if showing vis tweaks
|
|
if (_wrpWorldRenderPrefs.wrp_bShowVisTweaksOn && _pselbscVisTweaks!=NULL) {
|
|
// add flags for selected flags
|
|
if (_pselbscVisTweaks->Count()>0) {
|
|
re_ulVisExclude = VISM_INCLUDEEXCLUDE;
|
|
}
|
|
FOREACHINDYNAMICCONTAINER(*_pselbscVisTweaks, CBrushSector, itbsc) {
|
|
if (itbsc->bsc_ulFlags2&BSCF2_VISIBILITYINCLUDE) {
|
|
re_ulVisInclude = itbsc->bsc_ulVisFlags&VISM_INCLUDEEXCLUDE;
|
|
} else {
|
|
re_ulVisExclude &= itbsc->bsc_ulVisFlags&VISM_INCLUDEEXCLUDE;
|
|
}
|
|
}
|
|
}
|
|
|
|
// check if the background is needed
|
|
re_bBackgroundEnabled = FALSE;
|
|
if (!re_bRenderingShadows && _wrpWorldRenderPrefs.wrp_bBackgroundTextureOn) {
|
|
CEntity *penBackgroundViewer = re_pwoWorld->GetBackgroundViewer();
|
|
if (penBackgroundViewer!=NULL) {
|
|
re_bBackgroundEnabled = TRUE;
|
|
re_penBackgroundViewer = penBackgroundViewer;
|
|
re_prBackgroundProjection = re_prProjection;
|
|
CPlacement3D plViewer = re_prProjection->ViewerPlacementR();
|
|
plViewer.pl_PositionVector = FLOAT3D(0,0,0);
|
|
CPlacement3D plBcgViewer = penBackgroundViewer->GetLerpedPlacement();
|
|
if (re_prProjection->pr_bMirror) {
|
|
ReflectPositionVectorByPlane(re_prProjection->pr_plMirror, plBcgViewer.pl_PositionVector);
|
|
}
|
|
plViewer.RelativeToAbsoluteSmooth(plBcgViewer);
|
|
re_prBackgroundProjection->ViewerPlacementL() = plViewer;
|
|
re_prBackgroundProjection->ObjectPlacementL() = CPlacement3D(FLOAT3D(0,0,0), ANGLE3D(0,0,0));
|
|
re_prBackgroundProjection->FarClipDistanceL() = -1.0f;
|
|
re_prBackgroundProjection->DepthBufferNearL() = 0.9f;
|
|
re_prBackgroundProjection->DepthBufferFarL() = 1.0f;
|
|
re_prBackgroundProjection->TurnOffWarpPlane(); // background never needs warp-plane clipping
|
|
re_prBackgroundProjection->Prepare();
|
|
}
|
|
}
|
|
|
|
// if a viewer entity is given
|
|
if (re_penViewer!=NULL) {
|
|
// add all zoning sectors near the entity
|
|
AddZoningSectorsAroundEntity(re_penViewer, re_prProjection->ViewerPlacementR().pl_PositionVector);
|
|
// make sure the viewer is always added (if model)
|
|
if(re_penViewer->en_RenderType==CEntity::RT_MODEL ||
|
|
re_penViewer->en_RenderType==CEntity::RT_EDITORMODEL) {
|
|
AddModelEntity(re_penViewer);
|
|
}
|
|
// if a viewer polygons are given
|
|
} else if (re_pcspoViewPolygons!=NULL) {
|
|
// for each polygon
|
|
FOREACHINDYNAMICCONTAINER(*re_pcspoViewPolygons, CScreenPolygon, itspo) {
|
|
CBrushPolygon *pbpo = itspo->spo_pbpoBrushPolygon;
|
|
// get the sector, sector's brush mip, brush and entity
|
|
CBrushSector *pbsc = pbpo->bpo_pbscSector;
|
|
CBrushMip *pbmBrushMip = pbsc->bsc_pbmBrushMip;
|
|
CBrush3D *pbrBrush = pbmBrushMip->bm_pbrBrush;
|
|
ASSERT(pbrBrush!=NULL);
|
|
CEntity *penBrush = pbrBrush->br_penEntity;
|
|
// if the brush is zoning
|
|
if (penBrush->en_ulFlags&ENF_ZONING) {
|
|
// add the sector that the polygon is in
|
|
AddGivenZoningSector(pbsc);
|
|
// if the brush is non-zoning
|
|
} else {
|
|
// add sectors around it
|
|
AddZoningSectorsAroundEntity(penBrush, penBrush->GetPlacement().pl_PositionVector);
|
|
}
|
|
}
|
|
// if there is no viewer entity/polygon
|
|
} else {
|
|
// set up viewer bounding box as box of minimum redraw range around viewer position
|
|
if (re_bRenderingShadows) {
|
|
// NOTE: when rendering shadows, this is set in ::RenderShadows()
|
|
//re_boxViewer = FLOATaabbox3D(re_prProjection->ViewerPlacementR().pl_PositionVector,
|
|
// 1.0f);
|
|
} else {
|
|
re_boxViewer = FLOATaabbox3D(re_prProjection->ViewerPlacementR().pl_PositionVector,
|
|
_wrpWorldRenderPrefs.wrp_fMinimumRenderRange);
|
|
}
|
|
// add all zoning sectors near viewer box
|
|
AddZoningSectorsAroundBox(re_boxViewer);
|
|
// NOTE: this is so entities outside of world can be edited in WEd
|
|
// if editor models should be rendered
|
|
if (_wrpWorldRenderPrefs.IsEditorModelsOn()) {
|
|
// add all nonzoning entities near viewer box
|
|
AddEntitiesInBox(re_boxViewer);
|
|
}
|
|
}
|
|
|
|
if( wld_bAlwaysAddAll) {
|
|
AddAllEntities(); // used for profiling
|
|
} else {
|
|
// NOTE: this is so that world can be viewed from the outside in game
|
|
// if no brush sectors have been added so far
|
|
if (!re_bRenderingShadows && re_lhActiveSectors.IsEmpty()) {
|
|
// add all entities in the world
|
|
AddAllEntities();
|
|
}
|
|
}
|
|
|
|
// add the background if needed
|
|
if (re_bBackgroundEnabled) {
|
|
AddZoningSectorsAroundEntity(re_penBackgroundViewer,
|
|
re_penBackgroundViewer->GetPlacement().pl_PositionVector);
|
|
}
|
|
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_ADDINITIAL);
|
|
}
|
|
// scan through portals for other sectors
|
|
void CRenderer::ScanForOtherSectors(void)
|
|
{
|
|
ChangeStatsMode(CStatForm::STI_WORLDVISIBILITY);
|
|
// if shadows or polygons should be drawn
|
|
if (re_bRenderingShadows
|
|
||_wrpWorldRenderPrefs.wrp_ftPolygons != CWorldRenderPrefs::FT_NONE) {
|
|
// rasterize edges into spans
|
|
ScanEdges();
|
|
}
|
|
// for each of models that were kept for delayed rendering
|
|
for(INDEX iModel=0; iModel<re_admDelayedModels.Count(); iModel++) {
|
|
// mark the entity as not active in rendering anymore
|
|
re_admDelayedModels[iModel].dm_penModel->en_ulFlags &= ~ENF_INRENDERING;
|
|
}
|
|
ChangeStatsMode(CStatForm::STI_WORLDTRANSFORM);
|
|
}
|
|
// cleanup after scanning
|
|
void CRenderer::CleanupScanning(void)
|
|
{
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_CLEANUP);
|
|
|
|
// for all active sectors
|
|
{FORDELETELIST(CBrushSector, bsc_lnInActiveSectors, re_lhActiveSectors, itbsc) {
|
|
// remove it from list
|
|
itbsc->bsc_lnInActiveSectors.Remove();
|
|
|
|
// for all polygons in sector
|
|
FOREACHINSTATICARRAY(itbsc->bsc_abpoPolygons, CBrushPolygon, itpo) {
|
|
CBrushPolygon &bpo = *itpo;
|
|
// clear screen polygon pointers
|
|
bpo.bpo_pspoScreenPolygon = NULL;
|
|
}
|
|
}}
|
|
ASSERT(re_lhActiveSectors.IsEmpty());
|
|
|
|
// for all active brushes
|
|
{FORDELETELIST(CBrush3D, br_lnInActiveBrushes, re_lhActiveBrushes, itbr) {
|
|
// remove it from list
|
|
itbr->br_lnInActiveBrushes.Remove();
|
|
}}
|
|
ASSERT(re_lhActiveBrushes.IsEmpty());
|
|
|
|
// for all active terrains
|
|
{FORDELETELIST(CTerrain, tr_lnInActiveTerrains, re_lhActiveTerrains, ittr) {
|
|
// remove it from list
|
|
ittr->tr_lnInActiveTerrains.Remove();
|
|
}}
|
|
ASSERT(re_lhActiveTerrains.IsEmpty());
|
|
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_CLEANUP);
|
|
}
|
|
|
|
// Render active terrains
|
|
void CRenderer::RenderTerrains(void)
|
|
{
|
|
CAnyProjection3D *papr;
|
|
papr = &re_prProjection;
|
|
|
|
// for all active terrains
|
|
{FORDELETELIST(CTerrain, tr_lnInActiveTerrains, re_lhActiveTerrains, ittr) {
|
|
// render terrain
|
|
ittr->Render(*papr, re_pdpDrawPort);
|
|
}}
|
|
}
|
|
|
|
// Render active terrains in wireframe mode
|
|
void CRenderer::RenderWireFrameTerrains(void)
|
|
{
|
|
CAnyProjection3D *papr;
|
|
papr = &re_prProjection;
|
|
|
|
BOOL bShowEdges = _wrpWorldRenderPrefs.wrp_ftEdges != CWorldRenderPrefs::FT_NONE;
|
|
BOOL bShowVertices = _wrpWorldRenderPrefs.wrp_ftVertices != CWorldRenderPrefs::FT_NONE;
|
|
// BOOL bForceRegenerate = _wrpWorldRenderPrefs.wrp_ftPolygons
|
|
|
|
COLOR colEdges = _wrpWorldRenderPrefs.wrp_colEdges;
|
|
COLOR colVertices = 0xFF0000FF;
|
|
// for all active terrains
|
|
{FORDELETELIST(CTerrain, tr_lnInActiveTerrains, re_lhActiveTerrains, ittr) {
|
|
// render terrain
|
|
if(bShowEdges) {
|
|
ittr->RenderWireFrame(*papr, re_pdpDrawPort,colEdges);
|
|
}
|
|
if(bShowVertices) {
|
|
//ittr->RenderVertices(*papr, re_pdpDrawPort,colVertices);
|
|
}
|
|
}}
|
|
}
|
|
// draw the prepared things to screen
|
|
void CRenderer::DrawToScreen(void)
|
|
{
|
|
ChangeStatsMode(CStatForm::STI_WORLDRENDERING);
|
|
|
|
//------------------------------------------------- first render background
|
|
// if polygons should be drawn
|
|
if (!re_bRenderingShadows &&
|
|
_wrpWorldRenderPrefs.wrp_ftPolygons != CWorldRenderPrefs::FT_NONE) {
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_RENDERSCENE);
|
|
if( re_bBackgroundEnabled) {
|
|
// render the polygons to screen
|
|
CPerspectiveProjection3D *pprPerspective =
|
|
(CPerspectiveProjection3D *)(CProjection3D *)(re_prBackgroundProjection);
|
|
pprPerspective->Prepare();
|
|
RenderScene( re_pdpDrawPort, re_pspoFirstBackground, re_prBackgroundProjection, re_colSelection, FALSE);
|
|
} else {
|
|
// this is just for far sentinel
|
|
RenderSceneBackground( re_pdpDrawPort, re_spoFarSentinel.spo_spoScenePolygon.spo_cColor);
|
|
}
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_RENDERSCENE);
|
|
}
|
|
|
|
if (re_bBackgroundEnabled) {
|
|
// render models that were kept for delayed rendering.
|
|
ChangeStatsMode(CStatForm::STI_MODELSETUP);
|
|
RenderModels(TRUE); // render background models
|
|
ChangeStatsMode(CStatForm::STI_WORLDRENDERING);
|
|
}
|
|
|
|
// if polygons should be drawn
|
|
if (!re_bRenderingShadows &&
|
|
re_bBackgroundEnabled
|
|
&&_wrpWorldRenderPrefs.wrp_ftPolygons != CWorldRenderPrefs::FT_NONE) {
|
|
// render translucent portals
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_RENDERSCENE);
|
|
CPerspectiveProjection3D *pprPerspective = (CPerspectiveProjection3D*)(CProjection3D*)(re_prBackgroundProjection);
|
|
RenderScene( re_pdpDrawPort, SortTranslucentPolygons(re_pspoFirstBackgroundTranslucent),
|
|
re_prBackgroundProjection, re_colSelection, TRUE);
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_RENDERSCENE);
|
|
}
|
|
|
|
if( re_bBackgroundEnabled) {
|
|
ChangeStatsMode(CStatForm::STI_PARTICLERENDERING);
|
|
RenderParticles(TRUE); // render background particles
|
|
ChangeStatsMode(CStatForm::STI_WORLDRENDERING);
|
|
}
|
|
|
|
//------------------------------------------------- second render non-background
|
|
// if polygons should be drawn
|
|
if( !re_bRenderingShadows
|
|
&& _wrpWorldRenderPrefs.wrp_ftPolygons != CWorldRenderPrefs::FT_NONE) {
|
|
// render the spans to screen
|
|
re_prProjection->Prepare();
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_RENDERSCENE);
|
|
CPerspectiveProjection3D *pprPerspective = (CPerspectiveProjection3D*)(CProjection3D*)re_prProjection;
|
|
RenderScene( re_pdpDrawPort, re_pspoFirst, re_prProjection, re_colSelection, FALSE);
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_RENDERSCENE);
|
|
}
|
|
|
|
// Render active terrains
|
|
if( !re_bRenderingShadows
|
|
&& _wrpWorldRenderPrefs.wrp_ftPolygons != CWorldRenderPrefs::FT_NONE) {
|
|
RenderTerrains();
|
|
}
|
|
|
|
// if wireframe should be drawn
|
|
if( !re_bRenderingShadows &&
|
|
( _wrpWorldRenderPrefs.wrp_ftEdges != CWorldRenderPrefs::FT_NONE
|
|
|| _wrpWorldRenderPrefs.wrp_ftVertices != CWorldRenderPrefs::FT_NONE
|
|
|| _wrpWorldRenderPrefs.wrp_stSelection == CWorldRenderPrefs::ST_VERTICES
|
|
|| _wrpWorldRenderPrefs.IsFieldBrushesOn())) {
|
|
// render in wireframe all brushes that were added (in orthographic projection!)
|
|
re_pdpDrawPort->SetOrtho();
|
|
RenderWireFrameBrushes();
|
|
RenderWireFrameTerrains();
|
|
}
|
|
|
|
// render models that were kept for delayed rendering
|
|
ChangeStatsMode(CStatForm::STI_MODELSETUP);
|
|
RenderModels(FALSE); // render non-background models
|
|
ChangeStatsMode(CStatForm::STI_PARTICLERENDERING);
|
|
RenderParticles(FALSE); // render non-background particles
|
|
ChangeStatsMode(CStatForm::STI_WORLDRENDERING);
|
|
|
|
// if polygons should be drawn
|
|
if (!re_bRenderingShadows
|
|
&&_wrpWorldRenderPrefs.wrp_ftPolygons != CWorldRenderPrefs::FT_NONE) {
|
|
// render translucent portals
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_RENDERSCENE);
|
|
CPerspectiveProjection3D *pprPerspective = (CPerspectiveProjection3D*)(CProjection3D*)re_prProjection;
|
|
pprPerspective->Prepare();
|
|
RenderScene( re_pdpDrawPort, SortTranslucentPolygons(re_pspoFirstTranslucent),
|
|
re_prProjection, re_colSelection, TRUE);
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_RENDERSCENE);
|
|
}
|
|
|
|
// render lens flares
|
|
if( !re_bRenderingShadows) {
|
|
ChangeStatsMode(CStatForm::STI_FLARESRENDERING);
|
|
RenderLensFlares(); // (this also sets orthographic projection!)
|
|
ChangeStatsMode(CStatForm::STI_WORLDRENDERING);
|
|
}
|
|
|
|
// if entity targets should be drawn
|
|
if( !re_bRenderingShadows && _wrpWorldRenderPrefs.wrp_bShowTargetsOn) {
|
|
// render entity targets
|
|
RenderEntityTargets();
|
|
}
|
|
|
|
// if entity targets should be drawn
|
|
if( !re_bRenderingShadows && _wrpWorldRenderPrefs.wrp_bShowEntityNames) {
|
|
RenderEntityNames();
|
|
}
|
|
|
|
// clean all buffers after rendering
|
|
re_aspoScreenPolygons.PopAll();
|
|
re_admDelayedModels.PopAll();
|
|
re_cenDrawn.PopAll();
|
|
re_avvxViewVertices.PopAll();
|
|
}
|
|
|
|
|
|
// draw mirror polygons to z-buffer to enable drawing of mirror
|
|
void CRenderer::FillMirrorDepth(CMirror &mi)
|
|
{
|
|
// create a list of scene polygons for mirror
|
|
ScenePolygon *pspoFirst = NULL;
|
|
// for each polygon
|
|
FOREACHINDYNAMICCONTAINER(mi.mi_cspoPolygons, CScreenPolygon, itspo) {
|
|
CScreenPolygon &spo = *itspo;
|
|
CBrushPolygon &bpo = *spo.spo_pbpoBrushPolygon;
|
|
// create a new screen polygon
|
|
CScreenPolygon &spoNew = re_aspoScreenPolygons.Push();
|
|
ScenePolygon &sppoNew = spoNew.spo_spoScenePolygon;
|
|
// add it to mirror list
|
|
sppoNew.spo_pspoSucc = pspoFirst;
|
|
pspoFirst = &sppoNew;
|
|
|
|
// use same triangles
|
|
sppoNew.spo_iVtx0 = spo.spo_spoScenePolygon.spo_iVtx0;
|
|
sppoNew.spo_ctVtx = spo.spo_spoScenePolygon.spo_ctVtx;
|
|
sppoNew.spo_piElements = spo.spo_spoScenePolygon.spo_piElements;
|
|
sppoNew.spo_ctElements = spo.spo_spoScenePolygon.spo_ctElements;
|
|
}
|
|
|
|
// render all those polygons just to clear z-buffer
|
|
RenderSceneZOnly( re_pdpDrawPort, pspoFirst, re_prProjection);
|
|
}
|
|
|
|
|
|
|
|
// do the rendering
|
|
void CRenderer::Render(void)
|
|
{
|
|
// if the world doesn't have all portal-sector links updated
|
|
if( !re_pwoWorld->wo_bPortalLinksUpToDate) {
|
|
// update the links
|
|
CSetFPUPrecision FPUPrecision(FPT_53BIT);
|
|
re_pwoWorld->wo_baBrushes.LinkPortalsAndSectors();
|
|
re_pwoWorld->wo_bPortalLinksUpToDate = TRUE;
|
|
}
|
|
|
|
StartStatsMode(CStatForm::STI_WORLDTRANSFORM);
|
|
_pfRenderProfile.IncrementAveragingCounter();
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_RENDERING);
|
|
|
|
// set FPU to single precision while rendering
|
|
CSetFPUPrecision FPUPrecision(FPT_24BIT);
|
|
|
|
// initialize all rendering structures
|
|
Initialize();
|
|
// init select-on-render functionality if not rendering shadows
|
|
extern void InitSelectOnRender( PIX pixSizeI, PIX pixSizeJ);
|
|
if( re_pdpDrawPort!=NULL) InitSelectOnRender( re_pdpDrawPort->GetWidth(), re_pdpDrawPort->GetHeight());
|
|
// add initial sectors to active lists
|
|
AddInitialSectors();
|
|
// scan through portals for other sectors
|
|
ScanForOtherSectors();
|
|
|
|
// force finishing of all OpenGL pending operations, if required
|
|
ChangeStatsMode(CStatForm::STI_SWAPBUFFERS);
|
|
extern INDEX ogl_iFinish; ogl_iFinish = Clamp( ogl_iFinish, 0L, 3L);
|
|
extern INDEX d3d_iFinish; d3d_iFinish = Clamp( d3d_iFinish, 0L, 3L);
|
|
if( (ogl_iFinish==1 && _pGfx->gl_eCurrentAPI==GAT_OGL)
|
|
#ifdef SE1_D3D
|
|
|| (d3d_iFinish==1 && _pGfx->gl_eCurrentAPI==GAT_D3D)
|
|
#endif // SE1_D3D
|
|
)
|
|
gfxFinish();
|
|
|
|
// check any eventual delayed depth points outside the mirror (if API and time allows)
|
|
if( !re_bRenderingShadows && re_iIndex==0) {
|
|
// OpenGL allows us to check z-buffer from previous frame - cool deal!
|
|
// Direct3D is, of course, totally different story. :(
|
|
if( _pGfx->gl_eCurrentAPI==GAT_OGL || d3d_bAlternateDepthReads) {
|
|
ChangeStatsMode(CStatForm::STI_FLARESRENDERING);
|
|
extern void CheckDelayedDepthPoints( const CDrawPort *pdp, INDEX iMirrorLevel=0);
|
|
CheckDelayedDepthPoints(re_pdpDrawPort);
|
|
}
|
|
// in 1st pass - mirrors are not drawn
|
|
_bMirrorDrawn = FALSE;
|
|
}
|
|
|
|
// if may render one more mirror recursion
|
|
ChangeStatsMode(CStatForm::STI_WORLDTRANSFORM);
|
|
if( !re_bRenderingShadows
|
|
&& re_prProjection.IsPerspective()
|
|
&& re_iIndex<MAX_RENDERERS-1
|
|
&& re_amiMirrors.Count()>0
|
|
&& !re_pdpDrawPort->IsOverlappedRendering())
|
|
{
|
|
// cleanup after scanning
|
|
CleanupScanning();
|
|
|
|
// take next renderer
|
|
CRenderer &re = _areRenderers[re_iIndex+1];
|
|
// for each mirror
|
|
for( INDEX i=0; i<re_amiMirrors.Count(); i++)
|
|
{
|
|
// skip invalid mirrors
|
|
CMirror &mi = re_amiMirrors[i];
|
|
if( mi.mi_iMirrorType<0) continue;
|
|
|
|
// calculate all needed data for the mirror
|
|
mi.FinishAdding();
|
|
// skip mirror that has no significant area
|
|
if( mi.mi_fpixMaxPolygonArea<5) continue;
|
|
|
|
// expand mirror in each direction, but keep it inside drawport
|
|
PIX pixDPSizeI = re_pdpDrawPort->GetWidth();
|
|
PIX pixDPSizeJ = re_pdpDrawPort->GetHeight();
|
|
mi.mi_boxOnScreen.Expand(1);
|
|
mi.mi_boxOnScreen &= PIXaabbox2D( PIX2D(0,0), PIX2D(pixDPSizeI,pixDPSizeJ));
|
|
|
|
// get drawport and mirror coordinates
|
|
PIX pixMirrorMinI = mi.mi_boxOnScreen.Min()(1);
|
|
PIX pixMirrorMinJ = mi.mi_boxOnScreen.Min()(2);
|
|
PIX pixMirrorMaxI = mi.mi_boxOnScreen.Max()(1);
|
|
PIX pixMirrorMaxJ = mi.mi_boxOnScreen.Max()(2);
|
|
|
|
// calculate mirror size
|
|
PIX pixMirrorSizeI = pixMirrorMaxI-pixMirrorMinI;
|
|
PIX pixMirrorSizeJ = pixMirrorMaxJ-pixMirrorMinJ;
|
|
// clone drawport (must specify doubles here, to keep the precision)
|
|
re_pdpDrawPort->Unlock();
|
|
CDrawPort dpMirror( re_pdpDrawPort, pixMirrorMinI /(DOUBLE)pixDPSizeI, pixMirrorMinJ /(DOUBLE)pixDPSizeJ,
|
|
pixMirrorSizeI/(DOUBLE)pixDPSizeI, pixMirrorSizeJ/(DOUBLE)pixDPSizeJ);
|
|
// skip if cannot be locked
|
|
if( !dpMirror.Lock()) {
|
|
// lock back the original drawport
|
|
re_pdpDrawPort->Lock();
|
|
continue;
|
|
}
|
|
|
|
// recalculate mirror size to compensate for possible lost precision
|
|
pixMirrorMinI = dpMirror.dp_MinI - re_pdpDrawPort->dp_MinI;
|
|
pixMirrorMinJ = dpMirror.dp_MinJ - re_pdpDrawPort->dp_MinJ;
|
|
pixMirrorMaxI = dpMirror.dp_MaxI - re_pdpDrawPort->dp_MinI +1;
|
|
pixMirrorMaxJ = dpMirror.dp_MaxJ - re_pdpDrawPort->dp_MinJ +1;
|
|
pixMirrorSizeI = pixMirrorMaxI-pixMirrorMinI;
|
|
pixMirrorSizeJ = pixMirrorMaxJ-pixMirrorMinJ;
|
|
ASSERT( pixMirrorSizeI==dpMirror.dp_Width && pixMirrorSizeJ==dpMirror.dp_Height);
|
|
|
|
// set it up for rendering
|
|
re.re_pwoWorld = re_pwoWorld;
|
|
re.re_prProjection = re_prProjection;
|
|
re.re_pdpDrawPort = &dpMirror;
|
|
// initialize clipping rectangle around the mirror size
|
|
re.InitClippingRectangle( 0, 0, pixMirrorSizeI, pixMirrorSizeJ);
|
|
// setup projection to use the mirror drawport and keep same perspective as before
|
|
re.re_prProjection->ScreenBBoxL() = FLOATaabbox2D( FLOAT2D(0,0), FLOAT2D(pixDPSizeI, pixDPSizeJ));
|
|
((CPerspectiveProjection3D&)(*re.re_prProjection)).ppr_boxSubScreen =
|
|
FLOATaabbox2D( FLOAT2D(pixMirrorMinI, pixMirrorMinJ), FLOAT2D(pixMirrorMaxI, pixMirrorMaxJ));
|
|
|
|
// warp?
|
|
if( mi.mi_mp.mp_ulFlags&MPF_WARP) {
|
|
// warp clip plane is parallel to view plane and contains the closest point
|
|
re.re_penViewer = mi.mi_mp.mp_penWarpViewer;
|
|
re.re_pcspoViewPolygons = NULL;
|
|
re.re_prProjection->WarpPlaneL() = FLOATplane3D(FLOAT3D(0,0,-1), mi.mi_vClosest);
|
|
// create new viewer placement
|
|
CPlacement3D pl = re.re_prProjection->ViewerPlacementR();
|
|
FLOATmatrix3D m;
|
|
MakeRotationMatrixFast(m, pl.pl_OrientationAngle);
|
|
pl.AbsoluteToRelativeSmooth(mi.mi_mp.mp_plWarpIn);
|
|
pl.RelativeToAbsoluteSmooth(mi.mi_mp.mp_plWarpOut);
|
|
re.re_prProjection->ViewerPlacementL() = pl;
|
|
if (re.re_prProjection.IsPerspective() && mi.mi_mp.mp_fWarpFOV>=1 && mi.mi_mp.mp_fWarpFOV<=170) {
|
|
((CPerspectiveProjection3D&)*re.re_prProjection).FOVL() = mi.mi_mp.mp_fWarpFOV;
|
|
}
|
|
// mirror!
|
|
} else {
|
|
re.re_penViewer = NULL;
|
|
re.re_pcspoViewPolygons = &mi.mi_cspoPolygons;
|
|
re.re_prProjection->MirrorPlaneL() = mi.mi_plPlane;
|
|
re.re_prProjection->MirrorPlaneL().Offset(0.05f); // move projection towards mirror a bit, to avoid cracks
|
|
}
|
|
re.re_bRenderingShadows = FALSE;
|
|
re.re_ubLightIllumination = 0;
|
|
|
|
// just flat-fill if mirrors are disabled
|
|
extern INDEX wld_bRenderMirrors;
|
|
if( !wld_bRenderMirrors) dpMirror.Fill(C_GRAY|CT_OPAQUE);
|
|
else {
|
|
// render the view inside mirror
|
|
StopStatsMode();
|
|
_pfRenderProfile.StopTimer(CRenderProfile::PTI_RENDERING);
|
|
re.Render();
|
|
_pfRenderProfile.StartTimer(CRenderProfile::PTI_RENDERING);
|
|
StartStatsMode(CStatForm::STI_WORLDTRANSFORM);
|
|
}
|
|
// unlock mirror's and lock back the original drawport
|
|
dpMirror.Unlock();
|
|
re_pdpDrawPort->Lock();
|
|
// clear entire buffer to back value
|
|
re_pdpDrawPort->FillZBuffer(ZBUF_BACK);
|
|
// fill depth buffer of the mirror, so that scene cannot be drawn through it
|
|
FillMirrorDepth(mi);
|
|
_bMirrorDrawn = TRUE;
|
|
}
|
|
|
|
// flush all mirrors
|
|
re_amiMirrors.PopAll();
|
|
|
|
// fill z-buffer only if no mirrors have been drawn, not rendering second layer in world editor and not in wireframe mode
|
|
if( !_bMirrorDrawn
|
|
&& !re_pdpDrawPort->IsOverlappedRendering()
|
|
&& _wrpWorldRenderPrefs.wrp_ftPolygons != CWorldRenderPrefs::FT_NONE) {
|
|
re_pdpDrawPort->FillZBuffer(ZBUF_BACK);
|
|
}
|
|
// draw the prepared things to screen
|
|
DrawToScreen();
|
|
}
|
|
|
|
// no mirrors
|
|
else
|
|
{
|
|
// if rendering a mirror
|
|
// or not rendering second layer in world editor
|
|
// and not in wireframe mode
|
|
if( re_iIndex>0
|
|
|| !re_bRenderingShadows
|
|
&& !re_pdpDrawPort->IsOverlappedRendering()
|
|
&& _wrpWorldRenderPrefs.wrp_ftPolygons != CWorldRenderPrefs::FT_NONE) {
|
|
re_pdpDrawPort->FillZBuffer(ZBUF_BACK);
|
|
}
|
|
// draw the prepared things to screen and finish
|
|
DrawToScreen();
|
|
CleanupScanning();
|
|
}
|
|
|
|
// disable fog/haze
|
|
StopFog();
|
|
StopHaze();
|
|
// reset vertex arrays if this is the last renderer
|
|
if( re_iIndex==0) _avtxScene.PopAll();
|
|
|
|
// for D3D (or mirror) we have to check depth points now, because we need back (not depth!) buffer for it,
|
|
// and D3D can't guarantee that it won't be discarded upon swapbuffers (especially if multisampling is on!) :(
|
|
#ifdef SE1_D3D
|
|
if( !re_bRenderingShadows && ((_pGfx->gl_eCurrentAPI==GAT_D3D && !d3d_bAlternateDepthReads) || re_iIndex>0)) {
|
|
extern void CheckDelayedDepthPoints( const CDrawPort *pdp, INDEX iMirrorLevel=0);
|
|
CheckDelayedDepthPoints( re_pdpDrawPort, re_iIndex);
|
|
}
|
|
#endif // SE1_D3D
|
|
|
|
// end select-on-render functionality
|
|
extern void EndSelectOnRender(void);
|
|
EndSelectOnRender();
|
|
|
|
// assure that FPU precision was low all the rendering time
|
|
ASSERT( GetFPUPrecision()==FPT_24BIT);
|
|
StopStatsMode();
|
|
}
|
|
|
|
|
|
/*
|
|
* Constructor.
|
|
*/
|
|
CRenderer::CRenderer(void)
|
|
{
|
|
// setup self index
|
|
INDEX i = this-_areRenderers;
|
|
ASSERT(i>=0 && i<MAX_RENDERERS);
|
|
re_iIndex = i;
|
|
}
|
|
/*
|
|
* Destructor.
|
|
*/
|
|
CRenderer::~CRenderer(void)
|
|
{
|
|
}
|
|
|
|
// initialize clipping rectangle
|
|
void CRenderer::InitClippingRectangle(PIX pixMinI, PIX pixMinJ, PIX pixSizeI, PIX pixSizeJ)
|
|
{
|
|
re_pspoFirst = NULL;
|
|
re_pspoFirstTranslucent = NULL;
|
|
re_pspoFirstBackground = NULL;
|
|
re_pspoFirstBackgroundTranslucent = NULL;
|
|
|
|
re_fMinJ = (FLOAT) pixMinJ;
|
|
re_fMaxJ = (FLOAT) pixSizeJ+pixMinJ;
|
|
re_pixSizeI = pixSizeI;
|
|
re_fbbClipBox =
|
|
FLOATaabbox2D( FLOAT2D((FLOAT) pixMinI+CLIPMARGADD,
|
|
(FLOAT) pixMinJ+CLIPMARGADD),
|
|
FLOAT2D((FLOAT) pixMinI+pixSizeI-CLIPMARGSUB,
|
|
(FLOAT) pixMinJ+pixSizeJ-CLIPMARGSUB));
|
|
re_pixTopScanLineJ = PIXCoord(pixMinJ+CLIPMARGADD);
|
|
re_ctScanLines =
|
|
PIXCoord(pixSizeJ-CLIPMARGSUB) - PIXCoord(CLIPMARGADD)/* +1*/;
|
|
re_pixBottomScanLineJ = re_pixTopScanLineJ+re_ctScanLines;
|
|
}
|
|
|
|
// render a 3D view to a drawport
|
|
void RenderView(CWorld &woWorld, CEntity &enViewer,
|
|
CAnyProjection3D &prProjection, CDrawPort &dpDrawport)
|
|
{
|
|
// let the worldbase execute its render function
|
|
if (woWorld.wo_pecWorldBaseClass!=NULL
|
|
&&woWorld.wo_pecWorldBaseClass->ec_pdecDLLClass!=NULL
|
|
&&woWorld.wo_pecWorldBaseClass->ec_pdecDLLClass->dec_OnWorldRender!=NULL) {
|
|
woWorld.wo_pecWorldBaseClass->ec_pdecDLLClass->dec_OnWorldRender(&woWorld);
|
|
}
|
|
|
|
if(_wrpWorldRenderPrefs.GetShadowsType() == CWorldRenderPrefs::SHT_FULL)
|
|
{
|
|
// calculate all non directional shadows that are not up to date
|
|
woWorld.CalculateNonDirectionalShadows();
|
|
}
|
|
|
|
// take first renderer object
|
|
CRenderer &re = _areRenderers[0];
|
|
// set it up for rendering
|
|
re.re_penViewer = &enViewer;
|
|
re.re_pcspoViewPolygons = NULL;
|
|
re.re_pwoWorld = &woWorld;
|
|
re.re_prProjection = prProjection;
|
|
re.re_pdpDrawPort = &dpDrawport;
|
|
// initialize clipping rectangle around the drawport
|
|
re.InitClippingRectangle(0, 0, dpDrawport.GetWidth(), dpDrawport.GetHeight());
|
|
prProjection->ScreenBBoxL() = FLOATaabbox2D(
|
|
FLOAT2D(0.0f, 0.0f),
|
|
FLOAT2D((float)dpDrawport.GetWidth(), (float)dpDrawport.GetHeight())
|
|
);
|
|
re.re_bRenderingShadows = FALSE;
|
|
re.re_ubLightIllumination = 0;
|
|
|
|
// render the view (with eventuall t-buffer effect)
|
|
extern void SetTBufferEffect( BOOL bEnable);
|
|
SetTBufferEffect(TRUE);
|
|
re.Render();
|
|
SetTBufferEffect(FALSE);
|
|
}
|
|
|
|
|
|
// Render a world with some viewer, projection and drawport. (viewer may be NULL)
|
|
// internal version used for rendering shadows
|
|
ULONG RenderShadows(CWorld &woWorld, CEntity &enViewer,
|
|
CAnyProjection3D &prProjection, const FLOATaabbox3D &boxViewer,
|
|
UBYTE *pubShadowMask, SLONG slShadowWidth, SLONG slShadowHeight,
|
|
UBYTE ubIllumination)
|
|
{
|
|
_pfWorldEditingProfile.StartTimer(CWorldEditingProfile::PTI_RENDERSHADOWS);
|
|
|
|
// take a renderer object
|
|
CRenderer &re = _areRenderers[0];
|
|
// set it up for rendering
|
|
re.re_penViewer = &enViewer;
|
|
re.re_pcspoViewPolygons = NULL;
|
|
re.re_pwoWorld = &woWorld;
|
|
re.re_prProjection = prProjection;
|
|
re.re_pdpDrawPort = NULL;
|
|
re.re_boxViewer = boxViewer;
|
|
// initialize clipping rectangle around the drawport
|
|
const FLOATaabbox2D &box = prProjection->ScreenBBoxR();
|
|
//re.InitClippingRectangle(box.Min()(1), box.Min()(2), box.Size()(1), box.Size()(2));
|
|
re.InitClippingRectangle(0, 0, (PIX) box.Size()(1), (PIX) box.Size()(2));
|
|
|
|
re.re_bRenderingShadows = TRUE;
|
|
re.re_bDirectionalShadows = prProjection.IsParallel();
|
|
re.re_bSomeLightExists = FALSE;
|
|
re.re_bSomeDarkExists = FALSE;
|
|
_bSomeDarkExists = FALSE;
|
|
re.re_pubShadow = pubShadowMask;
|
|
re.re_slShadowWidth = slShadowWidth;
|
|
re.re_slShadowHeight = slShadowHeight;
|
|
re.re_ubLightIllumination = ubIllumination;
|
|
// render the view
|
|
re.Render();
|
|
|
|
ULONG ulFlags = 0;
|
|
if (!re.re_bSomeLightExists) {
|
|
ulFlags|=BSLF_ALLDARK;
|
|
}
|
|
if (!(re.re_bSomeDarkExists|_bSomeDarkExists)) {
|
|
ulFlags|=BSLF_ALLLIGHT;
|
|
}
|
|
|
|
_pfWorldEditingProfile.StopTimer(CWorldEditingProfile::PTI_RENDERSHADOWS);
|
|
|
|
return ulFlags;
|
|
}
|