General Manual for 3D Models

Model Installation Guide

Most game engines are compatible with files exported from Blender. However, some engines interpret axis orientation differently. By default, all models are configured with the Z-axis pointing up, but in certain engines, such as Unity, the Y-axis points up. To address this discrepancy, you can:

• Rotate the models 90° on the Y-axis in Blender before exporting.
• Use formats such as .glb or .fbx, which generally adjust this mismatch automatically.

Material Setup

Although engines are compatible with Blender, the fidelity of materials is often affected during import. Most engines assign a default PBR (Physically Based Rendering) material and approximately map the textures. To optimize materials:

• The texture r-rough-b-ao.png combines roughness information in the red channel (Roughness) and ambient occlusion in the blue channel (Ambient Occlusion).
• You may need to configure a custom shader to correctly interpret these data.
• The additional files package includes a GLSL shader compatible with Blender, which can serve as a base for designing a custom shader in your preferred engine.

Texture Atlas Setup

Some engines, such as Unreal Engine, allow combining multiple textures into a large Texture Atlas of up to 8192x8192 pixels. If your engine supports this feature, you can use it to manage textures more efficiently. However:

• Most engines do not support this feature automatically, which may require manual adjustments.
• The models are already designed with an optimized Texture Atlas, so additional configuration is generally unnecessary.

Model Hierarchy

Each product is delivered as a single file in a specific format (.blend, .fbx, .obj, .glb, etc.), containing multiple optimized meshes. These meshes share a single texture to ensure efficiency and compatibility. Key features include:

• Uniform Scale: All meshes have a scale of 1.0 on each axis.
• Standard Rotation: Rotations are set to 0.0 to prevent inconsistencies during import.
• Metric Units: Models are configured in meters to align with the International System of Units (SI).

If the model is designed to include animations, movable parts are separated from static parts to simplify manipulation. Most products do not include preconfigured bones or animations unless explicitly specified. For further details, consult the model-specific manual.

Texture Atlas Usage

Meshes utilize an optimized Texture Atlas to maximize texture area usage and minimize graphical load. The UV maps are configured with the following features:

• Efficient Distribution: UV islands are proportioned to match the model size, ensuring uniform resolution across all meshes.
• Minimal Stretching: UV cuts are designed to capture maximum detail without noticeable distortions.

his approach, however, has a limitation: separating meshes to apply individual textures can be challenging. In such cases, you may need to bake textures into a new UV map.

Object Positioning

Meshes are designed with the pivot located at the base of the model to facilitate placement on flat surfaces. For irregular objects that may be thrown or physically manipulated, the pivot is positioned at their center of mass to ensure more intuitive handling within the game engine.

Additionally, meshes are configured with standardized dimensions proportional to real-world objects, reducing the need for scaling adjustments in most cases. This modularity simplifies integration into various scenarios.

Animation Application

By default, most models do not include predefined animations. If animations are available, detailed instructions are provided in the product-specific manual included with the package.

Interaction with Engine Scripts and Physics

Most models are designed as static objects with no complex hierarchies, simplifying interaction with physics systems and game scripts. However, some models may feature additional functionalities, such as data stored in vertex colors. In such cases, additional files will be included to support these features:

• Examples of use through specific scripts.
• Shaders leveraging features like wind-based movement using vertex colors.
• Links to web demonstrations illustrating their functionality.

This model pack includes a data texture named `r-rough-b-ao.png`, which combines roughness, ambient occlusion, and other properties into separate channels. The purpose of this texture is to save GPU VRAM, but it requires additional configuration. Specifically, you need to create a shader that separates the channels and applies the values to the corresponding material properties.

Inside the ZIP file, you'll find a file named `PBR-shader-for-data-texture.GLSL`, which serves as an example implementation of the data texture applied to the material. This file is designed for Godot 4, but you can modify it to work with Unity 3D or use it as pseudo-code for Unreal Engine.

Shader Explanation

            
shader_type spatial;

// Texturas
uniform sampler2D albedo_texture : hint_albedo;
uniform sampler2D normal_texture : hint_normal;
uniform sampler2D data_texture; // Roughness (R), Displace (G), AO (B), Translucency (A)

// Parámetros ajustables
uniform float roughness_scale : hint_range(0, 1) = 1.0;
uniform float displace_scale : hint_range(0, 1) = 1.0;
uniform float ao_scale : hint_range(0, 1) = 1.0;
uniform float translucency_scale : hint_range(0, 1) = 1.0;

void fragment() {
    // Get values from textures
    vec4 albedo_color = texture(albedo_texture, UV);
    vec3 normal_map = texture(normal_texture, UV).rgb;
    vec4 data = texture(data_texture, UV);

    // Split channels from data texture
    float roughness = data.r * roughness_scale;
    float displace = data.g * displace_scale;
    float ao = data.b * ao_scale;
    float translucency = data.a * translucency_scale;

    // Apply values to PBR
    ALBEDO = albedo_color.rgb;
    NORMAL_MAP = normal_map;
    ROUGHNESS = roughness;
    METALLIC = 0.0; // Set the metalness
    AO = ao;
    TRANSLUCENCY = translucency;

    // Opcional: Aplicar el desplazamiento (displace)
    // Esto depende de cómo quieras usar el desplazamiento en tu shader
    // Por ejemplo, podrías modificar la posición del vértice en el vertex shader.
}
            
        

1. Textures:

• albedo_texture: Base color texture (Albedo).
• normal_texture: Normal map for surface detail.
• data_texture: Combines Roughness (Red), Displace (Green), AO (Blue), and Translucency (Alpha).

2. Separated Channels:

• data.r: Roughness
• data.g: Displace (not directly used in this fragment shader)
• data.b: Ambient Occlusion
• data.a: Translucency

3. Adjustable Parameters:

• roughness_scale: Adjusts the intensity of the roughness channel.
• displace_scale: Adjusts the intensity of the displace channel (not used in this fragment shader).
• ao_scale: Adjusts the intensity of the ambient occlusion channel.
• translucency_scale: Adjusts the intensity of the translucency channel.

4. Shader Outputs:

• ALBEDO: Base color of the material.
• NORMAL_MAP: Normals for surface detail.
• ROUGHNESS: Controls material roughness.
• METALLIC: Controls metallicity (disabled in this case).
• AO: Ambient occlusion for more realistic shadows.
• TRANSLUCENCY: Controls material translucency.

Additional Notes:

• If you need to use translucency, you can apply it in the vertex shader to modify vertex positions based on the alpha channel value.
• Ensure that the textures are correctly configured in Godot's material settings (e.g., sRGB for Albedo and non-sRGB for Roughness, Normal, etc.).
• You can adjust the values of `roughness_scale`, `displace_scale`, `ao_scale`, and `translucency_scale` directly in Godot's inspector to customize the effect.

What if I Don’t Know How to Program Shaders

Another option is to manually separate the channels of the `r-rough-b-ao.png` texture into individual textures. If you're not familiar with programming, you can use image editing software like GIMP or Photoshop to do this.

If you're comfortable with programming, you can run a script included in the ZIP file named `channel_splitter.py` to automatically separate the channels into individual textures.

How to Use `channel_splitter.py`

Requirements:

You need to install the `Pillow` library, which is used for image processing, by running the following command:

            
pip install pillow
            
            

GUI Execution:

After installing the dependency, simply run the script with the following command:

            
python3 channel_splitter.py
            
            

On Linux, you can execute it with:

            
./channel_splitter.py
            
            

The script will open a graphical interface where you can select the input image and the channels to split.

Command-Line Execution:

Using arguments can facilitate automation if you plan to separate channels from multiple data textures. The command structure is as follows:

            
python3 script.py -i input_image.png -r red.png -g green.png -b blue.png -a alpha.png
            
            

Here’s a practical example:

            
python3 script.py -i texture.png -r roughness.png -g displace.png -b ao.png -a translucency.png
            
            

Arguments:

The script accepts the following arguments:

            
            -i, --input: Input image file.
            -r, --red: Red channel output image file.
            -g, --green: Green channel output image file.
            -b, --blue: Blue channel output image file.
            -a, --alpha: Alpha channel output image file.
            
            

Note: The -i parameter is mandatory to load the data texture, while the -r, -g, -b, -a parameters are optional, but at least one must be used.

Lose the Script?

If you lose the script, you can find a copy in the following GitHub repository: under the `texture-ops` folder. This folder contains various scripts related to texture operations for 3D models.

Misaligned Uvs

If UVs are not properly assigned, open Blender and check the number of UV maps in the mesh section. It is possible that more than one UV map was mistakenly included. Simply delete the one that doesn't work. Note that stores typically review the content to ensure functionality before publication.

Textures Not Displaying Correctly

Default textures are located in the same directory as the main file. If the file was accidentally moved to a different location, reassign the textures to their new location within the material settings.

Compression Quality Loss

The product textures are provided in uncompressed PNG format so users can apply compression based on their needs. If compression issues occur, use a format that supports lossless compression and ensure reasonable compression values to maintain quality.

Standard Fab.com License

Rights:

• Personal Use: Products may be used for personal, non-commercial purposes. This includes use at home or in private projects.
• Digital Access: If the product includes digital content (such as downloadable files), the purchaser may download and use such content as stipulated in the terms.
• Ownership of Physical Item: If the product is physical, the purchaser owns that item but not the copyright or design rights.

Limitations:

• Prohibition of Commercial Resale: Products may not be resold for commercial purposes without prior authorization.
• No Modification or Reproduction: Modifying, copying, or reproducing the product's design or digital content for distribution or commercial use is not permitted.
• Non-Transferable License: The rights associated with the license cannot be transferred to another person.

If you have any questions or suggestions, feel free to reach out to us through our support channels.