We're excited to announce that as of our latest stable release, Construct now supports an official 3D model object! You can now import 3D models to your project and display them in your projects.
An animated 3D model in ConstructHow to use it
To use a 3D model in your project, you first need to import it. You can do this in the new 3D models section of the Project Bar.
Importing a 3D model in ConstructConstruct supports models in GLTF (.gltf/.glb) format. (We might add support for other formats in future, but for now we like GLTF as a web-friendly open format.) You can choose to import models in a self-contained file, or choose a folder for models which use a variety of files, such as external texture images.
Once imported, add a new object, and choose the new 3D model object. Place it in your layout, and you'll see your model appear! Adjust the model offset, rotation and scale to suit your project, and you're good to go. You can use animated models too!
Implementing 3D model support
When developing the feature, an obvious place to start was just to import a .glb file as a general project file, and have the 3D model object load that. Indeed we had an early prototype doing just that. However loading a model externally like that has several shortcomings. In short, it doesn't integrate with the rest of Construct. We wanted 3D models to tie in to existing features and workflows in Construct, including:
- Including model textures in Construct's existing spritesheeting engine
- Allowing export optimizations such as adjusting the image format and compression level
- Viewing and editing model textures in Construct's image/animations editor
- Including 3D models in Construct's memory management systems, such as preloading content before a layout starts
- Supporting model formats that reference external files as well as single-file models
- Optimizing models specifically for the way Construct works
It is very difficult to support all these things if you have an approach of just loading directly from a file. So even though it was a lot more work, we went back to the drawing board and designed 3D model support to be deeply integrated and work with the rest of the engine in pretty much the same way Sprite objects are. The import process also ensures Construct knows the full details of a model such as the textures it uses, it can apply potentially heavy-duty processing or optimization work at import time, and allows supporting a wider range of model types as well.
Construct started as a 2D engine, and adding support for 3D models has been an interesting project too. Construct previously assumed all geometry is dynamic and submitted it every frame. It's a reasonable approach for 2D content, but becomes extremely inefficient for large meshes. So we upgraded the engine to support GPU-resident geometry that can be re-used across frames. Interestingly, this work allowed us to also optimize Construct's existing mesh distortion feature. A complex 2D mesh is actually a very similar case to a complex 3D mesh, and the same work allowed us to do some big optimizations for the mesh distortion feature too! It's a good sign we're on the right track when other features can also significantly benefit from other engine work. Then to allow advanced users and addon developers to use the same approach, we added APIs to access this capability from code - see the new Draw mesh data example for a demo.
A change in policy
For many years we've resisted going too far in to 3D features. We wanted to get the fundamentals right, making sure we have everything from subfolder organization to timeline animations, while maintaining excellent performance with great editor usability. We didn't think it would be right to neglect those things in a rush to do 3D features. We think this was the right approach to build a quality product.
Despite that, we have over time been incrementally adding some smaller 3D features, ended up going quite a long way. Construct already supported moving 2D objects on the Z axis (also known as Z elevation), 3D shapes, 3D camera, 3D audio, orthographic/perspective projections, adjustable vanishing point and field of view, and more.
Adding 3D model support was the next logical step. We feel Construct is a robust and mature product with comprehensive features like outstanding performance, LTS releases, HTML integration, an advanced WebGPU renderer, TypeScript support, and much more - meaning we won't be neglecting fundamentals if we start to do more 3D features. So this is a change in policy: after many years of declining requests for more 3D features, we are now open to doing more 3D work! Expect to see more 3D features coming over time.
What engine renders 3D?
Construct renders 3D content with its own bespoke engine. This might be surprising - why not take an off-the-shelf 3D engine like three.js and use that? This is actually a complex question with a great deal of tradeoffs - we could probably write a long blog post exploring just this question alone. However it really comes down to three key points.
First of all, we have actually already taken several steps down the road of implementing a 3D engine. The 3D features we already support mean Construct already uses things like a depth buffer and frustum culling - typical features of a 3D renderer. This meant it wasn't actually too big a leap to then add support for 3D models.
Secondly, lots of products end up separating 2D and 3D in to separate editors and feature sets. Our vision is for a tool which allows smoothly integrating 2D and 3D. Why can't you drop a 3D model in to a 2D game, or put a Sprite object in a 3D world? We think it is a better design, more flexible, more creative, and just more fun, if everything works together. Using an entirely separate renderer to power 3D content throws huge obstacles in the way of properly integrating 2D and 3D content, and makes it easy to end up with entirely separate editors with distinct sets of features. We described previously how some of our 3D engine work helped improve the existing mesh distortion feature, which illustrates the benefits of an integrated engine. Another example of that is to take a look at how 3D models preview in the Construct editor. Even though the Layout View is (for now) a 2D view, it actually displays 3D content - so as you scroll and zoom around, 3D models display properly in 3D! And we wouldn't want it any other way.
Thirdly, using a third-party library for a major feature like 3D can be a benefit in the short term, allowing quicker development of 3D features at first. However in the long term it can impose limitations. The third-party developers have their own goals and priorities, and those don't always line up with what Construct needs. To illustrate this, we submitted a pull request for three.js (#29260) a while back in order to better support minification, but the developers rejected it. This is not meant as criticism - they had their reasons and explained them. However it illustrates how their diverging priorities can limit the kinds of features and improvements we want for Construct. Another good example of this is Construct's UI library: in Construct 2 we used a third-party library, and often users would make feature requests, or we'd want to make improvements ourselves, that simply couldn't be done with the library. In Construct 3 we developed our own UI library, and it's a better product for it: we have complete control and can adjust everything to our precise needs. In fact, there's an example of us doing exactly that later in this post!
We have, however, used the model loading code from three.js. Reading 3D model files is quite complex and three.js already has code for that, so we've re-used that rather than write out own implementation. However once it comes to rendering the model, that all happens in our own engine. So really our approach is a kind of hybrid: we develop our own 3D renderer, but we use bits of existing libraries where it makes sense.
So in summary, while using an existing 3D engine might seem from the outside to be an obvious thing to do, we see it more as a complex choice with difficult tradeoffs. We've decided to go with developing our own 3D renderer as we think it will produce a better product in the end with better integration with the rest of Construct's features, but we're still using parts of existing libraries in some places. We think this is the right combination of creating an innovative and creative product with a good internal architecture, and saving time with existing libraries.
More to come
In our latest beta release we've continued to make further improvements for the 3D model object. These include usability improvements, a default transform to easily update multiple instances, and a new ability to choose in the editor the initial meshes to display. The mesh selection uses a new specially designed user interface element, showing how developing our own UI library allows the flexibility to adapt it to our needs over time.
Selecting the initial meshes in a 3D model in the latest releaseWe have lots more 3D improvements planned! If you want to follow along with the latest developments, try out the latest beta releases on the releases page, and we'll be posting more news and occasional teasers on our social media accounts, so follow us on Bluesky, Mastodon, X and Facebook.
Are you giving up on 2D?
We're definitely not giving up on 2D! Developing 2D games and content remains a core purpose of Construct, and we'll keep developing features intended for 2D as well. Our latest releases include new features for 2D and pixel art style games like dynamic sampling, integer scale inner/outer fullscreen modes, and a new pixel snapping editor option, and as ever there will be more on the way.
Conclusion
These are exciting times as we are changing our policy: we're now going to develop 3D features! We've been working hard to develop 3D model support with the quality and performance you expect from Construct, ensuring it is well-integrated with the rest of the tool. You can try out 3D models in Construct today in the latest release, and we'll have more coming in future, so stay tuned for more updates! As ever you can try out Construct right now in your browser, so simply head over to editor.construct.net to load up Construct, and give it a go.