Правильная мозаика текстур атласа с помощью настраиваемого шейдера в Unity

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

Вот код перед шейдером:

Rect surfaceTextureRect = uvReMappers[textureIndex];
Mesh surfaceMesh = allFaces[i].mesh;
Vector2[] atlasTexturePosition = new Vector2[surfaceMesh.uv.Length];
Vector2[] atlasTextureSize = new Vector2[surfaceMesh.uv.Length];
for (int j = 0; j < atlasTexturePosition.Length; j++)
{
    atlasTexturePosition[j] = new Vector2(surfaceTextureRect.x, surfaceTextureRect.y);
    atlasTextureSize[j] = new Vector2(surfaceTextureRect.width, surfaceTextureRect.height);
}
surfaceMesh.uv2 = atlasTexturePosition;
surfaceMesh.uv3 = atlasTextureSize;

Вот код шейдера:

tex2D(_MainTex, float2((frac(IN.uv.x) * IN.uv3.x) + IN.uv2.x, (frac(IN.uv.y) * IN.uv3.y) + IN.uv2.y));

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

Мой сценарий - это настраиваемый воксельный движок, который может обрабатывать все, от Minecraft до рендеринга планет на основе вокселей, и я еще не нашел сценарий, с которым он еще не справился.

Вот мой код для атласа ...

using UnityEngine;
using Voxels.Objects;

namespace Engine.MeshGeneration.Texturing
{
    /// <summary>
    /// Packed texture set to be used for mapping texture info on 
    /// dynamically generated meshes.
    /// </summary>
    public class TextureAtlas
    {
        /// <summary>
        /// Texture definitions within the atlas.
        /// </summary>
        public TextureDef[] Textures { get; set; }

        public TextureAtlas()
        {
            SetupTextures();
        }

        protected virtual void SetupTextures()
        {
            // default for bas atlas is a material with a single texture in the atlas
            Textures = new TextureDef[]
            {
                new TextureDef 
                { 
                    VoxelType = 0, 
                    Faces =  new[] { Face.Top, Face.Bottom, Face.Left, Face.Right, Face.Front, Face.Back },
                    Bounds = new[] {
                        new Vector2(0,1), 
                        new Vector2(1, 1),
                        new Vector2(1,0),
                        new Vector2(0, 0)
                    }
                }
            };
        }


        public static TextureDef[] GenerateTextureSet(IntVector2 textureSizeInPixels, IntVector2 atlasSizeInPixels)
        {
            int x = atlasSizeInPixels.X / textureSizeInPixels.X;
            int z = atlasSizeInPixels.Z / textureSizeInPixels.Z;
            int i = 0;
            var result = new TextureDef[x * z];
            var uvSize = new Vector2(1f / ((float)x), 1f / ((float)z));

            for (int tx = 0; tx < x; tx++)
                for (int tz = 0; tz < z; tz++)
                {
                    // for perf, types are limited to 255 (1 byte)
                    if(i < 255)
                    {
                        result[i] = new TextureDef
                        {
                            VoxelType = (byte)i,
                            Faces = new[] { Face.Top, Face.Bottom, Face.Left, Face.Right, Face.Front, Face.Back },
                            Bounds = new[] {
                                new Vector2(tx * uvSize.x, (tz + 1f) * uvSize.y), 
                                new Vector2((tx + 1f) * uvSize.x, (tz + 1f) * uvSize.y),
                                new Vector2((tx + 1f) * uvSize.x, tz * uvSize.y),
                                new Vector2(tx * uvSize.x, tz * uvSize.y)
                            }
                        };

                        i++;
                    }
                    else
                        break;
                }

             return result;
        }
    }
}

А для определения текстуры в атласе ...

using UnityEngine;
using Voxels.Objects;

namespace Engine.MeshGeneration.Texturing
{
    /// <summary>
    /// Represents an area within the atlas texture 
    /// from which a single texture can be pulled.
    /// </summary>
    public class TextureDef
    {
        /// <summary>
        /// The voxel block type to use this texture for.
        /// </summary>
        public byte VoxelType { get; set; }

        /// <summary>
        /// Faces this texture should be applied to on voxels of the above type.
        /// </summary>
        public Face[] Faces { get; set; }

        /// <summary>
        /// Atlas start ref
        /// </summary>
        public Vector2[] Bounds { get; set; }
    }
}

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

Тогда UV-координаты для данного лица данного типа вокселей равны ...

IEnumerable<Vector2> UVCoords(byte voxelType, Face face, TextureAtlas atlas)
        {
            return atlas.Textures
                .Where(a => a.VoxelType == voxelType && a.Faces.Contains(face))
                .First()
                .Bounds;
        }

В вашем случае у вас, вероятно, есть другой способ сопоставления с выбранной текстурой из вашего пакета, но, по сути, комбинация лица и типа в моем случае - это то, что определяет набор УФ-сопоставления, который я хочу.

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

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

Вот код: вам нужно определить 2D переменные _MainTex и _PatternTex.

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


        float modFunction(float number, float divisor){
            //2018-05-24: copied from an answer by Nicol Bolas: https://stackoverflow.com/questions/35155598/unable-to-use-in-glsl
            return (number - (divisor * floor(number/divisor)));
        }


        fixed4 frag (v2f i) : SV_Target
        {
            fixed4 curColor = tex2D(_MainTex, i.uv);                
            fixed4 pattern = tex2D(_PatternTex, 
                float2(
                    modFunction(i.uv.x*_MainTex_TexelSize.z,_PatternTex_TexelSize.z) *_PatternTex_TexelSize.x,
                    modFunction(i.uv.y*_MainTex_TexelSize.w,_PatternTex_TexelSize.w) *_PatternTex_TexelSize.y
                )
            );
            fixed4 col = curColor * pattern;                
            col.rgb *= col.a;
            return col;
        }