public ViewProjectionProvider(bool projection, DrawState state) { _proj = projection; #if DEBUG _state = state; #endif }
public void Combine(DrawState state) { CombineShader shader = state.GetShader<CombineShader>(); shader.WorldTexture = _worldRenderTarget; shader.UITexture = _uiRenderTarget; shader.Bind(state); _vertices.Draw(state, null, PrimitiveType.TriangleStrip); }
internal void QueueQuad(DrawState state, ref Vector2 tl, ref Vector2 tr, ref Vector2 bl, ref Vector2 br, Texture2D texture) { if (_currentVertex + 4 >= _vertices.Length) Flush(state); _vertices[_currentVertex + 0].Position.X = tl.X; _vertices[_currentVertex + 0].Position.Y = tl.Y; _vertices[_currentVertex + 1].Position.X = bl.X; _vertices[_currentVertex + 1].Position.Y = bl.Y; _vertices[_currentVertex + 2].Position.X = tr.X; _vertices[_currentVertex + 2].Position.Y = tr.Y; _vertices[_currentVertex + 3].Position.X = br.X; _vertices[_currentVertex + 3].Position.Y = br.Y; _currentVertex += 4; _textures.Add(texture); }
protected internal override void End(DrawState state) { }
public Engine(IKernel kernel) { _kernel = kernel; _resouces = new List<IResourceContainer>(); _updatables = new List<IUpdatable>(); _renderables = new List<IRenderable>(); IDeviceProvider deviceProvider = kernel.Get<IDeviceProvider>(); _form = deviceProvider.RenderForm; _form.ResizeBegin += OnResizeBegin; _form.ResizeEnd += OnResizeEnd; _form.FormClosed += OnFormClosed; _form.Resize += new EventHandler(OnFormResize); _form.KeyDown += new KeyEventHandler(_form_KeyDown); _device = new DeviceEx(deviceProvider.Device.NativePointer); _presentParameters = deviceProvider.PresentParameters; _totalGameTime = TimeSpan.Zero; _lastFrameElapsedGameTime = TimeSpan.Zero; _drawState = new DrawState(); _updateState = new UpdateState(); _clock = new GameClock(); }
protected abstract void BindShader(DrawState state, bool maskOnly);
public void Render(DrawState state) { if (_enabled) Render(state, 255); }
internal abstract void WarmOverride(DrawState state);
private void Render(DrawState state) { SimpleTextureEffect shader = state.GetShader<SimpleTextureEffect>(); state.PushCamera(camera); shader.Texture = _texture; shader.Bind(state); _vertices.Draw(state, null, PrimitiveType.TriangleStrip); state.PopCamera(); }
public void EndWorld(DrawState state) { state.Context.SetRenderTarget(null); }
public void BeginWorld(DrawState state) { state.Context.SetRenderTarget(_worldRenderTarget); state.Context.Clear(ClearFlags.Target | ClearFlags.ZBuffer, System.Drawing.Color.CornflowerBlue, 1.0f, 0); }
public void BeginUI(DrawState state) { state.Context.SetRenderTarget(_uiRenderTarget); state.Context.Clear(ClearFlags.Target | ClearFlags.ZBuffer, new Color4(0, 0, 0, 0), 1.0f, 0); }
public abstract void Render(DrawState state);
public void Bind(DrawState state) { for (int i = 0; i < Parameters.Count; i++) { ShaderParameter parameter = Parameters[i]; ISemantic semantic; if (!string.IsNullOrEmpty(parameter.Semantic) && state.SemanticMappings.TryGetValue(parameter.Semantic, out semantic)) semantic.Apply(parameter); } state.Context.ActivePass = CurrentTechnique.Passes[0]; }
public unsafe void Draw(DrawState state) { DeviceContext context = state.Context; context.PerformanceMonitor.StartTimer("World.Draw"); state.PushCamera(_camera); float length = new Vector2(context.Viewport.Width, context.Viewport.Height).Length(); Vector2 position; position.X = Player.Position.X; position.Y = Player.Position.Y; Vector2 offset = new Vector2(position.X % 8, position.Y % 8); int overCellX = (int)Math.Round(position.X, 0, MidpointRounding.AwayFromZero); int overCellY = (int)Math.Round(position.Y, 0, MidpointRounding.AwayFromZero); int cellNodeX = (int)overCellX / 8; int cellNodeY = (int)overCellY / 8; int nodesToDraw = (int)Math.Round(length / 44f / 8f, 0, MidpointRounding.AwayFromZero); if (nodesToDraw % 2 == 0) nodesToDraw++; int nodesOverTwo = (int)Math.Round(nodesToDraw / 2f, 0, MidpointRounding.AwayFromZero); //int startNodeX = cellNodeX - nodesOverTwo; //int startNodeY = cellNodeY - nodesOverTwo; //int endNodeX = cellNodeX + nodesOverTwo; //int endNodeY = cellNodeY + nodesOverTwo; //state.BeginEffect("ColorEffect"); //if (_stream == null) // _stream = new VertexStream<VertexPositionColor, short>(state.Context, streamSize, (streamSize / 4) * 6); //_stream.Begin(PrimitiveType.TriangleList); //for (int y = startNodeY; y < endNodeY; y++) //{ // for (int x = startNodeX; x < endNodeX; x++) // { // for (int ty = 0; ty < 8; ty++) // { // for (int tx = 0; tx < 8; tx++) // { // Vector2 p = new Vector2(x * 8 + tx, y * 8 + ty); // Color4 color = new Color4(0,0,0,1); // if (p.X == overCellX && p.Y == overCellY) // color.Red = 1; // FragmentLocation location; // _stream.Allocate(VertexFragment.Quad, out location); // VertexPositionColor* vPtr = (VertexPositionColor*)location.Vertices; // ushort* iPtr = (ushort*)location.Indices; // *iPtr++ = (ushort)(location.BaseIndex + 0); // *iPtr++ = (ushort)(location.BaseIndex + 1); // *iPtr++ = (ushort)(location.BaseIndex + 2); // *iPtr++ = (ushort)(location.BaseIndex + 2); // *iPtr++ = (ushort)(location.BaseIndex + 1); // *iPtr = (ushort)(location.BaseIndex + 3); // vPtr->Position.X = p.X; // vPtr->Position.Y = p.Y; // vPtr->Position.Z = 0; // vPtr->Color = color; // vPtr++; // vPtr->Position.X = p.X + 1; // vPtr->Position.Y = p.Y; // vPtr->Position.Z = 0; // vPtr->Color = color; // vPtr++; // vPtr->Position.X = p.X; // vPtr->Position.Y = p.Y + 1; // vPtr->Position.Z = 0; // vPtr->Color = color; // vPtr++; // vPtr->Position.X = p.X + 1; // vPtr->Position.Y = p.Y + 1; // vPtr->Position.Z = 0; // vPtr->Color = color; // } // } // } //} //state.SetStream(_stream); //int primitiveCount; //context.CalculatePrimitiveCount(_stream.PrimitiveType, _stream.IndexCount, out primitiveCount); //context.DrawIndexedPrimitive(_stream.PrimitiveType, 0, 0, _stream.VertexCount, 0, primitiveCount); //state.ReleaseStream(); //_stream.End(); //state.EndEffect(); //state.PopProjectionMatrix(); //state.PopViewMatrix(); context.PerformanceMonitor.StopTimer("World.Draw"); }
internal override void WarmOverride(DrawState state) { }
internal void QueueQuad(DrawState state, Vector2 v1, Vector2 v2, Texture2D texture) { if (_currentVertex + 4 >= _vertices.Length) Flush(state); _vertices[_currentVertex + 0].Position.X = v1.X; _vertices[_currentVertex + 0].Position.Y = v1.Y; _vertices[_currentVertex + 1].Position.X = v1.X; _vertices[_currentVertex + 1].Position.Y = v2.Y; _vertices[_currentVertex + 2].Position.X = v2.X; _vertices[_currentVertex + 2].Position.Y = v1.Y; _vertices[_currentVertex + 3].Position.X = v2.X; _vertices[_currentVertex + 3].Position.Y = v2.Y; _currentVertex += 4; _textures.Add(texture); }
public override void Render(DrawState state) { if (_textures == null || !_isValid) return; IRenderer renderer = state.Renderer; Vector2 position = _positions[0]; Vector2 size = _sizes[0]; Vector2 texCoords = Vector2.One; renderer.RenderQuad(ref position, ref size, ref texCoords, _textures[0]); position = _positions[1]; size = _sizes[1]; texCoords = _texCoords[0]; renderer.RenderQuad(ref position, ref size, ref texCoords, _textures[1]); position = _positions[2]; size = _sizes[2]; texCoords = Vector2.One; renderer.RenderQuad(ref position, ref size, ref texCoords, _textures[2]); position = _positions[3]; size = _sizes[3]; texCoords = _texCoords[1]; renderer.RenderQuad(ref position, ref size, ref texCoords, _textures[3]); position = _positions[4]; size = _sizes[4]; texCoords = _texCoords[2]; renderer.RenderQuad(ref position, ref size, ref texCoords, _textures[4]); position = _positions[5]; size = _sizes[5]; texCoords = _texCoords[1]; renderer.RenderQuad(ref position, ref size, ref texCoords, _textures[5]); position = _positions[6]; size = _sizes[6]; texCoords = Vector2.One; renderer.RenderQuad(ref position, ref size, ref texCoords, _textures[6]); position = _positions[7]; size = _sizes[7]; texCoords = _texCoords[0]; renderer.RenderQuad(ref position, ref size, ref texCoords, _textures[7]); position = _positions[8]; size = _sizes[8]; texCoords = Vector2.One; renderer.RenderQuad(ref position, ref size, ref texCoords, _textures[8]); }
internal void Flush(DrawState state) { if (_currentVertex == 0) return; GraphicsDevice device = state.GraphicsDevice; using (var vertexBuffer = new VertexBuffer(device, VertexPositionTexture.VertexDeclaration, _vertices.Length, BufferUsage.None)) { using (var indexBuffer = new IndexBuffer(device, IndexElementSize.SixteenBits, _quadIndices.Length, BufferUsage.None)) { vertexBuffer.SetData(_vertices, 0, _vertices.Length); indexBuffer.SetData(_quadIndices, 0, _quadIndices.Length); device.Indices = indexBuffer; device.SetVertexBuffer(vertexBuffer); for (int i = 0; i < _textures.Count; i++) { device.Textures[0] = _textures[i]; device.DrawIndexedPrimitives(PrimitiveType.TriangleList, i * 4, 0, 4, 0, 2); } device.SetVertexBuffer(null); device.Indices = null; } } _currentVertex = 0; _textures.Clear(); }
public void Warm(DrawState state) { lock (this) WarmOverride(state); }
internal void Begin(DrawState state) { int w = state.Context.Viewport.Width; int h = state.Context.Viewport.Height; _dirty |= w != _rtWidth; _dirty |= h != _rtHeight; _rtWidth = w; _rtHeight = h; _rtHeightf = (float)h; _rtWidthf = (float)w; }
private void Render(DrawState state) { if (!IsOpen) return; //DeviceContext context = state.Context; //Viewport viewport = context.Viewport; //_vertexStream.Begin(PrimitiveType.TriangleList); //float height = _fontFactory.GetFontHeight(FONT_INDEX); //float consoleHeight = height * 21; //AllocateQuad(0, 0, viewport.Width, consoleHeight); //ConsoleLine[] lines = GetHistory(20); //Texture2D[] textures = new Texture2D[lines.Length + 2]; //for (int i = lines.Length - 1; i >= 0; i--) //{ // Texture2D texture = _fontFactory.GetText(FONT_INDEX, lines[0].Text, 0); // const float x = 5; // float y = consoleHeight - 5 - ((i + 2) * height); // AllocateQuad(x, y, texture.Size.X, texture.Size.Y); // textures[i + 1] = texture; //} //_vertexStream.Bind(); //Matrix projection; //Matrix.OrthoOffCenterRH(0, viewport.Width, viewport.Height, 0, 0, 1, out projection); //state.Context.SetRenderState(RenderState.CullMode, Cull.Clockwise); //context.SetStreamSource(0, _vertexStream.VertexBuffer, 0, _vertexStream.VertexStride); //context.VertexDeclaration = _vertexStream.VertexDeclaration; //context.Indices = _vertexStream.IndexBuffer; //_shader.Bind(state); //for (int i = 0; i < textures.Length; i++) //{ // context.SetTexture(0, textures[i]); // _shader.CommitChanges(); // context.DrawIndexedPrimitive(PrimitiveType.TriangleList, i * 4, 0, 4, 0, 2); //} //_vertexStream.End(); //foreach (Texture texture in textures) // if (texture != null) // texture.Dispose(); }
public void Render(DrawState state) { if (_projectionDirty) { _projectionDirty = false; Matrix.OrthoOffCenterLH(0, _device.Viewport.Width, _device.Viewport.Height, 0, 0, 1, out _projection); } state.PushRenderer(_renderer); state.Device.SetRenderState(RenderState.AlphaBlendEnable, true); state.Device.SetRenderState(RenderState.AlphaTestEnable, true); state.Device.SetRenderState(RenderState.SourceBlend, Blend.SourceAlpha); state.Device.SetRenderState(RenderState.DestinationBlend, Blend.InverseSourceAlpha); state.PushProjection(_projection); _shader.Begin(state); foreach (Element element in _elements) element.Render(state); state.PopRenderer(); state.PopProjection(); _shader.End(); }
public void Render(DrawState state, byte clipDepth) { Element parent = _parent; Matrix matrix; DeviceContext context = state.Context; if (parent == null) { _clipTest = false; DeviceRenderState rstate = new DeviceRenderState(); rstate.DepthColourCull.DepthWriteEnabled = false; rstate.DepthColourCull.DepthTestEnabled = false; state.PushRenderState(ref rstate); if (_camera == null) _camera = new ElementCamera(true); state.PushCamera(_camera); } else _clipTest = parent._clipTest | parent.ClipsChildren; StencilTestState stencilState = new StencilTestState(); if (_clipTest) { stencilState.Enabled = true; stencilState.ReferenceValue = clipDepth; stencilState.StencilFunction = Compare.Equal; stencilState.StencilPassOperation = StencilOperation.Keep; } bool clearStencil = false; if (ClipsChildren) { clearStencil = clipDepth == 255; clipDepth--; if (!_clipTest) { stencilState.Enabled = true; stencilState.ReferenceValue = clipDepth; stencilState.StencilPassOperation = StencilOperation.Replace; } else stencilState.StencilPassOperation = StencilOperation.Decrement; } Viewport viewport = context.Viewport; Vector2 scale = new Vector2(viewport.Width, viewport.Height); if ((scale.X != 0 && scale.Y != 0)) { Vector2 size = ElementSize; GetDisplayMatrix(out matrix, scale, ref size); state.PushWorldMatrixMultiply(ref matrix); BindShader(state, false); state.RenderState.AlphaBlend = _blendState; state.RenderState.StencilTest = stencilState; if (!UseSize) size = new Vector2(1, 1); else if (IsNormalised) { size.X *= scale.X; size.Y *= scale.Y; } PreDraw(state.Context, size); DrawElement(state); List<Element> children = Children; if (children != null) foreach (Element child in children) if (child.CullTest(state)) child.Render(state, clipDepth); if (clearStencil) { BindShader(state, true); stencilState = new StencilTestState(); stencilState.Enabled = true; stencilState.StencilFunction = Compare.Never; stencilState.StencilFailOperation = StencilOperation.Zero; state.RenderState.StencilTest = stencilState; DrawElement(state); } state.PopWorldMatrix(); } if (parent == null) { state.PopRenderState(); state.PopCamera(); } }
protected internal override void Begin(DrawState state) { DeviceContext device = state.Context; state.ResetTextures(); device.SetRenderTarget(0, null); Vector2 ws = new Vector2((float)Width, (float)Height); if (ws.X != windowSize.X || ws.Y != windowSize.Y) { windowSize = ws; windowSizeChangeIndex = System.Threading.Interlocked.Increment(ref DrawTarget.baseSizeIndex); } }
protected abstract void DrawElement(DrawState state);
private void Render(DrawState state) { _device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.CornflowerBlue, 1.0f, 0); _device.BeginScene(); foreach (IRenderable renderable in _renderables) renderable.Render(state); _device.EndScene(); //state.Device.SetRenderState(RenderState.AlphaBlendEnable, true); //state.Device.SetRenderState(RenderState.AlphaTestEnable, true); //state.Device.SetRenderState(RenderState.SourceBlend, Blend.SourceAlpha); //state.Device.SetRenderState(RenderState.DestinationBlend, Blend.InverseSourceAlpha); //state.PushProjection(_camera.Projection); //_shader.Begin(state); //Vector2 cameraOffset = new Vector2(0.5f, 0.5f); //Vector2 cameraPosition = state.Camera.Position + cameraOffset; //Vector2 viewSize = new Vector2(_presentParameters.BackBufferWidth, _presentParameters.BackBufferHeight); //Vector2 tileCounts = new Vector2(viewSize.X / 22, viewSize.Y / 22); //Tile centerTile = _maps.Felucca.Tiles.GetLandTile((int)cameraPosition.X, (int)cameraPosition.Y); //int centerTileZ = centerTile._z * 4; //tileCounts.X = 0.5f; //Math.Min(tileCounts.X, MaxTileDistanceTime2); //tileCounts.Y = 0.5f;// Math.Min(tileCounts.Y, MaxTileDistanceTime2); //int startX = (int)(cameraPosition.X - tileCounts.X); //int startY = (int)(cameraPosition.Y - tileCounts.Y); //int endX = (int)(cameraPosition.X + tileCounts.X); //int endY = (int)(cameraPosition.Y + tileCounts.Y); //Vector2 offset, northVector, eastVector, westVector, southVector, center; //float widthInPixels = tileCounts.X * TileStepX; //float heightInPixels = tileCounts.Y * TileStepY; //for (int y = startY; y < endY; y++) //{ // offset.X = widthInPixels + (((-tileCounts.X) + (startY - y)) * TileStepY); // offset.Y = heightInPixels + ((tileCounts.Y) + (startY - y)) * TileStepY; // BoundingBox bb; // for (int x = startX; x < endX; x++) // { // Tile tile = _maps.Felucca.Tiles.GetLandTile(x, y); // Tile eastTile = _maps.Felucca.Tiles.GetLandTile(x + 1, y); // Tile southTile = _maps.Felucca.Tiles.GetLandTile(x, y + 1); // Tile southEastTile = _maps.Felucca.Tiles.GetLandTile(x + 1, y + 1); // int tileZ = (tile._z * 4) - centerTileZ; // int eastTileZ = (eastTile._z * 4) - centerTileZ; // int southTileZ = (southTile._z * 4) - centerTileZ; // int southEastTileZ = (southEastTile._z * 4) - centerTileZ; // center.X = offset.X; // center.Y = offset.Y; // northVector.X = center.X; // northVector.Y = center.Y + TileSizeOver2 + tileZ; // eastVector.X = center.X - TileSizeOver2; // eastVector.Y = center.Y + southTileZ; // westVector.X = center.X + TileSizeOver2; // westVector.Y = center.Y + eastTileZ; // southVector.X = center.X; // southVector.Y = (center.Y - TileSizeOver2) + southEastTileZ; // bb.Minimum = new Vector3(eastVector.X, southVector.Y, float.MinValue); // bb.Maximum = new Vector3(westVector.X, northVector.Y, float.MaxValue); // if (_camera.BoundingFrustum.Contains(bb) != ContainmentType.Disjoint) // state.Renderer.RenderQuad(ref northVector, ref eastVector, ref westVector, ref southVector, _textureFactory.CreateLandTexture(tile._id)); // HuedTile[] statics = _maps.Felucca.Tiles.GetStaticTiles(x, y); // for (int i = 0; i < statics.Length; i++) // { // HuedTile s = statics[i]; // Texture texture = _textureFactory.CreateStaticTexture(s._id); // SurfaceDescription description = texture.GetLevelDescription(0); // int staticHeight = s._z * 4 + centerTileZ - 22; // int height = description.Height; // int width = description.Width; // int widthOver2 = width / 2; // northVector.X = center.X - widthOver2; // northVector.Y = center.Y + height + staticHeight; // eastVector.X = center.X - widthOver2; // eastVector.Y = center.Y + staticHeight; // westVector.X = center.X + widthOver2; // westVector.Y = center.Y + height + staticHeight; // southVector.X = center.X + widthOver2; // southVector.Y = center.Y + staticHeight; // bb.Minimum = new Vector3(eastVector.X, southVector.Y, 0); // bb.Maximum = new Vector3(westVector.X, northVector.Y, 0); // if (_camera.BoundingFrustum.Contains(bb) != ContainmentType.Disjoint) // state.Renderer.RenderQuad(ref northVector, ref eastVector, ref westVector, ref southVector, texture); // } // offset.X += TileStepX; // offset.Y -= TileStepY; // } //} //state.Flush(); //state.PopProjection(); //_shader.End(); //_device.EndScene(); }