在 Unity 中将纹理映射到点云

Question

I have a proprietary point cloud file that is then converted into a mesh that is displayed in Unity. The mesh consists of vertices where each point of the point cloud is. I'm trying to map the texture to the point cloud in a way that the texture aligns with the points 100%. I'm trying to accomplish this with a shader, but it seems that I don't have enough knowledge to do this. I've never worked with point clouds and shaders before, so I'm really struggling to do this.

The texture and the point cloud are the same x and y size and the ratio is 16:10 (1920x1200)

I've taken inspiration from an asset I found on the assetStore for the shader. To my knowledge, the shader creates a small quad on every vertex in the mesh and then takes the UV map information and maps the texture to the points. I downloaded the UV map from the internet, it should be neutral with no modifications when mapping the texture:

UV Map that I use

My current result is not good. By default, the texture is zoomed-in roughly 2x on both the x and y-axis. When manually adjusting the scale and the offset for both of the axes, I can get a somewhat correct result but only on one part of the image. The other parts then need a different offset/scale combination. I tried a lot of things with no success, but I'm pretty sure that the solution lies in the shader code since other modifications have no effect on the texture mapping process.

Since I can't show you all the details of the project because it is confidential, the question is probably hard to answer. Fortunately I can show you the shader code:

    Properties {
        [NoScaleOffset]_MainTex ("Texture", 2D) = "white" {}
        [NoScaleOffset]_UVMap ("UV", 2D) = "white" {}
        _TexScaleH("Uv texture scaler H", Float) = 1.0
        _TexScaleV("Uv texture scaler V", Float) = 1.0
        _PointSize("Point Size", Float) = 4.0
        _Color("PointCloud Color", Color) = (1, 1, 1, 1)
        _OffsetH("Horizontal offset", Float) = 0.0
        _OffsetV("Vertical offset", Float) = 0.0
    }

    SubShader
    {
        Cull Off
        Pass 
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma geometry geom
            #pragma fragment frag
            #pragma shader_feature USE_DISTANCE
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
            };

            float _PointSize;
            fixed4 _Color;

            sampler2D _MainTex;
            float4 _MainTex_TexelSize;
            float _OffsetH;
            float _OffsetV;

            sampler2D _UVMap;
            float4 _UVMap_TexelSize;
            float _TexScaleH;
            float _TexScaleV;

            struct g2f
            {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
            };

            [maxvertexcount(4)]
            void geom(point v2f i[1], inout TriangleStream<g2f> triStream)
            {
                g2f o;
                float4 v = i[0].vertex;
                float2 uv = v.xy;
                uv.x = -uv.x;
                uv.y = -uv.y;
                float2 p = _PointSize * 0.001;
                p.y *= _ScreenParams.x / _ScreenParams.y;
                
                o.vertex = UnityObjectToClipPos(v);
                o.vertex += float4(-p.x, p.y, 0, 0) * o.vertex.w;
                o.uv = uv * float3(_TexScaleH,_TexScaleV,0) + float3(_OffsetH,_OffsetV,0);
                triStream.Append(o);

                o.vertex = UnityObjectToClipPos(v);
                o.vertex += float4(-p.x, -p.y, 0, 0) * o.vertex.w;
                o.uv = uv * float3(_TexScaleH, _TexScaleV, 0) + float3(_OffsetH, _OffsetV, 0);
                triStream.Append(o);

                o.vertex = UnityObjectToClipPos(v);
                o.vertex += float4(p.x, p.y, 0, 0) * o.vertex.w;
                o.uv = uv * float3(_TexScaleH, _TexScaleV, 0) + float3(_OffsetH, _OffsetV, 0);
                triStream.Append(o);

                o.vertex = UnityObjectToClipPos(v);
                o.vertex += float4(p.x, -p.y, 0, 0) * o.vertex.w;
                o.uv = uv * float3(_TexScaleH, _TexScaleV, 0) + float3(_OffsetH, _OffsetV, 0);
                triStream.Append(o);

            }

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = v.vertex;
                o.uv = v.uv;
                return o;
            }

            fixed4 frag (g2f i) : SV_Target
            {
                float2 uv = tex2D(_UVMap, i.uv);
                if(any(uv <= 0 || uv >= 1))
                    discard;
                return tex2D(_MainTex, uv) * _Color;
            }
            ENDCG
        }
    }
}

There is not a lot of information on shader coding in Unity on the web, neither is there about point clouds so I'm kind of lost right now.

Let me know your thoughts down below on what things can I change in order to fix the issue.

Answer 1

Well I found a way to do it, but the result is not 100% what I need.

Shader "shaderexample"
{
    Properties
    {
        _MainTex("Texture", 2D) = "white" {}
        _PointSize("Point size", Float) = 1.0
    }
        SubShader
    {    
        Pass
        {
        CGPROGRAM
        #pragma vertex vert
        #pragma geometry geom
        #pragma fragment frag

        #include "UnityCG.cginc"

        sampler2D _MainTex;
        float4 _MainTex_ST;
        float _PointSize;

        struct v2f
        {
            float4 vertex : SV_POSITION;
            float2 texcoord : TEXCOORD0;

        };

        struct g2f
        {
            float4 vertex : SV_POSITION;
            float2 texcoord : TEXCOORD0;
        };

        v2f vert(appdata_full v)
        {
            v2f o;
            float4 vertex = mul(unity_ObjectToWorld, v.vertex);
            o.vertex = mul(UNITY_MATRIX_VP, vertex);
            o.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);
            return o;
        }

        fixed4 frag(g2f i) : SV_Target
        {
            fixed4 color = tex2D(_MainTex, i.texcoord);
            return color;
        }
        ENDCG
    }
}

}

Now every point is correctly aligned to the texture. Now I need to combine this functionality with my other one, and that is to enlarge every vertex of the mesh. Variable _PointSize should determine how large each vertex should be. I tried to use the code shown earlier that creates the small quads on the vertex positions. Does anyone know how to combine these two functionalities?

maxvertexcount(4)]
void geom(point v2f i[1], inout TriangleStream<g2f> triStream)
{
    g2f o;

    float4 v = i[0].vertex;
    float2 p = _PointSize * 0.001;
    p.y *= _ScreenParams.x / _ScreenParams.y;

    o.vertex = UnityObjectToClipPos(v);
    o.vertex += float4(p.x, p.y, 0, 0) * o.vertex.w;
    triStream.Append(o);

    o.vertex = UnityObjectToClipPos(v);
    o.vertex += float4(p.x, -p.y, 0, 0) * o.vertex.w;
    triStream.Append(o);

    o.vertex = UnityObjectToClipPos(v);
    o.vertex += float4(-p.x, p.y, 0, 0) * o.vertex.w;
    triStream.Append(o);

    o.vertex = UnityObjectToClipPos(v);
    o.vertex += float4(-p.x, -p.y, 0, 0) * o.vertex.w;
    triStream.Append(o);
}

This is the geometry part of the shader which should create small quads for each vertex.