public override void ChangedWorldConfig(GraphicsDevice gd) { base.ChangedWorldConfig(gd); PPXDepthEngine.SSAA = (WorldConfig.Current.AA ? 2 : 1); PPXDepthEngine.InitScreenTargets(); UseBackbuffer = WorldConfig.Current.AA; }
public void RenderCache(List <_2DDrawBuffer> cache) { var effect = this.Effect; Device.BlendState = BlendState.AlphaBlend; // set the only parameter this effect takes. var frontDir = FrontDirForRot(((FSO.LotView.Utils.WorldCamera)WorldCamera).Rotation); effect.Parameters["dirToFront"].SetValue(frontDir); effect.Parameters["offToBack"].SetValue(BackOffForRot(((FSO.LotView.Utils.WorldCamera)WorldCamera).Rotation)); //frontDir /= 3; //WorldContent._2DWorldBatchEffect.Parameters["LightOffset"].SetValue(new Vector2(frontDir.X / (6 * 75), frontDir.Z / (6 * 75))); var mat = this.WorldCamera.View * this.WorldCamera.Projection; effect.Parameters["worldViewProjection"].SetValue(mat); effect.Parameters["iWVP"].SetValue(Matrix.Invert(mat)); //effect.Parameters["depthOutMode"].SetValue(OutputDepth && (!FSOEnvironment.UseMRT)); foreach (var buffer in cache) { PPXDepthEngine.RenderPPXDepth(effect, false, (depth) => { foreach (var group in buffer.Groups) { RenderDrawGroup(group); } }); } }
public override bool NextPass() { if (Pass == 0) { Batch.Pause(); PPXDepthEngine.SetPPXTarget(Target, DepthTarget, true); Batch.OutputDepth = true; //depth surface always uses depth techniques Batch.Resume(); Pass++; return(true); } return(false); /*else if (Pass == 1) * { * if (FSOEnvironment.UseMRT) return false; * else * { * Batch.Pause(); * GD.SetRenderTarget(DepthTarget); * Batch.OutputDepth = true; * Batch.Resume(); * Pass++; * return true; * } * } * return false;*/ }
public void RenderCache(List <_2DDrawBuffer> cache) { var effect = this.Effect; Device.BlendState = BlendState.AlphaBlend; // set the only parameter this effect takes. effect.Parameters["dirToFront"].SetValue(FrontDirForRot(((FSO.LotView.Utils.WorldCamera)WorldCamera).Rotation)); effect.Parameters["offToBack"].SetValue(BackOffForRot(((FSO.LotView.Utils.WorldCamera)WorldCamera).Rotation)); effect.Parameters["viewProjection"].SetValue(this.View * this.Projection); var mat = this.WorldCamera.View * this.WorldCamera.Projection; effect.Parameters["worldViewProjection"].SetValue(this.WorldCamera.View * this.WorldCamera.Projection); effect.Parameters["ambientLight"].SetValue(AmbientLight); //effect.Parameters["depthOutMode"].SetValue(OutputDepth && (!FSOEnvironment.UseMRT)); foreach (var buffer in cache) { PPXDepthEngine.RenderPPXDepth(effect, false, (depth) => { foreach (var group in buffer.Groups) { RenderDrawGroup(group); } }); } }
public virtual void Dispose() { Batch.Pause(); PPXDepthEngine.SetPPXTarget(null, null, false); ExtractPixelTexture(); Batch.Resume(); }
/// <summary> /// Setup anything that needs a GraphicsDevice /// </summary> /// <param name="layer"></param> public override void Initialize(_3DLayer layer) { base.Initialize(layer); /** * Setup world state, this object acts as a facade * to world objects as well as providing various * state settings for the world and helper functions */ State = new WorldState(layer.Device, layer.Device.Viewport.Width, layer.Device.Viewport.Height, this); State._2D = new _2DWorldBatch(layer.Device, _2DWorldBatch.NUM_2D_BUFFERS, _2DWorldBatch.BUFFER_SURFACE_FORMATS, _2DWorldBatch.FORMAT_ALWAYS_DEPTHSTENCIL, _2DWorldBatch.SCROLL_BUFFER); Static = new WorldStatic(this); State.OutsidePx = new Texture2D(layer.Device, 1, 1); ChangedWorldConfig(layer.Device); PPXDepthEngine.InitGD(layer.Device); PPXDepthEngine.InitScreenTargets(); base.Camera = State.Camera; HasInitGPU = true; HasInit = HasInitGPU & HasInitBlueprint; GraphicsModeControl.ModeChanged += SetGraphicsMode; }
/// <summary> /// Setup anything that needs a GraphicsDevice /// </summary> /// <param name="layer"></param> public override void Initialize(_3DLayer layer) { base.Initialize(layer); /** * Setup world state, this object acts as a facade * to world objects as well as providing various * state settings for the world and helper functions */ State = new WorldState(layer.Device, layer.Device.Viewport.Width / FSOEnvironment.DPIScaleFactor, layer.Device.Viewport.Height / FSOEnvironment.DPIScaleFactor, this); State._3D = new FSO.LotView.Utils._3DWorldBatch(State); State._2D = new FSO.LotView.Utils._2DWorldBatch(layer.Device, World2D.NUM_2D_BUFFERS, World2D.BUFFER_SURFACE_FORMATS, World2D.FORMAT_ALWAYS_DEPTHSTENCIL, World2D.SCROLL_BUFFER); ChangedWorldConfig(layer.Device); PPXDepthEngine.InitGD(layer.Device); PPXDepthEngine.InitScreenTargets(); base.Camera = State.Camera; HasInitGPU = true; HasInit = HasInitGPU & HasInitBlueprint; }
public void ChangeAAMode(GraphicsDevice gd) { var lastm = PPXDepthEngine.MSAA; var lasts = PPXDepthEngine.SSAA; PPXDepthEngine.SSAAFunc = SSAADownsample.Draw; switch (WorldConfig.Current.AA) { case 0: PPXDepthEngine.MSAA = 0; PPXDepthEngine.SSAA = 1; break; case 1: PPXDepthEngine.MSAA = 4; PPXDepthEngine.SSAA = 1; break; case 2: PPXDepthEngine.MSAA = 0; PPXDepthEngine.SSAA = 2; break; } if (PPXDepthEngine.SSAA > 1 && State.CameraMode < CameraRenderMode._3D) { PPXDepthEngine.MSAA = 8; PPXDepthEngine.SSAA = 1; } if (lastm != PPXDepthEngine.MSAA || lasts != PPXDepthEngine.SSAA) { PPXDepthEngine.InitScreenTargets(); } }
public void DrawImmediate(_2DStandaloneSprite sprite) { var effect = this.Effect; if (!FSOEnvironment.DirectX) { Device.Indices = null; //monogame why Device.Indices = SpriteIndices; } PPXDepthEngine.RenderPPXDepth(effect, false, (depth) => { effect.pixelTexture = sprite.Pixel; if (sprite.Depth != null) { effect.depthTexture = sprite.Depth; } if (sprite.Mask != null) { effect.maskTexture = sprite.Mask; } EffectPassCollection passes = effect.CurrentTechnique.Passes; EffectPass pass = passes[Math.Min(passes.Count - 1, WorldConfig.Current.DirPassOffset)]; pass.Apply(); if (sprite.GPUVertices != null) { Device.SetVertexBuffer(sprite.GPUVertices); Device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, 2); } }); }
/// <summary> /// Ends rendering, should always be called after DrawMesh()! /// </summary> public void End() { if (Sprites.Count == 0) { return; } //Device.RasterizerState.CullMode = CullMode.CullCounterClockwiseFace; var character = Sprites.Where(x => x.Effect == _3DSpriteEffect.CHARACTER).ToList(); var pass = WorldConfig.Current.PassOffset * 2; PPXDepthEngine.RenderPPXDepth(Avatar.Effect, true, (depth) => { RenderSpriteList(character, Avatar.Effect, Avatar.Effect.Techniques[OBJIDMode ? 1 : pass]); }); /* * ApplyCamera(Effect); * Effect.World = world; * Effect.TextureEnabled = true; * Effect.Texture = binding.Texture; * Effect.CommitChanges(); * * Effect.Begin(); * foreach (var pass in Effect.CurrentTechnique.Passes) * { * pass.Begin(); * binding.Mesh.Draw(Device); * pass.End(); * } * Effect.End();*/ }
public override void PreDraw(GraphicsDevice device) { if (HasInit == false) { return; } var boundfactor = 0.5f; boundfactor *= Blueprint?.Width ?? 64; var off = 0.5f * (Blueprint?.Width ?? 64); var tile = State.CenterTile; tile = new Vector2(Math.Min(boundfactor + off, Math.Max(off - boundfactor, tile.X)), Math.Min(boundfactor + off, Math.Max(off - boundfactor, tile.Y))); if (tile != State.CenterTile) { State.CenterTile = tile; } State._2D.PreciseZoom = State.PreciseZoom; State.OutsideColor = Blueprint.OutsideColor; FSO.Common.Rendering.Framework.GameScreen.ClearColor = new Color(State.OutsideColor.ToVector4()); //new Color(0x72, 0x72, 0x72).ToVector4() * var frustrum = new BoundingFrustum(State.Camera.View * State.Camera.Projection); foreach (var sub in Blueprint.SubWorlds) { var bounds = ((SubWorldComponentRC)sub).Bounds; if (bounds.Intersects(frustrum)) { sub.PreDraw(device, State); } } State.UpdateInterpolation(); if (Blueprint != null) { foreach (var ent in Blueprint.Objects) { ent.Update(null, State); } } //For all the tiles in the dirty list, re-render them State.PrepareLighting(); _2DWorld.PreDraw(device, State); device.SetRenderTarget(null); State._3D.Begin(device); _3DWorld.PreDraw(device, State); State._3D.End(); if (UseBackbuffer) { PPXDepthEngine.SetPPXTarget(null, null, true, State.OutsideColor); InternalDraw(device); device.SetRenderTarget(null); } return; }
/// <summary> /// Processes the accumulated draw commands and paints the screen. Optionally outputs to a vertex cache. /// </summary> public void End(List <_2DDrawBuffer> cache, bool outputDepth) { if (WorldCamera == null) { return; } var effect = this.Effect; if (cache == null) { Device.BlendState = BlendState.AlphaBlend; // set the only parameter this effect takes. var frontDir = FrontDirForRot(((FSO.LotView.Utils.WorldCamera)WorldCamera).Rotation); effect.Parameters["dirToFront"].SetValue(frontDir); effect.Parameters["offToBack"].SetValue(BackOffForRot(((FSO.LotView.Utils.WorldCamera)WorldCamera).Rotation)); //frontDir /= 3; //WorldContent._2DWorldBatchEffect.Parameters["LightOffset"].SetValue(new Vector2(frontDir.X / (6 * 75), frontDir.Z / (6 * 75))); var mat = this.WorldCamera.View * this.WorldCamera.Projection; effect.Parameters["worldViewProjection"].SetValue(mat); var inv = Matrix.Invert(mat); effect.Parameters["iWVP"].SetValue(inv); effect.Parameters["rotProjection"].SetValue(((WorldCamera)this.WorldCamera).GetRotationMatrix() * this.WorldCamera.Projection); //effect.Parameters["depthOutMode"].SetValue(outputDepth && (!FSOEnvironment.UseMRT)); } if (Sprites.Count == 0) { return; } int i = 0; foreach (var sprites in Sprites) { if (cache != null) { if (i >= cache.Count) { cache.Add(new _2DDrawBuffer()); } EndDrawSprites(sprites, cache[i].Groups, outputDepth); } else { var temp = new _2DDrawBuffer(); EndDrawSprites(sprites, temp.Groups, OutputDepth); PPXDepthEngine.RenderPPXDepth(effect, false, (depth) => { RenderCache(new List <_2DDrawBuffer> { temp }); //EndDrawSprites(sprites, null, OutputDepth); }); temp.Dispose(); } i++; } }
public override void Dispose() { Batch.Pause(); Batch.OutputDepth = false; PPXDepthEngine.SetPPXTarget(null, null, false); //need to unbind both before we can extract their textures. ExtractPixelTexture(); ExtractDepthTexture(); Batch.Resume(); }
public void GameResized() { PPXDepthEngine.InitScreenTargets(); var newSize = PPXDepthEngine.GetWidthHeight(); State._2D.GenBuffers(newSize.X, newSize.Y); State.SetDimensions(newSize.ToVector2()); Blueprint?.Damage.Add(new BlueprintDamage(BlueprintDamageType.ZOOM)); }
public void ResizeBuffer(int bufferIndex, int width, int height) { var buffer = Buffers[bufferIndex]; if (buffer.Width != width || buffer.Height != height) { Buffers[bufferIndex] = PPXDepthEngine.CreateRenderTarget(Device, 1, 0, buffer.Format, width, height, buffer.DepthStencilFormat); buffer.Dispose(); } }
public void GameResized() { PPXDepthEngine.InitScreenTargets(); var newSize = PPXDepthEngine.GetWidthHeight(); var ssaa = new Point(newSize.X / PPXDepthEngine.SSAA, newSize.Y / PPXDepthEngine.SSAA); State._2D.GenBuffers(ssaa.X, ssaa.Y); State.SetDimensions(ssaa.ToVector2()); Blueprint?.Changes?.SetFlag(BlueprintGlobalChanges.ZOOM); }
public override void Draw(GraphicsDevice device, WorldState world) { device.RasterizerState = RasterizerState.CullNone; if (ShapeDirty) { RegenRoof(device); ShapeDirty = false; StyleDirty = false; } else if (StyleDirty) { RemeshRoof(device); StyleDirty = false; } for (int i = 0; i < Drawgroups.Length; i++) { if (i > world.Level - 1) { return; } Effect.Parameters["Level"].SetValue((float)i + 1.0001f); if (Drawgroups[i] != null) { var dg = Drawgroups[i]; if (dg.NumPrimitives == 0) { continue; } PPXDepthEngine.RenderPPXDepth(Effect, true, (depthMode) => { world._3D.ApplyCamera(Effect); Effect.Parameters["World"].SetValue(Matrix.Identity); Effect.Parameters["DiffuseColor"].SetValue(new Vector4(world.OutsideColor.R / 255f, world.OutsideColor.G / 255f, world.OutsideColor.B / 255f, 1.0f)); Effect.Parameters["UseTexture"].SetValue(true); Effect.Parameters["BaseTex"].SetValue(Texture); Effect.Parameters["Alpha"].SetValue(1f); Effect.Parameters["IgnoreColor"].SetValue(false); Effect.Parameters["TexOffset"].SetValue(Vector2.Zero); Effect.Parameters["TexMatrix"].SetValue(new Vector4(1, 0, 0, 1)); device.SetVertexBuffer(dg.VertexBuffer); device.Indices = dg.IndexBuffer; Effect.CurrentTechnique = Effect.Techniques["DrawBase"]; var pass = Effect.CurrentTechnique.Passes[(Common.FSOEnvironment.Enable3D && (world as RC.WorldStateRC)?.Use2DCam == false)?2:WorldConfig.Current.PassOffset]; pass.Apply(); device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, dg.NumPrimitives); }); } } }
public virtual bool NextPass() { if (Pass == 0) { Batch.Pause(); PPXDepthEngine.SetPPXTarget(Target, null, true); Batch.Resume(); Pass++; return(true); } return(false); }
public override Vector2 GetScreenPos(WorldState world) { var projected = Vector4.Transform(new Vector4(0, 0, 0, 1f), this.World * world.Camera.View * world.Camera.Projection); if (world.Camera is WorldCamera) { projected.Z = 1; } var res1 = new Vector2(projected.X / projected.Z, -projected.Y / projected.Z); var size = PPXDepthEngine.GetWidthHeight(); return(new Vector2((size.X / PPXDepthEngine.SSAA) * 0.5f * (res1.X + 1f), (size.Y / PPXDepthEngine.SSAA) * 0.5f * (res1.Y + 1f))); //world.WorldSpace.GetScreenFromTile(transhead) + world.WorldSpace.GetScreenOffset() + PosCenterOffsets[(int)world.Zoom - 1]; }
public override Vector2 GetScreenPos(WorldState world) { var headpos = Avatar.Skeleton.GetBone("HEAD").AbsolutePosition; var projected = Vector4.Transform(new Vector4(headpos, 1), Matrix.CreateRotationY((float)(Math.PI - RadianDirection)) * this.World * world.View * world.Projection); if (world.CameraMode < CameraRenderMode._3D) { projected.Z = 1; } var res1 = new Vector2(projected.X / projected.Z, -projected.Y / projected.Z); var size = PPXDepthEngine.GetWidthHeight(); return(new Vector2((size.X / PPXDepthEngine.SSAA) * 0.5f * (res1.X + 1f), (size.Y / PPXDepthEngine.SSAA) * 0.5f * (res1.Y + 1f))); //world.WorldSpace.GetScreenFromTile(transhead) + world.WorldSpace.GetScreenOffset() + PosCenterOffsets[(int)world.Zoom - 1]; }
public override void Draw(GraphicsDevice device, WorldState world) { if (ShapeDirty) { RegenRoof(device); ShapeDirty = false; StyleDirty = false; } else if (StyleDirty) { RemeshRoof(device); StyleDirty = false; } for (int i = 0; i < Drawgroups.Length; i++) { if (i > world.Level - 1) { return; } Effect.Parameters["Level"].SetValue((float)i + 1); if (Drawgroups[i] != null) { var dg = Drawgroups[i]; if (dg.NumPrimitives == 0) { continue; } PPXDepthEngine.RenderPPXDepth(Effect, true, (depthMode) => { world._3D.ApplyCamera(Effect); Effect.Parameters["World"].SetValue(Matrix.Identity); Effect.Parameters["DiffuseColor"].SetValue(new Vector4(world.OutsideColor.R / 255f, world.OutsideColor.G / 255f, world.OutsideColor.B / 255f, 1.0f)); Effect.Parameters["UseTexture"].SetValue(true); Effect.Parameters["BaseTex"].SetValue(Texture); device.SetVertexBuffer(dg.VertexBuffer); device.Indices = dg.IndexBuffer; Effect.CurrentTechnique = Effect.Techniques["DrawBase"]; foreach (var pass in Effect.CurrentTechnique.Passes) { pass.Apply(); device.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, dg.NumPrimitives); } }); } } }
/// <summary> /// Creates a UISpriteBatch. Same as spritebatch with some extra functionality /// required by the UI system of this game. /// /// NumBuffers refers to a number of RenderTarget2D objects to create up front. /// These should be used for temp rendering for special effects. E.g. rendering /// part of the GUI to a texture and then painting it with opacity onto the main /// target. /// </summary> /// <param name="gd"></param> /// <param name="numBuffers">The number of rendering buffers to pre-alloc</param> public UISpriteBatch(GraphicsDevice gd, int numBuffers, int width, int height, int multisample) : base(gd) { _Width = width; _Height = height; for (var i = 0; i < numBuffers; i++) { Buffers.Add( PPXDepthEngine.CreateRenderTarget(gd, 1, multisample, SurfaceFormat.Color, width, height, DepthFormat.None) ); } base.GraphicsDevice.DeviceReset += new EventHandler <EventArgs>(gd_DeviceReset); }
private void gd_DeviceReset(object sender, EventArgs e) { Invalidated = true; Buffers.Clear(); for (var i = 0; i < 3; i++) { Buffers.Add( PPXDepthEngine.CreateRenderTarget(base.GraphicsDevice, 1, 0, SurfaceFormat.Color, Width, Height, DepthFormat.None) ); } Invalidated = false; }
/// <summary> /// We will just take over the whole rendering of this scene :) /// </summary> /// <param name="device"></param> public override void Draw(GraphicsDevice device) { if (HasInit == false) { return; } if (FSOEnvironment.SoftwareDepth) { PPXDepthEngine.DrawBackbuffer(); return; } InternalDraw(device); }
public void GenBuffers(int bwidth, int bheight) { foreach (var buffer in Buffers) { buffer.Dispose(); } Buffers.Clear(); ResetMatrices(bwidth, bheight); ScreenWidth = bwidth; ScreenHeight = bheight; for (var i = 0; i < NumBuffers; i++) { int width = bwidth + ScrollBuffer; int height = bheight + ScrollBuffer; switch (i) { case 2: //World2D.BUFFER_OBJID width = 1; height = 1; break; case 3: //World2D.BUFFER_THUMB case 4: width = 1024; height = 1024; break; case 5: width = 576; height = 576; break; } if (NumBuffers == 2) { width = height = 1024; //special case, thumb only. } var depthformat = FSOEnvironment.SoftwareDepth ? DepthFormat.Depth24Stencil8 : DepthFormat.Depth24; //stencil is used for software depth Buffers.Add( PPXDepthEngine.CreateRenderTarget(Device, 1, 0, SurfaceFormats[i], width, height, (AlwaysDS[i] || (!FSOEnvironment.UseMRT && !FSOEnvironment.SoftwareDepth)) ? depthformat : DepthFormat.None) ); } }
public _2DWorldBatch(GraphicsDevice device, int numBuffers, SurfaceFormat[] surfaceFormats, bool[] alwaysDS, int scrollBuffer) { this.Device = device; this.Effect = WorldContent._2DWorldBatchEffect; //TODO: World size Sprites = new List <_2DSpriteGroup>(); ScrollBuffer = scrollBuffer; ResetMatrices(device.Viewport.Width, device.Viewport.Height); ScreenWidth = device.Viewport.Width; ScreenHeight = device.Viewport.Height; for (var i = 0; i < numBuffers; i++) { int width = device.Viewport.Width + scrollBuffer; int height = device.Viewport.Height + scrollBuffer; switch (i) { case 4: //World2D.BUFFER_OBJID width = 1; height = 1; break; case 0: //World2D.BUFFER_THUMB case 10: width = 1024; height = 1024; break; case 11: width = 1024; height = 1024; break; } if (numBuffers == 2 && i == 1) { width = height = 1024; //special case, thumb only. } Buffers.Add( PPXDepthEngine.CreateRenderTarget(device, 1, 0, surfaceFormats[i], width, height, (alwaysDS[i] || (!FSOEnvironment.UseMRT && !FSOEnvironment.SoftwareDepth))?DepthFormat.Depth24Stencil8:DepthFormat.None) ); } }
/// <summary> /// Pre-Draw /// </summary> /// <param name="device"></param> public override void PreDraw(GraphicsDevice device) { base.PreDraw(device); if (HasInit == false) { return; } BoundView(); State._2D.PreciseZoom = State.PreciseZoom; State.OutsideColor = Blueprint.OutsideColor; FSO.Common.Rendering.Framework.GameScreen.ClearColor = new Color(new Color(0x72, 0x72, 0x72).ToVector4() * State.OutsideColor.ToVector4()); foreach (var sub in Blueprint.SubWorlds) { sub.PreDraw(device, State); } State.UpdateInterpolation(); if (Blueprint != null) { foreach (var ent in Blueprint.Objects) { ent.Update(null, State); } } //For all the tiles in the dirty list, re-render them //PPXDepthEngine.SetPPXTarget(null, null, true); State.PrepareLighting(); State._2D.Begin(this.State.Camera); _2DWorld.PreDraw(device, State); device.SetRenderTarget(null); State._2D.End(); State._3D.Begin(device); _3DWorld.PreDraw(device, State); State._3D.End(); if (UseBackbuffer) { PPXDepthEngine.SetPPXTarget(null, null, true); InternalDraw(device); device.SetRenderTarget(null); } return; }
/// <summary> /// We will just take over the whole rendering of this scene :) /// </summary> /// <param name="device"></param> public override void Draw(GraphicsDevice device) { if (HasInit == false) { return; } FrameCounter++; if (FrameCounter < LastCacheClear + 60 * 60) { State._2D.ClearTextureCache(); } if (!UseBackbuffer) { InternalDraw(device); } else { PPXDepthEngine.DrawBackbuffer(Opacity); } return; }
public void ResizeBuffer(int width, int height) { _Width = width; _Height = height; var numBuffers = AllBuffers.Count; foreach (var buf in AllBuffers) { buf.Dispose(); } Buffers.Clear(); AllBuffers.Clear(); for (var i = 0; i < numBuffers; i++) { Buffers.Add( PPXDepthEngine.CreateRenderTarget(base.GraphicsDevice, 1, 0, SurfaceFormat.Color, Width, Height, DepthFormat.None) ); } AllBuffers = new List <RenderTarget2D>(Buffers); }
public override void ChangedWorldConfig(GraphicsDevice gd) { base.ChangedWorldConfig(gd); switch (WorldConfig.Current.AA) { case 1: PPXDepthEngine.MSAA = 4; PPXDepthEngine.SSAA = 1; break; case 2: PPXDepthEngine.SSAA = 2; PPXDepthEngine.MSAA = 0; break; default: PPXDepthEngine.MSAA = 0; PPXDepthEngine.SSAA = 1; break; } PPXDepthEngine.InitScreenTargets(); UseBackbuffer = WorldConfig.Current.AA > 0; }