Horde3D is a small 3D rendering and animation engine. It is written in an effort to create an engine being as lightweight and conceptually clean as possible.

Related tags

Graphics Horde3D


Horde3D is a 3D rendering engine written in C++ with an effort being as lightweight and conceptually clean as possible.

Horde3D requires a fully OpenGL 2.0 compatible graphics card. In terms of DirectX that means a card supporting at least Shader Model 2.0 or higher. For mobile operating systems (Android and IOS) OpenGL ES 3.0 capable device is required.


  • Modern, cross-platform, shader-based architecture (requires OpenGL 2.0+)
    • Lightweight, non-intrusive design with very few dependencies, avoiding complexity where possible
    • C-style API for easy usage from virtually any programming language
  • Resource management
    • Garbage collected resources, loaded from virtually any type of data stream
    • Hot-reloading of resources for more increased productivity during development
    • Access to vertex data for collision detection and interoperability with physics engines
  • Übershader-based, customizable rendering pipeline
    • Hot-reloading of pipelines for rapid testing of different rendering techniques
    • Support for post processing effects like bloom, DOF or motion blur
    • Support for almost all forward, deferred and High Dynamic Range rendering techniques
    • Support for real-time reflections and other techniques that require several cameras
    • Support for geometry, tessellation and compute shaders
    • Real-time shadows using Parallel Split Shadow Maps (PSSM)
    • Particle systems that can cast shadows and have effects like motion blur
  • Unified scene system
    • World, models and skeletons are scene nodes instead of special objects
    • Frustum culling based on spatial graph
    • Hardware occlusion culling
    • Level of detail for model geometry and materials
  • Unified, low-level animation system
    • Key frame animation for joints and meshes
    • Skeletal animation with up to 4 weights per vertex for articulated models
    • Layered animation blending and mixing using masks and additive channels
    • Morph targets for facial animation and lip synchronization
    • Access to joint data for dynamic animations and ragdoll physics
  • Content Pipeline
    • Mixture of binary and XML formats for best tradeoff between performance and productivity
      • Pipeline, material and scene descriptions are XML
      • Model and animation are binary for maximum performance
      • Textures are common image formats (DDS, PNG, JPEG, etc.)
    • COLLADA Converter for importing assets from many common DCC tools
      • Calculation of tangent space basis for normal mapping
      • Optimization of geometry for GPU post-transform vertex cache
    • Editor for composing scenes, developing shaders and rendering techniques


You need to have a C++11 compiler and CMake 3.7+ installed.

Use of CMake for Windows, Linux, macOs

CMake is a meta-build system, e.g. it creates Makefiles or Visual Studio files using Generators. The main ways to use CMake are cmake-gui (Qt Interface), ccmake (Curses Interface) and cmake (Commandline Interface). Instructions for commonly used generators:

  • Qt Creator: open CMakeLists.txt as new project, follow the instructions, hit build and you're done.
  • Visual Studio: start cmake-gui, choose OGDF as source path, build-vs as build path, press generate, open build-vs\Horde3D.sln and start compiling. You could also generate the solution from the command line running mkdir build-vs && cd build-vs && cmake -G "Visual Studio XYZ" .., where XYZ is the correct identifier for the desired version of Visual Studio (i.e. 14 2015 for VS 2015, 15 2015 for VS 2017, etc. Please run cmake --help for more info).
  • Xcode: open up a terminal, navigate to the repository and run mkdir build-xcode && cd build-xcode && cmake -G "Xcode" .., then open the generated project file inside Xcode.
  • Makefiles: open up a terminal, navigate to the repository and run mkdir build-make && cd build-make && cmake -G "Unix Makefiles" .. && make (hint: use export JOBS=MAX to speed things up).
  • Ninja: open up a terminal, navigate to the repository and run mkdir build-ninja && cd build-ninja && cmake -G "Ninja" .. && ninja.

Build samples

In order to build the samples you need GLFW (>3.x) or SDL (>=2.0.9).

By default, if not present on the system, a default version will be automatically downloaded, built and linked for you.

You could force this behavior using HORDE3D_FORCE_DOWNLOAD_GLFW flag with CMake (from your build directory):


With SDL you can use HORDE3D_FORCE_DOWNLOAD_SDL flag with CMake (from your build directory):


On Debian/Ubuntu platforms, you also need to install the following packages:

 sudo apt-get install xorg-dev

You could also skip sample building using HORDE3D_BUILD_EXAMPLES flag with CMake (from your build directory):


Building for Android

Building for Android requires using two build systems: CMake and Gradle. Gradle project is included in Horde3D distribution.


Android Studio is recommended, but not required.

CMake GUI usage is recommended. Following instruction depends on using GUI for building.

  • Select Horde3D source folder and folder where cmake intermediates and binaries would be stored
  • Hit "Add Entry" button and add new cmake variable "ANDROID_ABI". Tested value is arm64-v8a.
  • Hit "Add Entry" button again and add new cmake variable "ANDROID_PLATFORM". Tested value is android-24.
  • Hit "Add Entry" button again and add new cmake variable "ANDROID_DL_LIBRARY". Cmake may incorrectly specify libdl.a instead of libdl.so and that can lead to problems with libSDL so we have to do it manually. Please set the path to: Android NDK/toolchains/llvm/prebuilt//sysroot/usr/lib/aarch64-linux-android//libdl.so -- where platform is: windows-x86_64, linux-x86_64 -- version is android target api version: 24, 25, ..., 29.
  • Hit configure button, create the folder if asked, and select "Unix makefiles" and "Specify toolchain file for cross-compiling".
  • Select the toolchain file that is located in the Android NDK/build/cmake/android.toolchain.cmake
  • On Windows CMake may not be able to find make.exe program that is in the NDK. Please specify the make program in CMAKE_MAKE_PROGRAM field and set it to ANDROID NDK/prebuilt/windows-x86_64/bin/make.exe
  • In Horde3D submenu select OpenGL ES3 rendering backend and deselect GL2 and GL4 backends
  • If you have you own SDL2 build please specify it in SDL2 submenu (path to includes and library libSDL2.so). SDL2 can also be automatically downloaded and built with Horde3D (please select HORDE3D_FORCE_DOWNLOAD_SDL for that in Horde3D submenu)
  • Set CMAKE_BUILD_TYPE to either Debug or Release.
  • If you wish you can specify signer key for release builds of Android APK, otherwise you would be asked for it during build (debug builds do not require your own key as it would be generated by Android Studio). You can specify ANDROID_APK_SIGNER_KEYSTORE path to keystore file, ANDROID_APK_SIGNER_KEYSTORE_PASS for keystore password and ANDROID_APK_SIGNER_KEY_PASS for key password.
  • Specify ANDROID_SDK_ROOT_PATH - path to Android SDK (required on Linux).
  • Specify ANDROID_SDK_BUILD_TOOLS_PATH for correct release builds (path to signature tools). Default path is Android SDK/build-tools/28.0.3
  • Generate the make files
  • On Windows, Open the cmd.exe, go to the created folder and use the full path to make.exe to launch build process. Example: Android NDK/prebuilt/windows-x86_64/bin/make.exe -j4.
  • On Linux, open the terminal, go to the created folder and type make. Please note that using j parameter for multithreaded compilation requires you to input ANDROID_APK_SIGNER_KEYSTORE_PASS and ANDROID_APK_SIGNER_KEY_PASS in CMake, otherwise you will get a compilation error on apk signing process.

Building for iOS

Currently, building is supported only on macOS. Only iPhone target is supported for now, iPad and tvOS are not tested,

A new version of CMAKE is recommended, Cmake 3.16 was tested and was working correctly.


CMake GUI usage is recommended. Following instruction depends on using GUI for building.

SDL is required for samples. Automatic download and build is disabled for iOS as SDL fails to build with CMAKE (HORDE3D_FORCE_DOWNLOAD_SDL will have no effect ). Please download SDL manually and build it with XCode project, located in /XCode-iOS/SDL. In Build Settings set Enable Bitcode option to No,

  • Select Horde3D source folder and folder where cmake intermediates and binaries would be stored
  • Select the toolchain file that is located in the /BuildTools/ios/ios.toolchain.cmake
  • Hit Configure button
  • Check HORDE3D_USE_GLES3 flag and uncheck HORDE3D_USE_GL2 and HORDE3D_USE_GL4 flags.
  • Set SDL2 include path to /include and SDL library to the generated libSDL2.a file (it is usually located in /Users//Library/Developer/Xcode/DerivedData/SDL-/Build/Products/Debug-iphoneos/libSDL2.a)
  • In IOS category set IOS_CODE_SIGN_IDENTITY and IOS_DEVELOPMENT_TEAM properties. Details on checking the values of these parameters are provided below.
  • Hit Generate button.
  • Now XCode project is generated and can be launched.

To get your development team id go to Applications -> Utilities -> Keychain Access. Under the 'login' Keychain, go into the 'Certificates' category.

Scroll to find your development or distribution certificate. It should be something like that: Apple Development: ()

Double click on this certificate. "Organizational Unit" is the Team ID.

Please note that ParticleVortex and Tessellator sample will not run on iOS as OpenGL ES 3.2 is not available.

Build Horde3D scene editor

There is also a scene editor available for Horde3D. To enabling build of the editor, first make sure you have the Qt 4.8 or any newer Qt 5.x SDK installed. To enable creating makefiles for the editor via cmake set the HORDE3D_BUILD_EDITOR flag to ON (default is OFF).


As the editor needs Lua as a dependency you can either make sure the Lua development files can be found by cmake, or Lua will be automatically downloaded by CMake.

What's next

Here are some quick links to help you get started:


Horde3D is licensed under the Eclipse Public License v1.0 (EPL).

The EPL is a quite liberal license and has fewer restrictions than the popular LGPL. Basically it allows you to use Horde3D in free and commercial projects as long as you contribute improvements like bug fixes, optimizations and code refactorings back to the community. The EPL allows static linking and is not viral; hence it does not affect any other modules of your application.

  • Procedural animation

    Procedural animation

    Hello, I am trying to animate a model added with h3dAddModelNode. (I'm making a deep copy of existing geo data - for the sake of welding seamlessly model parts together) Using the same geo and material it animates when using h3dAddNodes.

    From what I have observed: when AnimationController::animate() gets called, going the fast path, it seems fine up to here :

    uint32 firstStage = _activeStages[0];
    AnimResEntity *animEnt = _nodeList[i].animEntities[firstStage];
    if( animEnt != 0x0 && !animEnt->frames.empty() )

    animEnt is null here when I use h3dAddModelNode

    opened by creutzerb 12
  • GL2 and GL4 problem on AMD card

    GL2 and GL4 problem on AMD card

    Tested newest h3d develop w10 x64.

    I got these errors:

    [h3d] Initializing GL4 backend using OpenGL driver '4.0.14736 Core Profile Context 20.9.1 27.20.12029.1000' by 'ATI Technologies Inc.' on 'Radeon RX550/550 Series' [h3d-err] Could not find all required OpenGL function entry points [h3d-err] Failed to init renderer backend (OpenGL 4.0), retrying with legacy OpenGL 2.1 backend [h3d] Initializing GL2 backend using OpenGL driver '4.0.14736 Core Profile Context 20.9.1 27.20.12029.1000' by 'ATI Technologies Inc.' on 'Radeon RX550/550 Series' [h3d-warn] Render target depth precision limited to 16 bit [h3d-err] Failed to create shadow map

    HACK #1: In utOpenGL.cpp : initModernExtensions( bool &r ) when I put return; just before if ( glExt::KHR_debug ) then GL4 works.

    HACK #2: This brokes GL2 on my AMD graphics card: https://github.com/horde3d/Horde3D/commit/35b510cf535fe50281250205228eb8fb9e1535b0
    when I commented out ASSERT(pixels); and got back uploadTextureData() functions, GL2 works (but it might not work on Nvidia cards).

    opened by bosoni 11
  • Terrain shows geometry artifacts

    Terrain shows geometry artifacts

    Occasionally you can see extra triangles in the terrain.

    These are most noticable if you go "under" the terrain and can see that every other triangle is exactly vertical

    from the top of the terrain you see all the triangles and some extra ones you shouldn't

    opened by chriscamacho 11
  • shadow dissappear

    shadow dissappear


    I have another case of shadows disappearing.


    It stops happening when the camera gets further.

    <Light name="Spot01" lightingContext="LIGHTING" shadowContext="SHADOWMAP" fov="89" shadowMapBias="0.005" shadowMapCount="1" shadowSplitLambda="0" material="materials/light.material.xml" radius="25.0" colMult="1.3333333333333333" col_R="0.5656790137290955" col_G="0.39505836367607117" col_B="0.3053949177265167" tx="-7.00000" ty="8.00000" tz="19.00000" rx="270.00000" ry="0.00000"/>


    opened by creutzerb 9
  • not working with MacOS

    not working with MacOS

    Error copying directory from "/Users/michael/Code/Game2/Horde3D/Horde3D/Binaries/Darwin" to "/Users/michael/Code/Game2/Horde3D/build/Binaries/Darwin//Debug/".

    makes sense because /Users/michael/Code/Game2/Horde3D/build/Binaries/ does not contain any folder Darwin

    opened by MichaelVoelkel 9
  • colladaConv process joints

    colladaConv process joints

    This is more like a question than an issue. I tried to convert some animated character models(dae format) to geo format that H3D can process. I encountered a warning message saying my character has more than 75 joints. Once the model is loaded into the engine, the joint's index (in abc.scene.xml file) which higher than 75 are missing and so does the meshes. Is there a restriction with H3D that prevent loading models that have more than 75 joints?

    Great work on the new version thou. Thanks a ton.

    opened by shadowver 8
  • Updating to GLFW3 (3.0.3) and downloading it via CMake 2.8.

    Updating to GLFW3 (3.0.3) and downloading it via CMake 2.8.

    Hi there, I have tested this on OSX 10.8.5 and it works... don't know why I need to push two times "Run" on XCode.

    Disclailer: I don't know much cmake.

    I have made 2 things

    1. Delete all the source code from GLFW and download it via cmake.
    2. Update to GLFW 3.0.3 the 3 samples.

    Also if you see the CMakeList.txt for the Samples, you will see that they are only configured for add the library from src/Debug from the install_dir.... so I guess this is to much osx and Debug mode... I don't have other machine for continue working on Linux or Windows. Also I don't know much about http://www.kitware.com/media/html/BuildingExternalProjectsWithCMake2.8.html I just read it and make search like:

    https://github.com/search?q=ExternalProject_Add++zip+path%3ACMakeList&type=Code https://github.com/search?q=GIT_REVISION+path%3ACMakeList&type=Code

    And do some try & error.

    opened by tyoc213 8
  • mingw support

    mingw support

    Originally raised here: http://horde3d.org/forums/viewtopic.php?f=2&t=2326

    I know mingw isn't officially supported, but it's a great alternative to VS and seems to be very close to working!

    It builds both GLFW and SDL2 and libHorde3D, but gets stuck at linking the libSampleFramework: undefined reference to `__imp_h3dutLoadResourcesFromDisk'

    Suspect it's a cmake make issue.

    opened by gwald 7
  • camera movement vs culling

    camera movement vs culling


    I just noticed big black patches.


    The walls of the room are made separate tiles. When the camera turns fast enough, and with enough contrast tile/background, you can notice there are holes. I suppose they were culled one frame too many ?

    opened by creutzerb 7
  • Sample framework for multiple platforms

    Sample framework for multiple platforms

    Hello. Currently, the engine itself should pretty much support android and ios, only build system is not yet adapted. The problem lies with samples. Current sample framework was not designed to work on mobile platforms (like ios) and in web (emscripten), partly because glfw does not support them.

    Here are a few suggestions how the sample framework could be adapted:

    1. Adapt sample framework to use glfw for desktops and glfm (link) for mobile and probably web (glfw works well in emscripten)
    2. Switch to SDL (works everywhere, but heavy)
    3. Make a somewhat combined sample framework that uses glfw and has special code for android/ios

    Any ideas on what path to take?

    opened by algts 7
  • New bin output path

    New bin output path

    A proposed solution for #33 and #37.

    Tested on Ubuntu and Windows.

    Please test on Mac OS (and everything else).

    I'm open to comments, critics and requests.

    opened by zuck 7
  • How can we run the sample after compiling

    How can we run the sample after compiling

    Hi dear expert
    Honor to write a letter to you, I have compiled the Horde3D using cmake on ubuntu18.04, but after compiling, I can't run the samples, how can i test the sample?

    $cd Horde3D
    $mkdir build
    $cd build
    $cmake .. $make



    thank you best regards

    opened by WilliamWangPeng 1
  • FBX and GLTF support

    FBX and GLTF support

    Currently Horde supports only Collada file format for input, which is a bit old by today's standards. I'm planning to implement GLTF and FBX support to converter and rename it to Asset converter. tinygltf would be used for gltf parsing and OpenFBX would be used for FBX parsing.

    GLTF converter is currently being developed and FBX backend would be next.

    opened by algts 0
  • PBR support

    PBR support

    Nowadays pbr became a de facto standard in 3d rendering engines, so Horde should also support it. Currently this feature is planned for next release, 2.1.0.

    opened by algts 0
  • glDrawBuffers is a global state function, used incorrectly

    glDrawBuffers is a global state function, used incorrectly

    Per the title, glDrawBuffers is used incorrectly and has to be specified (per the literal language of the spec) every time the fbo is changed.

    This is why deferred rendering doesn't function on Intel hardware (like an HD4000). ATI/nVidia treat the fbo a bit like a vao, which is not correct - drivers massaging out common errors.

    opened by JSandusky 2
  • Vulkan


    Preparing to tackle Vulkan, these are my notes. This issue is an RFC for things I might be missing before I dive in.

    Occlusion Query disabled for first version

    Vertex/Index Buffer changes addition of a dynamic/static specification changes expectations on data update, in Vulkan dynamic will be host-visible and not use the buffer copy operations

    all setXXXX functions pertaining to GL-state go away (blend / etc) Presumably these move into shader contexts Use possibility space for configurations blend = ADD|SUBTRACT|MULTIPLY to enumerate the permutations that need to be determined using derivative pipelines Contexts also specify targets

        is the most problematic function that must be moved into backend responsibility
        it now needs to know about the stage/substage of the renderpath so an appropriate Vulkan pipeline can be chosen
    lighting / shadow functions present concerns
        Horde3D uses a standard lighting model, one has to modify the code to do anime shadowing already (where world/character interactions are significant and different), I'm assuming that anime style shadowing is the extreme
            to clarify, I mean the use of RG16F shadow maps where R = shadows everything, G = shadows only the static world, anime hair/brow shadows are not resolvable on current hardware (to the point they would match production, N-dimensional peeling is required for hair-shadowing and most other anime shadowing [to match production that is])

    setShaderConst has to evolve for uniform-buffers not terribly difficult to leave the same API and also support blob transfer, provided UBO members are uniquely named adjustments portable to GL4 and GLES3 backends

    Hardest on extensions like Terrain / overlays / advanced debug-drawing
        overlays tries to just use a shader combination GL-state rather than properly following
        the material->pipeline flow
        Conditional pipeline command registration?

    Pipeline introduce substage stage is now just a container, Vulkan-wise the targets used by substages in stage are aggregated to the renderpass If no substages are contained in a stage element then a root substage will be inferred Targets can only be changed ONCE during a substage Targets can only be bound ONCE during a substage

    A pipeline must be loaded before any shaders, this changes the sample order
        if a pipeline is loaded later ALL shaders will have Vulkan pipelines generated for them
        Pipelines now become something the rendering backend needs to know about
    Could divine sub-passes from how the <stage /> is written, this would likely be painful and predefining them offers an opportunity to raise meaningful errors regarding mismatches

    SPIR-V SPIR-V is offline compiled, though the compiler could be bundled that's an unecessary dependency Add RIFF support to shaders because RIFF is trivial enough that tooling should never be a problem. Include reference "compiler" that delegates to glslValidator and SPIR-V_Cross binaries to generate this format

    RIFF form-type: HSHD (Horde Shader)
        ListType GL4_
        ListType GL2_
        ListType ES3_
        ListType SPIR
    Each list begins with a reflection chunk, followed by a data chunk (source in the case of raw GLSL) identified as META and CODE, example:
    "RIFF" (file-id)
        "HSHD" (form-type)
        "H_FX" (chunk)
        "LIST" (riff-list)
            "SPIR" (list type)
            "META" (chunk)
            "CODE" (chunk)
        "LIST" (riff-list)
            "GL4_" (list type)
            "META" (riff-chunk)
    	<Stage id="Main">
            <SubStage id="Attribpass">
                <SwitchTarget target="GBUFFER" />
                <ClearTarget depthBuf="true" colBuf0="true" />
                <DrawGeometry context="ATTRIBPASS" class="~Translucent" />
            <SubStage id="LightingPt1" link="pipelines/globalSettings.material.xml">
                <SwitchTarget target="" />
                <ClearTarget colBuf0="true" />
                <!-- Copy depth buffer to allow occlusion culling of lights -->
                <BindBuffer sampler="depthBuf" sourceRT="GBUFFER" bufIndex="32" />
                <DrawQuad material="materials/light.material.xml" context="COPY_DEPTH" />
            <SubStage id="LightingPt2" link="pipelines/globalSettings.material.xml">                
                <BindBuffer sampler="gbuf0" sourceRT="GBUFFER" bufIndex="0" />
                <BindBuffer sampler="gbuf1" sourceRT="GBUFFER" bufIndex="1" />
                <BindBuffer sampler="gbuf2" sourceRT="GBUFFER" bufIndex="2" />
                <BindBuffer sampler="gbuf3" sourceRT="GBUFFER" bufIndex="3" />
                <DrawQuad material="materials/light.material.xml" context="AMBIENT" class="Translucent"  />
                <DoDeferredLightLoop />
                <!-- particles ideally should be drawn without back to front - if you don't want translucent models just remove the order -->
                <DrawGeometry context="TRANSLUCENT" class="Translucent" order="BACK_TO_FRONT" />			
    	<Stage id="Translucent">
    		<ClearTarget depthBuf="true" colBuf0="false" />
    	<Stage id="Overlays">
    		<DrawOverlays context="OVERLAY" />
    opened by JSandusky 7
  • v2.0.2(Apr 26, 2022)

    Minor release that addresses compile issues.

    • Fix compiling with GLFW on new compilers and linux distros (fix library going to lib64 instead of lib during build).
    • Add mingw64 compiler support. Change library order for samples, so that mingw can compile them (other compilers compile with both library orders).
    Source code(tar.gz)
    Source code(zip)
  • v2.0.1(Oct 19, 2021)

    Patch release. There are following updates and bug fixes:

    • Fixed shadow issue with one light, when shadow disappears if camera is near shadow casting object or at a specific angle.
    • Fixed shadow issue with multiple lights, when shadow disappeared for one of the lights when shadow casting object is not visible by current camera.
    • Fixed compiling under Linux with GCC 10.
    • Fixed compiling with MinGW.
    • Terrain sample now respects 'HORDE3D_BUILD_EXAMPLES' define.
    • Collada converter now allows using material id instead of material name.
    Source code(tar.gz)
    Source code(zip)
  • v2.0.0(Feb 8, 2021)

    Release highlights:

    • Added support for OpenGL ES 3.
    • Added support for Android and iOS operating systems.
    • Added support for KTX texture format.
    • Added support for more compressed texture formats - BPTC (BC6-7), ETC1, ETC2, ASTC.
    • Reworked frustum culling - now everything is culled and render queues are generated in the beginning of the frame. Up to 2x performance on scenes with many objects.
    • Deferred shaders now support rendering particles.
    • Added support for custom pipeline actions. Overlays are now moved to extension.
    • Material class processing optimized (up to 15-20% fps increase on material heavy scenes).

    More changes can be found in the changelog file in the documentation

    Source code(tar.gz)
    Source code(zip)
  • v1.0.0(Sep 17, 2017)

    After a long period of beta versions, we finally release the first official Horde3D version. It brings a lot of new features for OpenGL 4 compatible graphic cards, like compute shaders, tessellation and more. The new version relies completly on CMake for project compilation and also integrates the Horde3D editor (disabled in CMake by default).

    Source code(tar.gz)
    Source code(zip)
  • 482a4c2afb(Oct 14, 2013)

Volker Vogelhuber
Volker Vogelhuber
ORE (OpenGL Rendering Engine) is a rendering engine developed for my college minor project assessment.

ORE (OPENGL RENDERING ENGINE) What is ORE? ORE(OpenGL Rendering Engine) is a rendering engine with great and easy to use UI that allows the user to lo

Legion Low Level Rendering Interface provides a graphics API agnostic rendering interface with minimal CPU overhead and low level access to verbose GPU operations.

Legion-LLRI Legion-LLRI, or “Legion Low Level Rendering Interface” is a rendering API that aims to provide a graphics API agnostic approach to graphic

Rythe Interactive 25 Mar 8, 2022
The official Open-Asset-Importer-Library Repository. Loads 40+ 3D-file-formats into one unified and clean data structure.

Open Asset Import Library (assimp) A library to import and export various 3d-model-formats including scene-post-processing to generate missing render

Open Asset Import Library 7.8k May 11, 2022
An implementation of OpenGL 3.x-ish in clean C

PortableGL "Because of the nature of Moore's law, anything that an extremely clever graphics programmer can do at one point can be replicated by a mer

Robert Winkler 471 May 14, 2022
Vire is a C++ voxel rendering engine. It is written in C++14 and uses OpenGL for graphics.

Vire Vire is a C++ voxel rendering engine. It is written in C++14 and uses OpenGL for graphics. Downloads If you'd just like to just download and try,

null 33 May 4, 2022
Im3d is a small, self-contained library for immediate mode rendering of basic primitives

Im3d is a small, self-contained library for immediate mode rendering of basic primitives (points, lines, triangles), plus an immediate mode UI which provides 3d manipulation 'gizmos' and other tools. It is platform and graphics API agnostic and designed to be compatible with VR.

John Chapman 746 May 17, 2022
SoL (for Speed of Light, or sun in Spanish) is a Physically-based rendering library written in modern C++

SoL (for Speed of Light, or sun in Spanish) is a small rendering library written in C++20. Its goal is to strike a good balance between performance and usability, and allow easy experimentation for rendering researchers.

Arsène Pérard-Gayot 9 Mar 3, 2022
Pencil2D is an animation/drawing software for Windows, macOS, Linux, and FreeBSD.

Pencil2D is an animation/drawing software for Windows, macOS, Linux, and FreeBSD. It lets you create traditional hand-drawn animation (cartoon) using both bitmap and vector graphics. Pencil2D is free and open source.

Pencil2D 1.1k May 11, 2022
Monster Mash: New Sketch-Based Modeling and Animation Tool

Monster Mash is a new sketch-based modeling and animation tool that allows you to quickly sketch a character, inflate it into 3D, and promptly animate it. You can perform all interactions in the sketching plane. No 3D manipulation is required.

Google 1.1k May 8, 2022
C++ (with python bindings) library for easily reading/writing/manipulating common animation particle formats such as PDB, BGEO, PTC. See the discussion group @ http://groups.google.com/group/partio-discuss

Partio - A library for particle IO and manipulation This is the initial source code release of partio a tool we used for particle reading/writing. It

Walt Disney Animation Studios 397 May 17, 2022
SVG animation from multiple SVGs or single GIF using tracer

svgasm svgasm is a proof-of-concept SVG assembler to generate a self-contained animated SVG file from multiple still SVG files with CSS keyframes anim

Tom Kwok 153 Apr 28, 2022
A simple animation challenge made with Flutter

Slide Show - Flutter Getting Started This project is a starting point for a Flutter application. A few resources to get you started if this is your fi

Pedro Massango 24 Dec 2, 2021
animation2gltf2 is a command line tool for generating animation glTF 2.0 content.

Generate animation glTF 2.0 content animation2gltf2 is a command line tool for generating animation glTF 2.0 content. A rotation and translation can b

UX3D GmbH 7 Jan 9, 2022
Cross-platform, graphics API agnostic, "Bring Your Own Engine/Framework" style rendering library.

bgfx - Cross-platform rendering library GitHub Discussions Discord Chat What is it? Cross-platform, graphics API agnostic, "Bring Your Own Engine/Fram

Бранимир Караџић 11.5k May 10, 2022
Source Code for "Ray Tracing Gems: High-Quality and Real-Time Rendering with DXR and Other APIs" by Eric Haines and Tomas Akenine-Möller

Apress Source Code This repository accompanies Ray Tracing Gems: High-Quality and Real-Time Rendering with DXR and Other APIs by Eric Haines and Tomas

Apress 781 May 13, 2022
A C++/DirectX 11 implementation of "A Scalable and Production Ready Sky and Atmosphere Rendering Technique"

Atmosphere Renderer A C++/DirectX 11 implementation of "A Scalable and Production Ready Sky and Atmosphere Rendering Technique" Features interactive e

Z Guan 26 May 7, 2022
A modern cross-platform low-level graphics library and rendering framework

Diligent Engine A Modern Cross-Platform Low-Level 3D Graphics Library Diligent Engine is a lightweight cross-platform graphics API abstraction library

Diligent Graphics 2.3k May 9, 2022
This repository accompanies Ray Tracing Gems II: Next Generation Rendering with DXR, Vulkan, and OptiX

Apress Source Code This repository accompanies Ray Tracing Gems II: Next Generation Rendering with DXR, Vulkan, and OptiX by Adam Marrs, Peter Shirley

Apress 625 May 10, 2022