# SetShaderUserValue(uint)

> Assign a custom value to this renderer.

## Definition

* **Type:** Method
* **Namespace:** [UnityEngine](/engine/6000.3/script-reference/unityengine.md)
* **Assembly:** UnityEngine.CoreModule

```csharp
public void SetShaderUserValue(uint v)
```

### Parameters

**** (\[uint]\(https\://learn.microsoft.com/dotnet/api/system.uint32)): The integer to assign to the renderer as a custom value to be used in shaders.

### Remarks

The `SetShaderUserValue` method assigns a custom integer value to a renderer. You can then access the value in your shaders as the `unity_RendererUserValue` variable. You can use this method to change how a shader draws each renderer, without using different materials or additional CPU time.

**Note**: The value of the `unity_RendererUserValue` shader variable will always be 0 in the following situations:

* The shader is written for the Built-In Render Pipeline.
* When baking lightmaps or light probes.

**Note**: The value is not serialized, so it is not saved to the asset and resets when the object is reloaded.

Additional Resources: [MeshRenderer.GetShaderUserValue](/engine/6000.3/script-reference/unityengine/meshrenderer/getshaderuservalue.md).

The following code sample creates a [MonoBehaviour](/engine/6000.3/script-reference/unityengine/monobehaviour.md) to assign a specific color value on a renderer by encoding it in a `uint`.

```csharp
using UnityEngine;
using UnityEngine.Rendering;

[ExecuteAlways]
public class PerRendererColor : MonoBehaviour
{
    public Color color = Color.white;

    private MeshRenderer m_Renderer;

    void Start()
    {
        m_Renderer = GetComponent<MeshRenderer>();
    }

    void Update()
    {
        if (m_Renderer)
        {
            Color32 colorb = color;
            uint packedColor = (uint)colorb.r | ((uint)colorb.g << 8) | ((uint)colorb.b << 16);
            m_Renderer.SetShaderUserValue(packedColor);
        }
    }
}
```

The corresponding shader code unpacks the unsigned integer into an RGB float triplet in the fragment shader.

```csharp
// This shader fills the mesh shape with the color packed in the renderer's user value.
Shader "Example/URPUnlitUserValue"
{
    Properties
    { }

    SubShader
    {
        Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" }

        Pass
        {
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            struct Attributes
            {
                float4 positionOS   : POSITION;
            };

            struct Varyings
            {
                float4 positionHCS  : SV_POSITION;
            };

            Varyings vert(Attributes IN)
            {
                Varyings OUT;
                OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
                return OUT;
            }

            half4 frag() : SV_Target
            {
                // Decoding the user value color and returning it.
                uint3 c = uint3(unity_RendererUserValue & 0xFF, (unity_RendererUserValue >> 8) & 0xFF, (unity_RendererUserValue >> 16) & 0xFF);
                return half4(half3(c) / 255.0f, 1.0f);
            }
            ENDHLSL
        }
    }
}
```