Où Unity élimine-t-il les sommets avant l'appel du shader?

Question

Je suis en train de créer un jeu avec des conditions limites périodiques (donc, fondamentalement, si vous êtes sur le bord droit de la carte, et que vous regardez vers la droite, vous devriez voir à nouveau toute la carte).

J'ai créé un shader de géométrie qui prend un triangle et produit les 27 triangles dont j'ai besoin (boîte périodique 3*3*3), et cela fonctionne parfaitement tant que l'objet de base est à l'écran. Dès que l'objet de base quitte l'écran, toutes les copies disparaissent aussi.

Je pense donc que Unity ne fait même pas appel à mes shaders sur les sommets qui se trouvent derrière ma caméra (ce qui est totalement normal pour l'optimisation), mais avec ma solution actuelle, j'ai besoin d'un appel sur chaque objet du jeu.

Est-il possible de forcer Unity à ne pas supprimer d'objets avant le rendu, ou devrais-je chercher une solution différente ? Si je dois faire autre chose, avez-vous des idées ?

Voici mon code actuel. (Je débute avec les shaders, donc cela peut être stupide...)

Shader "Unlit/Geom_shader"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma geometry geom
            #pragma fragment frag

            #include "UnityCG.cginc"

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

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

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

            sampler2D _MainTex;
            float4 _MainTex_ST;

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

            [maxvertexcount(3*3*3*3)]
            void geom(triangle v2g input[3], inout TriangleStream tristream) {

                g2f o = (g2f)0;

                for (int x = 0; x < 3; x++)
                {
                    float x_shift = (x - 1) * 2*_SinTime[2];
                    for (int y = 0; y < 3; y++)
                    {
                        float y_shift = (y - 1) * 2 * _SinTime[2];
                        for (int z = 0; z < 3; z++)
                        {
                            float z_shift = (z - 1) * 2 * _CosTime[2];

                            for (int i = 0; i < 3; i++)
                            {
                                o.vertex = UnityObjectToClipPos(input[i].vertex + float4(x_shift, y_shift, z_shift, 0));
                                o.uv = TRANSFORM_TEX(input[i].uv, _MainTex);
                                tristream.Append(o);
                            }
                            tristream.RestartStrip();
                        }
                    }
                }
            }

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

Je n'essaie pas de l'utiliser pour les lumières mais pour des objets entiers et je suis sûr qu'ils sont gérés différemment. Donc la raison pour laquelle cela se produit est la même, mais la solution doit être différente. (Pourquoi ce n'est pas un doublon de: Unity3D - Lumière désactivée lorsqu'elle fait face dans la direction opposée)

Answer 1

Il ne s'agit pas des sommets qui sont supprimés, mais de l'ensemble du maillage qui est éliminé dans son ensemble.

Unity met en œuvre le Culling du Frustum de Vue basé sur la boîte de délimitation de votre maillage. Vous pouvez modifier la boîte de délimitation d'un maillage manuellement en attribuant une nouvelle valeur à Mesh.bounds.