mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-23 14:14:45 +00:00
b32e7688c2
- Side by side rendering implemented throughout the graphics pipeline. - New GuiTSCtrl renderStyle property is set to "stereo side by side" to activate. - You set an IDisplayDevice on the GameConnection to define any vertical FOV, projection offset, and stereo eye offset properties required for the stereo rendering (no display device included with this commit). - Full and Empty templates updated with correct scripts and shaders.
367 lines
12 KiB
C++
367 lines
12 KiB
C++
//-----------------------------------------------------------------------------
|
|
// 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.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifndef _SCENEMANAGER_H_
|
|
#define _SCENEMANAGER_H_
|
|
|
|
#ifndef _SCENEOBJECT_H_
|
|
#include "scene/sceneObject.h"
|
|
#endif
|
|
|
|
#ifndef _SCENEZONESPACEMANAGER_H_
|
|
#include "scene/zones/sceneZoneSpaceManager.h"
|
|
#endif
|
|
|
|
#ifndef _MRECT_H_
|
|
#include "math/mRect.h"
|
|
#endif
|
|
|
|
#ifndef _COLOR_H_
|
|
#include "core/color.h"
|
|
#endif
|
|
|
|
#ifndef _INTERPOLATEDCHANGEPROPERTY_H_
|
|
#include "util/interpolatedChangeProperty.h"
|
|
#endif
|
|
|
|
#ifndef _GFXTEXTUREHANDLE_H_
|
|
#include "gfx/gfxTextureHandle.h"
|
|
#endif
|
|
|
|
#ifndef _FOGSTRUCTS_H_
|
|
#include "scene/fogStructs.h"
|
|
#endif
|
|
|
|
#ifndef _TVECTOR_H_
|
|
#include "core/util/tVector.h"
|
|
#endif
|
|
|
|
#ifndef _TSIGNAL_H_
|
|
#include "core/util/tSignal.h"
|
|
#endif
|
|
|
|
|
|
class LightManager;
|
|
class SceneRootZone;
|
|
class SceneRenderState;
|
|
class SceneCameraState;
|
|
class SceneZoneSpace;
|
|
class NetConnection;
|
|
class RenderPassManager;
|
|
|
|
|
|
/// The type of scene pass.
|
|
/// @see SceneManager
|
|
/// @see SceneRenderState
|
|
enum ScenePassType
|
|
{
|
|
/// The regular diffuse scene pass.
|
|
SPT_Diffuse,
|
|
|
|
/// The scene pass made for reflection rendering.
|
|
SPT_Reflect,
|
|
|
|
/// The scene pass made for shadow map rendering.
|
|
SPT_Shadow,
|
|
|
|
/// A scene pass that isn't one of the other
|
|
/// predefined scene pass types.
|
|
SPT_Other,
|
|
};
|
|
|
|
|
|
/// The type of scene render style
|
|
/// @see SceneRenderState
|
|
enum SceneRenderStyle
|
|
{
|
|
/// The regular style of rendering
|
|
SRS_Standard,
|
|
|
|
/// Side-by-side style rendering
|
|
SRS_SideBySide,
|
|
};
|
|
|
|
|
|
/// An object that manages the SceneObjects belonging to a scene.
|
|
class SceneManager
|
|
{
|
|
public:
|
|
|
|
/// A signal used to notify of render passes.
|
|
typedef Signal< void( SceneManager*, const SceneRenderState* ) > RenderSignal;
|
|
|
|
/// If true use the last stored locked frustum for culling
|
|
/// the diffuse render pass.
|
|
/// @see smLockedDiffuseFrustum
|
|
static bool smLockDiffuseFrustum;
|
|
|
|
/// If true, render the AABBs of objects for debugging.
|
|
static bool smRenderBoundingBoxes;
|
|
|
|
protected:
|
|
|
|
/// Whether this is the client-side scene.
|
|
bool mIsClient;
|
|
|
|
/// Manager for the zones in this scene.
|
|
SceneZoneSpaceManager* mZoneManager;
|
|
|
|
// NonClipProjection is the projection matrix without oblique frustum clipping
|
|
// applied to it (in reflections)
|
|
MatrixF mNonClipProj;
|
|
|
|
///
|
|
bool mUsePostEffectFog;
|
|
|
|
/// @see setDisplayTargetResolution
|
|
Point2I mDisplayTargetResolution;
|
|
|
|
/// The currently active render state or NULL if we're
|
|
/// not in the process of rendering.
|
|
SceneRenderState* mCurrentRenderState;
|
|
|
|
F32 mVisibleDistance;
|
|
|
|
F32 mNearClip;
|
|
|
|
FogData mFogData;
|
|
|
|
WaterFogData mWaterFogData;
|
|
|
|
/// The stored last diffuse pass frustum for locking the cull.
|
|
static SceneCameraState smLockedDiffuseCamera;
|
|
|
|
/// @name Lighting
|
|
/// @{
|
|
|
|
typedef InterpolatedChangeProperty< ColorF > AmbientLightInterpolator;
|
|
|
|
/// Light manager that is active for the scene.
|
|
LightManager* mLightManager;
|
|
|
|
/// Global ambient light level in the scene.
|
|
AmbientLightInterpolator mAmbientLightColor;
|
|
|
|
/// Deactivates the previous light manager and activates the new one.
|
|
bool _setLightManager( LightManager *lm );
|
|
|
|
/// @}
|
|
|
|
/// @name Rendering
|
|
/// @{
|
|
|
|
/// RenderPassManager for the default render pass. This is set up
|
|
/// in script and looked up by getDefaultRenderPass().
|
|
mutable RenderPassManager* mDefaultRenderPass;
|
|
|
|
///
|
|
Vector< SceneObject* > mBatchQueryList;
|
|
|
|
/// Render scene using the given state.
|
|
///
|
|
/// @param state SceneManager render state.
|
|
/// @param objectMask Object type mask with which to filter scene objects.
|
|
/// @param baseObject Zone manager to start traversal in. If null, the zone manager
|
|
/// that contains @a state's camera position will be used.
|
|
/// @param baseZone Zone in @a zone manager in which to start traversal. Ignored if
|
|
/// @a baseObject is NULL.
|
|
void _renderScene( SceneRenderState* state,
|
|
U32 objectMask = ( U32 ) -1,
|
|
SceneZoneSpace* baseObject = NULL,
|
|
U32 baseZone = 0 );
|
|
|
|
/// Callback for the container query.
|
|
static void _batchObjectCallback( SceneObject* object, void* key );
|
|
|
|
/// @}
|
|
|
|
public:
|
|
|
|
SceneManager( bool isClient );
|
|
~SceneManager();
|
|
|
|
/// Return the SceneContainer for this scene.
|
|
SceneContainer* getContainer() const { return mIsClient ? &gClientContainer : &gServerContainer; }
|
|
|
|
/// Return the manager for the zones in this scene.
|
|
/// @note Only client scenes have a zone manager as for the server, no zoning data is kept.
|
|
const SceneZoneSpaceManager* getZoneManager() const { return mZoneManager; }
|
|
SceneZoneSpaceManager* getZoneManager() { return mZoneManager; }
|
|
|
|
/// @name SceneObject Management
|
|
/// @{
|
|
|
|
/// Add the given object to the scene.
|
|
bool addObjectToScene( SceneObject* object );
|
|
|
|
/// Remove the given object from the scene.
|
|
void removeObjectFromScene( SceneObject* object );
|
|
|
|
/// Let the scene manager know that the given object has changed its transform or
|
|
/// sizing state.
|
|
void notifyObjectDirty( SceneObject* object );
|
|
|
|
/// @}
|
|
|
|
/// @name Rendering
|
|
/// @{
|
|
|
|
/// Return the default RenderPassManager for the scene.
|
|
RenderPassManager* getDefaultRenderPass() const;
|
|
|
|
/// Set the default render pass for the scene.
|
|
void setDefaultRenderPass( RenderPassManager* rpm ) { mDefaultRenderPass = rpm; }
|
|
|
|
/// Render the scene with the default render pass.
|
|
/// @note This uses the current GFX state (transforms, viewport, frustum) to initialize
|
|
/// the render state.
|
|
void renderScene( ScenePassType passType, U32 objectMask = DEFAULT_RENDER_TYPEMASK );
|
|
|
|
/// Render the scene with a custom rendering pass.
|
|
void renderScene( SceneRenderState *state, U32 objectMask = DEFAULT_RENDER_TYPEMASK, SceneZoneSpace* baseObject = NULL, U32 baseZone = 0 );
|
|
|
|
/// Render the scene with a custom rendering pass and no lighting set up.
|
|
void renderSceneNoLights( SceneRenderState *state, U32 objectMask = DEFAULT_RENDER_TYPEMASK, SceneZoneSpace* baseObject = NULL, U32 baseZone = 0 );
|
|
|
|
/// Returns the currently active scene state or NULL if no state is currently active.
|
|
SceneRenderState* getCurrentRenderState() const { return mCurrentRenderState; }
|
|
|
|
static RenderSignal& getPreRenderSignal()
|
|
{
|
|
static RenderSignal theSignal;
|
|
return theSignal;
|
|
}
|
|
|
|
static RenderSignal& getPostRenderSignal()
|
|
{
|
|
static RenderSignal theSignal;
|
|
return theSignal;
|
|
}
|
|
|
|
/// @}
|
|
|
|
/// @name Lighting
|
|
/// @{
|
|
|
|
/// Finds the light manager by name and activates it.
|
|
bool setLightManager( const char *lmName );
|
|
|
|
/// Return the current global ambient light color.
|
|
const ColorF& getAmbientLightColor() const { return mAmbientLightColor.getCurrentValue(); }
|
|
|
|
/// Set the time it takes for a new ambient light color to take full effect.
|
|
void setAmbientLightTransitionTime( SimTime time ) { mAmbientLightColor.setTransitionTime( time ); }
|
|
|
|
/// Set the interpolation curve to use for blending from one global ambient light
|
|
/// color to a different one.
|
|
void setAmbientLightTransitionCurve( const EaseF& ease ) { mAmbientLightColor.setTransitionCurve( ease ); }
|
|
|
|
/// @}
|
|
|
|
/// @name Networking
|
|
/// @{
|
|
|
|
/// Set the scoping states of the objects in the scene.
|
|
void scopeScene( CameraScopeQuery* query, NetConnection* netConnection );
|
|
|
|
/// @}
|
|
|
|
/// @name Fog/Visibility Management
|
|
/// @{
|
|
|
|
void setPostEffectFog( bool enable ) { mUsePostEffectFog = enable; }
|
|
bool usePostEffectFog() const { return mUsePostEffectFog; }
|
|
|
|
/// Accessor for the FogData structure.
|
|
const FogData& getFogData() { return mFogData; }
|
|
|
|
/// Sets the FogData structure.
|
|
void setFogData( const FogData &data ) { mFogData = data; }
|
|
|
|
/// Accessor for the WaterFogData structure.
|
|
const WaterFogData& getWaterFogData() { return mWaterFogData; }
|
|
|
|
/// Sets the WaterFogData structure.
|
|
void setWaterFogData( const WaterFogData &data ) { mWaterFogData = data; }
|
|
|
|
/// Used by LevelInfo to set the default visible distance for
|
|
/// rendering the scene.
|
|
///
|
|
/// Note this should not be used to alter culling which is
|
|
/// controlled by the active frustum when a SceneRenderState is created.
|
|
///
|
|
/// @see SceneRenderState
|
|
/// @see GameProcessCameraQuery
|
|
/// @see LevelInfo
|
|
void setVisibleDistance( F32 dist ) { mVisibleDistance = dist; }
|
|
|
|
/// Returns the default visible distance for the scene.
|
|
F32 getVisibleDistance() { return mVisibleDistance; }
|
|
|
|
/// Used by LevelInfo to set the default near clip plane
|
|
/// for rendering the scene.
|
|
///
|
|
/// @see GameProcessCameraQuery
|
|
/// @see LevelInfo
|
|
void setNearClip( F32 nearClip ) { mNearClip = nearClip; }
|
|
|
|
/// Returns the default near clip distance for the scene.
|
|
F32 getNearClip() { return mNearClip; }
|
|
|
|
/// @}
|
|
|
|
/// @name dtr Display Target Resolution
|
|
///
|
|
/// Some rendering must be targeted at a specific display resolution.
|
|
/// This display resolution is distinct from the current RT's size
|
|
/// (such as when rendering a reflection to a texture, for instance)
|
|
/// so we store the size at which we're going to display the results of
|
|
/// the current render.
|
|
///
|
|
/// @{
|
|
|
|
///
|
|
void setDisplayTargetResolution(const Point2I &size);
|
|
const Point2I &getDisplayTargetResolution() const;
|
|
|
|
/// @}
|
|
|
|
// NonClipProjection is the projection matrix without oblique frustum clipping
|
|
// applied to it (in reflections)
|
|
void setNonClipProjection( const MatrixF &proj ) { mNonClipProj = proj; }
|
|
const MatrixF& getNonClipProjection() const { return mNonClipProj; }
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//TODO: these two need to go
|
|
|
|
/// The client-side scene graph. Not used if the engine is running
|
|
/// as a dedicated server.
|
|
extern SceneManager* gClientSceneGraph;
|
|
|
|
/// The server-side scene graph. Not used if the engine is running
|
|
/// as a pure client.
|
|
extern SceneManager* gServerSceneGraph;
|
|
|
|
#endif //_SCENEMANAGER_H_
|