Tickets
List of all tickets
Last updated
List of all tickets
Last updated
Files 01 - Textures Crunch Compression
What It Does: Uses advanced compression to reduce texture file size and memory usage with minimal quality loss.
Our Modification: Enabling Crunch Compression reduces load times and overall memory footprint, which is crucial for mobile VR.
Note that crunch compression can produce some slight artefacts, while some textures, such as UI or fonts, need to remain precise. For this reason, we ignore Sprites (2D and UI) and Normal maps in the search.
Files 02 - Audios Force To Mono
What It Does: Converts stereo audio clips into mono, reducing file size and the number of audio channels processed at runtime.
Our Modification: We force audio clips to mono wherever spatialization or stereo panning is not required. This lowers memory use and reduces audio processing overhead, which is critical on performance-limited VR devices.
Files 03 - Audios Normalize
What It Does: Adjusts the overall volume of audio files to a consistent level, avoiding volume spikes or inconsistencies.
Our Modification: Normalizing helps keep a stable audio profile across assets, ensuring smoother playback and avoiding sudden volume jumps, especially in VR where loud spikes are more jarring.
Files 04 - Audios Load Type
Decompress on Load: Best for very small SFX (under 300 KB). Fully uncompressed into RAM on load, allowing instant playback with zero runtime CPU overhead. Avoid for larger files due to memory cost.
Compressed in Memory: Ideal for mid-sized audio (between 300 KB and 2 MB, e.g. voice clips). Keeps data compressed in RAM and decompresses on the fly. Saves memory, slight CPU cost during playback.
Streaming: Use for large files (2MB+, like background music). Data is streamed directly from disk, minimizing RAM usage. May introduce slight playback delay.
Files 05 - Audios Compression Format
What It Does: Selects an audio compression format that reduces file size while maintaining quality.
Our Modification: Choosing Vorbis ensures efficient compression for smaller file sizes without a significant loss in audio quality.
Files 06 - Audios Quality
What It Does: Controls the bitrate of audio compression, impacting both file size and sound clarity.
Our Modification: Adjusting this setting helps you find the lowest acceptable quality that minimizes file size while keeping audio clear.
Files 07 - Materials Simple Lit
What It Does: Simplifies material shaders, reducing GPU workload and calculation complexity.
Our Modification: Using simpler materials reduces shader complexity, improving performance, especially for mobile VR applications.
Files 08 - Materials Render Face
What It Does: Controls whether the material renders front, back, or both sides of a mesh.
Our Modification: Setting this to Front reduces unnecessary rendering of hidden faces, improving performance especially on complex models.
Files 09 - Textures Aniso Level
What It Does: Enhances texture clarity at steep viewing angles, particularly for ground or wall surfaces.
Our Modification: Lowering this setting reduces GPU cost, while still preserving enough clarity for VR comfort.
Files 10 - Textures Read Write
What It Does: Determines whether textures can be read or written at runtime.
Our Modification: Disabling "Read/Write Enabled" ensures no unnecessary memory allocation, thus saving resources.
Files 11 - Textures Mipmaps
What It Does: Generates lower-resolution versions of large textures for distant rendering, reducing aliasing and memory usage.
Our Modification: Enabling mip mapping for textures 1024 or larger ensures efficient texture display at various distances while saving memory.
Note that some textures should avoid having mipmaps in order to remain precise. For this reason, we ignore Lightmaps, Sprites (2D and UI) and GUI in the search.
Files 12 - Avoid 4K+ Textures
What It Does: Allows for the import of high-resolution textures, which may increase memory and processing demand.
Our Modification: Reducing texture resolution below 4K ensures lower memory usage with little to no visual loss in quality, optimizing performance for VR.
Files 13 - Non Directional Lightmaps
What It Does: Uses non-directional lightmaps that do not store lighting direction information, simplifying shading calculations.
Our Modification: Enabling this reduces memory and GPU load at the cost of less realistic lighting. An acceptable tradeoff for static scenes in mobile VR.
Files 14 - Disable Realtime Global Illumination
What It Does: Prevents Unity from calculating indirect lighting dynamically at runtime.
Our Modification: Disabling this saves considerable CPU and GPU cycles. Baked lighting is sufficient for most Quest use cases.
Files 15 - Textures Filtering
What It Does: Determines how texture pixels are interpolated. Bilinear filtering is faster, while trilinear filtering offers smoother transitions between mipmaps levels.
Our Modification: Testing between Bilinear and Trilinear helps find the right balance between performance and visual quality for your textures.
Files 16 - Meshes Compression
What It Does: Optimizes vertex data for meshes, reducing file size and memory usage.
Our Modification: Enabling mesh compression minimizes memory consumption and enhances performance by reducing data load.
Files 17 - Meshes Read Write
What It Does: Allows meshes to be read and written at runtime, which can increase memory usage.
Our Modification: Disabling "Read/Write Enabled" prevents unnecessary memory duplication, saving resources and improving performance.
Files 18 - Disable Meshes BlendShapes
What It Does: Controls the use of blend shapes for mesh animations.
Our Modification: Disabling blend shapes, if needed, reduces animation data, decreasing CPU load and improving performance.
Files 19 - Disable Meshes Normals
• What It Does: Controls whether normals are included in the mesh’s vertex data. Normals are mainly used for lighting calculations like diffuse and specular shading.
• Our Modification: We disable normals for meshes that don’t require dynamic lighting, reducing vertex data size and improving GPU efficiency on mobile VR.
Files 20 - Disable Meshes Tangents
• What It Does: Determines if tangents are included in the mesh’s vertex data. Tangents are necessary for effects like normal mapping but unused otherwise.
• Our Modification: We remove tangents from meshes that don’t use normal maps, saving memory and vertex bandwidth for better performance.
Files 21 - Textures Power of 2
What It Does: Ensures that texture dimensions are powers of two (e.g. 256, 512, 1024), which is a GPU-friendly format that improves texture streaming, mipmapping, and overall performance.
Our Modification: We adjust non-compliant textures to the nearest power-of-two size where visual quality is preserved, helping reduce runtime memory usage and improve rendering efficiency on mobile VR devices.
Graphics 01 - BatchRendererGroup KeepAll
What It Does: Organizes and batches renderer groups for better GPU efficiency.
Our Modification: Ensuring all batching variations are preserved optimizes rendering and ensures better performance during complex scenes.
Meta 00 - Add Oculus Package
What It Does: Adds Oculus-specific XR integration features required for optimal Quest development.
Our Modification: Installing this ensures proper headset tracking, input handling, and rendering paths tailored for Meta Quest.
Meta 01 - Add Target Device
What It Does: Specifies the target device for build optimization.
Our Modification: Targeting specific Quest devices ensures your build is optimized for the intended device.
Meta 02 - Multiview
What It Does: Determines the VR rendering method. MULTIVIEW renders both eyes in a single pass (ideal for Android), while Single Pass is often used on desktop.
Our Modification: Choosing MULTIVIEW on Android minimizes draw calls and GPU overhead, which is key for performance on Quest.
Meta 03 - Enable Optimize Buffer Discards
What It Does: Helps manage GPU memory by efficiently discarding unused buffers.
Our Modification: Enabling this improves Vulkan performance by reducing latency and ensuring smoother, more consistent rendering.
Meta 04 - Enable Symmetric Projection
What It Does: Forces similar projection matrices for both eyes to reduce computational overhead.
Our Modification: Enabling this improves Vulkan performance by reducing latency and ensuring smoother, more consistent rendering.
Meta 05 - Subsample Layout
What It Does: Adjusts texture sampling for peripheral regions to reduce processing load.
Our Modification: Enabling this option (with testing) can further reduce latency and boost performance, provided no visual artifacts occur.
Meta 06 - Vulkan Depth OculusDepthSubmission
What It Does: Efficiently passes depth information to the compositor for improved rendering.
Our Modification: Enabling this option (with testing) can further reduce latency and boost performance, provided no visual artifacts occur.
Meta 07 - Vulkan Late Latching
What It Does: Updates head tracking data later in the frame to minimize latency.
Our Modification: Enabling this option (with testing) can further reduce latency and boost performance, provided no visual artifacts occur.
Meta 08 - OpenGLES Subsample Layout
What It Does: Low Overhead mode minimizes driver overhead by streamlining command processing in OpenGLES.
Our Modification: Testing this option may reveal performance gains on OpenGLES builds, enable if your tests show a benefit without side effects.
Meta 09 - Fixed Foveated Rendering
What It Does: Reduces the rendering workload by decreasing detail in peripheral vision areas.
Our Modification: Enabling fixed foveated rendering improves performance by lowering GPU load without sacrificing the VR experience in the foveated region.
Meta 10 - OpenXR Foveated Rendering
What It Does: Enables foveated rendering through the standard OpenXR extension, which reduces visual detail in peripheral regions to improve performance.
Our Modification: We enable OpenXR foveated rendering to ensure performance gains on all compatible headsets.
Physics 01 - Default Contact Offset
What It Does: Controls the default contact offset for collision detection.
Our Modification: Setting defaultContactOffset >= 0.01f improves collision detection accuracy and performance by reducing unnecessary calculations.
Physics 02 - Sleep Treshold
What It Does: Determines the threshold for when a rigidbody will go to sleep (stop simulating physics).
Our Modification: Setting sleepThreshold >= 0.005f reduces unnecessary physics calculations when objects are at rest, improving performance.
Physics 03 - Default Solver Iterations
What It Does: Defines the number of solver iterations for physics calculations.
Our Modification: Reducing defaultSolverIterations <= 8 strikes a balance between performance and accuracy, improving performance in scenarios where detailed physics simulation is unnecessary.
Player 01 - LinearColorSpace
What It Does: Determines how lighting and colors are computed. In Linear mode, lighting is calculated physically correctly, which leads to more natural and consistent shading.
Our Modification: Setting it to Linear ensures realistic lighting interactions, which enhances immersion and visual quality on Quest.
Player 02 - MSAA Fallback Downgrade
What It Does: MSAA (Multi-Sample Anti-Aliasing) smooths out jagged edges by sampling multiple times per pixel. The fallback “Downgrade” allows Unity to reduce the MSAA level automatically if the performance impact is too high.
Our Modification: Using Downgrade protects your game from significant performance drops by dynamically lowering anti-aliasing quality when needed.
Player 03 - Disable Auto Graphics API
What It Does: When enabled, Unity selects the graphics API automatically. Disabling it forces you to manually choose the API (typically Vulkan for better performance, or OpenGLES3 for stability).
Our Modification: Disabling auto-selection lets you explicitly choose Vulkan orOpenGLES3 as needed, giving you control to optimize the render pipeline for Quest.
Player 04 - GraphicsJobs
What It Does: This experimental feature enables multi-threaded rendering by distributing graphics tasks across multiple CPU cores.
Our Modification: Enabling it may boost performance on multi-core devices, but thorough testing is required to ensure stability on Quest.
Player 05 - GraphicsJobsLegacy
What It Does: Determines which implementation of graphics jobs is used. The Legacy mode refers to the older, more proven system rather than newer, experimental approaches.
Our Modification: Using Legacy mode offers better compatibility and proven stability, minimizing risks when optimizing for Quest.
Player 06 - Color Gammut sRGB
What It Does: Determines the color space for rendering. sRGB is the standard for most displays.
Our Modification: Ensuring sRGB avoids color mismatches and maintains visual consistency on Quest’s display hardware.
Player 07 - Multithreaded Rendering
What It Does: Allows Unity to process rendering tasks across multiple CPU threads.
Our Modification: Enabling it improves CPU utilization, but must be tested thoroughly for compatibility with VR rendering paths.
Player 08 - Static Batching
What It Does: Combines static GameObjects into one mesh at build time to reduce draw calls.
Our Modification: Enabling this reduces CPU overhead, especially beneficial in static-heavy scenes typical of VR.
Player 09 - Lightmap Streaming
What It Does: Loads lightmaps gradually based on camera distance rather than all at once.
Our Modification: Helps manage memory more efficiently during runtime, improving performance on memory-constrained platforms.
Player 10 - Disable HDR Display Output
What It Does: Controls whether the app enables HDR (High Dynamic Range) output, which can improve brightness and contrast on displays that support it.
Our Modification: We disable this setting since Quest displays do not support HDR. Turning it off prevents unnecessary processing and avoids wasted GPU bandwidth.
Player 11 - PrebakeCollisionMeshes
What It Does: Precalculates collision data during the build, rather than at runtime, reducing CPU load during gameplay.
Our Modification: Enabling it decreases runtime collision calculations, helping maintain a stable frame rate on performance-constrained Quest hardware.
Player 12 - OptimizeMeshData
What It Does: Removes unused mesh data (like extra vertex channels) during the build process, reducing memory usage and load times.
Our Modification: Enabling this ensures only essential mesh information is kept, which is vital for maintaining high performance on mobile VR devices.
Player 13 - MipmapStripping
What It Does: Strips out unnecessary mip map levels from textures to save memory without compromising visual quality at various distances.
Our Modification: We enable this to reduce texture memory usage, which is important on the Quest’s limited RAM. However, it increases CPU usage at runtime, so this option should be disabled if CPU performance is a bottleneck.
Player 14 - Minimum API Level 32
What It Does: Sets the lowest Android API level that the app can run on. This affects backward compatibility with older Android versions and access to platform features.
Our Modification: We set it to API level 32 to align with Quest platform requirements and ensure compatibility with modern Android functionality.
Player 15 - TargetAPI 32
What It Does: Specifies the Android API level that the app is built to run against. Higher API levels provide access to newer system features but may also introduce compatibility requirements.
Our Modification: We target API level 32 to ensure compatibility with current Quest OS versions and meet Meta’s minimum submission criteria.
Player 16 - Managed Stripping Level
What It Does: Determines how aggressively unused code is removed during the build process.
Our Modification: We set this to Medium or High to reduce build size and improve loading times. However, this setting should be tested carefully, as it may cause issues with techniques like Dependency Injection, particularly with frameworks such as VContainer that rely on reflection.
Player 17 - TextureCompression_ASTC
What It Does: Enables ASTC (Adaptive Scalable Texture Compression) support, which allows textures to be stored with high quality and low memory usage, especially on supported mobile GPUs.
Our Modification: We use ASTC as our default texture compression format due to its efficiency on Quest devices. This helps reduce texture memory without noticeably degrading visual quality.
Player 18 - 32Bits Display Buffer
What It Does: Defines the color precision for the display buffer.
Our Modification: Keeping this enabled ensures accurate color rendering, but may use more memory. Test based on your visual needs.
Player 19 - Target Architecture arm64
What It Does: Specifies the target architecture for the app build, ensuring it matches the hardware for optimization.
Our Modification: Setting the target architecture to arm64 ensures the build is optimized for modern ARM-based devices, improving performance and compatibility with Quest.
Player 20 - Use Vulkan Graphics API
What It Does: Enables Vulkan as the primary graphics API instead of OpenGLES. Vulkan provides lower-level access to the GPU, enabling better performance through multithreading and reduced driver overhead.
Our Modification: We enable Vulkan to take advantage of its better performance profile on Quest, especially when used with features like multiview and late latching. It offers more control over rendering behavior, but should be tested thoroughly, as compatibility and stability can vary between devices and Unity versions.
Project 00 - Unity6
What It Does: Using a recent Unity version ensures access to the latest features, bug fixes, and performance improvements.
Our Modification: Using a recent Unity version helps take advantage of the latest XR features, improving both performance and stability for your VR project.
Project 01 - URP
What It Does: The Universal Render Pipeline (URP) provides flexibility in rendering and visual quality but may slightly reduce performance.
Our Modification: URP allows for fine-tuning rendering settings, offering a balance of performance and visual fidelity, making it ideal for mobile VR.
Project 02 - Download Android Module
What It Does: Installs the required Android Build Support module in Unity, which includes the Android SDK, NDK, and JDK. This is necessary to build and deploy projects to Android-based VR platforms like Meta Quest.
Our Modification: We ensure the Android module is downloaded and correctly configured in the Unity Hub installation, making the project VR-ready out of the box.
Project 03 - Switch To Android
What It Does: Switches the project settings to Android, the platform used by Quest.
Our Modification: Switching early to Android ensures proper configuration and optimization for Quest, avoiding setup issues later.
Project 04 - OpenXR Package
What It Does: Adds support for the OpenXR runtime, a cross-platform XR API designed to standardize VR/AR development across devices.
Our Modification: We include the OpenXR package to ensure future compatibility and take advantage of platform-agnostic features. It also integrates well with Unity's XR Management system and Meta’s newer recommendations.
Project 05 - OculusXR Or OpenXR
What It Does: Determines whether the project uses the Oculus XR plugin (Meta-specific) or the OpenXR runtime (cross-platform standard).
Our Modification: We recommend using OpenXR unless you rely on Oculus-specific features not yet exposed through OpenXR. This makes the project more portable and aligns with Meta’s long-term ecosystem strategy.
Project 06 - XRManagement Package
What It Does: Manages XR plugins like OpenXR or OculusXR through a centralized system in Unity.
Our Modification: We install this package to enable XR support and manage the active loader for the project.
Quality 01 - RealtimeReflectionProbes
What It Does: Realtime reflection probes calculate reflections dynamically, which can be performance-intensive.
Our Modification: Baked reflections are less resource-heavy and should be used wherever possible to save GPU resources.
Quality 02 - Disable VSync
What It Does: Vsync synchronizes the frame rate with the display’s refresh rate to avoid tearing but can add input lag.
Our Modification: Setting it to Don’t Sync removes the frame lock, reducing latency and allowing the engine to push higher frame rates essential for VR.
Quality 03 - Full Resolution Mip Map
What It Does: Uses full-resolution mipmaps for textures, which can increase texture quality but also memory usage.
Our Modification: Disabling full-resolution mipmaps lowers memory usage and improves performance, especially for mobile VR.
Quality 04 - AnisototropicTextures
What It Does: Applies anisotropic filtering to improve texture clarity at steep angles, but with a performance cost if overused.
Our Modification: Using the Per Textures option lets you fine-tune this effect, balancing detail and performance based on each texture’s needs.
Quality 05 - MipmapStreaming
What It Does: Dynamically loads only the needed mipmap levels based on camera distance, reducing memory consumption.
Our Modification: Enabling this streamlines texture memory usage and ensures your game uses texture detail only when needed, which is especially beneficial in complex or large scenes on the Quest.
Quality 06 - ShadowMaskMode
What It Does: In Shadowmask mode, static objects receive pre-baked shadows while dynamic objects cast realtime shadows, reducing the need for continuous shadow calculations.
Our Modification: Setting it to Shadowmask minimizes realtime shadow processing, thereby reducing GPU load and boosting performance.
Quality 07 - SkinWeightsTwoBones
What It Does: Determines how many bones affect each vertex during skinning. Fewer bones mean less computational work but may reduce animation smoothness.
Our Modification: Limiting skin weights to 2 bones lowers CPU overhead during animations, which is crucial for maintaining performance in VR.
Renderer 00 - Active Render Pipeline Asset
What It Does: Sets the URP asset currently used by the project.
Our Modification: Using a streamlined URP asset ensures consistent rendering configuration and avoids unintended performance hits.
Renderer 01 - DepthTexture
What It Does: Stores a depth texture that allows post-processing effects to access depth information.
Our Modification: Disabling it when unused saves memory and processing time. Only enable it if your effects require it.
Renderer 02 - OpaqueTexture
What It Does: Captures a low-res copy of the scene before post-processing.
Our Modification: Disabling it avoids extra memory and GPU usage unless specifically needed (e.g., for UI or distortion effects).
Renderer 03 - Disable Terrain Hole
What It Does: Disables terrain holes, which can be a feature that increases rendering overhead.
Our Modification: Disabling terrain holes reduces unnecessary computations and renders simpler terrain, improving performance.
Renderer 04 - GPUResidentDrawer
What It Does: Keeps frequently accessed GPU data in memory, reducing the need to reload it every frame.
Our Modification: We disable this feature, as it is not yet fully VR-ready. While it can reduce latency in some Vulkan projects, it may cause instability or visual issues in VR. Be sure to test thoroughly before enabling it in a Quest build.
Renderer 05 - GPUOcclusionCulling
What It Does: Prevents objects that are out of view from being rendered, saving GPU resources.
Our Modification: We disable GPU occlusion culling, as it is currently not fully compatible with VR rendering. It may lead to culling errors or visual artifacts in headset displays. Use with caution and only after confirming it works reliably in your project.
Renderer 06 - Disable HDR
What It Does: HDR processing enhances brightness range but adds extra processing.
Our Modification: Disabling HDR cuts unnecessary overhead since Quest displays don’t fully utilize HDR, thereby improving performance.
Renderer 07 - MSAA4x
What It Does: Smooths out jagged edges by sampling pixels multiple times; 4x indicates a moderate level of sampling.
Our Modification: Setting it to 4x balances improved image quality with minimal performance impact.
Renderer 08 - Render Scale
What It Does: Determines the resolution multiplier at which the scene is rendered relative to the device’s native resolution.
Our Modification: We recommend keeping the Render Scale between 0.85 and 1.2. A value of 1.0 is already below the headset’s full resolution, but increasing it slightly (up to 1.2) can enhance visual clarity if the project is well optimized. Conversely, Meta VRCs recommend not going below 0.85, as lower values may degrade the visual experience. Always test per scene to maintain performance and clarity.
Renderer 09 - Upscaling Filter Fidelity FX
What It Does: Provides a high-quality upscaling method, typically used in dynamic resolution scenarios.
Our Modification: Setting it to "Auto" ensures the best upscaling option is chosen automatically, balancing performance and image quality.
Renderer 10 - Lod Cross Fade
What It Does: Smooths the transition between levels of detail (LOD) for 3D models by blending between meshes rather than swapping instantly.
Our Modification: This option should be disabled unless necessary for visual polish, as it introduces slight overhead. Use it only if LOD popping is visually disruptive and justifies the cost.
Renderer 11 - One Main Light
What It Does: Limits the scene to a single directional light for simplicity and performance.
Our Modification: Enabling this ensures optimal performance, particularly for scenes relying mostly on baked lighting.
Renderer 12 - No Additional Light
What It Does: Disables extra dynamic lights to prevent unnecessary GPU calculations.
Our Modification: Keeping this off ensures only essential lighting is used, reducing per-frame overhead.
Renderer 13 - DisableMainLight
What It Does: Turns off the main directional light entirely.
Our Modification: Useful for stylized or baked-only scenes. Cuts all real-time lighting cost from the primary light source.
Renderer 14 - Disable Post Processing
What It Does: Turns off all post-processing effects in the URP pipeline.
Our Modification: Disabling this can result in large performance gains on Quest. Only enable specific effects selectively.
Renderer 15 - Rendering Path Forward
What It Does: Sets the rendering path for the URP pipeline. URP supports two main forward rendering paths:
Forward: A simpler rendering path with lower overhead. It renders each object once per light affecting it and supports a limited number of dynamic lights per object.
Forward+: Uses clustered lighting to support more dynamic lights efficiently. It introduces a depth pre-pass and additional memory usage for light clustering data.
Our Modification: We recommend using Forward on Quest to minimize draw calls, memory usage, and shader complexity. Forward+ can be useful in rare cases where multiple dynamic lights are essential, but it comes at the cost of performance and should be tested carefully on mobile VR hardware.
Renderer 16 - Disable SSAO
What It Does: Screen-Space Ambient Occlusion (SSAO) adds subtle shading to creases, corners, and contact areas to enhance visual depth.
Our Modification: Disabling SSAO removes a significant post-processing cost, with minimal impact on visuals for most mobile VR games.
Renderer 17 - Intermediate Texture Auto
What It Does: Automatically manages the use of intermediate render textures.
Our Modification: Leaving this to Auto allows Unity to optimize internally unless you need manual control for specific effects.
Scene 01 - No Volume in Scene
What It Does: Volumes in Unity (like post-processing volumes) add visual effects that can enhance scene realism but also consume GPU resources, which may not be necessary in VR where performance is critical.
Our Modification: We removed all Volume components from the scenes to reduce GPU load and improve frame rates, as post-processing effects are often not essential in mobile VR experiences.
Scene 02 - Multiple Materials Per Object
What It Does: Having more than one material per mesh increases draw calls.
Our Modification: Limiting objects to one material keeps rendering fast and avoids batching issues.
Scene 03 - OVR Use Recommend MSAA Level
What It Does: Automatically adjusts the Multi-Sample Anti-Aliasing (MSAA) level for optimal performance.
Our Modification: Using the recommended MSAA level ensures smooth visuals with minimal performance overhead on Quest.
Scene 04 - OVR Sharpen Type
What It Does: Controls the image sharpening applied to the scene, which can improve visual clarity.
Our Modification: Setting this to "None" avoids unnecessary sharpening, reducing processing overhead and keeping performance optimal.
Scene 05 - OVR Processor Favor
What It Does: Allows tuning which processor (CPU or GPU) receives more resources for a given task.
Our Modification: Configuring OVR Processor Favor ensures that either the CPU or GPU gets prioritized, optimizing performance based on your game’s needs.
Scene 06 - OVR Dynamic Resolution
What It Does: Adjusts the render resolution dynamically based on performance load to maintain frame rate.
Our Modification: Setting it to 0.7 lets the game drop to 70% of native resolution when needed, which helps maintain performance during heavy scenes—though it requires careful testing to ensure visual quality remains acceptable.
Scene 07 - Triangles Count
What It Does: Tracks total triangle count to ensure scene complexity stays within Quest limits.
Our Modification: Keeping under 100k visible triangles at a time is a good baseline for performance.
Note that for LOD Groups, only the LOD 0 is added to the count.
Scene 08 - Triangles Count Per Object
What It Does: Prevents large triangle meshes that can't be culled efficiently.
Our Modification: Keeping objects under ~10k triangles helps batching and reduces overdraw.
Scene 09 - Negative Scales
What It Does: Applying a negative scale (e.g., -1) to objects can break lighting calculations and frustrate GPU-based culling systems. It can also interfere with physics colliders.
Our Modification: Always avoid negative scales. Instead, flip models in 3D modeling software or adjust orientation using rotation. This ensures stable rendering, correct lighting, and physics behavior.
Scene 10 - Realtime Lights
What It Does: Real-time lights are evaluated every frame and consume GPU cycles, especially when casting shadows.
Our Modification: It is strongly recommended to set the number of real-time lights to 0. Use only baked lights unless absolutely necessary for gameplay. This significantly reduces performance cost on mobile hardware.
Scene 11 - Realtime Reflection Probes
What It Does: Real-time reflection probes update every frame, which adds a heavy GPU cost and can impact performance.
Our Modification: Always disable real-time reflection probes unless they are strictly required. Use baked reflection probes to achieve similar visual results with far less overhead.
Scene 12 - Static Baked Lights
What It Does: Marks lights as static and uses light baking to reduce runtime costs.
Our Modification: Ensures optimal GPU usage and smooth lighting without frame-by-frame recalculation.
Scene 13 - Static Baked Reflection Probe
What It Does: Bakes reflection data for static objects.
Our Modification: Reduces real-time reflection overhead while preserving visual feedback from reflective surfaces.
Scene 14 - Avoid Camera Stack
What It Does: Camera stacking combines outputs from multiple cameras and can greatly increase draw calls.
Our Modification: Use a single camera unless there's a critical design need for stacking.
Scene 15 - One Active Camera
What It Does: Multiple active cameras can conflict or duplicate rendering.
Our Modification: Always ensure only one active camera is present per scene for optimal performance.
Scene 16 - One Active Audio Listener
What It Does: Multiple audio listeners cause Unity to log warnings and reduce audio efficiency.
Our Modification: Keep only one Audio Listener active at any time (typically on the main camera).
Scene 17 - One Main Camera
What It Does: Ensures that the scene uses the main camera tag for rendering.
Our Modification: Using only one main camera tag simplifies the scene and improves rendering performance by ensuring that only the designated camera is active.
Scene 18 - Bake Occlusion Culling
What It Does: Hides objects that are blocked from view to reduce draw calls and GPU load at runtime.
Our Modification: Enabled and baked occlusion culling to improve performance in complex areas.
It also needs to be activated on the camera to work.
Scene 19 - Activate Occlusion Culling on Camera
What It Does: Allows the camera to skip rendering objects that are hidden behind others.
Our Modification: Enabled occlusion culling on the main camera to reduce draw calls and improve performance.
The scene needs to have baked occlusion data to work.
l