How to change material on a gameobject by rotation?

Issue

I want to change between 2 materials, depending on the platforms (gameobject) rotation. Here is what I've done so far:

public class PlatformSpawner : MonoBehaviour
{
    public GameObject platform;
    public Material[] platformMaterial;
    Material currentMaterial;
    Renderer _renderer;
}

    void Start()
    {
        _renderer = this.GetComponent<Renderer>();
    }

I also wrote this, but I don't want to change materials by buttons:

    public void LeftTurn()
    {
        _renderer.material = platformMaterial[0];
        currentMaterial = _renderer.material;
    }
    public void RightTurn()
    {
        _renderer.material = platformMaterial[1];
        currentMaterial = _renderer.material;
    }
}

And this is where the platform rotates randomly 90 degrees to the left or to the right:

    public struct SpawnPoint
    {
        public Vector3 position;
        public Quaternion orientation;

        public void Step(float distance)
        {
            if (Random.value < 0.5)
            {
                position.x += distance;
                orientation = Quaternion.Euler(0, 90, 0); //change to one of the materials
            }
            else
            {
                position.z += distance;
                orientation = Quaternion.Euler(0, 0, 0); //change to the other of the materials.
             //This is where I want to material to switch.
             //When the objects position changes, the material changes too.
            }
        }
    }

There is a picture of the gameplay. I want to change the material of all the corner platforms to have a nice curve line view.

Can anyone help me what and how to do in this case? I am a bit lost there. Every help is highly appreciated!

EDIT: new code looks like that. The only issue is that Unity gives me 15 errors (see on the picture below), even if Visual Studio says no issue has been found. The errors refer to the switch.

public class PlatformSpawner : MonoBehaviour
{
    public GameObject platform;
    public Transform lastPlatform;
    SpawnPoint _spawn;
    bool stop;

    public Material straightMaterial;
    public Material turnLeftMaterial;
    public Material turnRightMaterial;
    public Renderer roadPrefab;

    [System.Serializable]

    public struct SpawnPoint
    {
       public Vector3 position;
        public Quaternion orientation;
        public RoadType type;

        public enum RoadType
        {
            Straight,
            LeftTurn,
            RightTurn
        }

        private enum Direction
        {
            Z,
            X,
        }

        private Direction lastDirection;

        public void Step(float distance)
        {
            type = RoadType.Straight;

            if (Random.value < 0.5f)
            {
                position.x += distance;
                orientation = Quaternion.Euler(0, 90, 0);
                if (lastDirection == Direction.Z)
                {
                    type = RoadType.RightTurn;
                }
            }
            else
            {
                position.z += distance;
                orientation = Quaternion.Euler(0, 0, 0);
                if (lastDirection == Direction.X)
                {
                    type = RoadType.LeftTurn;
                }

                lastDirection = Direction.Z;
            }
        }
    }

    void Start()
    {
        _spawn.position = lastPlatform.position;
        _spawn.orientation = transform.rotation;

        StartCoroutine(SpawnPlatforms());
    }

    IEnumerator SpawnPlatforms()
    {
        while (!stop)
        {
            var _spawn = new SpawnPoint();

            for (var i = 0; i < 20; i++)
            {
                var newPlatform = Instantiate(roadPrefab, _spawn.position, _spawn.orientation);

                _spawn.Step(1.5f);

                var roadMaterial = _spawn.type switch
                {
                    SpawnPoint.RoadType.LeftTurn => turnLeftMaterial,
                    SpawnPoint.RoadType.RightTurn => turnRightMaterial,
                    _ => straightMaterial
                };

                newPlatform.GetComponent<Renderer>().material = roadMaterial;

                yield return new WaitForSeconds(0.1f);
            }
        }
    }
}

Solution

So it sounds like you basically have a working system for switching the materials and spawning you road parts and materials already look correctly according to your rotations - now you only need to identify the curves.

Actually this is pretty simple:

• is the current part in X direction and the next will be in Z -> Left Turn
• is the current part in Z direction and the next will be in X -> RightTurn
• any other case is straight

So you could probably do something like

public struct SpawnPoint
{
    public Vector3 position;
    public Quaternion orientation;
    public RoadType type;

    public enum RoadType
    {
        Straight,
        LeftTurn,
        RightTurn
    }

    private enum Direction
    {
        // since your orientation by default equals the Z direction use that as default value for the first tile
        Z,
        X, 
    }
    private Direction lastDirection;

    public void Step(float distance)
    {
        type = RoadType.Straight;

        if (Random.value < 0.5f)
        {
            position.x += distance;
            orientation = Quaternion.Euler(0, 90, 0);

            if(lastDirection == Direction.Z)
            {
                type = RoadType.RightTurn;
            }

            lastDirection = Direction.X;
        }
        else
        {
            position.z += distance;
            orientation = Quaternion.Euler(0, 0, 0); 

            if(lastDirection == Direction.X)
            {
                type = RoadType.LeftTurn;
            }

            lastDirection = Direction.Z;
        }
    }
}

And you didn't show your spawn code but I would assume something like

public class Example : MonoBehaviour
{
    public Material straightMaterial;
    public Material turnLeftMaterial;
    public Material turnRightMaterial;

    public Renderer roadPrefab;

    private void Awake()
    {
        var spawnPoint = new SpawnPoint();
        
        for(var i = 0; i < 20; i++)
        {
            var roadTile = Instantiate(roadPrefab, spawnPoint.position, spawnPoint.orientation);

            // do the Step after spawning the current tile but before assigning the material
            // -> we want/need to know already where the next tile is going to be
            spawnPoint.Step(1f);
            
            var roadMaterial = spawnPoint.type switch
            {
                SpawnPoint.RoadType.LeftTurn => turnLeftMaterial,
                SpawnPoint.RoadType.RightTurn => turnRightMaterial,
                _ => straightMaterial
            };

            roadTile.GetComponent<Renderer>().material = roadMaterial;
        }
    }
}

Behold my Paint skills ;)

Answered By - derHugo