Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

Привет у меня есть шейдер как его можно улучшить Shader "Custom/InteriorMapping -…

  1. User

    Привет у меня есть шейдер как его можно улучшить

    Shader "Custom/InteriorMapping - simple" { Properties { _RoomTex("Room Atlas RGB (alpha is not needed)", 2D) = "gray" {} _RoomMaxDepth01("Room Max Depth define(0 to 1)", range(0.001,0.999)) = 0.5 _RoomCount("Room Count(X count,Y count)", vector) = (1,1,0,0) } SubShader { Tags { "RenderType" = "Opaque" }

                Pass
                {
                        CGPROGRAM
                        #pragma vertex vert
                        #pragma fragment frag
    
                        #include "UnityCG.cginc"
                        #include "InteriorUVFunction.hlsl"
    
                        struct appdata
                        {
                                float4 vertex : POSITION;
                                float2 uv : TEXCOORD0;
                                float3 normal : NORMAL;
                                float4 tangent : TANGENT;
                        };
    
                        struct v2f
                        {
                                float4 pos : SV_POSITION;
                                float2 uv : TEXCOORD0;
                                float3 tangentViewDir : TEXCOORD1;
                        };
    
                        sampler2D _RoomTex;
                        float4 _RoomTex_ST;
    
                        float _RoomMaxDepth01;
                        float2 _RoomCount;
    
                        float3 DirObjectSpaceToTangentSpace(float3 inputDirOS, float3 normalOS, float4 tangentOS)
                        {
                                float tangentSign = tangentOS.w * unity_WorldTransformParams.w;
                                float3 bitangentOS = cross(normalOS, tangentOS.xyz) * tangentSign;
                                return float3(
                                        dot(inputDirOS, tangentOS.xyz),
                                        dot(inputDirOS, bitangentOS),
                                        dot(inputDirOS, normalOS)
                                        );
                        }
    
                        v2f vert(appdata v)
                        {
                                v2f o;
    
                                //regular
                                o.pos = UnityObjectToClipPos(v.vertex);
    
                                //tile uv base on room count in vertex shader
                                o.uv = v.uv * _RoomCount;
    
                                //find view dir Object Space
                                float3 camPosObjectSpace = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1.0)).xyz;
                                float3 viewDirObjectSpace = v.vertex.xyz - camPosObjectSpace;
    
                                //get tangent space view vector
                                o.tangentViewDir = DirObjectSpaceToTangentSpace(viewDirObjectSpace, v.normal, v.tangent);
    
                                return o;
                        }
    
                        fixed4 frag(v2f i) : SV_Target
                        {
                                float2 interiorUV = ConvertOriginalRawUVToInteriorUV(frac(i.uv), i.tangentViewDir, _RoomMaxDepth01);
                                interiorUV /= _RoomCount;
                                interiorUV = TRANSFORM_TEX(interiorUV, _RoomTex);
    
                                //map to differrent room if needed
                                float2 roomIndex = floor(i.uv);
                                interiorUV += roomIndex / _RoomCount;
    
                                return tex2D(_RoomTex, interiorUV);
                        }
                        ENDCG
                }
        }
    

    }

  2. Assistant

    Есть несколько направлений, в которых можно улучшить ваш шейдер для интерьерной текстуры. Вы можете обратить внимание на следующие аспекты:

    1. Улучшение качества текстур

    Для повышения качества текстур можно использовать Mipmaps. Это особенно важно для материалов, которые будут отображаться на значительном расстоянии от камеры. Вы можете включить Mipmaps в свойствах текстуры, если используются текстуры, которые это поддерживают.

    2. Добавление текстурных координат для более точного наложения

    Если хотите улучшить наложение текстуры, добавьте больше текстурных координат. Например, добавьте координаты для Normal Map, если у вас есть нормали. Это дает более детализированное освещение.

    3. Использование фрагментного шейдера для доработки света и теней

    Если ваша сцена сложная, то стоит рассмотреть использование освещения в фрагментном шейдере. Например, вы можете реализовать более сложную модель освещения, добавляя такие вещи, как:

    • Ambient Occlusion
    • Shadows
    • Specular Highlights

    4. Оптимизация производительности

    • Избегайте использования функций, вызываемых на каждом пикселе, таких как floor, если это можно сделать с использованием интераджективного значения. Попробуйте вычислить roomIndex один раз в вершинном шейдере.
    • Проверьте, есть ли у вас возможность избежать частых обращений к текстуре, которые могут замедлить выполнение шейдера.

    5. Устранение артефактов наложения

    Избегайте возможных артефактов наложения текстуры при переходе между разными комнатами. Убедитесь, что UV координаты правильно управляются с учетом границ текстур.

    6. Добавление параметров материала

    Рассмотрите возможность добавления дополнительных свойств, таких как:

    • Гладкость
    • Металлические значения
    • Параметры для нормальной карты или карты высоты

    Пример улучшенного кода:

    Ниже приведен пример кода, в который были внедрены некоторые из перечисленных выше предложений:

    Shader "Custom/InteriorMapping - Improved"
    {
        Properties
        {
            _RoomTex("Room Atlas RGB (alpha is not needed)", 2D) = "gray" {}
            _RoomMaxDepth01("Room Max Depth define(0 to 1)", Range(0.001, 0.999)) = 0.5
            _RoomCount("Room Count(X count,Y count)", Vector) = (1,1,0,0)
            _RoomNormalMap("Normal Map", 2D) = "bump" {}
        }
        SubShader
        {
            Tags { "RenderType" = "Opaque" }
            
            Pass
            {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
                
                #include "UnityCG.cginc"
    
                struct appdata
                {
                    float4 vertex : POSITION;
                    float2 uv : TEXCOORD0;
                    float3 normal : NORMAL;
                    float4 tangent : TANGENT;
                };
    
                struct v2f
                {
                    float4 pos : SV_POSITION;
                    float2 uv : TEXCOORD0;
                    float3 tangentViewDir : TEXCOORD1;
                    float2 roomIndex : TEXCOORD2; // передаем индекс комнаты
                };
    
                sampler2D _RoomTex;
                sampler2D _RoomNormalMap;
                float4 _RoomTex_ST;
                float _RoomMaxDepth01;
                float2 _RoomCount;
    
                // остающиеся функции стандартные
    
                v2f vert(appdata v)
                {
                    v2f o;
                    o.pos = UnityObjectToClipPos(v.vertex);
                    o.uv = v.uv * _RoomCount;
                    o.tangentViewDir = DirObjectSpaceToTangentSpace(viewDirObjectSpace, v.normal, v.tangent);
                    o.roomIndex = floor(v.uv); // вычисление индекса комнаты
                    return o;
                }
    
                fixed4 frag(v2f i) : SV_Target
                {
                    float2 interiorUV = ConvertOriginalRawUVToInteriorUV(frac(i.uv), i.tangentViewDir, _RoomMaxDepth01);
                    interiorUV /= _RoomCount;
                    interiorUV = TRANSFORM_TEX(interiorUV, _RoomTex);
    
                    interiorUV += i.roomIndex / _RoomCount;
    
                    fixed4 color = tex2D(_RoomTex, interiorUV);
                    // Добавление влияния нормалей, если требуется
                    // float3 normal = tex2D(_RoomNormalMap, interiorUV).xyz * 2.0 - 1.0;
                    // color += normal * someLightingFactor; // Поэкспериментируйте с это, чтобы добавить освещение
                    
                    return color;
                }
                ENDCG
            }
        }
    }
    

    Эти изменения могут повысить качество вашего шейдера, дать дополнительные возможности для выражения и улучшить производительность. Не забудьте протестировать шейдер на различных объектах и в разных диапазонах расстояний от камеры.

  3. User

    а можешь изменить логику _RoomMaxDepth01

  4. Assistant

    Конечно! Изменим логику использования _RoomMaxDepth01, чтобы она стала более интуитивной и удобной в использовании. Мы можем направить её на использование в качестве параметра для регулировки глубины текстурирования, но вместо значения от 0 до 1 можно сделать это более гибким, например, используя значения, которые определяют максимальную глубину в единицах длины или относительную величину.

    Изменения в логике _RoomMaxDepth01

    1. Изменение интерпретации: Вместо значения от 0 до 1, давайте позволим _RoomMaxDepth01 задавать максимальную глубину текстурирования в трехмерном пространстве. Это может быть, например, в метрах (или другой единице), в зависимости от масштаба вашей сцены.

    2. Изменение применения: Вместо использования по умолчанию текущего кода в frag для вычисления значения, мы можем использовать это значение для смещения UV или настраивания эффекта интерьера в методе ConvertOriginalRawUVToInteriorUV.

    Пример улучшенного кода с новой логикой _RoomMaxDepth01

    Shader "Custom/InteriorMapping - Improved"
    {
        Properties
        {
            _RoomTex("Room Atlas RGB (alpha is not needed)", 2D) = "gray" {}
            _RoomMaxDepth01("Max Interior Depth (in world units)", Float) = 5.0 // Новое значение
            _RoomCount("Room Count(X count,Y count)", Vector) = (1,1,0,0)
        }
        SubShader
        {
            Tags { "RenderType" = "Opaque" }
            
            Pass
            {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
                
                #include "UnityCG.cginc"
    
                struct appdata
                {
                    float4 vertex : POSITION;
                    float2 uv : TEXCOORD0;
                    float3 normal : NORMAL;
                    float4 tangent : TANGENT;
                };
    
                struct v2f
                {
                    float4 pos : SV_POSITION;
                    float2 uv : TEXCOORD0;
                    float3 tangentViewDir : TEXCOORD1;
                    float2 roomIndex : TEXCOORD2; // передаем индекс комнаты
                };
    
                sampler2D _RoomTex;
                float4 _RoomTex_ST;
                float _RoomMaxDepth01; // теперь это максимальная глубина
                float2 _RoomCount;
    
                float3 DirObjectSpaceToTangentSpace(float3 inputDirOS, float3 normalOS, float4 tangentOS)
                {
                    float tangentSign = tangentOS.w * unity_WorldTransformParams.w;
                    float3 bitangentOS = cross(normalOS, tangentOS.xyz) * tangentSign;
                    return float3(
                        dot(inputDirOS, tangentOS.xyz),
                        dot(inputDirOS, bitangentOS),
                        dot(inputDirOS, normalOS)
                    );
                }
    
                v2f vert(appdata v)
                {
                    v2f o;
                    o.pos = UnityObjectToClipPos(v.vertex);
                    o.uv = v.uv * _RoomCount;
                    float3 camPosObjectSpace = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1.0)).xyz;
                    float3 viewDirObjectSpace = v.vertex.xyz - camPosObjectSpace;
                    o.tangentViewDir = DirObjectSpaceToTangentSpace(viewDirObjectSpace, v.normal, v.tangent);
                    o.roomIndex = floor(v.uv); // индекс комнаты
                    return o;
                }
    
                fixed4 frag(v2f i) : SV_Target
                {
                    float2 interiorUV = ConvertOriginalRawUVToInteriorUV(frac(i.uv), i.tangentViewDir, _RoomMaxDepth01);
    
                    // Теперь используем _RoomMaxDepth01 как расстояние для смещения UV по Z
                    // Эта логика зависит от вашей функции ConvertOriginalRawUVToInteriorUV
                    // предположим, что она может использовать максимальную глубину
    
                    interiorUV.y *= _RoomMaxDepth01; // Здесь увеличиваем масштаб пути по Y, на основе новой логики
    
                    interiorUV /= _RoomCount;
                    interiorUV = TRANSFORM_TEX(interiorUV, _RoomTex);
                    interiorUV += i.roomIndex / _RoomCount;
    
                    return tex2D(_RoomTex, interiorUV);
                }
                ENDCG
            }
        }
    }
    

    Объяснение изменений:

    1. _RoomMaxDepth01 теперь воспринимается как максимальная глубина в пространстве, выраженная в единицах длины, что делает его более гибким.
    2. Обновленная логика в frag позволяет использовать это значение для масштабирования UV координат, что может создавать эффекты подстраиваемого текстурирования в зависимости от вашей глубины.

    Важно:

    Обязательно проверьте вашу функцию ConvertOriginalRawUVToInteriorUV, чтобы убедиться, что она соответствующим образом обрабатывает новое значение глубины, чтобы результат соответствовал вашим ожиданиям. Вы также можете изменить это в зависимости от ваших целей или добавить дополнительные параметры для тонкой настройки шейдера.

  5. User

    undeclared identifier 'ConvertOriginalRawUVToInteriorUV' Compiling Vertex program Platform defines: UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR

  6. Assistant

    Похоже, ваша шейдерная программа ссылается на функцию ConvertOriginalRawUVToInteriorUV, которая не объявлена в коде шейдера. Чтобы исправить это, вам нужно определить функцию, которая будет корректно преобразовывать UV координаты в соответствии с новой логикой. Давайте добавим реализацию этой функции.

    Пример реализации ConvertOriginalRawUVToInteriorUV

    Вам потребуется создать эту функцию таким образом, чтобы она принимала координаты UV, направление взгляда в тангенциальном пространстве и максимальную глубину. Ниже приведен пример, который можно использовать в вашем шейдере.

    В этом примере мы простым образом управляем смещением UV на основе направления взгляда и глубины. Имейте в виду, что вам может потребоваться настроить логику в зависимости от того, какой эффект вы хотите достичь.

    float2 ConvertOriginalRawUVToInteriorUV(float2 rawUV, float3 tangentViewDir, float maxDepth)
    {
        // Предположим, что 'maxDepth' определяет, как сильно модифицируем UV
        // Вы можете настроить эту логику по своему усмотрению
    
        // Учитываем направление просмотра, преобразуем UV по y на основе глубины
        float depthFactor = tangentViewDir.y / maxDepth; // Используем y-координату для модуляции
        float2 modifiedUV = rawUV + float2(depthFactor * 0.1, 0); // Простой сдвиг, основанный на направлении взгляда
    
        // Возвращаем измененные UV-координаты
        return modifiedUV;
    }
    

    Обновленный фрагмент шейдера

    Теперь обновим ваш шейдер, добавив определение вышеуказанной функции:

    Shader "Custom/InteriorMapping - Improved"
    {
        Properties
        {
            _RoomTex("Room Atlas RGB (alpha is not needed)", 2D) = "gray" {}
            _RoomMaxDepth01("Max Interior Depth (in world units)", Float) = 5.0
            _RoomCount("Room Count(X count,Y count)", Vector) = (1,1,0,0)
        }
        SubShader
        {
            Tags { "RenderType" = "Opaque" }
            
            Pass
            {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
                
                #include "UnityCG.cginc"
    
                struct appdata
                {
                    float4 vertex : POSITION;
                    float2 uv : TEXCOORD0;
                    float3 normal : NORMAL;
                    float4 tangent : TANGENT;
                };
    
                struct v2f
                {
                    float4 pos : SV_POSITION;
                    float2 uv : TEXCOORD0;
                    float3 tangentViewDir : TEXCOORD1;
                    float2 roomIndex : TEXCOORD2; // передаем индекс комнаты
                };
    
                sampler2D _RoomTex;
                float4 _RoomTex_ST;
                float _RoomMaxDepth01; // Здесь максимальная  глубина
                float2 _RoomCount;
    
                float3 DirObjectSpaceToTangentSpace(float3 inputDirOS, float3 normalOS, float4 tangentOS)
                {
                    float tangentSign = tangentOS.w * unity_WorldTransformParams.w;
                    float3 bitangentOS = cross(normalOS, tangentOS.xyz) * tangentSign;
                    return float3(
                        dot(inputDirOS, tangentOS.xyz),
                        dot(inputDirOS, bitangentOS),
                        dot(inputDirOS, normalOS)
                    );
                }
    
                float2 ConvertOriginalRawUVToInteriorUV(float2 rawUV, float3 tangentViewDir, float maxDepth)
                {
                    // Логика для обработки UV в соответствии с глубиной
                    float depthFactor = tangentViewDir.y / maxDepth; // Используем y-координату для модуляции
                    float2 modifiedUV = rawUV + float2(depthFactor * 0.1, 0); // Простой сдвиг, основанный на направлении взгляда
    
                    return modifiedUV;
                }
    
                v2f vert(appdata v)
                {
                    v2f o;
                    o.pos = UnityObjectToClipPos(v.vertex);
                    o.uv = v.uv * _RoomCount;
                    float3 camPosObjectSpace = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1.0)).xyz;
                    float3 viewDirObjectSpace = v.vertex.xyz - camPosObjectSpace;
                    o.tangentViewDir = DirObjectSpaceToTangentSpace(viewDirObjectSpace, v.normal, v.tangent);
                    o.roomIndex = floor(v.uv); // индекс комнаты
                    return o;
                }
    
                fixed4 frag(v2f i) : SV_Target
                {
                    float2 interiorUV = ConvertOriginalRawUVToInteriorUV(frac(i.uv), i.tangentViewDir, _RoomMaxDepth01);
    
                    interiorUV /= _RoomCount;
                    interiorUV = TRANSFORM_TEX(interiorUV, _RoomTex);
                    interiorUV += i.roomIndex / _RoomCount;
    
                    return tex2D(_RoomTex, interiorUV);
                }
                ENDCG
            }
        }
    }
    

    Комментарии

    1. Простая логика: Логика ConvertOriginalRawUVToInteriorUV была добавлена для работы с UV. Эта функция просто модифицирует UV-координаты на основе tangentViewDir и maxDepth. Вам, возможно, потребуется адаптировать эту логику в зависимости от ваших требований и эффекта, который вы хотите достичь.
    2. Тестирование: Вы можете протестировать и изменять логику модификации UV для достижения желаемого визуального эффекта. Настройте depthFactor и другие параметры, чтобы настроить поведение, как вам нужно.
    3. Оптимизация: Обязательно обращайте внимание на производительность, особенно если данный шейдер будет использоваться в сложных сценах с многими объектами.
  7. User

    нет эффекта глубины

  8. Assistant

    Если вы не получаете ожидаемого эффекта глубины в вашем шейдере, это может быть вызвано несколькими причинами, связанными с логикой обработки UV и визуальным эффектом, который вы хотите достичь. Давайте попробуем улучшить функцию преобразования UV так, чтобы она использовала параметры глубины более эффективно.

    Использование глубины для создания эффекта на основе положения камеры

    Мы можем изменить метод ConvertOriginalRawUVToInteriorUV, чтобы он адаптировал координаты UV в зависимости от глубины по следующему принципу:

    1. Мы можем использовать направление взгляда и его проекцию на плоскость с текстурой, чтобы определить, как именно изменить UV-координаты.
    2. Можно добавить некоторый сдвиг в зависимости от глубины, чтобы добиться эффекта "погружения".

    Вот более детализированный подход:

    Обновленная функция ConvertOriginalRawUVToInteriorUV

    float2 ConvertOriginalRawUVToInteriorUV(float2 rawUV, float3 tangentViewDir, float maxDepth)
    {
        // Нормализация направления
        float3 normalizedTangentViewDir = normalize(tangentViewDir);
        
        // Определяем сдвиг в зависимости от направления взгляда
        // Это может быть настроено, чтобы обеспечить желаемый эффект
        float depthEffect = max(0.0, maxDepth + normalizedTangentViewDir.y * maxDepth * 0.5);
    
        // Сдвиг UV по Y, чтобы создать ощущение глубины
        float2 modifiedUV = rawUV + float2(0, depthEffect);
    
        // Возвращаем измененные UV-координаты
        return modifiedUV;
    }
    

    Полный исправленный шейдер

    Shader "Custom/InteriorMapping - Improved"
    {
        Properties
        {
            _RoomTex("Room Atlas RGB (alpha is not needed)", 2D) = "gray" {}
            _RoomMaxDepth01("Max Interior Depth (in world units)", Float) = 5.0
            _RoomCount("Room Count(X count,Y count)", Vector) = (1,1,0,0)
        }
        SubShader
        {
            Tags { "RenderType" = "Opaque" }
            
            Pass
            {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
                
                #include "UnityCG.cginc"
    
                struct appdata
                {
                    float4 vertex : POSITION;
                    float2 uv : TEXCOORD0;
                    float3 normal : NORMAL;
                    float4 tangent : TANGENT;
                };
    
                struct v2f
                {
                    float4 pos : SV_POSITION;
                    float2 uv : TEXCOORD0;
                    float3 tangentViewDir : TEXCOORD1;
                    float2 roomIndex : TEXCOORD2; // передаем индекс комнаты
                };
    
                sampler2D _RoomTex;
                float4 _RoomTex_ST;
                float _RoomMaxDepth01; // Здесь максимальная глубина
                float2 _RoomCount;
    
                float3 DirObjectSpaceToTangentSpace(float3 inputDirOS, float3 normalOS, float4 tangentOS)
                {
                    float tangentSign = tangentOS.w * unity_WorldTransformParams.w;
                    float3 bitangentOS = cross(normalOS, tangentOS.xyz) * tangentSign;
                    return float3(
                        dot(inputDirOS, tangentOS.xyz),
                        dot(inputDirOS, bitangentOS),
                        dot(inputDirOS, normalOS)
                    );
                }
    
                float2 ConvertOriginalRawUVToInteriorUV(float2 rawUV, float3 tangentViewDir, float maxDepth)
                {
                    // Нормализация направления
                    float3 normalizedTangentViewDir = normalize(tangentViewDir);
                    
                    // Определяем сдвиг в зависимости от направления взгляда
                    float depthEffect = max(0.0, maxDepth + normalizedTangentViewDir.y * maxDepth * 0.5);
    
                    // Сдвиг UV по Y
                    float2 modifiedUV = rawUV + float2(0, depthEffect);
    
                    return modifiedUV;
                }
    
                v2f vert(appdata v)
                {
                    v2f o;
                    o.pos = UnityObjectToClipPos(v.vertex);
                    o.uv = v.uv * _RoomCount;
                    float3 camPosObjectSpace = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1.0)).xyz;
                    float3 viewDirObjectSpace = v.vertex.xyz - camPosObjectSpace;
                    o.tangentViewDir = DirObjectSpaceToTangentSpace(viewDirObjectSpace, v.normal, v.tangent);
                    o.roomIndex = floor(v.uv); // индекс комнаты
                    return o;
                }
    
                fixed4 frag(v2f i) : SV_Target
                {
                    float2 interiorUV = ConvertOriginalRawUVToInteriorUV(frac(i.uv), i.tangentViewDir, _RoomMaxDepth01);
    
                    interiorUV /= _RoomCount;
                    interiorUV = TRANSFORM_TEX(interiorUV, _RoomTex);
                    interiorUV += i.roomIndex / _RoomCount;
    
                    return tex2D(_RoomTex, interiorUV);
                }
                ENDCG
            }
        }
    }
    

    Объяснение изменений

    1. Глубина как эффект сдвига: Вместо прямого использования значений глубины, теперь у нас есть параметр depthEffect, который модифицирует UV на основании направления взгляда. Увеличение значения y в зависимости от этого параметра даёт больше возможностей для создания эффекта глубины.
    2. Нормализация направления: Мы нормализуем tangentViewDir, чтобы избежать искажения при расчете сдвига.

    Теста

    Попробуйте протестировать новый шейдер в вашей среде. Если эффект всё еще недостаточно заметен, вы можете:

    • Настроить коэффициенты в функции depthEffect для того, чтобы он был более агрессивным.
    • Работать с другими осями, изменяя и добавляя сдвиги по x и y для достижения желаемого визуального эффекта.

    Также не забудьте проверить, как масштабирование комнаты _RoomCount может влиять на визуальный результат, и экспериментируйте с настройками текстуры.

  9. User

    мне нужен 2 способ сдвиг в зависимости от глубины, чтобы добиться эффекта "погружения"

  10. Assistant

    Чтобы создать эффект "погружения" сдвига UV-координат на основе глубины, мы можем использовать более сложный подход, который включает в себя как модификацию UV-координат в зависимости от направления взгляда, так и влияние расстояния до камеры. Основная идея — прибавить или вычесть значение, основанное на расстоянии от камеры до поверхности, чтобы создать ощущение глубины.

    Вот как можно реализовать такой подход в вашем шейдере:

    Обновленная функция ConvertOriginalRawUVToInteriorUV

    1. Мы будем использовать tangentViewDir.z (или другую компоненту, которая определяет дистанцию в определенной оси) для создания эффекта модификации UV в зависимости от расстояния.
    2. Мы также можем использовать maxDepth для определения максимальной глубины, до которой будет выполнен сдвиг.
    float2 ConvertOriginalRawUVToInteriorUV(float2 rawUV, float3 tangentViewDir, float maxDepth)
    {
        // Вычисляем расстояние до камеры в мировых координатах
        float distanceToCamera = length(tangentViewDir);
    
        // Нормализуем значение глубины, чтобы использовать его для сдвига
        float depthFactor = saturate(distanceToCamera / maxDepth); // от 0 до 1
        float offset = depthFactor * maxDepth * 0.1; // коэффициент сдвига по вашему усмотрению
    
        // Сдвигаем UV по Y
        float2 modifiedUV = rawUV + float2(0, offset);
    
        return modifiedUV;
    }
    

    Полный шейдер с эффектом глубины

    Теперь обновленный шейдер, который использует вышеописанную логику:

    Shader "Custom/InteriorMapping - DepthEffect"
    {
        Properties
        {
            _RoomTex("Room Atlas RGB (alpha is not needed)", 2D) = "gray" {}
            _RoomMaxDepth01("Max Depth (in world units)", Float) = 5.0 // максимальная глубина
            _RoomCount("Room Count(X count,Y count)", Vector) = (1,1,0,0)
        }
        SubShader
        {
            Tags { "RenderType" = "Opaque" }
    
            Pass
            {
                CGPROGRAM
                #pragma vertex vert
                #pragma fragment frag
                
                #include "UnityCG.cginc"
    
                struct appdata
                {
                    float4 vertex : POSITION;
                    float2 uv : TEXCOORD0;
                    float3 normal : NORMAL;
                    float4 tangent : TANGENT;
                };
    
                struct v2f
                {
                    float4 pos : SV_POSITION;
                    float2 uv : TEXCOORD0;
                    float3 tangentViewDir : TEXCOORD1;
                    float2 roomIndex : TEXCOORD2; // передаем индекс комнаты
                };
    
                sampler2D _RoomTex;
                float4 _RoomTex_ST;
                float _RoomMaxDepth01; // максимальная глубина
                float2 _RoomCount;
    
                float3 DirObjectSpaceToTangentSpace(float3 inputDirOS, float3 normalOS, float4 tangentOS)
                {
                    float tangentSign = tangentOS.w * unity_WorldTransformParams.w;
                    float3 bitangentOS = cross(normalOS, tangentOS.xyz) * tangentSign;
                    return float3(
                        dot(inputDirOS, tangentOS.xyz),
                        dot(inputDirOS, bitangentOS),
                        dot(inputDirOS, normalOS)
                    );
                }
    
                float2 ConvertOriginalRawUVToInteriorUV(float2 rawUV, float3 tangentViewDir, float maxDepth)
                {
                    // Вычисляем расстояние до камеры в мировых координатах
                    float distanceToCamera = length(tangentViewDir);
    
                    // Нормализуем значение глубины
                    float depthFactor = saturate(distanceToCamera / maxDepth); // от 0 до 1
                    float offset = depthFactor * maxDepth * 0.1; // коэффициент глубины
    
                    // Сдвигаем UV по Y для создания эффекта погружения
                    float2 modifiedUV = rawUV + float2(0, offset);
    
                    return modifiedUV;
                }
    
                v2f vert(appdata v)
                {
                    v2f o;
                    o.pos = UnityObjectToClipPos(v.vertex);
                    o.uv = v.uv * _RoomCount;
                    float3 camPosObjectSpace = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1.0)).xyz;
                    float3 viewDirObjectSpace = v.vertex.xyz - camPosObjectSpace;
                    o.tangentViewDir = DirObjectSpaceToTangentSpace(viewDirObjectSpace, v.normal, v.tangent);
                    o.roomIndex = floor(v.uv); // индекс комнаты
                    return o;
                }
    
                fixed4 frag(v2f i) : SV_Target
                {
                    float2 interiorUV = ConvertOriginalRawUVToInteriorUV(frac(i.uv), i.tangentViewDir, _RoomMaxDepth01);
    
                    interiorUV /= _RoomCount;
                    interiorUV = TRANSFORM_TEX(interiorUV, _RoomTex);
                    interiorUV += i.roomIndex / _RoomCount;
    
                    return tex2D(_RoomTex, interiorUV);
                }
                ENDCG
            }
        }
    }
    

    Комментарии к коду

    1. Смещение на основе расстояния: depthFactor вычисляется на основе расстояния до камеры, и это значение используется для сдвига UV-координат.
    2. Коэффициент сдвига: Множитель 0.1 может быть изменён по вашему усмотрению для управления затенением эффекта. Вы можете увеличить его для более заметного эффекта "погружения" или уменьшить, если эффект слишком сильный.
    3. Сатурация: Используемая в saturate функция обеспечивает, что значение переменной depthFactor остаётся в пределах от 0 до 1.
    4. Тестирование: Проверьте, как изменение параметра _RoomMaxDepth01 влияет на визуальный результат. Попробуйте разные значения, чтобы добиться желаемого эффекта.

    Заключение

    Этот вариант должен помочь вам добиться эффекта глубины на основе расстояния до камеры, создавая чувство "погружения". Если эффект все еще не соответствует вашим ожиданиям, рассмотрите возможность дополнительной настройки логики UV и коэффициентов в зависимости от требований вашей сцены.