Classic Chess Scene - Cross-Platform Real-Time Rendering Demo

The Classic Chess Scene is one of the reference demonstrations included in Flow Render Engine to validate the rendering pipeline, lighting system, materials, shader management and cross-platform graphics architecture.

The scene renders a complete 3D chess board entirely in real time using modern C++ rendering techniques and demonstrates how the same rendering framework can operate on multiple graphics APIs without modifying the application code.

Flow Render Engine currently supports both OpenGL and Vulkan rendering backends, allowing the same scene, assets and shaders to be rendered through different graphics APIs while preserving identical visual results. The engine is also designed for cross-platform deployment across Windows, Linux and Webassembly, making it suitable for desktop and web graphics applications.

Unlike a simple graphics showcase, this scene is intended as a validation environment for many subsystems of the engine, including mesh management, material binding, shader compilation, texture sampling, render state management, camera control and GPU resource management.

The current screenshots use the classical Phong reflection model with a single directional light, providing a clean environment for evaluating lighting quality, material appearance and shader behaviour. Additional comparisons demonstrate the visual improvements obtained using normal mapping while maintaining the same underlying mesh geometry.

The images below illustrate the rendering quality achieved by Flow Render Engine across multiple rendering configurations and platforms.

Interactive Chess Scene Demo (WebAssembly / Emscripten)

Run the Classic Chess demo online

Classic Chess Scene - Phong Reflection Lighting

The following screenshots show the default rendering configuration using classic Phong lighting, textured materials and a single directional light. This setup provides a clean reference for evaluating illumination, specular highlights, shadow perception and overall scene composition.

The green board material demonstrates how the lighting model interacts with glossy wooden surfaces while preserving consistent shading across every chess piece.

The brown board version illustrates an alternative material configuration while maintaining the same lighting model and rendering pipeline.

Camera View 1

This camera angle demonstrates balanced ambient, diffuse and specular lighting while preserving the geometric details of every chess piece.

Camera View 2

A different perspective highlights the consistency of the lighting calculations across the complete chess board while maintaining stable texture quality and smooth shading.

Camera View 3

This viewpoint emphasizes the contribution of the Phong illumination model and the smooth interpolation of surface normals across the scene.

Camera View 4

A lower camera position provides a better visualization of light interaction with the chess pieces and demonstrates the material system implemented inside Flow Render Engine.

Cross-Platform Rendering on Linux Ubuntu 22.04 LTS

One of the primary design goals of Flow Render Engine is platform independence. The following screenshot shows the exact same scene rendered natively on Linux Ubuntu 22.04 LTS using the same rendering architecture. The visual output remains identical while demonstrating the portability of the graphics engine across multiple operating systems.

Normal Mapping vs Standard Phong Shading

Normal mapping is one of the most widely used techniques in modern real-time rendering. Instead of increasing polygon count, additional surface detail is simulated by perturbing the normal vectors used during lighting calculations. This technique significantly improves visual realism while keeping GPU performance high.

The following comparison illustrates the difference between standard Phong shading and the same scene rendered using normal maps.

The first comparison highlights the increased surface detail generated exclusively through lighting calculations.

Additional fine details become visible without modifying the underlying mesh geometry.

The lighting response appears richer while maintaining the same polygon count.

Normal mapping introduces additional depth perception, especially around edges and engraved surface details.

The comparison demonstrates how texture-based normal information interacts with the directional light source.

This final image summarizes the overall visual improvement achieved through normal mapping while preserving rendering efficiency.

Rendering Features

The Classic Chess demo demonstrates several core technologies implemented in Flow Render Engine:

• Modern C++ graphics engine.
• Multi-backend rendering architecture.
• OpenGL renderer.
• Vulkan renderer.
• GLSL shader system.
• SPIR-V shader pipeline.
• Phong reflection lighting.
• Directional lighting.
• Texture mapping.
• Normal mapping.
• Material system.
• Mesh management.
• GPU resource management.
• Cross-platform rendering.
• Windows support.
• Linux support.
• Webassembly (Emscripten) support.
• High-performance real-time rendering.
• Render pipeline abstraction.

Technical Overview

Internally, the scene is composed of multiple independent meshes representing the chess board and individual chess pieces. Each mesh is associated with a material containing textures and shader parameters used during rendering.

During each frame, Flow Render Engine updates the camera, prepares the rendering commands, binds the corresponding materials and shaders, and submits the geometry to the GPU. The lighting calculations are performed entirely in GLSL fragment shaders using the classical Phong illumination model.

The normal mapping examples additionally sample tangent-space normal textures to perturb the surface normals before evaluating the lighting equation. This approach significantly improves the visual complexity of the scene while keeping the original geometry unchanged, making it an efficient technique for real-time graphics applications.

Overall, this demonstration serves as a practical example of how Flow Render Engine combines modern C++ design, OpenGL and Vulkan rendering, shader-based lighting and cross-platform portability to build high-performance real-time graphics applications.