Different Texture appearance between SetTexture() and mat.mainTexture

Unity Engine
1

Hallo everyone, this is my first post in this forum so forgive me if this is the wrong section.

Sorry for my english too, isn’t my mother language sorry :stuck_out_tongue:

I’ve done the full system to procedurally generate my world (in this case my World Map) and I want to take care about perfomance using shader (well the appearence too since using shader result in a more gorgeus appearence with some custom made calculations).

Previously I was using mat.mainTexture = myTexture2D in applyin my Texture2D heightMapTexture and everything was fine (except for the appearence ofcourse), now I switched to a Custom Shader and tryin to use the exact same custom texture using mat.SetTexture(), but here comes the problem.

Most of my systems takes care about heights, I draw colors using those heights and when I have to spawn something I refer to the heightArray to check if it is a valid spot or not, so the height are crucial in the game.
Since using shader often my spawns popup on uncorrect spots (like water ones), I’ve analyzed the problem so far and finally found what cause the problem: applyin the procedural generated texture to the material via mat.mainTexture = myTexture2D results in a correct texture where pixel greyScale (or color, doesn’t make any difference) are equivalent to the height inside heightMap array, while applying the exact same texture to material using mat.SetTexture(“_MainTex”, myTexture2D) results in a slightly different texture where pixels are darker like if the height is lower.

In the example below I’ve used the same material with the same shader, the same values to generate the heightMap array, the same heightMap array, two same procedural generated Meshes and the exact same way to draw pixels with the exact same value on my Texture2D (the height from heightMap array).

The shader is just a Standard Surface Shader and I’ve also used different shaders (built in ones and new custom ones too, as can be seen in the example below) with the exact same result.

Ofcourse the result won’t change if I switch to actual colors from a table of greyscale.

Finally no interpolation (lerp, inverselerp, planar mapping, etc) and blending are being applied to the values used for pixels (float height) neither to the color value drawn on the texture (which is in the form of colorMap[ID] = new Color(height, height, height); ), just the plain “float height” value applied as Color using SetPixels using an array of colors (not Color32 and SetPixels32, anyway I’ve tried using them too with the same result as below) on an object, and the “float height” as Color using mat.mainTexture = myTexture2D in the other obejct.

I’ve also tried to use repeat wrapMode over clamp and point filtering over bilinear and trilinear, changed the anisioLevel too, I’ve also used some sort of interpolation (lerping colors on CPU, on shader, blending colors on CPU and on shader) but while the result cover the uncorrect spots, raise the other ones too and doesn’t fix the problem at all, and I’ve tried to use different textureformats (ARGB32, RGBA32, RGB24, RGBA444, RGB565, etc) but the result is always the same as shown here below.

I really need to have the exact pixel rapresentation from the heightMap array inside shaders, I’ve thought to use mat.mainTexture = myTexture2D but from my big ignorance with shaders I think isn’t an elegant aproach and I guess is way more flexible to use SetTexture(); so please help me since this problem is driving me crazy.

Inside shader (Standard Surface, used to show the example in the images below) I’ve used so many aproaches that I can’t remember (inverseLerp between colors, blending, plain color, greyscale over colors, maths to get the height starting from the vertex position inside vert method declared in #pragma, getting greyscale from the tex2D(_MainTex, IN.uv_MaintTex and using it to color the pixel), I’ve just tryed the most basic operation possible to study the problem: “o.Albedo = tex2D(_MainTex, IN.uv_MainTex)”; and also used “fixed4 c = tex2D(_MainTex, IN.uv_MainTex); o.Albedo = c.rgb; o.Alpha = c.a;” and as you can easly know at this point nothing won’t to fix this unwanted behaviour.

PS: I didn’t post the code since it’s pretty huge, so if you need something specifically just tell me and I’ll post it: the meshes (and their UVs) are built in a method which calls Mesh_Data class ctor, the method to build mesh is called twice to build 2 different meshes, the heightMap array is built in a method called from a class, the heithMapTexture is built inside another method called at the end of the method in charge of building the heightMap array, can’t copy paste the entire code since is something over 4000 lines of code fully commented, so if you need soemthing just tell me and I’ll post the exact piece, every method works regardless the others so can be called directly without any problem or correlation with other methods. The shader used inside this example shown in the following images is a Surface one having inside surf function the only line “o.Albedo = tex2D(_MainTex, IN.uv_MainTex);”.

Please help me, I need pixels to have colors exactly to the height values but using shader over CPU; I really don’t know what else to do since I’m a total noob with shaders (and I have 0 or less knowledge about ShaderGraph neither I know where I can find tutorials or explanation about them).

Thanks a lot

Following the Images explain the problem:
6138093--669684--CPU Tex Setting.PNG 6138093--669687--Shader Texture setting.PNG

6138093--669690--Wierd Behaviour Point filtering.PNG
6138093--669690--Wierd Behaviour Point filtering.PNG1307×659 70.5 KB
6138093--669693--Wierd Behaviour.PNG
6138093--669693--Wierd Behaviour.PNG1198×604 215 KB

2

There is no difference between material.mainTexture = myTexture; and material.SetTexture("_MainTex", myTexture);. The former is literally an internal alias for the later; it’s using the exact same code path. You can even see that in the source code here:

But, I noticed nowhere in the giant block of text above do you mention the single most important thing.

sRGB vs linear

By default all textures in Unity use sRGB color space. This is separate from the “Gamma” and Linear color space settings for the project, though they’re related. An sRGB color texture is one where the color values stored in the texture are assumed to be colors in sRGB space. When the GPU reads the texture, it’ll apply the sRGB transform to the color values. A linear color texture is one where the color values stored in the texture are assumed to be in linear space. When the GPU reads the texture, it’ll just return the raw float value.

Note I always say “color”. Only the RGB color components are affected. The alpha channel is always in linear space.

So, if you want a texture that’s linear data, like a height map, you’ll want to create the texture as a linear texture. For imported textures this is as simple as unchecking the sRGB (Color Texture) option on the import settings. For a texture created from script, the Texture2D needs to be created set to be a linear texture.

See the third method for creating a new Texture2D in the documentation.

Alternatively if you only need a greyscale value, you can create the texture as an Alpha8 and it’ll always be linear values. Also any floating point texture format (*Half or *Float formats) are always linear.

3

Thanks a lot for your answer and sorry for the big wall of text :sweat_smile:.

Anyway I’ve just give the linear option a try and doesn’t seems to work (tryed using linear and sRGB also if during all my trials it seems I’ve worked with sRGB as you mentioned in your message).

I’ve already tryed with Alpha8 format, but doesn’t show anything at all just two big black planes and the texture inside material appears as a white texture (probably because of the _MainTexture declared as white inside Shader? Don’t know).

PS: I’ve also switched mipmap bool from true to false and viceversa.

PSS: I’m using greyScale but the shader is supposed to draw colors from a custom palette based on the greyScale value of a processed pixel, so inside my systems I use the actual height value, inside shader I use greyscale but as I’ve already said I need pixels drawn in shader to be equivalent to the heights fro mthe heightmap, but well the texture appear to be different inside material.

Following the code used and the images:

heightTexture = new Texture2D(width, depth, TextureFormat.ARGB32, false, true)
            {
                wrapMode = TextureWrapMode.Clamp,
                filterMode = FilterMode.Trilinear,
                anisoLevel = 9,
            };

6139236--669897--Linear.PNG 6139236--669900--mainTexture.PNG 6139236--669903--Shader.PNG

4

Sure, probably because your shader is using one of the RGB channels. An Alpha8 format only has data in the alpha channel, so you need to do something like this:

float height = tex2D(_MyHeightTexture, i.uv).a;

And if you really only need a greyscale value, you shouldn’t use an ARGB32 anyway since you’re just wasting all that extra memory on data that’s never used. You should absolutely be using R8, Alpha8, or maybe RHalf if you need something with more precision.

Okay, how are you setting the texture then? I’m still not sure I understand what the difference between the two images are in terms of what you’re doing in the code to produce them. To reiterate, there’s nothing the SetTexture / mainTexture can do to change the textures as it’s the same code internally, but that’s the only thing I saw you say was different between the two. But that can’t be the only difference.

Also it’s unlikely there’s anything you’re doing in the shader that would be a problem either in terms of how the two would look, but without seeing that I won’t know for sure either.

You need to post more of the c# and shader code for me to be able to offer any real help.

5

Oh well didn’t thought about using just the alpha channel as color in shader while using Alpha8, as I’ve already said I’m noob like hell with shaders and usually I involuntarly forgot obvious passages; anyway changing it doesn’t provide any accettable results (the texture still appears white in the material, I know I’m doin something really wrong but I’m still learning shaders and in the future I just need the greyscale texture to apply colors thanks to the shader, so I don’t know if using Alpha8 is the right way to do it).

About the code I’ll copy paste the method I’m using to draw the texture via C# and the method to pass data to the shader in the form of SetTexture(), I’ll put the shader code too (also if it is containing just the simple line o.Albedo = tex2D(Tex, uvTex); ).

The following the method to build the texture and apply it to the material:

private IEnumerator BuildHeightMapTexture(float[,] noiseMap, Chunk mapChunk, TerrainTypes terrain, CommonData.BlendMode blendMode)
        {
            int width = noiseMap.GetLength(0);
            int depth = noiseMap.GetLength(1);
            Texture2D heightTexture;
            TerrainTypes.TerrainTypesPalette[] palette = (typeof(T) == typeof(ProceduralMap)) ? terrain.palette : terrain.palette;
            Vector2 startPos = new Vector2(mapChunk.chunkPos.x, mapChunk.chunkPos.y);


            heightTexture = new Texture2D(width, depth, TextureFormat.Alpha8, false, true)
            {
                wrapMode = TextureWrapMode.Clamp,
                filterMode = (blendMode == CommonData.BlendMode.Blend) ? FilterMode.Trilinear : FilterMode.Point,
                anisoLevel = 9,
            };

            Color[] colorMap = new Color[width * depth];

            Color black = Color.black;
            Color white = Color.white;

            for (int y = (int)startPos.y, i = 0; y < depth + (int)startPos.y; y++)
            {
                if (y - (int)startPos.y % CommonData.textureScale == 0)
                    yield return frameEnd;

                for (int x = (int)startPos.x; x < width + (int)startPos.x; x++, i++)
                {
                    int fixedX = x - (int)startPos.x;
                    int fixedY = y - (int)startPos.y;
                
                    float height = noiseMap[fixedX, fixedY];

                    switch (Map_Type)
                    {
                        case MapType.HeightMap:
                            colorMap[i] = new Color(height, height, height);
                            break;
                        case MapType.ColorMap:
                            colorMap[i] = new Color(height, height, height);
                            break;
                        case MapType.FalloffMap:
                            colorMap[i] = TryGetColor(height, palette, blendMode);
                            break;
                        default:
                            if (noiseMap[fixedX, fixedY] == 0)
                                colorMap[i] = Color.green;
                            else
                                colorMap[i] = Color.blue;
                            break;
                    }
                }
            }

            heightTexture.SetPixels(colorMap);
            heightTexture.Apply();
            heightTexture.name = (typeof(T) == typeof(ProceduralMap)) ? "Map Texture" : "Shrine Texture";


            if (typeof(T) == typeof(ProceduralMap))
            {
                GameData.GPD.mapTexture = heightTexture;
                mapChunk.worldObject.AddComponent<ShaderDataTransfer>().Setup(heightTexture, palette, vertexHeightMap);
            }
            else if (typeof(T) == typeof(ProceduralNatural))
            {
                mapChunk.worldObject.GetComponent<MeshRenderer>().material.mainTexture = heightTexture;
            }
}

Following the methods used to setup SetTexture() to material (is simple because all the other lines are commented for debug, otherwise it should stay as it is because of other commands done inside the method which for the purpose of the example aren’t usefull and the yare commented at the moment, like the terrain.Palette unused for now inside Setup() and SetupShader()):

    public void Setup(Texture2D noiseTex, TerrainTypes.TerrainTypesPalette[] palettes, float[,] vertexHeightMap)
    {
        this.noiseTex = noiseTex;

        mat = GetComponent<MeshRenderer>().material;
    }

    private void OnWillRenderObject()
    {
        SetupShader();
    }

public void SetupShader()
    {

        mat.SetTexture("_MainTex", noiseTex);

}

Here the shader (the texture saved as “grey” is actualyl “white” but the it seems I can’t edit the message to change it):

Properties
    {
        _MainTex("Noise", 2D) = "grey"{}
    }
        SubShader
    {
        Tags{ "RenderType" = "Opaque" }
        LOD 200

        CGPROGRAM

        // Physically based Standard lighting model, and enable shadows on all light types
        #pragma surface surf Standard fullforwardshadows vertex:heightFromVerticesPosition

        // Use shader model 3.0 target, to get nicer looking lighting
        #pragma target 3.0

      
        sampler2D _MainTex;



        struct Input
        {
            float2 uv_MainTex;
        };

        void surf(Input IN, inout SurfaceOutputStandard o)
        {
            fixed4 c = tex2D(_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
        }

        ENDCG
    }
    FallBack "Diffuse"
}
6

You’re not setting the alpha when defining the color, so it’s using a default of 1.0f.

But you still haven’t explained the most important part. What’s the difference between the code path where it “works” and the code path where it doesn’t? You say it’s the “same texture”, but it literally can’t be because if it was it’d be the same. So there’s still something else in the code path that’s different.

Though there is one thing that might be throwing you off. The display of textures in the UI is semi-broken and may or may not properly get gamma correction applied due to various bugs in Unity’s UI system. You may be hyper focusing on the fact the UI shows differently, but the actual shader might be identical. I’d try doing this before making any other changes:

fixed4 c = tex2D(_MainTex, IN.uv_MainTex);

// assuming you're still using an RGB24 or ARGB32 texture format
if (c.r > 0.5)
  c.rgb *= fixed3(0,1,0);
else
  c.rgb *= fixed3(1,0,0);

// set emission instead of o.Albedo so it's not affected by lighting
o.Emission = c;

Because the default gray texture is named “gray” and not “grey”.

1 Like
7

As you can see below (and also in the last lines in the first block of code inside my previous message) the changes are really simple, both images actually work but the following one produce the strange behaviour that can be seen in the image on the right in my previous message:

if (typeof(T) == typeof(ProceduralMap))
            {
                GameData.GPD.mapTexture = heightTexture;
                mapChunk.worldObject.AddComponent<ShaderDataTransfer>().Setup(heightTexture, palette, vertexHeightMap);
            }
            else if (typeof(T) == typeof(ProceduralNatural))
            {
                mapChunk.worldObject.GetComponent<MeshRenderer>().material.mainTexture = heightTexture;
            }

The problem seems to show up when I set my texture via Setup(heightTexture, palette, vertexHeightMap); and the code behind this call is the following:

public void Setup(Texture2D noiseTex, TerrainTypes.TerrainTypesPalette[] palettes, float[,] vertexHeightMap)
    {
        this.noiseTex = noiseTex;
        mat = GetComponent<MeshRenderer>().material;
    }
    private void OnWillRenderObject()
    {
        SetupShader();
    }
public void SetupShader()
    {
        mat.SetTexture("_MainTex", noiseTex);
}

With that said, the problem appears when I use this method over the material.mainTexture = heightTexture; (which leads to the result visible in the image on the left in my previous message which is the one I’m tryin to get with the second aproach: SetTexture();).

Here about the spelling is ok, I’ll try to set it as “gray” and I’ll give it a try, but I think (sorry if I’m wrong) with “white” keyword on _MainTex it should work as if it is “gray” while using Alpha8 format or not? If this is the case I’ve already tried with “white” and Alpha8 and doesn’t work.

But probably with the “gray” spelling and the Color c = new Color(height, height, height, height); changes, the Alpha8 format with the shader just getting “float height = tex2D(_MyHeightTexture, i.uv).a;” as color (o.Albedo = height; maybe? or maybe o.Albedo = float3(height, height, height)? I don’t knwo I’ll do some try) it get fixed while in Alpha8.

Yes I’ve not setup the alpha inside color since till now I was using ARGB32 format so I thought it was unecessary considering that in shader I actually didn’t minimally care about o.Alpha.

Well I wasn’t aware about this behaviour and now I will get over about the gamma inside material texture in the inspector.

Anyway I’ve also tried to setup a plain color (green, blue and black) inside shader based on the “height” of the pixel (using its greyScale ofcourse as height) but what I’ve seen is that the colors get drawn on the texture properly but the entire texture seems “lower” then the one applied via mainTexture; the colors appears where they should be but once it gets closer to the borders it “lower faster” like is clearly visible on the Images in my previous message.

I will try to use your advice inside shader again, and I’ll give you updates.

Thanks a lot for your help and patience, I know I’m driving you crazy with my noobness with shaders (which I’m sorry about).

8

Stop thinking about the texture as color and think about it as arbitrary data, since as a height map that’s what it is. o.Alpha and the alpha channel of a texture are in no way related unless you write code that links them together.

o.Albedo = tex2D(_MainTex, IN.uv_MainTex).aaa;

Is just as valid as:

o.Alpha = tex2D(_MainTex, IN.uv_MainTex).r;

Which just as valid as:

fixed4 c = tex2D(_MainTex, IN.uv_MainTex);
o.Albedo = c.rgb;
o.Alpha = c.a;

It all comes down to what kind of data you’ve chosen to store in what channel.

9

Ok applyin the height value to the Alpha channel inside new Color(); and turning the format to Alpha8 makes the both approaches result in the same texture being shown up, Because of this I’ve thought there was a problem in the process of creating texture using colors at this point, so probably it was inside the class to geenrate the heights which the texture is made from.

With that said I’ve reverted the code to ARGB32 and I’ve tried the second way you adviced me (with red and green) and looked for the entire process of texture generation and found I was applyin a falloff a bit bigger then the other one with maintexture approach.

Thanks a lot for your help, with your advices you helped me in finding the problem.

Really really thank you.

PS: I’m sorry about that because of this stupid and simple overlook, with a huge code base soemthing get lost soemtime and since I’m noob with shaders (no more thanks to your explanations) I thought it was a shader problem (I mean me coding it in a bad way) instead because of a simpel enum.

1 Like