Thank you for using Sollumz, the only GTA V modding suite for Blender!

Prerequisite Knowledge

• A basic understanding of Blender and 3D modeling. (This is a great place to start)

• A basic understanding of modding in GTA V including using CodeWalker.

Requirements

• Blender 4.0 or later -

• Latest version of CodeWalker found in #releases channel.

Reporting Bugs and Making Feature Requests

If you think you've found a bug or you wish to request a feature, please use the . Be sure you extensively troubleshoot the issue first to ensure a bug is actually present.

Our Community

Join the and be a part of our growing community!

Each separable part of a Fragment must have an associated collision object in order for physics to work. This means each bone with Use Physics enabled should also have a collision object linked to it.

Rigging Collisions

You link collisions to bones the same way you link Drawable Models to bones as described in Drawables (.ydr) > Rigging.

Setting Mass

Each collision object under a Fragment also has a Physics subpanel where you can define its mass.

Auto Mass Tool

There is also a tool for automatically calculating mass based on the collision material's density and the object's volume. Navigate to Sollumz Tools > Fragment > Set Mass. There you will find the Calculate Collision Mass tool.

In order for this tool to work, the collision object must have a collision material added.

Volume and Inertia

Volume and Inertia are essential physics properties for collisions. You can find these options under Object Properties > Sollumz.

Typically when creating completely custom collisions, you would auto-calculate these values during export, as calculating these involves a lot of math relating to the dimensions and shape of your collisions.

Setting up proper Sollumz Shaders

For your textures and materials to work correctly inside of GTA V, you will need to use 'Sollumz Shaders'. these are simply materials that are set up correctly for use with GTA V assets.

To get started, within the Sollumz Tools found in the Toolbar, navigate to Drawables -> Shader Tools

Here you can find a list of all usable shaders within GTA V. you will quickly notice just how many shaders there are, and you might be intimidated by the amount, but around 80-90% of these shaders are not used frequently or at all for props.

Next, we will need to decide which shader is right for our asset. some key things to keep in mind when deciding which shader to use are:

• Does my asset utilize a normal map?

• Does my asset utilize a specular map?

• Do my textures contain an alpha channel?

for this example, the asset uses a normal and specular map, but no alpha. so for this shader we will use "normal spec".

Creating the Shader

So now that we have decided which shader we will be using, we can now go ahead and create the shader. To do so, you can either press CTRL + F within the shader list and search for "normal_spec", or you can scroll manually.

Once you have located the shader, select it by clicking it. it should now be highlighted. next, select your prop model, and click the "Create Shader Material" button.

Applying textures to your new shader

If you now navigate to the Material tab on the bottom right panel with your prop model selected, you will see your newly created shader.

another thing you will notice is the "Sollumz" tab within the Material tab. Within this Sollumz tab is where you will be controlling everything related to this specific shader.

If you expand the Texture Parameters panel, you will see the 3 different texture slots:

• DiffuseSampler (Diffuse / Colour map)

• BumpSampler (Normal / Bump map)

• SpecSampler (Specular Map)

you can go ahead and click the folder icon on the right to open up the file explorer window and select the corresponding textures for each.

Once you apply each texture, ensure the BumpSampler Color Space is set to "non-Color" otherwise it will look incorrect within blender, but will be fine when you export.

Ped YFTs (.yft) with articulated skeletons

Skeleton yfts (like mp_f_freemode_01.yft) are supported, as they just contain skeletons. However, some ped yfts also contain additional unknown physics data which is not handled by Sollumz. Here is a list of ped yfts that are not supported.

The example vehicle used in this article is adder.yft

Fragment Hierarchy

All models rely on LOD meshes, which greatly reduces graphics demand of detailed models and improves overall performance.

In order to render your mesh at any distance:

1. Go to Data tab.

2. Scroll to Sollumz LOD.

3. Copy the name from High LOD to Very High, Medium and Low.

Vehicle windows are defined in the physics properties of the window collision. See window_lf.col in adder.yft for example.

Enabling Is Glass Window will cause the window properties to appear. The only property you should have to change here is the Window Material. This is the material that the corresponding window mesh uses. Looking at the window_lf mesh materials, we see that it uses two vehicle_generic_glasswindows2 materials.

This is because one material represents the inner glass and the other represents the outer glass. Go into Edit Mode and select the vertices of each material to see which one represents the outer glass. In this case, it's the material without the ".001" so that's the one that the glass window should reference.

That's all that is needed for working vehicle windows!

Shattermaps

You will notice that all vanilla vehicles have "shattermaps", which is an image that defines the border of the glass-breaking pattern. These aren't 100% necessary for working vehicle windows but will result in better-looking glass shatter patterns.

In Sollumz, shattermaps are represented as planes with a single texture. For example, adder.yft has an object called windscreen_shattermap which is parented to windscreen.col.

These are always low-res bitmap greyscale textures. Currently, Sollumz has no tools for creating shattermaps, so your best bet is to copy shattermaps from vanilla files and work off of those.

Drawables are objects that hold mesh data, skeleton data, and shader data. It can be thought of as the game engine's mesh format. YDR files contain one Drawable and are typically used for static mapping but are also used for dynamic props in some cases. In cases where a prop consists of multiple breakable parts, Fragment (.yft) objects are used instead.

File Layout

Drawable
    ShaderGroup
        Shaders
        TextureDictionary
    Skeleton (sometimes)
    DrawableModelsHigh
        Geometries...
    DrawableModelsMed
        Geometries...
    DrawableModelsLow
        Geometries...
    DrawableModelsVeryLow
        Geometries...
    Lights (sometimes)

Drawables consist of multiple "Drawable Models" which hold the actual mesh data. Drawable Models are organized into High, Medium, Low, and Very Low detail levels. In every Drawable there is also a list of the shaders used and the parameters for each shader. Sometimes there are textures embedded in the file as well. Drawables can also contain skeleton data, but it is not required. This is usually only found in dynamic Drawables (objects affected by physics) such as props or in Drawables that are animated. Lastly, Drawables can contain lights, where each light contains light properties such as direction, falloff, color, etc.

Blender Hierarchy

In Blender, the hierarchy for Drawables consists of one parent Drawable object (either an empty or an armature depending on whether or not the Drawable has skeleton data) and Drawable Models (mesh objects).

Paint colors allow you to determine which materials represent the Primary color, Secondary color, Wheel color, Interior Trim color, and Dashboard color. To select the paint color for a material, navigate to Material Properties > Sollumz > Fragment.

By default it will be "Not Paintable", meaning the shader will not be affected by any paint color.

In the Export Codewalker XML > Fragment panel, you will find the two options, depending of your edits done prior in Blender.

First option - Auto Calculate Bonetags in Drawable is doing a bone number calculations. This option is needed to use when you have added a fresh new bone (i.e. a rear doors). The hardcoded bone tag value tells the game that specific bone has to be treated as rear doors. If you have not added any bones, do not select this.

Second option - Auto Calculate Inertia and Auto Calculate Volume has to be ticked if you have changed the shape of any collision mesh. Using this option provides a correct calculation for a physics engine. If you have not changed any collision shapes, do not select this.

Prerequisite Knowledge

• Basic Blender skills

• Know how to either stream assets in a FiveM resource or load singleplayer mods

The example vehicle used in this article is adder.yft

Jump right in and create your first game asset by following one of our tutorials! We recommended you start with these tutorials first, as the other tutorials build off knowledge from these tutorials.

It's also highly recommended that you check out the documentation section. There you will find detailed information about each file type and how it is represented in Blender.

TODO

TODO

Key

🟩 Fully implemented

🟧 Partially implemented

🟥 Not implemented

File Formats

Specific Features

Drawable (.ydr)

Drawable Dictionary (.ydd)

Static Collision (.ybn)

Fragment (.yft)

Clip Dictionary (.ycd)

Map Data (.ymap)

Archetype Definition (.ytyp)

Drawables can be rigged using either vertex groups (skinning) or Child Of constraints. The top-level Drawable object must be an armature.

Skinning

Skinning Drawables works the same way you would normally do it in Blender. Simply create vertex groups where each group's name corresponds to a bone in the armature. Then, add an armature modifier and specify the Drawable as the armature object.

Linking bones to Drawable Models

Many Drawables aren't rigged using weighted vertex groups. You can instead link an entire Drawable Model to a bone by using a Copy Transforms constraint.

Use the "Add Bone Constraint" operator with the Drawable Model Selected to add a Copy Transforms constraint with the properties setup for correct previewing.

There are two import settings that determine how Fragments import: Split By Group and Import with _hi.

Split By Group

Split By Group will split the Drawable by vertex group. This is typically what you want when editing vehicles, as vehicles are skinned (i.e. rigged with weighted vertex groups), so there is typically only one Drawable Model containing many vertex groups as opposed to multiple Drawable Models each linked to a bone (see Drawables > Rigging > Skinning for more info on rigging Drawables).

Here is what adder.yft looks like when split by group.

Notice how each object represents a separable part of the vehicle. Since it's split by vertex group, each object will only have one vertex group.

Each object also has an armature modifier with the Fragment as the target object.

Import with _hi

Vehicle Fragments have an additional LOD level that is stored in a separate file named <fragment name>_hi.yft. For adder, it would be called adder_hi.yft. This is the highest level of detail and is what the player sees when close to the vehicle (i.e. when driving). It is very cumbersome to work on two separate YFTs so Sollumz stores this extra LOD level in the Very High LOD level. This enables you to work on both YFTs at once.

To import Very High LODs, first enable the Import with _hi option in the, and ensure the _hi YFT is in the same directory as the non-hi YFT. Then, select the non-hi YFT and import.

Prerequisite Knowledge

• Basic Blender skills (This is a great place to start)

• Know how to either stream assets in a FiveM server or load mods into the base-game

What you will need

• A mesh located at the world location (where you want the collision to be)

Converting to a Static Collision

The first thing to do is apply location transforms on your object(s). Select all the objects and press CTRL + A and select 'Location'.

Next go to Sollumz Tools > Collisions > Create Bounds and select your object(s) and click 'Convert to Composite'.

Ensure that the Bound Composite and Bound GeometryBVH empties are located at 0, 0, 0.

Next, Center the origins of your object(s), go to Object > Set Origin > Origin to Geometry.

It should now look something like this.

Last step is to rename the 'Bound Composite' empty to your .ybn file name.

Additional tips

Using Primitive shapes such as, 'Bound Poly Box', 'Bound Poly Capsule', 'Bound Poly Sphere' should be used for majority of your collisions, unless the mesh is a complex shape and cannot be made up of multiple primitive shapes. This is because it is more performance friendly and reduces unnecessary asset size.

Collisions are well, collisions. whether that is for players, bullets, vehicles etc. There is 3 main types of .ybns, the normal version(s), hi@ versions which is for weapon bullets, and ma@ collisions that are used to procedurally spawn grass and other things like garbage on the street.

BoundComposite
     BoundGeometryBVH
          BoundPolyMesh
          BoundBox
          BoundPolyBox

The Bound Composite is the top most part of the hierarchy, it doesnt control much on its own. The Bound GeometryBVH controls things like which things collide with the Bound Poly Mesh / Boxes. You can disable or enable certain flags here t o disable collision for specific object types. The Bound Poly Mesh / Box is the collision model itself, what you are actually colliding with. It is here where you can add or remove Collision materials and apply flags to said materials to control the physics of the collisions further. Also, the "Procedural ID" setting is used mainly for ma@ collision ybns to spawn procedural objects like trash on the ground. The "Room ID" Setting is used for setting up different rooms for MLOs.

Bones can be easily moved in Edit mode. To move them:

1. Switch to Solid Mode

2. Toggle X-Ray

3. Choose a bone you want to move

4. Select it in 3D View

5. Click on Move icon

6. Move the bone using gizmo.

The example prop used in this article is prop_container_05a.yft

Fragment Hierarchy

Create and assign Vertex Groups

To create a new vertex group, go to Data tab, click + in Vertex Groups, double click on the Group name and rename it to bonnet.

You will notice that each Fragment bone now has a Use Physics property.

Enabling this will reveal a Physics subpanel where various physics properties can be configured for that bone. The defaults work great for most use cases but feel free to tweak them to get the results you want.

Most importantly, enabling Use Physics is what causes the bone to react to physics. If this is unticked, any geometry associated with the bone will always remain static in-game. Usually, you'd have a bone for each separable part. That way, all parts of your Fragment will act independently of each other. See the

Game meshes are stored in the file format. Creating Drawables in Sollumz is very simple. This tutorial will walk you through step-by-step.

Converting to a Drawable

The first thing to do is convert your object(s) to a Drawable. Select all the objects and click Convert to Drawable in Sollumz Tools > Drawables > Create Drawable Objects.

Any mesh with vehicle_lightsemissive shaders will appear always emissive in-game unless light IDs are assigned. Assigning light IDs allow you to make some faces only appear emissive under certain conditions (i.e. headlights on/off). Sollumz makes assigning light IDs easy.

With a headlight object selected, enter Edit Mode in Face Selection mode and navigate to the Sollumz Tools > Fragment > Vehicle Light IDs panel.

Select the faces of the left headlight that use the emissive shader, then set its light ID to headlight_l.

In the Export Codewalker XML > Fragment panel, you will find the Toggle LODs option.

This allows you to export just the hi YFT, just the non-hi YFT, or both at the same time.

TODO

TODO

Importing a model

Without further ado, import a model (from a different game, modelled by yourself) to Blender. In this case, I am going to import the Super GT from GTAIV in .FBX format.

As the import has finished, you will see an imported mesh.

Assigning materials

The subject of consideration for this tutorial is the bonnet part. To assign a material, go to Material tab, click on Browse material button and select the material from the list. In this case, I have assigned a vehicle paint one to the outer part of the bonnet.

The same is true for all the bonnet's materials.

The LODs for each Drawable Model can be edited in the Mesh Properties > Sollumz LODs panel. As mentioned before, there are 4 LOD levels: High, Medium, Low, and Very Low. You will also see the "Very High" LOD level, but that is only used for YFT vehicles (see Fragments > Vehicle Setup).

Setting LOD Level

For each LOD level, you can select the mesh it will use. You can also select any LOD level from the list and it will swap out the mesh that the Drawable Model uses.

LODs can also be changed for the entire hierarchy at once in the Sollumz Tools > General > View panel.

Alternatively, press Shift + V to open a pie menu for quickly viewing different LOD levels.

Auto LOD Tool

Sollumz provides a basic LOD generation tool that uses the decimate modifier.

Select the Drawable Model and Navigate to Sollumz Tools > Drawable > LOD Tools.

From here you can select which LOD levels will get created. Normally you'd model the highest LOD first, convert to a Drawable Model, then use that high LOD mesh as the reference mesh. The reference mesh is not affected in this process. Each subsequent LOD level is decimated by Decimate Step.

Your results will vary depending on the mesh, as the decimate modifier does not work well for all topologies.

Extracting LODs into Separate Objects

You can also take advantage of Blender's instancing functionality and separate the LOD meshes into separate objects. This allows you to work on multiple LOD meshes at once.

Select the Drawable Model and Navigate to Sollumz Tools > Drawable > LOD Tools.

From here you can select which LODs to extract as well as what to parent the new objects to. You can either parent the objects to a collection or an empty object.

Notice how these new objects are using the same meshes as the ones defined in the Sollumz LODs panel.

Now, if you edit one of these object instances, the Drawable Model will be affected too.

Upon importing, you will notice that the vehicle has only one wheel. This is because the game instances (re-uses) wheel_lf for all other wheels.

Wheel meshes do not have vertex groups but are instead rigged by a Child Of Constraint (as explained in Drawables > Rigging).

Also, wheel meshes have the Is Wheel Mesh property ticked under Object Properties > Sollumz.

That's all that's needed for setting up wheel meshes!

Previewing the Other Wheels

In Sollumz Tools > Fragment > Create Fragment Objects is a tool called Generate Wheel Instances. This tool will create instances of the wheel, allowing you to better preview what it looks like in-game. This is useful when positioning the wheel bones.

How do I import files to Blender with Sollumz?

• Sollumz can only import XML files exported from CodeWalker. Make sure you install the latest version of CodeWalker as described.

Prerequisite Knowledge

• Basic Blender skills

Blender 4.2+

Starting with Blender 4.2, Sollumz can now be installed as an extension from our repository .

First, add https://repo.sollumz.org/ as a remote repository by navigating to Preferences > Get Extensions > Repositories > + > Add Remote Repository

The Drawable Dictionary is a container that holds a collection of drawables. Its primary use is for storing LOD models, ped components, ped props, mesh minimaps and instanced props.

It is recommended that you read the Drawable documentation page before creating a Drawable Dictionary, as it consists of drawables.

File Layout

For the hierarchy, several drawables exist as regular game-ready assets, but all of them share one parent drawable dictionary object.

Fragments are objects that contain separable parts and react to physics. These objects are typically used in breakable props (i.e. street lamps) and vehicles. The file contains a Drawable and a Composite (collision), and sometimes multiple of each if there is a destroyed variant such as in gas tanks. However, Sollumz does not currently support editing destroyed variants of Fragments.

It's recommended that you read the documentation page on Drawables and collisions first, as Fragments are made up of these objects.

File Layout

If you have any questions, feel free to ask on our server. Please use the "" channel.

Before asking

Helpers are taking time out of their day to help you, so please make an effort to provide as much detail as possible in your post. See the pinned post "" for guidelines on how to ask questions.

The default value is set to 0, or constantly visible.

Game meshes are stored in the Drawable (.ydr) file format. Creating Drawables in Sollumz is very simple. This tutorial will walk you through step-by-step.

Prerequisite Knowledge

• Basic Blender skills (This is a great place to start)

• Know how to create YMAPs to place objects in CodeWalker ()

• Know how to either stream assets in a FiveM server or load mods into the base-game

What you will need

• A UV-mapped 3D mesh of your choice

• Textures for the mesh

You can also follow along with the tutorial by using the assets below:

Converting to a Drawable

The first thing to do is convert your object(s) to a Drawable. Select all the objects and click Convert to Drawable in Sollumz Tools > Drawable > Create Drawable Objects.

You'll notice that an empty object gets created called "Drawable" and the objects that were selected are now Drawable models.

If you navigate to Mesh Properties > Sollumz LODs you'll also notice that the active mesh is automatically assigned to the "High" LOD level. This panel is where you can assign other meshes as LODs. More info on that . For the sake of this tutorial, we will only be setting the High LOD level.

Adding Materials

Next, we need to add materials to the Drawable Models. With one of the Drawable Models selected, open the Sollumz Tools > Drawable > Shader Tools panel. For this tutorial, I will use the "NORMAL" shader which allows us to specify a base color and a normal map. Search for the "NORMAL" shader and click Create Shader Material.

With the newly added material selected, head to the shading tab and assign your textures.

Repeat the process for any other Drawable Models. In my case, I am just going to use the same material for the "crate_top" Drawable Model.

Embedding Textures

Lastly, we need to set the textures as embedded. This will embed the textures into the YDR file, so we don't have to create a texture dictionary file (.ytd). With both objects selected, navigate to Sollumz Tools > Drawable > Shader Tools and click Set all Materials Embedded.

Exporting

Before exporting I'm going to rename my Drawable to something more descriptive like "crate". Once you're happy with everything, export the Drawable by clicking File > Export > Codewalker XML. I am going to also enable Export with ytyp. This will automatically generate a YTYP with the Drawable we created already defined.

Your Drawable is now ready to be loaded into the game!

Getting Files Ready to Stream

Convert the ydr.xml and ytyp.xml using CodeWalker.

Open the converted files in a CodeWalker project.

Add a YMAP to the project and add the newly created Drawable as an entity.

Position the entity to your liking, then export the YMAP.

Now, load your YDR, YTYP, YMAP, and _manifest.ymf into either an RPF or the stream folder of your FiveM resource.

Test In-Game

That's it! Load into the game and check out your creation!

Archetype definitions (.ytyp) is basically the configuration file to define properties of objects. inside the .ytyp you will find multiple Archetypes, each archetype is for one object, there is 3 types of archetypes, Base, Time and MLO. Base is for .ydr, .ydd, .yft objects, Time archetypes are for time based objects such as window emissives that only show up at night. MLO archetypes are for MLOs (.ybn) objects.

Often the easiest way to get into ped editing is to start simple: Let's edit an existing model from GTA for a freemode ped, so we can learn the basics.

Peds: Streamed vs Non-Streamed

One thing you should know is that there are generally two different types of peds for GTA: "streamed" and "non-streamed". For a basic explanation, just know that peds use YDD (drawable dictionary) files for their models instead of YDR. For streamed peds, all of their 'parts' (ie shirt, shoes, head, etc) are separate YDDs. For non-streamed peds, all of those parts are put together into 1 single YDD. Streamed peds are generally easier for beginners to start with editing, because you can edit and export 1 piece at a time so if you mess up, you know it's just that 1 part that isn't working.

MP Freemode both male and female are both "streamed peds". This means that all of their parts are separate. If you wanted to see a 'base body' in blender to work with, you'll need to import several different YDDs: a HEAD, an UPPER, a LOWR, and a FEET.

Ped Skeletons

One other note before we start: All peds, whether streamed or non-streamed, have a SEPARATE FILE called a YFT for their skeleton. For whatever ped you are editing with Sollumz, you will need their YFT file so that Sollumz knows what their bones are.

Importing the Files

Export the skeleton YFT XML

Let's start getting ready to get into Blender! The first step is to export the male and female Freemode ped skeletons (YFTs) to use when importing and exporting components that are rigged to the ped. These are located at x64v.rpf\models\cdimages\streamedpeds_mp.rpf and can be saved separately to be used with any freemode ped clothing or accessories you edit in the future.

If you haven't already created a folder somewhere on your computer to work on this project, do that now. Then, right-click the mp_m_freemode_01.yft and press Export XML.... Make sure you're keeping track of where you exported the XML to. It will need to be in the same folder as the YDD when we import into Sollumz.

Exporting the YDD

Now we'll export the model we actually want to edit, as well as a texture for it. If you didn't already know of it, is a good visual reference for most of the freemode components. It has most DLC clothing, although it is missing some of the newer updates. Today we already know what clothing piece we're using, so let's head back over to Codewalker RPF and grab the file.

Open up CW RPF and type mp_m_freemode into the searchbar

If you click "Name" at the top to sort by name, you'll then see a list of all of the MP Male folders. You'll notice there are multiple folders for every DLC. This is the original DLC folder, and then patchday folders that hotfixed any issues R* had with various pieces of clothing.

The 🟥 outline is all of the base MP male DLC folders

The 🟧 outline highlights all of the DLC names. Notice the original DLC and all of the patchday hotfixes.

The 🟩 outlines the original base game DLC folder.

Right now we aren't going to worry about any hotfixed files, so just click into the original DLC folder. If you are ever editing GTA assets, though, you should always look through the patchday folders for whatever component you're trying to edit so that you can work off of the most up-to-date version.

Now that we're inside the base folder, you'll see a long list of all the base game components and their YTD textures. Make sure you're sorted by 'Name' so that everything is alphabetical, and then scroll down until you see the JBIBs.

For the purposes of our tutorial, let's export jbib_007_u.

1. Right-click on jbib_007_u.ydd

2. Select export XML...

3. Export location: Make sure you export to the same folder you exported the YFT earlier.

Now let's quickly visit the folder you've just exported the file to. In the folder, you should have a couple of things. Firstly the mp_m_freemode_01.yft.xml, then .ydd.xml of our jbib & there should also be a folder named jbib_007_u.

Whenever you are exporting a model that has embedded textures, Codewalker RPF will create a folder named after the model you exported to XML with all of the embedded textures placed inside of it.

Go ahead and click into the folder and take a peek at the embedded textures! You should see two: a normal texture and a specular texture. To quickly explain these: A normal helps emphasize clothing details like wrinkles & a specular helps display the glossiness or matte of your clothing.

Most freemode clothing components have an embedded specular texture and normal texture. When you go to make your own models later on, you'll need to learn how to create these yourself. For now, they have already been made for us. So get familiar with them while you can!

Exporting a texture for our model

You might have already noticed, but there's one texture we don't have yet: A diffuse texture. The diffuse texture for clothing YDDs stays un-embedded from the model and in a separate file called a YTD (texture dictionary), and you can have up to 26 of them (A to Z) for any single YDD. We don't need the texture for our editing today, but it's nice to have a visual reference, so let's grab one now.

In Codewalker RPF right below where you found the YDD we exported, should be the YTD files. Scroll down until you see jbib_diff_007_a_uni.ytd and export it to XML. It will create a sub-folder named jbib_diff_007_a_uni with the texture inside of it.

Ready for Blender

Do a final check before opening blender. Your folder should look like this:

Your .yft.xml is in the same folder on the same level as the .ydd.xml . That's the import part!

If you would like, you can copy/paste the diffuse texture from the jbib_diff_007_a_uni to the "embedded textures" folder jbib_007_u . This will allow Sollumz/Blender to automatically find the texture when you go to import. Otherwise, you can link it manually later on.

Importing to Sollumz

With Blender open:

1. click File

2. Import ► Codewalker XML

3. Navigate to the folder you exported the XMLs

4. Click jbib_007_u.ydd.xml and from the side-menu options make sure you select 'Import External Skeleton'

You should now be looking at something like this:

Let's make sure we imported correctly. In scene collection:

1. Expand jbib_007_u and then jbib_007_u.001 and click on SKEL_ROOT

2. In the properties window, click on the Object Data Properties tab

3. Expand Vertex Groups (if its not already) and make sure they are all named.

If you see named bones like SKEL_L_Hand etc then you're good to go! If you see something like UNK.001 you did not follow the correct steps for exporting the YFT portion of this tutorial. Go back up, re-read, and try again.

Preparing the model

Viewport adjustments

With everything imported properly, let's get ready to actually edit! First things first, we probably want to change our viewport to actually see what we're working with.

Personally, I like to change the 'color' to Texture and 'lighting' to MatCap, but you can play around in this menu and see what works for you.

Linking diffuse texture

Once we have that set, your shirt might look like this:

If you left the diffuse texture in it's own jbib_diff_007_a_uni sub-folder, you'll see our jacket is pink. That's fine! We can just link up our diffuse texture now.

• Top-left, go to File ► External Data ► Find Missing Files

Navigate to your project folder and select the jbib_diff_007_a_uni sub-folder where you will see the jbib_diff_007_a_uni.dds. Then press 'find missing files'.

It's good to know this method, as you will use it in other parts of Sollumz modding as well for things like props and MLOs. You might see a yellow warning popup at the bottom of your blender that says it cannot find 'givemechecker.dds' . This is fine to ignore.

Head back to the 3D viewport (instead of shader editor) and we can see our jacket now has the diffuse texture:

Great! Just one more thing to do before we actually edit. When importing into blender our vertices have unmerged and we've lost our sharp edges. We want all of that back so that we can have the most accurate view of what we're working with and what it will look like in-game.

Merge vertices/Sharp Edges

To fix things, let's do the following:

1. Select SKEL_ROOT in scene collection

2. In 3D Viewport, Tab into Edit Mode

3. Select everything (Default: A key)

4. Merge ► By Distance (Default: M key)

Clothing has 3 LODs (level of detail): high, medium, and low. We also need to do the same thing for our medium and low LODs.

The easiest way to switch between LODs quickly is to press SHIFT + V (make sure you are no longer in edit mode) to bring up the Sollumz Object Visibility wheel.

The three options on the right-side of the wheel are the ones you'll be using for clothing YDDs. Switch to Medium, repeat the same steps above. Then switch to Low, and do it once more.

Editing

We're ready to edit! Switch back to High LOD with SHIFT + V and tab into edit mode. You can make any changes you want here. I'll delete the sleeves for the purpose of this tutorial.

Now that I've removed the sleeves, I have 2 things to resolve:

1. I need to fill in the holes where the sleeves used to be

2. I need to create new sharp edges to tidy up the model

The reason we want to fill in the holes is because GTA uses back-face culling. What this means is that the faces on the model do not have both a viewable "front" and "back". Instead, the front-facing side is visible and the back is invisible. We can see this in action in blender by going back up to the viewport shading options and turning it on.

You can see the "back side" of the model is invisible now. We need to fill in those holes. There are two ways to fix this.

First, go back into edit mode and select all of the vertices around the edge.

Then you have two options. You can either press F to fill in the hole, or you can extrude the hole and then merge the vertices from the extrusion. For this tutorial, I'll be doing the second method.

1. Select the vertices around the edge

2. Extrude (default E key)

3. With your mouse, move the new points slightly inward

4. Scale the vertices together (default S key) then merge them (M Key) ► at center

You might notice that our new geometry looks a little weird. Almost as if its shiny in places.

What's happening here is we have bad normals. To be clear, there is a difference between the embedded "normal texture" (sometimes also called a bump map) and geometry normals. If you'd like to learn more about normals, there are plenty of youtube videos that can help.

For now I'm just going to reset them to clear up this issue! With my geometry selected go to Mesh ► Normals ► Reset Vectors

Once that's done, everything should be looking much betterr.

Since this is the edge of the shirt, I'd also like to set some sharp edges along the same loop we just filled in. Sharp edges add a more "crisp" line in geometry that is clearly visible in-game. When you use them properly, they can add a little extra emphasis to your model quality. There's no rule of when or when not to use sharp edges, it's up to you to follow the lines of clothing and determine where they would make sense.

For now I'll go to edge select & select the loop I filled in, then right-click and press "mark sharp"

Now do the same thing with the other side.

With that done comes the boring part: Repeating the same process with the medium and low LODs! With custom models, you would have all of this already finished before you create your LODs but when editing existing clothing, you need to either edit everything the same or create new LODs after you've edited.

For this tutorial, you should delete the sleeves on the med/low LODs so that they look visually similar, but it's up to you whether you want to fill in the sleeve holes like we did here for High LOD. Chances are that from a distance people won't be able to see that small detail anyway.

Exporting

With all of the LODs edited, we're now ready to export!

• In the outliner window, right-click jbib_007_u and select hierarchy

• Then go top-left to File ► Export ► Codewalker XML

• It's best to create an 'export' folder so that you are not overwriting the original. That way if you mess up, you don't have to go grab the ydd xml all over again.

• navigate into Export folder

• Export

The window will close and at the bottom of your blender you should see a message like "exported in 0.12 seconds".

Now in our export folder, we should have our new .ydd.xml and a copy of the embedded textures folder with our normal/specular textures inside.

You can now head back over to Codewalker RPF and import the XML to turn it back into a YDD & preview it!

Our model is finished! Now you can replace the existing one or create an addon with the same textures and test in-game. In-game you might see it clips with the underarms as you move around. That's due to something called "weight painting". More about that to come in future tutorials!

CExtensionDefExpression

Used for:

CExtensionProcObject

Used For: Attaching / Spreading procedural objects

CExtensionDefWindDisturbance

Used for:

CExtensionDefSpawnPointOverride

Used For: Spawning / overriding ped spawns

CExtensionDefSpawnPoint

Used For: Attaching peds / ped scenarios to objects

CExtensionDefLightShaft

Used For: Light Rays / God Rays

Vehicle Paint shaders

vehicle_paint1

vehicle_paint1_enveff

vehicle_paint2

vehicle_paint2_enveff

vehicle_paint3

vehicle_paint3_enveff

vehicle_paint3_lvr

vehicle_paint4

vehicle_paint4_emissive

vehicle_paint4_enveff

vehicle_paint5_enveff

vehicle_paint6

vehicle_paint7

vehicle_paint7_enveff

vehicle_paint8

vehicle_paint9

Vehicle Light shaders

vehicle_lightsmeissive

Lights ID values for different type of vehicle lights, available in Fragments / Vehicle Light IDs

Vehicle Glass shaders

vehicle_vehglass

vehicle_vehglass_inner

Vehicle Interior shaders

vehicle_interior

vehicle_interior2

Simple interior shader without normal map support.

Vehicle Mesh shaders

vehicle_mesh

vehicle_mesh_enveff

Vehicle Tire shaders

vehicle_tire

vehicle_tire_emissive

Vehicle Emissive shaders

vehicle_dash_emissive

vehicle_dash_emissive_opaque

Vehicle License plate shaders

vehicle_licenseplate

Vehicle Miscellaneous shaders

vehicle_badges

vehicle_decal

vehicle_decal2

vehicle_detail2

vehicle_shuts

vehicle_track/vehicle_track2