Example - Cyberpunk Car
This document shows how to make a great asset from start to finish. It's more of a general guide than a step-by-step how-to.
Last updated
This document shows how to make a great asset from start to finish. It's more of a general guide than a step-by-step how-to.
Last updated
In web3, it's better to have assets that are easy to use. Wheels make development more complex, so we chose a hover car. This way, it works as a vehicle without needing extra functionality.
The best-known hover car is the Delorean from Back to the Future, but we can't use it due to copyright. Instead, we can draw inspiration from Cyberpunk or The Fifth Element. By gathering references following this idea, we can gather the following things :
Cyberpunk (Game, art, everything)
The Delorean (Future version)
The Fifth Element (Had some great flying/hovering vehicles)
Styles (Borderlands, Cyberpunk, Valorant, Arcane, etc)
Cars (Lamborghini, McLaren, Ferrari, Audi, concept, etc)
To make my asset work on all platforms, including WebGL, Mobile, and Standalone VR/XR, we need to keep the polycount and texture size low. This helps reduce the file size. There are various ways to achieve this, and we can explore them if we start with a high-polygon asset. This asset can either be baked down to a low-polygon version or used as a reference for palette texturing.
A story or background can bring your creation to life, influencing both the asset and its promotional material. We don't just want a car; we want a car that represents its driver, showcasing speed, wealth, or history. Alternatively, it could just look cool. We'll let the references guide me.
You can create your story in two ways: preplanned or developed during the process. Both have pros and cons, so it's good to start with a basic idea and let it evolve. For this project, we want a cyberpunk futuristic car that looks beat up. The idea of a future car that feels old is interesting.
Using PureRef, begin compiling all the resources we mentioned that grab our attention. Using google search, but you could also try some AI tools such as Midjourney, Stable Diffusion or even Co-pilot and Firefly.
Keep in mind optimization approaches to save texture resources and time, such as mirroring the asset or using duplicate elements like thrusters.
The final step is to get a basic orthographic view of the desired car model, such as a 1966 Ford Shelby Mustang. One could draw their own reference with all planned details or even a rough sketch to start. In this case, there is enough reference material and a clear idea of the goal, along with sufficient experience to execute it.
The first step is to create a high-polygon asset to optimize. Here is an example of the end result. This can be done through various methods, such as digital sculpting, AI asset creation, or, in this case, Hard Surface Modeling.
As you can see, the polycount is significant, which is not ideal for optimized experiences like WebGL, Standalone VR/XR, or mobile. We will need to optimize the asset later, but for now, that isn't a concern.
As the asset is primarily a hard surface, Sub-D modeling techniques will be used. There are many resources available on asset creation; search "Hard Surface Modelling " on YouTube or online for the latest information.
There are various approaches to making assets:
Primary to Tertiary Approach: Start with basic shapes to get an overall feel, then add details. This method is efficient but may lack immediate feedback, which can affect motivation. Trusting the process can help, but it can be challenging, especially for beginners.
Detail-Oriented Approach: Add details from the beginning. This can be motivating but often leads to changes later, wasting time as you find better ways to approach elements or prefer different results. However, this process can be educational and may balance out the time spent.\
The Primary to Tertiary approach is faster and more efficient but harder to maintain motivation. The Detail-Oriented approach is slower and may waste time but can be more motivating.
Each method has its pros and cons, and the choice depends on personal preference and experience.
With experience, you start to identify potential issues and find better or faster ways to achieve the same results. Each asset you create enhances your workflow. Here are some key points to keep in mind:
Optimization Balance: Optimization is as important as the final result, especially for mobile or standalone VR/XR. Balance the details accordingly.
Design Considerations: Keep potential optimizations in mind throughout the process, such as using duplicate or mirrored assets to save time and resources.
UV Space Utilization: Consider overlapping UVs to maximize UV space on the texture. Techniques to improve the result will vary.
GLB Specifics: If creating a GLB, additional steps may be needed for compatibility with engines like Unity. This will be covered later.
Low Poly Target: Always consider if high-poly details will transfer well to a low-poly version. Opt for designs that are equally good but more optimized.
Baking Challenges: Understand what details are difficult to bake into a normal texture. Texture resolution is crucial, and some details may need redesigning or creation workarounds.
Normal Map Details: Some elements are better added directly into the normal map during texturing. This varies case by case.
Window Tinting: Tinted windows can avoid the need for interior details, optimizing the asset. For transparent windows, use either one material with translucency or two materials (one opaque and one transparent). GLBs may have issues with transparency and opaque areas on the same material, so consider splitting transparent elements into their own material.
By keeping these points in mind, you can create optimized assets efficiently while maintaining quality.
Most of this asset was created using a few key tools in Blender. Besides the basic Position [G], Rotation [R], and Scale [S], the following tools were essential:
Delete [Del]:
Dissolve Edge: Used frequently to clean up unwanted edges.
Delete: Used for removing actual faces when needed.
Limited Dissolve: Useful for low-poly models, it cleans up unnecessary edges based on angle.
Extrude [E]:
Used for quickly creating basic shapes.
Switch between Extrude Region, Extrude Normals, and Extrude Individual as needed.
New Edge/Face from Vertices [F]:
Crucial for middle and detailed stages.
The 'Mesh: F2' add-on enhances functionality, allowing for quick addition of quads from three vertices or closing/joining loops.
These tools streamline the modeling process, making it efficient and effective.
With the primary shape created, loops are added and adjusted to fill out mid details. Clean loops make this process faster and easier, so edges are kept organized as long as possible. This is easier with high-poly assets since polycount isn't a concern, but it's more challenging with low-poly assets.
Here are some additional tools and techniques used:
Knife [K] / Bisect [Shift + 8]:
Knife: Great for adding edges where needed after defining basic shapes.
Bisect: Useful for cutting across an entire asset, though used less frequently.
Inset [I] / Bevel [Ctrl + B]:
Used less often but very useful when needed.
Loop Tools Add-on:
Found in Blender's default installation, it allows setting selected edges/vertices to a circle or other shapes.
Mark / Unmark Sharp:
Sometimes used to visualize edges better. Edge weights with the Subdivision modifier are often used instead to achieve desired bevels in the high-poly result.
Bridge Edge Loops / Bridge Faces:
Bridge Edge Loops: Connects several edges neatly.
Bridge Faces: Creates a tunnel between two internal faces.
These tools and techniques help streamline the modeling process, making it efficient and effective.
Modifiers are tools you can apply to your model to achieve various useful effects. In this case, three modifiers were used:
Mirror: Duplicates and mirrors the geometry across a specified axis, saving time and ensuring symmetry.
Bevel: Adds beveled edges to the model, creating smooth transitions and rounded corners.
Subdivision: Increases the mesh's resolution by subdividing faces, resulting in a smoother and more detailed model.
The Mirror modifier is frequently used in asset creation, especially at the start, since most things are symmetrical. However, to create more interesting assets, making them asymmetrical by the end is a common approach. How long you keep the asset mirrored depends on the specific project. In this case, the asset
The Bevel Modifier, combined with the Subdivision Modifier, speeds up the hard surface modeling process. It adds extra bevels to the low-poly asset, resulting in clean high-poly assets and saving a lot of time.
Bevel Modifier:
Set the 'Limit Method' to 'Weight'.
This allows precise control over which edges have a sharp bevel.
Select an edge, choose 'Edge Bevel Weight', and adjust as needed.
This method ensures efficient and clean results in your high-poly models.
This is where the high polygons come into play, resulting in a super smooth finish. If your computer starts to lag due to the high subdivision polycount, reduce the subdivisions to speed up the process. Occasionally increase the subdivisions to check if the asset looks as expected
Depending on how sharp certain edges need to be, it is often necessary to add more edges in some areas to clean up or sharpen details. In the picture below, extra loops have been added to make the edges crisper. This approach can be applied to achieve various desired results.
If you decide to use the original mesh for your low-poly model instead of retopologizing from scratch, you will need to manually clean up all these extra edges. Otherwise, they will add unnecessary polygons to the result without any benefit.
With all these techniques and considerations in mind, the following asset was created:
Mirror Modifier: Used for symmetry, saving time and ensuring consistent design.
Bevel Modifier: Applied with 'Weight' limit method to add sharp bevels where needed.
Subdivision Modifier: Increased mesh resolution for a smooth, detailed finish.
Edge Loops and Knife Tool: Added extra loops and edges to sharpen details.
Optimization: Kept potential optimizations in mind, such as reducing subdivisions to manage performance and cleaning up unnecessary edges for low-poly models.
The result is a well-optimized, detailed asset ready for use across various platforms.
When 'Optimal Display' is turned off on the Subdivision modifier, the asset shows 769,352 triangles. This high polycount is not recommended for most ecosystems, except for high-end gaming desktops. Therefore, an optimization pass is necessary.
With the asset made and looking great, we can now focus on the optimization process. Here is an example of the end result, showing a considerably lower polycount compared to the high-polygon model displayed above.
Optimizing assets is crucial for performance on platforms like Mobile, standalone VR/XR, or WebGL. In this case, two approaches were used: Recycling Previous Assets and Retopology.
The main method used in this case was to optimize the original mesh after removing the Bevel and Subdivision modifiers. This involved manually going over the entire asset to remove all the edge loops added to sharpen bevel data. While this method is faster since the main model is already made, it may be less optimized compared to manual retopology. It's easy to miss polygons that could be removed or not achieve the same level of optimization.
The most common element of this optimization process is selecting the edges to remove and using Delete > Dissolve Edges. This command removes the edges from the mesh while keeping the faces intact when possible.
You can start tracing the asset manually, considering each and every polygon. This approach is slower but can result in significantly more optimized assets. It is the better approach if you are designing for low-end devices such as Mobile, standalone VR/XR, and WebGL.
Retopology is indeed a straightforward process, though it can be time-consuming. The results are usually worth the effort, and with more experience, the process becomes faster and more efficient.
Duplicate the High-Polygon Assets:
Create a duplicate of the high-poly assets to keep an original backup.
Move elements apart to improve organization and baking results.
Trace the High-Polygon Asset:
Use retopology techniques to trace the high-poly model.
Enable the Snap tool with the Face setting selected to ensure new geometry adheres to the surface of the high-poly model.
Using the standard Sub-D modelling tools such as extrude, knife, and add edge loop with the Snap tool on to rebuild a low poly asset over the top of the high polygon asset with as few polygons as possible.
When creating a low-poly asset, it's essential to focus on the silhouette and utilize normal maps (or advanced bump maps) to capture finer details.
To optimize the asset and facilitate baking, certain elements were separated and duplicated. This approach not only saves time but also enhances texture quality by increasing the size of the assets in the texture map.
Separate Key Elements:
Thruster: Separated to avoid interference during baking. Can be duplicated to all four wheel slots.
Rear Window Cover Slat: Separated for easier baking and can be resized to fit the window.
Underside Detail: Separated and can be duplicated multiple times underneath the car.
Duplication Strategy:
Thruster: Duplicate to all four wheel slots.
Window Cover Slat: Duplicate and resize to fit the window.
Underside Detail: Duplicate multiple times as needed.
Texture Considerations:
Avoid very clear details that make duplicates look identical.
Be cautious with unique dirt and damage features to prevent obvious repetition.
Final Polycount:
After creating and duplicating all the assets, the final polycount is 7,034 triangles.
This is a significant improvement from the original 769,352 triangles.
While there are quicker ways to optimize an asset, such as remeshing or decimation, these methods are generally not recommended for hard surface modeling or assets that require rigging.
Here’s why:
Remeshing:
Pros: Quick and easy to apply.
Cons: Poor at preserving hard surface details and clean edge loops. Results in a less optimized mesh that can be problematic for detailed models.
Decimation:
Pros: Reduces polycount quickly.
Cons: Often results in uneven and messy topology, which is unsuitable for hard surface models and rigged characters. It can create artifacts and make the mesh difficult to work with.
With the asset completed, the next step is to unwrap the UVs. This allows for the application of 2D textures onto the 3D asset. For this asset, the goal is to use a single material to minimize draw calls and improve overall performance.
Initial UV Unwrapping:
Perform a quick unwrap to get an initial layout of the UVs.
Use tools like Smart UV Project or Mark Seams and Unwrap in Blender to start.
Quick Bake for Testing:
Perform a quick bake using software like Substance Painter.
This helps to check how well the high-poly details transfer to the low-poly texture.
Identify and fix issues such as flipped normals or misaligned polygons.
Refine UV Layout:
Adjust the UV layout based on the results of the quick bake.
Ensure that the UVs are properly aligned and scaled to maximize texture space.
Consider Mirroring and Overlapping:
Mirroring: Mirror the UVs down the middle to make them significantly bigger, allowing for more detail. However, this can make textures look repetitive, especially with dirt or damage details.
Overlapping: Overlap UVs for symmetrical parts to save texture space but avoid obvious repetitive details.
Optimized UV Layout:
Flip and mirror parts of the asset, such as the underside, to optimize UV scale while maintaining some asymmetrical detail.
Ensure that the UV layout balances detail and texture space efficiently.
In the case of the UVs and polygons shown in the picture above, the orange UVs and red polygons have been duplicated and overlapped. This approach allows for higher quality textures at the cost of more repetitive elements.
Duplicating and Overlapping UVs:
Duplicated UVs: The orange UVs and red polygons are duplicated and overlapped to maximize texture detail.
Higher Quality: This method increases texture resolution for these areas but can lead to repetitive patterns.
Adjusting UV Layout for Key Elements:
Rearrange UVs: Adjust the UV layout to position key elements (like the top and sides of the car) in a way that makes it easier to edit car paint styles later.
Ease of Editing: This adjustment facilitates easier texture editing and potential variations in the future.
Maximizing UV Space:
Utilize UV Space: Ensure that as much of the UV space as possible is utilized to get the best results from your texture space.
Avoid Wasting Space: Large areas of unused UV space can waste file size and reduce potential texture quality.
The next step is to take the high-poly assets and the low-poly assets with the final UVs into a baking tool such as Substance Painter. While Blender can also handle baking, Substance Painter provides better results and more advanced texturing tools.
When baking high-poly details onto a low-poly mesh, you may encounter issues such as mismatched details due to incorrect projection distances. Here are some techniques to address these common problems:
Adjust Projection Distance:
In Baking Tools: Depending on the baking tool (Substance Painter, Blender, Marmoset Toolbag, etc.), adjust the projection distance settings.
Quick Fix: Increase or decrease the projection distance to see if it resolves the issue.
Create a Cage Mesh:
Duplicate Low-Poly Asset: Create a duplicate of your low-poly asset.
Push Vertices Outwards: Use Alt+S in Blender to push all vertices outwards, creating a cage mesh. This is different from scaling and allows for more precise control.
Use Cage for Baking: Use the cage mesh as a reference during the baking process to ensure accurate projection distances.
Split Detail into Different Meshes:
Separate Meshes: Split the high-poly model into different meshes based on detail areas.
Control Baking: This approach gives you more control over how specific details are baked but is dependent on the specific issue.
Fixing the problem depends on the issue. In this particular assets case I found the following :
Fixing baking issues depends on the specific problem encountered. Here’s how the issues were resolved for this particular asset:
Overall Projection Distance:
Issue: The overall projection distance needed adjustment.
Solution: Reduced the projection distance slightly to clear up issues in all areas.
Spoiler Stand Projection:
Issue: The spoiler stand had difficulty projecting correctly.
Solution: Split the spoiler and stand mesh from the main mesh (without moving it) to ensure clean projection distances for each element. This prevented the projection from shrinking around the asset.
Pre-Moved Elements:
Issue: No issues with the thrusters, window cover, and underside detail since they were already moved.
Solution: No further action needed for these elements.
Using Substance Painter’s Mesh Labeling Feature:
Feature: Substance Painter allows baking meshes separately using labels. For example, any asset with <name>_high would bake detail against <name>_low.
Application: This feature prevents unwanted ambient occlusion or asset overlap during baking.
Current Case: Did not use this feature as the assets were already moved away from others, but it is useful in other scenarios.
Bake High-Poly Details:
Use your chosen baking tool (e.g., Substance Painter) to bake the high-poly details into the low-poly textures.
Ensure all necessary maps (e.g., normal, ambient occlusion) are baked correctly.
Start Texturing:
Use the texturing tools in applications like Blender, Substance Painter, or Marmoset Toolbag.
Apply materials, paint details, and add effects such as dirt, scratches, and wear.
Export Textures:
Export the textures with the appropriate settings for your 3D creation tool.
Keep roughness/metallic settings in mind for different platforms.
Diffuse Map: Contains the base color information.
Normal Map: Adds surface detail by simulating small bumps and grooves.
Roughness/Metallic Map:
For GLBs: Roughness (Green Channel) / Metallic (Blue Channel).
For Unity: Smoothness (Alpha Channel) / Metallic (Red Channel).
Ambient Occlusion Map: Adds shading to crevices and recessed areas. Can be included in the Metallic/Roughness map for GLBs.
Emissive Map: Adds glow effects to parts of the model.
Opacity Map: Controls transparency. Often included in the Diffuse map.
The texturing process involved a mix of experimentation and reference checks, with a focus on achieving a cohesive and detailed final asset. Here’s a breakdown of the approach and key considerations:
Experimentation with Smart Materials:
Approach: Played it by ear, experimenting with different smart materials in Substance Painter.
Reference Checks: Occasionally referred to the original reference for elements like lights and thrusters.
Exploration: Explored various smart materials and found some nice results through trial and error.
Custom Smart Materials:
Limitation: Wanted more custom smart materials but decided against it due to time constraints.
Focus: Concentrated on available materials and made the best use of them.
Adding Dirt and Muck:
Importance: Adding dirt was crucial for the final look.
UV Duplication: Only duplicated the side UVs to avoid repetitive dirt patterns on the top of the asset.
Detail Placement: Ensured dirt flowed naturally from insets, enhancing realism.
Thoughtful Detail Placement:
Reasoning: Thought through the approach to detail, ensuring each element had a purpose.
Dirt and Bolts: Dirt flowing from insets and bolts around the car added life and attention to specific areas.
Handling Difficult Elements:
Side Lights: Initially wanted LED lights but couldn’t achieve the desired finish.
Alternative: Switched to metal bars for simplicity and to avoid transparency issues in GLBs and Unity.
Future Considerations: Might consider multi-layered elements with transparency in future updates, despite the added complexity.
When creating a GLB file, the materials need to be set up according to specific standards. Here’s how to configure the required texture maps and use them in Blender or any 3D creation tool that supports the GLB format, which is covered in GLB Considerations.
Diffuse (RGB) + Alpha (A):
Diffuse Map: Contains the base color information in the RGB channels.
Alpha Channel: Contains transparency information.
Roughness (G) + Metallic (B) + Ambient Occlusion (R):
Roughness Map: Stored in the Green channel.
Metallic Map: Stored in the Blue channel.
Ambient Occlusion Map: Stored in the Red channel.
Normal Map (OpenGL):
Normal Map: Contains surface detail information. Ensure it is in OpenGL format.
Emissive (RGB):
Emissive Map: Contains glow information in the RGB channels.
Refining and polishing your asset is a continuous process that extends to the final stages of development. Here are some key steps and considerations to ensure your asset looks great across different platforms:
Iterative Testing:
Test the asset in Blender to ensure it looks as expected.
Import the asset into your target platform (e.g., Unity) to check for any discrepancies.
Each platform may render the asset differently, so it's crucial to test in all intended environments.
Manual Adjustments:
Texture Cleanup: Manually clean up textures, such as the normal map, in Photoshop or another image editing tool.
Mesh Updates: Make small updates to the high-poly or low-poly mesh if needed.
UV Adjustments: Fix any small overlaps or issues in the UV layout that become apparent during testing.
Roughness vs. Smoothness:
Blender and most other platforms use a roughness texture by default, while Unity uses a smoothness texture.
Export Specific Textures: Export the necessary textures for each platform.
Invert Roughness: Invert the roughness texture in an image editing tool to create a smoothness texture if needed.
Handling Mirrored Polygons and Overlapping UVs:
GLB Format: GLBs may not handle mirrored polygons or overlapping UVs as well as FBX files.
FBX Format: Consider using FBX if you encounter issues with GLBs.
When we imported the GLB file, it didn't look good because some parts were flipped, even though it looked fine in Blender.Here's a simple fix:
Import into Unity: First, save the model as an FBX file and import it into Unity.
Export as GLB: Use a tool called GLTFast in Unity to export the model as a GLB file.
Reimport into Blender: Bring the new GLB file back into Blender.
Reapply Materials: In Blender, add all the textures again. Make sure all textures except the Diffuse map are set to 'Non-Color'.
Once your asset is complete, it's time to share it with the world. To make it look as good as possible, you'll need some renders and promotional content. Here's how to do it:
Preview Render:
Purpose: A simple render to show off your asset on the marketplace.
Specifications: For the Mona Marketplace, this should be a 2000x2000 pixel image.
How to Create: Use your 3D creation program to render the image. It's best to use a transparent background.
Promote on Social Media:
Platforms: Share your content on Instagram, TikTok, Twitter (now called X), etc.
Content: Use text to promote the story and background of your asset. But to make it more engaging, consider creating a video.
Create Engaging Content:
Think Like a Movie Trailer: Use the story behind your asset to create a short video with both visuals and audio.
Target Audience: Consider who will be interested in your asset and tailor your content to them. This will also help you decide where to post your content.
Use a Mix of Media:
Images: Take high-quality images of your asset and use them in your promotions.
Text: Write engaging descriptions and stories about your asset.
Videos: Create short, exciting videos that showcase your asset in action.
By following these steps, you can effectively share your completed asset with a wide audience, making it look as good as possible and generating interest in your hard work.
