Blender Quiz: Add Image Texture Nodes And Connect Them Correctly Color Space Awareness Intro
10 questions · exam conditions
0:00
Add Image Texture Nodes And Connect Them Correctly Color Space Awareness IntroQuestion 1 of 10

A material uses two files: a photographed albedo image and a grayscale roughness map exported from a texturing application. The roughness file stores roughness directly, with lighter pixels intended to produce rougher areas.

Which Image Texture node setup preserves the intended interpretation of both files?

Set both images to sRGB; connect albedo Color to Base Color and roughness Color to Roughness.
Set albedo to Non-Color and roughness to sRGB; connect their Color outputs to the corresponding inputs.
Set albedo to sRGB and roughness to Non-Color; connect their Color outputs to Base Color and Roughness.
Set both images to Non-Color; connect albedo Color to Base Color and roughness Alpha to Roughness.
← Back to quizzes

Blender Quiz

Blender Quiz: Add Image Texture Nodes And Connect Them Correctly Color Space Awareness Intro

Practice Add Image Texture Nodes And Connect Them Correctly Color Space Awareness Intro in Blender with focused quiz questions that help you check what you know, review explanations, and build confidence with test-style prompts.

What this quiz covers

This quiz focuses on Add Image Texture Nodes And Connect Them Correctly Color Space Awareness Intro, giving you a quick way to practice the rules, question types, and explanations that matter most for Blender.

How to use this quiz

Try each quiz question before looking at the correct answer. Use the explanations to review missed ideas, then come back to similar questions until the pattern feels familiar.

All questions

Question 1

A material uses two files: a photographed albedo image and a grayscale roughness map exported from a texturing application. The roughness file stores roughness directly, with lighter pixels intended to produce rougher areas.

Which Image Texture node setup preserves the intended interpretation of both files?

  1. Set both images to sRGB; connect albedo Color to Base Color and roughness Color to Roughness.
  2. Set albedo to Non-Color and roughness to sRGB; connect their Color outputs to the corresponding inputs.
  3. Set albedo to sRGB and roughness to Non-Color; connect their Color outputs to Base Color and Roughness. (correct answer)
  4. Set both images to Non-Color; connect albedo Color to Base Color and roughness Alpha to Roughness.
Explanation: Whenever you see a question about texture setup in Blender, the core concept to anchor on is color space: how Blender interprets the raw data stored in an image file before feeding it to the shader. Photographed albedo images are captured and saved in sRGB color space — they're gamma-encoded so they look correct on a monitor. Blender needs to know this so it can linearize the data internally before lighting calculations. Grayscale utility maps like roughness, metallic, or normal maps, however, store raw numerical data — not perceptual color. They should be marked Non-Color so Blender reads the values literally, without applying any color correction that would distort the intended roughness values. That's exactly what C does: albedo gets sRGB (correct gamma handling for a photographic image), and the roughness map gets Non-Color (preserving the raw grayscale values). Both Color outputs then connect to their corresponding shader inputs, which is appropriate since a grayscale Non-Color image still outputs usable float data through the Color socket. A is wrong because setting the roughness map to sRGB causes Blender to gamma-correct it, brightening the midtones and distorting the intended roughness values — lighter pixels won't behave as expected. B flips the problem entirely: it applies sRGB correction to the roughness map and strips it from the albedo, which corrupts both. D sets albedo to Non-Color, which removes the necessary gamma correction from the photographic image, making colors appear washed out and inaccurate in rendered output. A reliable rule of thumb: if it's a photo or display-intent image, use sRGB; if it's data, use Non-Color.

Question 2

In Eevee, a PNG contains both painted color and a cutout alpha channel. Its Color output is connected to Principled BSDF Base Color, but the material still renders as an opaque rectangle.

Which additional setup is required for the cutout to affect the rendered material?

  1. Connect Alpha to Principled Alpha and enable an appropriate transparency render method or blend mode for the material. (correct answer)
  2. Connect Color to Principled Alpha and change the image from sRGB to Non-Color data.
  3. Connect Alpha to Principled Roughness and enable alpha premultiplication on the Principled BSDF.
  4. Connect Color to Material Output Displacement and enable an appropriate transparency render method or blend mode.
Explanation: When working with transparency in Blender's Eevee renderer, you need to think about two separate systems: the shader node graph and the material's render settings. Both must be configured correctly — fixing only one leaves the material opaque. A PNG's alpha channel is a separate data channel from its color. In the Image Texture node, the Color output carries RGB information, while the Alpha output carries the transparency mask. To make cutouts work, you must route the Alpha output into the Alpha input of the Principled BSDF — this tells the shader where transparency should occur. However, that alone isn't enough in Eevee. Unlike Cycles, Eevee is a rasterizer and doesn't handle transparency automatically. You must also set the material's Blend Mode (in Material Properties) to something like Alpha Clip or Alpha Blend, which tells Eevee's render pipeline to actually process those transparent pixels. Answer A correctly describes both steps. Answer B is wrong because connecting Color to Alpha feeds RGB brightness values into the transparency slot — this produces unpredictable, incorrect results — and changing to Non-Color doesn't fix the fundamental miswiring. Answer C is wrong because Roughness controls surface specularity, not transparency; routing Alpha there has no cutout effect whatsoever. Answer D is wrong because the Displacement socket affects geometry, not visibility, and connecting Color there won't produce transparency regardless of blend mode. As a study tip, remember the Eevee transparency checklist: correct socket connection (Alpha → Alpha) + correct Blend Mode. Missing either step means no cutout, and exam questions often test whether you know both are required.

Question 3

A 16-bit grayscale height map is intended to produce true displacement in Cycles. The material and object have already been configured for displacement, and sufficient subdivision is available.

Which node path correctly treats the image as height data?

  1. Image Texture set to sRGB, Color to Principled Base Color, then Principled BSDF to Material Output Surface.
  2. Image Texture set to Non-Color, Color to a Displacement node's Height, then Displacement to Material Output Displacement. (correct answer)
  3. Image Texture set to sRGB, Alpha to a Normal Map node's Color, then Normal to Material Output Displacement.
  4. Image Texture set to Non-Color, Color directly to Material Output Surface, with interpolation set to Closest.
Explanation: When working with displacement maps in Blender's Cycles renderer, you need to think about two separate decisions: how the image data is interpreted and where it's connected in the node graph. These aren't interchangeable — getting either one wrong breaks the displacement entirely. A 16-bit grayscale height map stores raw numerical height values, not color information. That means the Image Texture node must be set to Non-Color, which tells Blender to skip gamma correction and treat the data as linear numeric values. From there, those height values need to flow into a Displacement node via its Height input, which converts the values into actual geometric offset vectors. That Displacement node then connects to the Displacement socket of the Material Output — not the Surface socket. This is exactly what B describes, making it the correct path. A is wrong on two levels: sRGB color space applies gamma correction that distorts the height values, and plugging into Base Color only affects shading appearance, not geometry. C misuses the Alpha channel (which carries no meaningful height data for a grayscale image) and routes it through a Normal Map node, which is designed for tangent-space normals, not displacement vectors — and the color space is wrong too. D skips the Displacement node entirely and sends raw texture data to the Surface socket, which controls how light interacts with the material, not how geometry is displaced; Closest interpolation is also irrelevant here. As a study habit, remember the displacement pipeline as a three-step chain: Non-Color → Displacement node → Material Output Displacement. If any link breaks, true displacement won't work.

Question 4

The same image file is needed in one material as visible sRGB artwork and in another material as a numeric mask. Two Image Texture nodes currently reference the same Blender image data-block. Changing the color-space setting for one use also changes it for the other.

What is the most appropriate way to support both interpretations?

  1. Connect one node's Color output and the other node's Alpha output; shared image data-blocks then use independent color spaces.
  2. Create separate image data-blocks for the file, assigning sRGB to the artwork copy and Non-Color to the mask copy. (correct answer)
  3. Duplicate only the Image Texture node, assigning sRGB on one node and Non-Color on the duplicated node.
  4. Keep the shared image data-block in sRGB and place a Gamma node after both uses to cancel every conversion.
Explanation: Whenever you see a question about image color spaces in Blender, remember that the color space setting lives on the image data-block, not on the Image Texture node itself. This means any node referencing the same data-block shares that single color space setting — changing it anywhere changes it everywhere. This is exactly why B is correct. By creating two separate image data-blocks that both point to the same file on disk, you give each data-block its own independent color space assignment. One data-block gets sRGB for the artwork use (so Blender correctly converts display colors into linear light), and the other gets Non-Color for the mask use (so the pixel values are passed through as raw numbers, with no color transformation applied). Both data-blocks read the same pixels from disk without duplicating the actual file. A is wrong because routing through different output sockets (Color vs. Alpha) does nothing to the underlying color space. The data-block is still shared, so both uses remain locked to the same transformation — the socket choice is irrelevant to color management. C is the most tempting distractor. Duplicating only the node looks like it creates independence, but a duplicated Image Texture node still references the same data-block. Changing the color space on the node panel modifies that shared data-block, so both nodes are affected immediately. D would partially work only for sRGB's specific gamma curve, but it's a fragile manual workaround, not a proper solution, and it still doesn't address the root problem of shared data-block settings. The key study takeaway: in Blender, always distinguish between the node and the data-block it references — they are not the same thing.

Question 5

A uniform mid-gray roughness texture stores a channel value of 0.5. It was mistakenly interpreted as sRGB, so Blender converted that mid-gray to a substantially lower linear value before sending it to Principled Roughness. The artist changes the image to Non-Color without altering any connections.

What is the most likely visible result of correcting the color-space setting?

  1. The surface becomes metallic because Non-Color redirects grayscale values from Roughness to the Metallic input.
  2. The surface becomes smoother because Non-Color automatically inverts grayscale data before sending it to Roughness.
  3. The surface keeps identical roughness because color-space settings affect only Base Color and Emission inputs.
  4. The surface becomes rougher because the shader now receives a value near the stored 0.5 instead of the lower converted value. (correct answer)
Explanation: Whenever you see a question about image texture color spaces in Blender, focus on one core idea: color-space settings control how a stored channel value is interpreted before it reaches the shader. This is separate from the texture's actual stored data. Here's the key mechanic. sRGB-to-linear conversion darkens mid-range values significantly — a stored 0.5 in sRGB becomes roughly 0.214 in linear space. When Blender mistakenly treats a roughness texture as sRGB, it applies that conversion, sending ~0.214 to the Roughness input instead of the intended ~0.5. The result is a surface that appears unnaturally smooth. Switching to Non-Color tells Blender to pass the stored value through without conversion, so the shader finally receives something close to 0.5 — a noticeably rougher result. That's exactly what D describes, making it correct. D is right because correcting the color space removes the unwanted darkening conversion, restoring the intended roughness value and producing a visibly rougher surface. A is wrong because Non-Color has nothing to do with routing data between inputs like Metallic and Roughness — it's purely an interpretation setting, not a wiring instruction. B is wrong because Non-Color does not invert values. It simply bypasses gamma correction, passing data straight through unchanged. C is wrong and represents a common misconception. Color-space settings affect every image texture input, not just Base Color or Emission. Roughness, Normal maps, and Metallic textures all depend on correct color-space assignment. Study tip: For any non-color data texture (roughness, metallic, normal maps), always set the color space to Non-Color — sRGB is reserved for textures storing actual color information meant for human eyes.

Question 6

A tangent-space normal map has the familiar predominantly blue appearance. The mesh has valid UVs, but connecting the texture's Color output directly to the Principled BSDF Normal input produces incorrect lighting.

Which change most directly corrects the node graph?

  1. Set the image to Non-Color, pass Color through a Normal Map node, and connect its Normal output to the shader. (correct answer)
  2. Set the image to sRGB, pass Color through a Bump node's Height input, and connect its Normal output to the shader.
  3. Set the image to Non-Color, connect its Alpha output directly to the Principled BSDF Normal input, and reduce strength.
  4. Set the image to Linear color, pass Color through a Vector Math Normalize node, and connect the vector to the shader.
Explanation: Whenever you see a question about normal maps in Blender, think about two distinct problems that must both be solved: color space and data interpretation. Normal maps store directional vector data — not visual color — so the pipeline needs to handle them accordingly at every step. Tangent-space normal maps encode XYZ surface direction data as RGB values, where the dominant blue channel represents the Z-axis (pointing straight out). Because this is raw linear data, the image texture must be set to Non-Color (also called Linear) so Blender doesn't apply gamma correction, which would distort the directional values. Then, that raw color data needs to be interpreted as actual surface normals through a Normal Map node, which decodes the RGB values into proper tangent-space vectors the shader can use. This is exactly what option A describes — making it the correct answer. Option B is wrong on two counts: sRGB applies gamma correction that corrupts the linear vector data, and a Bump node interprets grayscale height values, not RGB direction vectors — it's the wrong tool entirely. Option C connects the Alpha channel to the Normal input, which makes no sense because Alpha carries transparency data, not surface direction information, and no color space setting fixes that fundamental mismatch. Option D gets the color space right with Linear, but a Vector Math Normalize node simply scales a vector to unit length — it doesn't decode packed RGB normal map data into tangent-space vectors the way the Normal Map node does. A reliable tip: always pair non-color data textures (normals, roughness, metallic, AO) with Non-Color color space, and remember that normal maps specifically require the dedicated Normal Map node to decode correctly.

Question 7

A single packed texture follows the convention red = ambient occlusion, green = roughness, and blue = metallic. The artist needs the roughness and metallic channels for a Principled BSDF.

Which node arrangement correctly supplies those two shader inputs without distorting the stored values?

  1. Use sRGB, separate the Color output into RGB, and connect red to Roughness and green to Metallic.
  2. Use Non-Color, separate the Color output into RGB, and connect green to Roughness and blue to Metallic. (correct answer)
  3. Use Non-Color, separate the Alpha output into RGB, and connect green to Roughness and blue to Metallic.
  4. Use sRGB, connect Color directly to Roughness, and connect the texture's Alpha output to Metallic.
Explanation: When working with packed texture maps in Blender, the most important concept to keep in mind is the difference between color space and channel routing. Any texture storing data values — roughness, metallic, AO — must be loaded as Non-Color, because sRGB color correction applies a gamma curve that distorts raw numerical data. Roughness and metallic values need to arrive at the shader exactly as stored, so gamma correction would break them. Once you've set the image to Non-Color, you use a Separate RGB (or Separate Color) node to split the image's Color output into its individual R, G, and B channels. Following the given convention — red = AO, green = roughness, blue = metallic — you connect green to Roughness and blue to Metallic on the Principled BSDF. That's exactly what B describes, making it correct. A fails on two fronts: it uses sRGB (distorting the data) and connects the wrong channels — red holds AO, not roughness, and green holds roughness, not metallic. C sounds plausible but makes a critical mistake: it says to separate the Alpha output, which is a single grayscale float, not a color vector. You cannot split Alpha into RGB channels — the Separate RGB node needs the Color output. D uses sRGB (again distorting values), routes the Color output directly to Roughness (which would pass a full RGB color, not a single channel), and incorrectly uses Alpha for Metallic. A reliable rule: any texture that isn't actual display color — normals, roughness, metallic, AO — must be Non-Color. Memorize that, and half of these texture-node questions solve themselves.

Question 8

A black-and-white JPEG was authored as a mask: black should select the first shader input and white should select the second. Because JPEG has no authored alpha channel, Blender reports a fully opaque alpha value for the image.

How should the Image Texture node be connected to a Mix Shader factor?

  1. Set the image to Non-Color and connect its Color output to the Mix Shader Fac input. (correct answer)
  2. Set the image to sRGB and connect its Alpha output to the Mix Shader Fac input.
  3. Set the image to Non-Color and connect its Alpha output to the Mix Shader Fac input.
  4. Set the image to sRGB and connect its Color output to the Mix Shader's second Shader input.
Explanation: When working with grayscale mask images in Blender, you need to think about two independent decisions: which output socket carries your mask data, and what color space the node uses to interpret that data. A grayscale image stores its mask values in the color channels (RGB), not the alpha channel. The Color output reads those luminance values — black (0.0) through white (1.0) — which maps perfectly onto the Mix Shader's Fac input, where 0.0 selects the first shader and 1.0 selects the second. That's exactly what you want. Additionally, because this image is data (not a photograph meant for display), you must set it to Non-Color. This prevents Blender from applying sRGB gamma correction, which would shift your intermediate gray values and break the intended blend ratios. Answer A is correct for both reasons. Answer B fails on both counts: sRGB gamma-corrects the values (distorting them), and the Alpha output of a JPEG is always fully opaque (1.0) since JPEGs have no alpha channel — connecting it just locks the factor at 1.0 permanently. Answer C gets the output socket wrong for the same reason — the Alpha output is meaningless here — though at least Non-Color is correct. Answer D misunderstands the Mix Shader entirely; the second Shader input expects a shader, not a color or texture value, so plugging a Color output there produces no useful blending behavior. A good rule of thumb: any image used as data (masks, roughness maps, normal maps) should always be set to Non-Color, and grayscale masks live in the Color output, not Alpha.

Question 9

An EXR used as an emission texture was exported with scene-linear RGB values. The artist wants Blender to treat those values as linear color rather than decode them as if they were sRGB or classify them as non-color material data.

Which interpretation is most appropriate for the Image Texture node?

  1. Use sRGB, because emission color inputs require an sRGB decoding transform to produce correct scene-linear values at the shader.
  2. Use Non-Color, because EXR files generally bypass color management and the emission input does not distinguish color from data.
  3. Use Linear, because the file already stores scene-linear color values that should be treated as color without an sRGB decode. (correct answer)
  4. Use Raw, because emission inputs expect display-referred values and a Raw setting avoids any scene-linear reinterpretation.
Explanation: When working with Image Texture nodes in Blender, your goal is always to match the color space setting to what the file actually contains, so that the shader receives the correct scene-linear values — no accidental encode or decode applied. EXR files are a floating-point format designed specifically to store scene-linear data. When an artist exports an EXR with scene-linear RGB values and wants to use it as an emission color, Blender needs to know: "these bytes are already linear color — pass them through as color, don't transform them." That's exactly what the Linear color space setting does. It tells Blender the file holds linear color data and that it should be interpreted as color (not raw data), so no sRGB decode curve is applied. Answer C is correct. A is wrong because sRGB tells Blender to apply an sRGB-to-linear decode. If your file is already linear, applying that decode a second time distorts the values — colors become incorrectly brightened or compressed. B is tempting but incorrect: Non-Color does skip the sRGB decode, but it also strips color semantics — the values flow through as plain numeric data without color management participation. For emission color, that distinction matters, and Non-Color isn't the right tool when you have linear color, not arbitrary data. D is wrong because Raw bypasses all color management entirely, including any working space transforms; it's meant for specialized pipeline use and would produce unpredictable results here — not what a scene-linear emission workflow needs. Your study tip: memorize the three-way distinction — sRGB for 8-bit display-encoded color textures, Non-Color for data maps (roughness, normals, masks), and Linear for HDR/EXR files that already store scene-linear color.

Question 10

A mesh has two UV maps named UV_Detail and UV_Decal. The Image Texture node must use UV_Decal even when UV_Detail remains the mesh's active UV map.

Which connection explicitly selects the required coordinates for the image?

  1. Use a Mapping node after the Image Texture and connect the texture's Color output to Mapping Vector.
  2. Use a UV Map node set to UV_Detail and connect its UV output to the Image Texture Color output.
  3. Use a Texture Coordinate node and connect its Generated output to the Image Texture Alpha output.
  4. Use a UV Map node set to UV_Decal and connect its UV output to the Image Texture Vector input. (correct answer)
Explanation: When working with multiple UV maps in Blender's shader editor, the key question is always: which node explicitly targets a specific UV map, and is it connected to the right input? In Blender, a mesh can store several UV maps simultaneously, but only one is "active" at a time. If you want an Image Texture node to sample coordinates from a specific UV map regardless of which one is active, you must use a UV Map node — set it to your desired map by name, then connect its UV output to the Image Texture's Vector input. That Vector input is precisely where texture coordinate data enters the node. Answer D does exactly this: it targets UV_Decal by name and feeds coordinates into the correct socket, giving you explicit, reliable control. Answer A is wrong on two levels: the Mapping node belongs before the Image Texture (to transform incoming coordinates), and connecting anything to the Image Texture's Color output makes no sense — outputs receive nothing. Answer B makes the same output-socket mistake, connecting a UV Map node into the Color output instead of the Vector input, and it targets the wrong map (UV_Detail) besides. Answer C compounds multiple errors: the Generated output provides object-space coordinates rather than UV coordinates, and the Alpha output is an output socket — you cannot feed data into it. A reliable pattern to remember: in Blender's node graph, coordinate data always flows into a Vector input, and UV Map nodes are the tool for pinning a texture to one specific UV channel. If a question asks about explicit coordinate selection, look for that combination first.