mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-02 17:02:17 +00:00
306 lines
14 KiB
C++
306 lines
14 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
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.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#ifndef __RENDERWORLDLOCAL_H__
|
|
#define __RENDERWORLDLOCAL_H__
|
|
|
|
#include "BoundsTrack.h"
|
|
|
|
// assume any lightDef or entityDef index above this is an internal error
|
|
const int LUDICROUS_INDEX = 10000;
|
|
|
|
|
|
typedef struct portal_s
|
|
{
|
|
int intoArea; // area this portal leads to
|
|
idWinding* w; // winding points have counter clockwise ordering seen this area
|
|
idPlane plane; // view must be on the positive side of the plane to cross
|
|
struct portal_s* next; // next portal of the area
|
|
struct doublePortal_s* doublePortal;
|
|
} portal_t;
|
|
|
|
|
|
typedef struct doublePortal_s
|
|
{
|
|
struct portal_s* portals[2];
|
|
int blockingBits; // PS_BLOCK_VIEW, PS_BLOCK_AIR, etc, set by doors that shut them off
|
|
|
|
// A portal will be considered closed if it is past the
|
|
// fog-out point in a fog volume. We only support a single
|
|
// fog volume over each portal.
|
|
idRenderLightLocal* fogLight;
|
|
struct doublePortal_s* nextFoggedPortal;
|
|
} doublePortal_t;
|
|
|
|
|
|
typedef struct portalArea_s
|
|
{
|
|
int areaNum;
|
|
int connectedAreaNum[NUM_PORTAL_ATTRIBUTES]; // if two areas have matching connectedAreaNum, they are
|
|
// not separated by a portal with the apropriate PS_BLOCK_* blockingBits
|
|
int viewCount; // set by R_FindViewLightsAndEntities
|
|
portal_t* portals; // never changes after load
|
|
areaReference_t entityRefs; // head/tail of doubly linked list, may change
|
|
areaReference_t lightRefs; // head/tail of doubly linked list, may change
|
|
} portalArea_t;
|
|
|
|
|
|
static const int CHILDREN_HAVE_MULTIPLE_AREAS = -2;
|
|
static const int AREANUM_SOLID = -1;
|
|
typedef struct
|
|
{
|
|
idPlane plane;
|
|
int children[2]; // negative numbers are (-1 - areaNumber), 0 = solid
|
|
int commonChildrenArea; // if all children are either solid or a single area,
|
|
// this is the area number, else CHILDREN_HAVE_MULTIPLE_AREAS
|
|
} areaNode_t;
|
|
|
|
struct reusableDecal_t
|
|
{
|
|
qhandle_t entityHandle;
|
|
int lastStartTime;
|
|
idRenderModelDecal* decals;
|
|
};
|
|
|
|
struct reusableOverlay_t
|
|
{
|
|
qhandle_t entityHandle;
|
|
int lastStartTime;
|
|
idRenderModelOverlay* overlays;
|
|
};
|
|
|
|
struct portalStack_t;
|
|
|
|
class idRenderWorldLocal : public idRenderWorld
|
|
{
|
|
public:
|
|
idRenderWorldLocal();
|
|
virtual ~idRenderWorldLocal();
|
|
|
|
virtual bool InitFromMap( const char* mapName );
|
|
virtual void ResetLocalRenderModels(); // Fixes a crash when switching between expansion packs in Doom3:BFG
|
|
|
|
virtual qhandle_t AddEntityDef( const renderEntity_t* re );
|
|
virtual void UpdateEntityDef( qhandle_t entityHandle, const renderEntity_t* re );
|
|
virtual void FreeEntityDef( qhandle_t entityHandle );
|
|
virtual const renderEntity_t* GetRenderEntity( qhandle_t entityHandle ) const;
|
|
|
|
virtual qhandle_t AddLightDef( const renderLight_t* rlight );
|
|
virtual void UpdateLightDef( qhandle_t lightHandle, const renderLight_t* rlight );
|
|
virtual void FreeLightDef( qhandle_t lightHandle );
|
|
virtual const renderLight_t* GetRenderLight( qhandle_t lightHandle ) const;
|
|
|
|
virtual bool CheckAreaForPortalSky( int areaNum );
|
|
|
|
virtual void GenerateAllInteractions();
|
|
virtual void RegenerateWorld();
|
|
|
|
virtual void ProjectDecalOntoWorld( const idFixedWinding& winding, const idVec3& projectionOrigin, const bool parallel, const float fadeDepth, const idMaterial* material, const int startTime );
|
|
virtual void ProjectDecal( qhandle_t entityHandle, const idFixedWinding& winding, const idVec3& projectionOrigin, const bool parallel, const float fadeDepth, const idMaterial* material, const int startTime );
|
|
virtual void ProjectOverlay( qhandle_t entityHandle, const idPlane localTextureAxis[2], const idMaterial* material, const int startTime );
|
|
virtual void RemoveDecals( qhandle_t entityHandle );
|
|
|
|
virtual void SetRenderView( const renderView_t* renderView );
|
|
virtual void RenderScene( const renderView_t* renderView );
|
|
|
|
virtual int NumAreas() const;
|
|
virtual int PointInArea( const idVec3& point ) const;
|
|
virtual int BoundsInAreas( const idBounds& bounds, int* areas, int maxAreas ) const;
|
|
virtual int NumPortalsInArea( int areaNum );
|
|
virtual exitPortal_t GetPortal( int areaNum, int portalNum );
|
|
|
|
virtual guiPoint_t GuiTrace( qhandle_t entityHandle, const idVec3 start, const idVec3 end ) const;
|
|
virtual bool ModelTrace( modelTrace_t& trace, qhandle_t entityHandle, const idVec3& start, const idVec3& end, const float radius ) const;
|
|
virtual bool Trace( modelTrace_t& trace, const idVec3& start, const idVec3& end, const float radius, bool skipDynamic = true, bool skipPlayer = false ) const;
|
|
virtual bool FastWorldTrace( modelTrace_t& trace, const idVec3& start, const idVec3& end ) const;
|
|
|
|
virtual void DebugClearLines( int time );
|
|
virtual void DebugLine( const idVec4& color, const idVec3& start, const idVec3& end, const int lifetime = 0, const bool depthTest = false );
|
|
virtual void DebugArrow( const idVec4& color, const idVec3& start, const idVec3& end, int size, const int lifetime = 0 );
|
|
virtual void DebugWinding( const idVec4& color, const idWinding& w, const idVec3& origin, const idMat3& axis, const int lifetime = 0, const bool depthTest = false );
|
|
virtual void DebugCircle( const idVec4& color, const idVec3& origin, const idVec3& dir, const float radius, const int numSteps, const int lifetime = 0, const bool depthTest = false );
|
|
virtual void DebugSphere( const idVec4& color, const idSphere& sphere, const int lifetime = 0, bool depthTest = false );
|
|
virtual void DebugBounds( const idVec4& color, const idBounds& bounds, const idVec3& org = vec3_origin, const int lifetime = 0 );
|
|
virtual void DebugBox( const idVec4& color, const idBox& box, const int lifetime = 0 );
|
|
virtual void DebugCone( const idVec4& color, const idVec3& apex, const idVec3& dir, float radius1, float radius2, const int lifetime = 0 );
|
|
virtual void DebugScreenRect( const idVec4& color, const idScreenRect& rect, const viewDef_t* viewDef, const int lifetime = 0 );
|
|
virtual void DebugAxis( const idVec3& origin, const idMat3& axis );
|
|
|
|
virtual void DebugClearPolygons( int time );
|
|
virtual void DebugPolygon( const idVec4& color, const idWinding& winding, const int lifeTime = 0, const bool depthTest = false );
|
|
|
|
virtual void DrawText( const char* text, const idVec3& origin, float scale, const idVec4& color, const idMat3& viewAxis, const int align = 1, const int lifetime = 0, bool depthTest = false );
|
|
|
|
//-----------------------
|
|
|
|
idStr mapName; // ie: maps/tim_dm2.proc, written to demoFile
|
|
ID_TIME_T mapTimeStamp; // for fast reloads of the same level
|
|
|
|
areaNode_t* areaNodes;
|
|
int numAreaNodes;
|
|
|
|
portalArea_t* portalAreas;
|
|
int numPortalAreas;
|
|
int connectedAreaNum; // incremented every time a door portal state changes
|
|
|
|
idScreenRect* areaScreenRect;
|
|
|
|
doublePortal_t* doublePortals;
|
|
int numInterAreaPortals;
|
|
|
|
idList<idRenderModel*, TAG_MODEL> localModels;
|
|
|
|
idList<idRenderEntityLocal*, TAG_ENTITY> entityDefs;
|
|
idList<idRenderLightLocal*, TAG_LIGHT> lightDefs;
|
|
|
|
idBlockAlloc<areaReference_t, 1024> areaReferenceAllocator;
|
|
idBlockAlloc<idInteraction, 256> interactionAllocator;
|
|
|
|
#ifdef ID_PC
|
|
static const int MAX_DECAL_SURFACES = 32;
|
|
#else
|
|
static const int MAX_DECAL_SURFACES = 16;
|
|
#endif
|
|
idArray<reusableDecal_t, MAX_DECAL_SURFACES> decals;
|
|
idArray<reusableOverlay_t, MAX_DECAL_SURFACES> overlays;
|
|
|
|
// all light / entity interactions are referenced here for fast lookup without
|
|
// having to crawl the doubly linked lists. EnntityDefs are sequential for better
|
|
// cache access, because the table is accessed by light in idRenderWorldLocal::CreateLightDefInteractions()
|
|
// Growing this table is time consuming, so we add a pad value to the number
|
|
// of entityDefs and lightDefs
|
|
idInteraction** interactionTable;
|
|
int interactionTableWidth; // entityDefs
|
|
int interactionTableHeight; // lightDefs
|
|
|
|
bool generateAllInteractionsCalled;
|
|
|
|
//-----------------------
|
|
// RenderWorld_load.cpp
|
|
|
|
idRenderModel* ParseModel( idLexer* src, const char* mapName, ID_TIME_T mapTimeStamp, idFile* fileOut );
|
|
idRenderModel* ParseShadowModel( idLexer* src, idFile* fileOut );
|
|
void SetupAreaRefs();
|
|
void ParseInterAreaPortals( idLexer* src, idFile* fileOut );
|
|
void ParseNodes( idLexer* src, idFile* fileOut );
|
|
int CommonChildrenArea_r( areaNode_t* node );
|
|
void FreeWorld();
|
|
void ClearWorld();
|
|
void FreeDefs();
|
|
void TouchWorldModels();
|
|
void AddWorldModelEntities();
|
|
void ClearPortalStates();
|
|
void ReadBinaryAreaPortals( idFile* file );
|
|
void ReadBinaryNodes( idFile* file );
|
|
idRenderModel* ReadBinaryModel( idFile* file );
|
|
idRenderModel* ReadBinaryShadowModel( idFile* file );
|
|
|
|
//--------------------------
|
|
// RenderWorld_portals.cpp
|
|
|
|
bool CullEntityByPortals( const idRenderEntityLocal* entity, const portalStack_t* ps );
|
|
void AddAreaViewEntities( int areaNum, const portalStack_t* ps );
|
|
bool CullLightByPortals( const idRenderLightLocal* light, const portalStack_t* ps );
|
|
void AddAreaViewLights( int areaNum, const portalStack_t* ps );
|
|
void AddAreaToView( int areaNum, const portalStack_t* ps );
|
|
idScreenRect ScreenRectFromWinding( const idWinding* w, const viewEntity_t* space );
|
|
bool PortalIsFoggedOut( const portal_t* p );
|
|
void FloodViewThroughArea_r( const idVec3& origin, int areaNum, const portalStack_t* ps );
|
|
void FlowViewThroughPortals( const idVec3& origin, int numPlanes, const idPlane* planes );
|
|
void BuildConnectedAreas_r( int areaNum );
|
|
void BuildConnectedAreas();
|
|
void FindViewLightsAndEntities();
|
|
|
|
void FloodLightThroughArea_r( idRenderLightLocal* light, int areaNum, const portalStack_t* ps );
|
|
void FlowLightThroughPortals( idRenderLightLocal* light );
|
|
|
|
int NumPortals() const;
|
|
qhandle_t FindPortal( const idBounds& b ) const;
|
|
void SetPortalState( qhandle_t portal, int blockingBits );
|
|
int GetPortalState( qhandle_t portal );
|
|
bool AreasAreConnected( int areaNum1, int areaNum2, portalConnection_t connection ) const;
|
|
void FloodConnectedAreas( portalArea_t* area, int portalAttributeIndex );
|
|
idScreenRect& GetAreaScreenRect( int areaNum ) const
|
|
{
|
|
return areaScreenRect[areaNum];
|
|
}
|
|
void ShowPortals();
|
|
|
|
//--------------------------
|
|
// RenderWorld_demo.cpp
|
|
|
|
void StartWritingDemo( idDemoFile* demo );
|
|
void StopWritingDemo();
|
|
bool ProcessDemoCommand( idDemoFile* readDemo, renderView_t* demoRenderView, int* demoTimeOffset );
|
|
|
|
void WriteLoadMap();
|
|
void WriteRenderView( const renderView_t* renderView );
|
|
void WriteVisibleDefs( const viewDef_t* viewDef );
|
|
void WriteFreeLight( qhandle_t handle );
|
|
void WriteFreeEntity( qhandle_t handle );
|
|
void WriteRenderLight( qhandle_t handle, const renderLight_t* light );
|
|
void WriteRenderEntity( qhandle_t handle, const renderEntity_t* ent );
|
|
void ReadRenderEntity();
|
|
void ReadRenderLight();
|
|
|
|
|
|
//--------------------------
|
|
// RenderWorld.cpp
|
|
|
|
void ResizeInteractionTable();
|
|
|
|
void AddEntityRefToArea( idRenderEntityLocal* def, portalArea_t* area );
|
|
void AddLightRefToArea( idRenderLightLocal* light, portalArea_t* area );
|
|
|
|
void RecurseProcBSP_r( modelTrace_t* results, int parentNodeNum, int nodeNum, float p1f, float p2f, const idVec3& p1, const idVec3& p2 ) const;
|
|
void BoundsInAreas_r( int nodeNum, const idBounds& bounds, int* areas, int* numAreas, int maxAreas ) const;
|
|
|
|
float DrawTextLength( const char* text, float scale, int len = 0 );
|
|
|
|
void FreeInteractions();
|
|
|
|
void PushFrustumIntoTree_r( idRenderEntityLocal* def, idRenderLightLocal* light, const frustumCorners_t& corners, int nodeNum );
|
|
void PushFrustumIntoTree( idRenderEntityLocal* def, idRenderLightLocal* light, const idRenderMatrix& frustumTransform, const idBounds& frustumBounds );
|
|
|
|
idRenderModelDecal* AllocDecal( qhandle_t newEntityHandle, int startTime );
|
|
idRenderModelOverlay* AllocOverlay( qhandle_t newEntityHandle, int startTime );
|
|
|
|
//-------------------------------
|
|
// tr_light.c
|
|
void CreateLightDefInteractions( idRenderLightLocal* const ldef, const int renderViewID );
|
|
};
|
|
|
|
// if an entity / light combination has been evaluated and found to not genrate any surfaces or shadows,
|
|
// the constant INTERACTION_EMPTY will be stored in the interaction table, int contrasts to NULL, which
|
|
// means that the combination has not yet been tested for having surfaces.
|
|
static idInteraction* const INTERACTION_EMPTY = ( idInteraction* )1;
|
|
|
|
void R_ListRenderLightDefs_f( const idCmdArgs& args );
|
|
void R_ListRenderEntityDefs_f( const idCmdArgs& args );
|
|
|
|
#endif /* !__RENDERWORLDLOCAL_H__ */
|