Material properties in Unity - Step-by-Step Execution

Concept Flow - Material properties

Create Material

↓

Assign Shader

↓

Set Properties

↓

Apply Material to Object

↓

Render Object with Material

This flow shows how a material is created, given a shader, properties are set, then applied to an object for rendering.

Execution Sample

Unity

Material mat = new Material(Shader.Find("Standard"));
mat.color = Color.red;
mat.SetFloat("_Glossiness", 0.5f);
Renderer rend = GetComponent<Renderer>();
rend.material = mat;

This code creates a red material with medium glossiness and applies it to the object's renderer.

Execution Table

Step	Action	Property Changed	Value Set	Effect
1	Create new Material with Standard shader	shader	Standard	Material ready with default properties
2	Set color property	color	red	Material color changes to red
3	Set glossiness property	_Glossiness	0.5	Material surface becomes moderately shiny
4	Get Renderer component	renderer	component found	Ready to assign material
5	Assign material to renderer	material	mat	Object will render with red, glossy material
6	Render frame	N/A	N/A	Object appears red and shiny on screen

💡 All material properties set and applied; rendering completes.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 5	Final
mat	null	Material(Standard)	Material(Standard, color=red)	Material(Standard, color=red, glossiness=0.5)	Material(Standard, color=red, glossiness=0.5)	Material(Standard, color=red, glossiness=0.5)
rend	null	null	null	null	Renderer component	Renderer with mat assigned

Key Moments - 3 Insights

Why do we need to create a new Material instead of modifying the shared material?

Creating a new Material instance (step 1) ensures changes affect only this object. Modifying shared material changes all objects using it, which can cause unexpected results.

What happens if we set a property name incorrectly?

If the property name is wrong (like in step 3), the property won't change and no error appears. The material keeps its previous value, so always check property names carefully.

Why do we assign the material to the renderer instead of the object directly?

The Renderer component controls how the object looks. Assigning material to renderer (step 5) tells Unity what surface appearance to use when drawing the object.

Visual Quiz - 3 Questions

Look at the execution table, what is the material's color after step 2?

A Blue

B Red

C Default (white)

D Green

💡 Hint

Check the 'Property Changed' and 'Value Set' columns at step 2 in the execution table.

At which step is the material assigned to the object's renderer?

A Step 3

B Step 1

C Step 5

D Step 6

💡 Hint

Look for the action 'Assign material to renderer' in the execution table.

If we skip setting the glossiness property, what will happen to the material's appearance?

A It will keep the default glossiness value

B It will be completely matte (no shine)

C It will be fully shiny

D The material will not render

💡 Hint

Refer to step 3 where glossiness is set; skipping it means the default remains.

Concept Snapshot

Material properties control how objects look in Unity.
Create a Material with a Shader.
Set properties like color and glossiness.
Assign the Material to the Renderer component.
Changes affect only that object’s appearance.

Full Transcript

In Unity, materials define how objects appear. First, you create a new Material and assign a shader to it. Then, you set properties such as color and glossiness to change its look. After that, you get the Renderer component of the object and assign the new material to it. This process ensures the object renders with the desired appearance. The execution table shows each step, including creating the material, setting properties, and applying it. Variables like 'mat' and 'rend' track the material and renderer states. Key points include why to create a new material instance, the importance of correct property names, and assigning materials to the renderer. The visual quiz tests understanding of these steps and their effects.

Practice

1. What does renderer.material.color control in Unity?

easy

A. The position of the object

B. The color of the object's material

C. The texture applied to the object

D. The size of the object

Solution

1. Step 1: Understand the property name

   The property color inside renderer.material refers to the color attribute of the material.

2. Step 2: Relate to object appearance

   Changing this property changes how the object looks in terms of color, not texture, position, or size.

3. Final Answer:

   The color of the object's material -> Option B

4. Quick Check:

   renderer.material.color changes color [OK]

Hint: Color property changes object color, not texture or size [OK]

Common Mistakes:

• Confusing color with texture
• Thinking it changes object position
• Assuming it changes object scale

2. Which of the following is the correct way to set a material's color to red in Unity C#?

easy

A. renderer.material.color = Color.red;

B. renderer.material.color = "red";

C. renderer.material.color = new Color(255, 0, 0);

D. renderer.material.color = Color(1, 0, 0);

Solution

1. Step 1: Check Unity color assignment syntax

   Unity uses predefined colors like Color.red or new Color(float r, float g, float b) with values between 0 and 1.

2. Step 2: Evaluate each option

   renderer.material.color = Color.red; uses Color.red correctly. renderer.material.color = "red"; uses a string which is invalid. renderer.material.color = new Color(255, 0, 0); uses integers 255 which is incorrect for Color. renderer.material.color = Color(1, 0, 0); misses new keyword and uses wrong syntax.

3. Final Answer:

   renderer.material.color = Color.red; -> Option A

4. Quick Check:

   Use Color.red constant for red color [OK]

Hint: Use Color.red constant, not strings or 255 values [OK]

Common Mistakes:

• Using string "red" instead of Color.red
• Using 255 instead of 1 for color values
• Missing 'new' keyword for Color constructor

3. What will be the output color of the object after running this code?

renderer.material.color = new Color(0.5f, 0.2f, 0.7f);

medium

A. Bright green

B. Black

C. Pure red

D. A shade of purple

Solution

1. Step 1: Understand the Color constructor values

   The values represent red=0.5, green=0.2, blue=0.7 on a scale from 0 to 1.

2. Step 2: Interpret the color mix

   Red and blue are medium to high, green is low, so the color will be a purple shade (mix of red and blue).

3. Final Answer:

   A shade of purple -> Option D

4. Quick Check:

   Color(0.5,0.2,0.7) = purple shade [OK]

Hint: Red + Blue mix with low green = purple shade [OK]

Common Mistakes:

• Assuming values are 0-255 instead of 0-1
• Confusing color channels order
• Thinking low green means green color

4. Identify the error in this Unity C# code snippet that tries to change material shininess:

renderer.material.shininess = 0.8f;

medium

A. Material does not have a 'shininess' property directly accessible

B. The value 0.8f is out of range

C. Missing semicolon at the end

D. Should use renderer.material.color instead

Solution

1. Step 1: Check if 'shininess' is a direct property

   Unity's standard material does not have a direct 'shininess' property; shininess is controlled via shader properties like '_Glossiness'.

2. Step 2: Correct way to set shininess

   You must use renderer.material.SetFloat("_Glossiness", 0.8f); to change shininess.

3. Final Answer:

   Material does not have a 'shininess' property directly accessible -> Option A

4. Quick Check:

   Use SetFloat for shininess, no direct property [OK]

Hint: Use SetFloat("_Glossiness", value) for shininess [OK]

Common Mistakes:

• Trying to access non-existent 'shininess' property
• Confusing shininess with color
• Ignoring shader property naming

5. You want to change the texture of a material at runtime in Unity. Which code snippet correctly does this assuming you have a Texture variable named newTexture?

hard

A. renderer.material.SetColor("_MainTex", newTexture);

B. renderer.material.color = newTexture;

C. renderer.material.mainTexture = newTexture;

D. renderer.material.texture = newTexture;

Solution

1. Step 1: Identify the correct property for texture

   The main texture of a material is accessed via mainTexture property.

2. Step 2: Check each option's validity

   renderer.material.mainTexture = newTexture; correctly assigns newTexture to mainTexture. renderer.material.color = newTexture; wrongly assigns texture to color. renderer.material.SetColor("_MainTex", newTexture); uses SetColor with a texture which is invalid. renderer.material.texture = newTexture; uses a non-existent 'texture' property.

3. Final Answer:

   renderer.material.mainTexture = newTexture; -> Option C

4. Quick Check:

   Use mainTexture to set material texture [OK]

Hint: Use mainTexture property to change textures [OK]

Common Mistakes:

• Assigning texture to color property
• Using SetColor instead of SetTexture
• Using wrong property name 'texture'