protected override void Initialise()
{
Camera3D camera = new Xen.Camera.FirstPersonControlledCamera3D(this.UpdateManager, Vector3.Zero,true);
//create the draw target.
drawToScreen = new DrawTargetScreen(camera);
drawToScreen.ClearBuffer.ClearColour = Color.CornflowerBlue;
//NEW CODE
//create a BatchModel, this class stores the ModelData and will draw BatchModelInstances
this.batchModel = new BatchModel();
//this.batchModel.ShaderProvider = new SimpleShaderProvider<Tutorial_16.Shader.Tutorial16>();
//NEW CODE
//create a large number of actors (1600)
for (float x = -20; x < 20; x++)
for (float y = -20; y < 20; y++)
{
drawToScreen.Add(new Actor(this.batchModel, new Vector3(x * 5, y * 5, -5)));
}
//this is the most important bit...
//always add the BatchModel itself to the draw target,
//this should be added *after* all BatchModelInstances have been added
//Note: each time a BatchModelInstance is drawn, it will store it's world matrix in the BatchModel
//If the BatchModel is not drawn, the buffer storing these matrices will not be emptied, and will
//eventually throw an OutOfMemoryException exception.
this.drawToScreen.Add(batchModel);
statistics = new Xen.Ex.Graphics2D.Statistics.DrawStatisticsDisplay(this.UpdateManager);
this.drawToScreen.Add(statistics);
}
protected override void Initialise()
{
//initialize the physic stuff!
physics = new PhysicsSystem();
physics.CollisionSystem = new CollisionSystemSAP();
//all draw targets need a default camera.
//create a 3D camera
var camera = new Xen.Camera.FirstPersonControlledCamera3D(this.UpdateManager, Vector3.Zero, false);
//don't allow the camera to move too fast
camera.MovementSensitivity *= 0.1f;
camera.LookAt(new Vector3(0.0f, 100.0f, 0.0f), new Vector3(640.0f, 300.0f, 640.0f), Vector3.Up);
console = new Console(400, 200);
//create the draw target.
this.drawToScreen = new DrawTargetScreen(camera);
//Set the screen clear colour to blue
//(Draw targets have a built in ClearBuffer object)
this.drawToScreen.ClearBuffer.ClearColour = Color.CornflowerBlue;
//create new actor ("tiny")
actor = new Actor(this.Content, "tiny_4anim", Vector3.Zero, 1f);
skydome = new Skydome(Content, new Vector3(500,100,700), 1000f);
//at runtime, pressing 'F12' will toggle the overlay (or holding both thumbsticks on x360)
this.statisticsOverlay = new Xen.Ex.Graphics2D.Statistics.DrawStatisticsDisplay(this.UpdateManager);
TerrainDrawer terrain = new TerrainDrawer(this.Content, Vector3.Zero);
drawToScreen.Add(terrain);
drawToScreen.Add(skydome);
//add statistics to screen
drawToScreen.Add(statisticsOverlay);
//add console to screen
drawToScreen.Add(console.getTextElementRect());
//add actor to the screen
drawToScreen.Add(actor);
}
protected override void Initialise()
{
//draw targets usually need a camera.
var camera = new Xen.Camera.FirstPersonControlledCamera3D(this.UpdateManager, Vector3.Zero, false);
//don't allow the camera to move too fast
camera.MovementSensitivity *= 0.1f;
camera.LookAt(new Vector3(0,3,0), new Vector3(1, 5, 10), new Vector3(0, 1, 0));
//create the draw target.
drawToScreen = new DrawTargetScreen(camera);
drawToScreen.ClearBuffer.ClearColour = new Color(45,50,60);
//create the fire and smoke particle system
this.fireParticleSystem = new ParticleSystem(this.UpdateManager);
this.smokeParticleSystem = new ParticleSystem(this.UpdateManager);
//IMPORTANT
//The following flags are FALSE by default.
//For looping effects, such as the fire and smoke, it's highly
//recommended to enable this flag. Otherwise, while the effect
//is offscreen, the particle system will continue to process.
this.fireParticleSystem.PauseUpdatingWhileCulled = true;
this.smokeParticleSystem.PauseUpdatingWhileCulled = true;
this.drawSorted = new Xen.Ex.Scene.DepthDrawSorter(Xen.Ex.Scene.DepthSortMode.BackToFront);
this.drawUnsorted = new DrawList();
var fireDrawer = new Xen.Ex.Graphics.Display.VelocityBillboardParticles3D(this.fireParticleSystem, true);
var smokeDrawer = new Xen.Ex.Graphics.Display.BillboardParticles3D(this.smokeParticleSystem);
for (int i = 0; i < 10; i++)
{
Vector3 position = new Vector3((float)Math.Cos(i * Math.PI / 5.0) * 6.0f, 0, (float)Math.Sin(i * Math.PI / 5.0) * 6.0f);
CullableParticleWrapper fireEffect, smokeEffect;
fireEffect = new CullableParticleWrapper(fireDrawer, position, new Vector3(0, 2, 0), 4);
smokeEffect = new CullableParticleWrapper(smokeDrawer, position, new Vector3(0, 6, 0), 5);
this.drawSorted.Add(fireEffect);
this.drawSorted.Add(smokeEffect);
this.drawUnsorted.Add(fireEffect);
this.drawUnsorted.Add(smokeEffect);
var light = new GroundLightDisk(position);
this.drawSorted.Add(light);
this.drawUnsorted.Add(light);
}
//setup the burst effect
this.burstParticleSystem = new ParticleSystem(this.UpdateManager);
//for this case, PauseUpdatingWhileCulled is not set to true.
//The particle emitting is culled when offscreen. If set to true,
//Any particles left offscreen could 'pause', when they naturally
//wouldn't be emitted anyway.
//(The particle system will use very few resources when it has no
//active particles)
this.burstSources = new BurstSource[20];
Random rand = new Random();
for (int i = 0; i < this.burstSources.Length; i++)
{
//create the bursts out in the distance
Vector3 position = new Vector3((float)i * 5.0f - this.burstSources.Length * 2.5f, 0, -20);
float radius = 10; // with a decent radius
//give them a random starting time
this.burstSources[i] = new BurstSource(position, radius, (float)rand.NextDouble() * 2);
this.drawSorted.Add(this.burstSources[i]);
this.drawUnsorted.Add(this.burstSources[i]);
}
//the bursts need to be drawn as a group..
var burstDrawer = new Xen.Ex.Graphics.Display.VelocityBillboardParticles3D(this.burstParticleSystem,false,0.5f);
this.drawSorted.Add(burstDrawer);
this.drawUnsorted.Add(burstDrawer);
//Use all the burst sources to cull the drawer (may not be ideal if there were many sources...)
//Use the particle drawer CullProxy to do it
burstDrawer.CullProxy = new BurstCullProxy(this.burstSources);
//add a ground plane to show the horizon
drawToScreen.Add(new Tutorial_22.DarkGroundPlane(new Vector4(0.125f,0.15f,0.135f,1)));
//add the sorted and unsorted lists
drawToScreen.Add(drawSorted);
drawToScreen.Add(drawUnsorted);
//finally, create a CullTestVisualizer, which will visually show the cull tests performed
cullTestVisualizer = new Xen.Ex.Scene.CullTestVisualizer();
//the visualizer is added as a draw modifier
this.drawToScreen.AddModifier(cullTestVisualizer);
//add help text
this.text = new TextElement();
this.text.VerticalAlignment = VerticalAlignment.Bottom;
this.text.Position = new Vector2(50, 100);
drawToScreen.Add(this.text);
//add draw stats
stats = new Xen.Ex.Graphics2D.Statistics.DrawStatisticsDisplay(this.UpdateManager);
drawToScreen.Add(stats);
}
protected override void Initialise()
{
//setup the view camera first
//--------------------------------------
viewCamera = new Xen.Camera.FirstPersonControlledCamera3D(this.UpdateManager);
viewCamera.Projection.FieldOfView *= 0.65f;
viewCamera.MovementSensitivity *= 0.05f;
viewCamera.LookAt(new Vector3(-3, 4, 2), new Vector3(6, 6, 2), new Vector3(0, 1, 0));
viewCamera.Projection.NearClip = 0.1f;
//shadow map setup:
//--------------------------------------
const float shadowArea = 4;
const int shadowMapResolution = 1024;
//setup the shadow map rendering camera
shadowCamera = new Camera3D();
//setup the shadow map projection to roughly cover the character
shadowCamera.Projection.Orthographic = true;
shadowCamera.Projection.NearClip = shadowArea * 2;
shadowCamera.Projection.FarClip = -shadowArea * 2;
shadowCamera.Projection.Region = new Vector4(1, -1.8f, -1, 0.2f) * shadowArea;
//setup the shadow map draw target
//create the shadow map
shadowMap = new DrawTargetTexture2D(shadowCamera, shadowMapResolution, shadowMapResolution, SurfaceFormat.HalfSingle, DepthFormat.Depth24);
shadowMap.ClearBuffer.ClearColour = Color.White;
//setup the shadow map drawer..
shadowDrawer = new Tutorial_25.ShadowMapDrawer(null, new Tutorial_25.ShadowOutputShaderProvider());
this.shadowMap.Add(shadowDrawer);
//create the main draw targets.
//--------------------------------------
drawToScreen = new DrawTargetScreen(new Camera2D());
drawToScreen.ClearBuffer.ClearColourEnabled = false;
drawToRenderTarget = new DrawTargetTexture2D(viewCamera, this.WindowWidth, this.WindowHeight, SurfaceFormat.Color, DepthFormat.Depth24Stencil8, false, PreferredMultiSampleLevel.FourSamples, RenderTargetUsage.PlatformContents);
drawToRenderTarget.ClearBuffer.ClearColourEnabled = false;
//setup the bloom draw targets
//--------------------------------------
//scale to reduce the size of the bloom target, compared to main render target
const int bloomDownsample = 8; //eight times smaller
bloomRenderTarget = new DrawTargetTexture2D(new Camera2D(), Math.Max(1, drawToRenderTarget.Width / bloomDownsample), Math.Max(1, drawToRenderTarget.Height / bloomDownsample), SurfaceFormat.Color, DepthFormat.None);
bloomRenderTarget.ClearBuffer.ClearColourEnabled = false;
bloomIntermediateRenderTarget = null;
//the bloom intermediate target is not needed on the xbox, as the full bloom target fits in EDRAM
bloomIntermediateRenderTarget = new DrawTargetTexture2D(viewCamera, bloomRenderTarget.Width, bloomRenderTarget.Height, SurfaceFormat.Color, DepthFormat.None);
bloomIntermediateRenderTarget.ClearBuffer.ClearColourEnabled = false;
//setup the blur filter, with a large 31 sample radius.
bloomBlurPass = new Xen.Ex.Filters.BlurFilter(Xen.Ex.Filters.BlurFilterFormat.ThirtyOneSampleBlur_FilteredTextureFormat, 1.0f, bloomRenderTarget, bloomIntermediateRenderTarget);
//setup the character model
this.model = new ModelInstance(); //(the model is setup in LoadContent)
this.modelRotation = new DrawRotated(model);
this.modelRotation.RotationAngle = 3;
//add the model to be drawn
drawToRenderTarget.Add(modelRotation);
//setup the shaders
this.characterRenderShader = new Shaders.Character();
//setup the output and bloom shaders
outputShader = new Shaders.RgbmDecode();
drawToScreen.Add(new ShaderElement(outputShader, new Vector2(1, 1), true));
bloomPassShader = new Shaders.RgbmDecodeBloomPass();
bloomRenderTarget.Add(new ShaderElement(bloomPassShader, new Vector2(1, 1), true));
//add a background to be drawn
drawToRenderTarget.Add(new BackgroundDrawer());
//setup the debug image displays
//--------------------------------------
this.rgmbTextureAlphaShader = new Shaders.AlphaWrite();
this.bloomTextureDisplay = new TexturedElement(this.bloomRenderTarget, new Vector2(0.2f, 0.2f), true);
this.rgbmTextureDisplay = new TexturedElement(this.drawToRenderTarget, new Vector2(0.2f, 0.2f), true);
this.rgbmTextureAlphaDisplay = new ShaderElement(this.rgmbTextureAlphaShader, new Vector2(0.2f, 0.2f), true);
this.rgbmTextureAlphaDisplay.Position = new Vector2(0.7f, 0.2f);
this.rgbmTextureDisplay.Position = new Vector2(0.7f, 0.4f);
this.bloomTextureDisplay.Position = new Vector2(0.7f, 0.6f);
this.drawToScreen.Add(this.rgbmTextureDisplay);
this.drawToScreen.Add(this.rgbmTextureAlphaDisplay);
this.drawToScreen.Add(this.bloomTextureDisplay);
//setup the render config
this.configEditor = new RenderConfigEditor(this.Content);
this.drawToScreen.Add(configEditor);
this.UpdateManager.Add(configEditor);
//add a statistics overlay.
drawStats = new Xen.Ex.Graphics2D.Statistics.DrawStatisticsDisplay(this.UpdateManager);
drawToScreen.Add(drawStats);
}
protected override void Initialise()
{
//create the camera
Xen.Camera.FirstPersonControlledCamera3D camera =
new Xen.Camera.FirstPersonControlledCamera3D(this.UpdateManager,Vector3.Zero);
camera.Projection.FarClip *= 10;
this.camera = camera;
//create the draw target.
drawToScreen = new DrawTargetScreen(camera);
//25,000 instances
const int instanceCount = 25000;
const float areaRadius = 500;
//setup the two draw lists
this.staticDrawList = new ToggleDrawList();
this.dynamicDrawList = new ToggleDrawList();
//geometry that will be drawn
var geometry = new Xen.Ex.Geometry.Sphere(Vector3.One, 2, true, false, false);
//create the mesh instance drawer, (but add it to the screen later)
var meshDrawer = new DynamicInstancedMeshGeometry(instanceCount, geometry);
var staticMeshDrawer = new StaticInstancedMeshGeometry(instanceCount, geometry);
//the dynamicly culled instances are added to a StaticBinaryTreePartition, which
//sorts the items into a binary tree, for more efficient culling.
//This class assumes it's children do not move (ie they are static)
var sceneTree = new Xen.Ex.Scene.StaticBinaryTreePartition();
//add it to the dynamic list
dynamicDrawList.Children.Add(sceneTree);
//create the instances
Random random = new Random();
for (int i = 0; i < instanceCount; i++)
{
//create a random position in a sphere
Vector3 position = new Vector3( (float)(random.NextDouble()-.5),
(float)(random.NextDouble()-.5),
(float)(random.NextDouble()-.5));
position.Normalize();
position *= (float)Math.Sqrt(random.NextDouble()) * areaRadius;
//create the instance
var instance = new DynamicMeshInstance(meshDrawer, position);
//add the instance to the StaticBinaryTreePartition
sceneTree.Add(instance);
//add the details of this instance to the static drawer
staticMeshDrawer.AddStaticInstance(Matrix.CreateTranslation(position), 1);
}
//now add the drawer (instances will be drawn by the StaticBinaryPartition, before the drawer)
dynamicDrawList.Children.Add(meshDrawer);
//now add the static mesh drawer
staticDrawList.Children.Add(staticMeshDrawer);
//finally, add them both to the screen
this.drawToScreen.Add(dynamicDrawList);
this.drawToScreen.Add(staticDrawList);
//Note that if the StaticBinaryTreePartition was not used, then
//in each frame, every single instance would perform a CullTest to the screen
//CullTests, despite their simplicity can be very costly in large numbers.
//The StaticBinaryTreePartition will usually perform a maximum number of CullTests
//that is approximately ~30% the number of children. (in this case, ~8000 tests)
//At it's best, when it's entirely off or on screen, it will perform only 1 or 2 CullTests.
//The number of cull tests performed will be displayed in debug builds of this tutorial:
//add some statusText to display on screen to show the stats
statusText = new TextElement();
statusText.Position = new Vector2(50, -50);
drawToScreen.Add(statusText);
//add the cull test visualiser
this.cullVis = new Xen.Ex.Scene.CullTestVisualizer();
drawToScreen.AddModifier(cullVis);
}
