3D Visualization Made Easy

Photorealistic rendering as optimized standalone application. Easy to understand and setup. Supports both real-time and film quality progressive ray tracing engines.

Download Beta 3
More information

Import

Import 3d models in various formats like obj, stl, ply, fbx, STEP, Collada, Alembic, Sketchup, Cinema4D and more. Original data like polygons, animations, skeletons, morphs, node hierarchy will be preserved.

View details »

Organize

Store the imported models in a database which supports thumbnails and keyword search. Custom meta-data can be assigned to each scene, which is accessible in standard Adobe XMP format.

View details »

Visualize

Visualize the scene with real-time and photo-realistic physically based rendering engines. Create and assign lights, materials and textures using non-destructive work-flow supporting multiple scene variants.

View details »

Export

Export the scene for the Web using the popular and open GLTF format, managed by Khronos. Or render the result to still image or movie animation.

View details »

Import from 3d formats

There are a lot of 3d formats out there. Some are application specific, some are interchange formats, some are open, some are closed. LibThree will try to convert them to a general open format that can handle the features found in all these various 3d formats. Additionally, missing data like normals and tangents (used in the visualization process) can be generated on the fly. Note that it's still possible to import formats and modify them without the need to actually save the converted version of the file!

See the complete list of supported formats here

The LibThree scene format

A great issue with most 3d formats is that they are created to fit specific needs, and are not general enough to handle the set of features required for all possible applications. Every application uses at least temporary storage for the data it can work with directly. Since LibThree was developed to help you manage your 3d model files, hiding and ignoring the importance of the way your data is stored was recognized as bad approach. This is why a lot of effort was put into developing open, extensible, compact and fast format. It's idea is not trying to become another "standard", but to document better how your data is stored and how you can access and understand it even outside LibThree. This format has both binary and human-readable text representation. The binary format is optimized to support features like embedding external data (like textures, ies lights), advanced compression and multi-threaded optimizations. The text format is based on the JSON data interchange format which is very simple and easy to work with.

Browse and search your scenes

Every imported/opened scene enters a database that manages thumbnails and fast keyword searches. This is similar to how image organizers work to help you navigate your library.

LibThree is using the Abobe XMP format to store meta-data associated with each scene in standard and understandable for other applications format. This includes additional information like scene author, contact info, copyright, original source, category, location, keywords, but also work-flow information to manage job status, priority, assignee and session changes.

Non-destructive real-time editing

Tweaking the scene materials, lighting, textures is essential to achieve your vision. This can be quite challenging process, taking into account all the parameters you have at your disposal and the complex way they interact with each other. To make this process easier and more pleasant, the application should have two important features - real time interactive changes (so you can immediately see the effects of your actions), and the ability to undo these actions if you don't like them. LibThree goes one step further by not applying your changes directly to the scene, so you can't possibly "break" it and lose information. You can always undo everything you did, even after reopening the scene! In the same way you can always redo your changes, even if you reimport the scene again into LibThree. This is quite helfull if you are working on your scene in another applicaiton. You can go even further by creating different variants of the same scene and switch between them!

Photorealistic ray tracing

Ray tracing is the most powerful known method to simulate the physical properties of the light and its interaction with material surfaces. This is why ray tracing is the method to go, when photorealism is required in any visualization task (like movies or architecture). Not only that, but using physical simulation has also another great benefit - it makes visualization always consistent and easy to setup. In the past, CG lighting worked by tweaking and "faking" huge amounts of lights for every shot, by highly trained artists and professionals. When the visualization follows the physical laws, it makes the lighting and material setup much easier, since they interact with each other properly "out of the box". It's impossible create something that is generally wrong and invalid. This makes it accessible even for people without deep understanding in computer graphics. LibThree is powered by the Intel® Rendering Framework: Embree.

Denoising

The only drawback of ray tracing is that it's computationally intensive. In fact, there are infinite amount of light paths that can be traced. We can't do this in practice, so we try to trace limited amount of rays, that contribute most to the image. The result however is "noise". The produced image is not smooth enough, because we are missing information. If we continue to generate less important paths, this will not resolve the problem fast enough, which is why we must fight the noise using special method called denoising. LibThree includes state of the art real-time NVIDIA® OptiX™ AI-Accelerated denoiser that runs on the GPU, and more basic CPU denoiser for people that don't have supported video card.

Real-time rendering

Even if ray tracing runs quite well on modern hardware, especially when combined with denoiser, real-time performance for animation and VR is a challenge. For high-performance graphics, hardware accelerated rasterization is still quite useful and can provide quicker visualization for non-demanding visualization tasks. LibThree is using exactly the same material and lighting description for both render engines, so you don't need extra setup to use either of them. While the real-time engine is currently more limited as feature set, it will no doubt evolve with time, especially if combined with ray-tracing techniques (like DirectX Raytracing).

Lighting, Material and Texture libraries

LibThree includes a big library of visualization building blocks to get you started. All textures are CC0 licensed, so you can freely include them in your projects, without any obligations. The material library can help you understand how to create different types of surfaces and volumetric effects. Creating your own library is also possible, so you can optimize your workflow. The library allows asigning keywords to each material/texture for faster searching. The actual lighting of the scene has alywas been the most challenging part of the visualization process, which is why there are many standard setups which artists have found to work well in most cases. You can instantly create one of the 13 built-in light setups to get you started.

Compositing and post-processing

Just rendering the image, like just taking the shot, doesn't complete the job. There is much more that can be done to improve the quality and tweak it to better match your vision. LibThree can render different elements of the image in different images that can be tweaked and then combined together again. This can be done either in external application (like Photoshop, Gimp, After Effects) or even with the built-it real-time compositing and post-processing tools. This tools will give you immediate feedback, even while still rendering the image.

Export for the Web

At the end of the process, you will want to either produce an image/video sequence or export actual 3d content for the Web. This is becoming more and more and more accessible today because of great initiatives like GLTF which is an open and widely supported format for the web, managed by Khronos. Note that this format is still actively developed and support for it is slowly maturing. Not all features are supported yet.