Awesome Open Source
Awesome Open Source

vxr engine logo version 0.7.0

What is vxr?

vxr is a project that emerged from the desire to build a general purpose rendering tool that I could use to implement anything I was curious about or wanted to learn about.

As it stands now, it is a multithreaded 3D game development engine written in C++ and oriented to support different rendering backends. It has its own PBR material model based on the standard microfacet BRDF, but extended to support other visual properties of materials such as iridescence or clear coat. The engine has two different APIs for development:

  • A lower level API based on render display list commands that can be used to build small but efficient applications.
  • A higher level API built on top of the lower level one, which abstracts it to provide a rendering agnostic and component oriented API.

Project webpage:

material model Material Model (from left to right): std, std + clear coat, std + iridescence, std + iridescence + clear coat.


[A vs2017 + opengl Solution is provided by default]

This project uses GENie.lua to create the project solution. Open a CMD in the root directory and execute the following commands to re-create a solution:

cd project
..\tools\genie [parameters] <vs2017|vs2015>

The solution will be located in project/vs/VXR-Engine.sln.

A list of example projects are provided within the solution to showcase the engine's capabilities. To create a new project, add a call to the function 'makeProject("yourProjectName");' at the end of the file project/genie.lua and build.


  • --gl: Build with OpenGL backend.
  • --debug_tracing: Build with minitrace and enable trace.json file creation.
  • --no-console: Do not launch a console with the graphic window.
  • --no-threading: Launch rendering on the same thread as the logic + no async loading tasks.
  • --no-ui: Disable all the UI (will still compile ImGui though).

















  • Multithreaded agnostical graphics API.
  • Command Based Rendering, allowing to build the render commands in advance to be run in a separate thread.
  • GameObjects with the following components currently implemented (each component is controlled and updated by a specific system):
    • Transform: Containing the object's transformation and position in the scene's hierarchy.
      • Quaternions!
    • Mesh Filter: Reference to the mesh the object will be rendered with.
    • Renderer: Reference to the Material Instance the object will be rendered with.
      • Current Materials:
        • Standard Lit (PBR)
          • Microfacet BRDF + Thin Film Iridescence + Clear Coat + Anisotropy
        • Unlit
        • Wireframe
        • Skybox
        • Screen
        • Planet (only in the PlanetEditor example!)
        • Add your own!
    • Rigidbody: Adds rigidbody physics to an object and can be applied forces and velocities.
    • Collider: Adds a particular shape to the object to detect collisions with other rigidbodies with a collision shape.
    • Light: Turns the object into a source of light.
      • Directional and Punctual lights supported.
    • Image Based Light: Calculates irradiance of the scene to be used by all PBR materials in the engine.
      • Takes either a cubemap texture or a 2D equirectangular texture.
    • Camera: Adds to an object all the functionality needed to render from its point of view with its unique parameters.
      • Camera Composer: Organizes all post-processing needed for any specific camera, and handles updates automatically.
        • Postprocessing Materials:
          • One-Pass-Filters: Grayscale, Negative.
    • Custom Component: Similar to Unity's MonoBehaviour, allows the user to create custom reusable components with specific behaviours.
  • Model loading (.obj).
  • Lazy Loading: All resources are loaded in different threads to prevent the engine from freezing.
  • UI Editor.



  • Windows


  • OpenGL
  • WIP: DirectX3D 11


The project includes some 3rd party dependencies, but not all of them are necessary (e.g. you won't need GLEW if you generate the project to use DirectX3D 11, you won't need minitrace if you don't want trace debugging, etc).

Optional Dependencies

  • glew - If you are building with OpenGL (--gl)
  • glfw - If you are building with OpenGL (--gl)
  • minitrace - If you are building with debug tracing (--debug-tracing)
  • px_sched.h - If you are not building with single threading (--no-threading)


This is the first project I have made open source, therefore I am wide open to feedback from the community and contributions :^)


MIT License


Mail: [email protected]



Get A Weekly Email With Trending Projects For These Topics
No Spam. Unsubscribe easily at any time.
C Plus Plus (367,525
Open Source (7,171
Opengl (3,710
3d (2,537
Game Engine (2,502
Graphics (2,466
Gamedev (2,328
Material (1,571
Engine (1,505
Multithreading (1,438
Rendering (894
Imgui (385
Graphics Programming (357
Glfw (309
Procedural (210
Pbr (187
Related Projects