usdrt/scenegraph/usd/usdGeom/tokens.h

File members: usdrt/scenegraph/usd/usdGeom/tokens.h

// Copyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//
#pragma once

// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//
// This is an automatically generated file (by usdGenSchema.py).
// Do not hand-edit!
//
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
#include <usdrt/scenegraph/base/tf/token.h>

namespace usdrt
{

struct UsdGeomTokensType
{
    UsdGeomTokensType();
    const TfToken accelerations;
    const TfToken all;
    const TfToken angularVelocities;
    const TfToken axis;
    const TfToken basis;
    const TfToken bezier;
    const TfToken bilinear;
    const TfToken boundaries;
    const TfToken bounds;
    const TfToken box;
    const TfToken bspline;
    const TfToken cards;
    const TfToken catmullClark;
    const TfToken catmullRom;
    const TfToken clippingPlanes;
    const TfToken clippingRange;
    const TfToken closed;
    const TfToken constant;
    const TfToken cornerIndices;
    const TfToken cornerSharpnesses;
    const TfToken cornersOnly;
    const TfToken cornersPlus1;
    const TfToken cornersPlus2;
    const TfToken creaseIndices;
    const TfToken creaseLengths;
    const TfToken creaseSharpnesses;
    const TfToken cross;
    const TfToken cubic;
    const TfToken curveVertexCounts;
    const TfToken default_;
    const TfToken doubleSided;
    const TfToken edgeAndCorner;
    const TfToken edgeOnly;
    const TfToken elementSize;
    const TfToken elementType;
    const TfToken exposure;
    const TfToken extent;
    const TfToken extentsHint;
    const TfToken face;
    const TfToken faceVarying;
    const TfToken faceVaryingLinearInterpolation;
    const TfToken faceVertexCounts;
    const TfToken faceVertexIndices;
    const TfToken familyName;
    const TfToken focalLength;
    const TfToken focusDistance;
    const TfToken form;
    const TfToken fromTexture;
    const TfToken fStop;
    const TfToken guide;
    const TfToken guideVisibility;
    const TfToken height;
    const TfToken hermite;
    const TfToken holeIndices;
    const TfToken horizontalAperture;
    const TfToken horizontalApertureOffset;
    const TfToken ids;
    const TfToken inactiveIds;
    const TfToken indices;
    const TfToken inherited;
    const TfToken interpolateBoundary;
    const TfToken interpolation;
    const TfToken invisible;
    const TfToken invisibleIds;
    const TfToken knots;
    const TfToken left;
    const TfToken leftHanded;
    const TfToken length;
    const TfToken linear;
    const TfToken loop;
    const TfToken metersPerUnit;
    const TfToken modelApplyDrawMode;
    const TfToken modelCardGeometry;
    const TfToken modelCardTextureXNeg;
    const TfToken modelCardTextureXPos;
    const TfToken modelCardTextureYNeg;
    const TfToken modelCardTextureYPos;
    const TfToken modelCardTextureZNeg;
    const TfToken modelCardTextureZPos;
    const TfToken modelDrawMode;
    const TfToken modelDrawModeColor;
    const TfToken mono;
    const TfToken motionBlurScale;
    const TfToken motionNonlinearSampleCount;
    const TfToken motionVelocityScale;
    const TfToken none;
    const TfToken nonOverlapping;
    const TfToken nonperiodic;
    const TfToken normals;
    const TfToken open;
    const TfToken order;
    const TfToken orientation;
    const TfToken orientations;
    const TfToken origin;
    const TfToken orthographic;
    const TfToken partition;
    const TfToken periodic;
    const TfToken perspective;
    const TfToken pinned;
    const TfToken pivot;
    const TfToken points;
    const TfToken pointWeights;
    const TfToken positions;
    const TfToken power;
    const TfToken primvarsDisplayColor;
    const TfToken primvarsDisplayOpacity;
    const TfToken projection;
    const TfToken protoIndices;
    const TfToken prototypes;
    const TfToken proxy;
    const TfToken proxyPrim;
    const TfToken proxyVisibility;
    const TfToken purpose;
    const TfToken radius;
    const TfToken ranges;
    const TfToken render;
    const TfToken renderVisibility;
    const TfToken right;
    const TfToken rightHanded;
    const TfToken scales;
    const TfToken shutterClose;
    const TfToken shutterOpen;
    const TfToken size;
    const TfToken smooth;
    const TfToken stereoRole;
    const TfToken subdivisionScheme;
    const TfToken tangents;
    const TfToken triangleSubdivisionRule;
    const TfToken trimCurveCounts;
    const TfToken trimCurveKnots;
    const TfToken trimCurveOrders;
    const TfToken trimCurvePoints;
    const TfToken trimCurveRanges;
    const TfToken trimCurveVertexCounts;
    const TfToken type;
    const TfToken uForm;
    const TfToken uKnots;
    const TfToken unauthoredValuesIndex;
    const TfToken uniform;
    const TfToken unrestricted;
    const TfToken uOrder;
    const TfToken upAxis;
    const TfToken uRange;
    const TfToken uVertexCount;
    const TfToken varying;
    const TfToken velocities;
    const TfToken vertex;
    const TfToken verticalAperture;
    const TfToken verticalApertureOffset;
    const TfToken vForm;
    const TfToken visibility;
    const TfToken visible;
    const TfToken vKnots;
    const TfToken vOrder;
    const TfToken vRange;
    const TfToken vVertexCount;
    const TfToken width;
    const TfToken widths;
    const TfToken wrap;
    const TfToken x;
    const TfToken xformOpOrder;
    const TfToken y;
    const TfToken z;
    const std::vector<TfToken> allTokens;
};

inline UsdGeomTokensType::UsdGeomTokensType()
    : accelerations("accelerations"),
      all("all"),
      angularVelocities("angularVelocities"),
      axis("axis"),
      basis("basis"),
      bezier("bezier"),
      bilinear("bilinear"),
      boundaries("boundaries"),
      bounds("bounds"),
      box("box"),
      bspline("bspline"),
      cards("cards"),
      catmullClark("catmullClark"),
      catmullRom("catmullRom"),
      clippingPlanes("clippingPlanes"),
      clippingRange("clippingRange"),
      closed("closed"),
      constant("constant"),
      cornerIndices("cornerIndices"),
      cornerSharpnesses("cornerSharpnesses"),
      cornersOnly("cornersOnly"),
      cornersPlus1("cornersPlus1"),
      cornersPlus2("cornersPlus2"),
      creaseIndices("creaseIndices"),
      creaseLengths("creaseLengths"),
      creaseSharpnesses("creaseSharpnesses"),
      cross("cross"),
      cubic("cubic"),
      curveVertexCounts("curveVertexCounts"),
      default_("default"),
      doubleSided("doubleSided"),
      edgeAndCorner("edgeAndCorner"),
      edgeOnly("edgeOnly"),
      elementSize("elementSize"),
      elementType("elementType"),
      exposure("exposure"),
      extent("extent"),
      extentsHint("extentsHint"),
      face("face"),
      faceVarying("faceVarying"),
      faceVaryingLinearInterpolation("faceVaryingLinearInterpolation"),
      faceVertexCounts("faceVertexCounts"),
      faceVertexIndices("faceVertexIndices"),
      familyName("familyName"),
      focalLength("focalLength"),
      focusDistance("focusDistance"),
      form("form"),
      fromTexture("fromTexture"),
      fStop("fStop"),
      guide("guide"),
      guideVisibility("guideVisibility"),
      height("height"),
      hermite("hermite"),
      holeIndices("holeIndices"),
      horizontalAperture("horizontalAperture"),
      horizontalApertureOffset("horizontalApertureOffset"),
      ids("ids"),
      inactiveIds("inactiveIds"),
      indices("indices"),
      inherited("inherited"),
      interpolateBoundary("interpolateBoundary"),
      interpolation("interpolation"),
      invisible("invisible"),
      invisibleIds("invisibleIds"),
      knots("knots"),
      left("left"),
      leftHanded("leftHanded"),
      length("length"),
      linear("linear"),
      loop("loop"),
      metersPerUnit("metersPerUnit"),
      modelApplyDrawMode("model:applyDrawMode"),
      modelCardGeometry("model:cardGeometry"),
      modelCardTextureXNeg("model:cardTextureXNeg"),
      modelCardTextureXPos("model:cardTextureXPos"),
      modelCardTextureYNeg("model:cardTextureYNeg"),
      modelCardTextureYPos("model:cardTextureYPos"),
      modelCardTextureZNeg("model:cardTextureZNeg"),
      modelCardTextureZPos("model:cardTextureZPos"),
      modelDrawMode("model:drawMode"),
      modelDrawModeColor("model:drawModeColor"),
      mono("mono"),
      motionBlurScale("motion:blurScale"),
      motionNonlinearSampleCount("motion:nonlinearSampleCount"),
      motionVelocityScale("motion:velocityScale"),
      none("none"),
      nonOverlapping("nonOverlapping"),
      nonperiodic("nonperiodic"),
      normals("normals"),
      open("open"),
      order("order"),
      orientation("orientation"),
      orientations("orientations"),
      origin("origin"),
      orthographic("orthographic"),
      partition("partition"),
      periodic("periodic"),
      perspective("perspective"),
      pinned("pinned"),
      pivot("pivot"),
      points("points"),
      pointWeights("pointWeights"),
      positions("positions"),
      power("power"),
      primvarsDisplayColor("primvars:displayColor"),
      primvarsDisplayOpacity("primvars:displayOpacity"),
      projection("projection"),
      protoIndices("protoIndices"),
      prototypes("prototypes"),
      proxy("proxy"),
      proxyPrim("proxyPrim"),
      proxyVisibility("proxyVisibility"),
      purpose("purpose"),
      radius("radius"),
      ranges("ranges"),
      render("render"),
      renderVisibility("renderVisibility"),
      right("right"),
      rightHanded("rightHanded"),
      scales("scales"),
      shutterClose("shutter:close"),
      shutterOpen("shutter:open"),
      size("size"),
      smooth("smooth"),
      stereoRole("stereoRole"),
      subdivisionScheme("subdivisionScheme"),
      tangents("tangents"),
      triangleSubdivisionRule("triangleSubdivisionRule"),
      trimCurveCounts("trimCurve:counts"),
      trimCurveKnots("trimCurve:knots"),
      trimCurveOrders("trimCurve:orders"),
      trimCurvePoints("trimCurve:points"),
      trimCurveRanges("trimCurve:ranges"),
      trimCurveVertexCounts("trimCurve:vertexCounts"),
      type("type"),
      uForm("uForm"),
      uKnots("uKnots"),
      unauthoredValuesIndex("unauthoredValuesIndex"),
      uniform("uniform"),
      unrestricted("unrestricted"),
      uOrder("uOrder"),
      upAxis("upAxis"),
      uRange("uRange"),
      uVertexCount("uVertexCount"),
      varying("varying"),
      velocities("velocities"),
      vertex("vertex"),
      verticalAperture("verticalAperture"),
      verticalApertureOffset("verticalApertureOffset"),
      vForm("vForm"),
      visibility("visibility"),
      visible("visible"),
      vKnots("vKnots"),
      vOrder("vOrder"),
      vRange("vRange"),
      vVertexCount("vVertexCount"),
      width("width"),
      widths("widths"),
      wrap("wrap"),
      x("X"),
      xformOpOrder("xformOpOrder"),
      y("Y"),
      z("Z")
{
}

struct UsdGeomTokensTypeAccessor
{
    const UsdGeomTokensType* operator->()
    {
        static const UsdGeomTokensType tokens;
        return &tokens;
    }
};

// This is not great
static UsdGeomTokensTypeAccessor UsdGeomTokens;

}