New naming convention proposal #149

Merged
Demeter Dzadik merged 12 commits from Mets/blender-studio-pipeline:mets-naming-conventions into main 2023-11-23 17:11:47 +01:00
Showing only changes of commit 27188bc437 - Show all commits

View File

@ -1,14 +1,16 @@
# Datablock names
## Separators
We only have 3 separators to work with, so we try to make the most of them and keep their meaning consistent across conventions:
We only have 3 separators to work with, so we try keep their meaning consistent across conventions:
`-` : Separates prefixes from each other and from the rest of the name.
`_` : Used instead of spacebar in composite words, eg. `eifel_tower_base`.

I agree with this characterization of _ which to me stands in confilct of the proposal to use it for hierarchies/parts later in this document.

I agree with this characterization of `_` which to me stands in confilct of the proposal to use it for hierarchies/parts later in this document.

I think that later part of the document is over-explaining a bit, and makes things that I see as part of the base name (without any suffixes or prefixes) sound as if they were something technically significant. I'll try to clarify this better.

I think that later part of the document is over-explaining a bit, and makes things that I see as part of the base name (without any suffixes or prefixes) sound as if they were something technically significant. I'll try to clarify this better.
`.` : Suffixes, used only for symmetry sides, ie `.L`/`.R`, and for variations, `clock.normal`, `clock.broken`, `clock.destroyed`

To me these two categories are completely separate from each other. There could also be variations of symmetric objects.

I'd propose to use . generally for parts/hierarchies like we have in the past. .L/R is compatible with that definition imo.
Variations are for me something orthogonal to that. Could we introduce :? Not sure why we are limited to those 3, as compatibility shouldn't be an issue.

To me these two categories are completely separate from each other. There could also be variations of symmetric objects. I'd propose to use `.` generally for parts/hierarchies like we have in the past. `.L/R` is compatible with that definition imo. Variations are for me something orthogonal to that. Could we introduce `:`? Not sure why we are limited to those 3, as compatibility shouldn't be an issue.

I agree with introducing : as a separator for variants, I only didn't do this because I wasn't sure if you guys are open to it.

Only note is that I would still always put .L/.R at the very end, even if there is a variation, otherwise blender's built-in name flipping function wouldn't work. (Which to be fair isn't used for any built-in operators in Object mode, but for add-ons it's still handy.)

I agree with introducing `:` as a separator for variants, I only didn't do this because I wasn't sure if you guys are open to it. Only note is that I would still always put `.L/.R` at the very end, even if there is a variation, otherwise blender's built-in name flipping function wouldn't work. (Which to be fair isn't used for any built-in operators in Object mode, but for add-ons it's still handy.)
## Asset Mnemonic

I had to google what mnemonic means. Maybe we can move to something more intuitive like identifier?

I had to google what mnemonic means. Maybe we can move to something more intuitive like identifier?

Agreed!

Agreed!
All local datablocks across all assets of a production must have a unique name. To faciliate this, each asset is assigned a mnemonic that must remain unique within a given production. For example, a character named "Elder Sprite" might get the mnemonic "ES". The max length of this mnemonic is not limited, but the shorter the better. If a minor prop in the production is called "Electric Switch", it can not have the mnemonic "ES", because it's already taken. So, "ELSW" would be fine.
All local datablocks across all assets of a production must have a unique name. To faciliate this, each asset is assigned a mnemonic that must remain unique within a given production. For example, a character named "Elder Sprite" might get the mnemonic "ES". The max length of this mnemonic is not limited, but the shorter the better. If a minor prop in the production is called "Electric Switch", it can not have the mnemonic "ES", because it's already taken. So, "ELSW" would be fine.

The mnemonics should have more 4 letters (more than the 2 and 3) to distinguish them from asset prefixes. otherwise it would be easy to confuse the two. maybe making them lower case would help too.

The mnemonics should have more 4 letters (more than the 2 and 3) to distinguish them from asset prefixes. otherwise it would be easy to confuse the two. maybe making them lower case would help too.

If we don't mind longer ID names, I'm happy to use just a slightly shortened version of names, eg. "elder" for Elder Sprite or "rocket_int" for Rocket Interior.

If we don't mind longer ID names, I'm happy to use just a slightly shortened version of names, eg. "elder" for Elder Sprite or "rocket_int" for Rocket Interior.
This mnemonic will be used in the names of datablocks, to make sure all names are unique, not just in a single file, but the whole production. This is useful/necessary because of the way Blender's Override system works, which relies on making local copies of linked object hierarchies, meaning all assets need to be able to exist in the same namespace without collisions.
## Asset Collections
@ -25,7 +27,7 @@ Example: `CH-elder_sprite`
Note that there's no technical distinction between different types of assets. This is purely for organizational purposes and comfort.
The immediate sub-collections of the root collection are strictly defined by our Asset Pipeline add-on, as being `{mnemonic}-{task_layer}`. Task Layers are the different data layers that make up an asset, such as Modeling, Rigging, and Shading. Beyond those two layers, any number of collections may be created according to the needs and wants of the person responsible for a given Task Layer. However, each sub-collection should still start with `{mnemonic}-{task_layer}-`.
The immediate sub-collections of the root collection are strictly defined by our Asset Pipeline add-on, as being `{mnemonic}-{task_layer}`. Task Layers are the different data layers that make up an asset, such as Modeling, Rigging, and Shading. Inside these Task Layer Collections, each artist responsible for their own Task Layer may create sub-collections freely, as long as each sub-collection still starts with `{mnemonic}-{task_layer}-`.

I don't remember this being a necessity in the current design of the asset pipeline. Maybe I'm misremembering but I don't generally think that binding the tasklayer association with the name is a good idea, since that will make changing this without breakage impossible.

I don't remember this being a necessity in the current design of the asset pipeline. Maybe I'm misremembering but I don't generally think that binding the tasklayer association with the name is a good idea, since that will make changing this without breakage impossible.

It is, it's necessary for each task layer to be assigned its own piece of the hierarchy, otherwise the pipeline doesn't know which hierarchy to keep; The one being pulled in, or the one already in the current file. So when pulling into Rigging currently, it will preserve the current hierarchy for the Rigging collection, but take the hierarchy of the other collections from the publish.

It is, it's necessary for each task layer to be assigned its own piece of the hierarchy, otherwise the pipeline doesn't know which hierarchy to keep; The one being pulled in, or the one already in the current file. So when pulling into Rigging currently, it will preserve the current hierarchy for the Rigging collection, but take the hierarchy of the other collections from the publish.

But I thought we agreed on storing this data as custom properties and keeping the hierarchies out of it, no?
Because this isn't just about the exceptions, right? Every collection would have that. Having the tasklayer name in every single collection of an asset seems quite off to me, that's not something I remember considering. Maybe that was a misunderstanding at the time.

But I thought we agreed on storing this data as custom properties and keeping the hierarchies out of it, no? Because this isn't just about the exceptions, right? Every collection would have that. Having the tasklayer name in every single collection of an asset seems quite off to me, that's not something I remember considering. Maybe that was a misunderstanding at the time.

So as far as the Asset Pipeline is concerned, we did agree on storing ownership information inside property groups on the individual objects, and that is how ownership of objects is handled by the Asset Pipeline.

But for consistency in the organization of collections each task layer has a collection, the user can assign objects to their task layer collection. These top-level collections are named after the task layers and are purely organizational and don't influence who owns what object, but they are necessary to avoid conflicts in collection assignments during Push/Pull. Personally I prefer the collection set-up like this, but I'm open to discussing alternatives.

It is possible to replace this feature with some kind of ownership system and UI similar to objects for collections, but that not within the scope of things we are currently focused on. We are more focused on finalizing the transfer logic and getting 'ownership' working on non-object IDs like GeoNode groups.

So as far as the Asset Pipeline is concerned, we did agree on storing ownership information inside property groups on the individual objects, and that is how ownership of objects is handled by the Asset Pipeline. But for consistency in the organization of collections each task layer has a collection, the user can assign objects to their task layer collection. These top-level collections are named after the task layers and are purely organizational and don't influence who owns what object, but they are necessary to avoid conflicts in collection assignments during Push/Pull. Personally I prefer the collection set-up like this, but I'm open to discussing alternatives. It is possible to replace this feature with some kind of ownership system and UI similar to objects for collections, but that not within the scope of things we are currently focused on. We are more focused on finalizing the transfer logic and getting 'ownership' working on non-object IDs like GeoNode groups.

It's actually not necessary for the sub-collections' names to include the task layer name, that's true. That was more of a stylistic choice on my end. So you're right, this is in fact legal:

CH-elder_sprite
    esprite-model
        esprite-head
        esprite-eyes
            esprite-eye.L
            esprite-eye.R
    esprite-rig
    esprite-shading

I think it might be a bit nicer with the task layer names, when seeing the collections as a flat list, like when appending or using the Blend File view of the Outliner. Also because multiple task layers might have their own collection relating to a given part of a character. But I don't mind too much if this isn't strictly enforced.

It's actually not necessary for the sub-collections' names to include the task layer name, that's true. That was more of a stylistic choice on my end. So you're right, this is in fact legal: ``` CH-elder_sprite esprite-model esprite-head esprite-eyes esprite-eye.L esprite-eye.R esprite-rig esprite-shading ``` I think it might be a bit nicer with the task layer names, when seeing the collections as a flat list, like when appending or using the Blend File view of the Outliner. Also because multiple task layers might have their own collection relating to a given part of a character. But I don't mind too much if this isn't strictly enforced.
So, here's what an asset's collection hierarchy might look like:
```txt
CH-elder_sprite
@ -40,13 +42,15 @@ CH-elder_sprite
ES-shading
ES-shading-outlines
```
## Asset Datablocks
- All local datablocks (Mesh, Material, Action, etc.) of an asset must start with or at least include the asset's mnemonic, eg `ES-eye.L`. This is automated by the Asset Pipeline add-on.
- All local datablocks of an asset (Object, Mesh, Material, Action, etc.) must include either the asset's mnemonic or full name (both is not necessary). Eg., `RIG-elder_sprite` or `GEO-ES-eye.L`. This is automated by the Asset Pipeline add-on.
- Object Data and Shape Keys should be named the same as the containing Object. This is automated by the Asset Pipeline add-on.
- Object names must not end with a `.00x` suffix. This is enforced by the Asset Pipeline add-on.
- In some cases it may be truly unreasonable to expect an artist to give every object in an asset a unique, manually typed in name, like when building a house out of a hundred wooden slab objects. In these cases, the Batch Rename Datablocks built-in add-on should be used to give groups of objects the same name, then in a subsequent step replace the `.` in the `.00x` suffixes with an `_` instead.
- The purpose of this is so that, when there are >1 copies of this asset overridden in a file, every object in the same copy of the asset will have the same number suffix. This would not be the case if we didn't replace the `.` with an `_` before publishing the asset.
- Without this step, debugging shot files with multiple copies of an asset becomes an absolute nightmare, and if you add the occasional deletion of copies into the mix, it could even confuse Blender's Library Override system and break shots.
- Datablock names must not end with a `.00x` suffix. This is enforced by the Asset Pipeline add-on.
- When there's too many objects to manually name, like when building a house out of a hundred wooden plank objects, the **Batch Rename Datablocks** built-in add-on should be used to give groups of objects the same name. Then replace the `.` in the `.00x` suffixes with an `_` instead, so `GEO-HS-wooden_plank.023` becomes `GEO-HS-wooden_plank_023`.
- The purpose of this is that when there are >1 copies of this asset overridden (and therefore local) in a file, every object in the same copy of the asset will have the same number suffix. The first copy will have no suffix. The second copy of the asset will have object names like `GEO-HS-wooden_plank_023.001`, which is fine. If we didn't do this step, this object would instead end up getting named `GEO-HS-wooden_plank.024`, which is not fine because now the suffix number has no correlation with which overridden copy of the asset this object belongs to.
- Without this step, debugging shot files with multiple copies of an asset becomes a nightmare, and it could even confuse the Library Override system and break shots.
It is advisable to give Objects an additional prefix to provide information about the object's purpose, especially when it is NOT part of an asset. This is purely for organizational and comfort purposes. Here are some recommendations:

This needs stronger wording than "should be advisable", every object datablock should have that prefix to make it clear when linking/appending what that object is and to visually distinguish the objects in the outliner and python query.

This needs stronger wording than "should be advisable", every object datablock should have that prefix to make it clear when linking/appending what that object is *and* to visually distinguish the objects in the outliner and python query.

Gotcha, will replace "should" with "must".

Gotcha, will replace "should" with "must".
@ -57,13 +61,14 @@ It is advisable to give Objects an additional prefix to provide information abou
- `RIG` : Rig and rig specific objects that do not appear in rendering
- `ENV` : Matte paintings, sky-domes, fog volume objects
- `GPL` : Grease pencil stroke objects (need to differentiate from GEO because can not be rendered on the farm)
- `TMP` : Any object used in pre-viz that should be replaced with final assets over the course of the production.
Use `.L` or `.R` for objects that belong to one side and are symmetrical.
On the other hand, avoid using `.L` and `.R` when similar objects exist on each side of an asset but aren't meant to be symmetrical.
Use `.L`/`.R` suffices for objects that belong to one side and are symmetrical.
On the other hand, avoid using `.L`/`.R` when similar objects exist on each side of an asset but aren't meant to be symmetrical.
Example: `GEO-WRDB-drawer_knob.L` for the left-side drawer knob of a wardrobe prop.
If a name contains a *of* relationship - in the above example the `knob` of the `drawer` - these should NOT be separated by `.`, but rather with `_`.
If a name contains an "*of*" relationship - in the above example the `knob` *of* the `drawer` - these should NOT be separated by `.`, but rather with `_`.

according to the first section, _ is used only as spacebar replacement, it's not a separator. so an of relationship could be - instead

according to the first section, `_` is used only as spacebar replacement, it's not a separator. so an _of_ relationship could be `-` instead

Thinking about it now, I actually don't think an of relationship needs to be signified by the ID name at all, since it has no technical significance in the pipeline. To me, it's just the same as any other word separation. Collections also help with this.

Thinking about it now, I actually don't think an *of* relationship needs to be signified by the ID name at all, since it has no technical significance in the pipeline. To me, it's just the same as any other word separation. Collections also help with this.
Another example:
```