From acea7b2e728787a0d83bbf83c8c1f042d2c32e7e Mon Sep 17 00:00:00 2001 From: chai <215380520@qq.com> Date: Mon, 3 Jun 2024 10:15:45 +0800 Subject: + plugins project --- .../source/MonoGame.Extended.Graphics/Batcher.cs | 387 ++++++++++++++++++ .../source/MonoGame.Extended.Graphics/Batcher2D.cs | 450 +++++++++++++++++++++ .../Effects/DefaultEffect.cs | 203 ++++++++++ .../Effects/EffectResource.cs | 119 ++++++ .../Effects/ITextureEffect.cs | 18 + .../Effects/MatrixChainEffect.cs | 155 +++++++ .../Effects/Resources/DefaultEffect.dx11.mgfxo | Bin 0 -> 4829 bytes .../Effects/Resources/DefaultEffect.fx | 72 ++++ .../Effects/Resources/DefaultEffect.ogl.mgfxo | Bin 0 -> 4833 bytes .../Effects/Resources/Macros.fxh | 60 +++ .../Effects/Resources/RebuildEffects.bat | 15 + .../Effects/Resources/Structures.fxh | 51 +++ .../source/MonoGame.Extended.Graphics/FlipFlags.cs | 13 + .../Geometry/GeometryBuilder.cs | 24 ++ .../Geometry/GeometryBuilder2D.cs | 119 ++++++ .../IBatchDrawCallInfo.cs | 19 + .../IMatrixChainEffect.cs | 30 ++ .../MonoGame.Extended.Graphics.csproj | 28 ++ .../PrimitiveTypeExtensions.cs | 42 ++ .../RenderTarget2DExtensions.cs | 41 ++ 20 files changed, 1846 insertions(+) create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Batcher.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Batcher2D.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/DefaultEffect.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/EffectResource.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/ITextureEffect.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/MatrixChainEffect.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.dx11.mgfxo create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.fx create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.ogl.mgfxo create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Macros.fxh create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/RebuildEffects.bat create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Structures.fxh create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/FlipFlags.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Geometry/GeometryBuilder.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Geometry/GeometryBuilder2D.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/IBatchDrawCallInfo.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/IMatrixChainEffect.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/MonoGame.Extended.Graphics.csproj create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/PrimitiveTypeExtensions.cs create mode 100644 Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/RenderTarget2DExtensions.cs (limited to 'Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics') diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Batcher.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Batcher.cs new file mode 100644 index 0000000..3cb5704 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Batcher.cs @@ -0,0 +1,387 @@ +using System; +using System.Runtime.CompilerServices; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics +{ + /// + /// Minimizes draw calls to a by sorting them and attempting to merge them together + /// before submitting them. + /// + /// The type of the information for a draw call. + /// + public abstract class Batcher : IDisposable + where TDrawCallInfo : struct, IBatchDrawCallInfo, IComparable + { + internal const int DefaultBatchMaximumDrawCallsCount = 2048; + private BlendState _blendState; + private SamplerState _samplerState; + private DepthStencilState _depthStencilState; + private RasterizerState _rasterizerState; + private readonly Effect _defaultEffect; + private Effect _currentEffect; + private Matrix? _viewMatrix; + private Matrix? _projectionMatrix; + + /// + /// The array of structs currently enqueued. + /// + protected TDrawCallInfo[] DrawCalls; + + /// + /// The number of structs currently enqueued. + /// + protected int EnqueuedDrawCallCount; + + /// + /// Gets the associated with this . + /// + /// + /// The associated with this . + /// + public GraphicsDevice GraphicsDevice { get; } + + /// + /// Gets a value indicating whether batching is currently in progress by being within a and + /// pair block of code. + /// + /// + /// true if batching has begun; otherwise, false. + /// + public bool HasBegun { get; internal set; } + + /// + /// Initializes a new instance of the class. + /// + /// The graphics device. + /// The default effect. + /// + /// The maximum number of structs that can be enqueued before a + /// + /// is required. The default value is 2048. + /// + /// + /// is + /// null. + /// + /// + /// is less than or equal + /// 0. + /// + protected Batcher(GraphicsDevice graphicsDevice, Effect defaultEffect, + int maximumDrawCallsCount = DefaultBatchMaximumDrawCallsCount) + { + if (graphicsDevice == null) + throw new ArgumentNullException(nameof(graphicsDevice)); + + if (maximumDrawCallsCount <= 0) + throw new ArgumentOutOfRangeException(nameof(maximumDrawCallsCount)); + + GraphicsDevice = graphicsDevice; + _defaultEffect = defaultEffect; + DrawCalls = new TDrawCallInfo[maximumDrawCallsCount]; + } + + /// + /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + /// + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + /// + /// Releases unmanaged and - optionally - managed resources. + /// + /// + /// true to release both managed and unmanaged resources; false to release only + /// unmanaged resources. + /// + protected virtual void Dispose(bool diposing) + { + if (!diposing) + return; + _defaultEffect.Dispose(); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + protected void EnsureHasBegun([CallerMemberName] string callerMemberName = null) + { + if (!HasBegun) + throw new InvalidOperationException( + $"The {nameof(Begin)} method must be called before the {callerMemberName} method can be called."); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + protected void EnsureHasNotBegun([CallerMemberName] string callerMemberName = null) + { + if (HasBegun) + throw new InvalidOperationException( + $"The {nameof(End)} method must be called before the {callerMemberName} method can be called."); + } + + /// + /// Begins the batch operation using an optional , , + /// , , , world-to-view + /// , or view-to-projection . + /// + /// + /// + /// The default objects for , , + /// , and are + /// , , + /// and respectively. + /// Passing + /// null for any of the previously mentioned parameters result in using their default object. + /// + /// + /// The to use for the , pair. + /// + /// The texture to use for the and + /// pair. + /// + /// + /// The to use for the and + /// pair. + /// + /// + /// The to use for the and + /// pair. + /// + /// The to use for the and pair. + /// + /// The world-to-view transformation matrix to use for the and + /// pair. + /// + /// + /// The view-to-projection transformation matrix to use for the and + /// pair. + /// + /// + /// cannot be invoked again until has been invoked. + /// + /// + /// + /// This method must be called before any enqueuing of draw calls. When all the geometry have been enqueued for + /// drawing, call . + /// + /// + public virtual void Begin(Matrix? viewMatrix = null, Matrix? projectionMatrix = null, BlendState blendState = null, SamplerState samplerState = null, + DepthStencilState depthStencilState = null, RasterizerState rasterizerState = null, Effect effect = null) + { + var viewMatrix1 = viewMatrix ?? Matrix.Identity; + var projectionMatrix1 = projectionMatrix ?? Matrix.CreateOrthographicOffCenter(0, GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height, 0, 0, -1); + Begin(ref viewMatrix1, ref projectionMatrix1, blendState, samplerState, depthStencilState, rasterizerState, effect); + } + + /// + /// Begins the batch operation using an optional , , + /// , , , world-to-view + /// , or view-to-projection . + /// + /// + /// + /// The default objects for , , + /// , and are + /// , , + /// and respectively. + /// Passing + /// null for any of the previously mentioned parameters result in using their default object. + /// + /// + /// The to use for the , pair. + /// + /// The texture to use for the and + /// pair. + /// + /// + /// The to use for the and + /// pair. + /// + /// + /// The to use for the and + /// pair. + /// + /// The to use for the and pair. + /// + /// The world-to-view transformation matrix to use for the and + /// pair. + /// + /// + /// The view-to-projection transformation matrix to use for the and + /// pair. + /// + /// + /// cannot be invoked again until has been invoked. + /// + /// + /// + /// This method must be called before any enqueuing of draw calls. When all the geometry have been enqueued for + /// drawing, call . + /// + /// + public virtual void Begin(ref Matrix viewMatrix, ref Matrix projectionMatrix, BlendState blendState = null, SamplerState samplerState = null, + DepthStencilState depthStencilState = null, RasterizerState rasterizerState = null, Effect effect = null) + { + EnsureHasNotBegun(); + HasBegun = true; + + // Store the states to be applied on End() + // This ensures that two or more batchers will not affect each other + _blendState = blendState ?? BlendState.AlphaBlend; + _samplerState = samplerState ?? SamplerState.PointClamp; + _depthStencilState = depthStencilState ?? DepthStencilState.None; + _rasterizerState = rasterizerState ?? RasterizerState.CullCounterClockwise; + _currentEffect = effect ?? _defaultEffect; + _projectionMatrix = projectionMatrix; + _viewMatrix = viewMatrix; + } + + /// + /// Flushes the batched geometry to the and restores it's state to how it was before + /// was called. + /// + /// + /// cannot be invoked until has been invoked. + /// + /// + /// + /// This method must be called after all enqueuing of draw calls. + /// + /// + public void End() + { + EnsureHasBegun(); + Flush(); + HasBegun = false; + } + + /// + /// Sorts then submits the (sorted) enqueued draw calls to the for + /// rendering without ending the and pair. + /// + protected void Flush() + { + if (EnqueuedDrawCallCount == 0) + return; + SortDrawCallsAndBindBuffers(); + ApplyStates(); + SubmitDrawCalls(); + RestoreStates(); + } + + /// + /// Sorts the enqueued draw calls and binds any used or to the . + /// + protected abstract void SortDrawCallsAndBindBuffers(); + + private void ApplyStates() + { + var oldBlendState = GraphicsDevice.BlendState; + var oldSamplerState = GraphicsDevice.SamplerStates[0]; + var oldDepthStencilState = GraphicsDevice.DepthStencilState; + var oldRasterizerState = GraphicsDevice.RasterizerState; + + GraphicsDevice.BlendState = _blendState; + + GraphicsDevice.SamplerStates[0] = _samplerState; + GraphicsDevice.DepthStencilState = _depthStencilState; + GraphicsDevice.RasterizerState = _rasterizerState; + + _blendState = oldBlendState; + _samplerState = oldSamplerState; + _depthStencilState = oldDepthStencilState; + _rasterizerState = oldRasterizerState; + + var viewMatrix = _viewMatrix ?? Matrix.Identity; + var projectionMatrix = _projectionMatrix ?? + Matrix.CreateOrthographicOffCenter(0, GraphicsDevice.Viewport.Width, + GraphicsDevice.Viewport.Height, 0, 0f, -1f); + + var matrixChainEffect = _currentEffect as IMatrixChainEffect; + if (matrixChainEffect != null) + { + matrixChainEffect.World = Matrix.Identity; + matrixChainEffect.SetView(ref viewMatrix); + matrixChainEffect.SetProjection(ref projectionMatrix); + } + else + { + var effectMatrices = _currentEffect as IEffectMatrices; + if (effectMatrices == null) + return; + effectMatrices.World = Matrix.Identity; + effectMatrices.View = viewMatrix; + effectMatrices.Projection = projectionMatrix; + } + } + + private void RestoreStates() + { + GraphicsDevice.BlendState = _blendState; + GraphicsDevice.SamplerStates[0] = _samplerState; + GraphicsDevice.DepthStencilState = _depthStencilState; + GraphicsDevice.RasterizerState = _rasterizerState; + } + + /// + /// Enqueues draw call information. + /// + /// The draw call information. + /// + /// + /// If possible, the is merged with the last enqueued draw call information instead of + /// being + /// enqueued. + /// + /// + /// If the enqueue buffer is full, a is invoked and then afterwards + /// is enqueued. + /// + /// + protected void Enqueue(ref TDrawCallInfo drawCall) + { + if (EnqueuedDrawCallCount > 0 && drawCall.TryMerge(ref DrawCalls[EnqueuedDrawCallCount - 1])) + return; + if (EnqueuedDrawCallCount >= DrawCalls.Length) + Flush(); + DrawCalls[EnqueuedDrawCallCount++] = drawCall; + } + + /* It might be better to have derived classes just implement the for loop instead of having this virtual method call... + * However, if the derived class is only going to override this method once and the code is short, which should both be + * true, then maybe we can get away with this virtual method call by having it inlined. So tell the JIT or AOT compiler + * we would like it be so. This does NOT guarantee the compiler will respect our wishes. + */ + + /// + /// Submits a draw operation to the using the specified . + /// + /// The draw call information. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + protected abstract void InvokeDrawCall(ref TDrawCallInfo drawCall); + + private void SubmitDrawCalls() + { + if (EnqueuedDrawCallCount == 0) + return; + + for (var i = 0; i < EnqueuedDrawCallCount; i++) + { + DrawCalls[i].SetState(_currentEffect); + + foreach (var pass in _currentEffect.CurrentTechnique.Passes) + { + pass.Apply(); + InvokeDrawCall(ref DrawCalls[i]); + } + } + + Array.Clear(DrawCalls, 0, EnqueuedDrawCallCount); + EnqueuedDrawCallCount = 0; + } + } +} + \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Batcher2D.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Batcher2D.cs new file mode 100644 index 0000000..e7ec533 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Batcher2D.cs @@ -0,0 +1,450 @@ +using System; +using System.Text; +using System.ComponentModel; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using MonoGame.Extended.BitmapFonts; +using MonoGame.Extended.Graphics.Effects; +using MonoGame.Extended.Graphics.Geometry; + +namespace MonoGame.Extended.Graphics +{ + /// + /// A general purpose for two-dimensional geometry that change + /// frequently between frames such as sprites and shapes. + /// + /// + /// + /// For drawing user interfaces, consider using instead because it supports scissor rectangles. + /// + public sealed class Batcher2D : Batcher + { + + internal const int DefaultMaximumVerticesCount = 8192; + internal const int DefaultMaximumIndicesCount = 12288; + + private readonly VertexBuffer _vertexBuffer; + private readonly IndexBuffer _indexBuffer; + private readonly VertexPositionColorTexture[] _vertices; + private int _vertexCount; + private readonly ushort[] _indices; + private int _indexCount; + private readonly ushort[] _sortedIndices; + private readonly GeometryBuilder2D _geometryBuilder; + + /// + /// Initializes a new instance of the class. + /// + /// The graphics device. + /// + /// The maximum number of vertices that can be enqueued before a + /// is required. The default value is 8192. + /// + /// + /// The maximum number of indices that can be enqueued before a + /// is required. The default value is 12288. + /// + /// + /// The maximum number of structs that can be enqueued before a + /// is required. The default value is 2048. + /// + /// . + /// + /// is less than or equal + /// 0, or is less than or equal to 0, or, + /// is less than or equal to 0. + /// + public Batcher2D(GraphicsDevice graphicsDevice, + ushort maximumVerticesCount = DefaultMaximumVerticesCount, + ushort maximumIndicesCount = DefaultMaximumIndicesCount, + int maximumDrawCallsCount = DefaultBatchMaximumDrawCallsCount) + : base( + graphicsDevice, + new DefaultEffect(graphicsDevice) + { + TextureEnabled = true, + VertexColorEnabled = true + }, maximumDrawCallsCount) + + { + _vertices = new VertexPositionColorTexture[maximumVerticesCount]; + _vertexBuffer = new DynamicVertexBuffer(graphicsDevice, VertexPositionColorTexture.VertexDeclaration, maximumVerticesCount, BufferUsage.WriteOnly); + + _indices = new ushort[maximumIndicesCount]; + _sortedIndices = new ushort[maximumIndicesCount]; + _indexBuffer = new DynamicIndexBuffer(graphicsDevice, IndexElementSize.SixteenBits, maximumIndicesCount, BufferUsage.WriteOnly); + _geometryBuilder = new GeometryBuilder2D(4, 6); + } + + protected override void SortDrawCallsAndBindBuffers() + { + // Upload the vertices to the GPU and then select that vertex stream for drawing + _vertexBuffer.SetData(_vertices, 0, _vertexCount); + GraphicsDevice.SetVertexBuffer(_vertexBuffer); + + Array.Sort(DrawCalls, 0, EnqueuedDrawCallCount); + BuildSortedIndices(); + + // Upload the indices to the GPU and then select that index stream for drawing + _indexBuffer.SetData(_sortedIndices, 0, _indexCount); + GraphicsDevice.Indices = _indexBuffer; + + _indexCount = 0; + _vertexCount = 0; + } + + private void BuildSortedIndices() + { + var newDrawCallsCount = 0; + DrawCalls[0].StartIndex = 0; + var currentDrawCall = DrawCalls[0]; + DrawCalls[newDrawCallsCount++] = DrawCalls[0]; + + var drawCallIndexCount = currentDrawCall.PrimitiveCount * 3; + Array.Copy(_indices, currentDrawCall.StartIndex, _sortedIndices, 0, drawCallIndexCount); + var sortedIndexCount = drawCallIndexCount; + + // iterate through sorted draw calls checking if any can now be merged to reduce expensive draw calls to the graphics API + // this might need to be changed for next-gen graphics API (Vulkan, Metal, DirectX 12) where the draw calls are not so expensive + for (var i = 1; i < EnqueuedDrawCallCount; i++) + { + currentDrawCall = DrawCalls[i]; + drawCallIndexCount = currentDrawCall.PrimitiveCount * 3; + Array.Copy(_indices, currentDrawCall.StartIndex, _sortedIndices, sortedIndexCount, drawCallIndexCount); + sortedIndexCount += drawCallIndexCount; + + if (currentDrawCall.TryMerge(ref DrawCalls[newDrawCallsCount - 1])) + continue; + + currentDrawCall.StartIndex = sortedIndexCount; + DrawCalls[newDrawCallsCount++] = currentDrawCall; + } + + EnqueuedDrawCallCount = newDrawCallsCount; + } + + /// + /// Submits a draw operation to the using the specified . + /// + /// The draw call information. + protected override void InvokeDrawCall(ref DrawCallInfo drawCall) + { + GraphicsDevice.DrawIndexedPrimitives(drawCall.PrimitiveType, 0, drawCall.StartIndex, drawCall.PrimitiveCount); + } + + /// + /// Draws a sprite using a specified , transform , source + /// , and an optional + /// , origin , , and depth . + /// + /// The . + /// The transform . + /// + /// The texture region of the . Use + /// null to use the entire . + /// + /// The . Use null to use the default . + /// The . The default value is . + /// The depth . The default value is 0. + /// The method has not been called. + /// is null. + public void DrawSprite(Texture2D texture, ref Matrix2 transformMatrix, ref Rectangle sourceRectangle, + Color? color = null, FlipFlags flags = FlipFlags.None, float depth = 0) + { + _geometryBuilder.BuildSprite(_vertexCount, ref transformMatrix, texture, ref sourceRectangle, color, flags, depth); + EnqueueBuiltGeometry(texture, depth); + } + + /// + /// Draws a using the specified transform and an optional + /// , origin , , and depth . + /// + /// The . + /// The transform . + /// The . Use null to use the default . + /// The . The default value is . + /// The depth . The default value is 0. + /// The method has not been called. + /// is null. + public void DrawTexture(Texture2D texture, ref Matrix2 transformMatrix, Color? color = null, + FlipFlags flags = FlipFlags.None, float depth = 0) + { + var rectangle = default(Rectangle); + _geometryBuilder.BuildSprite(_vertexCount, ref transformMatrix, texture, ref rectangle, color, flags, depth); + EnqueueBuiltGeometry(texture, depth); + } + + private void EnqueueBuiltGeometry(Texture2D texture, float depth) + { + if ((_vertexCount + _geometryBuilder.VertexCount > _vertices.Length) || + (_indexCount + _geometryBuilder.IndexCount > _indices.Length)) + Flush(); + var drawCall = new DrawCallInfo(texture, _geometryBuilder.PrimitiveType, _indexCount, + _geometryBuilder.PrimitivesCount, depth); + Array.Copy(_geometryBuilder.Vertices, 0, _vertices, _vertexCount, _geometryBuilder.VertexCount); + _vertexCount += _geometryBuilder.VertexCount; + Array.Copy(_geometryBuilder.Indices, 0, _indices, _indexCount, _geometryBuilder.IndexCount); + _indexCount += _geometryBuilder.IndexCount; + Enqueue(ref drawCall); + } + + /// + /// Draws unicode (UTF-16) characters as sprites using the specified , text + /// , transform and optional , origin + /// , , and depth . + /// + /// The . + /// The text . + /// The transform . + /// + /// The . Use null to use the default + /// . + /// + /// The . The default value is . + /// The depth . The default value is 0f. + /// The method has not been called. + /// is null or is null. + public void DrawString(BitmapFont bitmapFont, StringBuilder text, ref Matrix2 transformMatrix, + Color? color = null, FlipFlags flags = FlipFlags.None, float depth = 0f) + { + EnsureHasBegun(); + + if (bitmapFont == null) + throw new ArgumentNullException(nameof(bitmapFont)); + + if (text == null) + throw new ArgumentNullException(nameof(text)); + + var lineSpacing = bitmapFont.LineHeight; + var offset = new Vector2(0, 0); + + BitmapFontRegion lastGlyph = null; + for (var i = 0; i < text.Length;) + { + int character; + if (char.IsLowSurrogate(text[i])) + { + character = char.ConvertToUtf32(text[i - 1], text[i]); + i += 2; + } + else if (char.IsHighSurrogate(text[i])) + { + character = char.ConvertToUtf32(text[i], text[i - 1]); + i += 2; + } + else + { + character = text[i]; + i += 1; + } + + // ReSharper disable once SwitchStatementMissingSomeCases + switch (character) + { + case '\r': + continue; + case '\n': + offset.X = 0; + offset.Y += lineSpacing; + lastGlyph = null; + continue; + } + + var fontRegion = bitmapFont.GetCharacterRegion(character); + if (fontRegion == null) + continue; + + var transform1Matrix = transformMatrix; + transform1Matrix.M31 += offset.X + fontRegion.XOffset; + transform1Matrix.M32 += offset.Y + fontRegion.YOffset; + + var textureRegion = fontRegion.TextureRegion; + var bounds = textureRegion.Bounds; + DrawSprite(textureRegion.Texture, ref transform1Matrix, ref bounds, color, flags, depth); + + var advance = fontRegion.XAdvance + bitmapFont.LetterSpacing; + if (BitmapFont.UseKernings && lastGlyph != null) + { + int amount; + if (lastGlyph.Kernings.TryGetValue(character, out amount)) + { + advance += amount; + } + } + + offset.X += i != text.Length - 1 + ? advance + : fontRegion.XOffset + fontRegion.Width; + + lastGlyph = fontRegion; + } + } + + /// + /// Draws unicode (UTF-16) characters as sprites using the specified , text + /// , position and optional , rotation + /// , origin , scale , and + /// depth . + /// + /// The . + /// The text . + /// The position . + /// + /// The . Use null to use the default + /// . + /// + /// + /// The angle (in radians) to rotate each sprite about its . The default + /// value is 0f. + /// + /// + /// The origin . Use null to use the default + /// . + /// + /// + /// The scale . Use null to use the default + /// . + /// + /// The . The default value is . + /// The depth . The default value is 0f + /// The method has not been called. + /// is null or is null. + public void DrawString(BitmapFont bitmapFont, StringBuilder text, Vector2 position, Color? color = null, + float rotation = 0f, Vector2? origin = null, Vector2? scale = null, + FlipFlags flags = FlipFlags.None, float depth = 0f) + { + Matrix2 transformMatrix; + Matrix2.CreateFrom(position, rotation, scale, origin, out transformMatrix); + DrawString(bitmapFont, text, ref transformMatrix, color, flags, depth); + } + + /// + /// Draws unicode (UTF-16) characters as sprites using the specified , text + /// , transform and optional , origin + /// , , and depth . + /// + /// The . + /// The text . + /// The transform . + /// + /// The . Use null to use the default + /// . + /// + /// The . The default value is . + /// The depth . The default value is 0f + /// The method has not been called. + /// is null or is null. + public void DrawString(BitmapFont bitmapFont, string text, ref Matrix2 transformMatrix, Color? color = null, + FlipFlags flags = FlipFlags.None, float depth = 0f) + { + EnsureHasBegun(); + + if (bitmapFont == null) + throw new ArgumentNullException(nameof(bitmapFont)); + + if (text == null) + throw new ArgumentNullException(nameof(text)); + + var glyphs = bitmapFont.GetGlyphs(text); + foreach (var glyph in glyphs) + { + var transform1Matrix = transformMatrix; + transform1Matrix.M31 += glyph.Position.X; + transform1Matrix.M32 += glyph.Position.Y; + + var texture = glyph.FontRegion.TextureRegion.Texture; + var bounds = texture.Bounds; + DrawSprite(texture, ref transform1Matrix, ref bounds, color, flags, depth); + } + } + + /// + /// Draws unicode (UTF-16) characters as sprites using the specified , text + /// , position and optional , rotation + /// , origin , scale , and + /// depth . + /// + /// The . + /// The text . + /// The position . + /// + /// The . Use null to use the default + /// . + /// + /// + /// The angle (in radians) to rotate each sprite about its . The default + /// value is 0f. + /// + /// + /// The origin . Use null to use the default + /// . + /// + /// + /// The scale . Use null to use the default + /// . + /// + /// The . The default value is . + /// The depth . The default value is 0f + /// The method has not been called. + /// is null or is null. + public void DrawString(BitmapFont bitmapFont, string text, Vector2 position, Color? color = null, + float rotation = 0f, Vector2? origin = null, Vector2? scale = null, + FlipFlags flags = FlipFlags.None, float depth = 0f) + { + Matrix2 matrix; + Matrix2.CreateFrom(position, rotation, scale, origin, out matrix); + DrawString(bitmapFont, text, ref matrix, color, flags, depth); + } + + [StructLayout(LayoutKind.Sequential, Pack = 1)] + [EditorBrowsable(EditorBrowsableState.Never)] + public struct DrawCallInfo : IBatchDrawCallInfo, IComparable + { + internal readonly PrimitiveType PrimitiveType; + internal int StartIndex; + internal int PrimitiveCount; + internal readonly Texture2D Texture; + internal readonly uint TextureKey; + internal readonly uint DepthKey; + + internal unsafe DrawCallInfo(Texture2D texture, PrimitiveType primitiveType, int startIndex, int primitiveCount, float depth) + { + PrimitiveType = primitiveType; + StartIndex = startIndex; + PrimitiveCount = primitiveCount; + Texture = texture; + TextureKey = (uint)RuntimeHelpers.GetHashCode(texture); + DepthKey = *(uint*)&depth; + } + + public void SetState(Effect effect) + { + var textureEffect = effect as ITextureEffect; + if (textureEffect != null) + textureEffect.Texture = Texture; + } + + public bool TryMerge(ref DrawCallInfo drawCall) + { + if (PrimitiveType != drawCall.PrimitiveType || TextureKey != drawCall.TextureKey || + DepthKey != drawCall.DepthKey) + return false; + drawCall.PrimitiveCount += PrimitiveCount; + return true; + } + + [SuppressMessage("ReSharper", "ImpureMethodCallOnReadonlyValueField")] + public int CompareTo(DrawCallInfo other) + { + var result = TextureKey.CompareTo(other.TextureKey);; + if (result != 0) + return result; + result = DepthKey.CompareTo(other.DepthKey); + return result != 0 ? result : ((byte)PrimitiveType).CompareTo((byte)other.PrimitiveType); + } + } + } +} \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/DefaultEffect.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/DefaultEffect.cs new file mode 100644 index 0000000..df71e47 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/DefaultEffect.cs @@ -0,0 +1,203 @@ +using System.Collections.Specialized; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics.Effects +{ + /// + /// An that allows objects, within a 3D context, to be represented on a 2D monitor. + /// + /// + /// + public class DefaultEffect : MatrixChainEffect, ITextureEffect + { + /// + /// The bitmask for use with indicating wether has + /// changed in the last frame. + /// + protected static int DirtyTextureBitMask = BitVector32.CreateMask(UseDefaultProjectionBitMask); + + /// + /// The bitmask for use with indicating wether the underlying vertex shader and + /// fragment (pixel) shaders have changed to one of the pre-defined shaders in the last frame. + /// + protected static int DirtyShaderIndexBitMask = BitVector32.CreateMask(DirtyTextureBitMask); + + /// + /// The bitmask for use with indicating wether the material color has changed in + /// the last frame. + /// + public static int DirtyMaterialColorBitMask = BitVector32.CreateMask(DirtyShaderIndexBitMask); + + private Texture2D _texture; + private EffectParameter _textureParameter; + + private float _alpha = 1; + private Color _diffuseColor = Color.White; + private EffectParameter _diffuseColorParameter; + + private bool _textureEnabled; + private bool _vertexColorEnabled; + + /// + /// Gets or sets the material . + /// + /// + /// The material . + /// + public Texture2D Texture + { + get { return _texture; } + set + { + _texture = value; + Flags[DirtyTextureBitMask] = true; + } + } + + /// + /// Gets or sets the material color alpha. + /// + /// + /// + /// The alpha channel uses the premultiplied (associated) representation. This means that the RGB components of a + /// color represent + /// the color of the object of pixel, adjusted for its opacity by multiplication of . + /// + /// + public float Alpha + { + get { return _alpha; } + + set + { + _alpha = value; + Flags[DirtyMaterialColorBitMask] = true; + } + } + + /// + /// Gets or sets whether texturing is enabled. + /// + public bool TextureEnabled + { + get { return _textureEnabled; } + + set + { + if (_textureEnabled == value) + return; + _textureEnabled = value; + Flags[DirtyShaderIndexBitMask] = true; + } + } + + /// + /// Gets or sets whether vertex color is enabled. + /// + public bool VertexColorEnabled + { + get { return _vertexColorEnabled; } + + set + { + if (_vertexColorEnabled == value) + return; + _vertexColorEnabled = value; + Flags[DirtyShaderIndexBitMask] = true; + } + } + + /// + /// Initializes a new instance of the class. + /// + /// The graphics device. + public DefaultEffect(GraphicsDevice graphicsDevice) + : base(graphicsDevice, EffectResource.DefaultEffect.Bytecode) + { + Initialize(); + } + + /// + /// Initializes a new instance of the class. + /// + /// The graphics device. + /// The byte code of the shader program. + public DefaultEffect(GraphicsDevice graphicsDevice, byte[] byteCode) + : base(graphicsDevice, byteCode) + { + Initialize(); + } + + /// + /// Initializes a new instance of the class. + /// + /// The clone source. + public DefaultEffect(Effect cloneSource) + : base(cloneSource) + { + Initialize(); + } + + private void Initialize() + { + Flags[DirtyMaterialColorBitMask] = true; + _textureParameter = Parameters["Texture"]; + _diffuseColorParameter = Parameters["DiffuseColor"]; + } + + /// + /// Computes derived parameter values immediately before applying the effect. + /// + protected override void OnApply() + { + base.OnApply(); + + if (Flags[DirtyTextureBitMask]) + { + _textureParameter.SetValue(_texture); + Flags[DirtyTextureBitMask] = false; + } + + // ReSharper disable once InvertIf + if (Flags[DirtyMaterialColorBitMask]) + { + UpdateMaterialColor(); + Flags[DirtyMaterialColorBitMask] = false; + } + + // ReSharper disable once InvertIf + if (Flags[DirtyShaderIndexBitMask]) + { + var shaderIndex = 0; + + if (_textureEnabled) + shaderIndex += 1; + + if (_vertexColorEnabled) + shaderIndex += 2; + + Flags[DirtyShaderIndexBitMask] = false; + CurrentTechnique = Techniques[shaderIndex]; + } + } + + /// + /// Updates the material color parameters associated with this . + /// + protected virtual void UpdateMaterialColor() + { + var diffuseColorVector3 = _diffuseColor.ToVector3(); + + var diffuseColorVector4 = new Vector4() + { + X = diffuseColorVector3.X * Alpha, + Y = diffuseColorVector3.Y * Alpha, + Z = diffuseColorVector3.Z * Alpha, + W = Alpha, + }; + + _diffuseColorParameter.SetValue(diffuseColorVector4); + } + } +} \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/EffectResource.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/EffectResource.cs new file mode 100644 index 0000000..43bd535 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/EffectResource.cs @@ -0,0 +1,119 @@ +using System; +using System.Diagnostics; +using System.IO; +using System.Reflection; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics.Effects +{ + /// + /// Reperesents the bytecode of an that is encapsulated inside a compiled assembly. + /// + /// + /// + /// Files that are encapsulated inside a compiled assembly are commonly known as Manifiest or embedded resources. + /// Since embedded resources are added to the assembly at compiled time, they can not be accidentally deleted or + /// misplaced. However, if the file needs to be changed, the assembly will need to be re-compiled with the changed + /// file. + /// + /// + /// To add an embedded resource file to an assembly, first add it to the project and then change the Build Action + /// in the Properties of the file to Embedded Resource. The next time the project is compiled, the + /// compiler will add the file to the assembly as an embedded resource. The compiler adds namespace(s) to the + /// embedded resource so it matches with the path of where the file was added to the project. + /// + /// + public class EffectResource + { + private static EffectResource _defaultEffect; + private static string _shaderExtension; + + /// + /// Gets the embedded into the MonoGame.Extended.Graphics library. + /// + public static EffectResource DefaultEffect => _defaultEffect ?? (_defaultEffect = new EffectResource($"MonoGame.Extended.Graphics.Effects.Resources.DefaultEffect.{_shaderExtension}.mgfxo")); + + static EffectResource() + { + DetermineShaderExtension(); + } + + private static void DetermineShaderExtension() + { + // use reflection to figure out if Shader.Profile is OpenGL (0) or DirectX (1), + // may need to be changed / fixed for future shader profiles + + var assembly = typeof(Game).GetTypeInfo().Assembly; + Debug.Assert(assembly != null); + + var shaderType = assembly.GetType("Microsoft.Xna.Framework.Graphics.Shader"); + Debug.Assert(shaderType != null); + var shaderTypeInfo = shaderType.GetTypeInfo(); + Debug.Assert(shaderTypeInfo != null); + + // https://github.com/MonoGame/MonoGame/blob/develop/MonoGame.Framework/Graphics/Shader/Shader.cs#L47 + var profileProperty = shaderTypeInfo.GetDeclaredProperty("Profile"); + var value = (int)profileProperty.GetValue(null); + + switch (value) + { + case 0: + // OpenGL + _shaderExtension = "ogl"; + break; + case 1: + // DirectX + _shaderExtension = "dx11"; + break; + default: + throw new InvalidOperationException("Unknown shader profile."); + } + } + + private readonly string _resourceName; + private volatile byte[] _bytecode; + private readonly Assembly _assembly; + + /// + /// Gets the bytecode of the file. + /// + /// + /// The bytecode of the file. + /// + public byte[] Bytecode + { + get + { + if (_bytecode != null) + return _bytecode; + + lock (this) + { + if (_bytecode != null) + return _bytecode; + + var stream = _assembly.GetManifestResourceStream(_resourceName); + using (var memoryStream = new MemoryStream()) + { + stream.CopyTo(memoryStream); + _bytecode = memoryStream.ToArray(); + } + } + + return _bytecode; + } + } + + /// + /// Initializes a new instance of the class. + /// + /// The name of the embedded resource. This must include the namespace(s). + /// The assembly which the embedded resource is apart of. + public EffectResource(string resourceName, Assembly assembly = null) + { + _resourceName = resourceName; + _assembly = assembly ?? typeof(EffectResource).GetTypeInfo().Assembly; + } + } +} \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/ITextureEffect.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/ITextureEffect.cs new file mode 100644 index 0000000..ea2ef0b --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/ITextureEffect.cs @@ -0,0 +1,18 @@ +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics.Effects +{ + /// + /// Defines an that uses a . + /// + public interface ITextureEffect + { + /// + /// Gets or sets the . + /// + /// + /// The . + /// + Texture2D Texture { get; set; } + } +} \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/MatrixChainEffect.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/MatrixChainEffect.cs new file mode 100644 index 0000000..046479f --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/MatrixChainEffect.cs @@ -0,0 +1,155 @@ +using System.Collections.Specialized; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics.Effects +{ + /// + /// An that uses the standard chain of matrix transformations to represent a 3D object on a 2D + /// monitor. + /// + /// + /// + public abstract class MatrixChainEffect : Effect, IMatrixChainEffect + { + /// + /// The bitmask for use with indicating wether , , or has changed in the last frame. + /// + protected static int DirtyWorldViewProjectionBitMask = BitVector32.CreateMask(); + + /// + /// The bitmask for use with indicating wether to use a default projection matrix or a custom projection matrix. + /// + protected static int UseDefaultProjectionBitMask = BitVector32.CreateMask(DirtyWorldViewProjectionBitMask); + + /// + /// The dirty flags associated with this . + /// + protected BitVector32 Flags; + + private Matrix _projection = Matrix.Identity; + private Matrix _view = Matrix.Identity; + private Matrix _world = Matrix.Identity; + private EffectParameter _matrixParameter; + + /// + /// Gets or sets the model-to-world . + /// + /// + /// The model-to-world . + /// + public Matrix World + { + get { return _world; } + set { SetWorld(ref value); } + } + + /// + /// Gets or sets the world-to-view . + /// + /// + /// The world-to-view . + /// + public Matrix View + { + get { return _view; } + set { SetView(ref value); } + } + + /// + /// Gets or sets the view-to-projection . + /// + /// + /// The view-to-projection . + /// + public Matrix Projection + { + get { return _projection; } + set { SetProjection(ref value); } + } + + /// + /// Initializes a new instance of the class. + /// + /// The graphics device. + /// The effect code. + protected MatrixChainEffect(GraphicsDevice graphicsDevice, byte[] byteCode) + : base(graphicsDevice, byteCode) + { + Initialize(); + } + + /// + /// Initializes a new instance of the class. + /// + /// The clone source. + protected MatrixChainEffect(Effect cloneSource) + : base(cloneSource) + { + Initialize(); + } + + private void Initialize() + { + Flags[UseDefaultProjectionBitMask] = true; + + _matrixParameter = Parameters["WorldViewProjection"]; + } + + /// + /// Sets the model-to-world . + /// + /// The model-to-world . + public void SetWorld(ref Matrix world) + { + _world = world; + Flags[DirtyWorldViewProjectionBitMask] = true; + } + + /// + /// Sets the world-to-view . + /// + /// The world-to-view . + public void SetView(ref Matrix view) + { + _view = view; + Flags[DirtyWorldViewProjectionBitMask] = true; + } + + /// + /// Sets the view-to-projection . + /// + /// The view-to-projection . + public void SetProjection(ref Matrix projection) + { + _projection = projection; + Flags[DirtyWorldViewProjectionBitMask] = true; + Flags[UseDefaultProjectionBitMask] = false; + } + + /// + /// Computes derived parameter values immediately before applying the effect. + /// + protected override void OnApply() + { + base.OnApply(); + + // ReSharper disable once InvertIf + if (Flags[DirtyWorldViewProjectionBitMask] || Flags[UseDefaultProjectionBitMask]) + { + if (Flags[UseDefaultProjectionBitMask]) + { + var viewport = GraphicsDevice.Viewport; + _projection = Matrix.CreateOrthographicOffCenter(0, viewport.Width, viewport.Height, 0, 0, -1); + } + + Matrix worldViewProjection; + Matrix.Multiply(ref _world, ref _view, out worldViewProjection); + Matrix.Multiply(ref worldViewProjection, ref _projection, out worldViewProjection); + _matrixParameter.SetValue(worldViewProjection); + + Flags[DirtyWorldViewProjectionBitMask] = false; + } + } + } +} \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.dx11.mgfxo b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.dx11.mgfxo new file mode 100644 index 0000000..b83b6ed Binary files /dev/null and b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.dx11.mgfxo differ diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.fx b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.fx new file mode 100644 index 0000000..30a772d --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.fx @@ -0,0 +1,72 @@ +#include "Macros.fxh" +#include "Structures.fxh" + +DECLARE_TEXTURE(Texture, 0); + +BEGIN_CONSTANTS + +float4 DiffuseColor = float4(1, 1, 1, 1); + +MATRIX_CONSTANTS + +float4x4 WorldViewProjection _vs(c0) _cb(c0); + +END_CONSTANTS + +VertexShaderOutputPosition VertexShaderFunctionPosition(VertexShaderInputPosition input) +{ + VertexShaderOutputPosition output; + output.Position = mul(input.Position, WorldViewProjection); + return output; +} + +float4 PixelShaderFunctionPosition(VertexShaderOutputPosition input) : SV_Target0 +{ + return DiffuseColor; +} + +VertexShaderOutputPositionTexture VertexShaderFunctionPositionTexture(VertexShaderInputPositionTexture input) +{ + VertexShaderOutputPositionTexture output; + output.Position = mul(input.Position, WorldViewProjection); + output.TextureCoordinate = input.TextureCoordinate; + return output; +} + +float4 PixelShaderFunctionPositionTexture(VertexShaderOutputPositionTexture input) : SV_Target0 +{ + return SAMPLE_TEXTURE(Texture, input.TextureCoordinate) * DiffuseColor; +} + +VertexShaderOutputPositionColor VertexShaderFunctionPositionColor(VertexShaderInputPositionColor input) +{ + VertexShaderOutputPositionColor output; + output.Position = mul(input.Position, WorldViewProjection); + output.Color = input.Color; + return output; +} + +float4 PixelShaderFunctionPositionColor(VertexShaderOutputPositionColor input) : SV_Target0 +{ + return input.Color * DiffuseColor; +} + +VertexShaderOutputPositionColorTexture VertexShaderFunctionPositionColorTexture(VertexShaderInputPositionColorTexture input) +{ + VertexShaderOutputPositionColorTexture output; + output.Position = mul(input.Position, WorldViewProjection); + output.Color = input.Color; + output.TextureCoordinate = input.TextureCoordinate; + return output; +} + +float4 PixelShaderFunctionPositionColorTexture(VertexShaderOutputPositionColorTexture input) : SV_Target0 +{ + float4 textureColor = SAMPLE_TEXTURE(Texture, input.TextureCoordinate); + return textureColor * input.Color * DiffuseColor; +} + +TECHNIQUE(Position, VertexShaderFunctionPosition, PixelShaderFunctionPosition); +TECHNIQUE(PositionTexture, VertexShaderFunctionPositionTexture, PixelShaderFunctionPositionTexture); +TECHNIQUE(PositionColor, VertexShaderFunctionPositionColor, PixelShaderFunctionPositionColor); +TECHNIQUE(PositionColorTexture, VertexShaderFunctionPositionColorTexture, PixelShaderFunctionPositionColorTexture); \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.ogl.mgfxo b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.ogl.mgfxo new file mode 100644 index 0000000..4f51d2a Binary files /dev/null and b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/DefaultEffect.ogl.mgfxo differ diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Macros.fxh b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Macros.fxh new file mode 100644 index 0000000..c253efe --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Macros.fxh @@ -0,0 +1,60 @@ +//----------------------------------------------------------------------------- +// Macros.fxh +// +// Microsoft XNA Community Game Platform +// Copyright (C) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- + +#if SM4 + +// Macros for targetting shader model 4.0 (DX11) + +#define TECHNIQUE(name, vsname, psname ) \ + technique name { pass { VertexShader = compile vs_4_0_level_9_1 vsname (); PixelShader = compile ps_4_0_level_9_1 psname(); } } + +#define BEGIN_CONSTANTS cbuffer Parameters : register(b0) { +#define MATRIX_CONSTANTS +#define END_CONSTANTS }; + +#define _vs(r) +#define _ps(r) +#define _cb(r) + +#define DECLARE_TEXTURE(Name, index) \ + Texture2D Name : register(t##index); \ + sampler Name##Sampler : register(s##index) + +#define DECLARE_CUBEMAP(Name, index) \ + TextureCube Name : register(t##index); \ + sampler Name##Sampler : register(s##index) + +#define SAMPLE_TEXTURE(Name, texCoord) Name.Sample(Name##Sampler, texCoord) +#define SAMPLE_CUBEMAP(Name, texCoord) Name.Sample(Name##Sampler, texCoord) + + +#else + +// Macros for targetting shader model 2.0 (DX9) + +#define TECHNIQUE(name, vsname, psname ) \ + technique name { pass { VertexShader = compile vs_2_0 vsname (); PixelShader = compile ps_2_0 psname(); } } + +#define BEGIN_CONSTANTS +#define MATRIX_CONSTANTS +#define END_CONSTANTS + +#define _vs(r) : register(vs, r) +#define _ps(r) : register(ps, r) +#define _cb(r) + +#define DECLARE_TEXTURE(Name, index) \ + sampler2D Name : register(s##index); + +#define DECLARE_CUBEMAP(Name, index) \ + samplerCUBE Name : register(s##index); + +#define SAMPLE_TEXTURE(Name, texCoord) tex2D(Name, texCoord) +#define SAMPLE_CUBEMAP(Name, texCoord) texCUBE(Name, texCoord) + + +#endif \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/RebuildEffects.bat b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/RebuildEffects.bat new file mode 100644 index 0000000..4fc7f21 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/RebuildEffects.bat @@ -0,0 +1,15 @@ +setlocal + +SET TWOMGFX="mgfxc" + +@for /f %%f IN ('dir /b *.fx') do ( + + call %TWOMGFX% %%~nf.fx %%~nf.ogl.mgfxo /Profile:OpenGL + + call %TWOMGFX% %%~nf.fx %%~nf.dx11.mgfxo /Profile:DirectX_11 + +) + +endlocal + +pause \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Structures.fxh b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Structures.fxh new file mode 100644 index 0000000..d3af6a0 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Effects/Resources/Structures.fxh @@ -0,0 +1,51 @@ +// Vertex shader input structures. + +struct VertexShaderInputPosition +{ + float4 Position : SV_Position; +}; + +struct VertexShaderInputPositionColor +{ + float4 Position : SV_Position; + float4 Color : COLOR; +}; + +struct VertexShaderInputPositionTexture +{ + float4 Position : SV_Position; + float2 TextureCoordinate : TEXCOORD0; +}; + +struct VertexShaderInputPositionColorTexture +{ + float4 Position : SV_Position; + float4 Color : COLOR; + float2 TextureCoordinate : TEXCOORD0; +}; + +// Vertex shader output structures. + +struct VertexShaderOutputPosition +{ + float4 Position : SV_Position; +}; + +struct VertexShaderOutputPositionColor +{ + float4 Position : SV_Position; + float4 Color : COLOR0; +}; + +struct VertexShaderOutputPositionTexture +{ + float4 Position : SV_Position; + float2 TextureCoordinate : TEXCOORD0; +}; + +struct VertexShaderOutputPositionColorTexture +{ + float4 Position : SV_Position; + float4 Color : COLOR0; + float2 TextureCoordinate : TEXCOORD0; +}; diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/FlipFlags.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/FlipFlags.cs new file mode 100644 index 0000000..6c19887 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/FlipFlags.cs @@ -0,0 +1,13 @@ +using System; + +namespace MonoGame.Extended.Graphics +{ + [Flags] + public enum FlipFlags : byte + { + None = 0, + FlipDiagonally = 1 << 0, + FlipVertically = 1 << 1, + FlipHorizontally = 1 << 2 + } +} diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Geometry/GeometryBuilder.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Geometry/GeometryBuilder.cs new file mode 100644 index 0000000..dad4f15 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Geometry/GeometryBuilder.cs @@ -0,0 +1,24 @@ +using System; +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics.Geometry +{ + public abstract class GeometryBuilder + where TVertexType : struct, IVertexType + where TIndexType : struct + { + public PrimitiveType PrimitiveType { get; protected set; } + public int VertexCount { get; protected set; } + public int IndexCount { get; protected set; } + public int PrimitivesCount { get; protected set; } + + public TVertexType[] Vertices { get; } + public TIndexType[] Indices { get; } + + protected GeometryBuilder(int maximumVerticesCount, int maximumIndicesCount) + { + Vertices = new TVertexType[maximumVerticesCount]; + Indices = new TIndexType[maximumIndicesCount]; + } + } +} diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Geometry/GeometryBuilder2D.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Geometry/GeometryBuilder2D.cs new file mode 100644 index 0000000..c113fbe --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/Geometry/GeometryBuilder2D.cs @@ -0,0 +1,119 @@ +using System; +using System.Runtime.CompilerServices; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics.Geometry +{ + public class GeometryBuilder2D : GeometryBuilder + { + public GeometryBuilder2D(int maximumVerticesCount, int maximumIndicesCount) + : base(maximumVerticesCount, maximumIndicesCount) + { + } + + public void BuildSprite(int indexOffset, ref Matrix2 transformMatrix, Texture2D texture, + ref Rectangle sourceRectangle, + Color? color = null, FlipFlags flags = FlipFlags.None, float depth = 0) + { + if (texture == null) + throw new ArgumentNullException(nameof(texture)); + + var texelLeft = 0f; + var texelTop = 0f; + var texelRight = 1f; + var texelBottom = 1f; + + if (sourceRectangle.Width > 0) + { + texelLeft = (float)sourceRectangle.X / texture.Width; + texelTop = (float)sourceRectangle.Y / texture.Height; + texelRight = (sourceRectangle.X + sourceRectangle.Width) / (float)texture.Width; + texelBottom = (sourceRectangle.Y + sourceRectangle.Height) / (float)texture.Height; + } + else + { + sourceRectangle.Width = texture.Width; + sourceRectangle.Height = texture.Height; + } + + var color1 = color ?? Color.White; + + var vertices = Vertices; + + transformMatrix.Transform(0, 0, ref vertices[0].Position); + vertices[0].Position.Z = depth; + vertices[0].Color = color1; + vertices[0].TextureCoordinate.X = texelLeft; + vertices[0].TextureCoordinate.Y = texelTop; + + transformMatrix.Transform(sourceRectangle.Width, 0, ref vertices[1].Position); + vertices[1].Position.Z = depth; + vertices[1].Color = color1; + vertices[1].TextureCoordinate.X = texelRight; + vertices[1].TextureCoordinate.Y = texelTop; + + transformMatrix.Transform(0, sourceRectangle.Height, ref vertices[2].Position); + vertices[2].Position.Z = depth; + vertices[2].Color = color1; + vertices[2].TextureCoordinate.X = texelLeft; + vertices[2].TextureCoordinate.Y = texelBottom; + + transformMatrix.Transform(sourceRectangle.Width, sourceRectangle.Height, ref vertices[3].Position); + vertices[3].Position.Z = depth; + vertices[3].Color = color1; + vertices[3].TextureCoordinate.X = texelRight; + vertices[3].TextureCoordinate.Y = texelBottom; + + var flipDiagonally = (flags & FlipFlags.FlipDiagonally) != 0; + var flipHorizontally = (flags & FlipFlags.FlipHorizontally) != 0; + var flipVertically = (flags & FlipFlags.FlipVertically) != 0; + + if (flipDiagonally) + { + FloatHelper.Swap(ref vertices[1].TextureCoordinate.X, ref vertices[2].TextureCoordinate.X); + FloatHelper.Swap(ref vertices[1].TextureCoordinate.Y, ref vertices[2].TextureCoordinate.Y); + } + + if (flipHorizontally) + if (flipDiagonally) + { + FloatHelper.Swap(ref vertices[0].TextureCoordinate.Y, ref vertices[1].TextureCoordinate.Y); + FloatHelper.Swap(ref vertices[2].TextureCoordinate.Y, ref vertices[3].TextureCoordinate.Y); + } + else + { + FloatHelper.Swap(ref vertices[0].TextureCoordinate.X, ref vertices[1].TextureCoordinate.X); + FloatHelper.Swap(ref vertices[2].TextureCoordinate.X, ref vertices[3].TextureCoordinate.X); + } + + if (flipVertically) + if (flipDiagonally) + { + FloatHelper.Swap(ref vertices[0].TextureCoordinate.X, ref vertices[2].TextureCoordinate.X); + FloatHelper.Swap(ref vertices[1].TextureCoordinate.X, ref vertices[3].TextureCoordinate.X); + } + else + { + FloatHelper.Swap(ref vertices[0].TextureCoordinate.Y, ref vertices[2].TextureCoordinate.Y); + FloatHelper.Swap(ref vertices[1].TextureCoordinate.Y, ref vertices[3].TextureCoordinate.Y); + } + + VertexCount = 4; + AddQuadrilateralIndices(indexOffset); + IndexCount = 6; + PrimitivesCount = 2; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private void AddQuadrilateralIndices(int indexOffset) + { + Indices[0] = (ushort)(0 + indexOffset); + Indices[1] = (ushort)(1 + indexOffset); + Indices[2] = (ushort)(2 + indexOffset); + Indices[3] = (ushort)(1 + indexOffset); + Indices[4] = (ushort)(3 + indexOffset); + Indices[5] = (ushort)(2 + indexOffset); + } + } +} diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/IBatchDrawCallInfo.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/IBatchDrawCallInfo.cs new file mode 100644 index 0000000..67c4755 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/IBatchDrawCallInfo.cs @@ -0,0 +1,19 @@ +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics +{ + /// + /// Defines the for a deferred draw call when batching. + /// + public interface IBatchDrawCallInfo where TDrawCallInfo : IBatchDrawCallInfo + { + /// + /// Applies any state from the to the + /// or . + /// + /// The effect. + void SetState(Effect effect); + + bool TryMerge(ref TDrawCallInfo drawCall); + } +} \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/IMatrixChainEffect.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/IMatrixChainEffect.cs new file mode 100644 index 0000000..da8ccb9 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/IMatrixChainEffect.cs @@ -0,0 +1,30 @@ +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics +{ + /// + /// Defines an that uses the standard chain of matrix transformations to represent a 3D object on + /// a 2D monitor. + /// + public interface IMatrixChainEffect : IEffectMatrices + { + /// + /// Sets the model-to-world . + /// + /// The model-to-world . + void SetWorld(ref Matrix world); + + /// + /// Sets the world-to-view . + /// + /// The world-to-view . + void SetView(ref Matrix view); + + /// + /// Sets the view-to-projection . + /// + /// The view-to-projection . + void SetProjection(ref Matrix projection); + } +} \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/MonoGame.Extended.Graphics.csproj b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/MonoGame.Extended.Graphics.csproj new file mode 100644 index 0000000..fd25850 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/MonoGame.Extended.Graphics.csproj @@ -0,0 +1,28 @@ + + + + Graphics makes MonoGame more awesome. + monogame graphics batcher effects + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/PrimitiveTypeExtensions.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/PrimitiveTypeExtensions.cs new file mode 100644 index 0000000..68a39ef --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/PrimitiveTypeExtensions.cs @@ -0,0 +1,42 @@ +using System; +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics +{ + public static class PrimitiveTypeExtensions + { + internal static int GetPrimitivesCount(this PrimitiveType primitiveType, int verticesCount) + { + switch (primitiveType) + { + case PrimitiveType.LineStrip: + return verticesCount - 1; + case PrimitiveType.LineList: + return verticesCount/2; + case PrimitiveType.TriangleStrip: + return verticesCount - 2; + case PrimitiveType.TriangleList: + return verticesCount/3; + default: + throw new ArgumentException("Invalid primitive type."); + } + } + + internal static int GetVerticesCount(this PrimitiveType primitiveType, int primitivesCount) + { + switch (primitiveType) + { + case PrimitiveType.LineStrip: + return primitivesCount + 1; + case PrimitiveType.LineList: + return primitivesCount*2; + case PrimitiveType.TriangleStrip: + return primitivesCount + 2; + case PrimitiveType.TriangleList: + return primitivesCount*3; + default: + throw new ArgumentException("Invalid primitive type."); + } + } + } +} \ No newline at end of file diff --git a/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/RenderTarget2DExtensions.cs b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/RenderTarget2DExtensions.cs new file mode 100644 index 0000000..f090603 --- /dev/null +++ b/Plugins/MonoGame.Extended/source/MonoGame.Extended.Graphics/RenderTarget2DExtensions.cs @@ -0,0 +1,41 @@ +using System; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace MonoGame.Extended.Graphics +{ + public static class RenderTarget2DExtensions + { + public static IDisposable BeginDraw(this RenderTarget2D renderTarget, GraphicsDevice graphicsDevice, + Color backgroundColor) + { + return new RenderTargetOperation(renderTarget, graphicsDevice, backgroundColor); + } + + private class RenderTargetOperation : IDisposable + { + private readonly GraphicsDevice _graphicsDevice; + private readonly RenderTargetUsage _previousRenderTargetUsage; + private readonly Viewport _viewport; + + public RenderTargetOperation(RenderTarget2D renderTarget, GraphicsDevice graphicsDevice, + Color backgroundColor) + { + _graphicsDevice = graphicsDevice; + _viewport = _graphicsDevice.Viewport; + _previousRenderTargetUsage = _graphicsDevice.PresentationParameters.RenderTargetUsage; + + _graphicsDevice.PresentationParameters.RenderTargetUsage = RenderTargetUsage.PreserveContents; + _graphicsDevice.SetRenderTarget(renderTarget); + _graphicsDevice.Clear(backgroundColor); + } + + public void Dispose() + { + _graphicsDevice.SetRenderTarget(null); + _graphicsDevice.PresentationParameters.RenderTargetUsage = _previousRenderTargetUsage; + _graphicsDevice.Viewport = _viewport; + } + } + } +} \ No newline at end of file -- cgit v1.1-26-g67d0