Instancing and SharpDX (revisited)

[Idomeneas1970]

Hi, question regarding instancing please. Two fold:

1. I saw in the API that in the VertexDeclaration there is no way to change the InputSlotClass to InputClassification.Instance in the VertexElement definition. Is there a way to change this value? I want to be able to build a vertex like from SharpDX:

InputElement[] inputElements = new InputElement[] 
{
    new InputElement()
    {
        SemanticName = "POSITION",
        SemanticIndex = 0,
        Format = SharpDX.DXGI.Format.R32G32B32_Float,
        Slot = 0,
        AlignedByteOffset = 0,
        Classification = InputClassification.PerVertexData,
        InstanceDataStepRate = 0
    },
    new InputElement()
    {
        SemanticName = "TEXCOORD",
        SemanticIndex = 0,
        Format = SharpDX.DXGI.Format.R32G32_Float,
        Slot = 0,
        AlignedByteOffset = InputElement.AppendAligned,
        Classification = InputClassification.PerVertexData,
        InstanceDataStepRate = 0
    },
    new InputElement()
    {
        SemanticName = "TEXCOORD",
        SemanticIndex = 1,
        Format = SharpDX.DXGI.Format.R32G32B32_Float,
        Slot = 1,
        AlignedByteOffset = 0,
        Classification = InputClassification.PerInstanceData,
        InstanceDataStepRate = 1
    }
};

I believe that this will be faster and wont take a performance hit when you want 1mil instances. The projects I saw from @tebjanand bytesized are good for low count instances for up to a few thousand (I tried tebjan's example, for 1mil cubes it went from 60fps down to 10fps) .

I think the following is useful in the pipeline, so I'll try a new RootRenderFeature see if it works and report later.

var InputElementDescr=new InputElementDescription[]
   {
        new InputElementDescription ()
        {
            SemanticName = "POSITION",
            SemanticIndex = 0,
            Format = PixelFormat.R32G32B32_Float,
            InputSlot = 0,
            AlignedByteOffset = 0,
            InputSlotClass  = InputClassification.Vertex,
            InstanceDataStepRate = 0
        },
        new InputElementDescription ()
        {
            SemanticName = "TEXCOORD",
            SemanticIndex = 0,
            Format = PixelFormat.R32G32_Float,
            InputSlot = 0,
            AlignedByteOffset = -1,
            InputSlotClass  = InputClassification.Vertex,
            InstanceDataStepRate = 0
        },
        new InputElementDescription ()
        {
            SemanticName = "TEXCOORD",
            SemanticIndex = 1,
            Format = PixelFormat.R32G32B32_Float,
            InputSlot = 1,
            AlignedByteOffset = 0,
            InputSlotClass  = InputClassification.Instance,
            InstanceDataStepRate = 1
        }
   };

2. Is it possible to bind a drawinstanced setup from SharpDX into the Stride pipeline? That would solve all sorts of problems.
   Sorry for being longwinded and thank you for your time.

[Idomeneas1970]

Update
A RootRenderFeature works very well and seems to beat some of the other ways we have to draw massive numbers of primitives. The code follows. It is drawing 1024*1024=1,048,576 cubes with different color. Do not attempt to add texture (massive hit to FPS lol).
Since this is done through renderFeature, frustum culling is taken care of. I hope it helps someone; it will be included in my terrain editor when it is released.

After a lot of comparisons and tests between existing projects and examples, Tebjan's project here seems to be the best way to handle instancing for general models and animations, but your instance count has to be in the thousands.

RootRenderFeature

public class InstancingRenderFeature : RootRenderFeature
  {
      DynamicEffectInstance shader;
      MutablePipelineState pipelineState;

      public override Type SupportedRenderObjectType => typeof(RenderMesh);

      public InstancingRenderFeature()
      {
          //pre adjust render priority, low numer is early, high number is late
          SortKey = 255;
      }

      protected override void InitializeCore()
      {
          base.InitializeCore();

          // initialize shader
          shader = new DynamicEffectInstance("CubeInstancingShader");
          shader.Initialize(Context.Services);

          // create the pipeline state and set properties that won't change
          pipelineState = new MutablePipelineState(Context.GraphicsDevice);
          pipelineState.State.SetDefaults();
          pipelineState.State.InputElements = VertexPositionColor.Layout.CreateInputElements();
          pipelineState.State.BlendState = BlendStates.Opaque;
          pipelineState.State.RasterizerState.CullMode = CullMode.Back;
          pipelineState.State.PrimitiveType = PrimitiveType.TriangleList;
      }

      public override void Prepare(RenderDrawContext context)
      {
          base.Prepare(context);
      }

      public override void Draw(RenderDrawContext context, RenderView renderView, RenderViewStage renderViewStage)
      {
          shader.UpdateEffect(context.GraphicsDevice);

          foreach (var renderNode in renderViewStage.SortedRenderNodes)
          {
              var renderMesh = renderNode.RenderObject as RenderMesh;
              if (renderMesh == null)
              {
                  continue;
              }
              // get InstancingRenderScript script
              InstancingRenderScript InstancingRenderScript = null;
              if (renderMesh.Source is ModelComponent)
              {
                  InstancingRenderScript = (renderMesh.Source as ModelComponent).Entity.Get<InstancingRenderScript>();
              }

              if (InstancingRenderScript == null || !InstancingRenderScript.Enabled)
              {
                  continue;
              }

              MeshDraw drawData = renderMesh.ActiveMeshDraw;
              // bind VB
              for (int slot = 0; slot < drawData.VertexBuffers.Length; slot++)
              {
                  var vertexBuffer = drawData.VertexBuffers[slot];
                  context.CommandList.SetVertexBuffer(slot, vertexBuffer.Buffer, vertexBuffer.Offset, vertexBuffer.Stride);
              }
              // set shader parameters
              shader.Parameters.Set(TransformationKeys.WorldViewProjection, renderMesh.World * renderView.ViewProjection); // matrix
              shader.Parameters.Set(TexturingKeys.Sampler, context.GraphicsDevice.SamplerStates.LinearWrap);
          //    shader.Parameters.Set(CubeInstancingShaderKeys.shaderTexture, TerrainScript.GetTerrainTexture(1));
              shader.Parameters.Set(CubeInstancingShaderKeys.InstanceLocations,                    InstancingRenderScript.InstanceLocations);
              shader.Parameters.Set(CubeInstancingShaderKeys.InstanceColors, InstancingRenderScript.InstanceColors);
              shader.Parameters.Set(CubeInstancingShaderKeys.Phase, DateTime.UtcNow.Millisecond);
              
              // prepare pipeline state
              pipelineState.State.RootSignature = shader.RootSignature;
              pipelineState.State.EffectBytecode = shader.Effect.Bytecode;
              pipelineState.State.PrimitiveType = PrimitiveType.TriangleList;// drawData.PrimitiveType;

              pipelineState.State.Output.CaptureState(context.CommandList);
              pipelineState.Update();

              context.CommandList.SetIndexBuffer(drawData.IndexBuffer.Buffer, drawData.IndexBuffer.Offset, drawData.IndexBuffer.Is32Bit);
              context.CommandList.SetPipelineState(pipelineState.CurrentState);
              // apply the effect
              shader.Apply(context.GraphicsContext);

              // Render the models.
              if (drawData.IndexBuffer != null)
              {
                  //context.CommandList.DrawIndexed(drawData.DrawCount, drawData.StartLocation);
                  context.CommandList.DrawIndexedInstanced(drawData.DrawCount,
               InstancingRenderScript.InstanceCount);
              }
              else
              {
                  context.CommandList.DrawInstanced(drawData.DrawCount,
                    InstancingRenderScript.InstanceCount);
              }
          }
      }
  }

Attach this script to an entity that has a model attached.

public class InstancingRenderScript : StartupScript
   {
       [DataMember(0)]
       public bool Enabled = true;

       [Display(Browsable = false)]
       [DataMember(2)]
       public int InstanceCount { get; private set; }

       [Display(Browsable = false)]
       [DataMember(3)]
       public Buffer<Vector3> InstanceLocations;

       [Display(Browsable = false)]
       [DataMember(4)]
       public Buffer<Vector4> InstanceColors;

       public override void Start()
       {
           if (!Enabled) return;
           InitializeInstanceBuffersPosCol(GraphicsDevice);
       }

       public bool InitializeInstanceBuffersPosCol(GraphicsDevice GraphicsDevice)
       {
           try
           {
               // Set the number of instances in the array.
               InstanceCount = 1024*1024;
               Vector3[] instancespos = new Vector3[InstanceCount];
               Vector4[] instancescol = new Vector4[InstanceCount];
               for (int i = 0; i < InstanceCount; i++)
               {
                   instancespos[i] = new Vector3(Utility.Runif(-120, 120),
                       Utility.Runif(-120, 120), Utility.Runif(-120, 120));
                   instancescol[i] = new Vector4(Utility.Runif(), Utility.Runif(),
                       Utility.Runif(), Utility.Runif());
               }
               InstanceLocations = Stride.Graphics.Buffer.Structured.New<Vector3>(
                    GraphicsDevice, instancespos);
               InstanceColors = Stride.Graphics.Buffer.Structured.New<Vector4>(
                    GraphicsDevice, instancescol);
               return true;
           }
           catch
           {
               return false;
           }

       }

   }

The shader for instancing

   shader CubeInstancingShader: ComputeColor,//Texturing, 
   Transformation, ShaderBase,
   PositionStream4,TransformationInstancing
   {
     // rgroup PerMaterial    { stage Texture2D shaderTexture;   }
    stage float Phase=1.0f;
  StructuredBuffer<float3> InstanceLocations;
  StructuredBuffer<float4> InstanceColors;

  stage override void VSMain() 
       {
   streams.Position.w=1;
    streams.Position.x += InstanceLocations[streams.InstanceID].x*sin(2*3.14*Phase);
   streams.Position.y += InstanceLocations[streams.InstanceID].y;
   streams.Position.z += InstanceLocations[streams.InstanceID].z;
          streams.ShadingPosition = mul(streams.Position, WorldViewProjection);
      }      
       
// pixel shader
   stage override void PSMain()    {        
       streams.ColorTarget = InstanceColors[streams.InstanceID];
       //* shaderTexture.Sample(Sampler,streams.TexCoord);  
   }

   };