Rapid Render: Real-Time 3D Product Configurator

Quick Summary

• Role: Software Developer (core 3D engine, asset pipeline, V-Ray SDK integration)
• Duration: February 2021 – January 2022
• Platform: Unity WebGL + Desktop
• Core Technologies: Unity 2020 LTS, URP, C#, Python, V-Ray SDK, glTF, Draco
• Output Types: Realtime WebGL preview, 1080p offline rendering, JSON scene export
• Verified Evidence: Open-source: DracoPy Pull Request #17. Performance: WebGL load <3 sec / 60 FPS- test: [device_class], [browser], [scene: tri_count=[tri_count], texture_count=[texture_count], avg_asset_mb=[avg_asset_mb]]. Offline rendering: V-Ray 1080p ~15 min- settings: [samples], [denoise], [machine/spec], [render_farm?]

RapidRender 3D Configuration and Rendering Engine

I developed RapidRender's core 3D engine within Sugar Technology. By combining Unity's realtime rendering capabilities with V-Ray's production-quality ray tracing approach, I established a hybrid structure that produces both interactive design and high-quality final outputs on the same platform.

Problems and Constraints

• Goal to open heavy scenes in WebGL with low loading time.
• The need to normalize heterogeneous 3D asset formats into a single standard.
• Expect visual consistency between realtime preview and offline photorealistic output.
• Render job queuing and offline pipeline delay costs.
• Browser/GPU diversity and performance constraints.

Solution Summary

I designed a hybrid pipeline: Unity realtime scene production + V-Ray offline rendering. The Unity scene was imported into the V-Ray SDK with Python via the JSON intermediate format; Quality consistency was achieved while maintaining web performance with the glTF/Draco asset pipeline.

Architecture Overview

• Unity scene -> JSON interop -> Python -> V-Ray SDK -> 1080p render output.
• WebGL runtime: Unity build + asynchronous asset streaming + control panel integration.
• Keeping stage schema backwards compatible with JSON serialization and versioning.

Asset Pipeline (glTF/glb + Draco)

• Different manufacturer formats normalized to glTF/glb; UV unwrap, texture baking and metadata injection are automated.
• Data consistency was ensured with Pygltflib based validation and rule sets.
• Asynchronous loading and progressive streaming implemented with UnityGLTF.
• Optimized WebGL delivery size with Draco compression.

Performance and Optimization

• Material, glass and outline effects were produced with Shader Graph and custom HLSL shaders.
• Draw call batching, GPU instancing, texture atlasing and LOD strategies were implemented.
• Iterative performance tuning was done with Unity Profiler + Frame Debugger.

V-Ray Pipeline (Render Jobs)

• Unity scene exported as JSON; Ported to V-Ray SDK with Python.
• Offline output consistency was achieved by preserving the camera/light/material mapping.
• Quality/time balance was established with adaptive sampling and denoising.
• Render jobs were queued and managed with automation scripts.

Open-Source Contribution (Verified Evidence)

I prepared PR #17, which adds texture coordinates and normal support to DracoPy; The contribution was accepted in the open-source community and merged into the main branch.

Impact / Results

• WebGL scene load time - <3 sec - context: [device_class], [browser], [scene: tri_count=[tri_count], texture_count=[texture_count], avg_asset_mb=[avg_asset_mb]], measurement: [profiling_tool].
• Realtime fluidity - 60 FPS - context: [device_class], [resolution], [scene: tri_count=[tri_count]], measurement: [profiler].- Offline rendering time- 1080p ~15 min- settings: [samples], [denoise], [machine/spec], [render_farm?].
• Draco compression effect - (metric can be added: packet size reduction rate) - metric: [build_size_report].
• Asset validation errors - (metrics can be added) - measurement: pipeline validation logs.

Tech Stack (Categories)

• Engine: Unity 2020 LTS, URP, Shader Graph
• Languages: C#, Python 3.8, Cython
• Rendering: V-Ray 5, V-Ray SDK, HDRI, IES
• Formats: glTF 2.0, glb, Draco, Assimp
• Web: WebGL, WebAssembly, gzip/Brotli, CDN
• Data/Interop: JSON, Newtonsoft.Json
• Tools: Visual Studio, PyCharm, Unity Editor, Git

FAQ

Why the Unity + V-Ray hybrid approach?

To meet the need for realtime interaction and offline photorealistic output on the same platform.

Why was glTF/glb chosen?

Because it provides web compatibility, wide tool support and stable standardization.

Why is Draco critical?

To reduce loading time and packet size in WebGL.

How was 60 FPS maintained in WebGL?

With batching, instancing, LOD, shader optimization and profiler based tuning.

How was the render farm job orchestration managed?

Prioritization/retry flows were established with Python scripts and job queue approach.

How were versioning and migration managed?

With JSON schema versioning and automatic migration scripts.

How is asset pipeline quality assured?

With Pygltflib validations and metadata rules.

Related Projects

• Kayra Export: Marketplace & E-Commerce Platform
• ABC Logistics: Real-Time GIS Tracking Platform- Dunelm: LiDAR Supported AR "View-in-Room" Experience

Project Imprint

• Company: Sugar Technology
• Position: Software Developer
• Sector: Architecture & Interior Design Technologies
• Platform: Unity WebGL & Desktop
• Core Technologies: Unity 3D, C#, Python, V-Ray
• 3D Formats: glTF/glb, Draco Compression
• Open-Source: DracoPy Texture Coordinates & Normals Support (PR #17)
• Duration: February 2021 – January 2022
• Location: Istanbul, Türkiye
• GitHub Contribution: DracoPy Pull Request #17