How To Create FiveM MLOs

Official QBCore Store LLC Sep 12, 2024

Have you ever wondered if creating custom FiveM MLOs is within your reach?
We’re here to tell you it absolutely is.
Do you have a creative vision you’re eager to bring into the bustling world of your FiveM server?
Excellent.

This comprehensive guide is designed to walk you through the entire process, from initial concept to in-game implementation.
We’ll cover the essential tools, techniques, and best practices you need.
By the time you finish reading, you’ll possess the foundational knowledge required to design, build, and integrate your own unique FiveM MLOs.

Introduction to FiveM MLOs: Building New Worlds

First things first, let’s clarify exactly what we’re talking about.

What is a FiveM MLO?

MLO stands for Map Loader Object.
In the context of Grand Theft Auto V (GTA V) and specifically the FiveM modification framework, FiveM MLOs represent custom interior spaces.
Think of them as self-contained bubbles of architecture inserted into the existing game world.
These aren’t just simple map edits; MLOs allow creators to build entirely new, detailed interiors – complete with walls, floors, ceilings, props, and even their own lighting and atmospheric effects.
Crucially, they achieve this without replacing or modifying the base game’s map files directly.
This non-destructive approach is key to maintaining compatibility and stability on FiveM servers.
Instead of overwriting existing locations (like traditional mapping often required), MLOs load dynamically, allowing players to enter unique spaces seamlessly through designated doorways or portals.

Why are MLOs Important for FiveM Servers?

The impact of well-crafted FiveM MLOs on a server’s atmosphere and gameplay potential cannot be overstated.
They offer several significant advantages:

  • Uniqueness and Server Identity: Custom MLOs allow server owners to differentiate themselves. A unique police station, a custom-designed player housing complex, or a bespoke business interior instantly gives your server a unique flavor and identity that players won’t find elsewhere.
  • Enhanced Roleplay: Roleplay servers, in particular, benefit immensely. Imagine custom hospitals with detailed examination rooms, intricate bank vaults for heist scenarios, or hidden underground labs for criminal enterprises. These environments provide richer contexts for player interactions and storytelling. Explore our selection of premium MLOs for inspiration.
  • New Gameplay Opportunities: MLOs can be the foundation for new gameplay loops. Custom garages can integrate with vehicle tuning scripts, unique business interiors can host specific jobs, and custom hideouts can offer strategic advantages.
  • Expanding the World: Los Santos is vast, but MLOs allow you to add depth and utility to previously inaccessible or generic buildings, effectively expanding the playable space without altering the core map structure.
  • Creative Expression: For developers and designers, creating FiveM MLOs is a powerful outlet for creativity, allowing you to leave your architectural mark on the digital landscape.

This guide aims to demystify the process, showing you that while it requires patience and learning, creating functional and beautiful MLOs is achievable.

Required Tools: Your MLO Creation Toolkit

Before we dive into the creative process, we need to assemble our digital toolkit.
Having the right software is essential for a smooth workflow.
Here are the core tools we recommend for creating FiveM MLOs:

  • Blender (Essential):
    • This is a free, open-source, and incredibly powerful 3D modeling suite.
    • It will be our primary environment for constructing the 3D models (the walls, floors, props) of our MLO interior.
    • Blender handles modeling, UV unwrapping, texturing, and preparing the assets for export.
    • Its versatility and strong community support make it an ideal choice, especially for those starting out.
    • Download: Download Blender (Official Site)
  • CodeWalker (Essential):
    • This is an indispensable tool specifically designed for exploring and manipulating GTA V’s game files and formats.
    • Its primary roles for MLO creation include:
      • Viewing GTA V’s existing map and models for reference.
      • Creating and editing essential metadata files (.ytyp, .ymap) that define how your MLO behaves and where it’s placed.
      • Setting up MLO portals (entry/exit points) and occlusion (making sure the game doesn’t render things you shouldn’t see).
      • Generating collision files (.ybn) sometimes.
    • Think of Blender as building the physical structure, and CodeWalker as telling the game engine how to understand and load that structure.
    • Download: You can usually find the latest release on GTA5-Mods or its official Discord/GitHub. (The provided link points to a specific version; always check for the latest stable release). Example search: CodeWalker on GTA5-Mods
  • Sollumz Blender Add-on (Highly Recommended):
    • This is a community-developed add-on for Blender specifically tailored for GTA V modding.
    • It massively simplifies the process of working with GTA V’s proprietary file formats (.ydr, .ydd, .ybn, .ytyp, etc.) directly within Blender.
    • It helps set up correct materials, shaders, collision properties, and export settings compatible with the game engine.
    • Using Sollumz streamlines the workflow significantly compared to older methods involving multiple intermediate tools.
    • Installation: Usually involves downloading the add-on (.zip file) and installing it via Blender’s Edit > Preferences > Add-ons > Install menu. Find it on platforms like GitHub.
  • OpenIV (Essential for Texture Extraction):
    • While CodeWalker can browse files, OpenIV is often preferred for its robust capabilities in opening GTA V’s RPF archives and, crucially, extracting game assets.
    • We’ll primarily use it to find and export vanilla GTA V textures (.dds files) to use on our custom models, ensuring our MLOs fit visually within the game world.
    • It can also be used to extract reference models or props if needed.
    • Download: Download OpenIV (Official Site)
  • A Functional FiveM Server (Essential for Testing):
    • You absolutely need a testing environment.
    • This could be a local server running on your own PC or a hosted development server.
    • This is where you will load your MLO resource pack to see it in action, check for errors, test collisions, and ensure everything works as intended.
    • If you need guidance, check our tutorial: How To Create a FiveM Server.
  • Image Editing Software (Optional but Recommended):
    • Tools like Adobe Photoshop, GIMP (free alternative), or Paint.NET can be useful for modifying existing textures or creating entirely new custom textures for your MLO.
  • 3ds Max + GIMS Evo (Alternative to Blender):
    • Some experienced developers prefer Autodesk 3ds Max, particularly if they have prior experience with it.
    • GIMS Evo is a plugin for 3ds Max, similar in function to Sollumz for Blender, enabling import/export of GTA V formats.
    • This guide will focus on the Blender workflow due to its accessibility, but be aware that 3ds Max is another viable, professional option.
    • Download GIMS Evo: Often found on GTA5-Mods.

Important Note: Always ensure you’re using the latest stable versions of these tools to benefit from bug fixes, new features, and compatibility improvements. Keep them updated!

Setting Up Blender for FiveM MLO Creation: Preparing Your Canvas

Blender is our digital workshop.
Before we start hammering polygons, we need to set it up correctly for creating FiveM MLOs.
This involves installing necessary add-ons and configuring the workspace for optimal results.

Step 1: Install the Sollumz Add-on (Crucial)

As mentioned, Sollumz is key to bridging Blender and GTA V formats.

  1. Download the latest release of the Sollumz add-on (usually a .zip file) from its official source (e.g., GitHub).
  2. Open Blender.
  3. Go to Edit > Preferences.
  4. Navigate to the Add-ons section on the left.
  5. Click the Install... button at the top right.
  6. Browse to where you downloaded the Sollumz .zip file and select it. Click Install Add-on.
  7. After installation, you should see “Import-Export: Sollumz” in the add-on list. If not, use the search bar.
  8. Make sure the checkbox next to “Import-Export: Sollumz” is ticked to enable it.
  9. You should now see a new “Sollumz” tab appear in various Blender panels (like the 3D Viewport sidebar N key, Material Properties, Object Properties, etc.). This confirms it’s active.

Step 2: Configure Scene Units and Scale

GTA V uses specific scaling. Matching this in Blender prevents size issues later.

  1. In Blender, go to the Scene Properties tab (icon looks like a cone and sphere).
  2. Expand the Units section.
  3. Set Unit System to Metric.
  4. Set Length to Meters.
  5. Crucially, ensure Unit Scale is set to 1.000000. This means 1 Blender unit equals 1 meter in GTA V.
  6. You might also want to adjust the Viewport Overlays > Grid scale settings for visual reference, perhaps setting the Scale to 1.0 so major grid lines represent meters.

Step 3: Familiarize Yourself with the Blender Interface (Brief Overview)

If you’re new to Blender, the interface can seem daunting. Focus on these core areas initially:

  • 3D Viewport: The main window where you see and manipulate your models.
  • Outliner (Top Right): A list of all objects, lights, and cameras in your scene. Essential for organization. Name your objects logically!
  • Properties Panel (Bottom Right): Contains tabs for various settings related to selected objects, the scene, rendering, materials, modifiers, etc. We’ll use this extensively.
  • Toolbar (Left Side, T key toggle): Contains tools for moving, rotating, scaling, modeling, etc.
  • Modes: You’ll primarily switch between Object Mode (manipulating whole objects) and Edit Mode (Tab key) (editing the vertices, edges, and faces of a selected object).

Step 4: Basic Navigation and Selection

Mastering navigation is key to working efficiently.

  • Orbit: Hold the Middle Mouse Button (MMB) and drag.
  • Pan: Hold Shift + MMB and drag.
  • Zoom: Scroll the Mouse Wheel or hold Ctrl + MMB and drag up/down.
  • Select Object: Left-click (in modern Blender versions; older versions used Right-click).
  • Select Multiple: Hold Shift + Left-click.
  • Box Select: Press B and drag a box.
  • Deselect All: Press Alt + A or click in empty space.
  • Focus on Selected: Press . (period key) on the Numpad.

Step 5: Understanding Collections

Use Blender’s “Collections” feature (visible in the Outliner) to organize your MLO.
Create collections for different parts like:

  • Exterior Shell
  • Interior Walls
  • Floors_Ceilings
  • Props_Static
  • Props_Dynamic (if applicable)
  • Collisions
  • Portals_Occlusion (for helper objects)
    Good organization now saves headaches later.

With Blender configured and a basic understanding of its interface, we’re ready to start shaping our custom interior.

Creating the Basic Structure of an MLO: From Concept to Model

This is where your MLO starts taking physical form.
We’ll move from planning to creating the fundamental geometry – the walls, floors, and ceilings that define the space.

Step 1: Planning and Design – The Blueprint Phase

Resist the urge to jump straight into modeling.
A little planning goes a long way.

  • Define the Purpose: What is this interior for? A cozy apartment? A gritty warehouse? A high-tech lab? The purpose dictates the style, size, and layout.
  • Gather References: Look for real-world photos, architectural drawings, or even screenshots from GTA V or other games that inspire your design. Reference images are invaluable for details and scale.
  • Sketch a Layout: Draw a simple top-down floor plan. It doesn’t need to be perfect art, just a clear representation of rooms, doors, windows, and general flow. Consider player movement. Where will they enter? How will they navigate the space?
  • Consider Scale: Think about the size relative to a GTA V player character. Use the default Blender cube (which is 2x2x2 meters if units are set correctly) or import a simple human model for scale reference. Ensure doorways are tall enough, hallways wide enough, etc. Standard door height is roughly 2.1-2.4 meters.
  • Location, Location, Location: Where in the GTA V world will this MLO exist? While the MLO itself is its own space, you’ll need an exterior “shell” building in the main world to contain the entrance portal. Choose a suitable location and maybe take screenshots in-game for context.

Step 2: Modeling the Exterior Shell (Optional but Recommended)

Often, you’ll model a simple exterior shell first. This helps define the overall boundaries and provides a base to build the interior within.

  1. Start with a basic shape, often a Cube (Shift + A > Mesh > Cube).
  2. Enter Edit Mode (Tab).
  3. Scale (S) and move (G) the cube to roughly match the overall dimensions of your planned interior space based on your floor plan and scale considerations. Use the Numpad keys (1, 3, 7) for orthogonal views (Front, Right, Top) for precision.
  4. You might add simple details like a basic roof shape if relevant to the interior ceiling.

Step 3: Blocking Out the Interior Walls, Floors, and Ceilings

Now, let’s build the core structure inside the shell or based directly on your plan.

  1. Floors: Create a Plane (Shift + A > Mesh > Plane) for the main floor. Scale and position it. For multiple levels, duplicate (Shift + D) the floor plane and move it vertically (G then Z).
  2. Walls: There are several methods:
    • Extrusion Method: Start with a Plane for the floor outline. Enter Edit Mode, select the outer edges (Alt + Left-click on an edge in Edge Select mode). Extrude (E) these edges upwards (Z axis) to create the exterior walls. For interior walls, you can add new Planes, extrude edges, or use Loop Cuts (Ctrl + R) on the floor plan and extrude the resulting edges.
    • Solidify Method: Create thin planes representing your walls according to your floor plan. Use the Solidify modifier (in the Modifier Properties tab – wrench icon) to give them thickness. Apply the modifier once satisfied.
    • Cube Method: Use multiple scaled Cubes snapped together to form rooms and hallways. Use Boolean modifiers (or the Bool Tool add-on) to cut openings later, but this can sometimes lead to messy geometry if not done carefully.
  3. Ceilings: Similar to floors, create Planes for ceilings, potentially duplicating and modifying floor geometry.
  4. Accuracy: Use Blender’s snapping tools (Shift + Tab to toggle, configure options in the magnet icon menu) and precise transforms (typing values after pressing G, R, or S) to ensure walls meet cleanly and dimensions are accurate. Check face orientations (Viewport Overlays > Face Orientation – blue should face outwards/visible, red inwards). Select all (A in Edit Mode) and recalculate normals (Shift + N) if needed.

Step 4: Creating Openings (Doors and Windows)

Your interior needs ways in and out, and sources of light.

  • Loop Cuts: The cleanest method often involves using Loop Cuts (Ctrl + R). Hover over an edge on a wall, scroll the mouse wheel to add multiple cuts if needed (e.g., two horizontal for the top and bottom of a window), left-click to confirm placement, then slide into position and left-click again. Add vertical cuts similarly. Select the face(s) created within the cuts (Face Select mode) and delete them (X > Faces).
  • Boolean Modifier: For more complex shapes or arches, you can use the Boolean modifier. Create a separate “cutter” object (e.g., a cube for a window). Select your wall, add a Boolean modifier, set the Operation to Difference, select the cutter object as the Object, and apply the modifier. Delete the cutter object afterwards. Be mindful that Booleans can sometimes create complex or messy geometry (ngons) that might need manual cleanup (connecting vertices with J key).

Step 5: Basic Stairs and Ramps

If your MLO has multiple levels:

  1. Model stairs using simple cubes for steps, duplicated and positioned accurately.
  2. Alternatively, model a ramp (a tilted plane) and extrude edges or use loop cuts to define steps, then extrude the step faces slightly.
  3. Ensure stair height and depth are comfortable for player traversal.

Key Modeling Principles:

  • Keep it Clean: Aim for quad-based topology (faces with four vertices) where possible, though triangles are acceptable and necessary. Avoid ngons (faces with more than four vertices) where possible, especially if deforming or subdividing later.
  • Name Everything: In the Outliner, give meaningful names to your objects (e.g., Wall_LivingRoom_North, Floor_Level1, Stairs_Main).
  • Save Frequently: Blender can crash. Save (Ctrl + S) often, and consider using incremental saves (File > Save As... and click the + icon).

At this stage, you should have the basic, untextured shell of your FiveM MLO. It won’t look pretty yet, but the fundamental structure is there.

Texturing and Materials: Breathing Life into Your MLO

An untextured model is just geometry.
Texturing and materials give your FiveM MLO its visual identity, making surfaces look like wood, concrete, metal, or anything else you envision.
This involves finding textures, preparing your model to receive them (UV unwrapping), and setting up materials in Blender using the Sollumz add-on.

Step 1: Finding and Preparing Textures

To maintain visual consistency with GTA V, using textures from the base game is highly recommended.

  1. Launch OpenIV: Open OpenIV and ensure it’s pointed to your GTA V installation directory. Enable Edit mode.
  2. Navigate Archives: GTA V textures are stored in various .rpf archives, often within x64 subfolders (e.g., x64h.rpf, x64i.rpf, etc.) under levels > gta5 > _part_generic > _x64 > textures. Props and specific building textures might be elsewhere (e.g., related to the area map DLCs). This requires exploration. Use the search function in OpenIV (Ctrl+F3), searching for keywords like “wall,” “floor,” “concrete,” “wood,” or specific texture set names if you know them (e.g., v_int_texture, v_gen_texture).
  3. Identify Textures: Textures are usually stored in .ytd (Texture Dictionary) files. Open these to view the .dds texture files within. Look for textures that fit the surfaces of your MLO (walls, floors, ceilings, details). Pay attention to texture dimensions (e.g., 512×512, 1024×1024). Try to use appropriately sized textures – avoid using a massive 2K texture for a tiny detail.
  4. Export Textures: Once you find suitable textures, right-click on the .dds file(s) within the .ytd viewer and choose Export (or Export all textures). Save them as .dds files to a dedicated textures folder within your MLO project directory. Do not convert them to other formats like .png or .jpg at this stage unless you plan extensive editing; keep them as .dds for direct use.
  5. Custom Textures (Optional): If you can’t find suitable vanilla textures, you can create your own using image editing software. Ensure they are seamless (tileable) if used on large surfaces. Save them as .dds files using appropriate compression (e.g., DXT1 for no alpha, DXT5 for alpha channel) using a DDS plugin for your editor (like the Nvidia Texture Tools for Photoshop or a built-in feature in GIMP).

Step 2: UV Unwrapping – The Art of Skinning Your Model

Before applying textures, you need to tell Blender how to map the 2D texture image onto your 3D model’s surfaces. This process is called UV Unwrapping.

  1. Understanding UVs: Imagine cutting seams on your 3D model and unfolding it flat onto a 2D plane (the UV map). Each face of your model corresponds to an area on this 2D map. The texture image is then placed onto this map.
  2. Select Your Object: Select the model part you want to unwrap (e.g., a wall section).
  3. Enter Edit Mode (Tab).
  4. Mark Seams: Switch to Edge Select mode (press 2). Select edges where you want the UV map to be “cut” open. Think about where natural breaks would occur (corners, edges of surfaces). Right-click and choose Mark Seam. Seams will turn red. Good seam placement is crucial for minimizing distortion. Mark seams along hard corners or where different materials might meet.
  5. Unwrap: Select all faces you want to unwrap (A key, or select linked faces with L key). Press U to open the UV Mapping menu. Choose an unwrapping method:
    • Unwrap: The standard method, unfolds based on your marked seams.
    • Smart UV Project: An automatic method, often good for complex shapes or quick results, but can create many small UV islands. You can adjust the angle limit.
    • Cube/Cylinder/Sphere Projection: Useful for shapes that resemble these primitives.
    • Project from View: Maps based on your current viewport angle. Useful for flat surfaces viewed head-on.
  6. UV Editing Workspace: Switch to the UV Editing workspace tab at the top of Blender. You’ll see your 3D model on the right and the 2D UV map on the left, usually overlaid on a checker pattern.
  7. Adjusting UVs: In the UV Editor window, you can select vertices, edges, or faces (G to move, R to rotate, S to scale) of the UV map to arrange them efficiently, straighten edges, and minimize stretching or distortion. Aim to pack UV islands efficiently to maximize texture space usage (though avoid overlapping unless intended). You can scale UV islands up or down to control the texture density on different parts of the model.
  8. Repeat: Repeat the unwrapping process for all parts of your MLO that need texturing.

Step 3: Creating and Applying Materials with Sollumz

Now we connect the textures to the model using Blender’s material system, enhanced by Sollumz for GTA V compatibility.

  1. Select Object: In Object Mode, select the part of your model you want to apply a material to.
  2. Material Properties: Go to the Material Properties tab (red checker sphere icon).
  3. New Material: Click + New to create a new material slot. Click New again to create the actual material. Give it a descriptive name (e.g., Concrete_Wall_A, Wood_Floor_Dark).
  4. Sollumz Shader: With the material selected, find the Sollumz panel within the Material Properties. Click the dropdown that likely says Default Shader and change it to a suitable GTA V shader. Common choices for MLOs include:
    • gta_default.sps: Standard shader for most opaque surfaces.
    • gta_normal_spec.sps: Similar, often used when you have normal and specular maps.
    • gta_emissive.sps: For surfaces that should glow (lights, screens).
    • Consult Sollumz documentation or community resources for shader specifics.
  5. Assign Textures: Open the Shader Editor workspace. You’ll see nodes representing your material.
    • Find the Texture Samplers section in the Sollumz material settings (often in the N-panel sidebar within the Shader Editor if not directly visible).
    • Click the folder icon next to Diffuse Sampler (or similar name for the main color texture).
    • Browse to and select the .dds texture file you exported earlier for this surface.
    • If you have other maps (Normal, Specular), assign them to the corresponding sampler slots. Normal maps add fake surface detail; Specular maps control shininess. GTA V often combines Specular, Metallic, and AO into single textures – refer to guides on how vanilla textures pack these maps.
  6. Assign Material to Faces (If Needed): If an object uses multiple materials (e.g., a wall with a painted section and a brick section), enter Edit Mode, select the faces (Face Select mode) that should receive a specific material, select that material in the Material Properties list, and click the Assign button.
  7. Viewport Display: Ensure your 3D Viewport is set to Material Preview mode or Rendered mode (using Eevee renderer is usually sufficient for preview) to see the textures applied to your model. Adjust UVs if the texture looks stretched, squashed, or improperly scaled.

Texturing is often the most time-consuming part, but it’s what makes your MLO visually appealing and believable within the game world. Take your time, experiment, and refer back to your reference images.

Advanced Modeling, Detailing, and Collisions: Adding Functionality and Flair

With the basic structure textured, it’s time to add the details that make an interior feel lived-in and functional.
We also need to define how players interact physically with the space through collision models.

Step 1: Adding Props and Furniture

Empty rooms are boring. Props bring life and context.

  • Using Vanilla GTA V Props: This is the most performance-friendly method.
    • Use CodeWalker’s 3D view or websites listing GTA V prop names to find suitable objects (chairs, tables, lights, clutter). Note down their model names (e.g., prop_chair_01a, prop_off_shelf_01).
    • In Blender, you don’t typically model these directly. Instead, you can create simple “placeholder” objects (like Empty objects: Shift + A > Empty > Plain Axes) in Blender where you want the props to be. Name these Empties clearly (e.g., PROP_prop_chair_01a_1).
    • Later, in CodeWalker, you will replace these placeholders with actual references to the game’s props when defining the .ytyp (archetype) file for your MLO room or instance.
  • Creating Custom Props: If you need unique furniture or objects not available in GTA V:
    • Model them in Blender just like you modeled the main structure. Keep poly counts reasonable.
    • Texture them using the methods described earlier (vanilla or custom textures).
    • These custom props will become part of your MLO’s drawable models (.ydr).
    • Ensure they also have appropriate collision models (see below).

Step 2: Interior Lighting Considerations

While FiveM handles dynamic lighting, you can enhance the atmosphere within your MLO:

  • Emissive Materials: For light fixtures, screens, or signs that should glow, use the gta_emissive.sps shader (or similar) in Blender via Sollumz. Assign a texture that defines the lit-up areas (often white or colored). You can control the intensity and color in the material settings.
  • Vertex Colors: GTA V uses vertex colors for various effects, including baked ambient occlusion (soft shadows in corners) and basic lighting information.
    • In Blender, switch to Vertex Paint mode.
    • You can paint subtle dark colors (not pure black) into corners and crevices to simulate ambient occlusion.
    • You can also bake lighting: Add lights in Blender (Shift + A > Light), configure their intensity and color, then use Blender’s Render Properties > Bake feature (often with Bake Type set to Diffuse or Emit, influencing Color) to bake light influence into vertex colors. This requires careful setup and experimentation. Sollumz might offer specific tools or workflows for handling vertex AO/lighting.
  • Light Sources Props: Place vanilla GTA V light props (like prop_wall_light_01a) as placeholders (Empties) to leverage the game’s dynamic lighting system.

Step 3: Collision Modeling (.ybn) – The Invisible Walls

Collisions define the physical boundaries of your MLO, preventing players and objects from passing through walls, floors, and props. This is absolutely critical for gameplay.

  1. What are Collisions?: Collision models (.bnv or .ybn files) are simplified, invisible versions of your visible models. The game engine uses these low-poly meshes for physics calculations because checking against high-poly visual models is too performance-intensive.
  2. Creating Collision Meshes in Blender:
    • Duplicate your visible geometry (Shift + D). Move the duplicates to a dedicated Collisions collection in the Outliner.
    • Simplify these duplicates significantly. Remove small details. Use basic shapes (cubes, planes, simplified ramps) to approximate the physical boundaries. Think “blocking out” the space.
    • Ensure there are no gaps where a player could fall through. Collisions must be watertight for floors and walls.
    • For complex props, use very simple primitives (like a box around a chair).
    • Crucially, collision meshes need specific material assignments and object properties set via the Sollumz add-on.
  3. Sollumz Collision Setup:
    • Select a collision mesh part.
    • Go to the Object Properties tab (orange square icon). Find the Sollumz panel. Change Object Type from Drawable to Collision.
    • Go to the Material Properties tab. Create a new material for the collision mesh (e.g., Collision_Material).
    • In the Sollumz panel for the material, you’ll need to assign a Collision Material. This tells the game what the surface sounds and behaves like (e.g., physics_material_concrete, physics_material_wood_solid, physics_material_metal_solid). Choose appropriate types for floors, walls, etc. There are lists available online or through Sollumz documentation.
    • You might need to assign flags (e.g., FLAG_MAP_WEAPON, FLAG_MAP_COVER) in the Physics Properties or Object Properties depending on how you want players to interact (can weapons hit it? can players take cover?).
  4. Exporting Collisions: Sollumz allows you to export these specially prepared meshes as .ybn files, which FiveM can then load.

Step 4: Portals and Occlusion (Conceptual Setup)

MLOs work by defining “rooms” and “portals” (doorways/transitions). The game engine uses this information for occlusion culling (not rendering rooms you can’t see).

  • Portals: Think of these as the connections between the exterior world and your MLO interior, or between different rooms within a complex MLO. In Blender, you might model simple planes or boxes representing doorway areas and place them in a Portals_Occlusion collection. You’ll assign specific properties or names that CodeWalker will use later.
  • Rooms (MLO Entities): Your MLO interior itself will be defined as an MLO instance or entity. You might create an Empty object in Blender at the MLO’s origin point to represent this.
  • Occlusion Geometry: You might sometimes need simple planes inside the MLO to block sightlines between rooms more effectively.
  • Note: The precise setup of portals and occlusion geometry often involves helper objects and naming conventions specific to the tools (Sollumz/CodeWalker) and is finalized in CodeWalker. The Blender stage involves creating the basic geometric shapes that will represent these elements.

Adding these details and functional elements elevates your MLO from a simple model to an interactive game environment. Pay close attention to collision accuracy – nothing breaks immersion faster than falling through the floor!

Exporting Your MLO: Packaging for FiveM

Your masterpiece is modeled, textured, detailed, and has collisions defined.
Now, we need to export it from Blender into the various file formats GTA V and FiveM understand, using the Sollumz add-on.
We also need to structure these files correctly into a FiveM resource folder.

Step 1: Final Checks in Blender

Before exporting, run through this checklist:

  • Object Origins: Ensure the origin point (. the orange dot) of each object is reasonably placed (often at the base or center). This affects rotation and placement later. Select object(s), right-click > Set Origin.
  • Transforms Applied: Select all your visual and collision objects in Object Mode. Press Ctrl + A and apply All Transforms (or at least Rotation & Scale). Unapplied transforms can cause export issues.
  • Face Orientation: Double-check face orientation (Viewport Overlays > Face Orientation). Blue faces outward, red inward. Fix any red faces (Edit Mode > A > Shift + N).
  • Naming Conventions: Ensure objects, materials, and collections are logically named. Sollumz might rely on specific naming for batch exporting or linking objects.
  • Sollumz Properties: Verify that collision meshes have the correct Collision object type and appropriate collision materials assigned. Verify visual meshes use appropriate gta_*.sps shaders and have textures assigned.

Step 2: Exporting with Sollumz

Sollumz provides exporters for the necessary GTA V file types. The exact workflow might vary slightly based on the Sollumz version, but the general process is:

  1. Drawable Models (.ydr / .ydd):
    • These contain your visible geometry and material information.
    • Select the visual mesh objects you want to export (e.g., Exterior Shell, Interior Walls, Props_Custom). Do not include collision meshes or placeholders here.
    • Go to File > Export > Sollumz GXT (.ydr/.ydd).
    • Export Options:
      • Format: Choose .ydr (Drawable) for single objects or .ydd (Drawable Dictionary) if exporting multiple objects grouped together (often preferred for MLO components).
      • Selection Only: Ensure this is checked if you only want to export selected objects.
      • Apply Modifiers: Usually checked, unless you have specific reasons not to.
      • Export Textures: Sollumz can sometimes embed or reference textures. Configure as needed, but typically you’ll manage textures separately in a .ytd.
      • LODs: If you created Level of Detail models, configure the export settings to include them (High, Medium, Low, VLow). Name your LOD objects correctly (e.g., my_wall_high, my_wall_med).
    • Specify a filename (e.g., my_mlo_interior.ydd) and save it to your MLO project’s stream folder (we’ll discuss folder structure next).
  2. Collision Models (.ybn):
    • These contain your simplified physics meshes.
    • Select only the collision mesh objects (from your Collisions collection).
    • Go to File > Export > Sollumz Collision (.ybn).
    • Export Options:
      • Selection Only: Check this.
      • Apply Modifiers: Usually checked.
    • Specify a filename (e.g., my_mlo_collision.ybn) and save it to your stream folder. Often, the collision (.ybn) filename should match the main drawable dictionary (.ydd) filename for automatic linking, but verify this with current best practices.
  3. Texture Dictionaries (.ytd):
    • You need to package your .dds textures into a .ytd file.
    • You can create .ytd files using OpenIV: Create a new folder, place all your required .dds files inside, then in OpenIV, create a new .ytd file and import the .dds files into it.
    • Alternatively, newer Sollumz versions might offer direct .ytd export capabilities based on materials used in the scene. Check the Sollumz documentation for the recommended workflow.
    • Name your texture dictionary (e.g., my_mlo_textures.ytd) and place it in the stream folder.

Step 3: Creating the FiveM Resource Folder Structure

Your exported files need to be organized into a specific folder structure that FiveM recognizes as a resource pack.
Create a main folder for your MLO (e.g., my_cool_mlo). Inside it, create:

  • stream folder: This is where your core game assets go. Place your exported .ydd, .ybn, and .ytd files here. If you used vanilla props (placeholders), you don’t put the actual prop models here; the game already has them.
  • fxmanifest.lua file (or __resource.lua for older servers): This file tells FiveM what your resource contains and how to load it.
  • (Optional) data files: You’ll likely need .ymap, .ytyp, and potentially _manifest.ymf files. These are often created/edited using CodeWalker in the next step, but they will eventually reside either in the stream folder or a dedicated data folder, depending on how you configure the manifest.

Example fxmanifest.lua:

fx_version 'cerulean' -- Or 'adamant', 'bodacious' etc. depending on server artifact
game 'gta5'

author 'Your Name / QBCore Store LLC'
description 'Custom MLO Interior Example - My Cool MLO'
version '1.0.0'

-- Define the files this resource provides
this_is_a_map 'yes' -- Important flag for map resources

-- Files to stream
files {
    'stream/*.ydd',
    'stream/*.ybn',
    'stream/*.ytd',
    -- Add data files if they are in the root or stream folder
    'stream/my_mlo_placement.ymap',
    'stream/my_mlo_archetypes.ytyp',
    'stream/my_mlo_manifest.ymf'
}

-- Data files (alternative loading method, often preferred)
-- Make sure these files exist in the resource folder (not stream)
-- data_file 'MAP_DATA' 'my_mlo_placement.ymap'
-- data_file 'DLC_ITYP_REQUEST' 'my_mlo_archetypes.ytyp'
-- data_file 'INTERIOR_PROXY_ORDER_FILE' 'my_mlo_manifest.ymf' -- For MLO instances

-- Example assuming data files are in the root alongside fxmanifest.lua
-- data_file 'MAP_DATA' 'my_mlo_placement.ymap'
-- data_file 'DLC_ITYP_REQUEST' 'my_mlo_archetypes.ytyp'
-- data_file 'INTERIOR_PROXY_ORDER_FILE' 'my_mlo_manifest.ymf'

-- Make sure CodeWalker generated files are referenced correctly based on their location.
-- Consult FiveM documentation for current best practices on loading map data.

Self-Correction: The loading of data files (ymap, ytyp, ymf) in fxmanifest.lua has evolved. Using data_file entries is often the modern approach, rather than listing them in the files section if they aren’t directly streamed. The example above shows both potential methods; choose the appropriate one based on current FiveM standards and where you place the files (root vs. stream). We’ll assume placing them in the stream folder and listing them under files for simplicity here, but data_file is generally cleaner if files are in the root.

At this point, you have the raw assets exported from Blender and structured into a basic resource folder. The next critical step is using CodeWalker to define how these assets integrate into the game world.

Using CodeWalker: Defining and Placing Your MLO

CodeWalker is where we bridge the gap between our exported models and the GTA V engine.
We’ll use it to define the properties of our custom models, place the MLO in the world, and set up the crucial MLO instance (portals, rooms, occlusion).

Step 1: Setting Up CodeWalker (If First Use)

  1. Launch CodeWalker.
  2. It might prompt you to locate your GTA V installation directory. Browse and select it.
  3. It will likely need to scan game files, which can take some time initially.
  4. Enable RPF Explorer mode (Tools > RPF Explorer or F3).
  5. Enable 3D View (Tools > 3D View or F4).
  6. Ensure DLC Levels are enabled in the options if you plan to use DLC assets or place your MLO in DLC areas.

Step 2: Creating the Archetype Definition (.ytyp)

The .ytyp file defines the “archetypes” or blueprints for your custom models and props. It tells the game about their properties, including linking drawables to collisions and defining LOD distances.

  1. In CodeWalker’s RPF Explorer, navigate to a suitable location to create your definition file (often within update.rpf > dlcpacks > [your_dlc_or_base] > dlc.rpf > common > data > levels > gta5 or create a custom path). Alternatively, create it directly within your FiveM resource’s stream folder.
  2. Right-click in the file list area > New > YTYP File.... Name it descriptively (e.g., my_mlo_archetypes.ytyp).
  3. Double-click the newly created .ytyp file to open it in the YTYP editor.
  4. Click New Archetype (or Edit > Add Archetype from YDR/YDD). If adding from YDD, browse to your exported .ydd file in the stream folder. This can auto-populate some fields. If creating manually:
    • Name: Give the archetype a unique name (e.g., my_mlo_interior_arch). This name links to the model.
    • Model Name: Enter the name of your exported drawable without the extension (e.g., my_mlo_interior).
    • Texture Dictionary: Enter the name of your .ytd file without the extension (e.g., my_mlo_textures).
    • Physics Dictionary / Collision Model: Enter the name of your .ybn file without the extension (e.g., my_mlo_collision). This links the visual model to its physics.
    • LOD Distance / HD Texture Dist: Set distances (in meters) at which the model should display. Start with sensible values (e.g., LOD Dist: 300, HD Texture Dist: 100) and adjust later based on testing. If you exported LODs, define them here.
    • Flags: Set appropriate flags. For static MLO structures, flags like Static, Allow Cover might be relevant. Explore the flags list.
    • Bounds: CodeWalker can often calculate bounds automatically (Tools > Calculate All Bounds), or you might need to define them manually based on your model’s dimensions. Bounds help the engine know the object’s spatial extent.
  5. Adding Vanilla Props: If your MLO uses vanilla props referenced by Empties in Blender: Create new archetypes in the same .ytyp file for each type of vanilla prop you used. For these, set the Model Name to the correct GTA V prop name (e.g., prop_chair_01a), leave Texture Dictionary and Physics Dictionary blank (the game knows these), set appropriate LOD distances, and ensure the Static flag is usually set.
  6. Save the .ytyp file (File > Save or Ctrl+S).

Step 3: Placing the MLO in the World (.ymap)

The .ymap (Ymap) file defines where objects and entities are placed in the game world coordinates.

  1. Create a new .ymap file (New > YMAP File...) in your resource’s stream folder. Name it (e.g., my_mlo_placement.ymap).
  2. Open the .ymap file.
  3. Go to the 3D View in CodeWalker and navigate to the exact location in the GTA V world where you want your MLO’s entrance/exterior shell to be. Use the map, coordinate search, or free camera controls.
  4. In the Ymap editor, click New Entity.
  5. Select the new entity. In the properties panel:
    • Archetype Name: Enter the name of the main archetype you created in the .ytyp file (e.g., my_mlo_interior_arch).
    • Position: Click the Move To Camera button (or manually enter coordinates) to place the entity at your current camera location in the 3D view.
    • Rotation: Adjust rotation (as Quaternion or Euler angles) to orient your MLO correctly.
    • LOD Distance / Parent Index / Flags: Configure as needed (often defaults are okay initially).
  6. Placing Vanilla Props: If you used vanilla props defined in your .ytyp, create new entities in the .ymap for each prop instance. Set their Archetype Name to the prop’s archetype (e.g., prop_chair_01a_arch if you named it that way) and position/rotate them accurately within your MLO’s space relative to the main MLO entity’s position. This can be tedious; sometimes positioning props is done via MLO room definitions instead (see next step).
  7. Save the .ymap file.

Step 4: Creating the MLO Instance (_manifest.ymf / .ymf)

This is arguably the most complex part, defining the interior “bubble” itself, its rooms, portals, and occlusion relationships. This file tells the game “this entity is special; it’s an interior.”

  1. CodeWalker has tools specifically for MLOs. You might need to create a _manifest.ymf or a standalone .ymf file (consult CodeWalker guides/forums for the current best practice, often involving the Project Window). Let’s assume a workflow using the Ymap editor’s capabilities or a dedicated MLO tool within CodeWalker.
  2. Define MLO Entity: Select the main entity you placed in the .ymap. There should be options or flags (perhaps in the Ytyp definition or Ymap entity properties) to mark it as an MLO instance (CEntityDef MLO).
  3. Create Rooms: Within the MLO definition tools, define the different “rooms” or logical spaces within your interior (e.g., LivingRoom, Kitchen, Hallway). Assign properties like lighting settings (referencing .yld light definitions if needed) and bounds.
  4. Define Portals: Define portals connecting rooms or connecting the interior to the exterior. Portals are essentially invisible doorways that control visibility (occlusion) and audio propagation. You define their position, size, and which two rooms they link. Getting portal placement and size right is crucial for preventing visual glitches (seeing through walls) or performance issues. Use the helper geometry you created in Blender as a guide.
  5. Assign Props to Rooms: Instead of placing all props in the .ymap, you can often assign props (both custom parts of your .ydd and vanilla props) to specific rooms within the MLO definition. This helps with streaming and occlusion.
  6. Occlusion: The room and portal structure inherently creates occlusion. The engine won’t render Room B if you’re in Room A and the portal between them isn’t visible. You might need to add explicit occlusion planes (CMloOcclusionMesh) for complex sightlines, using geometry defined in Blender and referenced here.
  7. Saving: Save the MLO definition. This might update the .ymap or save data into a separate .ymf file (e.g., my_mlo_manifest.ymf) that needs to be referenced in your fxmanifest.lua using data_file 'INTERIOR_PROXY_ORDER_FILE'.

Important Considerations:

  • Complexity: MLO instance creation is intricate. Referencing video tutorials (like the ones mentioned in the original article) or specific CodeWalker MLO guides is highly recommended. The exact UI and workflow in CodeWalker can change.
  • Tools: CodeWalker’s Project Window (Tools > Project Window) is often used to manage all these related files (.ydd, .ybn, .ytd, .ytyp, .ymap, .ymf) together.
  • Iteration: Expect to go back and forth between Blender (adjusting models/collisions), CodeWalker (adjusting definitions/placement), and your FiveM server (testing) multiple times.

Once you have saved your .ytyp, .ymap, and MLO instance definitions (.ymf), and ensured they are correctly referenced in your fxmanifest.lua, you are ready to test your creation in-game.

Testing and Debugging in FiveM: Bringing Your MLO to Life

Theory and tools are one thing; seeing your creation live in your FiveM server is the real test.
This phase is all about loading your MLO resource, checking for errors, and identifying areas for improvement.

Step 1: Preparing Your Server

  1. Transfer Resource: Copy your entire MLO resource folder (e.g., my_cool_mlo) into your FiveM server’s resources directory.
  2. Ensure Resource: Open your server’s server.cfg file. Add a line to start your resource, for example: ensure my_cool_mlo. Place it logically, often grouped with other map or asset resources.
  3. Restart Server: Stop your FiveM server completely and then restart it. Watch the server console for any error messages during startup related to your resource (e.g., “Could not load…” errors indicate missing files or incorrect fxmanifest.lua setup).

Step 2: In-Game Testing – The First Look

  1. Connect to Server: Launch your FiveM client and connect to your server.
  2. Navigate to Location: Fly or teleport (noclip is invaluable here – enable it via a script or server command if possible) to the coordinates where you placed your MLO entity in the .ymap.
  3. Initial Checks:
    • Does it Appear? Can you see the exterior shell or the entrance portal area? If not, double-check the .ymap placement and ensure the resource is actually running (resmon 1 in F8 console can show running resources). Check server logs again.
    • Can You Enter? Approach the intended entrance. Does the MLO portal activate? Do you transition smoothly into the interior? If you fall through the world or hit an invisible wall, there’s likely an issue with portal setup or collisions.
    • Basic Visuals: Once inside, look around. Are the textures loading correctly? Do models appear as expected? Are there any obvious gaps or holes in the geometry?

Step 3: Thorough Interaction Testing

Now, interact with the environment like a player would:

  • Collisions: Walk around everywhere. Rub against walls, walk up stairs, try to jump onto furniture. Do you collide correctly with all surfaces? Do you snag on unexpected invisible edges? Do you fall through the floor anywhere? Collision issues often require going back to Blender to adjust the .ybn collision meshes and re-exporting.
  • Props: Are static props positioned correctly? Can you walk through them (shouldn’t happen if collisions are right)? If you have dynamic props (rare for basic MLOs, more script-related), do they behave as expected?
  • Portals and Occlusion: Move between rooms. Does the transition feel seamless? Look back through doorways – does the previous room correctly disappear (occlude) when you can no longer see it? Are there any visual glitches where you can see the outside world from deep inside the interior, or see parts of other rooms you shouldn’t? Portal size, position, and room bounds in CodeWalker are key here.
  • Lighting and Textures: Check lighting in all areas. Does emissive lighting work? Is vertex AO noticeable and looking correct? Are textures displaying properly without flickering (Z-fighting) or obvious tiling artifacts? Z-fighting (flickering when two faces occupy the same space) requires adjusting geometry slightly in Blender. Tiling might need UV adjustments or different textures.
  • Scale: Does the space feel right relative to your player character? Are doorways, furniture, and ceiling heights appropriate?
  • Boundaries: Try to find ways to escape the MLO bounds unintentionally. Are there any gaps in collision or geometry?

Step 4: Using Debug Tools

Leverage FiveM’s built-in tools:

  • F8 Console: Check for client-side errors related to your MLO (missing models, textures, script errors if integrated). Commands like resmon 1 (resource monitor) and neteventlog (network event log) can sometimes provide clues.
  • Developer Mode (developer 1 in F8): Can provide more verbose logging and sometimes overlay debug information. Use developer 0 to turn off.
  • Noclip: Essential for quickly moving around, inspecting areas from different angles, and checking exterior/interior transitions.
  • Coordinate Display: Use a script or tool to display your current coordinates and heading. This helps verify placement and identify specific locations where issues occur.

Step 5: Iteration and Refinement

Testing almost always reveals issues.

  1. Document: Note down every problem you find, being specific about the location and nature of the issue. Screenshots or short video clips can be very helpful.
  2. Prioritize: Fix critical issues first (falling through floor, inability to enter, major visual bugs).
  3. Troubleshoot: Use your notes to determine the likely cause. Is it a modeling error (Blender)? A collision error (Blender/.ybn)? A definition error (CodeWalker/.ytyp)? A placement error (CodeWalker/.ymap)? A portal/occlusion error (CodeWalker/.ymf)?
  4. Fix and Re-Export: Make the necessary corrections in Blender or CodeWalker. Re-export the affected files (.ydd, .ybn, .ytyp, .ymap, .ymf).
  5. Update Resource: Replace the old files in your server’s resource stream or data folder with the updated ones.
  6. Restart Resource: Use the restart my_cool_mlo command in the server console (or F8 if you have permissions) to reload the resource without restarting the entire server.
  7. Retest: Verify that the fix worked and didn’t introduce new problems.

Testing is a cycle. Be patient and methodical. Each bug fixed brings you closer to a polished, functional FiveM MLO. Don’t hesitate to seek help from communities if you get stuck on a particularly tricky issue.

Optimizing Your MLO for Performance: Smooth Sailing

A visually stunning MLO is great, but if it cripples server or client performance, players won’t enjoy it.
Optimization is the crucial process of ensuring your custom interior runs smoothly without causing lag or frame drops.
Here’s how to optimize your FiveM MLOs:

Step 1: Polygon Count (Poly Budget)

Every triangle (poly) in your model requires processing power to render. More polys = more work for the GPU.

  • Be Mindful While Modeling: Don’t add excessive detail that won’t be noticeable. Avoid unnecessary subdivisions. Use techniques like normal mapping to simulate detail on lower-poly surfaces instead of modeling every tiny bump.
  • Check Statistics: In Blender, enable Statistics in the Viewport Overlays. In Edit Mode, it shows the triangle count for your selection; in Object Mode, for the entire object (and scene total at the bottom status bar). Keep track of your MLO’s total poly count. There’s no single “magic number,” as it depends on complexity and target hardware, but aim for efficiency. Compare your counts to similarly sized vanilla interiors if possible.
  • Use the Decimate Modifier: If parts of your model are too high-poly, select the object, go to Modifier Properties (wrench icon), add a Decimate modifier.
    • Collapse mode is often best. Adjust the Ratio slider (below 1.0) to reduce polygons. Visually check that you aren’t losing critical shape details.
    • Planar mode can simplify flat surfaces effectively.
    • Apply the modifier once satisfied. Use it judiciously; over-decimation looks bad.

Step 2: Draw Calls and Material Management

A “draw call” is essentially a command from the CPU to the GPU to draw an object on screen. Each object with a unique material often results in a separate draw call. Too many draw calls can bottleneck the CPU.

  • Combine Meshes: Where appropriate, combine separate objects that share the same material into a single object. In Blender, select multiple objects (Shift + Left-click), then press Ctrl + J to join them. This reduces the number of individual objects the engine needs to manage. Join structural elements (walls, floors) that use the same concrete texture, for example.
  • Texture Atlases: Instead of using many small, separate texture files for details, try combining multiple textures into a single larger image file called a texture atlas. You then UV unwrap different parts of your model onto the corresponding sections of the atlas. This allows multiple objects or parts of an object to use just one material and one texture file, significantly reducing draw calls. Creating atlases requires planning and skill in UV mapping and image editing.
  • Limit Material Variety: While variety is nice, try not to use hundreds of unique materials if fewer, well-utilized ones (perhaps combined with vertex color variations) can achieve a similar look.

Step 3: LODs (Level of Detail)

LODs are lower-polygon versions of your models that the game swaps in when the object is further away from the camera. This is one of the most effective optimization techniques.

  • Create LOD Meshes: In Blender, duplicate your main (high-poly) visual model. Create several progressively simpler versions:
    • _med LOD: Remove smaller details, chamfers, maybe use Decimate modifier slightly.
    • _low LOD: Simplify shapes further. Remove interior details if it’s a prop. Use very basic forms.
    • _vlow LOD: Extremely basic shapes, perhaps just a box or silhouette. Can often share textures with higher LODs via UV mapping.
  • Naming Convention: Name your LOD objects clearly, typically appending _med, _low, _vlow to the high-detail object’s name (e.g., my_chair_high, my_chair_med, my_chair_low, my_chair_vlow). Sollumz uses these names during export.
  • Export LODs: Ensure your Sollumz export settings are configured to include these LOD models.
  • Define LOD Distances: In CodeWalker’s .ytyp editor, for each archetype, specify the distances (in meters) at which the game should switch between LOD levels (e.g., High visible up to 40m, Medium 40m-100m, Low 100m-300m, VLow beyond 300m). Tune these distances based on testing.

Step 4: Occlusion Culling (MLO Portals/Rooms)

As discussed previously, the MLO portal and room system is inherently an optimization. By defining rooms and the portals connecting them, you tell the engine it doesn’t need to render rooms that aren’t visible from the player’s current room and viewpoint.

  • Accurate Portals: Ensure portals in CodeWalker are accurately sized and positioned at doorways or transitions. Portals that are too large or misplaced can cause adjacent rooms to render unnecessarily or fail to occlude properly.
  • Sensible Room Divisions: Break down larger interiors into logical room definitions in CodeWalker. Don’t make one giant room if it contains distinct areas separated by walls/doors.
  • Occlusion Meshes: For complex sightlines or large open MLOs, you might need explicit occlusion meshes (simple planes/boxes defined in the MLO manifest) to help the engine hide geometry more aggressively.

Step 5: Texture Optimization

Large, unoptimized textures consume VRAM (video memory) and bandwidth.

  • Appropriate Resolutions: Use texture dimensions suitable for the object’s size and visibility. A small detail doesn’t need a 2K (2048×2048) texture; 512×512 or even 256×256 might suffice. Use larger textures for prominent surfaces like floors and walls. Powers of two (e.g., 256, 512, 1024, 2048) are standard.
  • DDS Format and Mipmaps: Always save your final textures as .dds. Use appropriate compression (DXT1/BC1 for opaque, DXT5/BC3 for transparency). Crucially, ensure Mipmaps are generated when saving the DDS. Mipmaps are smaller, pre-filtered versions of the texture that the game uses when the object is far away, reducing aliasing (shimmering) and improving performance. Most DDS plugins/tools generate mipmaps automatically or have an option for it.
  • Texture Atlasing: As mentioned under Draw Calls, atlasing also helps texture memory by loading one larger texture instead of many small ones.

Step 6: Collision Optimization

Complex collision meshes (.ybn) can also impact performance, especially CPU physics calculations.

  • Keep it Simple: Collision meshes should be much simpler than visual meshes. Use basic primitives (boxes, spheres, capsules, convex shapes) whenever possible. Avoid concave shapes if you can approximate them with multiple convex pieces.
  • No Unnecessary Detail: The player only needs to collide with the main surfaces. Don’t create collision for tiny details on a prop unless it’s gameplay-critical.

Optimization is an ongoing process. Test performance on your target server environment (and ideally on lower-spec client machines if possible) using tools like resmon 1 in the F8 console to monitor resource CPU/GPU time. A well-optimized MLO provides a seamless experience for everyone.

Common Issues and Troubleshooting: Navigating Roadblocks

Creating FiveM MLOs is a complex process, and running into problems is normal, especially when starting out.
Here’s a breakdown of common issues and how to approach troubleshooting them:

Issue: MLO Doesn’t Appear In-Game

  • Check Resource Status: Is the resource actually running? Use resmon 1 in F8 console. Did you add ensure my_cool_mlo to server.cfg? Check server console for startup errors loading the resource.
  • Check fxmanifest.lua: Are all necessary files (.ydd, .ybn, .ytd, .ymap, .ytyp, .ymf) correctly listed and present in the specified paths? Is this_is_a_map 'yes' included? Are data files loaded correctly (using files or data_file)?
  • Check .ymap Placement: Open the .ymap in CodeWalker. Is the MLO entity placed at the correct coordinates? Did you accidentally place it miles away or under the map? Use Move To Camera in CodeWalker’s Ymap editor while positioned correctly in the 3D view.
  • Check .ytyp Definition: Does the entity name in the .ymap exactly match an archetype name defined in the .ytyp? Is the .ytyp itself loading correctly?
  • Invisible Object / Missing Model: Is the archetype in the .ytyp correctly linked to the .ydd (Model Name) and .ytd (Texture Dictionary)? Are those files present in the stream folder?

Issue: Player Falls Through Floor / Walls

  • Missing/Incorrect Collision File: Is the .ybn file present in the stream folder? Is it correctly named? Crucially, is the archetype in the .ytyp correctly linked to this .ybn file via the Physics Dictionary field?
  • Collision Mesh Errors: Open the .ybn file in a viewer (CodeWalker might support this, or dedicated collision tools). Are there holes or gaps in the collision mesh corresponding to where the player falls through? Go back to Blender, fix the collision mesh geometry, ensure it’s watertight, re-export the .ybn.
  • Incorrect Collision Material: Did you assign collision materials (e.g., physics_material_concrete) to your collision meshes in Blender using Sollumz? If not, the game might not treat them as solid.
  • Transforms Not Applied: Did you apply transforms (Ctrl+A) in Blender before exporting the collision mesh? Unapplied scale can sometimes cause physics issues.

Issue: Textures Not Showing / Wrong Textures / Flickering (Z-Fighting)

  • Missing/Incorrect Texture Dictionary: Is the .ytd file in the stream folder? Is the archetype (.ytyp) linked to the correct .ytd name in the Texture Dictionary field?
  • Incorrect Texture Assignment: In Blender’s Shader Editor/Sollumz material settings, did you assign the correct .dds texture to the Diffuse Sampler (or equivalent)?
  • Incorrect Shader: Are you using a compatible gta_*.sps shader via Sollumz? Using a standard Blender shader won’t work in-game.
  • UV Unwrapping Issues: Are the UVs laid out correctly? If textures look stretched, smeared, or completely wrong, revisit UV unwrapping in Blender for the affected parts.
  • Z-Fighting (Flickering): This happens when two faces occupy the exact same space. In Blender’s Edit Mode, slightly move one of the overlapping faces back along its normal axis. Even a tiny offset can fix it. Check for duplicate geometry (Mesh > Clean Up > Merge by Distance).
  • Incorrect DDS Format: Did you save textures as .dds with the correct compression (DXT1/BC1 or DXT5/BC3) and with mipmaps generated?

Issue: Cannot Enter MLO / Invisible Wall at Entrance

  • Portal Not Defined/Incorrect: This is the most likely cause. Check the MLO instance (.ymf or MLO data) in CodeWalker. Is there a portal defined at the entrance location? Is it linking the correct “exterior” room (often Room 0) to your main interior room? Is the portal large enough and positioned correctly?
  • Collision Blocking Entrance: Is there an unintended collision mesh blocking the doorway? Inspect the .ybn visually.
  • Incorrect Entity Flags: Less common, but ensure the MLO entity flags are set correctly in the .ytyp or .ymap to allow interaction.

Issue: Seeing Through Walls / World Outside from Inside

  • Portal Issues: Portals control occlusion. If you can see outside or into other rooms you shouldn’t, check portal placement and size in CodeWalker. Are they fully sealing the transitions? Is the portal linking the correct rooms?
  • Room Bounds Incorrect: Are the room bounds defined in the MLO instance accurately encompassing the room’s geometry?
  • Missing Occlusion Meshes: For complex layouts, you might need explicit occlusion meshes defined in the MLO instance to block sightlines the portal system doesn’t handle perfectly.

Issue: Poor Performance / Lag Inside MLO

  • High Polygon Count: Check model complexity. Use LODs and decimate where needed.
  • Too Many Draw Calls: Combine meshes, use texture atlases, limit material variety.
  • Missing/Incorrect LODs: Ensure LODs are created, exported, and defined with appropriate distances in the .ytyp.
  • Inefficient Textures: Use appropriate resolutions, ensure .dds format with mipmaps.
  • Complex Collisions: Simplify .ybn meshes.
  • Check resmon 1: Identify if the CPU or GPU time for your resource is excessively high.

General Troubleshooting Steps:

  • Isolate the Problem: If you added multiple things at once, try removing them one by one to see what caused the issue. Test frequently after small changes.
  • Check Console Logs: Server console and client F8 console are your best friends for error messages.
  • Validate Files: Use CodeWalker’s analysis tools if available to check for errors in .ytyp, .ymap, etc.
  • Compare with Working Examples: Look at the structure and files of known working MLOs (even simple ones) to see how they are set up. You can find some great examples, including free ones, right here on QBCore Store LLC: Free FiveM MLOs.
  • Seek Community Help: If truly stuck, forums (like the official FiveM forums) or dedicated modding Discords can be helpful. Provide clear descriptions of the problem, what you’ve tried, and include relevant files or screenshots.

Troubleshooting is a skill learned through practice. Don’t be discouraged; each solved problem deepens your understanding.

Helpful Videos and Further Learning

While this guide provides a comprehensive overview, sometimes watching the process in action is invaluable. Here are some concepts often covered in video tutorials that can supplement your learning (Note: We are not linking specific videos directly as quality/relevance changes, but search for these topics):

  • “FiveM MLO Tutorial Blender“: General workflow videos showing the process from Blender to CodeWalker.
  • “Sollumz Blender Tutorial“: Videos focusing specifically on using the Sollumz add-on for materials, collisions, and export.
  • “CodeWalker MLO Tutorial”: Guides focusing on using CodeWalker to create .ytyp, .ymap, and especially MLO instances (.ymf) with portals and rooms.
  • “GTA V Texturing in Blender”: Tutorials on finding, exporting, and applying GTA V textures using OpenIV and Blender/Sollumz.
  • “FiveM MLO Collisions”: Specific guides on creating accurate and optimized .ybn collision files.
  • “FiveM MLO Optimization”: Videos covering techniques like LODs, draw call reduction, and texture optimization specifically for FiveM.

Key Communities and Resources:

  • FiveM Forums (Cfx.re): The official forums have dedicated sections for mapping, development discussion, and tutorials.
  • CodeWalker Discord: Often the best place for direct support and discussion about CodeWalker features.
  • Sollumz Documentation/Discord: Check for official guides and community support related to the Blender add-on.
  • GTA5-Mods.com: Primarily for single-player mods, but hosts many essential tools (CodeWalker, OpenIV, GIMS Evo) and often has relevant discussions or tutorials in comments/forums.

Frequently Asked Questions (FAQ)

Q1: Is it really free to start creating FiveM MLOs?

  • Yes, the core tools we recommend – Blender, CodeWalker, OpenIV, and the Sollumz add-on – are all free to download and use. Your main investment is time and willingness to learn.

Q2: How long does it typically take to create a FiveM MLO?

  • This varies massively depending on the complexity of the interior, your skill level, and how much detail you include. A very simple single-room interior might take a few days for a beginner, while a large, multi-room, highly detailed MLO could take weeks or even months for experienced creators.

Q3: Do I need coding or scripting knowledge to make an MLO?

  • No, not for creating the MLO asset itself (the model, textures, collisions, placement). The process primarily involves 3D modeling (Blender) and using specialized tools (CodeWalker). However, integrating advanced functionality into your MLO (like custom interactions, dynamic props, job triggers) would require scripting knowledge (usually Lua).

Q4: Can I edit existing GTA V interiors using these methods?

  • MLOs are typically for creating new interiors in otherwise inaccessible building shells or adding interiors where none existed. Editing existing, complex GTA V interiors (like Michael’s house or the FIB building) is significantly more complex, often involving decompiled game files and advanced techniques beyond the scope of a basic MLO creation guide. It’s generally easier and safer to build new spaces.

Q5: What’s the difference between an MLO and just placing props with a YMAP?

  • A YMAP simply places existing models (props or building shells) in the world. An MLO (.ymf definition linked to .ytyp/.ydd/.ybn) creates a self-contained interior “bubble” with its own rooms, portals, occlusion culling, and potentially unique lighting/audio environments. MLOs allow players to seamlessly enter interiors without just seeing props placed inside an empty shell.

Q6: Can I sell the FiveM MLOs I create?

  • Yes, many creators sell their high-quality MLOs. Platforms like Tebex are common, and marketplaces exist. If you create something unique and valuable, selling it can be an option. Ensure you are not using copyrighted assets from other games or paid assets you don’t have a license to redistribute. Using vanilla GTA V assets within your MLO is standard practice. Of course, here at QBCore Store LLC, we also offer a platform for talented creators and provide a wide selection of premium FiveM MLOs for server owners.

Q7: My MLO looks dark inside, how do I add lights?

  • MLOs interact with the game’s time cycle, but you often need to define interior lighting. Use emissive materials on light fixtures in Blender (using gta_emissive.sps via Sollumz). You can also place GTA V light props (prop_light_*) via CodeWalker, or use vertex colors baked in Blender to add ambient light/shadow. More advanced lighting often involves editing .yld (Light Definitions) files, which is a more complex topic.

Q8: Why do my custom props sometimes disappear or flicker?

  • This could be related to LOD distances set too short in the .ytyp, issues with the prop’s bounds calculation, or potentially streaming issues if the MLO is very complex. Ensure LOD distances are appropriate and bounds are correctly calculated/set in CodeWalker.

You’ve made it through our deep dive into creating FiveM MLOs.
We’ve journeyed from the initial concept and tool setup, through the intricacies of modeling, texturing, and collision creation in Blender, to the vital definition and placement steps in CodeWalker, and finally, the crucial testing and optimization phases.

Creating custom interiors is undoubtedly a challenging but incredibly rewarding aspect of FiveM development.
It requires patience, attention to detail, and a willingness to learn and troubleshoot.
Don’t be discouraged if your first attempts aren’t perfect.
Every challenge you overcome, every bug you squash, builds your expertise.
The ability to shape the virtual world, to create unique and immersive spaces for players to explore, is a powerful skill.
Whether you’re building a secret base for your roleplay group, a stunning showroom for custom vehicles, or just a cozy home, MLOs add unparalleled depth and personality to a server.

We encourage you to experiment, to push your creative boundaries, and to keep refining your techniques.
The FiveM community thrives on innovation, and creators like you are the driving force behind its constantly evolving landscape.
Start small, practice consistently, and consult the wealth of resources available in the community.

We hope this comprehensive guide has empowered you with the knowledge and confidence to start creating your own amazing FiveM MLOs.
Happy modeling, and we at QBCore Store LLC can’t wait to see the incredible environments you bring to life!

Find MLOs for your server

Related Posts

Leave a Reply

Your email address will not be published. Required fields are marked *