[Native] - Implement some existing C++ methods in C#

sources/engine/Stride.Graphics/FastTextRenderer.cs

@@ -16,6 +16,14 @@ namespace Stride.Graphics
     /// </summary>
     public class FastTextRenderer : ComponentBase
     {
+        private static readonly VertexPositionNormalTexture[] BaseVertexBufferData =
+        {
+            // Position		Normal		UV Coordinates
+            new( new(-1, 1, 0), new(0, 0, 1), new(0, 0) ),
+            new( new(1, 1, 0 ), new(0, 0, 1 ), new(1, 0 )),
+            new( new(-1, -1, 0 ), new(0, 0, 1 ), new(0, 1 )),
+            new( new(1, -1, 0 ), new(0, 0, 1 ), new(1, 1 )),
+        };
         private const int VertexBufferCount = 2;
 
         private const int IndexStride = sizeof(int);
@@ -212,11 +220,9 @@ public unsafe void End([NotNull] GraphicsContext graphicsContext)
                 foreach (var textInfo in stringsToDraw)
                 {
                     var textLength = textInfo.Text.Length;
-                    var textLengthPointer = new IntPtr(&textLength);
-
-                    Native.NativeInvoke.xnGraphicsFastTextRendererGenerateVertices(constantInfos, textInfo.RenderingInfo, textInfo.Text, out textLengthPointer, out mappedVertexBufferPointer);
+                    GraphicsFastTextRendererGenerateVertices(constantInfos, textInfo.RenderingInfo, textInfo.Text, ref textLength,  mappedVertexBufferPointer);
 
-                    charsToRenderCount += *(int*)textLengthPointer.ToPointer();
+                    charsToRenderCount += textLength;
                 }
             }
 
@@ -247,6 +253,97 @@ public unsafe void End([NotNull] GraphicsContext graphicsContext)
             graphicsContext.CommandList.DrawIndexed(charsToRenderCount * 6);
         }
 
+        public unsafe void GraphicsFastTextRendererGenerateVertices(RectangleF constantInfos, RectangleF renderInfos, string textPointer, ref int textLength, IntPtr vertexBufferPointer)
+        {
+            var vertexBuffer = (VertexPositionNormalTexture**)vertexBufferPointer;
+
+            float fX = renderInfos.X / renderInfos.Width;
+            float fY = renderInfos.Y / renderInfos.Height;
+            float fW = constantInfos.X / renderInfos.Width;
+            float fH = constantInfos.Y / renderInfos.Height;
+
+            RectangleF destination = new(fX, fY, fW, fH);
+            RectangleF source = new(0.0f, 0.0f, constantInfos.X, constantInfos.Y);
+
+            // Copy the array length (since it may change during an iteration)
+            int textCharCount = textLength;
+
+            float scaledDestinationX = 0.0f;
+            float scaledDestinationY = -(destination.Y * 2.0f - 1.0f);
+
+            float invertedWidth = 1.0f / constantInfos.Width;
+            float invertedHeight = 1.0f / constantInfos.Height;
+
+            for (int i = 0; i < textCharCount; i++)
+            {
+                char currentChar = textPointer[i];
+
+                if (currentChar == 11)
+                {
+                    // Tabulation
+                    destination.X+= 8 * fX;
+                    --textLength;
+                    continue;
+                }
+                else if (currentChar >= 10 && currentChar <= 13)
+                {
+                    // New Line
+                    destination.X= fX;
+                    destination.Y += fH;
+                    scaledDestinationY = -(destination.Y * 2.0f - 1.0f);
+                    --textLength;
+                    continue;
+                }
+                else if (currentChar < 32 || currentChar > 126)
+                {
+                    currentChar = (char)32;
+                }
+
+                source.X= currentChar % 32 * constantInfos.X;
+                source.Y = currentChar / 32 % 4 * constantInfos.Y;
+
+                scaledDestinationX = destination.X * 2.0f - 1.0f;
+
+                // 0
+                (*vertexBuffer)->Position.X = scaledDestinationX + BaseVertexBufferData[0].Position.X* destination.Width;
+                (*vertexBuffer)->Position.Y = scaledDestinationY + BaseVertexBufferData[0].Position.Y * destination.Height;
+
+                (*vertexBuffer)->TextureCoordinate.X= (source.X + BaseVertexBufferData[0].TextureCoordinate.X * source.Width) * invertedWidth;
+                (*vertexBuffer)->TextureCoordinate.Y = (source.Y + BaseVertexBufferData[0].TextureCoordinate.Y * source.Height) * invertedHeight;
+
+                ++(*vertexBuffer);
+
+                // 1
+                (*vertexBuffer)->Position.X = scaledDestinationX + BaseVertexBufferData[1].Position.X * destination.Width;
+                (*vertexBuffer)->Position.Y = scaledDestinationY + BaseVertexBufferData[1].Position.Y * destination.Height;
+
+                (*vertexBuffer)->TextureCoordinate.X = (source.X + BaseVertexBufferData[1].TextureCoordinate.X * source.Width) * invertedWidth;
+                (*vertexBuffer)->TextureCoordinate.Y = (source.Y + BaseVertexBufferData[1].TextureCoordinate.Y * source.Height) * invertedHeight;
+
+                ++(*vertexBuffer);
+
+                // 2
+                (*vertexBuffer)->Position.X = scaledDestinationX + BaseVertexBufferData[2].Position.X * destination.Width;
+                (*vertexBuffer)->Position.Y = scaledDestinationY + BaseVertexBufferData[2].Position.Y * destination.Height;
+
+                (*vertexBuffer)->TextureCoordinate.X = (source.X + BaseVertexBufferData[2].TextureCoordinate.X * source.Width) * invertedWidth;
+                (*vertexBuffer)->TextureCoordinate.Y = (source.Y + BaseVertexBufferData[2].TextureCoordinate.Y * source.Height) * invertedHeight;
+
+                ++(*vertexBuffer);
+
+                // 3
+                (*vertexBuffer)->Position.X = scaledDestinationX + BaseVertexBufferData[3].Position.X * destination.Width;
+                (*vertexBuffer)->Position.Y = scaledDestinationY + BaseVertexBufferData[3].Position.Y * destination.Height;
+
+                (*vertexBuffer)->TextureCoordinate.X = (source.X + BaseVertexBufferData[3].TextureCoordinate.X * source.Width) * invertedWidth;
+                (*vertexBuffer)->TextureCoordinate.Y = (source.Y + BaseVertexBufferData[3].TextureCoordinate.Y * source.Height) * invertedHeight;
+
+                ++(*vertexBuffer);
+
+                destination.X += destination.Width;
+            }
+        }
+
         /// <summary>
         /// Sets or gets the color to use when drawing the text.
         /// </summary>

sources/engine/Stride.Graphics/SpriteBatch.cs

@@ -5,7 +5,6 @@
 using System.Runtime.InteropServices;
 using System.Text;
 using Stride.Core.Mathematics;
-using Stride.Native;
 using Stride.Rendering;
 
 namespace Stride.Graphics
@@ -590,9 +589,45 @@ internal unsafe void DrawSprite(Texture texture, ref RectangleF destination, boo
 
         protected override unsafe void UpdateBufferValuesFromElementInfo(ref ElementInfo elementInfo, IntPtr vertexPtr, IntPtr indexPtr, int vertexOffset)
         {
+            var vertex = (VertexPositionColorTextureSwizzle*)vertexPtr;
             fixed (SpriteDrawInfo* drawInfo = &elementInfo.DrawInfo)
             {
-                NativeInvoke.UpdateBufferValuesFromElementInfo(new IntPtr(drawInfo), vertexPtr, indexPtr, vertexOffset);
+                float deltaX = 1.0f / drawInfo->TextureSize.X;
+                float deltaY = 1.0f / drawInfo->TextureSize.Y;
+
+                Vector2 rotation = new(1,0);
+
+                if (Math.Abs(drawInfo->Rotation) > float.Epsilon)
+                {
+                    (rotation.X, rotation.Y) = MathF.SinCos(drawInfo->Rotation);
+                }
+
+                Vector2 origin = drawInfo->Origin;
+                origin.X /= Math.Max(float.Epsilon, drawInfo->Source.Width);
+                origin.Y /= Math.Max(float.Epsilon, drawInfo->Source.Height);
+
+                for (int j = 0; j < 4; j++)
+                {
+                    Vector2 corner = CornerOffsets[j];
+                    Vector2 position;
+                    position.X = (corner.X - origin.X) * drawInfo->Destination.Width;
+                    position.Y = (corner.Y - origin.Y) * drawInfo->Destination.Height;
+
+                    vertex->Position.X = drawInfo->Destination.X + (position.X * rotation.X) - (position.Y * rotation.Y);
+                    vertex->Position.Y = drawInfo->Destination.Y + (position.X * rotation.Y) + (position.Y * rotation.X);
+                    vertex->Position.Z = drawInfo->Depth;
+                    vertex->Position.W = 1.0f;
+                    vertex->ColorScale = drawInfo->ColorScale;
+                    vertex->ColorAdd = drawInfo->ColorAdd;
+
+                    corner = CornerOffsets[((j ^ (int)drawInfo->SpriteEffects) + (int)drawInfo->Orientation) % 4];
+                    vertex->TextureCoordinate.X = (drawInfo->Source.X + corner.X * drawInfo->Source.Width) * deltaX;
+                    vertex->TextureCoordinate.Y = (drawInfo->Source.Y + corner.Y * drawInfo->Source.Height) * deltaY;
+
+                    vertex->Swizzle = (int)drawInfo->Swizzle;
+
+                    vertex++;
+                }
             }
         }
 

sources/engine/Stride.Graphics/Stride.Graphics.csproj

@@ -5,8 +5,6 @@
   </PropertyGroup>
   <Import Project="..\..\targets\Stride.props" />
   <PropertyGroup>
-    <ProductVersion>8.0.30703</ProductVersion>
-    <SchemaVersion>2.0</SchemaVersion>
     <StrideAssemblyProcessor>true</StrideAssemblyProcessor>
     <StridePlatformDependent>true</StridePlatformDependent>
     <StrideBuildTags>*</StrideBuildTags>
@@ -43,7 +41,6 @@
       <GlobalPropertiesToRemove>TargetFramework;StrideGraphicsApi</GlobalPropertiesToRemove>
       <SkipGetTargetFrameworkProperties>true</SkipGetTargetFrameworkProperties>
     </ProjectReference>
-    <ProjectReference Include="..\Stride.Native\Stride.Native.csproj" />
     <ProjectReference Include="..\Stride.Shaders\Stride.Shaders.csproj" />
     <ProjectReference Include="..\Stride\Stride.csproj" />
     <PackageReference Include="System.Memory" Version="4.5.4" />