Importing Game Assets in Blender

Let’s start Chapter 5 with the process involving how to import game assets in Blender. Of course, before we import a game asset, we need first to take a look at file formats that our program supports.

For Blender, we have 10 file formats that are supported: Collada (.dae), Alembic (.abc), Motion Capture (.bvh), Scalable Vector Graphics (.svg), Stanford (.ply), Stl (.stl), FBX (.fbx), glTF 2.0 (.glb/.gltf), Wavefront (.obj), and X3D Extensible 3D (.x3d/.wrl).

Let’s have a little discussion about each of these file formats.

.DAE file format is a 3D interchange file format used for exchanging digital assets between multiple graphics programs. It is based on the Collada or Collaborative Design Activity XML Schema, which is now owned by Autodesk. Collada was originally developed by Sony and is now jointly supported by Sony and the Khronos Group.

.ABC file format is an interchangeable computer graphics, open source file format developed by Sony Pictures Imageworks and Industrial Light & Magic. It supports the common geometric representations used in the industry, including polygon meshes, subdivision surfaces, parametric curves, NURBS patches, and particles. Alembic also has support for transforming hierarchies and cameras.

.BVH file format is an ASCII file format developed by Biovision as a standard format to save biped character motion data that contains motion capture data for three-dimensional characters. It is used by 3D animation programs to import rotational joint data. BVH files also store animation data for characters in Second Life and other various 3D video games.

.SVG file format is a graphics file that uses a two-dimensional vector graphic format created by the World Wide Web Consortium (W3C). It describes images using a text format that is based on XML. SVG files are developed as a standard format for displaying vector graphics on the web.

.PLY file format is a three-dimensional image file created using the polygon file format, which is an open standard that describes objects as a collection of polygons. It contains a header followed by a list of vertices that specify the shape of each polygon. Since the PLY file format was developed at Stanford University, it is also known as the Stanford Triangle Format.

.FBX file format is a 2D or 3D drawing saved in the Autodesk FBX format. It maintains the full fidelity and functionality of the original file and can be manipulated by multiple programs. It is used for creating interoperability between 3D applications.

.GLTF 2.0 (Graphics Library Transmission Format) is a file format developed by the Khronos Group for 3D scenes and 3D models using the JSON standard. It stores a full scene description in JSON format, which includes node hierarchies, cameras, and materials. GLTF files also contain descriptor information about animation and meshes.

GLTF files can be used to save and share digital assets between different 3D modeling tools, like .DAE files. However, they are also optimized for download speed and load time at runtime, which makes it easier to use in mobile and web-based 3D modeling programs. It is also a more streamlined format for uploading and downloading from online digital asset databases.

.GLB is a binary form of gltf that includes textures instead of referencing them as external images.

.OBJ file format is a standard 3D image format that can be exported and opened by various 3D image editing programs. It contains a three-dimensional object that includes 3D coordinates, texture maps, polygonal faces, and other object information. This format is considered to be a universal 3D model format since it is widely supported by 3D image editing applications. The format is simple and text-based, which is one reason why many programs use it. Since the OBJ format is widely supported, many users export their models as OBJ files when transferring them from one 3D program to another or when sharing a 3D model with a coworker.

.X3D file format is an ISO-ratified file format and runtime architecture to represent and communicate 3D scenes and objects. This file format was developed by the Web3D Consortium and has evolved from its beginning as the Virtual Reality Modeling Language (VRML) to the considerably more mature, refined ISO X3D standard. It provides a system for the storage, retrieval, and playback of real-time 3D scenes in multiple applications.

.WRL file format is a virtual world created in VRML and can be navigated in three dimensions. WRL files are saved in an ASCII text format, which can be edited with a text editor.

Now, we have at least a basic idea about our file formats. So let’s take a look at how to import our game assets using some of these file formats.

Importing Using .DAE Format

Let’s take a look at Figures 5-1 to 5-6 to see the process of importing a .DAE file format.

Of course, the first part will be to go to File menu ➤ Import ➤ choose COLLADA .dae ➤, then browsing to the folder where your .Dae file is located.

Usually, this file is downloaded in a compressed format like Zip. You can uncompress it using programs like Winrar or Winzip.

You can see in Figure 5-1 that we have a Walking.dae file, and beside it is a textures folder. Let’s start importing our Walking.dae file.

Ta-da! This is how your object looks like after you import it. Hmmm. We are already in the render view but we can’t see any textures. Look, we even have a point light there. What’s the problem? Okay. Let’s take a look at our shaders editor.

Hmmm. It seems that Blender isn’t recognizing the nodes settings that the .DAE file format imported. This is why we have separate texture references for a .DAE file. In case the program didn’t recognize your material shading, you can re-create it with your own shading settings.

I replace the default node that our imported object is using by first creating another one, and then in the base color in properties from the material panel, I select the image texture and the texture provided with our .DAE file.

After fixing some things, as you can see in Figure 5-6, you are looking at our textures in a render view.

Let’s proceed to our next file format.

Importing Using .ABC Format

Now, let’s take a look at Figures 5-7 to 5-13 to see the process of importing an Alembic file.

Of course, the process will be the same as the first part. We will go to File menu ➤ Import ➤ Choose Alembic (.abc) ➤ Browse to the file location of our file to be imported, and then import.

What we can see in Figure 5-7 is the view of our game asset after being imported. Our texture for this one is separated so if we look at the render view, we can only see a diffuse color white as a material shade of the gun. Let’s add the texture of the gun.

Okay. If you are a beginner, you might wonder about the form of our gun. Why is that there that long line or cylinder, and how can we ever hide it? You can just play around in the outliner and hide parts of your game asset to know which one is the one on your screen.

You can see that the named muzzle_fire object in our outliner refers to that mesh encircled in our gun, and the bullet refers to the long line. If you don’t want to see these parts in your render or you feel that you don’t need those parts of your imported game asset, all you need to do is to go to your outliner and hide those unwanted parts of your game assets by filtering it out.

If you just want to disable it in the viewport, all you just need to do is to click the eye icon next to the object name; but if you want to remove it in the render view but you don’t want to delete that part completely, you need to go to Filter ➤ toggle renders, which will enable you to manipulate which object will be in the render.

In order to apply the textures, first I select all the mesh that can be seen in the viewport and go to UV editing. I go to UV editor and open the texture that I will use for the gun.

The next thing I do is to go to texture paint to add the texture by selecting the mode to single image and selecting the texture I want for the gun as the single image material.

Make sure that your base color in your material settings has the image or texture name in it. Sometimes, even you already have the texture in the texture paint or even a UV wrapping, the image doesn’t link to this part; that’s why the texture didn’t appear in the render view.

This is now how our game asset looks like in render view.

Let’s now proceed with our next file format.

Importing Using .OBJ Format

.OBJ file format comes with an .Mtl file format; it’s the file format that contains data about the materials of the object.

Let’s now take a look at Figures 5-14 to 5-17 to see the process of importing an .OBJ file.

The first part of the process is of course the same: File Menu ➤ Import ➤ Wavefront (.obj) ➤ browse your file ➤ then import.

Again, we will filter out what part of our game asset we want to be seen and rendered.

You might wonder how to import the .Mtl file that comes with the .Obj file. When you import the .Obj file, Blender will also import the associated .Mtl file by default as well as long as they have the same file name.

We already know that the .Mtl files are already applied. Then why we can’t see any textures in our mesh, but instead, we see it in pink? It’s because just like what we did in the Alembic file, we need to select the meshes and unwrap them to the UV editor with the texture that we want to use in it.

We also need to re-browse the file in the material settings since the textures or the reference images now have a new path.

Here is the rendered view of our game asset imported from the .Obj file.

The process of importing an FBX file is the same with .DAE and .ABC. You just need to go to File menu ➤ import ➤ browse the .FBX file and import. That’s it. If there is a need to do something with textures, just look at the material settings like what we did in the .DAE and .ABC files, but if you have an .FBX file with textures in it, it will be easier. You just need to import it and everything is already done.

It’s the same thing with a .PLY file. You just need to go File Menu ➤ Import ➤ Stanford (.Ply) ➤ Browse .Ply file ➤ import your file and then that’s it. It’s the same for both .STL and .WRL files but with the same set of concerns. If your mesh is something like our gun with some added meshes that aren’t necessary, you might need to edit something before you can use it.

Even for .glTF files, you just need to go to File Menu ➤ Import ➤ glTF 2.0 (.gltf/.glb) ➤ browse a glTF file ➤ import your file and that’s it. When you render, you can even see your materials in it even the textures are created in a separated folder.

For .SVG files, it is the same process. The only difference will be is that when you import .SVG files, they will end up as curve objects since they were originally 2D images.

For .BVH files, it is also the same simple process of importing as .FBX, after all. What we have in this file format is only the animation data of your project as you can see in Figures 5-18 and 5-19.

The one I boxed with the red rectangle is the .BVH data created inside the .Blend file or in Blender. The one you can see in the 3D viewport is the output using this data.

In Figure 5-19, this is how it looks like after you import a .BVH file. This is the same as the one in Figure 5-18.

Now, we’re done discussing the process of importing our game assets in Blender. Let’s now talk about exporting our game assets from Blender.

Exporting Game Assets in Blender

For exporting game assets, we also have 10 available file formats, which are COLLADA (.dae), Alembic (.abc), Universal Scene Description (.usd, .usdc, .usda), Motion Capture (.bvh), Stanford (.ply), Stl (.stl), FBX (.fbx), glTF 2.0 (.glb/.gltf), Wavefront (.obj), and X3D Extensible 3D (.x3d)

We already know .dae, .abc, .bvh, .ply, .stl, .fbx, .glb/.gltf, .obj, and .x3d file formats. What’s left here are the .usd, .usdc, and .usda, which are Universal Scene Descriptions. Let’s have a little discussion about this file format.

.USD is a file format that can be both ASCII and binary-encoded. It was developed by Pixar in a Universal Scene Description, which is a framework for interchange in 3D computer graphics data. This characteristic of .USD files are advantageous in certain scenarios like if one has a USD file that contains references to plain .usd assets, those assets can be converted between binary and ASCII without changing the sources that refer to them.

Now, let’s talk about the process of exporting files. The process of exporting in all file formats in Blender are the same. You just need to go to File Menu ➤ Export ➤ file format you wanted ➤ to export the game assets. The only difference lies after you export the file and for some file formats, there are some settings available in case you want only to export some parts of your project.

For Collada (.Dae) files, you only have the simple exportation process. There are no other settings available. Its difference is that the textures are separated to the .dae file that contains the information about the geometry, etc., of the object.

For Alembic (.abc) files, it also only has the simple exportation process and no other settings available; in addition, it only has the .abc file and no other separated file for its textures.

For Wavefront (.obj) files, we have the file that handles the information for our object, which is the .obj file and a file that handles the information for our materials, which is the .mtl file. It also has other export settings available.

For .Universal Scene Description (.usd, .usda, .usdc) files, it has other export settings but it doesn’t have a separated file for its textures. This is the same for .PLY, .FBX, .GLB, .STL, and .X3D. Now, let’s take a look at Figure 5-20 to see the other settings that we have for exporting our game assets in a .usd file.

You can see in Figure 5-20 that we have options to include the animation, hair, UV maps, normals, and materials. We also have an option to just export those currently selected objects in the scene or project, and we can do this by toggling the selection only. You can also choose which settings it will be based on, in the settings of your project in the render mode or in the viewport mode. By default, exporting UV maps, normals, and materials are enabled.

Now, let’s look at Figure 5-21 to see the other settings that we have for exporting our game assets in a .PLY file format.

As you can see in Figure 5-21, we have options for including modifiers’ settings, normals, UVs, and vertex colors in exportation. We also have an option if we want only those that are currently selected in the project to be the ones that will be exported; and we can do this by toggling the selection only under the include panel. In transform, this part will help you set your game assets’ positions differently from what it is in the project. The forward and up refers to the axis while the scale refers to the size of the game assets after you export them.

Let’s now have the .STL file format. Take a look at Figure 5-22 to see the other options for this file format when exporting our game assets.

For .STL format, we have an option to include modifiers’ settings. We also have the option to transform our game assets’ positioning after the exportation just like what we have in .PLY file format; and an option if we want to export only the current selected objects in our project by toggling the selection only.

Let’s see what additional options for exporting game assets that we have for the .FBX file format in Figure 5-23.

For .fbx file format, we have more specific options for exporting our game assets. For object types, we can choose if we want to export empties, cameras, lamps or light objects, armatures or the bones that we use for animation or rigging, mesh, and other object types like curves. We still have the option if we want only to export those that are currently selected in the project, and we can do this by toggling the selected objects. We also have another option if we only want to export those that are part of the active collection and we can do this by toggling active collection. We have here the transform panel, which gives us option if we want to change the position in the axis or scale the game assets after exportation. There are other options there that are for geometry of the mesh (under the geometry panel), armature and animation.

Under the geometry panel, you can decide about the smoothing information: if it will be only normals, faces, or edges. You also have the option here to export the subdivision surface, loose edges, and tangent space.

Under the armature panel, you can set the axis for the primary and the secondary bones. There is also this option called Only Deform Bones, which enable you to export only the deformed Bones and the Non-deformed bones that have a deformed children(bones).

Now, let’s take a look at the settings of exportation that we have for .GLB file format in Figure 5-24.

Hmmm. As for .glb format, you can see in Figure 5-24 that we have remember export settings. As what it says, if you toggle this up, whatever settings you have, they will be saved and that will be the one Blender uses as export settings the next time you export a game asset unless you change it again. And another thing, we have here copyright where you can place a copyright setting.

There are still options for which objects you wanted to be exported, and that was under the include panel. Also, the option for the positioning of your game assets after exportation was under the transform panel. You also have options if you want to include modifiers’ settings, UVs, normals, tangents, vertex colors, and materials, and these are all under the geometry panel. What you can see under the animation panel are options if you want to export information related to shape keys, skinning, and, of course, animation.

Now, let’s take a look at Figure 5-25 to see the available export settings for the .X3D file format.

As for .X3D file format, still, we have an option to include modifiers’ settings, triangulate, normals, and compress. We also have the option to change the position and size of our game assets after exportation through the settings under the transform panel. We still have this selection only, which gives us the option to only export those objects that are currently selected in the project. We also have this hierarchy that when enabled exports parent–child relationships of the objects while name decoration adds prefixes to the names of exported nodes to indicate their type.

Let’s take a look at the export settings of the .OBJ file format shown in Figure 5-26.

For .OBJ file format, we have selection only , which gives us the options to export only the currently selected objects in the project; objects as OBJ objects, which gives us the option to exports objects in objects under OBJ file format; objects as OBJ groups that give us the option to export objects in groups under OBJ file format; material groups that give us the option to export our game assets’ materials in the group; and animation, which gives us the option to write out an .OBJ for each frame.

We also have options here for adjusting the size and position of our game assets in the axis after exporting under the transform panel. And we also have options here if we want to include modifiers’ settings, normals, UVs, materials, triangulate faces, curves, etc., and this is under the geometry panel.

Now that we’re already discussed how our game assets can be exported in different file formats, let’s start discussing how we can import our game assets in a game engine that is compatible with Blender.

Open Source Game Engine

The earlier version of Blender, until the 2.7x version, has its own game engine; but when 2.80 came, Mr. Ton Roosendaal decided to discontinue it. He stated that the future of the Blender game engine will integrate the system into Blender as an interaction mode for game prototypes, architectural walkthroughs, and scientific simulation. Now, Blender is working to be a good support for external open source game engines.

Now, let’s start our brief discussion about one of the open source game engines that we can use together with Blender, the Godot Engine.

Godot Engine (godotengine.org)

Godot is a 2D and 3D game engine released under an MIT license. It’s both a free and open source game engine. Its development was started by Juan ‘reduz’ Linietsky and Ariel ‘punto’ Manzur in 2007. Godot aims to offer a fully integrated game development environment. It allows developers to create a game from scratch, needing no tools beyond those used for content creation like art assets, music, etc.

Godot engine is a feature-packed, cross-platform game engine to create 2D and 3D games from a unified interface. It provides a comprehensive set of common tools, so users can focus on making games without having to reinvent the wheel. Games can be exported in one click to a number of platforms, including the major desktop platforms (Linux, masOS, and Windows) as well as mobile (Android, iOS) and web-based (HTML5) platforms.

Godot is a free and open source software under the OSI-approved MIT licensed. In short, you are free to download and use it for any purpose, personal, nonprofit, commercial, or otherwise. You are also free to modify, distribute, redistribute, and remix Godot for any reason, both noncommercially and commercially.

The official supported languages for Godot are GDScript, Visual Scripting, C#, and C++. If you are just starting out with either Godot or game development in general, GDscript is the recommended language to learn and use since it is native to Godot. While scripting languages tend to be less performant than lower-level languages in the long run, for prototyping, developing Minimum Viable Products (MVPs) and focusing on Time-To-Market (TTM) , GDScript will provide a fast, friendly, and capable way of developing your games.

Godot also includes a script editor with a real-time parser, syntax highlighting, and code completion. It also features a built-in debugger that helps you explore and modify your project while it’s running, a built-in profiler with graph plotting and time seeking, and an error logger with full stack traces.

Godot also has support for physical-based rendering with full MSAA support, full-principled BSDF with subsurface scattering, reflection, refraction, anisotropy, clear coat, transmittance, etc. It also uses global illumination for real-time gorgeous graphics, easy-to-use shader language based on GLSL with a built-in editor and code completion, and mid- and post-processing effects including a new tonemapper that supports HDR, multiple standard curves and auto-exposure, screen space reflections, fog, bloom, and depth of field.

Okay. We already have basic knowledge about Godot’s features and capabilities. Let’s now see its process for importing our game assets. Take a look at Figure 5-27 to 5-32 to see the process of importing game assets to the Godot game engine.

I export our game assets in Blender in a .gITF file format. The only file formats you can import in Godot engine are .OBJ, glTF 2.0, .DAE, ESCN, and .FBX, but there are problems with .FBX since it is a proprietary file format and .OBJ is pretty limited because there is no support for pivots, skeletons, etc. And for .DAE, the supported ones are more of the older versions. The most recommended file format would be the glTF 2.0. So, for our project, I will also use the glTF 2.0 format.

Now, we’re going to import it in Godot, but first, we need to create a project in the said game engine. What you can see in Figure 5-27 is the first window you can see when you open Godot. When creating a new project, you just need to click New project, but if you already have an existing Godot project, either you will choose it in the list or you will choose the Import button if the project is not in the list that appears in the window.

Next, we will be asked for the project name. Godot isn’t sensitive for a project name, but for project path, it requires an empty folder so you will need to create a new folder that is specific to a Godot project.

You can see in Figure 5-29 the interface of the Godot game engine. It looks simple, right? But it is actually kind of tricky. When you created a new folder for your project earlier, Godot created files with it just like what you can see in Figure 5-30.

You can notice that the default_env.tres and icon.png can also be seen in Godot’s file system panel. Now, for us to be able to import our object, all we need to do is to copy and paste our object or our glTF 2.0 file in this folder.

This will be the next thing that happens after you import your game assets. You will see in the FileSystem panel the .glb file, together with the material files of your object. If you look at your folder, you can also see a file equivalent to those that you can see in this FileSystem panel. In other words, whatever you do in this panel will affect your project folder, and whatever you do in your project folder will also have an effect on this panel.

In order to use our imported game assets, we need to use so-called instances. To do this, you first need to create a root node in the scene panel. Godot gives four options there: 2D scene, 3D scene, user interface, and custom node. Since we’re doing 3D, we will choose 3D scene. After clicking 3D scene, you will see “Spatial” created. Next, you will click the plus icon to choose instances or nodes for our object to work on. Since we want to create a mesh one, we will click MultiMeshInstance. After adding the instance, you can just drag your game asset to the viewport and voilà! Your game asset will already appear in the scene.

These are the processes on how we import our game assets from Blender to a Godot game engine.

There are other open source game engines out there that can be used together with Blender. Here are some of those to help you find other options.