How to get model matrix into Graphics.DrawProcedural custom shader?

Unity Engine
1

I am trying to get a custom shader to work with vertex pulling from a generic buffer. To do this, I’ve created a custom shader that only uses SV_VertexId and a StructuredBuffer as inputs, and then I call Graphics.DrawProcedural to actually draw stuff. The basics work, but I’m having a lot of trouble getting the correct MVP matrix in the shader.

I found How do I reproduce the MVP matrix? - Questions & Answers - Unity Discussions but it doesn’t work reliably on all my platforms; sometimes I need to flip the Y-coordinate, and sometimes I don’t. So I figured I would go back to the shader and attempt to use the UnityObjectToClipPos() function in 2017.1.

That works for the VP part of the MVP matrix, but the model part isn’t updated. If I create a scene then I can see that standard objects/shaders do scale for example, but the object with my custom script and shader doesn’t.

Below is some example code that exhibits the issue. Simply create an empty GameObject, attach this script, create a new Material that uses this custom shader and link that into the script. Although the procedural triangle is correctly rendered as the camera changes position, any changes to the position/rotation/scale aren’t visible.

I have looked at the render calls with RenderDoc, and as far as I can tell there is a matrix in the shader that stays at identity. I suspect that is the model matrix, and that I somehow need to tell Unity to update it from the current transform.

Any help would be greatly appreciated!

Kind regards,
Rick

Script

using UnityEngine;

public class TestDirectProcedural : MonoBehaviour {

    public Material mat;
    public void OnRenderObject()
    {
        mat.SetPass(0);
        Graphics.DrawProcedural(MeshTopology.Triangles, 3, 1);
    }
}

Shader

Shader "Custom/TestProceduralShader" {
    SubShader {
        Tags { "RenderType"="Opaque" }
        LOD 200
       
        Pass
        {
            Cull Off

            CGPROGRAM
            #include "UnityShaderVariables.cginc"
            #pragma only_renderers d3d11
           
            #pragma vertex vs
            #pragma fragment ps

            #pragma target 3.0

            struct v2f {
                float4 position : SV_Position;
            };
       

            static float3 positions[3] = {
                float3(0,0,0),
                float3(10,0,0),
                float3(0,0,10)
            };

            v2f vs( uint index : SV_VertexId ) {
                v2f o;

                float4 position = float4(positions[index], 1);
                position = UnityObjectToClipPos(position);
                o.position = position;
               
                return o;
            }
           
            fixed4 ps(v2f input) : SV_Target0
            {
                return fixed4(1, 0, 0, 1);
            }
            ENDCG
        }
    }
}
2

I’m running into the same issue. So far, it seems that Graphics.DrawProcedural just doesn’t set the model matrix (or perhaps clears it, as OnRenderObject supposedly is called after all normal drawing and the matrix should be set).

The short answer is that, unfortunately, at the moment it does seem that you will have to recreate at least the model matrix for this. Now to preface this, I should point out that I target Win/Mac/Linux and UWP almost exclusively, and have never had to deal with the flipped y axis of which you speak.

As it turns out, UnityObjectToClipPos() is actually just defined as:

// Tranforms position from object to homogenous space
inline float4 UnityObjectToClipPos(in float3 pos)
{
    // More efficient than computing M*VP matrix product
    return mul(UNITY_MATRIX_VP, mul(unity_ObjectToWorld, float4(pos, 1.0)));
}

It’s pretty much just a shorthand for what you’d be doing anyway, and doesn’t do anything platform-specific. I would assume that such flipping would likely be done by the camera in preparation for rendering. Defining a float4x4 in a shader and recreating the UnityObjectToClipPos function would be trivial, leaving only the model matrix to be calculated. Once again, I do not unfortunately have the hardware to test this, but if the VP portion is being calculated accurately for all platforms then I see no reason why calculating a model matrix with Matrix4x4.TRS or the like would cause any issues.
If it is the case, you may need to (and I can’t believe I’m saying this) use a bunch of preprocessor defines. Yeah, it would be kinda gross, but you could wrap it in a method, and if it works for everything you’re targeting, well then it works.

So far, there unfortunately doesn’t seem to be a solution for this other than to just work around it and make your own modelmatrix. In some ways, one could think of this as a feature, in the case of, say, DrawProcedural being used to draw a lot of different objects that might all have different matrices, a bit like instancing (on some hardware this is actually faster than instancing), or for something like particles. Regardless, for just rendering bits of geometry on an object, you would just need to use Material.SetMatrix or a command buffer to transform the vertices correctly.

Certainly, however, the VP matrix can stay the same per camera, and does when using DrawProcedural, so there’s no need to recreate an entire MVP matrix.