Namespace-prefixed attributes are the correct approach for representing grouped or compound source data in OpenUSD. NVIDIA’s Learn OpenUSD data extraction guidance states that when source formats contain compound or grouped data types, such as structs, records, or grouped fields, namespace-prefixed attributes provide the convention for grouping related properties together in USD. It also states that USD does not have a native struct type, so namespace-prefixed attributes serve as the standard approach for representing this kind of grouped data.

Option B is correct because attributes such as acme:sensor:temperature, acme:sensor:humidity, and acme:sensor:pressure can express ownership and logical grouping while remaining ordinary USD attributes with valid scalar or array value types. NVIDIA’s custom properties lesson reinforces this pattern, explaining that namespace prefixes logically group related properties on a single prim and are especially useful when mapping structured data types from other formats into USD.

Option A is incomplete because arrays represent repeated values, not named compound fields. Option C is incorrect because USD does not provide a native struct attribute type. This aligns with Data Exchange → Data Extraction, Conceptual Data Mapping, Custom Properties, Namespace-Prefixed Attributes .

The correct method is my_prim.GetAttribute("size") because the question asks for a specific attribute , not a relationship or generic property. NVIDIA’s Learn OpenUSD material defines properties as the data-bearing namespace objects on prims and distinguishes two property categories: attributes and relationships . Attributes hold typed values, while relationships point to other objects in the scene description. NVIDIA’s Omniverse developer reference also states that Usd.Prim.GetAttribute() returns a Usd.Attribute, after which Usd.Attribute.Get() is used to resolve the actual authored or composed value.

Option A is therefore the precise API call. Option B is incorrect because GetRelationship() retrieves relationship properties, not value-bearing attributes. Option C is less specific: GetProperty("size") can retrieve either an attribute or relationship as a generic UsdProperty, requiring additional type handling. Option D is incorrect because primvars are accessed through schema-specific APIs such as UsdGeom.PrimvarsAPI, not directly as a general Usd.Prim method. This aligns with Pipeline Development → USD Python API, Property Access, Attributes, Relationships, and Scenegraph Authoring .

The composed value is [(0.2, 0.75, 0.1)]. The active variant selection on /World/Tree is foliage_color = "default", and the "default" variant contains no authored opinion for Canopy.primvars:displayColor. Therefore, the "evergreen" and "orange" variant opinions are not active and cannot contribute their color values. NVIDIA’s Learn OpenUSD variant-set guidance explains that a variant set provides alternative authored representations, but only the selected variant contributes to the composed result.

The remaining contributing opinion is the reference on def Cone "Canopy": references = [ < /_base_foliage_color > ]. References are composition arcs that bring scene description from a targeted prim into the destination prim without copying it. The referenced class prim /_base_foliage_color authors color3f[] primvars:displayColor = [(0.2, 0.75, 0.1)], so that value composes onto /World/Tree/Canopy. No stronger local or selected-variant opinion overrides it. This follows USD strength ordering, where opinions are resolved through composition arcs and the strongest applicable opinion wins. This aligns with Composition → References, Variant Sets, Selected Variants, and LIVERPS Strength Ordering .

The key distinction is addressability and representation. Native, or scenegraph, instancing preserves each instance as a prim in the composed scene hierarchy. Each instance root can have its own path, transform, metadata, and root-level refinements while sharing an implicit prototype generated from matching instanceable composition. OpenUSD’s scenegraph instancing documentation explains that prims bringing in common scene description through composition arcs can share those composed subgraphs rather than duplicating them per prim.

Point instancing, by contrast, is a vectorized representation. NVIDIA’s instancing guide states that point instancing represents repeated instances through array attributes such as positions, orientations, scales, prototype indices, and prototype relationships. It is more compact because it does not require a prim for each instance , but this comes with reduced flexibility and addressability.

Option D is correct because native instances remain individually addressable scenegraph prims, while point instances are addressed through array elements and IDs rather than unique prim paths. A reverses prototype behavior: native instancing uses implicit prototypes, while point instancing uses explicit prototype relationships. B and C impose restrictions that do not exist. This aligns with Content Aggregation → Scenegraph Instancing, PointInstancer, Prototypes, Addressability, and Scalable Repetition .

An edit target determines where authored opinions are written while working through the composed view of a stage. NVIDIA’s Learn OpenUSD stage material emphasizes that a stage is not simply a file; it is a unified scenegraph populated from multiple data sources called layers. ( docs.nvidia.com ) In that layered environment, a developer often edits a composed prim while needing the resulting opinion to land in a specific contributing layer, variant, or composition context.

OpenUSD defines this role through UsdEditTarget: edit targets allow work on the composed stage and its UsdPrim objects while specifying which contributing site in the composition network should receive the authored opinions. ( openusd.org )

Option C is correct because the edit target is the authoring destination, not a composition override mechanism. Option A is incorrect because USD does not automatically merge edits into all layers. Option B is incorrect because edits are not forced to the root layer; developers can target other valid layers or edit contexts. Option D is incorrect because setting an edit target does not disable sublayers or composition arcs. This aligns with Pipeline Development → Layer Authoring, Edit Targets, Non-Destructive Editing, Stage Workflows, and Collaborative Layer Stacks .

A standalone converter is appropriate when the conversion workflow should operate outside the DCC application. NVIDIA’s Learn OpenUSD Data Exchange lesson defines a standalone converter as a script, executable, or microservice dedicated to translating to and from another file format. It contrasts this with importers and exporters, which are implemented as part of a DCC application’s runtime or plugin system. ( docs.nvidia.com )

Option C is correct because if a developer cannot access the DCC’s SDK, plugin API, or runtime integration path, a native importer/exporter may not be feasible. A separate converter can still be built around accessible file-level data, command-line tools, services, or external APIs. Option D is also correct because standalone converters are well suited for automation, headless processing, farm execution, and batch conversion pipelines that do not belong inside an artist-facing DCC session. NVIDIA’s OpenUSD guidance also notes that data exchange implementations must account for different client needs, workflow performance, and content structures rather than assuming one implementation pattern fits all. ( docs.nvidia.com )

Option A is false because proprietary formats can also be supported by native plugins or file format plugins when appropriate access exists. Option B is false because fidelity depends on data mapping and implementation quality, not on whether the tool is standalone. This aligns with Data Exchange → Importers, Exporters, Standalone Converters, File Format Plugins, and Workflow Requirements .

ETL is useful for USD data exchange because it separates the problem into disciplined phases instead of forcing extraction, interpretation, optimization, and client-specific restructuring into one converter step. NVIDIA’s Learn OpenUSD data exchange guidance describes a two-phase approach, extract and transform, inspired by ETL. The extract phase should translate source data to OpenUSD as directly as possible, mapping source concepts to USD concepts to preserve the integrity and structure of the original data. The transform phase then applies optional changes such as user export options, content-structure changes, and optimizations for workflow or client performance.

Option B is correct because this separation of concerns makes converters easier to maintain, test, and adapt. Option D is correct because the pattern preserves source fidelity first, then permits controlled tailoring for specific downstream needs. Option A is incorrect because NVIDIA explicitly notes that data exchange is typically lossy and not every data model maps directly. Option C is incorrect because the guide states there is no single content structure suitable for every organization or workflow. This aligns with Data Exchange → Two-Phase Data Exchange, Data Extraction, Data Transformation, Export Options, and Pipeline Adaptability .

The valid model kind hierarchies are A, B, and E . NVIDIA’s Learn OpenUSD material defines group, assembly, and component as model kinds, while subcomponent is explicitly outside the model hierarchy. The hierarchy rule is that all ancestors of a component must be group or a subkind of group, such as assembly, and a component acts as a leaf or pruning point in the model hierarchy; therefore, it cannot contain descendant model kinds such as another component, group, or assembly. ( NVIDIA Docs )

A is valid because CarA is a component and every descendant has unset kind, so no nested model violates the component boundary. B is valid because CarA is an assembly, organizational containers use group, and the leaf model assets are component prims. E is valid because CarA is a component, and internal important parts are marked as subcomponent, which is permitted inside a component and does not count as a model kind. C is invalid because a component contains descendant component prims. D is invalid because Wheels (group) appears under a component, placing a model kind below a component boundary. This aligns with Content Aggregation → Asset Structure → Model Hierarchy → Model Kinds .

The immutable stage-opening concerns are the path resolver context and the variant fallback configuration used for unselected variants . The resolver context is bound when the stage is created or opened and is used for future asset-path resolution on that stage, regardless of what other resolver context may be bound elsewhere. The OpenUSD UsdStage API documentation describes this binding behavior during stage creation, making option C correct.

Option D is also correct because global variant fallback preferences are defined as preferences “used in new UsdStages.” Once a stage has been composed with its fallback preferences, changing global fallback settings affects newly opened stages, not the already-opened stage’s established fallback behavior.

Option A is incorrect because payload loading is mutable: Load(), Unload(), LoadAndUnload(), and SetLoadRules() modify the stage’s payload working set after opening. Option B is incorrect because layers can be muted and unmuted on an existing stage through MuteLayer(), UnmuteLayer(), and MuteAndUnmuteLayers(). This aligns with Pipeline Development → Stage Opening, Asset Resolution, Variant Fallbacks, Load Rules, and Layer Muting .

Setting instanceable = false on an instance root is a deinstancing operation. NVIDIA’s Learn OpenUSD instancing material explains that instanceable prims share composed data through implicit prototypes, and that scenegraph instances restrict sparse descendant overrides because instance proxies are not directly editable. In NVIDIA’s instance-refinement guidance, the three practical rules are: prototypes are not editable, instance proxies are not editable and local opinions are discarded, while the instanceable prim itself remains editable. ( docs.nvidia.com )

Therefore, when the targeted instance root is deinstanced, local opinions authored under that prim’s descendant paths can become effective because the subtree is no longer represented only through the shared prototype. USD must also recompose that hierarchy because changing instanceable changes whether the prim contributes to prototype sharing or composes its own local subtree. Option A is incorrect because disabling instanceable on one prim does not mutate metadata on other prims that previously shared the prototype. Option C describes the still-instanced behavior, not the deinstanced result. In the screenshot, the stem names /ParkingLot/Car_2 while options B and D name /ParkingLot/Car_1; the correct effects apply to the prim whose instanceable metadata is disabled. This aligns with Content Aggregation → Scenegraph Instancing, Instance Refinement, Deinstancing, and Recomposition .