public override void CreateViewports()
{
base.CreateViewports();
viewport2 = window.AddViewport( camera2, 0.6f, 0, 0.4f, 0.4f, 102 );
viewport2.ShowOverlays = false;
viewport2.BackgroundColor = ColorEx.Blue;
}
/// <summary>
/// Adds an object to the collection.
/// </summary>
/// <param name="item"></param>
public void Add(T item)
{
Debug.Assert(!objectList.ContainsKey(item.ZOrder), "A viewport with the specified ZOrder " + item.ZOrder + " already exists.");
// assign this viewport to the parent RenderTarget
item.Target = (P)parent;
// add the viewport
base.Add(item.ZOrder, item);
}
public void OnLoad()
{
//ResourceGroupManager.Instance.AddResourceLocation("media", "Folder", true);
_root.SceneManager = _sceneManager = _root.CreateSceneManager(SceneType.ExteriorClose);
_sceneManager.ClearScene();
_camera = _sceneManager.CreateCamera("MainCamera");
_camera.Position = new Vector3(0, 0, 500);
_camera.LookAt(new Vector3(0, 0, -300));
_camera.Near = 5;
_camera.AutoAspectRatio = true;
_camera.FieldOfView = 0.70f;
_viewport = _renderWindow.AddViewport(_camera, 0, 0, 1.0f, 1.0f, 100);
_viewport.BackgroundColor = ColorEx.Black; ;
_light = _sceneManager.CreateLight("light1");
_light.Type = LightType.Directional;
_light.Position = new Vector3(0, 150, 300);
_light.Diffuse = ColorEx.Blue;
_light.Specular = ColorEx.Blue;
//_light.Direction = new Vector3(0, 0, -300);
_sceneManager.AmbientLight = ColorEx.White;// new ColorEx(0.2f, 0.2f, 0.2f);
ResourceGroupManager.Instance.InitializeAllResourceGroups();
_inputReader = PlatformManager.Instance.CreateInputReader();
_inputReader.Initialize(_renderWindow, true, true, false, false);
_inputReader.UseKeyboardEvents = true;
_inputReader.UseMouseEvents = false;
//_renderItems.Add(new BasicCube());
_renderItems.Add(new CubeBrowser());
foreach (var i in _renderItems)
{
i.Initialise(_root);
}
}
protected virtual void FireViewportPreUpdate(Viewport viewport)
{
if (BeforeViewportUpdate != null)
{
BeforeViewportUpdate(new RenderTargetViewportEventArgs(this, viewport));
}
}
public RenderTargetViewportEventArgs(RenderTarget source, Viewport viewport)
: base(source)
{
this.viewport = viewport;
}
public virtual void UpdateViewport(Viewport viewport, bool updateStatistics)
{
Debug.Assert(viewport.Target == this,
"RenderTarget::_updateViewport the requested viewport is not bound to the rendertarget!");
FireViewportPreUpdate(viewport);
viewport.Update();
if (updateStatistics)
{
stats.TriangleCount += viewport.RenderedFaceCount;
stats.BatchCount += viewport.RenderedBatchCount;
}
FireViewportPostUpdate(viewport);
}
public void ManualRender( RenderOperation op,
Pass pass,
Viewport vp,
Matrix4 worldMatrix,
Matrix4 viewMatrix,
Matrix4 projMatrix )
{
this.ManualRender( op, pass, vp, worldMatrix, viewMatrix, projMatrix, false );
}
//---------------------------------------------------------------------
protected override void PrepareShadowTextures( Camera cam, Viewport vp )
{
if ( ( (PCZSceneNode)cam.ParentSceneNode ) != null )
{
this.activeCameraZone = ( (PCZSceneNode)cam.ParentSceneNode ).HomeZone;
}
base.PrepareShadowTextures( cam, vp );
}
public virtual Viewport AddViewport(Camera camera, float left, float top, float nwidth, float nheight, int zOrder)
{
if (ViewportList.ContainsKey(zOrder))
throw new AxiomException("Can't create another viewport for {0} with Z-Order {1} because a viewport exists with this Z-Order already.", name, zOrder);
// create a new camera and add it to our internal collection
var viewport = new Viewport(camera, this, left, top, nwidth, nheight, zOrder);
ViewportList.Add(viewport);
FireViewportAdded(viewport);
return viewport;
}
public void NotifyViewport( Viewport viewport )
{
Viewport = viewport;
}
///<summary>
/// Restore a viewport, the camera and the scene after a rendering operation
///</summary>
protected void PostTargetOperation(CompositorTargetOperation op, Viewport vp, Camera cam)
{
SceneManager sm = cam.SceneManager;
/// Unregister our listener
sm.QueueStarted -= listener.OnRenderQueueStarted;
sm.QueueEnded -= listener.OnRenderQueueEnded;
/// Flush remaing operations
listener.FlushUpTo(RenderQueueGroupID.Count);
/// Restore default scene and camera settings
sm.VisibilityMask = oldVisibilityMask;
sm.FindVisibleObjectsBool = oldFindVisibleObjects;
cam.LodBias = oldLodBias;
vp.MaterialScheme = oldMaterialScheme;
}
///<summary>
/// Prepare a viewport, the camera and the scene for a rendering operation
///</summary>
protected void PreTargetOperation(CompositorTargetOperation op, Viewport vp, Camera cam)
{
SceneManager sm = cam.SceneManager;
/// Set up render target listener
listener.SetOperation(op, sm, sm.TargetRenderSystem);
listener.NotifyViewport(vp);
/// Register it
sm.QueueStarted += listener.OnRenderQueueStarted;
sm.QueueEnded += listener.OnRenderQueueEnded;
/// Set visiblity mask
oldVisibilityMask = sm.VisibilityMask;
sm.VisibilityMask = op.VisibilityMask;
/// Set whether we find visibles
oldFindVisibleObjects = sm.FindVisibleObjectsBool;
sm.FindVisibleObjectsBool = op.FindVisibleObjects;
/// Set LOD bias level
oldLodBias = cam.LodBias;
cam.LodBias = cam.LodBias * op.LodBias;
/// Set material scheme
oldMaterialScheme = vp.MaterialScheme;
vp.MaterialScheme = op.MaterialScheme;
/// XXX TODO
//vp->setClearEveryFrame( true );
//vp->setOverlaysEnabled( false );
//vp->setBackgroundColour( op.clearColour );
}
public CompositorChain(Viewport vp)
{
this.viewport = vp;
originalScene = null;
instances = new List<CompositorInstance>();
dirty = true;
anyCompositorsEnabled = false;
compiledState = new List<CompositorTargetOperation>();
outputOperation = null;
oldClearEveryFrameBuffers = viewport.ClearBuffers;
renderSystemOperations = new List<CompositorRenderSystemOperation>();
listener = new RQListener();
Debug.Assert(viewport != null);
}
///<summary>
/// destroy internal resources
///</summary>
protected void DestroyResources()
{
ClearCompiledState();
if (viewport != null) {
RemoveAllCompositors();
viewport.Target.BeforeUpdate -= BeforeRenderTargetUpdate;
// viewport.Target.AfterUpdate -= AfterRenderTargetUpdate;
viewport.Target.BeforeViewportUpdate -= BeforeViewportUpdate;
viewport.Target.AfterViewportUpdate -= AfterViewportUpdate;
/// Destroy "original scene" compositor instance
originalScene.Technique.DestroyInstance(originalScene);
viewport = null;
}
}
protected virtual void OnBeforeViewportUpdate(Viewport viewport)
{
if(BeforeViewportUpdate != null) {
ViewportUpdateEventArgs e = new ViewportUpdateEventArgs();
e.viewport = viewport;
BeforeViewportUpdate(this, e);
}
}
/// <summary>
/// Internal method for queueing the visible overlays for rendering.
/// </summary>
/// <param name="camera"></param>
/// <param name="queue"></param>
/// <param name="viewport"></param>
internal void QueueOverlaysForRendering(Camera camera, RenderQueue queue, Viewport viewport)
{
// Flag for update pixel-based OverlayElements if viewport has changed dimensions
if(lastViewportWidth != viewport.ActualWidth ||
lastViewportHeight != viewport.ActualHeight) {
viewportDimensionsChanged = true;
lastViewportWidth = viewport.ActualWidth;
lastViewportHeight = viewport.ActualHeight;
}
else {
viewportDimensionsChanged = false;
}
// TODO: optimize this resource list to avoid the foreach
foreach(Overlay overlay in resourceList.Values) {
overlay.FindVisibleObjects(camera, queue);
}
}
// Overridden from SceneManager
public new void RenderScene( Camera cam, Viewport vp, bool includeOverlays )
{
// notify all the zones that a scene render is starting
foreach ( PCZone zone in this.zones )
{
zone.NotifyBeginRenderScene();
}
// do the regular _renderScene
base.RenderScene( cam, vp, includeOverlays );
}
protected virtual void FireViewportPostUpdate(Viewport viewport)
{
if (AfterViewportUpdate != null)
{
AfterViewportUpdate(new RenderTargetViewportEventArgs(this, viewport));
}
}
///<summary>
/// Notify current destination viewport
///</summary>
public void NotifyViewport(Viewport vp)
{
viewport = vp;
}
protected virtual void FireViewportRemoved(Viewport viewport)
{
if (ViewportRemoved != null)
{
ViewportRemoved(new RenderTargetViewportEventArgs(this, viewport));
}
}
/// <summary>
/// Prompts the class to send its contents to the renderer.
/// </summary>
/// <remarks>
/// This method prompts the scene manager to send the
/// contents of the scene it manages to the rendering
/// pipeline, possibly preceded by some sorting, culling
/// or other scene management tasks. Note that this method is not normally called
/// directly by the user application; it is called automatically
/// by the engine's rendering loop.
/// </remarks>
/// <param name="camera">Pointer to a camera from whose viewpoint the scene is to be rendered.</param>
/// <param name="viewport">The target viewport</param>
/// <param name="showOverlays">Whether or not any overlay objects should be rendered</param>
protected internal void RenderScene( Camera camera, Viewport viewport, bool showOverlays )
{
// let the engine know this is the current scene manager
Root.Instance.SceneManager = this;
if ( this.IsShadowTechniqueInUse )
{
// initialize shadow volume materials
this.InitShadowVolumeMaterials();
}
// Perform a quick pre-check to see whether we should override far distance
// When using stencil volumes we have to use infinite far distance
// to prevent dark caps getting clipped
if ( this.IsShadowTechniqueStencilBased &&
camera.Far != 0 &&
this.targetRenderSystem.Capabilities.HasCapability( Capabilities.InfiniteFarPlane ) &&
this.shadowUseInfiniteFarPlane )
{
// infinite far distance
camera.Far = 0.0f;
}
this.cameraInProgress = camera;
this.hasCameraChanged = true;
// Update the scene, only do this once per frame
ulong thisFrameNumber = Root.Instance.CurrentFrameCount;
if ( thisFrameNumber != this.lastFrameNumber )
{
// Update animations
this.ApplySceneAnimations();
// Update controllers
ControllerManager.Instance.UpdateAll();
this.lastFrameNumber = thisFrameNumber;
}
// Update scene graph for this camera (can happen multiple times per frame)
this.UpdateSceneGraph( camera );
// Auto-track nodes
foreach ( SceneNode sn in autoTrackingSceneNodes.Values )
{
sn.AutoTrack();
}
// ask the camera to auto track if it has a target
camera.AutoTrack();
// Are we using any shadows at all?
if ( this.IsShadowTechniqueInUse && this.illuminationStage != IlluminationRenderStage.RenderToTexture &&
viewport.ShowShadows && this.findVisibleObjects )
{
// Locate any lights which could be affecting the frustum
this.FindLightsAffectingFrustum( camera );
if ( this.IsShadowTechniqueTextureBased )
{
// *******
// WARNING
// *******
// This call will result in re-entrant calls to this method
// therefore anything which comes before this is NOT
// guaranteed persistent. Make sure that anything which
// MUST be specific to this camera / target is done
// AFTER THIS POINT
this.PrepareShadowTextures( camera, viewport );
// reset the cameras because of the re-entrant call
this.cameraInProgress = camera;
this.hasCameraChanged = true;
}
}
// Invert vertex winding?
this.targetRenderSystem.InvertVertexWinding = camera.IsReflected;
// Tell params about viewport
this.autoParamDataSource.Viewport = viewport;
// Set the viewport
this.SetViewport( viewport );
// set the current camera for use in the auto GPU program params
this.autoParamDataSource.Camera = camera;
// Set autoparams for finite dir light extrusion
this.autoParamDataSource.SetShadowDirLightExtrusionDistance( this.shadowDirLightExtrudeDist );
// sets the current ambient light color for use in auto GPU program params
this.autoParamDataSource.AmbientLight = this.ambientColor;
// Tell rendersystem
this.targetRenderSystem.AmbientLight = this.ambientColor;
// Tell params about render target
this.autoParamDataSource.RenderTarget = viewport.Target;
// set fog params
float fogScale = 1f;
if ( this.fogMode == FogMode.None )
{
fogScale = 0f;
}
this.autoParamDataSource.FogParams = new Vector4( this.fogStart, this.fogEnd, fogScale, 0 );
// set the time in the auto param data source
//autoParamDataSource.Time = ((float)Root.Instance.Timer.Milliseconds) / 1000f;
// Set camera window clipping planes (if any)
if ( this.targetRenderSystem.Capabilities.HasCapability( Capabilities.UserClipPlanes ) )
{
// TODO: Add ClipPlanes to RenderSystem.cs
if ( camera.IsWindowSet )
{
targetRenderSystem.ResetClipPlanes();
IList<Plane> planeList = camera.WindowPlanes;
for ( ushort i = 0; i < 4; ++i )
{
targetRenderSystem.AddClipPlane( planeList[ i ] );
//this.targetRenderSystem.EnableClipPlane( i, true );
//this.targetRenderSystem.SetClipPlane( i, planeList[ i ] );
}
}
// this disables any user-set clipplanes... this should be done manually
//else
//{
// for (ushort i = 0; i < 4; ++i)
// {
// targetRenderSystem.EnableClipPlane(i, false);
// }
//}
}
// Prepare render queue for receiving new objects
this.PrepareRenderQueue();
// Parse the scene and tag visibles
if ( this.findVisibleObjects )
{
if ( this.PreFindVisibleObjects != null )
PreFindVisibleObjects( this, this.illuminationStage, viewport );
this.FindVisibleObjects( camera, this.illuminationStage == IlluminationRenderStage.RenderToTexture );
if ( this.PostFindVisibleObjects != null )
PostFindVisibleObjects( this, this.illuminationStage, viewport );
}
// Add overlays, if viewport deems it
if ( viewport.ShowOverlays && this.illuminationStage != IlluminationRenderStage.RenderToTexture )
{
// Queue overlays for rendering
OverlayManager.Instance.QueueOverlaysForRendering( camera, this.GetRenderQueue(), viewport );
}
// queue overlays and skyboxes for rendering
if ( viewport.ShowSkies && this.findVisibleObjects &&
this.illuminationStage != IlluminationRenderStage.RenderToTexture )
{
this.QueueSkiesForRendering( camera );
}
// begin frame geometry count
this.targetRenderSystem.BeginGeometryCount();
// clear the device if need be
if ( viewport.ClearEveryFrame )
{
this.targetRenderSystem.ClearFrameBuffer( viewport.ClearBuffers, viewport.BackgroundColor );
}
// being a frame of animation
this.targetRenderSystem.BeginFrame();
// use the camera's current scene detail level
this.targetRenderSystem.PolygonMode = camera.PolygonMode;
// Set initial camera state
this.targetRenderSystem.ProjectionMatrix = camera.ProjectionMatrixRS;
this.targetRenderSystem.ViewMatrix = camera.ViewMatrix;
// render all visible objects
this.RenderVisibleObjects();
// end the current frame
this.targetRenderSystem.EndFrame();
// Notify camera of the number of rendered faces
camera.NotifyRenderedFaces( this.targetRenderSystem.FaceCount );
// Notify camera of the number of rendered batches
camera.NotifyRenderedBatches( this.targetRenderSystem.BatchCount );
}
/// <summary>
///
/// </summary>
protected override void SetupView()
{
// setup default viewport layout and camera
this.Camera = SceneManager.CreateCamera( "MainCamera" );
this.Viewport = Window.AddViewport( this.Camera );
this.Camera.AspectRatio = (Real)this.Viewport.ActualWidth / (Real)this.Viewport.ActualHeight;
this.Camera.Near = 5;
this.CameraManager = new SdkCameraManager( this.Camera ); // create a default camera controller
}
/// <summary>
/// Internal method for setting the destination viewport for the next render.
/// </summary>
/// <param name="viewport"></param>
protected virtual void SetViewport( Viewport viewport )
{
this.currentViewport = viewport;
// Set viewport in render system
this.targetRenderSystem.Viewport = viewport;
// Set the active material scheme for this viewport
MaterialManager.Instance.ActiveScheme = viewport.MaterialScheme;
}
/// <summary>
/// Called to ask a camera to render the scene into the given viewport.
/// </summary>
/// <param name="viewport"></param>
/// <param name="showOverlays"></param>
internal void RenderScene( Viewport viewport, bool showOverlays )
{
if ( CameraPreRenderScene != null )
{
CameraPreRenderScene( new CameraEventArgs( this ) );
}
SceneManager.RenderScene( this, viewport, showOverlays );
if ( CameraPostRenderScene != null )
{
CameraPostRenderScene( new CameraEventArgs( this ) );
}
}
protected virtual void OnAfterViewportUpdate(Viewport viewport)
{
if(AfterViewportUpdate != null) {
ViewportUpdateEventArgs e = new ViewportUpdateEventArgs();
e.viewport = viewport;
AfterViewportUpdate(this, e);
}
}
/// <summary>
/// Manual rendering method, for advanced users only.
/// </summary>
/// <remarks>
/// This method allows you to send rendering commands through the pipeline on
/// demand, bypassing any normal world processing. You should only use this if you
/// really know what you're doing; the engine does lots of things for you that you really should
/// let it do. However, there are times where it may be useful to have this manual interface,
/// for example overlaying something on top of the scene.
/// <p/>
/// Because this is an instant rendering method, timing is important. The best
/// time to call it is from a RenderTarget event handler.
/// <p/>
/// Don't call this method a lot, it's designed for rare (1 or 2 times per frame) use.
/// Calling it regularly per frame will cause frame rate drops!
/// </remarks>
/// <param name="op">A RenderOperation object describing the rendering op.</param>
/// <param name="pass">The Pass to use for this render.</param>
/// <param name="vp">Reference to the viewport to render to.</param>
/// <param name="worldMatrix">The transform to apply from object to world space.</param>
/// <param name="viewMatrix">The transform to apply from object to view space.</param>
/// <param name="projMatrix">The transform to apply from view to screen space.</param>
/// <param name="doBeginEndFrame">
/// If true, BeginFrame() and EndFrame() are called, otherwise not.
/// You should leave this as false if you are calling this within the main render loop.
/// </param>
public virtual void ManualRender( RenderOperation op,
Pass pass,
Viewport vp,
Matrix4 worldMatrix,
Matrix4 viewMatrix,
Matrix4 projMatrix,
bool doBeginEndFrame )
{
// configure all necessary parameters
this.targetRenderSystem.Viewport = vp;
this.targetRenderSystem.WorldMatrix = worldMatrix;
this.targetRenderSystem.ViewMatrix = viewMatrix;
this.targetRenderSystem.ProjectionMatrix = projMatrix;
if ( doBeginEndFrame )
{
this.targetRenderSystem.BeginFrame();
}
// set the pass and render the object
this.SetPass( pass );
this.targetRenderSystem.Render( op );
if ( doBeginEndFrame )
{
this.targetRenderSystem.EndFrame();
}
}
public override void SetViewport( Viewport viewport )
{
if ( viewport != activeViewport || viewport.IsUpdated )
{
RenderTarget target = viewport.Target;
SetRenderTarget( target );
activeViewport = viewport;
int x, y, w, h;
w = viewport.ActualWidth;
h = viewport.ActualHeight;
x = viewport.ActualLeft;
y = viewport.ActualTop;
if ( !target.RequiresTextureFlipping )
{
// Convert "upper-left" corner to "lower-left"
y = target.Height - h - y;
}
OpenGL.Viewport( x, y, w, h );
GLESConfig.GlCheckError( this );
// Configure the viewport clipping
OpenGL.Scissor( x, y, w, h );
GLESConfig.GlCheckError( this );
viewport.IsUpdated = false;
}
}
/// <summary>
/// Internal method for preparing shadow textures ready for use in a regular render
/// </summary>
/// <param name="camera"></param>
/// <param name="viewPort"></param>
protected internal virtual void PrepareShadowTextures( Camera camera, Viewport viewPort )
{
// Set the illumination stage, prevents recursive calls
IlluminationRenderStage savedStage = this.illuminationStage;
this.illuminationStage = IlluminationRenderStage.RenderToTexture;
// Determine far shadow distance
float shadowDist = this.shadowFarDistance;
if ( shadowDist == 0.0f )
{
// need a shadow distance, make one up
shadowDist = camera.Near * 300;
}
// set fogging to hide the shadow edge
float shadowOffset = shadowDist * this.shadowTextureOffset;
// Precalculate fading info
float shadowEnd = shadowDist + shadowOffset;
float fadeStart = shadowEnd * this.shadowTextureFadeStart;
float fadeEnd = shadowEnd * this.shadowTextureFadeEnd;
// Additive lighting should not use fogging, since it will overbrighten; use border clamp
if ( !this.IsShadowTechniqueAdditive )
{
this.shadowReceiverPass.SetFog( true,
FogMode.Linear,
ColorEx.White,
0,
fadeStart,
fadeEnd );
// if we have a custom receiver material, then give it the fog params too
if ( this.shadowTextureCustomReceiverPass != null )
{
this.shadowTextureCustomReceiverPass.SetFog( true,
FogMode.Linear,
ColorEx.White,
0,
fadeStart,
fadeEnd );
}
}
else
{
// disable fogging explicitly
this.shadowReceiverPass.SetFog( true, FogMode.None );
// if we have a custom receiver material, then give it the fog params too
if ( this.shadowTextureCustomReceiverPass != null )
{
this.shadowTextureCustomReceiverPass.SetFog( true, FogMode.None );
}
}
// Iterate over the lights we've found, max out at the limit of light textures
int sti = 0;
foreach ( Light light in this.lightsAffectingFrustum )
{
// Check limit reached
if ( sti == this.shadowTextures.Count )
break;
// Skip non-shadowing lights
if ( !light.CastShadows )
{
continue;
}
Texture shadowTex = this.shadowTextures[ sti ];
RenderTarget shadowRTT = shadowTex.GetBuffer().GetRenderTarget();
Viewport shadowView = shadowRTT.GetViewport( 0 );
Camera texCam = this.shadowTextureCameras[ sti ];
// rebind camera, incase another SM in use which has switched to its cam
shadowView.Camera = texCam;
// Associate main view camera as LOD camera
texCam.LodCamera = camera;
//Vector3 dir;
// set base
if ( light.Type == LightType.Point )
texCam.Direction = light.DerivedDirection;
if ( light.Type == LightType.Directional )
texCam.Position = light.DerivedPosition;
// Use the material scheme of the main viewport
// This is required to pick up the correct shadow_caster_material and similar properties.
shadowView.MaterialScheme = viewPort.MaterialScheme;
if ( light.CustomShadowCameraSetup == null )
{
_defaultShadowCameraSetup.GetShadowCamera( this, camera, viewPort, light, texCam, sti );
}
else
{
light.CustomShadowCameraSetup.GetShadowCamera( this, camera, viewPort, light, texCam, sti );
}
shadowView.BackgroundColor = ColorEx.White;
// Fire shadow caster update, callee can alter camera settings
// fireShadowTexturesPreCaster(light, texCam);
// Update target
shadowRTT.Update();
++sti;
}
// Set the illumination stage, prevents recursive calls
this.illuminationStage = savedStage;
//fireShadowTexturesUpdated( std::min(mLightsAffectingFrustum.size(), mShadowTextures.size()));
}
public void SetViewport( Viewport viewport )
{
vpWidth = viewport.ActualWidth;
vpHeight = viewport.ActualHeight;
}
protected virtual void CreateViewports()
{
Debug.Assert(window != null, "Attempting to use a null RenderWindow.");
// create a new viewport and set it's background color
viewport = window.AddViewport(camera, 0, 0, 1.0f, 1.0f, 100);
viewport.BackgroundColor = ColorEx.Black;
}
protected override void CreateViewports()
{
base.CreateViewports();
viewport2 = window.AddViewport(camera2, 0.6f, 0, 0.4f, 0.4f, 102);
viewport2.OverlaysEnabled = false;
viewport2.BackgroundColor = ColorEx.Blue;
}
