Filter troubleshooting guides by category, difficulty, or keywords. Currently 99 items available.
Expert When building Unity projects with IL2CPP, reflection and generic method calls can trigger 'ExecutionEngineException: Attempting to call method... for which no ahead of time (AOT) code was generated'. Learn the mechanics of managed code stripping and how to resolve these issues using link.xml and AOT hints.
Intermediate Fix SRP Batcher compatibility issues (Compatible: No) in Unity URP. Learn how to wrap properties in CBUFFER_START(UnityPerMaterial) and resolve conflicts with MaterialPropertyBlock.
Intermediate Resolve stutters and spikes during scene transitions and async loading in Unity. Learn the mechanics of Resources.UnloadUnusedAssets and GC.Collect, and how to optimize them using Incremental GC, asynchronous asset unloading, and pooling.
Intermediate Understand the memory and performance costs of using LINQ queries in high-frequency Unity methods like Update. Learn how LINQ triggers hidden GC Allocations and how to replace them with zero-allocation loops, custom extensions, and spans.
Intermediate Address the performance cost of having thousands of Update calls in Unity. Learn how to implement a Centralized Update Pattern with an auto-registration system to bypass Managed-to-Native overhead and keep your frame rates high.
Intermediate Resolve performance issues and GC Alloc spikes caused by ScrollRect in Unity uGUI for large lists. Learn how to implement a recyclable scroll view pattern that reuse a minimal pool of cell elements and eliminates LayoutGroups.
Intermediate Resolve CPU performance issues and spikes caused by GraphicRaycaster.Raycast in Unity uGUI. Learn how to profile UI overhead, write helper editor scripts to disable Raycast Target automatically, and split canvases to optimize event handling.
Intermediate Resolve MissingReferenceException and ObjectDisposedException when objects are destroyed during async/await or UniTask operations in Unity. Learn how to prevent memory leaks and null reference bugs using CancellationToken and GetCancellationTokenOnDestroy.
Advanced Resolve rendering order and invisible output issues in Unity URP Custom Scriptable Render Features. Learn how to select the right RenderPassEvent (Injection Points) and implement modern RTHandle and Blitter.BlitCameraTexture workflows.
Intermediate Explains the root cause of heap memory fragmentation and GC spikes (frame drops) when frequently spawning and deleting bullets or effects in Unity. Details how to use the built-in UnityEngine.Pool and zero-allocation object pooling patterns.
Intermediate Learn why editing Prefabs via C# Editor scripts often fails to save changes or sync with active scene instances in Unity, and how to use PrefabUtility.EditPrefabContentsScope for safe, robust automated modifications.
Intermediate Explains the root cause of uGUI elements (text and images) becoming blurry when lowering the URP Render Scale for optimization, and details solutions like using Screen Space - Overlay or a Multi-Base Camera setup.
Intermediate Learn how to resolve issues where URP Decal Projectors distort on slopes, project through walls, bleed onto moving characters, or fail to render entirely in Unity's Universal Render Pipeline.
Intermediate Learn the root cause and setup instructions for resolving issues where custom Shader Graph materials fail to fade (instantly pop) and shadows disappear during LOD Group Cross-fade transitions in Unity URP.
Intermediate Learn the root cause and setup procedures for fixing transparent objects (glass, sheer clothing, visual effects) failing to cast or receive shadows in Unity's Universal Render Pipeline (URP) using Shader Graph, Custom Functions, and Depth Settings.
Intermediate Learn how to troubleshoot jagged shadow edges (pixelated shadows), dark striped artifacts (shadow acne), and detached shadows (peter panning) in Unity URP by fine-tuning Shadow Bias, Normal Bias, and Cascades.
Intermediate Explains the root causes of screen blackouts (rendering feedback loops), UI bleeding, and VR render failures when implementing custom post-processing via URP Full Screen Pass Renderer Feature in Unity, and details the correct setup steps.
Intermediate Explains the root cause of sprite micro-jittering and distorted pixel art during camera or player movement in Unity 2D, and details the steps to solve it using the Pixel Perfect Camera component.
Intermediate Explains the root cause of dynamic lights flickering or turning off when using URP Forward+ rendering with many point/spot lights in Unity, and details how to resolve it by adjusting the maximum tile light limits.
Intermediate We will explain the root causes and solutions for a drawing/data saving bug where when Unity's ScriptableObject parameters are changed from a C# script or a unique EditorWindow, even though the changes appear to have been made in the editor, they are reset to the state before the change or disappear when Unity is restarted, transitioned to playback mode, or built.
Advanced We will explain in detail the root cause of drawing bugs such as flattening of light and distorted shadows when implementing vertex displacement to move Position (vertex coordinates) in Shader Graph, and the correct procedure for recalculating and reconstructing normals and tangents using HLSL/nodes.
Intermediate We will explain in detail the root causes and solutions for a bug where anti-aliasing (MSAA) and post processing are not applied to 3D objects on the overlay camera side and severe jaggies occur on the edges when using Unity URP camera stacking.
Advanced Learn how to declare CBUFFER parameters properly in custom HLSL code blocks to keep your custom Unity Shader Graph nodes compatible with the SRP Batcher for optimal draw call reduction.
Advanced We will explain the root causes and solutions for a bug where video memory (VRAM) is consumed excessively when a large number of GPU particles are generated using VFX Graph, causing the app to close due to Out of Memory (OOM), especially on iOS devices.
Advanced We will explain the problem that when controlling the properties of an object using Custom Playable (PlayableBehaviour) in Unity Timeline, the value does not return to its initial state after playback or when seeking, and the solution to the memory leak.
Intermediate We will explain the root causes and solutions for the color space mismatch bug where characters and objects become extremely dark (or blown out) when the Unity color space is Linear and the camera output drawn in RenderTexture is sent to a UI such as RawImage.
Beginner In Unity's URP (Universal Render Pipeline), we will explain the cause of the problem where the shadow disappears when the camera is pulled, and the correct adjustment procedure for Shadow Distance and Cascade.
Intermediate This solves the problems that often occur when migrating from legacy (Built-in) to URP, such as ``the translucency of particles is strange'', ``the background becomes completely black'', and ``the drawing order is wrong''.
Advanced Fixed a small freeze that would occur when playing cutscenes or skill productions in Timeline. A thorough explanation of Prewarm limitations, shader compilation, and the correct prewarming method from a practical perspective.
Intermediate Explains the problem where the Shader Graph's Scene Depth node and CameraDepthTexture turn white. Posting the solution procedure using URP assets and camera settings.
Intermediate Explaining the causes of problems where the URP Decal Projector does not appear on terrain or walls or displays strange images. From Renderer Feature settings to Receive Decal material adjustment.
Beginner Solved an issue where the particle size did not change even if the scale of the parent Transform was changed. Explains the correct understanding of Scaling Mode and the setting procedure.
Intermediate Fixed a bug where the context would flicker when translucent flames and smoke overlapped. Correct sorting control method using Sorting Fudge.
Advanced We will explain in detail the root causes and solutions for the culling bug in VFX Graph, where effects suddenly disappear off-screen due to camera rotation or angle changes, using the analogy of an invisible packaging box.
Intermediate Resolve issues where particles fail to emit when triggering SendEvent from a C# script in Unity Visual Effect Graph.
Advanced Fixed an error when writing a Custom Function node in Shader Graph. Detailed explanations from naming rules for suffixes (_float/_half) to type consistency of arguments.
Intermediate We will solve in detail the bug where translucent edges and borders darken when 3D objects and effects drawn in RenderTexture are overlapped using uGUI's RawImage, using an analogy of overlapping colored glass.
Advanced Solved the "only the right eye is not visible" bug caused by Single Pass Instanced during VR development. The correct way to write stereo macros in custom shaders.
Advanced We will explain in detail the root cause and solution of a bug where the SRP Batcher (scriptable render pipeline batcher) becomes incompatible in the Unity URP environment and the draw calls are not reduced at all, using an analogy of a chef's cooking process.
Advanced Learn how to profile and optimize heavy Universal Render Pipeline (URP) post-processing volumes for mobile and standalone VR headsets.
Intermediate Solved an issue where vertex colors and alpha blending were not reflected in mesh particles. Custom vertex stream binding instructions.
Advanced We will explain in detail the causes and solutions for a bug where the main thread load on the CPU suddenly increases and the game slows down when the Shuriken Particle System's Noise module is enabled, using an analogy of origami staff allocation.
Intermediate We will explain in detail how to combine Soft Particles to eliminate the phenomenon where the smoke and light effects created with Shader Graph look sharp and unnatural straight lines at the boundaries where they intersect with the ground or walls, and blend smoothly, using the analogy of ice melting in water.
Advanced In Unity URP's Linear space, we will explain in detail the root cause and solution of color inconsistency (darkening/overexposure) that occurs when displaying RenderTexture on the UI, using an analogy of double dimming of sunglasses.
Advanced Fixed a bug in specific drawing path injection using Custom Render Feature. Camera depth buffer binding and render pass event synchronization.
Advanced FFR outer resolution collapse noise during Meta Quest development. Optimized the drawing buffer around the visual field and set the correct FFR level.
Beginner Resolved the "UnityEditor namespace not found" error that occurred when building the actual Unity machine. Isolation method using preprocessor macros and Editor folders.
Beginner When using Screen Space - Camera in Unity's uGUI Canvas, we will explain in detail the root cause and solution of a bug where the drawing priority of 3D effects and 3D models and UI panels is broken, using an analogy of stage layout in a play.
Beginner We will explain in detail the root cause and solution of a bug where when you try to dynamically pass parameters to VFX Graph from a C# script, the values are completely ignored and are not updated to their initial values, using an analogy of an office extension phone.
Beginner How to hide the URP rendering debugger that appears on the screen when building the actual machine. Disable procedure in C# code.
Intermediate Fixed a bug that caused post-process volume switching in a scene to fail. The trap of Volume weight and collider settings.
Advanced Fixed dynamic texture transfer bug to VFX Graph. Texture node type consistency and texture upload validation to GPU memory.
Advanced Resolved SRP Batcher inconsistency due to use of Vertex Position node in Shader Graph. Combining and optimizing GPU instancing.
Intermediate Eliminate memory leaks due to dynamic RenderTexture generation. Explaining the correct order flow of RenderTexture.Release and Destroy.
Advanced Fixed the post-process right eye misalignment bug in Single Pass drawing under VR environment. Correction of screen coordinates and texture array sampling.
Intermediate We will explain in detail the root cause and solution of a bug where the source of the effect does not follow the deformation or movement of the animation when particles are emitted from the body of a moving character (Skinned Mesh Renderer) in Unity, using the analogy of a shadow that leaves behind clothes.
Beginner Game view and actual machine reflection bug of Gizmo drawing. Build a debug line compatible with actual devices using OnDrawGizmos and GL/Line drawing.
Intermediate Fix rendering bugs where transparent particles fail to blend with URP Fog and appear bright or cut-out in front of volumetric fog.
Advanced Resolved SRP Batcher inconsistency in multi-material applied assets. The importance of mesh atlasing and submesh optimization.
Intermediate Position shift problem when looping Timeline animation. Correct application procedure for root motion and optimization of Extrapolation settings.
Advanced Fixed Timeline audio sync bug when dropping frames. Instructions for optimizing DSP buffers and applying asynchronous synchronous mode for Audio Source.
Beginner Resolved the Activation Track reset specification when Timeline ends. Correct behavior adjustment flow for Wrap Mode (Hold/None).
Advanced Fixed automatic import infinite loop bug by AssetPostprocessor. Correct usage of AssetDatabase.WriteImportSettingsIfDirty.
Intermediate Fixed texture/resource residual leak in custom EditorWindow. Cleanup flow in OnDisable and OnDestroy.
Intermediate Solved the Editor extension build failure error when installing asmdef. Explains the separation and reference setting procedure of asmdef for Editor.
Advanced VFX Graph Fixed an issue with overlapping translucent particles. Steps to enable GPU sorting option (Sort).
Advanced Fixed collision detection collision in VFX Graph. How to configure the Colliders node and optimally tune the GPU depth collision buffer.
Advanced Fixed the child particle emission failure bug in VFX Graph. Simulation lifecycle binding procedure for GPU events.
Advanced Fixed a bug when using Shader Graph's Custom Interpolators node. Coordinate space transformation matching and data passing procedures.
Intermediate Eliminated texture stretching during Triplanar sampling. Blend parameter optimization and world normal correction procedure.
Advanced Solved stereoscopic misalignment of Fresnel effect during VR development. Single pass compatible correction node configuration for view direction vector.
Intermediate Steps to resolve the phenomenon where the shadows of static and dynamic objects overlap and become unnaturally dark when using URP's mixed light, and the light leakage bug where shadows float on the ground.
Advanced A solution to an issue where the VFX Graph's trail expression (Strip) causes spikes, rendering collapse, and crashes on Android/iOS. Indirect Draw buffer optimization procedure.
Intermediate Solved the issue where stencils (masks) did not function properly with Shader Graph materials. Render Objects setting procedure in URP Universal Renderer Data.
Advanced Detection and avoidance processing in C# for a Timeline bug that causes Signal Emitter to malfunction the same event twice in a row when a processing failure occurs in Timeline.
Advanced Resolved peripheral vision texture blur and scan line noise during Quest development. Foveated Shading Mode settings and fallback adjustment steps.
Intermediate An advanced rendering optimization system in Unity URP that accelerates CPU dispatch by batching bind calls for identical shaders.
Beginner A renderer setting in Unity Particle Systems used to adjust the sorting order relative to other transparent objects.
Advanced A VR rendering optimization technique that reduces resolution at the peripheral vision of standalone headsets like Meta Quest.
Intermediate A specialized render texture containing the distance of geometry from the camera, used for soft particles, water depth, and post-processing.
Beginner Q&A to resolve the problem where objects turn bright pink when migrating a Unity project to URP or adding external assets.
![[Q&A] Countermeasures for the bug where VFX Graph effects suddenly disappear when the camera is moved](/assets/images/qa_vfx_bounds_culling_fix.png)
Intermediate Q&A on countermeasures for the culling phenomenon where effects created with Visual Effect Graph are instantly deleted due to off-screen or camera angle.
![[Q&A] Memory leak countermeasures when dynamically generating RenderTexture in C#](/assets/images/qa_rendertexture_leak_prevention_fix.png)
Advanced Q&A to prevent the game from crashing due to GPU and VRAM memory accumulation when newing RenderTexture or calling GetTemporary on the C# script side.
![[Q&A] Steps to fully synchronize Timeline playhead and Particle System simulation time](/assets/images/qa_timeline_particle_sync_fix.png)
Beginner Q&A to solve the problem that the timing of particle effects is off or Prewarm does not work when creating cinematics and cutscenes with Timeline.
Beginner A numeric value that defines the exact execution sequence of materials during the rendering pipeline passes.
Intermediate The principle and setting procedure of GPU Instancing, which dramatically reduces the draw call load when drawing a large number of the same mesh and material.
Advanced A technical explanation of VRS, which changes the processing density of the pixel shader according to the local details and contour information of the scene, reducing the GPU load while maintaining image quality.
Intermediate An explanation of how to embed advanced graphics algorithms by writing HLSL code directly within Unity's Shader Graph, beyond the limitations of GUI nodes.
Beginner A guide to setting the Prewarm parameter in Unity's Particle System to make it appear in a completed state after some time has passed since the initial frame of the effect display.
Beginner A basic explanation of culling technology that instantly skips the drawing process for objects that are outside the camera's viewing angle (outside the viewing frustum) and significantly reduces GPU load.
Beginner A technical explanation of automatically reducing the texture resolution in stages according to the 3D distance from the camera to save VRAM bandwidth and eliminate screen flickering (jaggies).
Advanced Explanation of render features that extend Unity URP's standard rendering pipeline and freely insert custom paths such as outlines, mosaics, and blurs.
Advanced Basic knowledge of the basic structure of HLSL, a language for writing drawing instructions directly to the GPU in Unity shader development, and custom code writing of Shader Graph.
Beginner A billboard drawing technology that constantly turns 2D polygons such as particles to face the front according to camera movements, creating a three-dimensional illusion.
Advanced A deferred drawing mechanism that reduces the GPU load when arranging a large number of lights by writing drawing information to the G buffer once and then performing write calculations all at once.
Advanced A drawing method that achieves both translucent drawing and a large amount of light placement by dividing the screen into tiles and applying only the light related to each tile to pixels.
Beginner An explanation of the series of drawing processing flows in Unity, from meshes, textures, and camera settings in 3D space to outputting the final screen pixels.
Intermediate When the GPU draws a pixel, it compares it with the distance information already written to the depth buffer, determines whether it is in front or in the back, and processes occluding objects.
Intermediate When an object is drawn, the distance of that pixel from the camera (depth value) is recorded in a dedicated Depth Buffer, and is used to determine the front and back of subsequent objects.
Advanced Explanation of crop shader technology that writes an arbitrary integer (mask value) for each pixel on the screen and draws objects only within the range of a specific shape.
Intermediate An explanation of the phenomenon where translucent objects etc. are drawn over and over again on the same screen pixel, causing the GPU's fill rate load to exceed its limit and become choppy.
Beginner Technology that eliminates the blurring of 3D flat textures (ground, road surfaces, etc.) that are sharply tilted toward the camera, and renders sharp, high-definition images even in the background.
Intermediate A basic explanation of the difference between the color expression methods (Linear and Gamma) used during Unity's rendering calculations, and physically correct light blending and HDR expression.
Beginner A technology that automatically changes the complexity (number of polygons) of a 3D mesh in stages according to the distance between the camera and the object, optimizing the geometry load on the GPU.
Intermediate A powerful optimization technique that automatically skips the rendering of 3D objects that are in view but hidden behind foreground walls or buildings and are not visible to the player.
Beginner A technology that completely changes the atmosphere of the screen by applying the physical effects of the camera lens (Bloom, chromatic aberration, tone mapping, etc.) to the 2D screen after rendering is complete.
Intermediate A technology that stores camera drawing results in video memory like regular texture assets and draws them on the surfaces of 3D objects in the game in real time.
Beginner An API command that the CPU issues to the graphics card (GPU) by specifying mesh and material parameters and telling it to ``draw this 3D model.''
Intermediate An optimization process that consolidates drawing instructions for multiple individual objects into one large group on the CPU or GPU side, minimizing the number of draw call APIs issued.
Beginner In a particle system, a setting that determines whether the particle behavior and coordinate calculations are based on the parent game object (Local) or the scene's world space (World).
Advanced A technology that uses 3D texture assets that store 3D forces (wind direction and strength) at each coordinate in a 3D grid space to give particles complex, organic undulations.
Beginner An explanation of the most basic property of effect control, which defines the lifetime (in seconds) of each individual particle from its creation to its disappearance.
Beginner Explanation of Emission Rate, which is a parameter for the number of particles continuously generated over time (per second) in a particle system.
Beginner An explanation of the burst setting that instantly releases a large amount of particles explosively at a specific time or at the start of a loop in a particle system.
Advanced The core technology of VFX Graph makes full use of the massively parallel computing power of the GPU rather than the CPU to control and simulate an extremely large number of particles, ranging from hundreds of thousands to millions, in real time.
Advanced A technology that bakes the surface coordinates (vertex positions and normal lines) data of complex 3D characters and objects as text textures in advance, and generates effects according to the shape within the VFX Graph.
Intermediate An explanation of the hierarchical effect technology that generates a new child particle from the coordinates of a parent particle in a particle system at the moment a specific event (collision, extinction, birth, etc.) occurs.
Intermediate A processing system that determines when a particle physically intersects or contacts an obstacle or collider in 3D space, and provides dynamic behavior such as bouncing, sliding, friction, or annihilation.
Intermediate An explanation of the technology that creates fractal pseudo-random force fields such as Perlin noise and Simplex noise in 3D space to impart organic and irregular fluctuations (wind pressure) to the movement of particles.
Beginner In particle systems, settings that specify how particles are drawn on screen as billboards, meshes, or horizontal/vertical boards.
Intermediate In VFX Graph, a function that connects individual generated particles with a smooth band (ribbon)-like mesh to create a trajectory or string-like effect.
Beginner Explanation of the function that tracks the movement path of particles and moving objects and dynamically generates beautiful afterimages and flight trajectory polygons that flow behind them.
Beginner When particles are generated, it automatically takes over the movement speed of the source of the emission (parent object or moving character), reproducing natural physical behavior.
Intermediate A rendering technology that uses the difference in depth values to smoothly fade out the boundary line where translucent particles collide with opaque objects such as the ground or walls, eliminating unnatural edges.
Intermediate A program that is executed on each "vertex" that makes up a 3D model, converting coordinates, processing vertex colors, and adding animation such as waves and deformation to shapes.
Intermediate After processing the vertex shader, a program that uses lighting, textures, and color composition to determine what color to paint each pixel (fragment) on the screen.
Beginner A technology that reproduces the physical phenomenon in which the reflectance and luminous intensity of contours increase depending on the angle between the camera's line of sight and the normal (orientation) of the object's surface.
Beginner A technology that creates the illusion of three-dimensional shadows by pasting a pseudo "direction of unevenness (normal)" expressed in RGB values as a texture on the surface of a flat polygon and using lighting calculations.
Beginner A two-dimensional positioning coordinate system represented by U (horizontal axis) and V (vertical axis) for pasting a 2D planar image (texture) onto the three-dimensional surface of a 3D model.
Beginner The latest drawing method uses mathematical formulas to model physical laws such as absorption and reflection of light and the roughness of materials, and reproduces realistic and consistent textures no matter the lighting environment.
Beginner In a shader, a technology that immediately ``discards'' pixels whose texture alpha value (transparency) is below a certain threshold value at the GPU judgment stage and cuts the drawing.
Beginner RGB (and Alpha) color information stored in each "vertex" of a 3D model itself, and is used as a coloring or mask in a shader without using a texture.
Advanced A special shader technology that ignores the UV coordinates of the 3D model and automatically composites textures by projecting them from three directions in world space: top, side, and front, without requiring UV expansion.
Advanced Explanation of a large number of internal program branches that are automatically generated for the GPU from a single shader file depending on the combination of enabled/disabled functions (e.g. presence/absence of shadows, presence/absence of fog).
Advanced In VR rendering, an optimization technology that combines the drawing processing (Draw Call) for the left and right eyes into one call, and uses GPU hardware instancing to quickly draw images for both eyes at once.
Intermediate In VR drawing, after all objects for the left eye have been drawn, the camera position is shifted to the right eye again and all drawing processing is repeated from scratch.This stereo drawing method emphasizes compatibility.
Beginner Explanation of the ultra-high-speed working memory dedicated to the graphics card (GPU) that stores textures, 3D meshes, and various screen buffers during rendering.
Intermediate This refers to the maximum pixel processing capacity that the GPU can output by filling in colors for each pixel on the screen per second, and is an indicator that is directly linked to the screen resolution and the load of overlapping drawings.
Intermediate Optimization technology that automatically combines drawing instructions for multiple objects that share the same material or texture into one, dramatically reducing the number of communications from the CPU to the GPU.
Beginner A powerful debugging tool that connects to the Unity editor or actual device and visualizes and measures CPU function execution time, GPU rendering load, VRAM/memory changes, physical calculation overhead, etc. in real time.
Beginner An indicator of how many times the screen is redrawn per second (unit: FPS), and is the most important physical performance value that determines the smoothness of the game and the response speed to player operations.
Beginner An explanation of the state in which the slowest part of the entire system's processing performance (such as specific processing by the CPU or pixel calculation by the GPU) slows down the entire system and determines the overall speed.
Beginner In Unity, a standard component that sets the LOD stage (level of detail) for each 3D model according to the distance from the camera, and controls automatic mesh switching and drawing/hiding (culling).
Advanced An explanation of the process of translating and building human-written source code (HLSL and Shader Graph nodes) into a binary instruction set (machine language) that can be directly understood and executed by the target graphics board (GPU).
Beginner An optimization technique that pre-combines the meshes of static objects (such as buildings and terrain) that do not move during game execution, significantly reducing the CPU load of draw calls.
Intermediate An automatic optimization function that reduces draw calls by grouping vertex information of small moving objects (such as bullets or simple coins) in real time on the CPU every frame.
Advanced Explanation of the function that allows developers to freely extend the drawing path by inserting arbitrary custom drawing instructions (material application, texture copy, etc.) between Unity's standard rendering processing.
Advanced Explanation of multiple huge texture groups that temporarily store shape (geometry) information such as color, normal, depth, and smoothness of objects at each pixel on the screen in deferred shading.
Beginner An explanation of the mechanism for correctly determining occlusion (Z-Test) of the front and back of 3D objects using a dedicated buffer that stores the "distance (depth)" from the camera for each pixel on the screen.
Intermediate An explanation of the top-level memory buffer on the GPU that temporarily holds one frame's worth of color data (red, green, blue, alpha values) that is ultimately output to the display.
Intermediate An explanation of shadow drawing technology that depicts the depth (distance) of the entire scene as seen from the light (light source) in a dedicated texture and determines whether each pixel of an object is blocked from light (in the shadow).
Advanced Explanation of a technology that divides and applies shadow maps of different resolutions to multiple ranges of foreground, mid-range, and distant view depending on the distance from the camera, achieving both lightness of distant shadows and high definition of shadows at your feet.
Advanced A middle-rendering technology that minimizes shadow calculations during runtime by burning the shadow information cast by static background objects onto dynamic objects (characters, etc.) into a dedicated texture (Shadowmask) that is separate from the light map.
Beginner Explanation of a technology that eliminates the light calculation load during runtime by calculating the gradation of light and shadow that hits the surface of a static object in advance using high-precision offline calculations and superimposing it on the model as a 2D texture.
Intermediate A system in which surrounding light information (color and intensity) is recorded in advance on a grid-like point (sphere) in space, and a high-speed approximation of the surrounding pre-baked light is applied to a dynamic character (player, etc.) that moves between them.
Intermediate An explanation of the technology that takes a 360-degree panoramic image (cube map) of the surrounding area from a specific position in a scene, either in advance or dynamically, and applies realistic background reflections to surrounding mirrored materials such as metal or water surfaces.
Beginner A virtual giant cube or spherical texture that surrounds the camera (infinite distance), representing the in-game sky, clouds, space, and mountains in the distance, and at the same time serves as a reference for the ambient light of the entire scene.
Beginner Explanation of the technology that uses the GPU to calculate an infinite brightness (light energy value) range that exceeds the limits of traditional displays (0 to 1) and simulates the realistic glow of the dazzling sun and ultra-high brightness effects.
Beginner A post-processing technology that extracts high-brightness pixels on the screen (such as dazzling light sources with an HDR value of 1.0 or higher) and synthesizes beautiful light blurring and leakage around them using Gaussian blur to make them appear truly dazzling.
Advanced Using a tone mapping method based on international standards in the film industry, this algorithm achieves a beautiful cinematic saturation blend (film look) near the boundaries of overexposure when compressing the extremely wide luminance information of HDR for display use.
Intermediate A processing technology that smoothly converts and compresses the ultra-high brightness color energy range of over 1.0 calculated by HDR rendering into the LDR color range of ``0.0 to 1.0'' that can be expressed by a normal monitor while preventing white collapse and color distortion.
Beginner A post-processing effect that reproduces the effect of a toy camera lens by gradually darkening the four corners of the screen (the outer periphery) or reducing its transparency by reducing the brightness and focusing the player's gaze on the character or important object in the center of the screen.
Beginner An explanation of post effects that simulate the shift in light wavelength due to physical camera lens defects and slightly shift the red, green, and blue (RGB) color channels at the four corners of the screen to create a realistic lens feel and the effects of sci-fi bugs and shock waves.
Intermediate This technology creates an overwhelming sense of depth similar to that of a single-lens reflex camera by clearly depicting only the specific object that the camera focuses on (focus position), and smoothly blurring the foreground and background that are outside of that object.
Beginner This technology generates a blur (afterimage) that stretches pixels in the direction of movement along the trajectory of a camera's rapid rotation or an object's high-speed movement, smoothing out jitters in the image and creating an overwhelming sense of speed.
Intermediate A technology that creates ``occlusion'' shadows of physical indirect light in real time in minute gaps where light cannot reach, the depths of recesses, or joints between objects, giving the world an outstanding sense of three-dimensionality and grounding.
Advanced An explanation of advanced reflection technology that uses pixel data (color and depth values) already rendered on the screen to physically accurately calculate and draw dynamic, real-time reflections on the floor and water surface that are reflected in the camera.
Advanced The latest anti-aliasing technology superimposes and blends the past several frames' worth of drawing results (time axis information) and pixel movement speeds (motion vectors) for each frame, beautifully erasing harsh jagged edges of polygons and minute noises (flickering).
Intermediate An explanation of the most recommended anti-aliasing method for VR and mobile, which utilizes GPU hardware capabilities to partially sample only the pixels of the contour (edge) of an object's polygons at several times the normal resolution and blend them smoothly.
Beginner An explanation of extremely fast and ultra-lightweight post-processing anti-aliasing technology that detects ``jagged borders'' on a pixel-by-pixel basis from differences in contrast on the final screen (single image) after drawing is completed, and blurs and blends the color with the surrounding area.
Intermediate An evolution of FXAA, this is a post-process anti-aliasing technology that uses image analysis to highly classify edge patterns (boundary shapes such as L-shaped and U-shaped) within the screen, and minimizes blurring of edges while expressing crisp, smooth edges comparable to MSAA.
Beginner Explanation of a function that dynamically scales only the internal rendering resolution of the 3D drawing area while leaving the game's UI resolution (100%) unchanged, dramatically reducing the pixel load on the GPU while completely maintaining the crispness of the UI.
Advanced An explanation of dynamic optimization technology for professionals that monitors the game's processing load (frame rate) in real time and automatically lowers the 3D resolution only at moments when the GPU load suddenly increases, such as when an effect explodes, absolutely preventing FPS drops (stuttering).
Advanced An explanation of a program that is completely independent of the graphics drawing path and utilizes the GPU's thousands of massively parallel cores to process massive mathematical calculations such as physical calculations, large number of particle position calculations, and crowd simulations at lightning speed.
Advanced In Compute Shader and the latest shaders, an explanation of a large-capacity shared buffer that transfers arrays of C# structures (custom data with multiple attributes) to GPU memory while retaining them with high precision and density, and reads and writes them in massively parallel.
Advanced Explanation of the data transmission route for safely transmitting custom computed values for each vertex (normal, arbitrary distance, noise, etc.) from the vertex shader to the fragment shader via linear interpolation between pixels.
Advanced In order to express an amazing three-dimensional effect that exceeds that of normal maps, we use height maps (height information) to calculate ``occlusion and deviation due to unevenness'' from the angle of the camera's line of sight, and explain the technology that creates the illusion of deep grooves and three-dimensional sculptures in completely flat polygons.
Beginner An explanation of the technology that multiplies patterns (high resolution) such as fine noise, cloth fibers, and metal scratches on top of the main texture (low resolution) using extremely fine UV tiling to create a texture that does not blur even when the camera is extremely close.
Beginner A material setting in which the object itself emits light, like a light bulb or neon, and when combined with HDR settings and the Bloom effect, it creates a beautiful glow in the dark.
Beginner An explanation of the most important texture factor in physically-based rendering (PBR), which is a parameter that determines the fine smoothness (smoothness) of the surface of a material, and controls whether the reflection of light is clearly concentrated in one point or spread out in a blurry manner.
Beginner Explanation of the factors that determine the physical behavior of the color and reflectance of light reflection, which is a parameter that classifies whether a material is "metal (conductor)" or "nonmetal (insulator)" in physically based rendering (PBR).
Intermediate An explanation of the technology for defining ultra-light and precise shadows for each material, in addition to post-processing SSAO, using textures that are pre-baked to reflect the ``light inability (environmental light shielding degree)'' of deep gaps such as wrinkles, screw holes, and joints in 3D models.
Advanced An explanation of ultra-advanced geometry technology that uses GPU hardware functions to automatically divide (subdivide) low-polygon triangles into many times smaller polygons at runtime, and dynamically generate real rugged 3D vertices based on a height map.
Advanced An explanation of the advanced shader stage that dynamically generates and destroys polygon vertex data in real time inside the GPU immediately after the vertex shader, and programs to generate polygons and solids from mere points on the spot.
Beginner A basic culling technology that automatically discards rendering calculations for "polygons facing backwards" that are physically invisible to the camera, such as inside or behind a 3D object, at the initial stage of the GPU, dramatically reducing the rendering load by half.
Beginner When drawing a translucent object, a general term for the settings that specify the formula used to mix the color to be drawn (source) with the color of the background already drawn on the screen (frame buffer) (destination).
Beginner In translucent drawing, this is a mode in which the new pixel color is simply added (A + B) to the background color to synthesize it, and the more it overlaps, the brighter it becomes and the more it becomes blown out, an essential technology for expressing energy such as shining flames, lasers, and sparks.
Beginner A basic explanation of how to darken the background, such as shadows, stained glass, scorch marks, and muddy puddles, using a mode that combines the new pixel color and the already drawn background color by "multiplying (A x B)" in translucent drawing.
Beginner An explanation of the technology that uses the most standard translucent compositing mode to blend the object's own color and the background color by smooth linear interpolation based on the ratio of the alpha value (transparency: 0 to 1) of the material.
Advanced An explanation of the smallest unit of rendering that encapsulates a series of drawing processes (e.g. drawing only depth, drawing only opacity, executing post-processing, etc.) in Unity's render pipeline (URP, etc.).
Advanced An explanation of a next-generation rendering architecture that completely transfers object culling (view frustum culling, occlusion) and drawing command generation to the GPU's Compute Shader, reducing the CPU's draw call load to zero.
Advanced An explanation of next-generation rendering technology that physically simulates and tracks the countless ``rays'' emitted from light sources within the screen, completely reproducing accurate mirror-like reflections, realistic light refraction, and realistic light bounce (indirect light).
Beginner An explanation of Unity's standard visual editor tool that allows you to intuitively create high-quality custom materials and vertex animations by visually connecting visual nodes (mathematical functions, textures, time values, etc.) on the screen without writing any programming code such as C# or HLSL.
Intermediate An explanation of an optimization technique that utilizes the hardware capabilities of the GPU to draw duplicates of the same 3D mesh (e.g., tens of thousands of grasses in a meadow, thousands of soldiers, etc.) in a massively parallel manner while assigning individual positions, angles, and colors (Structured Buffer, etc.) with a single draw call.
Advanced A rendering method that optimizes the number of light calculations per pixel by batch-processing lighting calculations after drawing the depth and normal buffers.
Beginner The most standard and compatible rendering method that projects objects one at a time to the camera and processes light calculations on the fly simultaneously.
Advanced A memory-saving and high-speed deferred drawing method that divides the screen into grid-like tiles and calculates only the lights in each tile against the G-buffer.
Advanced In addition to dividing the screen into 2D tiles, it also divides the screen in the ``depth (Z-axis)'' direction, and is a cutting-edge drawing method that optimizes light calculations on a 3D spatial block (cluster) basis.
Intermediate An optimization technology that uses the GPU's massively parallel core instead of the CPU to process mesh deformation calculations (vertex simulation) associated with character bone animation.
Intermediate A compatibility-oriented method that safely pre-calculates mesh deformation due to character bone animation on the CPU's main thread or multi-thread (Job System).
Beginner A mechanism that reads the movement speed and trajectory of forward movement, jumps, etc. recorded in the 3D character's animation data itself, and automatically synchronizes it with the movement of the physical character collider in the game.
Beginner An explanation of a visual tool in Animator Controller that dynamically blends and synthesizes multiple animations (walking, running, leaning, etc.) in a smooth ratio according to parameter values such as the character's movement speed and orientation.
Beginner In Unity, a standard system for designing and managing the state transitions of a character's various actions (standby, running, attacking, being hit, etc.) as a visual state machine.
Intermediate In Unity Timeline, a dedicated clip track function that completely synchronizes and controls other sub-timelines, particle systems, dynamic generation of Prefab assets, etc. from the main timeline track.
Intermediate An explanation of a framework that is a next-generation asset management/loading system in Unity that performs ultra-lightweight dynamic loading/memory management by simply specifying a unique string (address) regardless of where assets are physically stored (local, cloud, etc.).
Advanced A package asset that compresses and archives multiple Unity assets (meshes, textures, materials, prefabs, etc.) into a single external file, and is a technology that is the basis for dynamic downloading and memory saving.
Beginner An optimization feature that automatically packs multiple independent 2D images (sprites) into one giant connected texture at build time, dramatically reducing 2D drawing and UI (uGUI) draw calls.
Intermediate In the Mipmap system, which reduces texture resolution according to the distance from the camera, a technology that manually shifts the resolution switching boundary (bias value) to fine-tune the sharpness and blur of the texture.
Advanced Unity's standard memory optimization system dynamically loads only the Mipmap level of the resolution required for the current camera field of view and distance into VRAM (video memory), dramatically reducing memory consumption.
Advanced An advanced texture technology that subdivides extremely large high-resolution textures (such as vast terrain textures with hundreds of thousands of pixels) into small tiles, and dynamically virtually deploys and draws only the tiles currently visible on the screen to VRAM.
Advanced A technology that uses the GPU's hardware functions to count how many pixels are actually output on the screen when the object being drawn is hidden by a nearby obstruction (such as a wall), and feeds back the hidden determination to the CPU.
Advanced An explanation of the GPU's hardware function that automatically performs depth comparison (Z-Test) at the ``Early'' stage when executing the heavy ``fragment shader'' that colors pixels, and immediately discards calculations for pixels in the hidden and invisible depths to speed up the calculation.
Advanced Explanation of a high-speed culling stage that compares the integer value written in the stencil buffer with the conditional expression of the shader when the GPU draws pixels, and allows drawing only within the range of a specific pattern (mask).
Beginner An explanation of color correction technology that modulates the hue, contrast, saturation, and brightness balance of the final rendered screen with high precision to infuse a specific atmosphere (retro, horror, cinematic, etc.) into the entire game.
Intermediate Ultra-high-speed image conversion technology that processes complex color correction (color grading) calculations for the entire screen at lightning speed by simply sampling 2D/3D color conversion table textures (LUTs) once on the GPU.
Beginner An explanation of the technology that precisely corrects the color temperature and tint to neutralize the effects of the color of the light source (reddish bulb light, bluish shadows, etc.) so that ``naturally white things'' on the screen appear correctly white.
Beginner An optimization function that specifies the limit distance for drawing real-time shadows according to the distance from the camera, and dramatically reduces the processing load on the GPU/CPU by skipping unnecessary shadow drawing in distant scenes.
Advanced A high-precision shadow correction technology that uses the depth buffer of the screen to artificially draw ultra-small shadows between objects and the ground (such as gaps between feet or pebbles) in screen space, which tend to disappear due to insufficient shadow map resolution.
Advanced A technology that multiplies minute unevenness information from the material's Normal Map and Occlusion Map (AO Map) by the incident angle of the light in a shader to synthesize ultra-high-precision self-shadows on the material's microscopic fibers and the valley bottoms of rock surfaces.
Advanced An explanation of next-generation shadow drawing technology that physically traces the line of light from the light source to the pixels (ray tracing) without using any shadow maps, and physically draws real shadows with perfectly accurate outlines that naturally blur as you move away from the light source.
Advanced A high-quality ambient occlusion technology that is an evolution of SSAO and calculates the shadow occlusion rate by highly sampling the angle of the "horizon" around pixels, and expresses physically correct gap shadows that are much deeper, more precise, and free from distortion than SSAO.
Intermediate An explanation of ultra-high-speed graphics optimization technology that uses a fine halftone pattern of dots (noise) to artificially blend colors to prevent gradation steps (color banding), or to dissolve (fading) while remaining opaque without using translucency.
Intermediate An explanation of a lightweight shader technology that uses texture RGB values as two-dimensional "movement vectors (flow direction and speed)" to freely flow water surfaces, magma, gas, clouds, etc. by dynamically transforming UV coordinates.
Beginner This is an index that compares the color of light to physical absolute temperature (unit: K/Kelvin), and explains the elements that control the emotional atmosphere of light, from low temperature (orange light bulb light) to high temperature (bluish sky light).
Intermediate Explanation of the solution to the shadow leak bug that causes light to penetrate and leak behind thin walls and floors.
Advanced Explanation of the solution to the variant explosion where the progress bar freezes and stops for several minutes at the shader compilation step when building a Unity project.
Intermediate Prevent rendering glitches where transparent particle systems overlap incorrectly or cut through UI canvases by tuning Sorting Fudge.
Intermediate Explanation of a solution for the CPU load that spikes due to mesh rebuilding of the entire Canvas when dynamically updating UI text and icons.
Advanced Explanation of the solution to a bug where the app forcefully closes the moment it enters a specific screen or production when running the game on an old Android smartphone.
Advanced Explanation of the solution to the delay in which the Unity editor freezes with "Compiling..." for tens of seconds every time a single character is rewritten in a C# script.
Advanced A solution to a bug where dynamically loaded assets using the Addressable Asset System are not released from memory and accumulate.
Advanced Explanation of the solution to a graphic bug in VR devices such as Quest that causes pixels at the periphery (four corners) of the field of view to become abnormally rough and crumble into a mosaic pattern.
Intermediate Explanation of the solution to the problem where a gun bullet or a car running at high speed passes through a collision detection wall (collider) and disappears on the other side.
Intermediate When switching Cinemachine cameras in Timeline, the cause of the bug where the character returns to T-pose for just one frame or the camera shakes violently, and the steps to solve it by synchronizing the update order of Animator and Cinemachine Brain.
Intermediate Explains the root causes and solutions for bugs where transparent materials fail to render correctly or cause self-reflection/rendering glitches when using Shader Graph's Scene Color or Scene Depth nodes to create refraction/glass shaders.
Intermediate Explains the root cause of the missing character (tofu) bug in Unity's TextMeshPro (TMP) when using Dynamic fonts for CJK and other multi-byte languages, and details solutions including atlas size optimization, C# script notifications, and hybrid baked-dynamic setups.
Intermediate Learn how to fix the bugs where multiple Unity NavMeshAgents crowd in narrow passages, push each other, cause violent shaking (jitter), or clip through static wall colliders (wall penetration) by optimizing RVO and physics settings.
Intermediate A small freeze (spike) phenomenon in the main thread that occurs even though Addressables and AssetBundles are loaded asynchronously. We will explain the root cause of the decompression bottleneck in the LZMA compression format, practical steps to resolve it by migrating to LZ4 (Chunk-based) compression, and the asynchronous control code.
Intermediate Learn why Unity WebGL builds crash with "Out of Memory" or "Cannot enlarge memory arrays" errors. Discover how to configure WebGL Memory Size, utilize Addressables, optimize texture formats, and prevent browser-side crashes.
Intermediate Learn how anonymous methods and lambda expressions in Unity C# can cause memory spikes via closures and delegate instantiation. This guide shows how to profile these allocations and shares optimization techniques like delegate caching and static lambdas to achieve zero GC Alloc.
Intermediate Learn how to fix blurry or jagged edges when using Step or Smoothstep in Unity's Shader Graph. This article covers the root cause of aliasing and explains how to implement resolution-independent, 1-pixel-wide anti-aliasing using the ddx and ddy screen-space derivative nodes.
Intermediate Fix mobile overheating and FPS drops caused by uGUI Overdraw (excessive layered transparent UI elements) in Unity. Learn how to identify hotspots and optimize fillrate using Empty Graphics.
Intermediate Fix mobile overheating and FPS drops caused by VFX Graph rendering issues on low-end Android devices and WebGL. Learn how to verify Compute Shader compatibility and build a Shuriken-based fallback system.