Mapping of ShaderFX / Stingray PBS materials ​

// Stingray PBS export / import script
string $rootPath = "C:\\SimplygonExample\\";

// pipeline settings
string $pipelineFilePath = $rootPath + "\\Pipelines\\Aggregation_With_Baking_Stingray.json";

// "" = default, "d:\\TextureOutputFolder\\" = custom
string $textureOutputDirectory = $rootPath + "\\OutputTextures\\";

// drive to store temporary xml files (c might be protected)
string $xmlExportPath = $rootPath + "\\XMLTempFolder\\";

// populate material list with Stingray PBS materials
string $stingrayMaterials[] = `ls -type StingrayPBS`;

// create Simplygon shading networks for each Stingray material
string $inputMaterialString = "";
for($stingray_mat in $stingrayMaterials)
{
    if(size ($stingray_mat) == 0)
        continue;

    print ("\nStingray shader:\n Name: " + $stingray_mat + "\n");

    // if there is a normal map, make sure it is in Raw color space
    int $TEX_normal_map_enabled = `getAttr($stingray_mat + ".use_normal_map")`;
    if($TEX_normal_map_enabled)
    {
        string $normalNodes[] = `listConnections -type "bump2d" ($stingray_mat + ".TEX_normal_map")`;
        string $normalMaps[] = `listConnections -type "file" ($stingray_mat + ".TEX_normal_map")`;

        if(size($normalNodes) > 0)
        {
            string $furtherNormalMaps[] = `listConnections -type "file" $normalNodes[0]`;
            int $size = size($furtherNormalMaps);
            appendStringArray($normalMaps, $furtherNormalMaps, $size);
        }

        for ($nMap in $normalMaps)
        {
            string $filename = `getAttr($nMap + ".fileTextureName")`;
            print (" Normal map (" + $nMap + "): "  + $filename + "\n");

            // check color space for all textures connected to the normal map of this material
            string $currentColorSpace = `getAttr ($nMap + ".colorSpace")`;
            print (" Current color space: " + $currentColorSpace + "\n");

            if($currentColorSpace != "Raw")
            {
                string $availableColorSpaces[] = `colorManagementPrefs -q -inputSpaceNames`;
                if (stringArrayContains("Raw", $availableColorSpaces))
                {
                    setAttr ($nMap+".ignoreColorSpaceFileRules") 1;
                    setAttr ($nMap+".colorSpace") -type "string" "Raw";
                    print (" New color space: Raw\n");
                }
                else
                {
                    print ("Normal map with incorrect color space found but could not find a suitable color space, please check the color space setting for this texture!\n");
                }
            }

            int $NameBasedSearchWarning = false;
            string $result = `match "_n." $filename`;
            if($result == "_n.")
            {
                $NameBasedSearchWarning = true;
            }
            $result = `match "normals" $filename`;
            if($result == "normals")
            {
                $NameBasedSearchWarning = true;
            }
            if($NameBasedSearchWarning == true)
            {
                print (" Prediction (name based): most likely a normal map)\n");
            }
        }
    }

    int $bakeShaderProperties = true;

    float $uvOffsetX = 0.0;
    float $uvOffsetY = 0.0;

    float $uvScaleX = 1.0;
    float $uvScaleY = 1.0;

    float $baseColor[] = {0.5, 0.5, 0.5};
    float $baseColorDisplay[] = {0.5, 0.5, 0.5};

    float $metallicFactor = 0.0;
    float $roughnessFactor = 1.0;

    float $emissiveColor[] = {0.0, 0.0, 0.0};
    float $emissiveColorDisplay[] = {0.0, 0.0, 0.0};

    float $emissiveIntensity = 0.0;

    // read Stingray PBS shader properties
    if($bakeShaderProperties)
    {
        $uvOffsetX = `getAttr($stingray_mat + ".uv_offsetX")`;
        $uvOffsetY = `getAttr($stingray_mat + ".uv_offsetY")`;
        print(" Offset: " + $uvOffsetX + ", " + $uvOffsetY + "\n");

        $uvScaleX = `getAttr($stingray_mat + ".uv_scaleX")`;
        $uvScaleY = `getAttr($stingray_mat + ".uv_scaleY")`;
        print(" Scale: " + $uvScaleX + ", " + $uvScaleY + "\n");

        $baseColor = `getAttr($stingray_mat + ".base_color")`;
        print(" BaseColor: " + $baseColor[0] + ", " + $baseColor[1] + ", " + $baseColor[2] + "\n");

        $baseColorDisplay = `colorManagementConvert -toDisplaySpace $baseColor[0] $baseColor[1] $baseColor[2]`;
        print(" BaseColor (display): " + $baseColorDisplay[0] + ", " + $baseColorDisplay[1] + ", " + $baseColorDisplay[2] + "\n");

        $metallicFactor = `getAttr($stingray_mat + ".metallic")`;
        print(" MetallicFactor: " + $metallicFactor + "\n");

        $roughnessFactor = `getAttr($stingray_mat + ".roughness")`;
        print(" RoughnessFactor: " + $roughnessFactor + "\n");

        $emissiveColor = `getAttr($stingray_mat + ".emissive")`;
        print(" EmissiveColor: " + $emissiveColor[0] + ", " + $emissiveColor[1] + ", " + $emissiveColor[2] + "\n");

        $emissiveColorDisplay = `colorManagementConvert -toDisplaySpace $emissiveColor[0] $emissiveColor[1] $emissiveColor[2]`;
        print(" EmissiveColor (display): " + $emissiveColorDisplay[0] + ", " + $emissiveColorDisplay[1] + ", " + $emissiveColorDisplay[2] + "\n");

        $emissiveIntensity = `getAttr($stingray_mat + ".emissive_intensity")`;
        print(" EmissiveIntensity: " + $emissiveIntensity + "\n");
    }

    // create base color texture node if there is a map, otherwise a color node
    int $color_map_enabled = `getAttr($stingray_mat + ".use_color_map")`;
    if($color_map_enabled)
    {
        SimplygonShadingNetwork
        // create color texture node, point it to TEX_color_map
        -cn $stingray_mat TextureNode TEX_color_map

        // override uv channel
        -uva TEX_color_map map1

        // override sRGB
        -sa TEX_color_map false

        // connect texture node to simplygon material channel
        -sce $stingray_mat color TEX_color_map

        // override tiling and offset  
        -tmc $stingray_mat color TEX_color_map ($uvScaleX) ($uvScaleY)
        -omc $stingray_mat color TEX_color_map $uvOffsetX $uvOffsetY

        // export material channel templates to xml for later use
        -exf $stingray_mat color ($xmlExportPath + $stingray_mat + "_color.xml");
    }
    else
    {
        SimplygonShadingNetwork
        // create color node
        -cn $stingray_mat ColorNode baseColor

        // set the color to baseColorDisplay
        -sd $stingray_mat baseColor 0 $baseColorDisplay[0] $baseColorDisplay[1] $baseColorDisplay[2]

        // connect color node to simplygon material channel
        -sce $stingray_mat color baseColor

        // export material channel templates to xml for later use
        -exf $stingray_mat color ($xmlExportPath + $stingray_mat + "_color.xml");
    }

    // create metallic texture node if there is a map, otherwise a color node
    int $metallic_map_enabled = `getAttr($stingray_mat + ".use_metallic_map")`;
    if($metallic_map_enabled)
    {
        SimplygonShadingNetwork
        // create color texture node, point it to TEX_metallic_map
        -cn $stingray_mat TextureNode TEX_metallic_map

        // override uv channel
        -uva TEX_metallic_map map1

        // override sRGB
        -sa TEX_metallic_map false

        // connect texture node to simplygon material channel
        -sce $stingray_mat metallic TEX_metallic_map

        // override tiling and offset  
        -tmc $stingray_mat metallic TEX_metallic_map ($uvScaleX) ($uvScaleY)
        -omc $stingray_mat metallic TEX_metallic_map $uvOffsetX $uvOffsetY

        // export material channel templates to xml for later use
        -exf $stingray_mat metallic ($xmlExportPath + $stingray_mat + "_metallic.xml");
    }
    else
    {
        SimplygonShadingNetwork
        // create metallic color node
        -cn $stingray_mat ColorNode metallicColor
        -sd $stingray_mat metallicColor 0 $metallicFactor $metallicFactor $metallicFactor

        // connect color node to simplygon material channel
        -sce $stingray_mat metallic metallicColor

        // export material channel templates to xml for later use
        -exf $stingray_mat metallic ($xmlExportPath + $stingray_mat + "_metallic.xml");
    }

    // create roughness texture node if there is a map, otherwise a color node
    int $roughness_map_enabled = `getAttr($stingray_mat + ".use_roughness_map")`;
    if($roughness_map_enabled)
    {
        SimplygonShadingNetwork
        // create color texture node, point it to TEX_roughness_map
        -cn $stingray_mat TextureNode TEX_roughness_map

        // override uv channel
        -uva TEX_roughness_map map1

        // override sRGB
        -sa TEX_roughness_map false

        // connect texture node to simplygon material channel
        -sce $stingray_mat roughness TEX_roughness_map

        // override tiling and offset
        -tmc $stingray_mat roughness TEX_roughness_map ($uvScaleX) ($uvScaleY)
        -omc $stingray_mat roughness TEX_roughness_map $uvOffsetX $uvOffsetY

        // export material channel templates to xml for later use
        -exf $stingray_mat roughness ($xmlExportPath + $stingray_mat + "_roughness.xml");
    }
    else
    {
        SimplygonShadingNetwork
        // create roughness color node
        -cn $stingray_mat ColorNode roughnessColor
        -sd $stingray_mat roughnessColor 0 $roughnessFactor $roughnessFactor $roughnessFactor

        // connect texture node to simplygon material channel
        -sce $stingray_mat roughness roughnessColor

        // export material channel templates to xml for later use
        -exf $stingray_mat roughness ($xmlExportPath + $stingray_mat + "_roughness.xml");
    }

    // create emissive texture node if there is a map, otherwise a color node
    int $emissive_map_enabled = `getAttr($stingray_mat + ".use_emissive_map")`;
    if($emissive_map_enabled)
    {
        SimplygonShadingNetwork
        // create color texture node, point it to TEX_emissive_map
        -cn $stingray_mat TextureNode TEX_emissive_map

        // override uv channel
        -uva TEX_emissive_map map1

        // override sRGB
        -sa TEX_emissive_map false

        // connect texture node to simplygon material channel
        -sce $stingray_mat emissive TEX_emissive_map

        // override tiling and offset  
        -tmc $stingray_mat emissive TEX_emissive_map ($uvScaleX) ($uvScaleY)
        -omc $stingray_mat emissive TEX_emissive_map $uvOffsetX $uvOffsetY

        // export material channel templates to xml for later use
        -exf $stingray_mat emissive ($xmlExportPath + $stingray_mat + "_emissive.xml");
    }
    else
    {
        SimplygonShadingNetwork
        // create emissive color and multiply nodes
        -cn $stingray_mat ColorNode emissiveColor
        -cn $stingray_mat ColorNode emissiveIntensity
        -cn $stingray_mat MultiplyNode emissiveMultiply

        // set color values
        -sd $stingray_mat emissiveColor 0 $emissiveColorDisplay[0] $emissiveColorDisplay[1] $emissiveColorDisplay[2]
        -sd $stingray_mat emissiveIntensity 0 $emissiveIntensity $emissiveIntensity $emissiveIntensity

        // multiply emissive color with intensity
        -si $stingray_mat emissiveMultiply 0 emissiveColor
        -si $stingray_mat emissiveMultiply 1 emissiveIntensity

        // connect multiply node to simplygon material channel
        -sce $stingray_mat emissive emissiveMultiply

        // export material channel templates to xml for later use
        -exf $stingray_mat emissive ($xmlExportPath + $stingray_mat + "_emissive.xml");
    }

    SimplygonShadingNetwork
    // create color texture nodes, point them to
    // TEX_normal_map and TEX_normal_map
    -cn $stingray_mat TextureNode TEX_normal_map
    -cn $stingray_mat TextureNode TEX_ao_map

    // override uv channel
    -uva TEX_normal_map map1
    -uva TEX_ao_map map1

    // override sRGB
    -sa TEX_normal_map false
    -sa TEX_ao_map false

    // connect texture nodes to simplygon material channels
    -sce $stingray_mat normal TEX_normal_map
    -sce $stingray_mat ao TEX_ao_map

    // override tiling and offset
    -tmc $stingray_mat normal TEX_normal_map ($uvScaleX) ($uvScaleY)
    -omc $stingray_mat normal TEX_normal_map $uvOffsetX $uvOffsetY

    -tmc $stingray_mat ao TEX_ao_map ($uvScaleX) ($uvScaleY)
    -omc $stingray_mat ao TEX_ao_map $uvOffsetX $uvOffsetY

    // export material channel templates to xml for later use
    -exf $stingray_mat normal ($xmlExportPath + $stingray_mat + "_normal.xml")
    -exf $stingray_mat ao ($xmlExportPath + $stingray_mat + "_ao.xml");

    // append material name to string (for later use)
    $inputMaterialString += $stingray_mat + "|";
}

// parse arguments
string $arguments = "";
for($stingray_material in $stingrayMaterials)
{
    if(size ($stingray_material) == 0)
        continue;

    print ("\nStingray shader " + $stingray_material + " has the following maps:\n");

    // color map detection (can be skipped if channel always exist)
    int $hasTEX_color_map = false;
    int $TEX_color_map_enabled = `getAttr($stingray_material + ".use_color_map")`;
    if($TEX_color_map_enabled)
    {
        string $colorMaps[] = `listConnections -type "file" ($stingray_material + ".TEX_color_map")`;
        for ($dMap in $colorMaps)
        {
            string $filename = `getAttr($dMap + ".fileTextureName")`;
            $hasTEX_color_map = size($filename) > 0;
            print (" Color map (" + $dMap + "): "  + $filename + " (" + $hasTEX_color_map + ")\n");
        }
    }

    // metallic map detection (can be skipped if channel always exist)
    int $hasTEX_metallic_map = false;
    int $TEX_metallic_map_enabled = `getAttr($stingray_material + ".use_metallic_map")`;
    if($TEX_metallic_map_enabled)
    {
        string $metallicMaps[] = `listConnections -type "file" ($stingray_material + ".TEX_metallic_map")`;
        for ($dMap in $metallicMaps)
        {
            string $filename = `getAttr($dMap + ".fileTextureName")`;
            $hasTEX_metallic_map = size($filename) > 0;
            print (" Metallic map (" + $dMap + "): "  + $filename + " (" + $hasTEX_metallic_map + ")\n");
        }
    }

    // roughness map detection (can be skipped if channel always exist)
    int $hasTEX_roughness_map = false;
    int $TEX_roughness_map_enabled = `getAttr($stingray_material + ".use_roughness_map")`;
    if($TEX_roughness_map_enabled)
    {
        string $roughnessMaps[] = `listConnections -type "file" ($stingray_material + ".TEX_roughness_map")`;
        for ($dMap in $roughnessMaps)
        {
            string $filename = `getAttr($dMap + ".fileTextureName")`;
            $hasTEX_roughness_map = size($filename) > 0;
            print (" Roughness map (" + $dMap + "): "  + $filename + " (" + $hasTEX_roughness_map + ")\n");
        }
    }

    // emissive map detection (can be skipped if channel always exist)
    int $hasTEX_emissive_map = false;
    int $TEX_emissive_map_enabled = `getAttr($stingray_material + ".use_emissive_map")`;
    if($TEX_emissive_map_enabled)
    {
        string $emissiveMaps[] = `listConnections -type "file" ($stingray_material + ".TEX_emissive_map")`;
        for ($dMap in $emissiveMaps)
        {
            string $filename = `getAttr($dMap + ".fileTextureName")`;
            $hasTEX_emissive_map = size($filename) > 0;
            print (" Emissive map (" + $dMap + "): "  + $filename + " (" + $hasTEX_emissive_map + ")\n");
        }
    }

    // ao map detection (can be skipped if channel always exist)
    int $hasTEX_ao_map = false;
    int $TEX_ao_map_enabled = `getAttr($stingray_material + ".use_ao_map")`;
    if($TEX_ao_map_enabled)
    {
        string $aoMaps[] = `listConnections -type "file" ($stingray_material + ".TEX_ao_map")`;
        for ($dMap in $aoMaps)
        {
            string $filename = `getAttr($dMap + ".fileTextureName")`;
            $hasTEX_ao_map = size($filename) > 0;
            print (" Ao map (" + $dMap + "): "  + $filename + " (" + $hasTEX_ao_map + ")\n");
        }
    }

    // normal map detection (can be skipped if channel always exist)
    int $hasTEX_normal_map = false;
    int $TEX_normal_map_enabled = `getAttr($stingray_material + ".use_normal_map")`;
    if($TEX_normal_map_enabled)
    {
        string $normalNodes[] = `listConnections -type "bump2d" ($stingray_material + ".TEX_normal_map")`;
        string $normalMaps[] = `listConnections -type "file" ($stingray_material + ".TEX_normal_map")`;

        if(size($normalNodes) > 0)
        {
            string $furtherNormalMaps[] = `listConnections -type "file" $normalNodes[0]`;
            int $size = size($furtherNormalMaps);
            appendStringArray($normalMaps, $furtherNormalMaps, $size);
        }

        for ($nMap in $normalMaps)
        {
            string $filename = `getAttr($nMap + ".fileTextureName")`;
            $hasTEX_normal_map = size($filename) > 0;
            print (" Normal map (" + $nMap + "): "  + $filename + " (" + $hasTEX_normal_map + ")\n");
        }
    }

    // if a material channel always exists, with either a color node
    // or texture node (with connected texture), there is no need to
    // skip import. Baking of texture nodes without textures will fail!

    //if($hasTEX_color_map == true)
    {
        $arguments += " -ixf \"" + $stingray_material + "\" color \"" + ($xmlExportPath + $stingray_material + "_color.xml\"");
    }
    //if($hasTEX_metallic_map == true)
    {
        $arguments += " -ixf \"" + $stingray_material + "\" metallic \"" + ($xmlExportPath + $stingray_material + "_metallic.xml\"");
    }
    //if($hasTEX_roughness_map == true)
    {
        $arguments += " -ixf \"" + $stingray_material + "\" roughness \"" + ($xmlExportPath + $stingray_material + "_roughness.xml\"");
    }
    //if($hasTEX_emissive_map == true)
    {
        $arguments += " -ixf \"" + $stingray_material + "\" emissive \"" + ($xmlExportPath + $stingray_material + "_emissive.xml\"");
    }
    if($hasTEX_ao_map == true)
    {
        $arguments += " -ixf \"" + $stingray_material + "\" ao \"" + ($xmlExportPath + $stingray_material + "_ao.xml\"");
    }
    if($hasTEX_normal_map == true)
    {
        $arguments += " -ixf \"" + $stingray_material + "\" normal \"" + ($xmlExportPath + $stingray_material + "_normal.xml\"");
    }
}

// correct slashes
$arguments = substituteAllString($arguments, "\\", "\\\\");

// launch Simplygon and fetch the result
string $processedMeshes[] = eval("Simplygon -rsg -sf $pipelineFilePath -dgm -tod $textureOutputDirectory -asm $inputMaterialString" + $arguments);

// fetch lod names
int $lodIndex = 0;
string $materialNameArray[];
string $SGNameArray[];

for($m in $processedMeshes)
{
    // correct mesh names from Simplygon call
    $m = substituteAllString($m, "|", "");
    print ("\nMesh: " + $m + "\n");

    // offset new mesh along x-axis
    select -r $m;
    $transAttr = $m+".translateX";
    float $bbox[] = `exactWorldBoundingBox`;
    float $moveOffset = ($lodIndex+1)*($bbox[3]-$bbox[0])*1.1;

    setAttr -lock off $transAttr;
    move -r $moveOffset 0 0;

    string $material;

    // fetch material name for mesh,
    // start with checking for reused materials
    $reuseMaterials = `SimplygonQuery -rms $m`;
    if(size ($reuseMaterials) == 0)
    {
        print ("  Not reusing material.\n");
        $material = `SimplygonQuery -gmm $m`;
    }
    else
    {
        int $currentMaterialIndex = 0;
        int $isReusingMaterial = false;

        for($reuseMaterial in $reuseMaterials)
        {
            print ("  Checking material: " + $reuseMaterial + "\n");
            int $i = stringArrayFind( $reuseMaterial, 0, $materialNameArray );
            if($i < 0)
            {
                print ("    Reusing original material!\n");
                select -cl;
                $materialIds = `SimplygonQuery -gmi $m`;
                //print $materialIds;

                int $tid = 0;
                for($mid in $materialIds)
                {
                    if($mid == $currentMaterialIndex)
                    {
                        //print ("     Selecting triangle " + $tid + " for material " + $mid + "\n");
                        select -tgl ($m + ".f[" + $tid + "]");
                    }
                    $tid++;
                }

                print ("     Assigning material " + $reuseMaterial + " to selected triangles for mesh " + $m + "\n");
                sets -e -forceElement $reuseMaterial;
                select -cl;

                $lodIndex++;
                $currentMaterialIndex++;
                $isReusingMaterial = true;
                continue;
            }

            // material was found in lod chain, continuing
            string $nameOfMaterialNode = $SGNameArray[$i];

            // assign material to selected mesh
            select -r $m;
            if(size ($nameOfMaterialNode) != 0)
            {
                sets -e -forceElement $nameOfMaterialNode;
            }

            // offset new mesh along x-axis
            $lodIndex++;
            $currentMaterialIndex++;
            $isReusingMaterial = true;
            continue;
        }

        // if reuse, exit here
        if($isReusingMaterial == true)
        {
            continue;
        }
    }

    // if not reuse, create new (Stingray PBS) material
    print ("  Creating material: " + $material + "\n");

    // create material and matching SG node
    string $shader = `shadingNode -asShader StingrayPBS`;
    string $shaderSG = `sets -renderable true -noSurfaceShader true -empty -name ($shader + "SG")`;

    stringArrayInsertAtIndex($lodIndex, $SGNameArray, $shaderSG);
    stringArrayInsertAtIndex($lodIndex, $materialNameArray, $material);

    // connect shader to shaderSG
    connectAttr -f ( $shader + ".outColor" ) ( $shaderSG + ".surfaceShader" );
    shaderfx -sfxnode $shader -edit_string 6 "shaderresource" "core/stingray_renderer/shader_import/standard";

    // assign UV-set to the shader
    string $currentUVSet[] = `polyUVSet -q -currentUVSet $m`;

    // fetch channel names for mesh material
    $channels = `SimplygonQuery -gcm $material`;
    for($c in $channels)
    {
        // fetch texture path for channel
        print ("    Channel: " + $c + "\n");
        $filepath = `SimplygonQuery -gtc $material $c`;
        print ("      Texture: " + $filepath + "\n");

        // create texture nodes and link textures
        string $fileNode = `shadingNode -isColorManaged -asTexture file`;

        setAttr -type "string" ( $fileNode + ".fileTextureName" ) $filepath;
        if($c == "color")
        {
            setAttr ($shader + ".use_color_map") 1;
            connectAttr -force ($fileNode + ".outColor") ($shader + ".TEX_color_map");
        }
        else if($c == "metallic")
        {
            setAttr ($shader + ".use_metallic_map") 1;
            setAttr ($shader + ".metallic") 1.0;
            connectAttr -force ($fileNode + ".outColor") ($shader + ".TEX_metallic_map");
        }
        else if($c == "roughness")
        {
            setAttr ($shader + ".use_roughness_map") 1;
            setAttr ($shader + ".roughness") 1.0;
            connectAttr -force ($fileNode + ".outColor") ($shader + ".TEX_roughness_map");
        }
        else if($c == "emissive")
        {
            setAttr ($shader + ".use_emissive_map") 1;
            setAttr ($shader + ".emissive_intensity") 1.0;
            connectAttr -force ($fileNode + ".outColor") ($shader + ".TEX_emissive_map");
        }
        else if($c == "ao")
        {
            setAttr ($shader + ".use_ao_map") 1;
            connectAttr -force ($fileNode + ".outColor") ($shader + ".TEX_ao_map");
        }
        else if($c == "normal")
        {
            setAttr ($shader + ".use_normal_map") 1;
            connectAttr -force ($fileNode + ".outColor") ($shader + ".TEX_normal_map");

            // force colorspace, if possible
            string $currentColorSpace = `getAttr ($fileNode + ".colorSpace")`;
            if($currentColorSpace != "Raw")
            {
                string $availableColorSpaces[] = `colorManagementPrefs -q -inputSpaceNames`;
                if ( stringArrayContains("Raw", $availableColorSpaces) )
                {
                    setAttr ($fileNode+".ignoreColorSpaceFileRules") 1;
                    setAttr ($fileNode+".colorSpace") -type "string" "Raw";
                }
            }
        }
    }

    // assign material to selected mesh
    select -r $m;
    sets -e -forceElement $shaderSG;

    // offset new mesh along x-axis
    $lodIndex++;
}