notebooks/Build_Assets_With_Python_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a12712d8-0930-496e-abee-88b822e616d9",
   "metadata": {},
   "source": [
    "## **Preface**\n",
    "This guide aims to learn about USD asset creation with python, and build familiarty with USD Python Library. \n",
    "\n",
    "## **Prerequisites**\n",
    "Python examples in this guide requires only having `usd-core` library.\n",
    "\n",
    "### **Install the `usd-core` Python package**\n",
    "\n",
    "Install the [`usd-core`](https://pypi.org/project/usd-core/) Python package providing the core USD libraries. Note that it does not provide any of the optional plugins or imaging features from the complete USD distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "461e2e1d-a7d8-49c5-9236-215fd16573a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "! pip install usd-core\n",
    "\n",
    "# See https://pypi.org/project/usd-core/#history for a list of supported USD\n",
    "# versions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e476329-2e08-4d55-a184-d49b724e5778",
   "metadata": {},
   "source": [
    "## **USD Termnial commands**\n",
    "I'm using `usdview` command to examine my generated usd files.\n",
    "To avoid any headaches, I'm using `Houdini 19.5 Command Line Tools` which shipped with USD already.\n",
    "\n",
    "Alternatively, you can use \n",
    "- [pre-built USD library](https://developer.nvidia.com/usd#libraries-and-tools)\n",
    "- `usdview` shipped with Omniverse, [Get Omniverse](https://www.nvidia.com/en-us/omniverse/download/) then from `exchange` tab find `usdview`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70c3d878-af0d-4f49-bf31-441bba6df393",
   "metadata": {},
   "source": [
    "## **Build Assets with python**\n",
    "\n",
    "### **Warm-up**\n",
    "\n",
    "Let's create a simple asset as a warm-up where everything is defined in one USD layer.\n",
    "In this exercise:\n",
    "```\n",
    "{asset-name}.usda\n",
    "  └── Xform {asset-name}\n",
    "        ├── Variant Sets : [model, material]\n",
    "        ├── Scope Geo\n",
    "        |       └── Cube\n",
    "        |            ├── add scale property\n",
    "        |            └── append it to transform order property\n",
    "        ├── Scope Mtl\n",
    "        |        └── Red Material\n",
    "        |              ├── connect sufrace output to the output surface of Red Shader \n",
    "        |              └── Red Shader\n",
    "        |                    ├── set shader id\n",
    "        |                    ├── set diffuse color\n",
    "        |                    └── create output surface\n",
    "        ├── model Variant Set\n",
    "        |        └── one variant\n",
    "        |                └── over Geo\n",
    "        |                      └── over Cube\n",
    "        |                            └── set scale property\n",
    "        └── material Variant Set\n",
    "                └── one variant\n",
    "                        └── over Geo\n",
    "                              └── over Cube\n",
    "                                    ├── apply material binding api schema\n",
    "                                    └── set material binding\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "79d50f81-a1d1-44a8-ba67-3b90a089bcdd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#usda 1.0\n",
      "\n",
      "def Xform \"Cube_Asset\" (\n",
      "    variants = {\n",
      "        string material = \"red\"\n",
      "        string model = \"tall\"\n",
      "    }\n",
      "    prepend variantSets = [\"model\", \"material\"]\n",
      ")\n",
      "{\n",
      "    def Scope \"Geo\"\n",
      "    {\n",
      "        def Cube \"Cube\"\n",
      "        {\n",
      "            float3 xformOp:scale\n",
      "            uniform token[] xformOpOrder = [\"xformOp:scale\"]\n",
      "        }\n",
      "    }\n",
      "\n",
      "    def Scope \"Mtl\"\n",
      "    {\n",
      "        def Material \"Red\"\n",
      "        {\n",
      "            token outputs:surface.connect = </Cube_Asset/Mtl/Red/RedShader.outputs:surface>\n",
      "\n",
      "            def Shader \"RedShader\"\n",
      "            {\n",
      "                uniform token info:id = \"UsdPreviewSurface\"\n",
      "                color3f inputs:diffuseColor = (1, 0, 0)\n",
      "                token outputs:surface\n",
      "            }\n",
      "        }\n",
      "    }\n",
      "    variantSet \"model\" = {\n",
      "        \"tall\" {\n",
      "            over \"Geo\"\n",
      "            {\n",
      "                over \"Cube\"\n",
      "                {\n",
      "                    float3 xformOp:scale = (1, 2, 1)\n",
      "                }\n",
      "            }\n",
      "\n",
      "        }\n",
      "    }\n",
      "    variantSet \"material\" = {\n",
      "        \"red\" {\n",
      "            over \"Geo\"\n",
      "            {\n",
      "                over \"Cube\" (\n",
      "                    prepend apiSchemas = [\"MaterialBindingAPI\"]\n",
      "                )\n",
      "                {\n",
      "                    rel material:binding = </Cube_Asset/Mtl/Red>\n",
      "                }\n",
      "            }\n",
      "\n",
      "        }\n",
      "    }\n",
      "}\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pxr import Usd, Sdf, UsdGeom, UsdShade\n",
    "\n",
    "# Crteate Stage\n",
    "stage = Usd.Stage.CreateInMemory()\n",
    "\n",
    "# Create Main prim\n",
    "mainPrim = UsdGeom.Xform.Define(stage, '/Cube_Asset')\n",
    "\n",
    "# Create Geo Scope prim to group our geometry \n",
    "geoScope = UsdGeom.Scope.Define(stage, '/Cube_Asset/Geo')  \n",
    "\n",
    "# Create a Cube prim inside Geo\n",
    "cubePrim = UsdGeom.Cube.Define(stage, '/Cube_Asset/Geo/Cube')\n",
    "\n",
    "# Add scale property and append it to xform order\n",
    "scaleOp = cubePrim.AddScaleOp()  \n",
    "\n",
    "# Create model Variant Set inside main prim\n",
    "modelVariantSet = mainPrim.GetPrim().GetVariantSets().AddVariantSet('model')  \n",
    "\n",
    "# Add new model variant\n",
    "modelVariantSet.AddVariant('tall')  \n",
    "\n",
    "# Set model variant selection\n",
    "modelVariantSet.SetVariantSelection('tall')  \n",
    "\n",
    "# Modifiy current model variant selection\n",
    "with modelVariantSet.GetVariantEditContext():\n",
    "    # Set Y scale to 2 to my cube. it will automatically create over prims\n",
    "    scaleOp.Set((1, 2, 1))\n",
    "\n",
    "# Create Mtl Scope\n",
    "materialScope = UsdGeom.Scope.Define(stage, '/Cube_Asset/Mtl')\n",
    "\n",
    "# Create a material prim inside Mtl\n",
    "redMaterial = UsdShade.Material.Define(stage, '/Cube_Asset/Mtl/Red')\n",
    "\n",
    "# Create a shader prim inside the material prim\n",
    "redShaderPreview = UsdShade.Shader.Define(stage, '/Cube_Asset/Mtl/Red/RedShader')\n",
    "\n",
    "# Connect material surface to the surface output of the shader \n",
    "redMaterial.CreateSurfaceOutput().ConnectToSource(redShaderPreview.ConnectableAPI(), \"surface\")\n",
    "\n",
    "# Set Shader Id (material type)\n",
    "redShaderPreview.CreateIdAttr(\"UsdPreviewSurface\")\n",
    "\n",
    "# Set diffuse color to (1,0,0) which means red.\n",
    "redShaderPreview.CreateInput('diffuseColor', Sdf.ValueTypeNames.Color3f).Set((1, 0, 0))\n",
    "\n",
    "# Create material Variant Set\n",
    "materialVariantSet = mainPrim.GetPrim().GetVariantSets().AddVariantSet('material')\n",
    "\n",
    "# Add new material variant\n",
    "materialVariantSet.AddVariant('red')\n",
    "\n",
    "# Set material variant selection\n",
    "materialVariantSet.SetVariantSelection('red')\n",
    "\n",
    "# Modifiy current material variant selection\n",
    "with materialVariantSet.GetVariantEditContext():\n",
    "    # Apply material variant to my cube. it will automatically create over prims\n",
    "    cubePrim.GetPrim().ApplyAPI(\"MaterialBindingAPI\")\n",
    "\n",
    "    # Add material binding to my cube\n",
    "    UsdShade.MaterialBindingAPI(cubePrim.GetPrim()).Bind(redMaterial)\n",
    "\n",
    "# Print stage\n",
    "print(stage.GetRootLayer().ExportToString())\n",
    "\n",
    "# Export Stage to a usda file\n",
    "stage.GetRootLayer().Export('examples/build_assets_with_python_1/warmup/cube_asset.usda')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0db3e21a-1982-4671-9748-982bab2c9c51",
   "metadata": {},
   "source": [
    "**Result:**\n",
    "\n",
    "![](../resources/build_assets_with_python_1/warmup.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20f22956-754a-4334-a69a-d60fb544b5c2",
   "metadata": {},
   "source": [
    "### **Example 2 : variant Geo and variant Mtl layers as payload**\n",
    "> This is exactly the same last example in [USD_Asset_Structure](USD_Asset_Structure.ipynb)\n",
    "\n",
    "![](../resources/asset_structure/asset_structure.png)\n",
    "\n",
    "#### **Geo Layer**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "13d4539a-f867-47c7-92ed-29633572d393",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#usda 1.0\n",
      "\n",
      "def Xform \"Cube_Asset\" (\n",
      "    variants = {\n",
      "        string model = \"normal\"\n",
      "    }\n",
      "    prepend variantSets = \"model\"\n",
      ")\n",
      "{\n",
      "    def Scope \"Geo\"\n",
      "    {\n",
      "        def Cube \"Cube\"\n",
      "        {\n",
      "            float3 xformOp:scale\n",
      "            uniform token[] xformOpOrder = [\"xformOp:scale\"]\n",
      "        }\n",
      "    }\n",
      "    variantSet \"model\" = {\n",
      "        \"normal\" {\n",
      "            over \"Geo\"\n",
      "            {\n",
      "                over \"Cube\"\n",
      "                {\n",
      "                    float3 xformOp:scale = (1, 1, 1)\n",
      "                }\n",
      "            }\n",
      "\n",
      "        }\n",
      "        \"short\" {\n",
      "            over \"Geo\"\n",
      "            {\n",
      "                over \"Cube\"\n",
      "                {\n",
      "                    float3 xformOp:scale = (1, 0.5, 1)\n",
      "                }\n",
      "            }\n",
      "\n",
      "        }\n",
      "        \"tall\" {\n",
      "            over \"Geo\"\n",
      "            {\n",
      "                over \"Cube\"\n",
      "                {\n",
      "                    float3 xformOp:scale = (1, 2, 1)\n",
      "                }\n",
      "            }\n",
      "\n",
      "        }\n",
      "    }\n",
      "}\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create Geom Layer\n",
    "from pxr import Usd, UsdGeom\n",
    "\n",
    "stage = Usd.Stage.CreateInMemory()\n",
    "\n",
    "asset = UsdGeom.Xform.Define(stage, '/Cube_Asset')\n",
    "geo_scope_prim = UsdGeom.Scope.Define(stage, asset.GetPath().AppendPath('Geo'))\n",
    "cube_prim = UsdGeom.Cube.Define(stage, geo_scope_prim.GetPath().AppendPath('Cube'))\n",
    "\n",
    "# colorAttr = cubePrim.GetDisplayColorAttr()\n",
    "# colorAttr.Set([color])\n",
    "\n",
    "scale_op = cube_prim.AddScaleOp()\n",
    "\n",
    "# Add the VariantSet\n",
    "model_variant_set = asset.GetPrim().GetVariantSets().AddVariantSet('model')\n",
    "\n",
    "# Add variants to the VariantSet\n",
    "model_variant_set.AddVariant('tall')\n",
    "model_variant_set.AddVariant('short')\n",
    "model_variant_set.AddVariant('normal')\n",
    "\n",
    "# Set the variant values\n",
    "model_variant_set.SetVariantSelection('normal')\n",
    "with model_variant_set.GetVariantEditContext():\n",
    "    # colorAttr.Set([(1,0,0)])\n",
    "    scale_op.Set((1, 1, 1))\n",
    "\n",
    "model_variant_set.SetVariantSelection('short')\n",
    "with model_variant_set.GetVariantEditContext():\n",
    "    # colorAttr.Set([(0,1,0)])\n",
    "    scale_op.Set((1, 0.5, 1))\n",
    "\n",
    "model_variant_set.SetVariantSelection('tall')\n",
    "with model_variant_set.GetVariantEditContext():\n",
    "    # colorAttr.Set([(0,0,1)])\n",
    "    scale_op.Set((1, 2, 1))\n",
    "\n",
    "# Set the model variant selection to normal\n",
    "model_variant_set.SetVariantSelection('normal')\n",
    "\n",
    "\n",
    "print(stage.GetRootLayer().ExportToString())\n",
    "stage.GetRootLayer().Export('examples/build_assets_with_python_1/asset_1_variant_geo_variant_mtl/geo.usda')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c91b2ae0-46de-4667-a404-8123d9d3b3ae",
   "metadata": {},
   "source": [
    "#### **Mtl Layer**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6561006c-bbd5-4dc5-8782-f59a90f0455f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#usda 1.0\n",
      "\n",
      "def Xform \"Cube_Asset\" (\n",
      "    variants = {\n",
      "        string material = \"red\"\n",
      "    }\n",
      "    prepend variantSets = \"material\"\n",
      ")\n",
      "{\n",
      "    def Scope \"Mtl\"\n",
      "    {\n",
      "        def Material \"Red\"\n",
      "        {\n",
      "            token outputs:surface.connect = </Cube_Asset/Mtl/Red/Red_Shader.outputs:surface>\n",
      "\n",
      "            def Shader \"Red_Shader\"\n",
      "            {\n",
      "                uniform token info:id = \"UsdPreviewSurface\"\n",
      "                color3f inputs:diffuseColor = (1, 0, 0)\n",
      "                token outputs:surface\n",
      "            }\n",
      "        }\n",
      "\n",
      "        def Material \"Green\"\n",
      "        {\n",
      "            token outputs:surface.connect = </Cube_Asset/Mtl/Green/Green_Shader.outputs:surface>\n",
      "\n",
      "            def Shader \"Green_Shader\"\n",
      "            {\n",
      "                uniform token info:id = \"UsdPreviewSurface\"\n",
      "                color3f inputs:diffuseColor = (0, 1, 0)\n",
      "                token outputs:surface\n",
      "            }\n",
      "        }\n",
      "\n",
      "        def Material \"Blue\"\n",
      "        {\n",
      "            token outputs:surface.connect = </Cube_Asset/Mtl/Blue/Blue_Shader.outputs:surface>\n",
      "\n",
      "            def Shader \"Blue_Shader\"\n",
      "            {\n",
      "                uniform token info:id = \"UsdPreviewSurface\"\n",
      "                color3f inputs:diffuseColor = (0, 0, 1)\n",
      "                token outputs:surface\n",
      "            }\n",
      "        }\n",
      "    }\n",
      "    variantSet \"material\" = {\n",
      "        \"blue\" {\n",
      "            over \"Geo\"\n",
      "            {\n",
      "                over \"Cube\" (\n",
      "                    prepend apiSchemas = [\"MaterialBindingAPI\"]\n",
      "                )\n",
      "                {\n",
      "                    rel material:binding = </Cube_Asset/Mtl/Blue>\n",
      "                }\n",
      "            }\n",
      "\n",
      "        }\n",
      "        \"green\" {\n",
      "            over \"Geo\"\n",
      "            {\n",
      "                over \"Cube\" (\n",
      "                    prepend apiSchemas = [\"MaterialBindingAPI\"]\n",
      "                )\n",
      "                {\n",
      "                    rel material:binding = </Cube_Asset/Mtl/Green>\n",
      "                }\n",
      "            }\n",
      "\n",
      "        }\n",
      "        \"red\" {\n",
      "            over \"Geo\"\n",
      "            {\n",
      "                over \"Cube\" (\n",
      "                    prepend apiSchemas = [\"MaterialBindingAPI\"]\n",
      "                )\n",
      "                {\n",
      "                    rel material:binding = </Cube_Asset/Mtl/Red>\n",
      "                }\n",
      "            }\n",
      "\n",
      "        }\n",
      "    }\n",
      "}\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create Material Layer\n",
    "# Material X won't be used in this example as it's not available inside usd-core.\n",
    "from pxr import Usd, Sdf, UsdGeom, UsdShade\n",
    "\n",
    "def create_material(parent_prim, mat_name, color_value): \n",
    "    material = UsdShade.Material.Define(stage, parent_prim.GetPath().AppendPath('{0}'.format(mat_name)) )\n",
    "    shader_preview = UsdShade.Shader.Define(stage, material.GetPath().AppendPath('{0}_Shader'.format(mat_name)))\n",
    "    material.CreateSurfaceOutput().ConnectToSource(shader_preview.ConnectableAPI(), \"surface\")\n",
    "    shader_preview.CreateIdAttr(\"UsdPreviewSurface\")\n",
    "    shader_preview.CreateInput('diffuseColor',Sdf.ValueTypeNames.Color3f).Set(color_value)\n",
    "\n",
    "    return material\n",
    "\n",
    "\n",
    "stage = Usd.Stage.CreateInMemory()\n",
    "asset = UsdGeom.Xform.Define(stage, '/Cube_Asset')\n",
    "mtl_scope_prim = UsdGeom.Scope.Define(stage, asset.GetPath().AppendPath('Mtl'))\n",
    "\n",
    "# Create materials\n",
    "red_material   = create_material(mtl_scope_prim, \"Red\"  , (1, 0, 0))\n",
    "green_material = create_material(mtl_scope_prim, \"Green\", (0, 1, 0))\n",
    "blue_material  = create_material(mtl_scope_prim, \"Blue\" , (0, 0, 1))\n",
    "\n",
    "# Material variants are different binding variants.\n",
    "material_variant_set = asset.GetPrim().GetVariantSets().AddVariantSet('material')\n",
    "\n",
    "variants = {\n",
    "    'red'   : red_material,\n",
    "    'green' : green_material,\n",
    "    'blue'  : blue_material\n",
    "}\n",
    "\n",
    "for variant_name, variant_value in variants.items() :\n",
    "    material_variant_set.AddVariant(variant_name)\n",
    "    material_variant_set.SetVariantSelection(variant_name)\n",
    "    with material_variant_set.GetVariantEditContext():\n",
    "        # Create geo prim override inside the variant.\n",
    "        cube_prim = stage.OverridePrim(asset.GetPath().AppendPath('Geo/Cube'))  # Same prim hierarchy as in geo.usda\n",
    "        cube_prim.ApplyAPI(\"MaterialBindingAPI\")\n",
    "        UsdShade.MaterialBindingAPI(cube_prim).Bind(variant_value)  # add material binding to geo override\n",
    "\n",
    "# Set the material variant selection to red\n",
    "material_variant_set.SetVariantSelection('red')\n",
    "\n",
    "print(stage.GetRootLayer().ExportToString())\n",
    "stage.GetRootLayer().Export('examples/build_assets_with_python_1/asset_1_variant_geo_variant_mtl/mtl.usda')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "709765f7-00b4-4a2a-bf05-18594c79fdb4",
   "metadata": {},
   "source": [
    "#### **Payload layer**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "a4f97010-b8f3-4655-861b-5fb841f5dffa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#usda 1.0\n",
      "\n",
      "def Xform \"Cube_Asset\" (\n",
      "    prepend references = [\n",
      "        @./geo.usda@</Cube_Asset>,\n",
      "        @./mtl.usda@</Cube_Asset>\n",
      "    ]\n",
      ")\n",
      "{\n",
      "}\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Payload\n",
    "from pxr import Usd, Sdf, UsdGeom, UsdShade\n",
    "    \n",
    "name = \"payload\"\n",
    "stage = Usd.Stage.CreateInMemory()\n",
    "asset = UsdGeom.Xform.Define(stage, '/Cube_Asset')\n",
    "\n",
    "asset.GetPrim().GetReferences().AddReference('./geo.usda', '/Cube_Asset')\n",
    "asset.GetPrim().GetReferences().AddReference('./mtl.usda', '/Cube_Asset')\n",
    "\n",
    "print(stage.GetRootLayer().ExportToString())\n",
    "stage.GetRootLayer().Export('examples/build_assets_with_python_1/asset_1_variant_geo_variant_mtl/payload.usda')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0a4dbe3-02d7-433c-8741-3a9fcb596197",
   "metadata": {},
   "source": [
    "#### **Asset layer**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "29564f63-2010-4171-b8e3-3593ee1f14b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#usda 1.0\n",
      "\n",
      "def Xform \"Cube_Asset\" (\n",
      "    prepend payload = @./payload.usda@</Cube_Asset>\n",
      "    variants = {\n",
      "        string material = \"red\"\n",
      "        string model = \"normal\"\n",
      "    }\n",
      "    prepend variantSets = [\"model\", \"material\"]\n",
      ")\n",
      "{\n",
      "    variantSet \"model\" = {\n",
      "        \"normal\" {\n",
      "\n",
      "        }\n",
      "        \"short\" {\n",
      "\n",
      "        }\n",
      "        \"tall\" {\n",
      "\n",
      "        }\n",
      "    }\n",
      "    variantSet \"material\" = {\n",
      "        \"blue\" {\n",
      "\n",
      "        }\n",
      "        \"green\" {\n",
      "\n",
      "        }\n",
      "        \"red\" {\n",
      "\n",
      "        }\n",
      "    }\n",
      "}\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create asset with payload and variant selections\n",
    "from pxr import Usd, Sdf, UsdGeom\n",
    "\n",
    "\n",
    "stage = Usd.Stage.CreateInMemory()\n",
    "asset = UsdGeom.Xform.Define(stage, '/Cube_Asset')\n",
    "\n",
    "# Add payload\n",
    "asset.GetPrim().GetPayloads().AddPayload('./payload.usda', '/Cube_Asset')\n",
    "\n",
    "variants = {\n",
    "    'model' : ['normal', 'short', 'tall'],\n",
    "    'material' : ['red', 'green', 'blue']\n",
    "}\n",
    "\n",
    "# Loft variants\n",
    "for variant_set_name, variants_list in variants.items():\n",
    "    variant_set = asset.GetPrim().GetVariantSets().AddVariantSet(variant_set_name)\n",
    "    for variant in variants_list:\n",
    "        variant_set.AddVariant(variant)\n",
    "        \n",
    "    variant_set.SetVariantSelection(variants_list[0])\n",
    "\n",
    "print(stage.GetRootLayer().ExportToString())\n",
    "stage.GetRootLayer().Export('examples/build_assets_with_python_1/asset_1_variant_geo_variant_mtl/cube_asset.usda')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6734cbc1-68b5-4bb2-94e7-f48b469f741b",
   "metadata": {},
   "source": [
    "**Result**\n",
    "It's the exact same result as example 4 in Asset structure 1.\n",
    "![](../resources/build_assets_with_python_1/asset_1_variant_geo_variant_mtl.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4eeda8a2-5e38-4943-8865-0618f989a8b6",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}