Datasets:

pe-nlp

/

ov-kit-files-filtered-dedup-py

like 0

Follow

PE-NLP 14

ft-lab/omniverse_sample_scripts/Nucleus/existPath.py

# See : https://docs.omniverse.nvidia.com/py/kit/source/extensions/omni.client/docs/index.html import asyncio import omni.client # Check for the existence of the specified path. async def existPath (path : str): (result, entry) = await omni.client.stat_async(path) if result == omni.client.Result.ERROR_NOT_FOUND: print("Does not exist : " + path) return print("Exist : " + path) # Awaiting results. async def _ocl_existPath (path : str): (result, entry) = await omni.client.stat_async(path) if result == omni.client.Result.ERROR_NOT_FOUND: return False return True def ocl_existPath (path : str): loop = asyncio.get_event_loop() return loop.run_until_complete(_ocl_existPath(path)) # ------------------------------------------. path1 = "omniverse://localhost/Users/test" asyncio.ensure_future(existPath(path1)) path2 = "omniverse://localhost/Users/test/xxx.usd" asyncio.ensure_future(existPath(path2)) if ocl_existPath(path1): print("Exist : " + path1) else: print("Does not exist : " + path1)

Python

ft-lab/omniverse_sample_scripts/Nucleus/listFiles.py

# See : https://docs.omniverse.nvidia.com/py/kit/source/extensions/omni.client/docs/index.html import asyncio import omni.client # Lists files in the specified path. async def listFiles (_depth : int, _path : str): (result, entries) = await omni.client.list_async(_path) if result != omni.client.Result.OK: return for entry in entries: # Skip for Channel file. if (entry.flags & omni.client.ItemFlags.IS_CHANNEL) != 0: continue name = entry.relative_path if name == "" or name.find(".") == 0: continue path = _path + "/" + name isFolder = (entry.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN) != 0 msg = "" for i in range(_depth): msg += " " if isFolder: msg += "[" + name + "]" else: msg += name msg += " " if (entry.flags & omni.client.ItemFlags.READABLE_FILE) != 0: msg += " [R]" if (entry.flags & omni.client.ItemFlags.WRITEABLE_FILE) != 0: msg += " [W]" if (entry.flags & omni.client.ItemFlags.CAN_LIVE_UPDATE) != 0: msg += " [LiveUpdate]" if not isFolder: msg += f" {entry.size} bytes" print(msg) if isFolder: await listFiles(_depth + 1, path) # -----------------------------------------------. path1 = "omniverse://localhost/Users/test" asyncio.ensure_future(listFiles(0, path1))

Python

ft-lab/omniverse_sample_scripts/Nucleus/ReadImageFile.py

# See : https://docs.omniverse.nvidia.com/py/kit/source/extensions/omni.client/docs/index.html import io import omni.client from PIL import Image result, vers, content = omni.client.read_file("omniverse://localhost/Users/test/xxx.png") if result != omni.client.Result.ERROR_NOT_FOUND: image_data = memoryview(content).tobytes() image = Image.open(io.BytesIO(image_data)) # Show Image. image.show() # Save Image. #image.save("C:\\temp\\xxx.png")

Python

ft-lab/omniverse_sample_scripts/Nucleus/FileCopy.py

# See : https://docs.omniverse.nvidia.com/py/kit/source/extensions/omni.client/docs/index.html import asyncio import omni.client # The following should be rewritten for your environment. srcURL = "K:\\NVIDIA_omniverse\\images\\tile_image.png" dstURL = "omniverse://localhost/test/tile_image.png" # Copy a file or folder. # When copying is complete, proceed. result = omni.client.copy(srcURL, dstURL) if result == omni.client.Result.OK: print("success !") else: print("failed ...")

Python

ft-lab/omniverse_sample_scripts/Physics/RayCast.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import random import omni.physx # Get stage. stage = omni.usd.get_context().get_stage() # Y-Up. UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y) # Get default prim. defaultPrim = stage.GetDefaultPrim() defaultPrimPath = defaultPrim.GetPath().pathString # Physics scene definition. scene = UsdPhysics.Scene.Define(stage, defaultPrimPath + '/physicsScene') scene.CreateGravityDirectionAttr().Set(Gf.Vec3f(0.0, -1.0, 0.0)) scene.CreateGravityMagnitudeAttr().Set(981.0) # --------------------------------------------. # Create cube. # --------------------------------------------. def CreateCube (name : str, pos : Gf.Vec3f, scale : Gf.Vec3f): path = defaultPrimPath + '/cubes' prim = stage.GetPrimAtPath(path) if prim.IsValid() == False: UsdGeom.Xform.Define(stage, path) cubePath = path + '/' + name cubeGeom = UsdGeom.Cube.Define(stage, cubePath) # Set cube size. cubeGeom.CreateSizeAttr(10.0) # Set color. cubeGeom.CreateDisplayColorAttr([(0.0, 1.0, 0.0)]) # Set position. UsdGeom.XformCommonAPI(cubeGeom).SetTranslate((pos[0], pos[1], pos[2])) # Set scale. UsdGeom.XformCommonAPI(cubeGeom).SetScale((scale[0], scale[1], scale[2])) # Physics settings. cubePrim = stage.GetPrimAtPath(cubePath) UsdPhysics.CollisionAPI.Apply(cubePrim) # --------------------------------------------. # Create red sphere. # --------------------------------------------. def CreateRedSphere (name : str, pos : Gf.Vec3f, radius : float): path = defaultPrimPath + '/spheres' prim = stage.GetPrimAtPath(path) if prim.IsValid() == False: UsdGeom.Xform.Define(stage, path) spherePath = path + '/' + name sphereGeom = UsdGeom.Sphere.Define(stage, spherePath) # Set radius. sphereGeom.CreateRadiusAttr(radius) # Set color. sphereGeom.CreateDisplayColorAttr([(1.0, 0.0, 0.0)]) # Set position. UsdGeom.XformCommonAPI(sphereGeom).SetTranslate((pos[0], pos[1], pos[2])) # ------------------------------------------------------. # Create cubes. areaV = 100.0 cubeScale = 1.0 for i in range(50): posX = (random.random() - 0.5) * areaV posY = (random.random() - 0.5) * (areaV * 0.1) posZ = (random.random() - 0.5) * areaV + 100.0 pos = Gf.Vec3f(posX, posY, posZ) scale = Gf.Vec3f(cubeScale, cubeScale, cubeScale) name = 'cube_' + str(i) CreateCube(name, pos, scale) # Remove spheres. path = defaultPrimPath + '/spheres' prim = stage.GetPrimAtPath(path) if prim.IsValid(): stage.RemovePrim(path) # Callback for Rayhit. # rayhit works during animation playback. sphereIndex = 0 def ray_hit (hit): global sphereIndex print("distance : " + str(hit.distance)) print("Hit position : " + str(hit.position)) print("Hit normal : " + str(hit.normal)) print("Collision prim path : " + str(hit.collision)) # Get collision prim. prim = stage.GetPrimAtPath(hit.collision) print(" name : " + str(prim.GetName())) print("-----------------------------") # Create sphere. name = "sphere_" + str(sphereIndex) CreateRedSphere(name, hit.position, 1.0) sphereIndex += 1 for i in range(100): # Ray position. rayPos = Gf.Vec3f(0, 0, 0) # Ray direction. dx = (random.random() - 0.5) * 0.3 dy = (random.random() - 0.5) * 0.3 dz = 1.0 rayDir = Gf.Vec3f(dx, dy, dz).GetNormalized() # Ray distance. distance = 10000.0 # raycast. omni.physx.get_physx_scene_query_interface().raycast_all(rayPos, rayDir, distance, ray_hit)

Python

ft-lab/omniverse_sample_scripts/Physics/RigidBody/rigidbody_benchmark.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import math import random # Get stage. g_stage = omni.usd.get_context().get_stage() # Y-Up. UsdGeom.SetStageUpAxis(g_stage, UsdGeom.Tokens.y) # Physics scene definition. scene = UsdPhysics.Scene.Define(g_stage, "/physicsScene") scene.CreateGravityDirectionAttr().Set(Gf.Vec3f(0.0, -1.0, 0.0)) scene.CreateGravityMagnitudeAttr().Set(981.0) # Create Xform. g_basePath = '/World/spheres' xformPrim = UsdGeom.Xform.Define(g_stage, g_basePath) # --------------------------------------------------------. # Create ground. # --------------------------------------------------------. def createGround (): # Create cube. path = '/World/ground' cubeGeom = UsdGeom.Cube.Define(g_stage, path) # Set color. cubeGeom.CreateDisplayColorAttr([(0.2, 0.2, 0.2)]) # Set position. UsdGeom.XformCommonAPI(cubeGeom).SetTranslate((0.0, -5.0, 0.0)) # Set scale. UsdGeom.XformCommonAPI(cubeGeom).SetScale((200.0, 10, 200.0)) # Create collider. objPrim = g_stage.GetPrimAtPath(path) UsdPhysics.CollisionAPI.Apply(objPrim) # --------------------------------------------------------. # Create sphere. # @param[in] index serial number. # @param[in] radius radius of sphere. # @param[in] wPos world position (x, y, z). # @param[in] colorV color (red, green, blue). # --------------------------------------------------------. def createSphere(index, radius, wPos, colorV): # Create sphere. name = 'sphere_' + str(index) path = g_basePath + '/' + name spherePrim = UsdGeom.Sphere.Define(g_stage, path) # Set radius. spherePrim.CreateRadiusAttr(radius) # Set color. spherePrim.CreateDisplayColorAttr([colorV]) objPrim = g_stage.GetPrimAtPath(path) # Set position. UsdGeom.XformCommonAPI(spherePrim).SetTranslate(wPos) # Create collider. UsdPhysics.CollisionAPI.Apply(objPrim) UsdPhysics.MeshCollisionAPI(objPrim).CreateApproximationAttr("boundingSphere") UsdPhysics.MeshCollisionAPI.Apply(objPrim) # Rigid body. rigidBodyAPI = UsdPhysics.RigidBodyAPI.Apply(objPrim) # --------------------------------------------------------. # Create cube. # @param[in] wPos world position (x, y, z). # @param[in] wSize size (x, y, z). # --------------------------------------------------------. def createCube (index, wPos, wSize): name = 'cube_' + str(index) path = '/World/' + name cubePrim = UsdGeom.Cube.Define(g_stage, path) # Set cube size. cubePrim.CreateSizeAttr(1.0) # Set color. cubePrim.CreateDisplayColorAttr([(0.2, 0.2, 0.2)]) # Set position. UsdGeom.XformCommonAPI(cubePrim).SetTranslate((wPos[0], wPos[1], wPos[2])) # Set scale. UsdGeom.XformCommonAPI(cubePrim).SetScale((wSize[0], wSize[1], wSize[2])) # Create collider. objPrim = g_stage.GetPrimAtPath(path) UsdPhysics.CollisionAPI.Apply(objPrim) # --------------------------------------------------------. # Create wall. # --------------------------------------------------------. def createWall (): createCube(0, [-200.0, 25.0, 0.0], [ 10.0, 50.0, 400.0]) createCube(1, [ 200.0, 25.0, 0.0], [ 10.0, 50.0, 400.0]) createCube(2, [ 0.0, 25.0, -200.0], [400.0, 50.0, 10.0]) createCube(3, [ 0.0, 25.0, 200.0], [400.0, 50.0, 10.0]) # -----------------------------------------------------------. # -----------------------------------------------------------. # Create ground. createGround() # Create wall. createWall() # Create spheres. sR = 5.0 dd = 15.0 sCount = 16 dMin = dd * (float)(sCount) * 0.5 i = 0 fy = 30.0 for y in range(10): fz = -dMin for z in range(sCount): fx = -dMin for x in range(sCount): colR = random.random() colG = random.random() colB = random.random() dx = random.random() * 5.0 dz = random.random() * 5.0 createSphere(i, sR, (fx + dx, fy, fz + dz), (colR, colG, colB)) i = i + 1 fx += dd fz += dd fy += dd

Python

ft-lab/omniverse_sample_scripts/Physics/RigidBody/rigidBody_01.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import math import random # Get stage. g_stage = omni.usd.get_context().get_stage() # Y-Up. UsdGeom.SetStageUpAxis(g_stage, UsdGeom.Tokens.y) # Physics scene definition. scene = UsdPhysics.Scene.Define(g_stage, "/physicsScene") scene.CreateGravityDirectionAttr().Set(Gf.Vec3f(0.0, -1.0, 0.0)) scene.CreateGravityMagnitudeAttr().Set(981.0) # Create Xform. g_basePath = '/World/spheres' xformPrim = UsdGeom.Xform.Define(g_stage, g_basePath) # --------------------------------------------------------. # Create ground. # --------------------------------------------------------. def createGround (): # Create cube. path = '/World/ground' cubeGeom = UsdGeom.Cube.Define(g_stage, path) # Set color. cubeGeom.CreateDisplayColorAttr([(0.2, 0.2, 0.2)]) # Set position. UsdGeom.XformCommonAPI(cubeGeom).SetTranslate((0.0, -5.0, 0.0)) # Set scale. UsdGeom.XformCommonAPI(cubeGeom).SetScale((200.0, 10, 200.0)) # Create collider. objPrim = g_stage.GetPrimAtPath(path) UsdPhysics.CollisionAPI.Apply(objPrim) # --------------------------------------------------------. # Create sphere. # @param[in] index serial number. # @param[in] radius radius of sphere. # @param[in] wPos world position (x, y, z). # @param[in] colorV color (red, green, blue). # --------------------------------------------------------. def createSphere(index, radius, wPos, colorV): # Create sphere. name = 'sphere_' + str(index) path = g_basePath + '/' + name spherePrim = UsdGeom.Sphere.Define(g_stage, path) # Set radius. spherePrim.CreateRadiusAttr(radius) # Set color. spherePrim.CreateDisplayColorAttr([colorV]) objPrim = g_stage.GetPrimAtPath(path) # Set position. UsdGeom.XformCommonAPI(spherePrim).SetTranslate(wPos) # Create collider. UsdPhysics.CollisionAPI.Apply(objPrim) UsdPhysics.MeshCollisionAPI(objPrim).CreateApproximationAttr("boundingSphere") UsdPhysics.MeshCollisionAPI.Apply(objPrim) # Rigid body. rigidBodyAPI = UsdPhysics.RigidBodyAPI.Apply(objPrim) # -----------------------------------------------------------. # -----------------------------------------------------------. # Create ground. createGround() # Create spheres. r = 100.0 sR = 10.0 rCount = 32 fV = 0.0 fVD = 2.0 * math.pi / (float)(rCount) fy = 50.0 fyD = 1.0 for i in range(200): fx = r * math.cos(fV) fz = r * math.sin(fV) colR = random.random() colG = random.random() colB = random.random() createSphere(i, sR, (fx, fy, fz), (colR, colG, colB)) fV += fVD fy += fyD if (i & 15) == 15: r *= 0.9 sR *= 0.9

Python

ft-lab/omniverse_sample_scripts/Physics/Joint/simpleJoint02.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Y-Up. UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y) rootPath = '/World' # Physics scene definition. scene = UsdPhysics.Scene.Define(stage, rootPath + '/physicsScene') scene.CreateGravityDirectionAttr().Set(Gf.Vec3f(0.0, -1.0, 0.0)) scene.CreateGravityMagnitudeAttr().Set(981.0) hPos = 15.0 # --------------------------------------------. # cube0. # --------------------------------------------. cube0Path = rootPath + '/cube0' cube0Geom = UsdGeom.Cube.Define(stage, cube0Path) # Set cube size. cube0Geom.CreateSizeAttr(10.0) # Set color. cube0Geom.CreateDisplayColorAttr([(0.0, 1.0, 0.0)]) # Set position. UsdGeom.XformCommonAPI(cube0Geom).SetTranslate((0.0, hPos, 0.0)) # Set scale. UsdGeom.XformCommonAPI(cube0Geom).SetScale((2.0, 0.5, 0.5)) # --------------------------------------------. # cube1. # --------------------------------------------. cube1Path = rootPath + '/cube1' cube1Geom = UsdGeom.Cube.Define(stage, cube1Path) # Set cube size. cube1Geom.CreateSizeAttr(10.0) # Set color. cube1Geom.CreateDisplayColorAttr([(0.0, 0.0, 1.0)]) # Set position. UsdGeom.XformCommonAPI(cube1Geom).SetTranslate((21.0, hPos, 0.0)) # Set scale. UsdGeom.XformCommonAPI(cube1Geom).SetScale((2.0, 0.5, 0.5)) # --------------------------------------------. # cube2. # --------------------------------------------. cube2Path = rootPath + '/cube2' cube2Geom = UsdGeom.Cube.Define(stage, cube2Path) # Set cube size. cube2Geom.CreateSizeAttr(10.0) # Set color. cube2Geom.CreateDisplayColorAttr([(0.0, 1.0, 1.0)]) # Set position. UsdGeom.XformCommonAPI(cube2Geom).SetTranslate((42.0, hPos, 0.0)) # Set scale. UsdGeom.XformCommonAPI(cube2Geom).SetScale((2.0, 0.5, 0.5)) # --------------------------------------------. # Physics settings. # --------------------------------------------. # cube0 : static body cube0Prim = stage.GetPrimAtPath(cube0Path) UsdPhysics.CollisionAPI.Apply(cube0Prim) # cube1 : dynamic body cube1Prim = stage.GetPrimAtPath(cube1Path) UsdPhysics.CollisionAPI.Apply(cube1Prim) UsdPhysics.RigidBodyAPI.Apply(cube1Prim) # cube2 : dynamic body cube2Prim = stage.GetPrimAtPath(cube2Path) UsdPhysics.CollisionAPI.Apply(cube2Prim) UsdPhysics.RigidBodyAPI.Apply(cube2Prim) # ----------------------------------------. # Setup joint. # ----------------------------------------. jointPath = rootPath + '/revoluteJoint' revoluteJoint = UsdPhysics.RevoluteJoint.Define(stage, jointPath) # define revolute joint axis and its limits, defined in degrees revoluteJoint.CreateAxisAttr("Z") revoluteJoint.CreateLowerLimitAttr(-50.0) revoluteJoint.CreateUpperLimitAttr(50.0) # define revolute joint bodies revoluteJoint.CreateBody0Rel().SetTargets([cube0Path]) revoluteJoint.CreateBody1Rel().SetTargets([cube1Path]) # define revolute joint local poses for bodies revoluteJoint.CreateLocalPos0Attr().Set(Gf.Vec3f(5.25, 0.0, 0.0)) revoluteJoint.CreateLocalRot0Attr().Set(Gf.Quatf(1.0)) revoluteJoint.CreateLocalPos1Attr().Set(Gf.Vec3f(-5.25, 0.0, 0.0)) revoluteJoint.CreateLocalRot1Attr().Set(Gf.Quatf(1.0)) # set break force/torque revoluteJoint.CreateBreakForceAttr().Set(1e20) revoluteJoint.CreateBreakTorqueAttr().Set(1e20) # optionally add angular drive for example angularDriveAPI = UsdPhysics.DriveAPI.Apply(stage.GetPrimAtPath(jointPath), "angular") angularDriveAPI.CreateTypeAttr("force") angularDriveAPI.CreateMaxForceAttr(100.0) angularDriveAPI.CreateTargetVelocityAttr(1.0) angularDriveAPI.CreateDampingAttr(100.0) angularDriveAPI.CreateStiffnessAttr(0.0) # ----------------------------------------. # Setup joint2. # ----------------------------------------. jointPath2 = rootPath + '/revoluteJoint2' revoluteJoint2 = UsdPhysics.RevoluteJoint.Define(stage, jointPath2) # define revolute joint axis and its limits, defined in degrees revoluteJoint2.CreateAxisAttr("Z") revoluteJoint2.CreateLowerLimitAttr(-50.0) revoluteJoint2.CreateUpperLimitAttr(50.0) # define revolute joint bodies revoluteJoint2.CreateBody0Rel().SetTargets([cube1Path]) revoluteJoint2.CreateBody1Rel().SetTargets([cube2Path]) # define revolute joint local poses for bodies revoluteJoint2.CreateLocalPos0Attr().Set(Gf.Vec3f(5.25, 0.0, 0.0)) revoluteJoint2.CreateLocalRot0Attr().Set(Gf.Quatf(1.0)) revoluteJoint2.CreateLocalPos1Attr().Set(Gf.Vec3f(-5.25, 0.0, 0.0)) revoluteJoint2.CreateLocalRot1Attr().Set(Gf.Quatf(1.0)) # set break force/torque revoluteJoint2.CreateBreakForceAttr().Set(1e20) revoluteJoint2.CreateBreakTorqueAttr().Set(1e20) # optionally add angular drive for example #angularDriveAPI2 = UsdPhysics.DriveAPI.Apply(stage.GetPrimAtPath(jointPath2), "angular") #angularDriveAPI2.CreateTypeAttr("force") #angularDriveAPI2.CreateMaxForceAttr(100.0) #angularDriveAPI2.CreateTargetVelocityAttr(1.0) #angularDriveAPI2.CreateDampingAttr(100.0) #angularDriveAPI2.CreateStiffnessAttr(0.0)

Python

ft-lab/omniverse_sample_scripts/Physics/Gear/gear_01.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf, UsdSkel, PhysxSchema import math # Get stage. g_stage = omni.usd.get_context().get_stage() # gear path. gear_basePath = '/World/gears' # Y-Up. UsdGeom.SetStageUpAxis(g_stage, UsdGeom.Tokens.y) xformCache = UsdGeom.XformCache(0) # -------------------------------------------------------. # Calculate normal. # -------------------------------------------------------. def calcTriangleNormal (v1 : Gf.Vec3d, v2 : Gf.Vec3d, v3 : Gf.Vec3d): e1 = v2 - v1 e2 = v3 - v2 e1 = Gf.Vec4f(e1[0], e1[1], e1[2],1.0) e2 = Gf.Vec4f(e2[0], e2[1], e2[2],1.0) e3 = Gf.HomogeneousCross(e1, e2) n = Gf.Vec3d(e3[0], e3[1], e3[2]) return n.GetNormalized() # -------------------------------------------------------. # Attach thickness. # @param[in] primPath Target Prim path. # @param[in] thickness Thickness. # -------------------------------------------------------. def AttachThickness (primPath : str, thickness : float): prim = g_stage.GetPrimAtPath(primPath) if prim.IsValid() == False: return if prim.GetTypeName() != 'Mesh': return m = UsdGeom.Mesh(prim) # Number of faces. faceVCouList = m.GetFaceVertexCountsAttr().Get() faceCou = len(faceVCouList) if faceCou == 0: return normalsList = m.GetNormalsAttr().Get() normalsCou = len(normalsList) if normalsCou == 0: return normalV = normalsList[0] versList = m.GetPointsAttr().Get() versCou = len(versList) if versCou < 3: return faceVIList = m.GetFaceVertexIndicesAttr().Get() faceVICou = len(faceVIList) # Stores the face number for each vertex. vFList = [[]] * (versCou) for i in range(versCou): vFList[i] = [] index = 0 for i in range(len(faceVCouList)): faceVCou = faceVCouList[i] for j in range(faceVCou): vI = faceVIList[index + j] vFList[vI].append(i) index += faceVCou faceIndicesList = [[]] * faceCou for i in range(faceCou): faceIndicesList[i] = [] # Rearrange the vertex indices per face. index = 0 for i in range(faceCou): faceVCou = faceVCouList[i] for j in range(faceVCou): faceIndicesList[i].append(faceVIList[index + j]) index += faceVCou # Create a list of independent edges. edgesList = [] for i in range(faceCou): faceVCou = faceVCouList[i] for j in range(faceVCou): vI1 = faceIndicesList[i][j] vI2 = faceIndicesList[i][(j + 1) % faceVCou] chkF = False cI = -1 for k in range(len(edgesList)): if (edgesList[k][0] == vI1 and edgesList[k][1] == vI2) or (edgesList[k][0] == vI2 and edgesList[k][1] == vI1): chkF = True cI = k break if chkF == False: edgesList.append([vI1, vI2, 1]) else: cou = edgesList[cI][2] edgesList[cI] = [vI1, vI2, cou + 1] edgesOneList = [] for p in edgesList: if p[2] == 1: edgesOneList.append([p[0], p[1]]) # Create a symmetrical face. faceVCouList2 = [0] * (faceCou * 2) normalsList2 = [(0.0, 0.0, 0.0)] * (normalsCou * 2) versList2 = [(0.0, 0.0, 0.0)] * (versCou * 2) faceVIList2 = [0] * (faceVICou * 2) for i in range(faceCou): faceVCouList2[i] = faceVCouList[i] faceVCouList2[i + faceCou] = faceVCouList[i] for i in range(faceVICou): faceVIList2[i] = faceVIList[i] faceVIList2[i + faceVICou] = faceVIList[faceVICou - i - 1] + versCou for i in range(normalsCou): normalsList2[i] = normalsList[i] normalsList2[i + normalsCou] = -normalsList[i] for i in range(versCou): versList2[i] = versList[i] n = normalsList[i] versList2[i + versCou] = versList[i] - (n * thickness) # Create side faces. vIndex = len(versList2) for edgeI in edgesOneList: e1 = edgeI[0] e2 = edgeI[1] i1 = e1 i2 = e2 i3 = e1 + versCou i4 = e2 + versCou v1 = versList2[i2] v2 = versList2[i1] v3 = versList2[i3] v4 = versList2[i4] n = calcTriangleNormal(v1, v2, v3) faceVCouList2.append(4) for j in range(4): normalsList2.append(n) versList2.append(v1) versList2.append(v2) versList2.append(v3) versList2.append(v4) for j in range(4): faceVIList2.append(vIndex + j) vIndex += 4 m.CreatePointsAttr(versList2) m.CreateNormalsAttr(normalsList2) m.CreateFaceVertexCountsAttr(faceVCouList2) m.CreateFaceVertexIndicesAttr(faceVIList2) # -------------------------------------------------------. # Create gear. # @param[in] name Prim name. # @param[in] gearR Radius of gear. # @param[in] filletCount Number of gear divisions. # @param[in] filletHeight Fillet height. # @param[in] gearWidth Gear width. # @param[in] position position. # -------------------------------------------------------. def CreateGear (name : str, gearR : float, filletCount : int, filletHeight : float, gearWidth : float, position : Gf.Vec3f): angle = 360.0 / filletCount # Angle of one tooth. # Calculate the length of one tooth on the circumference. D = (gearR * math.sin((angle / 2.0) * math.pi / 180.0)) * 2 dHalf = D * 0.5 dQuarter = D * 0.25 centerV = Gf.Vec3d(0, 0, 0) versList = [] versList.append(centerV) faceIndexList = [] maxVCou = 1 + (5 * filletCount) index = 1 aV = 0.0 for i in range(filletCount): # Vertices of a single tooth. vDirX = math.cos(aV * math.pi / 180.0) vDirY = math.sin(aV * math.pi / 180.0) v2X = -vDirY v2Y = vDirX vD = Gf.Vec3d(vDirX, vDirY, 0) vCrossD = Gf.Vec3d(v2X, v2Y, 0) vCenter = vD * gearR v1 = vCenter - (vCrossD * dHalf) v2 = v1 + (vCrossD * dQuarter) v3 = v2 + (vD * filletHeight) v4 = v3 + (vCrossD * dHalf) v5 = v4 - (vD * filletHeight) v6 = v5 + (vCrossD * dQuarter) dd = D * 0.1 vCD = vCrossD * dd v3 += vCD v4 -= vCD v2 -= vCD v5 += vCD versList.append(v1) versList.append(v2) versList.append(v3) versList.append(v4) versList.append(v5) faceIndexList.append(0) faceIndexList.append(index) faceIndexList.append(index + 1) faceIndexList.append(index + 2) faceIndexList.append(index + 3) faceIndexList.append(index + 4) if index + 5 >= maxVCou: faceIndexList.append(1) else: faceIndexList.append(index + 5) index += 5 aV += angle # Create mesh. pathName = "/World/gears" prim = g_stage.GetPrimAtPath(pathName) if prim.IsValid() == False: UsdGeom.Xform.Define(g_stage, pathName) pathMeshName0 = pathName + '/' + name pathMeshName = pathMeshName0 index = 0 while True: pathMeshName = pathMeshName0 if index > 0: pathMeshName += '_' + str(index) prim = g_stage.GetPrimAtPath(pathMeshName) if prim.IsValid() == False: break index += 1 meshGeom = UsdGeom.Mesh.Define(g_stage, pathMeshName) # Set vertices. stVersList = [] stNormalList = [] for i in range(len(versList)): stVersList.append((versList[i][0], versList[i][1], versList[i][2])) stNormalList.append((0, 0, 1)) meshGeom.CreatePointsAttr(stVersList) # Set normals. meshGeom.CreateNormalsAttr(stNormalList) # Set face vertex count. faceVCouList = [] for i in range(filletCount): faceVCouList.append(7) meshGeom.CreateFaceVertexCountsAttr(faceVCouList) # Set face vertex indices. meshGeom.CreateFaceVertexIndicesAttr(faceIndexList) # Set position. UsdGeom.XformCommonAPI(meshGeom).SetTranslate((position[0], position[1], position[2])) # Set rotation. UsdGeom.XformCommonAPI(meshGeom).SetRotate((0.0, 0.0, 0.0), UsdGeom.XformCommonAPI.RotationOrderXYZ) # Set scale. UsdGeom.XformCommonAPI(meshGeom).SetScale((1.0, 1.0, 1.0)) # Attach thickness. if gearWidth > 0.0: AttachThickness(pathMeshName, gearWidth) # ------------------------------------------ # Get prim center position. # @param[in] primPath Prim path. # @return position(Gf.Vec3f) # ------------------------------------------ def GetPrimCenter (primPath : str): prim = g_stage.GetPrimAtPath(primPath) if prim.IsValid() == False: return globalPose = xformCache.GetLocalToWorldTransform(prim) translate, rotation, scale = UsdSkel.DecomposeTransform(globalPose) return translate # ------------------------------------------ # Set RigidBody on gear. # ------------------------------------------ def SetRigidBodyOnGear (primPath : str, index : int): prim = g_stage.GetPrimAtPath(primPath) if prim.IsValid() == False: return physicsAPI = UsdPhysics.RigidBodyAPI.Apply(prim) UsdPhysics.MassAPI.Apply(prim) # Create collider. UsdPhysics.CollisionAPI.Apply(prim) UsdPhysics.MeshCollisionAPI(prim).CreateApproximationAttr("convexHull") UsdPhysics.MeshCollisionAPI.Apply(prim) pos = GetPrimCenter(primPath) # revolute joint path = gear_basePath + '/revoluteJoint_' + str(index) revoluteJoint = UsdPhysics.RevoluteJoint.Define(g_stage, path) revoluteJoint.CreateAxisAttr("Z") revoluteJoint.CreateBody1Rel().SetTargets([primPath]) revoluteJoint.CreateLocalPos0Attr().Set(pos) revoluteJoint.CreateLocalRot0Attr().Set(Gf.Quatf(1.0)) revoluteJoint.CreateLocalPos1Attr().Set(Gf.Vec3f(0.0, 0.0, 0.0)) revoluteJoint.CreateLocalRot1Attr().Set(Gf.Quatf(1.0)) # ----------------------------------------------- # Radius. radius1 = 5.0 radius2 = 10.0 radius3 = 6.25 # Create Gears. CreateGear("gear", radius1, 24, 1.0, 1.0, Gf.Vec3f(0, 0, 0)) CreateGear("gear_1", radius2, 48, 1.0, 1.0, Gf.Vec3f(16.3, 0.72, 0)) CreateGear("gear_2", radius3, 30, 1.0, 1.0, Gf.Vec3f(0.0, -12.6, 0)) # gear1 path. gear1_path = gear_basePath + '/gear' # gear2 path. gear2_path = gear_basePath + '/gear_1' # gear3 path. gear3_path = gear_basePath + '/gear_2' # Physics scene definition. scene = UsdPhysics.Scene.Define(g_stage, "/physicsScene") scene.CreateGravityDirectionAttr().Set(Gf.Vec3f(0.0, -1.0, 0.0)) scene.CreateGravityMagnitudeAttr().Set(981.0) gear1_prim = g_stage.GetPrimAtPath(gear1_path) pos1 = GetPrimCenter(gear1_path) # Set RigidBody on gear. SetRigidBodyOnGear(gear1_path, 0) SetRigidBodyOnGear(gear2_path, 1) SetRigidBodyOnGear(gear3_path, 2) # add angular drive. revolute0_path = gear_basePath + "/revoluteJoint_0" revolute1_path = gear_basePath + "/revoluteJoint_1" revolute2_path = gear_basePath + "/revoluteJoint_2" # gear joint (0-1) gearJoint = PhysxSchema.PhysxPhysicsGearJoint.Define(g_stage, gear_basePath+"/gearJoint_0_1") gearJoint.CreateBody0Rel().SetTargets([gear1_path]) gearJoint.CreateBody1Rel().SetTargets([gear2_path]) gearJoint.CreateGearRatioAttr(radius1/radius2) gearJoint.CreateHinge0Rel().SetTargets([revolute0_path]) gearJoint.CreateHinge1Rel().SetTargets([revolute1_path]) # gear joint (0-2) gearJoint2 = PhysxSchema.PhysxPhysicsGearJoint.Define(g_stage, gear_basePath+"/gearJoint_0_2") gearJoint2.CreateBody0Rel().SetTargets([gear1_path]) gearJoint2.CreateBody1Rel().SetTargets([gear3_path]) gearJoint2.CreateGearRatioAttr(radius1/radius3) gearJoint2.CreateHinge0Rel().SetTargets([revolute0_path]) gearJoint2.CreateHinge1Rel().SetTargets([revolute2_path])

Python

ft-lab/omniverse_sample_scripts/PostProcessing/ChangePostProcessing.py

from pxr import Usd, UsdGeom, UsdShade, Sdf, Gf, Tf import omni.kit # Change Post Processing parameter. omni.kit.commands.execute("ChangeSetting", path="rtx/post/lensFlares/enabled", value=True) omni.kit.commands.execute("ChangeSetting", path="rtx/post/lensFlares/flareScale", value=0.2)

Python

ft-lab/omniverse_sample_scripts/UI/DragAndDrop/dropTest.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import omni.ui # Create new window. my_window = omni.ui.Window("Drop test window", width=300, height=200) # ------------------------------------------. with my_window.frame: sField = None # Enable Drop. def drop_accept(url): return True # Called at Drop event. def drop (uiField, event): # prim path. vPath = event.mime_data # Get stage. stage = omni.usd.get_context().get_stage() # Get prim. if Sdf.Path(vPath): prim = stage.GetPrimAtPath(vPath) if prim.IsValid(): # Set string. uiField.model.set_value(vPath) # Create window UI. with omni.ui.VStack(height=0): with omni.ui.Placer(offset_x=8, offset_y=8): omni.ui.Label("Please drop Prim below.") with omni.ui.Placer(offset_x=8, offset_y=0): omni.ui.Spacer(height=4) with omni.ui.Placer(offset_x=8, offset_y=0): sField = omni.ui.StringField(width=240, height=14, style={"color": 0xffffffff}) sField.set_accept_drop_fn(drop_accept) sField.set_drop_fn(lambda a, w=sField: drop(w, a))

Python

ft-lab/omniverse_sample_scripts/UI/DrawImage/drawImageWithPIL.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import omni.ui import omni.kit.app import carb.events import asyncio import math import itertools # PIL exists in "kit/extscore/omni.kit.pip_archive/pip_prebundle". from PIL import Image, ImageDraw, ImageFont # Get main window viewport. window = omni.ui.Window('Viewport') # ref : omni.kit.window.images extension.py # ------------------------------------------. # Managing overlay image. # ------------------------------------------. class OverlayImageBuffer: _width = 256 _height = 256 _byte_provider = None _byte_data = None def __init__(self): self._width = 256 self._height = 256 self._byte_provider = None self._byte_data = None def startup (self, width : int, height : int): self._byte_provider = omni.ui.ByteImageProvider() self._width = width self._height = height # default format omni.ui.TextureFormat.RGBA8_UNORM. self._byte_data = [0] * (4 * self._width * self._height) self._byte_provider.set_bytes_data(self._byte_data, [self._width, self._height]) def update (self): self._byte_provider.set_bytes_data(self._byte_data, [self._width, self._height]) # ------------------------------------------. # Draw image with PIL. # ------------------------------------------. class DrawImageWithPIL: _timeCount = 0 _image = None _draw = None _overlayImageBuffer = None def __init__(self): self._image = None self._draw = None self._overlayImageBuffer = None def __del__(self): self._image = None self._draw = None def getWidth (self): return self._overlayImageBuffer._width def getHeight (self): return self._overlayImageBuffer._height def getByteProvider (self): return self._overlayImageBuffer._byte_provider def startup (self, width : int, height : int): # Create new image. self._image = Image.new("RGBA", (width, height), (0, 0, 0, 0)) self._draw = ImageDraw.Draw(self._image) self._overlayImageBuffer = OverlayImageBuffer() self._overlayImageBuffer.startup(width, height) def draw (self): # Draw rectangle (fill). self._draw.rectangle((0, 0, self._image.width, self._image.height), fill=(0, 0, 0, 0)) # Draw rectangle (fill). self._draw.rectangle((100, 100, 200, 200), fill=(255, 0, 0)) # Draw rectangle. self._draw.rectangle((100, 220, 200, 320), outline=(0, 0, 255), width=1) # Draw line. self._draw.line((0, 0, self._image.width, self._image.height), fill=(0, 255, 0), width=2) # Draw circle. self._draw.ellipse((100, 400, 150, 450), outline=(0, 0, 255), width=2) # Draw circle (fill). self._draw.ellipse((280, 300, 380, 400), fill=(0, 0, 255)) def update (self): self.draw() # Get image data(RGBA buffer). imgD = self._image.getdata() # Converting a 2d array to a 1d array. self._overlayImageBuffer._byte_data = list(itertools.chain.from_iterable(imgD)) # Update omni.ui.ByteImageProvider. self._overlayImageBuffer.update() # ------------------------------------------. # Update event. # ------------------------------------------. _drawImageWithPIL = None _img1 = None def on_update(e: carb.events.IEvent): global _drawImageWithPIL global _img1 if _drawImageWithPIL == None: _drawImageWithPIL = DrawImageWithPIL() _drawImageWithPIL.startup(512, 512) _drawImageWithPIL.update() with window.frame: with omni.ui.VStack(height=0): with omni.ui.Placer(offset_x=8, offset_y=8): _img1 = omni.ui.ImageWithProvider(_drawImageWithPIL.getByteProvider(), width=_drawImageWithPIL.getWidth(), height=_drawImageWithPIL.getHeight()) # ------------------------------------------. # Register for update events. # To clear the event, specify "subs=None". subs = omni.kit.app.get_app().get_update_event_stream().create_subscription_to_pop(on_update, name="Test update")

Python

ft-lab/omniverse_sample_scripts/UI/DrawImage/drawImage.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import omni.ui import omni.kit.app import carb.events import asyncio import math # Get main window viewport. window = omni.ui.Window('Viewport') # ref : omni.kit.window.images extension.py # ------------------------------------------. # Managing overlay image. # ------------------------------------------. class OverlayImageBuffer: _width = 256 _height = 256 _byte_provider = None _timeCount = 0 def __init__(self): self._timeCount = 0 self._width = 512 self._height = 256 self._byte_provider = None def startup (self): self._byte_provider = omni.ui.ByteImageProvider() def update (self): # default format omni.ui.TextureFormat.RGBA8_UNORM. byte_data = [0] * (4 * self._width * self._height) for x in range(self._width): hV = 100.0 v = math.cos((float)(x + self._timeCount) * 1.2 * math.pi / 180.0) * hV iV = 128 + (int)(v) iPos = (iV * self._width + x) * 4 byte_data[iPos + 0] = 255 # Red byte_data[iPos + 1] = 255 # Green byte_data[iPos + 2] = 0 # Blue byte_data[iPos + 3] = 255 # Alpha self._byte_provider.set_bytes_data(byte_data, [self._width, self._height]) self._timeCount += 1 # ------------------------------------------. # Update event. # ------------------------------------------. _imgBuffer = None _img1 = None def on_update(e: carb.events.IEvent): global _imgBuffer global _img1 if _imgBuffer == None: _imgBuffer = OverlayImageBuffer() _imgBuffer.startup() _imgBuffer.update() with window.frame: with omni.ui.VStack(height=0): with omni.ui.Placer(offset_x=8, offset_y=8): _img1 = omni.ui.ImageWithProvider(_imgBuffer._byte_provider, width=_imgBuffer._width, height=_imgBuffer._height) _imgBuffer.update() # ------------------------------------------. # Register for update events. # To clear the event, specify "subs=None". subs = omni.kit.app.get_app().get_update_event_stream().create_subscription_to_pop(on_update, name="Test update")

Python

ft-lab/omniverse_sample_scripts/UI/DebugDraw/UseDebugDraw.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import omni.ui import omni.kit.app import carb import carb.events import math from omni.debugdraw import _debugDraw _debugDraw = _debugDraw.acquire_debug_draw_interface() # --------------------------------------------. # Draw arrow. # --------------------------------------------. def drawArrow (p1, p2, color): _debugDraw.draw_line(carb.Float3(p1[0], p1[1], p1[2]), color, carb.Float3(p2[0], p2[1], p2[2]), color) P1 = Gf.Vec3f(p1[0], p1[1], p1[2]) P2 = Gf.Vec3f(p2[0], p2[1], p2[2]) vDir = P2 - P1 lenV = vDir.GetLength() vDir /= lenV v1_2 = Gf.Vec4f(vDir[0], vDir[1], vDir[2], 1.0) v2_2 = Gf.Vec4f(0, 1, 0, 1.0) v3_2 = Gf.HomogeneousCross(v1_2, v2_2) vDirX = Gf.Vec3f(v3_2[0], v3_2[1], v3_2[2]).GetNormalized() vD1 = (vDir + vDirX).GetNormalized() * (lenV * 0.1) vD2 = (vDir - vDirX).GetNormalized() * (lenV * 0.1) pp = P1 + vD1 _debugDraw.draw_line(carb.Float3(pp[0], pp[1], pp[2]), color, carb.Float3(P1[0], P1[1], P1[2]), color) pp = P1 + vD2 _debugDraw.draw_line(carb.Float3(pp[0], pp[1], pp[2]), color, carb.Float3(P1[0], P1[1], P1[2]), color) pp = P2 - vD1 _debugDraw.draw_line(carb.Float3(pp[0], pp[1], pp[2]), color, carb.Float3(P2[0], P2[1], P2[2]), color) pp = P2 - vD2 _debugDraw.draw_line(carb.Float3(pp[0], pp[1], pp[2]), color, carb.Float3(P2[0], P2[1], P2[2]), color) # ------------------------------------------. # Update event. # ------------------------------------------. def on_update(e: carb.events.IEvent): color = 0xffffc000 # AARRGGBB r = 100.0 angleD = 10.0 angleV = 0.0 px1 = 0.0 pz1 = 0.0 py1 = 0.0 for i in range(200): px2 = math.cos(angleV * math.pi / 180.0) * r pz2 = math.sin(angleV * math.pi / 180.0) * r py2 = py1 + 0.1 if i == 0: px1 = px2 pz1 = pz2 _debugDraw.draw_line(carb.Float3(px1, py1, pz1), color, carb.Float3(px2, py2, pz2), color) r -= 0.5 angleV += angleD px1 = px2 py1 = py2 pz1 = pz2 #_debugDraw.draw_point(carb.Float3(0, 30, 0), 0xffff0000) color2 = 0xffff0000 drawArrow((-100.0, 5.0, -100.0), (-100.0, 5.0, 100.0), color2) # ------------------------------------------. # Register for update events. # To clear the event, specify "subs=None". subs = omni.kit.app.get_app().get_update_event_stream().create_subscription_to_pop(on_update, name="draw update")

Python

ft-lab/omniverse_sample_scripts/UI/Window/CreateNewWindow.py

import omni.ui # Create new window. my_window = omni.ui.Window("New Window", width=300, height=200) # ------------------------------------------. # Clicked button event. # ------------------------------------------. def onButtonClick(floatField): print("Button pushed.") # get/set FloatField. fCounter = floatField.model.get_value_as_float() fCounter += 1.0 floatField.model.set_value(fCounter) # ------------------------------------------. with my_window.frame: with omni.ui.VStack(height=0): floatField = None with omni.ui.Placer(offset_x=8, offset_y=8): # Set label. f = omni.ui.Label("Hello Omniverse!") f.set_style({"color": 0xff00ffff, "font_size": 20}) with omni.ui.Placer(offset_x=8, offset_y=0): f2 = omni.ui.Label("Line2!") f2.set_style({"color": 0xff00ff00, "font_size": 20}) with omni.ui.Placer(offset_x=8, offset_y=0): with omni.ui.HStack(width=300): omni.ui.Label("Edit : ", width=50) floatField = omni.ui.FloatField(width=200, height=0) with omni.ui.Placer(offset_x=8, offset_y=0): # Set button. btn = omni.ui.Button("Push", width=200, height=0) btn.set_clicked_fn(lambda f = floatField: onButtonClick(f))

Python

ft-lab/omniverse_sample_scripts/UI/Window/FileDialog.py

import omni.ui # ref : omni.kit.window.file

Python

ft-lab/omniverse_sample_scripts/UI/Window/InputField.py

import omni.ui # Create new window. my_window = omni.ui.Window("Input test window", width=300, height=200) # ------------------------------------------. with my_window.frame: sField = None sLabel = None # Reset StringField, Label. def onReset (uiField, uiLabel): if not uiField or not uiLabel: return uiField.model.set_value("") uiLabel.text = "" # Called when a value is changed in a StringField. def onValueChanged (uiFieldModel, uiLabel): if not uiFieldModel or not uiLabel: return v = uiFieldModel.get_value_as_string() uiLabel.text = v # Create window UI. with omni.ui.VStack(height=0): with omni.ui.Placer(offset_x=8, offset_y=8): with omni.ui.HStack(width=0): omni.ui.Label("Input ") sField = omni.ui.StringField(width=120, height=14, style={"color": 0xffffffff}) omni.ui.Spacer(height=4) sLabel = omni.ui.Label("text") omni.ui.Spacer(height=4) btn = omni.ui.Button(" Reset ") # Specify the callback to be called when the Button is pressed. btn.set_clicked_fn(lambda f = sField, l = sLabel: onReset(f, l)) # Specify a callback when a value is changed in a StringField. sField.model.add_value_changed_fn(lambda f, l = sLabel: onValueChanged(f, l))

Python

ft-lab/omniverse_sample_scripts/UI/Window/ImageWindow.py

import omni.ui # Create new window. my_window = omni.ui.Window("New Window", width=300, height=200) # ------------------------------------------. with my_window.frame: with omni.ui.VStack(height=0): with omni.ui.Placer(offset_x=8, offset_y=8): f = omni.ui.Label("Hello Omniverse!") f.set_style({"color": 0xff00ffff, "font_size": 20}) with omni.ui.Placer(offset_x=8, offset_y=0): # image search path : # "kit" or # absolute path omni.ui.Image("resources/desktop-icons/omniverse_64.png", width=64, height=64, fill_policy=omni.ui.FillPolicy.PRESERVE_ASPECT_FIT, alignment=omni.ui.Alignment.LEFT_CENTER)

Python

ft-lab/omniverse_sample_scripts/UI/Viewport/UpdateText2.py

import omni.ui import omni.kit.app import carb.events import asyncio import time # Get main window viewport. window = omni.ui.Window('Viewport') countV = 0 timeV = time.time() # ------------------------------------------. # Update event. # ------------------------------------------. def on_update(e: carb.events.IEvent): global countV global timeV # Process every second. curTimeV = time.time() if curTimeV - timeV > 1: timeV = curTimeV with window.frame: with omni.ui.VStack(height=0): with omni.ui.Placer(offset_x=20, offset_y=50): # Set label. f = omni.ui.Label("counter = " + str(countV)) f.visible = True f.set_style({"color": 0xff00ffff, "font_size": 32}) countV += 1 # ------------------------------------------. # Register for update events. # To clear the event, specify "subs=None". subs = omni.kit.app.get_app().get_update_event_stream().create_subscription_to_pop(on_update, name="Test update")

Python

ft-lab/omniverse_sample_scripts/UI/Viewport/WorldToScreen.py

from pxr import Usd, UsdGeom, CameraUtil, UsdShade, Sdf, Gf, Tf import omni.ext import omni.ui from omni.ui import color as cl from omni.ui import scene as sc import omni.kit # Kit104 : Get active viewport window. active_vp_window = omni.kit.viewport.utility.get_active_viewport_window() viewport_api = active_vp_window.viewport_api # World to NDC space (X : -1.0 to +1.0, Y : -1.0 to +1.0). p = (0, 0, 0) p_screen = viewport_api.world_to_ndc.Transform(p) # NDC to Pixel space. sPos, in_viewport = viewport_api.map_ndc_to_texture_pixel(p_screen) if in_viewport: print(sPos)

Python

ft-lab/omniverse_sample_scripts/UI/Viewport/DrawRandomRect.py

import omni.ui import random # Get main window viewport. window = omni.ui.Window('Viewport') rectSize = 5.0 with window.frame: # Use ZStack for multiple displays. with omni.ui.ZStack(): for i in range(50): px = random.random() * 500.0 py = random.random() * 500.0 with omni.ui.VStack(height=0): with omni.ui.Placer(offset_x=px, offset_y=py): # Set rectangle. rect = omni.ui.Rectangle(width=rectSize, height=rectSize) # Color : 0xAABBGGRR. rect.set_style({"background_color":0xff0000ff})

Python

ft-lab/omniverse_sample_scripts/UI/Viewport/UpdateText.py

import omni.ui import asyncio import omni.kit.app # Get main window viewport. window = omni.ui.Window('Viewport') # ------------------------------------------. async def my_task(): countV = 0 print('Start task.') f = None for i in range(10): with window.frame: with omni.ui.VStack(): with omni.ui.Placer(offset_x=20, offset_y=50): # Set label. f = omni.ui.Label("counter = " + str(countV), alignment=omni.ui.Alignment.LEFT_TOP) f.visible = True f.set_style({"color": 0xff00ffff, "font_size": 32}) countV += 1 await asyncio.sleep(1) # Sleep 1sec. print('End task.') if f != None: f.visible = False f = None # ------------------------------------------. # Start task. asyncio.ensure_future(my_task())

Python

ft-lab/omniverse_sample_scripts/UI/Viewport/GetActiveViewportInfo.py

from pxr import Usd, UsdGeom, CameraUtil, UsdShade, Sdf, Gf, Tf import omni.ext import omni.ui from omni.ui import color as cl from omni.ui import scene as sc import omni.kit # Kit104 : Get active viewport window. active_vp_window = omni.kit.viewport.utility.get_active_viewport_window() viewport_api = active_vp_window.viewport_api # Get Viewport window title. print("Viewport window : " + active_vp_window.name) # Get camera path ("/OmniverseKit_Persp" etc). cameraPath = viewport_api.camera_path.pathString print("cameraPath : " + cameraPath) # Resolution. resolution = viewport_api.resolution print("Resolution : " + str(resolution[0]) + " x " + str(resolution[1])) # Stage (Usd.Stage). print(viewport_api.stage) # Projection matrix (Gf.Matrix4d). print(viewport_api.projection) # Transform matrix (Gf.Matrix4d). print(viewport_api.transform) # View matrix (Gf.Matrix4d). print(viewport_api.view)

Python

ft-lab/omniverse_sample_scripts/UI/Viewport/GetViewportRect.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdSkel, UsdShade, Sdf, Gf, Tf import omni.ui # Get main window viewport. viewportI = omni.kit.viewport_legacy.acquire_viewport_interface() vWindow = viewportI.get_viewport_window(None) # Get viewport rect. viewportRect = vWindow.get_viewport_rect() viewportSize = (viewportRect[2] - viewportRect[0], viewportRect[3] - viewportRect[1]) print(viewportRect) print(viewportSize) # Get Viewport window rect. uiViewportWindow = omni.ui.Workspace.get_window("Viewport") wid = uiViewportWindow.width hei = uiViewportWindow.height posX = uiViewportWindow.position_x posY = uiViewportWindow.position_y print("wid = " + str(wid)) print("hei = " + str(hei)) print("posX = " + str(posX)) print("posY = " + str(posY))

Python

ft-lab/omniverse_sample_scripts/UI/Viewport/DrawText.py

import omni.ui # Get main window viewport. window = omni.ui.Window('Viewport') with window.frame: with omni.ui.VStack(): # Display position from top left. with omni.ui.Placer(offset_x=20, offset_y=50): # Set label. f = omni.ui.Label("Hello Omniverse!", alignment=omni.ui.Alignment.LEFT_TOP) f.visible = True # Color : 0xAABBGGRR. f.set_style({"color": 0xff00ffff, "font_size": 32})

Python

ft-lab/omniverse_sample_scripts/UI/Viewport/UpdateDrawImage.py

import omni.ui import omni.kit.app import carb.events import carb.tokens import asyncio import time import itertools from pathlib import Path import os.path # PIL exists in "kit/extscore/omni.kit.pip_archive/pip_prebundle". from PIL import Image, ImageDraw, ImageFont # Get main window viewport. window = omni.ui.Window('Viewport') countV = 0 timeV = time.time() # ------------------------------------------. # Load image. # ------------------------------------------. class LoadImageRGBA: _byte_provider = None _width = 0 _height = 0 def __init__(self): pass def Open (self, path : str): try: # Load image (RGBA). im = Image.open(path).convert('RGBA') # Get image size. self._width = im.size[0] self._height = im.size[1] # Get image data(RGBA buffer). imgD = im.getdata() # Converting a 2d array to a 1d array. byte_data = list(itertools.chain.from_iterable(imgD)) self._byte_provider = omni.ui.ByteImageProvider() self._byte_provider.set_bytes_data(byte_data, [self._width, self._height]) except Exception as e: self._width = 0 self._height = 0 self._byte_provider = None print(e) return False return True def GetWidth (self): return self._width def GetHeight (self): return self._height def GetByteProvider (self): return self._byte_provider # Image data. imgData = None # ------------------------------------------. # Update event. # ------------------------------------------. def on_update(e: carb.events.IEvent): global countV global timeV global imgData # Process every second. curTimeV = time.time() if curTimeV - timeV > 1: timeV = curTimeV countV += 1 # Update UI. with window.frame: with omni.ui.ZStack(): with omni.ui.VStack(height=0): with omni.ui.Placer(offset_x=20, offset_y=50): # Set label. f = omni.ui.Label("counter = " + str(countV)) f.visible = True f.set_style({"color": 0xff00ffff, "font_size": 32}) with omni.ui.VStack(height=0): with omni.ui.Placer(offset_x=220, offset_y=150): # "omni.ui.Image" cannot be used with "get_update_event_stream().create_subscription_to_pop". # Use "omni.ui.ImageWithProvider" instead. byte_provider = imgData.GetByteProvider() imgWidth = imgData.GetWidth() imgHeight = imgData.GetHeight() omni.ui.ImageWithProvider(byte_provider, width=imgWidth, height=imgHeight) # ------------------------------------------. # Kit file path. kitAbsPath = os.path.abspath(carb.tokens.get_tokens_interface().resolve("${kit}")) # Load image (RGBA). imagePath = Path(kitAbsPath).joinpath("resources").joinpath("desktop-icons") imagePath = f"{imagePath}/omniverse_64.png" imgData = LoadImageRGBA() if imgData.Open(imagePath): # Register for update events. # To clear the event, specify "subs=None". subs = omni.kit.app.get_app().get_update_event_stream().create_subscription_to_pop(on_update, name="Test update")

Python

ft-lab/omniverse_sample_scripts/UI/Viewport/DrawText2.py

import omni.ui # Get main window viewport. window = omni.ui.Window('Viewport') with window.frame: with omni.ui.VStack(height=0): with omni.ui.Placer(offset_x=20, offset_y=50): # Set label. f = omni.ui.Label("Hello Omniverse!") f.visible = True f.set_style({"color": 0xff00ffff, "font_size": 32}) with omni.ui.Placer(offset_x=20, offset_y=0): f2 = omni.ui.Label("Line2!") f2.visible = True f2.set_style({"color": 0xff00ff00, "font_size": 32}) with omni.ui.Placer(offset_x=20, offset_y=0): f3 = omni.ui.Label("Line3!") f3.visible = True f3.set_style({"color": 0xff0000ff, "font_size": 32})

Python

ft-lab/omniverse_sample_scripts/pip_archive/numpy/CreateMatrix.py

import numpy # Create 4x4 matrix (identity matrix). m = numpy.matrix(numpy.identity(4)) print(m) # Set a value to a matrix. m[3,0] = 2.0 m[2] = [50.0, 100.0, -20.0, 1.0] print(m)

Python

ft-lab/omniverse_sample_scripts/pip_archive/numpy/CalcVector.py

import numpy v1 = numpy.array([0.0, 1.0, 2.0]) v2 = numpy.array([1.2, 1.5, 2.3]) v3 = v1 + v2 print(v3) v3 = v1 * v2 print(v3) v2[0] += 0.5 print(v2[0]) print(v2[1]) print(v2[2])

Python

ft-lab/omniverse_sample_scripts/pip_archive/numpy/CalcVectorLength.py

import numpy val = numpy.array([2.5, 1.0, 3.0]) lenV = numpy.linalg.norm(val) print(str(val) + " : Length = " + str(lenV)) # Normalized. lenV = numpy.linalg.norm(val) val2 = val if lenV != 0.0: val2 = val / lenV print("Normalized " + str(val) + " ==> " + str(val2))

Python

ft-lab/omniverse_sample_scripts/pip_archive/numpy/CalcMultiplyMatrix.py

import numpy # Create 4x4 matrix (identity matrix). m1 = numpy.matrix(numpy.identity(4)) m2 = numpy.matrix(numpy.identity(4)) m1[3] = [22.3, 15.5, 3.0, 1.0] m2[3] = [50.0, 100.0, -20.0, 1.0] # Multiply matrix. # (Same result for mA and mB) mA = m1 * m2 mB = numpy.dot(m1, m2) print(mA) print(mB)

Python

ft-lab/omniverse_sample_scripts/pip_archive/numpy/CalcVectorDotCross.py

import numpy v1 = numpy.array([0.0, 1.0, 2.0]) v2 = numpy.array([1.2, 1.5, 2.3]) # Calculating the Inner Product. v = numpy.dot(v1, v2) print("Inner product : " + str(v)) # Calculating the Outer Product. v = numpy.cross(v1, v2) print("Outer product : " + str(v))

Python

ft-lab/omniverse_sample_scripts/pip_archive/numpy/CalcMultiplyMatrixVector.py

import numpy # Create Vector3. v1 = numpy.array([0.0, 1.0, 2.0]) # Create 4x4 matrix. m1 = numpy.matrix(numpy.identity(4)) m1[3] = [22.3, 15.5, 3.0, 1.0] # Make sure that the vector to be multiplied has four elements. vec4 = numpy.array(v1) if v1.size == 3: vec4 = numpy.array([v1[0], v1[1], v1[2], 1.0]) # Vector and matrix multiplication. retM = numpy.dot(vec4, m1) print(retM) # Replace the result with Vector3. retV = numpy.array([retM[0,0], retM[0,1], retM[0,2]]) print(retV)

Python

ft-lab/omniverse_sample_scripts/pip_archive/PIL/DrawImage.py

# PIL exists in "kit/extscore/omni.kit.pip_archive/pip_prebundle". from PIL import Image, ImageDraw, ImageFont # Create new image. im = Image.new("RGBA", (512, 512), (0, 0, 0, 0)) draw = ImageDraw.Draw(im) # Draw rectangle (fill). draw.rectangle((100, 100, 200, 200), fill=(255, 0, 0)) # Draw rectangle. draw.rectangle((100, 220, 200, 320), outline=(0, 0, 255), width=1) # Draw line. draw.line((0, 0, im.width, im.height), fill=(0, 255, 0), width=2) # Draw circle. draw.ellipse((100, 400, 150, 450), outline=(0, 0, 255), width=2) # Draw circle (fill). draw.ellipse((280, 300, 380, 400), fill=(0, 0, 255)) # Polygon. vers = ((40, 20), (140, 120), (180, 60)) draw.polygon(vers, outline=(128, 0, 0)) # Polygon (fill). vers = ((240, 20), (340, 120), (380, 60)) draw.polygon(vers, fill=(128, 128, 0)) # Font. font = None try: # The ttf font path should be replaced according to your environment. basePath = "K:/fonts" fontPath = basePath + "/SourceHanSansJP-Bold.otf" font = ImageFont.truetype(fontPath, 48) except Exception as e: print(e) # Draw text. if font != None: draw.multiline_text((16, 40), 'Draw Text!', fill=(0, 128, 0)) # Save image. # Rewrite it to any file path and uncomment the following. #im.save("K:/NVIDIA_omniverse/images/out.png", quality=95)

Python

ft-lab/omniverse_sample_scripts/pip_archive/PIL/LoadImage.py

# PIL exists in "kit/extscore/omni.kit.pip_archive/pip_prebundle". from PIL import Image # Load image from file. path = "K:/NVIDIA_omniverse/images/omniverse_64.png" im = None try: im = Image.open(path) # Get image size. wid = im.size[0] hei = im.size[1] print("Image size : " + str(wid) + " x " + str(hei)) # Get format (PNG, JPEG, etc). print("Format : " + str(im.format)) # Get mode (RGB, RGBA, etc.). print("Mode : " + str(im.mode)) except Exception as e: print(e)

Python

ft-lab/omniverse_sample_scripts/Material/UnbindMaterial.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Get selection. selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() for path in paths: prim = stage.GetPrimAtPath(path) if prim.IsValid(): # Unbind Material. UsdShade.MaterialBindingAPI(prim).UnbindAllBindings()

Python

ft-lab/omniverse_sample_scripts/Material/OmniPBR/CreateMaterialWithDiffuseTexture.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Create mesh. meshPath = '/World/mesh' meshGeom = UsdGeom.Mesh.Define(stage, meshPath) meshGeom.CreatePointsAttr([(-10, 0, -10), (-10, 0, 10), (10, 0, 10), (10, 0, -10)]) meshGeom.CreateNormalsAttr([(0, 1, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0)]) meshGeom.CreateFaceVertexCountsAttr([4]) meshGeom.CreateFaceVertexIndicesAttr([0, 1, 2, 3]) texCoords = meshGeom.CreatePrimvar("st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying) texCoords.Set([(0, 1), (0, 0), (1, 0), (1, 1)]) meshPrim = stage.GetPrimAtPath(meshPath) # Create material scope. materialScopePath = '/World/Materials' scopePrim = stage.GetPrimAtPath(materialScopePath) if scopePrim.IsValid() == False: UsdGeom.Scope.Define(stage, materialScopePath) # Create material (omniPBR). materialPath = '/World/Materials/omniPBR_mat1' material = UsdShade.Material.Define(stage, materialPath) shaderPath = materialPath + '/Shader' shader = UsdShade.Shader.Define(stage, shaderPath) shader.SetSourceAsset('OmniPBR.mdl', 'mdl') shader.GetPrim().CreateAttribute('info:mdl:sourceAsset:subIdentifier', Sdf.ValueTypeNames.Token, False, Sdf.VariabilityUniform).Set('OmniPBR') # Set Diffuse color. shader.CreateInput('diffuse_color_constant', Sdf.ValueTypeNames.Color3f).Set((1.0, 0.5, 0.4)) # Set Metallic. shader.CreateInput('metallic_constant', Sdf.ValueTypeNames.Float).Set(0.0) # Set Roughness. shader.CreateInput('reflection_roughness_constant', Sdf.ValueTypeNames.Float).Set(0.2) # Set Diffuse texture. # Note : Texture files should be specified in the path where they exist. #textureFilePath = '../textures/tile_image.png' textureFilePath = 'https://ft-lab.github.io/usd/omniverse/textures/tile_image.png' diffTexIn = shader.CreateInput('diffuse_texture', Sdf.ValueTypeNames.Asset) diffTexIn.Set(textureFilePath) diffTexIn.GetAttr().SetColorSpace('sRGB') # Set Diffuse value. diffTintIn = shader.CreateInput('diffuse_tint', Sdf.ValueTypeNames.Color3f) diffTintIn.Set((0.9, 0.9, 0.9)) # Connecting Material to Shader. mdlOutput = material.CreateSurfaceOutput('mdl') mdlOutput.ConnectToSource(shader, 'out') # Bind material. UsdShade.MaterialBindingAPI(meshPrim).Bind(material)

Python

ft-lab/omniverse_sample_scripts/Material/OmniPBR/CreateMaterialWithCommand.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import omni.kit.commands # Get stage. stage = omni.usd.get_context().get_stage() # Create new material. omni.kit.commands.execute('CreateAndBindMdlMaterialFromLibrary', mdl_name='OmniPBR.mdl', mtl_name='OmniPBR', mtl_created_list=['/World/Looks/OmniPBR']) # Get selection. selection = omni.usd.get_context().get_selection() selectedPaths = selection.get_selected_prim_paths() # Path of the added material. selectPrimPath = "" for path in selectedPaths: selectPrimPath = path break print(selectPrimPath)

Python

ft-lab/omniverse_sample_scripts/Material/OmniPBR/CreateMaterial.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Create sphere. spherePath = '/World/sphere' sphereGeom = UsdGeom.Sphere.Define(stage, spherePath) sphereGeom.CreateRadiusAttr(20.0) spherePrim = stage.GetPrimAtPath(spherePath) spherePrim.CreateAttribute('refinementEnableOverride', Sdf.ValueTypeNames.Bool).Set(True) spherePrim.CreateAttribute('refinementLevel', Sdf.ValueTypeNames.Int).Set(2) prim = sphereGeom.GetPrim() # Create material scope. materialScopePath = '/World/Materials' scopePrim = stage.GetPrimAtPath(materialScopePath) if scopePrim.IsValid() == False: UsdGeom.Scope.Define(stage, materialScopePath) # Create material (omniPBR). materialPath = '/World/Materials/omniPBR_mat1' material = UsdShade.Material.Define(stage, materialPath) shaderPath = materialPath + '/Shader' shader = UsdShade.Shader.Define(stage, shaderPath) shader.SetSourceAsset('OmniPBR.mdl', 'mdl') shader.GetPrim().CreateAttribute('info:mdl:sourceAsset:subIdentifier', Sdf.ValueTypeNames.Token, False, Sdf.VariabilityUniform).Set('OmniPBR') # Set Diffuse color. shader.CreateInput('diffuse_color_constant', Sdf.ValueTypeNames.Color3f).Set((1.0, 0.5, 0.4)) # Set Metallic. shader.CreateInput('metallic_constant', Sdf.ValueTypeNames.Float).Set(0.0) # Set Roughness. shader.CreateInput('reflection_roughness_constant', Sdf.ValueTypeNames.Float).Set(0.2) # Connecting Material to Shader. mdlOutput = material.CreateSurfaceOutput('mdl') mdlOutput.ConnectToSource(shader, 'out') # Bind material. bindAPI = UsdShade.MaterialBindingAPI(prim) bindAPI.Bind(material) bindAPI.Apply(prim)

Python

ft-lab/omniverse_sample_scripts/Material/GetMaterial/GetMaterial.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() for path in paths: prim = stage.GetPrimAtPath(path) # Get Material. rel = UsdShade.MaterialBindingAPI(prim).GetDirectBindingRel() pathList = rel.GetTargets() print('[ ' + prim.GetName() + ' ]') for mTargetPath in pathList: print(' material : ' + mTargetPath.pathString) material = UsdShade.Material(stage.GetPrimAtPath(mTargetPath)) print(material)

Python

ft-lab/omniverse_sample_scripts/Material/GetMaterial/GetMaterialTexturePath.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() for path in paths: prim = stage.GetPrimAtPath(path) if prim.GetTypeName() != "Material": continue # List textures referenced by Material. pChildren = prim.GetChildren() for cPrim in pChildren: if cPrim.GetTypeName() == "Shader": shaderPrim = UsdShade.Shader(cPrim) print(f"[{shaderPrim.GetPath().pathString}]") mInputs = shaderPrim.GetInputs() for inputV in mInputs: baseName = inputV.GetBaseName() typeName = inputV.GetTypeName() if typeName == "asset": v = inputV.Get() # Sdf.AssetPath if v.path != "": # v.path ... display path. # v.resolvedPath ... absolute path. print(f" {baseName}") print(f" path [ {v.path} ]") print(f" resolvedPath [ {v.resolvedPath} ]")

Python

ft-lab/omniverse_sample_scripts/Material/GetMaterial/GetMaterialType.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() # Get material type (UsdPreviewSurface/OmniPBR/CustomMDL etc.) def GetMaterialType (path : str): prim = stage.GetPrimAtPath(path) if prim.GetTypeName() != "Material": return "" materialTypeName = "" pChildren = prim.GetChildren() for cPrim in pChildren: if cPrim.GetTypeName() == "Shader": shaderPrim = UsdShade.Shader(cPrim) # In the case of UsdPreviewSurface, ImplementationSource is "id". # In the case of MDL, the ImplementationSource is "sourceAsset". sourceV = shaderPrim.GetImplementationSource() if sourceV == "id": attr = shaderPrim.GetIdAttr() idValue = attr.Get() # "UsdPreviewSurface" if idValue == "UsdPreviewSurface": materialTypeName = idValue # Get MDL information. if sourceV == "sourceAsset": # Sdf.AssetPath # assetPath.path ... display path. # assetPath.resolvedPath ... absolute path. assetPath = shaderPrim.GetSourceAsset("mdl") # MDL name. subIdentifier = shaderPrim.GetSourceAssetSubIdentifier("mdl") if subIdentifier != "": materialTypeName = subIdentifier else: materialTypeName = assetPath.resolvedPath if materialTypeName != "": break return materialTypeName # -----------------------------------. for path in paths: materialTypeName = GetMaterialType(path) if materialTypeName != "": print(f"{path} : {materialTypeName}")

Python

ft-lab/omniverse_sample_scripts/Material/GetMaterial/GetMaterialInputs.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() for path in paths: prim = stage.GetPrimAtPath(path) if prim.GetTypeName() != "Material": continue print("[" + prim.GetPath().pathString + "]") # Get Shader of Material and input parameters. pChildren = prim.GetChildren() for cPrim in pChildren: if cPrim.GetTypeName() == "Shader": shaderPrim = UsdShade.Shader(cPrim) mInputs = shaderPrim.GetInputs() for inputV in mInputs: baseName = inputV.GetBaseName() typeName = inputV.GetTypeName() print(" [" + baseName + "] (" + str(typeName) + ")") v = inputV.Get() print(" " + str(type(v)) + " ==> " + str(v))

Python

ft-lab/omniverse_sample_scripts/Material/UsdPreviewSurface/CreateMaterialWithDiffuseTexture.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Create mesh. meshPath = '/World/mesh' meshGeom = UsdGeom.Mesh.Define(stage, meshPath) meshGeom.CreatePointsAttr([(-10, 0, -10), (-10, 0, 10), (10, 0, 10), (10, 0, -10)]) meshGeom.CreateNormalsAttr([(0, 1, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0)]) meshGeom.CreateFaceVertexCountsAttr([4]) meshGeom.CreateFaceVertexIndicesAttr([0, 1, 2, 3]) texCoords = meshGeom.CreatePrimvar("st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying) texCoords.Set([(0, 1), (0, 0), (1, 0), (1, 1)]) meshPrim = stage.GetPrimAtPath(meshPath) # Create material scope. materialScopePath = '/World/Materials' scopePrim = stage.GetPrimAtPath(materialScopePath) if scopePrim.IsValid() == False: UsdGeom.Scope.Define(stage, materialScopePath) # Create material (UsdPreviewSurface). materialPath = '/World/Materials/mat1' material = UsdShade.Material.Define(stage, materialPath) pbrShader = UsdShade.Shader.Define(stage, materialPath + '/PBRShader') pbrShader.CreateIdAttr("UsdPreviewSurface") pbrShader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).Set((1.0, 0.2, 0.0)) pbrShader.CreateInput("roughness", Sdf.ValueTypeNames.Float).Set(0.4) pbrShader.CreateInput("metallic", Sdf.ValueTypeNames.Float).Set(0.0) # Set diffuse texture. stReader = UsdShade.Shader.Define(stage, materialPath + '/stReader') stReader.CreateIdAttr('UsdPrimvarReader_float2') diffuseTextureSampler = UsdShade.Shader.Define(stage, materialPath + '/diffuseTexture') diffuseTextureSampler.CreateIdAttr('UsdUVTexture') # Note : Texture files should be specified in the path where they exist. #textureFilePath = '../textures/tile_image.png' textureFilePath = 'https://ft-lab.github.io/usd/omniverse/textures/tile_image.png' diffuseTextureSampler.CreateInput('file', Sdf.ValueTypeNames.Asset).Set(textureFilePath) diffuseTextureSampler.CreateInput("st", Sdf.ValueTypeNames.Float2).ConnectToSource(stReader.ConnectableAPI(), 'result') diffuseTextureSampler.CreateOutput('rgb', Sdf.ValueTypeNames.Float3) pbrShader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).ConnectToSource(diffuseTextureSampler.ConnectableAPI(), 'rgb') stInput = material.CreateInput('frame:stPrimvarName', Sdf.ValueTypeNames.Token) stInput.Set('st') stReader.CreateInput('varname',Sdf.ValueTypeNames.Token).ConnectToSource(stInput) # Connect PBRShader to Material. material.CreateSurfaceOutput().ConnectToSource(pbrShader.ConnectableAPI(), "surface") # Bind material. UsdShade.MaterialBindingAPI(meshPrim).Bind(material)

Python

ft-lab/omniverse_sample_scripts/Material/UsdPreviewSurface/CreateMaterial.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Create sphere. spherePath = '/World/sphere' sphereGeom = UsdGeom.Sphere.Define(stage, spherePath) sphereGeom.CreateRadiusAttr(20.0) spherePrim = stage.GetPrimAtPath(spherePath) spherePrim.CreateAttribute('refinementEnableOverride', Sdf.ValueTypeNames.Bool).Set(True) spherePrim.CreateAttribute('refinementLevel', Sdf.ValueTypeNames.Int).Set(2) # Create material scope. materialScopePath = '/World/Materials' scopePrim = stage.GetPrimAtPath(materialScopePath) if scopePrim.IsValid() == False: UsdGeom.Scope.Define(stage, materialScopePath) # Create material (UsdPreviewSurface). materialPath = '/World/Materials/mat1' material = UsdShade.Material.Define(stage, materialPath) pbrShader = UsdShade.Shader.Define(stage, materialPath + '/PBRShader') pbrShader.CreateIdAttr("UsdPreviewSurface") pbrShader.CreateInput("diffuseColor", Sdf.ValueTypeNames.Color3f).Set((1.0, 0.2, 0.0)) pbrShader.CreateInput("roughness", Sdf.ValueTypeNames.Float).Set(0.4) pbrShader.CreateInput("metallic", Sdf.ValueTypeNames.Float).Set(0.0) # Connect PBRShader to Material. material.CreateSurfaceOutput().ConnectToSource(pbrShader.ConnectableAPI(), "surface") # Bind material. UsdShade.MaterialBindingAPI(spherePrim).Bind(material)

Python

ft-lab/omniverse_sample_scripts/Python/Class/SimpleClass.py

# -----------------------------------------------. # Simple class. # -----------------------------------------------. class ClassFoo: _name = "" # Constructor def __init__(self, name : str): self.name = name print("Constructor") # Destructor def __del__(self): print("Destructor") def printName (self): print("name = " + self.name) def add (self, a : float, b : float): return (a + b) # -----------------------------------------------. # Create new class. foo = ClassFoo("test") foo.printName() print(foo.add(12.5, 8.2)) # Destroying a class. foo = None

Python

ft-lab/omniverse_sample_scripts/Python/string/NumToStr.py

v = 0.25364 # number to string. # ==> "0.25364" print("Value = " + str(v)) # Digit number specification. # ==> "0000.25364" print("Value : {:#010}".format(v)) print("Value : " + format(v, '#010')) # Specify the number of decimal places. # ==> "0.254" print("Value : {:.3f}".format(v)) print("Value : " + format(v, '.3f')) # Replaced by hexadecimal. # ==> "0x7fff" v2 = 32767 print(hex(v2)) # Replaced by a binary number. # ==> "0b101" v2 = 5 print(bin(v2))

Python

ft-lab/omniverse_sample_scripts/Python/string/StringTest.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf v = 25.3674 print("Value = " + str(v)) print(f"Value = {v}") print(f"Type = {type(v)}") # Specify the number of decimal places. # ==> "25.367" print(f"Value = {'{:.3f}'.format(v)}") vec3 = Gf.Vec3f(1.2, 5.6, 90) print(f"vec3 = {vec3}") array = [1.2, "test", True] print(f"array = {array}")

Python

ft-lab/omniverse_sample_scripts/Python/Web/WebOpen.py

import webbrowser url = "https://docs.omniverse.nvidia.com/" webbrowser.open(url)

Python

ft-lab/omniverse_sample_scripts/AssetConverter/importObjToUSD.py

# --------------------------------------------------. # obj to usd conversion. # See : https://docs.omniverse.nvidia.com/app_create/prod_extensions/ext_asset-converter.html # --------------------------------------------------. import carb import omni import asyncio import omni.kit.asset_converter # Progress of processing. def progress_callback (current_step: int, total: int): # Show progress print(f"{current_step} of {total}") # Convert asset file(obj/fbx/glTF, etc) to usd. async def convert_asset_to_usd (input_asset: str, output_usd: str): # Input options are defaults. converter_context = omni.kit.asset_converter.AssetConverterContext() converter_context.ignore_materials = False converter_context.ignore_camera = False converter_context.ignore_animations = False converter_context.ignore_light = False converter_context.export_preview_surface = False converter_context.use_meter_as_world_unit = False converter_context.create_world_as_default_root_prim = True converter_context.embed_textures = True converter_context.convert_fbx_to_y_up = False converter_context.convert_fbx_to_z_up = False converter_context.merge_all_meshes = False converter_context.use_double_precision_to_usd_transform_op = False converter_context.ignore_pivots = False converter_context.keep_all_materials = True converter_context.smooth_normals = True instance = omni.kit.asset_converter.get_instance() task = instance.create_converter_task(input_asset, output_usd, progress_callback, converter_context) # Wait for completion. success = await task.wait_until_finished() if not success: carb.log_error(task.get_status(), task.get_detailed_error()) print("converting done") # Rewrite it to suit your environment. input_obj = "K:/Modeling/obj/simple_obj2/simple_obj.obj" output_usd = "K:/Modeling/obj/simple_obj2/simple_obj/simple_obj.usd" # Convert to USD (obj to USD). asyncio.ensure_future( convert_asset_to_usd(input_obj, output_usd) )

Python

ft-lab/omniverse_sample_scripts/Event/UpdateInterval.py

import omni.ui import omni.kit.app import carb.events import time import asyncio class UpdateInterval: _viewportWindow = None _subs = None _visible = True _time = None _vTime = None def __init__(self): pass # Update event. def on_update (self, e: carb.events.IEvent): if self._viewportWindow == None: return curTime = time.time() diffTime = curTime - self._time self._time = curTime if self._vTime == None: self._vTime = curTime if curTime < self._vTime + 0.5 and self._visible: return self._vTime = curTime # Update UI. with self._viewportWindow.frame: with omni.ui.VStack(height=0): with omni.ui.Placer(offset_x=20, offset_y=30): # Set label. fpsV = 1.0 / diffTime msgStr = "Update interval(sec) : {:.5f} sec, {:.2f} fps".format(diffTime, fpsV) f = omni.ui.Label(msgStr) f.visible = self._visible f.set_style({"color": 0xff00ffff, "font_size": 32}) def startup (self): # Get main window viewport. self._viewportWindow = omni.ui.Window('Viewport') self._time = time.time() self._visible = True # Register for update event. self._subs = omni.kit.app.get_app().get_update_event_stream().create_subscription_to_pop(self.on_update) def shutdown (self): # Release the update event. async def _exitUpdateEvent (): self._visible = False await omni.kit.app.get_app().next_update_async() self._subs = None self._vTime = None asyncio.ensure_future(_exitUpdateEvent()) # -----------------------------------------. updateI = UpdateInterval() updateI.startup() # Finish the process below. #updateI.shutdown()

Python

ft-lab/omniverse_sample_scripts/System/GetUSDVersion.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf print(Usd.GetVersion())

Python

ft-lab/omniverse_sample_scripts/System/GetPythonVersion.py

import sys print(sys.version)

Python

ft-lab/omniverse_sample_scripts/System/GetSysPath.py

import sys import os # Append path. def appendSysPath (newPath): existF = False for path in sys.path: if path == newPath: existF = True break if existF: return sys.path.append(newPath) for path in sys.path: print(path)

Python

ft-lab/omniverse_sample_scripts/Geometry/SetMeshPrimvars.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Get selection. selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() for path in paths: # Get prim. prim = stage.GetPrimAtPath(path) if prim.GetTypeName() != "Mesh": continue m = UsdGeom.Mesh(prim) # USD 22.11 : The specification has been changed to use UsdGeom.PrimvarsAPI. # Set primvar(float). primvarV = UsdGeom.PrimvarsAPI(prim).CreatePrimvar("dat1", Sdf.ValueTypeNames.Float) attr = primvarV.GetAttr() attr.Set((2.2)) if UsdGeom.primvarV(prim).HasPrimvar("dat1"): # Check primvar. # Remove primvar. UsdGeom.primvarV(prim).RemovePrimvar("dat1") # Set primvar (float2). # If there is already a primvar with the same name but a different type, # it must be removed using RemoveProperty. primvarV = UsdGeom.PrimvarsAPI(prim).CreatePrimvar("dat1", Sdf.ValueTypeNames.Float2) attr = primvarV.GetAttr() attr.Set((1.0, 2.0)) # Set primvar (color). primvarV = UsdGeom.PrimvarsAPI(prim).CreatePrimvar("dat2", Sdf.ValueTypeNames.Color3f) attr = primvarV.GetAttr() attr.Set((1.0, 0.5, 0.2)) # Set primvar (float3 array) primvarV = UsdGeom.PrimvarsAPI(prim).CreatePrimvar("dat3", Sdf.ValueTypeNames.Float3Array) attr = primvarV.GetAttr() attr.Set([(0.1, 0.2, 0.5), (0.4, 0.05, 0.0), (0.1, 0.4, 0.05)])

Python

ft-lab/omniverse_sample_scripts/Geometry/GetMeshPrimvars.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Get selection. selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() for path in paths: # Get prim. prim = stage.GetPrimAtPath(path) if prim.GetTypeName() != "Mesh": continue # USD 22.11 : The specification has been changed to use UsdGeom.PrimvarsAPI. primvarsAPI = UsdGeom.PrimvarsAPI(prim) primvars = primvarsAPI.GetPrimvars() if len(primvars) > 0: print("[" + prim.GetPath().pathString + "]") for primvar in primvars: primName = primvar.GetPrimvarName() typeName = primvar.GetTypeName() val = primvar.Get() print(" " + primName + " (" + str(typeName) + ") : " + str(val))

Python

ft-lab/omniverse_sample_scripts/Geometry/CreateMesh/CreateSimpleMesh.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Get default prim. defaultPrim = stage.GetDefaultPrim() # Get root path. rootPath = '/' if defaultPrim.IsValid(): rootPath = defaultPrim.GetPath().pathString # Create mesh. meshGeom = UsdGeom.Mesh.Define(stage, rootPath + "/mesh") # Set vertices. meshGeom.CreatePointsAttr([(-10, 0, -10), (-10, 0, 10), (10, 0, 10), (10, 0, -10)]) # Set normals. meshGeom.CreateNormalsAttr([(0, 1, 0), (0, 1, 0), (0, 1, 0), (0, 1, 0)]) meshGeom.SetNormalsInterpolation("vertex") # Set face vertex count. meshGeom.CreateFaceVertexCountsAttr([4]) # Set face vertex indices. meshGeom.CreateFaceVertexIndicesAttr([0, 1, 2, 3]) # Set uvs. # USD 22.11 : The specification has been changed to use UsdGeom.PrimvarsAPI. primvarV = UsdGeom.PrimvarsAPI(meshGeom).CreatePrimvar("st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.vertex) attr = primvarV.GetAttr() attr.Set([(0, 1), (0, 0), (1, 0), (1, 1)]) # Compute extent. boundable = UsdGeom.Boundable(meshGeom.GetPrim()) extent = boundable.ComputeExtent(Usd.TimeCode(0)) # Set Extent. meshGeom.CreateExtentAttr(extent) # Subdivision is set to none. meshGeom.CreateSubdivisionSchemeAttr().Set("none") # Set position. UsdGeom.XformCommonAPI(meshGeom).SetTranslate((0.0, 0.0, 0.0)) # Set rotation. UsdGeom.XformCommonAPI(meshGeom).SetRotate((0.0, 0.0, 0.0), UsdGeom.XformCommonAPI.RotationOrderXYZ) # Set scale. UsdGeom.XformCommonAPI(meshGeom).SetScale((1.0, 1.0, 1.0))

Python

ft-lab/omniverse_sample_scripts/Geometry/CreateMesh/CreateSimpleMeshWithSubset.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Get default prim. defaultPrim = stage.GetDefaultPrim() # Get root path. rootPath = '/' if defaultPrim.IsValid(): rootPath = defaultPrim.GetPath().pathString # --------------------------------------. # Create new Material (OmniPBR). # @param[in] materialPrimPath Prim path of Material # @param[in] diffuseColor Diffuse color. # --------------------------------------. def createMaterialOmniPBR (materialPrimPath : str, diffuseColor : Gf.Vec3f): material = UsdShade.Material.Define(stage, materialPrimPath) shaderPath = materialPrimPath + '/Shader' shader = UsdShade.Shader.Define(stage, shaderPath) shader.SetSourceAsset('OmniPBR.mdl', 'mdl') shader.GetPrim().CreateAttribute('info:mdl:sourceAsset:subIdentifier', Sdf.ValueTypeNames.Token, False, Sdf.VariabilityUniform).Set('OmniPBR') # Set Diffuse color. shader.CreateInput('diffuse_color_constant', Sdf.ValueTypeNames.Color3f).Set(diffuseColor) # Connecting Material to Shader. mdlOutput = material.CreateSurfaceOutput('mdl') mdlOutput.ConnectToSource(shader.ConnectableAPI(), 'out') return materialPrimPath # --------------------------------------. # Create mesh with subset. # --------------------------------------. def createMesh (meshPath : str): # Create mesh. meshGeom = UsdGeom.Mesh.Define(stage, meshPath) # Set vertices. meshGeom.CreatePointsAttr([(-10, 0, -10), (0, 0, -10), (10, 0, -10), (-10, 0, 0), (0, 0, 0), (10, 0, 0)]) # Set face vertex count. meshGeom.CreateFaceVertexCountsAttr([4, 4]) # Set face vertex indices. meshGeom.CreateFaceVertexIndicesAttr([0, 3, 4, 1, 1, 4, 5, 2]) # Set normals and UVs for each face vertex. # Set normals. normalList = [] for i in range(2): normalList.extend([(0.0, 1.0, 0.0), (0.0, 1.0, 0.0), (0.0, 1.0, 0.0), (0.0, 1.0, 0.0)]) meshGeom.CreateNormalsAttr(normalList) meshGeom.SetNormalsInterpolation("faceVarying") # Set uvs. # USD 22.11 : The specification has been changed to use UsdGeom.PrimvarsAPI. primvarV = UsdGeom.PrimvarsAPI(meshGeom).CreatePrimvar("st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.faceVarying) attr = primvarV.GetAttr() uvsList = [] uvsList.extend([(0.0, 1.0), (0.0, 0.0), (1.0, 0.0), (1.0, 1.0)]) uvsList.extend([(1.0, 1.0), (1.0, 0.0), (2.0, 0.0), (2.0, 1.0)]) attr.Set(uvsList) # Subdivision is set to none. meshGeom.CreateSubdivisionSchemeAttr().Set("none") # Set position. UsdGeom.XformCommonAPI(meshGeom).SetTranslate((0.0, 0.0, 0.0)) # Set rotation. UsdGeom.XformCommonAPI(meshGeom).SetRotate((0.0, 0.0, 0.0), UsdGeom.XformCommonAPI.RotationOrderXYZ) # Set scale. UsdGeom.XformCommonAPI(meshGeom).SetScale((1.0, 1.0, 1.0)) # Create subset 1. subsetPath = meshPath + "/submesh_1" geomSubset1 = UsdGeom.Subset.Define(stage, subsetPath) geomSubset1.CreateFamilyNameAttr("materialBind") geomSubset1.CreateElementTypeAttr("face") geomSubset1.CreateIndicesAttr([0]) # Set the index on the face. # Bind material. matPrim = stage.GetPrimAtPath(rootPath + "/Looks/mat1") if matPrim.IsValid(): UsdShade.MaterialBindingAPI(geomSubset1).Bind(UsdShade.Material(matPrim)) # Create subset 2. subsetPath = meshPath + "/submesh_2" geomSubset2 = UsdGeom.Subset.Define(stage, subsetPath) geomSubset2.CreateFamilyNameAttr("materialBind") geomSubset2.CreateElementTypeAttr("face") geomSubset2.CreateIndicesAttr([1]) # Set the index on the face. # Bind material. matPrim = stage.GetPrimAtPath(rootPath + "/Looks/mat2") if matPrim.IsValid(): UsdShade.MaterialBindingAPI(geomSubset2).Bind(UsdShade.Material(matPrim)) # -----------------------------------------------------------. # Create scope. looksScopePath = rootPath + "/Looks" scopePrim = stage.GetPrimAtPath(looksScopePath) if scopePrim.IsValid() == False: UsdGeom.Scope.Define(stage, looksScopePath) # Create material. createMaterialOmniPBR(rootPath + "/Looks/mat1", Gf.Vec3f(1.0, 0.0, 0.0)) createMaterialOmniPBR(rootPath + "/Looks/mat2", Gf.Vec3f(0.0, 1.0, 0.0)) # Create mesh. createMesh(rootPath + "/mesh")

Python

ft-lab/omniverse_sample_scripts/Geometry/CreateMesh/GetMeshInfo.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # ---------------------------------------. # Dump mesh data. # ---------------------------------------. def DumpMeshData (prim): typeName = prim.GetTypeName() if typeName == 'Mesh': m = UsdGeom.Mesh(prim) # Get prim name. name = prim.GetName() # Get prim path. path = prim.GetPath().pathString # Get show/hide. showF = (m.ComputeVisibility() == 'inherited') # Get the number of faces of Mesh. facesCou = len(m.GetFaceVertexCountsAttr().Get()) # Get number of normals. normalsCou = len(m.GetNormalsAttr().Get()) # Total number of vertices. versCou = len(m.GetPointsAttr().Get()) # Get UV. # USD 22.11 : The specification has been changed to use UsdGeom.PrimvarsAPI. primvarsAPI = UsdGeom.PrimvarsAPI(prim) primvars = primvarsAPI.GetPrimvars() uvsCou = 0 uvlayersCou = 0 for primvar in primvars: typeName = str(primvar.GetTypeName().arrayType) if typeName == 'float2[]' or typeName == 'texCoord2f[]': # 'st' pName = primvar.GetPrimvarName() uvlayersCou += 1 uvsCou = len(primvar.Get()) # Get Material. rel = UsdShade.MaterialBindingAPI(prim).GetDirectBindingRel() pathList = rel.GetTargets() print(f"[ {name} ] {path}") print(f"Show : {showF}") print(f"Points : {versCou}") print(f"Faces : {facesCou}") print(f"uvs : {uvsCou}") print(f"normals : {normalsCou}") print(f"UV sets : {uvlayersCou}") if len(pathList) > 0: print("Material : ") for mPath in pathList: print(f" {mPath.pathString}") print("") # ---------------------------------------. # Traverse the hierarchy. # ---------------------------------------. def TraverseHierarchy (prim): DumpMeshData(prim) # Recursively traverse the hierarchy. pChildren = prim.GetChildren() for cPrim in pChildren: TraverseHierarchy(cPrim) # ----------------------------------------------------. # Get stage. stage = omni.usd.get_context().get_stage() # Get selection. selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() for path in paths: # Get prim. prim = stage.GetPrimAtPath(path) TraverseHierarchy(prim)

Python

ft-lab/omniverse_sample_scripts/Geometry/CreateMesh/CreateGear.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import math import omni.ui # Get stage. stage = omni.usd.get_context().get_stage() # -------------------------------------------------------. # Calculate normal. # -------------------------------------------------------. def calcTriangleNormal (v1 : Gf.Vec3d, v2 : Gf.Vec3d, v3 : Gf.Vec3d): e1 = v2 - v1 e2 = v3 - v2 e1 = Gf.Vec4f(e1[0], e1[1], e1[2],1.0) e2 = Gf.Vec4f(e2[0], e2[1], e2[2],1.0) e3 = Gf.HomogeneousCross(e1, e2) n = Gf.Vec3d(e3[0], e3[1], e3[2]) return n.GetNormalized() # -------------------------------------------------------. # Attach thickness. # @param[in] primPath Target Prim path. # @param[in] thickness Thickness. # -------------------------------------------------------. def AttachThickness (primPath : str, thickness : float): prim = stage.GetPrimAtPath(primPath) if prim.IsValid() == False: return if prim.GetTypeName() != 'Mesh': return m = UsdGeom.Mesh(prim) # Number of faces. faceVCouList = m.GetFaceVertexCountsAttr().Get() faceCou = len(faceVCouList) if faceCou == 0: return normalsList = m.GetNormalsAttr().Get() normalsCou = len(normalsList) if normalsCou == 0: return normalV = normalsList[0] versList = m.GetPointsAttr().Get() versCou = len(versList) if versCou < 3: return faceVIList = m.GetFaceVertexIndicesAttr().Get() faceVICou = len(faceVIList) # Stores the face number for each vertex. vFList = [[]] * (versCou) for i in range(versCou): vFList[i] = [] index = 0 for i in range(len(faceVCouList)): faceVCou = faceVCouList[i] for j in range(faceVCou): vI = faceVIList[index + j] vFList[vI].append(i) index += faceVCou faceIndicesList = [[]] * faceCou for i in range(faceCou): faceIndicesList[i] = [] # Rearrange the vertex indices per face. index = 0 for i in range(faceCou): faceVCou = faceVCouList[i] for j in range(faceVCou): faceIndicesList[i].append(faceVIList[index + j]) index += faceVCou # Create a list of independent edges. edgesList = [] for i in range(faceCou): faceVCou = faceVCouList[i] for j in range(faceVCou): vI1 = faceIndicesList[i][j] vI2 = faceIndicesList[i][(j + 1) % faceVCou] chkF = False cI = -1 for k in range(len(edgesList)): if (edgesList[k][0] == vI1 and edgesList[k][1] == vI2) or (edgesList[k][0] == vI2 and edgesList[k][1] == vI1): chkF = True cI = k break if chkF == False: edgesList.append([vI1, vI2, 1]) else: cou = edgesList[cI][2] edgesList[cI] = [vI1, vI2, cou + 1] edgesOneList = [] for p in edgesList: if p[2] == 1: edgesOneList.append([p[0], p[1]]) # Create a symmetrical face. faceVCouList2 = [0] * (faceCou * 2) normalsList2 = [(0.0, 0.0, 0.0)] * (normalsCou * 2) versList2 = [(0.0, 0.0, 0.0)] * (versCou * 2) faceVIList2 = [0] * (faceVICou * 2) for i in range(faceCou): faceVCouList2[i] = faceVCouList[i] faceVCouList2[i + faceCou] = faceVCouList[i] for i in range(faceVICou): faceVIList2[i] = faceVIList[i] faceVIList2[i + faceVICou] = faceVIList[faceVICou - i - 1] + versCou for i in range(normalsCou): normalsList2[i] = normalsList[i] normalsList2[i + normalsCou] = -normalsList[i] for i in range(versCou): versList2[i] = versList[i] n = normalsList[i] versList2[i + versCou] = versList[i] - (n * thickness) # Create side faces. vIndex = len(versList2) for edgeI in edgesOneList: e1 = edgeI[0] e2 = edgeI[1] i1 = e1 i2 = e2 i3 = e1 + versCou i4 = e2 + versCou v1 = versList2[i2] v2 = versList2[i1] v3 = versList2[i3] v4 = versList2[i4] n = calcTriangleNormal(v1, v2, v3) faceVCouList2.append(4) for j in range(4): normalsList2.append(n) versList2.append(v1) versList2.append(v2) versList2.append(v3) versList2.append(v4) for j in range(4): faceVIList2.append(vIndex + j) vIndex += 4 m.CreatePointsAttr(versList2) m.CreateNormalsAttr(normalsList2) m.CreateFaceVertexCountsAttr(faceVCouList2) m.CreateFaceVertexIndicesAttr(faceVIList2) # -------------------------------------------------------. # Create gear. # @param[in] name Prim name. # @param[in] gearR Radius of gear. # @param[in] filletCount Number of gear divisions. # @param[in] filletHeight Fillet height. # @param[in] gearWidth Gear width. # -------------------------------------------------------. def CreateGear (name : str, gearR : float, filletCount : int, filletHeight : float, gearWidth : float): angle = 360.0 / filletCount # Angle of one tooth. # Calculate the length of one tooth on the circumference. D = (gearR * math.sin((angle / 2.0) * math.pi / 180.0)) * 2 dHalf = D * 0.5 dQuarter = D * 0.25 centerV = Gf.Vec3d(0, 0, 0) versList = [] versList.append(centerV) faceIndexList = [] maxVCou = 1 + (5 * filletCount) index = 1 aV = 0.0 for i in range(filletCount): # Vertices of a single tooth. vDirX = math.cos(aV * math.pi / 180.0) vDirY = math.sin(aV * math.pi / 180.0) v2X = -vDirY v2Y = vDirX vD = Gf.Vec3d(vDirX, vDirY, 0) vCrossD = Gf.Vec3d(v2X, v2Y, 0) vCenter = vD * gearR v1 = vCenter - (vCrossD * dHalf) v2 = v1 + (vCrossD * dQuarter) v3 = v2 + (vD * filletHeight) v4 = v3 + (vCrossD * dHalf) v5 = v4 - (vD * filletHeight) v6 = v5 + (vCrossD * dQuarter) dd = D * 0.1 vCD = vCrossD * dd v3 += vCD v4 -= vCD v2 -= vCD v5 += vCD versList.append(v1) versList.append(v2) versList.append(v3) versList.append(v4) versList.append(v5) faceIndexList.append(0) faceIndexList.append(index) faceIndexList.append(index + 1) faceIndexList.append(index + 2) faceIndexList.append(index + 3) faceIndexList.append(index + 4) if index + 5 >= maxVCou: faceIndexList.append(1) else: faceIndexList.append(index + 5) index += 5 aV += angle # Get default prim. defaultPrim = stage.GetDefaultPrim() # Get root path. rootPath = '/' if defaultPrim.IsValid(): rootPath = defaultPrim.GetPath().pathString # Create mesh. pathName = rootPath + '/gears' prim = stage.GetPrimAtPath(pathName) if prim.IsValid() == False: UsdGeom.Xform.Define(stage, pathName) pathMeshName0 = pathName + '/' + name pathMeshName = pathMeshName0 index = 0 while True: pathMeshName = pathMeshName0 if index > 0: pathMeshName += '_' + str(index) prim = stage.GetPrimAtPath(pathMeshName) if prim.IsValid() == False: break index += 1 meshGeom = UsdGeom.Mesh.Define(stage, pathMeshName) # Set vertices. stVersList = [] stNormalList = [] for i in range(len(versList)): stVersList.append((versList[i][0], versList[i][1], versList[i][2])) stNormalList.append((0, 0, 1)) meshGeom.CreatePointsAttr(stVersList) # Set normals. meshGeom.CreateNormalsAttr(stNormalList) # Set face vertex count. faceVCouList = [] for i in range(filletCount): faceVCouList.append(7) meshGeom.CreateFaceVertexCountsAttr(faceVCouList) # Set face vertex indices. meshGeom.CreateFaceVertexIndicesAttr(faceIndexList) # Set position. UsdGeom.XformCommonAPI(meshGeom).SetTranslate((0.0, 0.0, 0.0)) # Set rotation. UsdGeom.XformCommonAPI(meshGeom).SetRotate((0.0, 0.0, 0.0), UsdGeom.XformCommonAPI.RotationOrderXYZ) # Set scale. UsdGeom.XformCommonAPI(meshGeom).SetScale((1.0, 1.0, 1.0)) # Attach thickness. if gearWidth > 0.0: AttachThickness(pathMeshName, gearWidth) # --------------------------------------------------------. # Main UI. # --------------------------------------------------------. # Clicked button event. def onButtonClick (hNameStringField, hRadiusFloatField, hFilletCouIntField, hFilletHeightFloatField, hGearWidthFloatField): name = hNameStringField.model.get_value_as_string() if name == '': name = 'gear' radius = hRadiusFloatField.model.get_value_as_float() if radius < 0.00001: radius = 0.00001 filletCou = hFilletCouIntField.model.get_value_as_int() if filletCou < 4: filletCou = 4 filletHeight = hFilletHeightFloatField.model.get_value_as_float() if filletHeight < 0.00001: filletHeight = 0.00001 gearWidth = hGearWidthFloatField.model.get_value_as_float() if gearWidth < 0.00001: gearWidth = 0.00001 # Create Cear. CreateGear(name, radius, filletCou, filletHeight, gearWidth) # ------------------------------------------. my_window = omni.ui.Window("Create Gear", width=350, height=250) with my_window.frame: with omni.ui.VStack(height=0): labelWidth = 120 with omni.ui.Placer(offset_x=8, offset_y=8): # Set label. f = omni.ui.Label("Create Gear.") with omni.ui.Placer(offset_x=8, offset_y=4): with omni.ui.HStack(width=300): omni.ui.Label("Name : ", width=labelWidth) hNameStringField = omni.ui.StringField(width=200, height=0) hNameStringField.model.set_value("gear") with omni.ui.Placer(offset_x=8, offset_y=4): with omni.ui.HStack(width=300): omni.ui.Label("Radius : ", width=labelWidth) hRadiusFloatField = omni.ui.FloatField(width=200, height=0) hRadiusFloatField.model.set_value(10.0) with omni.ui.Placer(offset_x=8, offset_y=4): with omni.ui.HStack(width=300): omni.ui.Label("Number of fillet : ", width=labelWidth) hFilletCouIntField = omni.ui.IntField(width=200, height=0) hFilletCouIntField.model.set_value(32) with omni.ui.Placer(offset_x=8, offset_y=4): with omni.ui.HStack(width=300): omni.ui.Label("Fillet height : ", width=labelWidth) hFilletHeightFloatField = omni.ui.FloatField(width=200, height=0) hFilletHeightFloatField.model.set_value(1.0) with omni.ui.Placer(offset_x=8, offset_y=4): with omni.ui.HStack(width=300): omni.ui.Label("Gear width : ", width=labelWidth) hGearWidthFloatField = omni.ui.FloatField(width=200, height=0) hGearWidthFloatField.model.set_value(2.0) with omni.ui.Placer(offset_x=8, offset_y=4): # Set button. btn = omni.ui.Button("Create", width=200, height=0) btn.set_clicked_fn(lambda name = hNameStringField, f = hRadiusFloatField, f2 = hFilletCouIntField, f3 = hFilletHeightFloatField, f4 = hGearWidthFloatField: onButtonClick(name, f, f2, f3, f4))

Python

ft-lab/omniverse_sample_scripts/Geometry/CreateMesh/CreateMeshInterpolation.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Get default prim. defaultPrim = stage.GetDefaultPrim() # Get root path. rootPath = '/' if defaultPrim.IsValid(): rootPath = defaultPrim.GetPath().pathString # ------------------------------------------------. # Create mesh. # @param[in] path Prim path. # @param[in] interpolation "vertex" or "faceVarying". # ------------------------------------------------. def createTestMesh (path : str, interpolation : str = "vertex", pos : Gf.Vec3f = Gf.Vec3f(0, 0, 0)): if interpolation != "vertex" and interpolation != "faceVarying": return # Create mesh. meshGeom = UsdGeom.Mesh.Define(stage, path) # Set vertices. meshGeom.CreatePointsAttr([(-10, 0, -10), (0, 0, -10), (10, 0, -10), (-10, 0, 0), (0, 0, 0), (10, 0, 0)]) # Set face vertex count. meshGeom.CreateFaceVertexCountsAttr([4, 4]) # Set face vertex indices. meshGeom.CreateFaceVertexIndicesAttr([0, 3, 4, 1, 1, 4, 5, 2]) if interpolation == "vertex": # Set normals and UVs for each vertex. # Set normals. meshGeom.CreateNormalsAttr([(0.0, 1.0, 0.0), (0.0, 1.0, 0.0), (0.0, 1.0, 0.0), (0.0, 1.0, 0.0), (0.0, 1.0, 0.0), (0.0, 1.0, 0.0)]) meshGeom.SetNormalsInterpolation("vertex") # Set uvs. # USD 22.11 : The specification has been changed to use UsdGeom.PrimvarsAPI. primvarV = UsdGeom.PrimvarsAPI(meshGeom).CreatePrimvar("st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.vertex) attr = primvarV.GetAttr() attr.Set([(0.0, 1.0), (1.0, 1.0), (2.0, 1.0), (0.0, 0.0), (1.0, 0.0), (2.0, 0.0)]) else: # Set normals and UVs for each face vertex. # Set normals. normalList = [] for i in range(2): normalList.extend([(0.0, 1.0, 0.0), (0.0, 1.0, 0.0), (0.0, 1.0, 0.0), (0.0, 1.0, 0.0)]) meshGeom.CreateNormalsAttr(normalList) meshGeom.SetNormalsInterpolation("faceVarying") # Set uvs. primvarV = UsdGeom.PrimvarsAPI(meshGeom).CreatePrimvar("st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.faceVarying) attr = primvarV.GetAttr() uvsList = [] uvsList.extend([(0.0, 1.0), (0.0, 0.0), (1.0, 0.0), (1.0, 1.0)]) uvsList.extend([(1.0, 1.0), (1.0, 0.0), (2.0, 0.0), (2.0, 1.0)]) attr.Set(uvsList) # Subdivision is set to none. meshGeom.CreateSubdivisionSchemeAttr().Set("none") # Set position. UsdGeom.XformCommonAPI(meshGeom).SetTranslate((pos[0], pos[1], pos[2])) # Set rotation. UsdGeom.XformCommonAPI(meshGeom).SetRotate((0.0, 0.0, 0.0), UsdGeom.XformCommonAPI.RotationOrderXYZ) # Set scale. UsdGeom.XformCommonAPI(meshGeom).SetScale((1.0, 1.0, 1.0)) # -----------------------------------------------. createTestMesh(rootPath + "/mesh_vertex", "vertex", Gf.Vec3f(0, 0, 0)) createTestMesh(rootPath + "/mesh_faceVarying", "faceVarying", Gf.Vec3f(0, 0, 20))

Python

ft-lab/omniverse_sample_scripts/Geometry/CreateCube/CreateCube.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Create cube. pathName = '/World/cube' cubeGeom = UsdGeom.Cube.Define(stage, pathName) # Set cube size. cubeGeom.CreateSizeAttr(10.0) # Set color. cubeGeom.CreateDisplayColorAttr([(0.0, 1.0, 0.0)]) # Set position. UsdGeom.XformCommonAPI(cubeGeom).SetTranslate((0.0, 5.0, 0.0)) # Set scale. UsdGeom.XformCommonAPI(cubeGeom).SetScale((2.0, 1.0, 2.0))

Python

ft-lab/omniverse_sample_scripts/Geometry/CreateSphere/GetSphereInfo.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, UsdSkel, Sdf, Gf, Tf xformCache = UsdGeom.XformCache(0) # ---------------------------------------. # Dump sphere data. # ---------------------------------------. def DumpSphereData (prim): typeName = prim.GetTypeName() if typeName == 'Sphere': sphereGeom = UsdGeom.Sphere(prim) # Get prim name. name = prim.GetName() # Get prim path. path = prim.GetPath().pathString # Get show/hide. showF = (sphereGeom.ComputeVisibility() == 'inherited') # Decompose transform. globalPose = xformCache.GetLocalToWorldTransform(prim) translate, rotation, scale = UsdSkel.DecomposeTransform(globalPose) # Get radius. r = sphereGeom.GetRadiusAttr().Get() # Get Material. rel = UsdShade.MaterialBindingAPI(prim).GetDirectBindingRel() pathList = rel.GetTargets() print(f"[ {name} ] {path}") print(f"Show : {showF}") print(f"Radius : {r * scale[0]} , {r * scale[1]} , {r * scale[2]}") if len(pathList) > 0: print("Material : ") for mPath in pathList: print(f" {mPath.pathString}") print("") # ---------------------------------------. # Traverse the hierarchy. # ---------------------------------------. def TraverseHierarchy (prim): DumpSphereData(prim) # Recursively traverse the hierarchy. pChildren = prim.GetChildren() for cPrim in pChildren: TraverseHierarchy(cPrim) # ----------------------------------------------------. # Get stage. stage = omni.usd.get_context().get_stage() # Get selection. selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() for path in paths: # Get prim. prim = stage.GetPrimAtPath(path) TraverseHierarchy(prim)

Python

ft-lab/omniverse_sample_scripts/Geometry/CreateSphere/CReateSphereWithRefinement.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Create sphere. pathName = '/World/sphere' sphereGeom = UsdGeom.Sphere.Define(stage, pathName) # Set radius. sphereGeom.CreateRadiusAttr(5.0) # Set color. sphereGeom.CreateDisplayColorAttr([(1.0, 0.0, 0.0)]) # Set position. UsdGeom.XformCommonAPI(sphereGeom).SetTranslate((0.0, 5.0, 0.0)) # Set refinement. objPrim = stage.GetPrimAtPath(pathName) objPrim.CreateAttribute('refinementEnableOverride', Sdf.ValueTypeNames.Bool).Set(True) objPrim.CreateAttribute('refinementLevel', Sdf.ValueTypeNames.Int).Set(2)

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.hello/ft_lab/sample/hello/hello.py

import omni.ext # Any class derived from `omni.ext.IExt` in top level module (defined in `python.modules` of `extension.toml`) will be # instantiated when extension gets enabled and `on_startup(ext_id)` will be called. Later when extension gets disabled # on_shutdown() is called. class HelloExtension(omni.ext.IExt): # ext_id is current extension id. It can be used with extension manager to query additional information, like where # this extension is located on filesystem. def on_startup(self, ext_id): print("[ft_lab.sample.hello] HelloExtension startup") def on_shutdown(self): print("[ft_lab.sample.hello] HelloExtension shutdown")

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.hello/ft_lab/sample/hello/__init__.py

from .hello import *

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.loadStage/ft_lab/sample/loadStage/main.py

from pxr import Usd, UsdGeom, UsdShade, Sdf, Gf, Tf import omni.ext from pathlib import Path class LoadStageExtension(omni.ext.IExt): def on_startup(self, ext_id): print("[ft_lab.sample.loadStage] LoadStageExtension startup") # Get USD file. usdPath = Path(__file__).parent.joinpath("usd") usdFile = f"{usdPath}/test.usd" # Load stage. omni.usd.get_context().open_stage(usdFile) def on_shutdown(self): print("[ft_lab.sample.loadStage] LoadStageExtension shutdown")

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.loadStage/ft_lab/sample/loadStage/__init__.py

from .main import *

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.uiSceneDraw/ft_lab/sample/uiSceneDraw/main.py

import omni.ext import omni.ui from omni.ui import color as cl from omni.ui import scene as sc from pathlib import Path import math # -------------------------------------. # Scene draw process. # -------------------------------------. class SceneDraw(sc.Manipulator): _angle1 = 0.0 _angle2 = 0.0 def __init__(self, **kwargs): super().__init__(**kwargs) self._angle1 = 0.0 self._angle2 = 45.0 def on_build(self): # Consider the order. This uses the z-value Depth. # -1.0 < depth <= 0.0 depth = 0.0 moveT = sc.Matrix44.get_translation_matrix(0.0, 0.0, depth) with sc.Transform(transform=moveT): sc.Rectangle(2.0, 2.0, wireframe=False, color=cl("#003000")) depth = -0.1 rotT = sc.Matrix44.get_rotation_matrix(0, 0, self._angle1, True) moveT = sc.Matrix44.get_translation_matrix(0.25, 0.3, depth) viewT = moveT * rotT with sc.Transform(transform=viewT): sc.Rectangle(1.5, 0.15, wireframe=False, color=cl("#3030ff")) depth = -0.15 rotT = sc.Matrix44.get_rotation_matrix(0, 0, self._angle2, True) moveT = sc.Matrix44.get_translation_matrix(-0.25, -0.1, depth) viewT = moveT * rotT with sc.Transform(transform=viewT): sc.Rectangle(1.5, 0.15, wireframe=False, color=cl("#ff3030")) self._angle1 = math.fmod(self._angle1 + 0.2, 360.0) self._angle2 = math.fmod(self._angle2 + 0.1, 360.0) self.invalidate() # ----------------------------------------------------------. class UISceneDrawExtension(omni.ext.IExt): _window = None _scene_view = None # ------------------------------------------------. # Init window. # ------------------------------------------------. def init_window (self): imagesPath = Path(__file__).parent.joinpath("images") # Create new window. self._window = omni.ui.Window("UI Scene Draw Window", width=400, height=400) # ------------------------------------------. with self._window.frame: # Create window UI. with omni.ui.VStack(height=0): omni.ui.Spacer(height=4) omni.ui.Label("Use omni.ui.scene for custom drawing.") omni.ui.Spacer(height=4) self._scene_view = sc.SceneView( aspect_ratio_policy=sc.AspectRatioPolicy.PRESERVE_ASPECT_FIT, height=300 ) with self._scene_view.scene: SceneDraw() # ------------------------------------------------. # Term window. # ------------------------------------------------. def term_window (self): if self._window != None: self._window = None # ------------------------------------------------. # Startup. # ------------------------------------------------. def on_startup(self, ext_id): self.init_window() # ------------------------------------------------. # Shutdown. # ------------------------------------------------. def on_shutdown(self): self.term_window()

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.menu/ft_lab/sample/menu/main.py

import omni.ext import asyncio import omni.kit.menu.utils import omni.kit.undo import omni.kit.commands import omni.usd from omni.kit.menu.utils import MenuItemDescription class MenuExtension(omni.ext.IExt): # Menu list. _menu_list = None _sub_menu_list = None # Menu name. _menu_name = "MenuTest" # ------------------------------------------. # Initialize menu. # ------------------------------------------. def init_menu (self): async def _rebuild_menus(): await omni.kit.app.get_app().next_update_async() omni.kit.menu.utils.rebuild_menus() def menu_select (mode): if mode == 0: print("Select MenuItem 1.") if mode == 1: print("Select MenuItem 2.") if mode == 2: print("Select MenuItem 3.") if mode == 10: print("Select Sub MenuItem 1.") if mode == 11: print("Select Sub MenuItem 2.") self._sub_menu_list = [ MenuItemDescription(name="Sub MenuItem 1", onclick_fn=lambda: menu_select(10)), MenuItemDescription(name="Sub MenuItem 2", onclick_fn=lambda: menu_select(11)), ] self._menu_list = [ MenuItemDescription(name="MenuItem 1", onclick_fn=lambda: menu_select(0)), MenuItemDescription(name="MenuItem 2", onclick_fn=lambda: menu_select(1)), MenuItemDescription(name="MenuItem 3", onclick_fn=lambda: menu_select(2)), MenuItemDescription(), MenuItemDescription(name="SubMenu", sub_menu=self._sub_menu_list), ] # Rebuild with additional menu items. omni.kit.menu.utils.add_menu_items(self._menu_list, self._menu_name) asyncio.ensure_future(_rebuild_menus()) # ------------------------------------------. # Term menu. # It seems that the additional items in the top menu will not be removed. # ------------------------------------------. def term_menu (self): async def _rebuild_menus(): await omni.kit.app.get_app().next_update_async() omni.kit.menu.utils.rebuild_menus() # Remove and rebuild the added menu items. omni.kit.menu.utils.remove_menu_items(self._menu_list, self._menu_name) asyncio.ensure_future(_rebuild_menus()) # ------------------------------------------. def on_startup(self, ext_id): print("[ft_lab.sample.menu] MenuExtension startup") # Initialize menu. self.init_menu() def on_shutdown(self): print("[ft_lab.sample.menu] MenuExtension shutdown") # Term menu. self.term_menu()

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.callDLL/ft_lab/sample/callDLL/__init__.py

from .callDLL import *

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.callDLL/ft_lab/sample/callDLL/callDLL.py

import omni.ext from ctypes import * # Load library. # Add the search path for [[native.library]] to "config/extension.toml". dll = cdll.LoadLibrary(r"OmniverseSimpleDLL.dll") # ----------------------------------------------------. # Call external function. # ----------------------------------------------------. def callExtFunc(): if dll == None: return v = dll.ext_add(3, 8) print("dll.ext_add(3, 8) : " + str(v)) v2 = dll.ext_sub(3, 8) print("dll.ext_sub(3, 8) : " + str(v2)) # ----------------------------------------------------. class CallDLLExtension(omni.ext.IExt): def on_startup(self, ext_id): print("[ft_lab.sample.callDLL] HelloExtension startup") callExtFunc() def on_shutdown(self): print("[ft_lab.sample.callDLL] HelloExtension shutdown")

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.widgets_progressBar/ft_lab/sample/widgets_progressBar/extension.py

import omni.ext import omni.ui from pathlib import Path import os.path import carb.tokens import carb.events import time # ----------------------------------------------------------. class WidgetsExtension(omni.ext.IExt): _window = None _btn = None # omni.ui.Button. _progressBar = None # omni.ui.ProgressBar. _progressValue = 0.2 # PrograssBar value. _progressStart = True # True if Progress is to proceed. _subs = None # Update Events. _timeV = 0 # ------------------------------------. # Update event. # ------------------------------------. def on_update (self, e: carb.events.IEvent): # Processing every 0.2 seconds. curTimeV = time.time() if curTimeV - self._timeV > 0.2: self._timeV = curTimeV # Update progressBar. if self._progressStart: self._progressValue += 0.05 if self._progressValue > 1.0: self._progressValue -= 1.0 self._progressBar.model.set_value(self._progressValue) # ------------------------------------------------. # Init window. # ------------------------------------------------. def init_window (self): self._progressStart = True self._timeV = time.time() # Create new window. self._window = omni.ui.Window("Widgets Window(ProgressBar)", width=300, height=100) # Callback when button is clicked. def onButtonClicked (self): if self._progressStart: self._progressStart = False else: self._progressStart = True # Change button text. if self._progressStart: self._btn.text = "Stop" else: self._btn.text = "Start" # ------------------------------------------. with self._window.frame: # Create window UI. with omni.ui.VStack(height=0): # ------------------------------------------. # ProgressBar & Button. # ------------------------------------------. omni.ui.Spacer(height=4) self._progressBar = omni.ui.ProgressBar(height=14, style={"color": 0xffdd0000}) self._progressBar.model.set_value(self._progressValue) omni.ui.Spacer(height=4) self._btn = omni.ui.Button(" Button ") self._btn.set_clicked_fn(lambda s = self : onButtonClicked(s)) if self._progressStart: self._btn.text = "Stop" else: self._btn.text = "Start" omni.ui.Spacer(height=4) # Register for update events. # To clear the event, specify "subs=None". self._subs = omni.kit.app.get_app().get_update_event_stream().create_subscription_to_pop(self.on_update) # ------------------------------------------------. # Term window. # ------------------------------------------------. def term_window (self): if self._subs != None: self._subs = None if self._window != None: self._window = None # ------------------------------------------------. # Startup. # ------------------------------------------------. def on_startup(self, ext_id): self.init_window() # ------------------------------------------------. # Shutdown. # ------------------------------------------------. def on_shutdown(self): self.term_window()

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.widgets/ft_lab/sample/widgets/extension.py

import omni.ext import omni.ui from pathlib import Path import os.path import carb.tokens # ----------------------------------------------------------. class WidgetsExtension(omni.ext.IExt): _window = None _sField = None _label0 = None _radioCollection = None _label1 = None _checkbox = None _label2 = None _combobox = None _label3 = None _slider = None _label4 = None # ------------------------------------------------. # Init window. # ------------------------------------------------. def init_window (self): imagesPath = Path(__file__).parent.joinpath("images") # Create new window. self._window = omni.ui.Window("Widgets Window", width=300, height=400) # Radio Button Style. style = { "": {"background_color": 0x0, "image_url": f"{imagesPath}/radio_off.svg"}, ":checked": {"image_url": f"{imagesPath}/radio_on.svg"}, } def onButtonClicked (uiFieldModel, uiLabel): if not uiFieldModel or not uiLabel: return v = uiFieldModel.model.get_value_as_string() uiLabel.text = "Input : " + v def onRadioValueChanged (uiFieldModel, uiLabel): if not uiFieldModel or not uiLabel: return v = uiFieldModel.get_value_as_int() uiLabel.text = "Select Radio : " + str(v) def onCheckBoxValueChanged (uiFieldModel, uiLabel): if not uiFieldModel or not uiLabel: return b = uiFieldModel.get_value_as_bool() uiLabel.text = "CheckBox : " + str(b) def onComboBoxValueChanged (uiFieldModel, uiLabel): if not uiFieldModel or not uiLabel: return v = uiFieldModel.get_value_as_int() uiLabel.text = "ComboBox : " + str(v) def onSliderValueChanged (uiFieldModel, uiLabel): if not uiFieldModel or not uiLabel: return v = uiFieldModel.get_value_as_float() uiLabel.text = "Slider : " + str(v) # ------------------------------------------. with self._window.frame: # Create window UI. with omni.ui.VStack(height=0): # ------------------------------------------. # StringField & Button. # ------------------------------------------. omni.ui.Spacer(height=4) self._sField = omni.ui.StringField(width=120, height=14, style={"color": 0xffffffff}) self._sField.model.set_value("xxx") omni.ui.Spacer(height=4) omni.ui.Spacer(height=4) btn = omni.ui.Button(" Button ") omni.ui.Spacer(height=4) # Label. with omni.ui.HStack(width=0): omni.ui.Spacer(width=8) self._label0 = omni.ui.Label("") btn.set_clicked_fn(lambda s = self._sField, l = self._label0: onButtonClicked(s, l)) # Separator. omni.ui.Spacer(height=4) omni.ui.Line(style={"border_width":2, "color":0xff202020}) omni.ui.Spacer(height=4) # ------------------------------------------. # Radio Button. # ------------------------------------------. # Radio button. self._radioCollection = omni.ui.RadioCollection() radioLBtnList = [] with omni.ui.HStack(width=0): for i in range(3): with omni.ui.HStack(style=style): radio = omni.ui.RadioButton(radio_collection=self._radioCollection, width=30, height=30) omni.ui.Label(f"Radio {i} ", name="text") radioLBtnList.append(radio) # Label. with omni.ui.HStack(width=0): omni.ui.Spacer(width=8) self._label1 = omni.ui.Label("") # Update label. onRadioValueChanged(self._radioCollection.model, self._label1) for radio in radioLBtnList: radio.set_clicked_fn(lambda f = self._radioCollection.model, l = self._label1: onRadioValueChanged(f, l)) # Separator. omni.ui.Spacer(height=4) omni.ui.Line(style={"border_width":2, "color":0xff202020}) omni.ui.Spacer(height=4) # ------------------------------------------. # CheckBox. # ------------------------------------------. # CheckBox omni.ui.Spacer(height=4) with omni.ui.HStack(width=0): self._checkbox = omni.ui.CheckBox() omni.ui.Label(" CheckBox") omni.ui.Spacer(height=4) # Label. with omni.ui.HStack(width=0): omni.ui.Spacer(width=8) self._label2 = omni.ui.Label("") # Update label. onCheckBoxValueChanged(self._checkbox.model, self._label2) self._checkbox.model.add_value_changed_fn(lambda f = self._checkbox.model, l = self._label2: onCheckBoxValueChanged(f, l)) # Separator. omni.ui.Spacer(height=4) omni.ui.Line(style={"border_width":2, "color":0xff202020}) omni.ui.Spacer(height=4) # ------------------------------------------. # ComboBox. # ------------------------------------------. # ComboBox omni.ui.Spacer(height=4) self._combobox = omni.ui.ComboBox(1, "Item1", "Item2", "Item3") omni.ui.Spacer(height=4) # Label. with omni.ui.HStack(width=0): omni.ui.Spacer(width=8) self._label3 = omni.ui.Label("") # Update label. onComboBoxValueChanged(self._combobox.model.get_item_value_model(), self._label3) cModel = self._combobox.model.get_item_value_model() cModel.add_value_changed_fn(lambda f = cModel, l = self._label3: onComboBoxValueChanged(f, l)) # Separator. omni.ui.Spacer(height=4) omni.ui.Line(style={"border_width":2, "color":0xff202020}) omni.ui.Spacer(height=4) # ------------------------------------------. # Slider. # ------------------------------------------. # Slider. omni.ui.Spacer(height=4) self._slider = omni.ui.FloatSlider(min=0.0, max=10.0) self._slider.model.set_value(1.2) omni.ui.Spacer(height=4) # Label. with omni.ui.HStack(width=0): omni.ui.Spacer(width=8) self._label4 = omni.ui.Label("") onSliderValueChanged(self._slider.model, self._label4) self._slider.model.add_value_changed_fn(lambda f = self._slider.model, l = self._label4: onSliderValueChanged(f, l)) # Separator. omni.ui.Spacer(height=4) omni.ui.Line(style={"border_width":2, "color":0xff202020}) omni.ui.Spacer(height=4) # ------------------------------------------. # Image. # ------------------------------------------. # Kit file path. kitAbsPath = os.path.abspath(carb.tokens.get_tokens_interface().resolve("${kit}")) # Load image (RGBA). imagePath = Path(kitAbsPath).joinpath("resources").joinpath("desktop-icons") imagePath = f"{imagePath}/omniverse_64.png" omni.ui.Image(imagePath, width=64, height=64) # ------------------------------------------------. # Term window. # ------------------------------------------------. def term_window (self): if self._window != None: self._window = None # ------------------------------------------------. # Startup. # ------------------------------------------------. def on_startup(self, ext_id): self.init_window() # ------------------------------------------------. # Shutdown. # ------------------------------------------------. def on_shutdown(self): self.term_window()

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.uiSceneViewportOverlay/ft_lab/sample/uiSceneViewportOverlay/extension.py

from pxr import Usd, UsdGeom, CameraUtil, UsdShade, Sdf, Gf, Tf import omni.ext import omni.ui from omni.ui import color as cl from omni.ui import scene as sc import omni.kit from pathlib import Path import math # Kit104 : changed from omni.kit.viewport_legacy to omni.kit.viewport.utility.get_active_viewport_window import omni.kit.viewport.utility # Reference : https://github.com/NVIDIA-Omniverse/kit-extension-sample-ui-scene # ----------------------------------------------------------. class UISceneViewportOverlayExtension(omni.ext.IExt): _scene_view = None _stage = None _viewport_api = None _active_vp_window = None # ------------------------------------------------. # Init window. # ------------------------------------------------. def init_window (self, ext_id : str): imagesPath = Path(__file__).parent.joinpath("images") # Get current stage. self._stage = omni.usd.get_context().get_stage() # Kit104 : Get active viewport window. self._active_vp_window = omni.kit.viewport.utility.get_active_viewport_window() self._viewport_api = self._active_vp_window.viewport_api with self._active_vp_window.get_frame(ext_id): self._scene_view = sc.SceneView() with self._scene_view.scene: # Edges of cube cubeSize = 100.0 sc.Line([-cubeSize, -cubeSize, -cubeSize], [cubeSize, -cubeSize, -cubeSize]) sc.Line([-cubeSize, cubeSize, -cubeSize], [cubeSize, cubeSize, -cubeSize]) sc.Line([-cubeSize, -cubeSize, cubeSize], [cubeSize, -cubeSize, cubeSize]) sc.Line([-cubeSize, cubeSize, cubeSize], [cubeSize, cubeSize, cubeSize]) sc.Line([-cubeSize, -cubeSize, -cubeSize], [-cubeSize, cubeSize, -cubeSize]) sc.Line([cubeSize, -cubeSize, -cubeSize], [cubeSize, cubeSize, -cubeSize]) sc.Line([-cubeSize, -cubeSize, cubeSize], [-cubeSize, cubeSize, cubeSize]) sc.Line([cubeSize, -cubeSize, cubeSize], [cubeSize, cubeSize, cubeSize]) sc.Line([-cubeSize, -cubeSize, -cubeSize], [-cubeSize, -cubeSize, cubeSize]) sc.Line([-cubeSize, cubeSize, -cubeSize], [-cubeSize, cubeSize, cubeSize]) sc.Line([cubeSize, -cubeSize, -cubeSize], [cubeSize, -cubeSize, cubeSize]) sc.Line([cubeSize, cubeSize, -cubeSize], [cubeSize, cubeSize, cubeSize]) # Use Transform to change position. moveT = sc.Matrix44.get_translation_matrix(0, 0, 0) with sc.Transform(transform=moveT): sc.Label("Hello Omniverse !!", alignment = omni.ui.Alignment.CENTER, color=cl("#ffff00a0"), size=20) # Register the SceneView with the Viewport to get projection and view updates self._viewport_api.add_scene_view(self._scene_view) # ------------------------------------------------. # Term window. # ------------------------------------------------. def term_window (self): if self._scene_view: # Empty the SceneView of any elements it may have self._scene_view.scene.clear() # Be a good citizen, and un-register the SceneView from Viewport updates if self._active_vp_window: self._active_vp_window.viewport_api.remove_scene_view(self._scene_view) self._active_vp_window = None # ------------------------------------------------. # Startup. # ------------------------------------------------. def on_startup(self, ext_id): self.init_window(ext_id) # ------------------------------------------------. # Shutdown. # ------------------------------------------------. def on_shutdown(self): self.term_window()

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.uiSceneShowPrimName/ft_lab/sample/uiSceneShowPrimName/extension.py

from pxr import Usd, UsdGeom, CameraUtil, UsdShade, UsdSkel, Sdf, Gf, Tf import omni.ext import omni.ui from omni.ui import color as cl from omni.ui import scene as sc import omni.kit import omni.kit.app import carb.events from pathlib import Path import time # Kit104 : changed from omni.kit.viewport_legacy to omni.kit.viewport.utility.get_active_viewport_window import omni.kit.viewport.utility # Reference : https://github.com/NVIDIA-Omniverse/kit-extension-sample-ui-scene # -------------------------------------. # Scene draw process. # -------------------------------------. class SceneDraw (sc.Manipulator): _viewport_api = None def __init__(self, viewport_api, **kwargs): super().__init__ (**kwargs) # Set Viewport API. self._viewport_api = viewport_api # -------------------------------------------. # Repaint. # -------------------------------------------. def on_build (self): stage = omni.usd.get_context().get_stage() # Get selection. selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() time_code = Usd.TimeCode.Default() xformCache = UsdGeom.XformCache(time_code) for path in paths: prim = stage.GetPrimAtPath(path) if prim.IsValid(): # Get world Transform. globalPose = xformCache.GetLocalToWorldTransform(prim) # Decompose transform. translate, rotation, scale = UsdSkel.DecomposeTransform(globalPose) # World to NDC space (X : -1.0 to +1.0, Y : -1.0 to +1.0). ndc_pos = self._viewport_api.world_to_ndc.Transform(translate) # Translation matrix. moveT = sc.Matrix44.get_translation_matrix(ndc_pos[0], ndc_pos[1], 0.0) # Draw prim name. with sc.Transform(transform=moveT): sc.Label(prim.GetName(), alignment = omni.ui.Alignment.CENTER, color=cl("#ffff00a0"), size=20) # ----------------------------------------------------------. class UISceneShowPrimNameExtension(omni.ext.IExt): _scene_view = None _stage = None _sceneDraw = None _time = 0 _selectedPrimPaths = None _active_vp_window = None _viewport_api = None _active_viewport_name = "" _ext_id = "" # ------------------------------------------------. # Update event. # Update when selection shape changes. # Update when the active viewport is switched. # ------------------------------------------------. def on_update (self, e: carb.events.IEvent): # Check every 0.2 seconds. curTime = time.time() diffTime = curTime - self._time if diffTime > 0.2: self._time = curTime # Get selection. selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() # Selection changed. if self._selectedPrimPaths == None or self._selectedPrimPaths != paths: self._selectedPrimPaths = paths # Update drawing. if self._sceneDraw != None: self._sceneDraw.invalidate() # If the active viewport name has changed. active_vp_window = omni.kit.viewport.utility.get_active_viewport_window() if active_vp_window != None and active_vp_window.name != self._active_viewport_name: # Rebuild overlay. self.term_window() self.init_window(self._ext_id) # ------------------------------------------------. # Init window. # ------------------------------------------------. def init_window (self, ext_id : str): self._ext_id = ext_id # Get current stage. self._stage = omni.usd.get_context().get_stage() self._time = time.time() # Kit104 : Get active viewport window. self._active_vp_window = omni.kit.viewport.utility.get_active_viewport_window() # Get viewport API. self._viewport_api = self._active_vp_window.viewport_api # Register a callback to be called when the camera in the viewport is changed. self._subs_viewport_change = self._viewport_api.subscribe_to_view_change(self._viewport_changed) with self._active_vp_window.get_frame(ext_id): self._scene_view = sc.SceneView() # Add the manipulator into the SceneView's scene with self._scene_view.scene: ObjectInfoManipulator(model=ObjectInfoModel()) # Register the SceneView with the Viewport to get projection and view updates self._viewport_api.add_scene_view(self._scene_view) # ------------------------------------------------. # Term window. # ------------------------------------------------. def term_window (self): if self._scene_view: # Empty the SceneView of any elements it may have self._scene_view.scene.clear() # Be a good citizen, and un-register the SceneView from Viewport updates if self._active_vp_window: self._active_vp_window.viewport_api.remove_scene_view(self._scene_view) self._active_vp_window = None # ------------------------------------------------. # Startup. # ------------------------------------------------. def on_startup(self, ext_id): self.init_window(ext_id) # ------------------------------------------------. # Shutdown. # ------------------------------------------------. def on_shutdown(self): self.term_window()

Python

ft-lab/omniverse_sample_scripts/Extensions/ft_lab.sample.uiScene/ft_lab/sample/uiScene/extension.py

import omni.ext import omni.ui from omni.ui import color as cl from omni.ui import scene as sc from pathlib import Path # ----------------------------------------------------------. class UISceneExtension(omni.ext.IExt): _window = None _scene_view = None # ------------------------------------------------. # Init window. # ------------------------------------------------. def init_window (self): imagesPath = Path(__file__).parent.joinpath("images") # Create new window. self._window = omni.ui.Window("UI Scene Window", width=300, height=400) # ------------------------------------------. with self._window.frame: # Create window UI. with omni.ui.VStack(height=0): omni.ui.Spacer(height=4) omni.ui.Label("Use omni.ui.scene for custom drawing.") omni.ui.Spacer(height=4) self._scene_view = sc.SceneView( aspect_ratio_policy=sc.AspectRatioPolicy.PRESERVE_ASPECT_FIT, height=200 ) with self._scene_view.scene: sc.Line([-1.0, -1.0, 0], [1.0, 1.0, 0], color=cl.red, thickness=2) sc.Line([-1.0, 1.0, 0], [1.0, -1.0, 0], color=cl.green, thickness=1) sc.Arc(0.5, color=cl("#5040ff")) sc.Rectangle(0.3, 0.3, wireframe=False, color=cl("#c0ff00")) # Use Transform to change position. moveT = sc.Matrix44.get_translation_matrix(0.0, -0.8, 0) with sc.Transform(transform=moveT): sc.Label("Test", alignment = omni.ui.Alignment.CENTER, color=cl.black, size=20) # ------------------------------------------------. # Term window. # ------------------------------------------------. def term_window (self): if self._window != None: self._window = None # ------------------------------------------------. # Startup. # ------------------------------------------------. def on_startup(self, ext_id): self.init_window() # ------------------------------------------------. # Shutdown. # ------------------------------------------------. def on_shutdown(self): self.term_window()

Python

ft-lab/omniverse_sample_scripts/Rendering/Capture/CaptureRenderingColorToBuffer.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import asyncio from PIL import Image import ctypes import carb from omni.kit.viewport.utility import get_active_viewport, capture_viewport_to_buffer # See also : https://forums.developer.nvidia.com/t/how-to-get-the-backbuffer-of-omniverses-current-viewport/236825 # -------------------------------------------. # Capture LDR. # -------------------------------------------. async def capture(): # Get active viewport. active_viewport = get_active_viewport() await active_viewport.wait_for_rendered_frames() # Called when capture is complete. callbackExit = False def capture_callback(buffer, buffer_size, width, height, format): nonlocal callbackExit print(f"Buffer size : {buffer_size}") print(f"Resolution : {width} x {height} ") print(f"TextureFormat : {format}") # TextureFormat.RGBA8_UNORM # Get capture image. if str(format) == "TextureFormat.RGBA8_UNORM": # Get buffer from void *. try: ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.POINTER(ctypes.c_byte * buffer_size) ctypes.pythonapi.PyCapsule_GetPointer.argtypes = [ctypes.py_object, ctypes.c_char_p] content = ctypes.pythonapi.PyCapsule_GetPointer(buffer, None) except Exception as e: carb.log_error(f"Failed to get capture buffer: {e}") callbackExit = True return # Create image. # content.contents is RGBA buffers. image = Image.frombytes("RGBA", (width, height), content.contents) # Show. image.show() callbackExit = True # Capturing. cap_obj = capture_viewport_to_buffer(active_viewport, capture_callback) await omni.kit.app.get_app_interface().next_update_async() # Wait for a callback to return from a callback. while callbackExit == False: await asyncio.sleep(0.05) print(f"Capture complete.") # -------------------------------------------. asyncio.ensure_future( capture() )

Python

ft-lab/omniverse_sample_scripts/Rendering/Capture/CaptureRenderingColorToFile.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import asyncio import carb import carb.settings from omni.kit.viewport.utility import get_active_viewport, capture_viewport_to_file # See also : omni.kit.capture. # -------------------------------------------. # Capture LDR/HDR. # -------------------------------------------. async def capture(filePath : str, hdr : bool = False): # Assign ldr/hdr in settings. settings = carb.settings.get_settings() prevAsyncRendering = settings.get("/app/asyncRendering") prevAsyncRenderingLowLatency = settings.get("/app/asyncRenderingLowLatency") prevHdr = settings.get("/app/captureFrame/hdr") settings.set("/app/asyncRendering", False) settings.set("/app/asyncRenderingLowLatency", False) settings.set("/app/captureFrame/hdr", hdr) # Get active viewport. active_viewport = get_active_viewport() await active_viewport.wait_for_rendered_frames() # Capturing. cap_obj = capture_viewport_to_file(active_viewport, filePath) await omni.kit.app.get_app_interface().next_update_async() # awaiting completion. result = await cap_obj.wait_for_result(completion_frames=30) settings.set("/app/asyncRendering", prevAsyncRendering) settings.set("/app/asyncRenderingLowLatency", prevAsyncRenderingLowLatency) settings.set("/app/captureFrame/hdr", prevHdr) print(f"Capture complete [{filePath}].") # -------------------------------------------. asyncio.ensure_future( capture("K:/temp/output.png") ) # HDR capture not working? asyncio.ensure_future( capture("K:/temp/output.exr", True) )

Python

ft-lab/omniverse_sample_scripts/Rendering/Capture/CaptureRenderingDepth.py

""" Use "Synthetic Data Sensor". This requires that Extension "omni.syntheticdata" be enabled. Set "Depth" of "Synthetic Data Sensor" to On. """ from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import omni.ui import omni.kit.app import omni.syntheticdata # Use omni.syntheticdata extension. import numpy as np from PIL import Image import itertools # Colorize Helpers (ref : omni.syntheticdata) def colorize_depth(depth_image): height, width = depth_image.shape[:2] colorized_image = np.zeros((height, width, 4)) depth_image[depth_image == 0.0] = 1e-5 depth_image = np.clip(depth_image, 0, 255) depth_image -= np.min(depth_image) depth_image /= np.max(depth_image) + 1e-8 colorized_image[:, :, 0] = depth_image colorized_image[:, :, 1] = depth_image colorized_image[:, :, 2] = depth_image colorized_image[:, :, 3] = 1 colorized_image = (colorized_image * 255).astype(int) return colorized_image # Get main window viewport. window = omni.ui.Window('Viewport') viewportI = omni.kit.viewport_legacy.acquire_viewport_interface() vWindow = viewportI.get_viewport_window(None) iface = omni.syntheticdata._syntheticdata.acquire_syntheticdata_interface() sensor_list = iface.get_sensor_list(vWindow) for sensorD in sensor_list: if iface.get_sensor_type(sensorD) == omni.syntheticdata._syntheticdata.SensorType.DepthLinear: # Get viewport image. data = iface.get_sensor_host_float_texture_array(sensorD) # Get size. hei, wid = data.shape[:2] # Store data (buff[hei][wid]). buff = np.frombuffer(data, np.float32).reshape(hei, wid, -1) buff[buff == buff.max()] = 0 # Save the Viewport image as a file. # The path should be rewritten to match your environment. filePath = "K:/temp/output_depth.png" # Convert float32 to RGBA. rgbaBuff = colorize_depth(buff.squeeze()) rgbaBuff2 = list(itertools.chain.from_iterable(rgbaBuff)) rgbaBuff3 = [] for item in rgbaBuff2: rgbaBuff3.append((item[0], item[1], item[2], item[3])) # Create new image (with PIL). im = Image.new("RGBA", (wid, hei), (0, 0, 0, 0)) im.putdata(rgbaBuff3) # store rgba. im.save(filePath, quality=95)

Python

ft-lab/omniverse_sample_scripts/Rendering/Capture/CaptureCameraRenderingColorToBuffer.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import asyncio from PIL import Image import ctypes import carb from omni.kit.viewport.utility import get_active_viewport, capture_viewport_to_buffer, create_viewport_window, get_viewport_from_window_name from omni.kit.viewport.utility.camera_state import ViewportCameraState # See also : https://forums.developer.nvidia.com/t/how-to-get-the-backbuffer-of-omniverses-current-viewport/236825 # -------------------------------------------. # Search for viewport with specified name. # -------------------------------------------. def SearchViewportWindow(window_name : str): try: from omni.kit.viewport.window import get_viewport_window_instances for window in get_viewport_window_instances(None): if window.title == window_name: return window except ImportError: pass return None # -------------------------------------------. # Capture LDR. # -------------------------------------------. async def captureCamera(cameraPrimPath : str): if cameraPrimPath == None or cameraPrimPath == "": carb.log_error("Camera path is not specified.") return stage = omni.usd.get_context().get_stage() prim = stage.GetPrimAtPath(cameraPrimPath) if prim.IsValid() == False: carb.log_error(f"[{cameraPrimPath}] could not be found.") return # Create a Viewport corresponding to the camera. # If a Viewport already exists, reuse it. viewportName = "Viewport Camera" #viewport_api = get_viewport_from_window_name(viewportName) viewport_api = None viewportWindow = SearchViewportWindow(viewportName) if viewportWindow != None: viewport_api = viewportWindow.viewport_api if viewport_api == None: # Create new viewport. viewportWindow = create_viewport_window(viewportName, width=800, height=600) viewport_api = viewportWindow.viewport_api # Hide Viewport viewportWindow.visible = False if viewport_api == None: carb.log_error("Viewport could not be created.") return viewport_api.set_active_camera(cameraPrimPath) await viewport_api.wait_for_rendered_frames() # Called when capture is complete. cImage = None callbackExit = False def capture_callback(buffer, buffer_size, width, height, format): nonlocal cImage nonlocal callbackExit print(f"Buffer size : {buffer_size}") print(f"Resolution : {width} x {height} ") print(f"TextureFormat : {format}") # TextureFormat.RGBA8_UNORM if str(format) != "TextureFormat.RGBA8_UNORM": callbackExit = True return # Get capture image. try: ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.POINTER(ctypes.c_byte * buffer_size) ctypes.pythonapi.PyCapsule_GetPointer.argtypes = [ctypes.py_object, ctypes.c_char_p] content = ctypes.pythonapi.PyCapsule_GetPointer(buffer, None) except Exception as e: carb.log_error(f"Failed to get capture buffer: {e}") callbackExit = True return # Create image. # content.contents is RGBA buffers. cImage = Image.frombytes("RGBA", (width, height), content.contents) callbackExit = True # Capturing. cap_obj = capture_viewport_to_buffer(viewport_api, capture_callback) await omni.kit.app.get_app_interface().next_update_async() # Wait for a callback to return from a callback. while callbackExit == False: await asyncio.sleep(0.05) # Destroy Viewport window. # Note that Viewport must be discarded completely or it will consume the GPU. viewportWindow.destroy() viewportWindow = None print(f"Capture complete.") # Show image. if cImage != None: cImage.show() # -------------------------------------------. asyncio.ensure_future( captureCamera("/World/Camera") )

Python

ft-lab/omniverse_sample_scripts/Camera/GetCurrentCamera.py

from pxr import Usd, UsdGeom, CameraUtil, UsdShade, Sdf, Gf, Tf import omni.kit # Get viewport. # Kit103 : changed from omni.kit.viewport to omni.kit.viewport_legacy #viewport = omni.kit.viewport_legacy.get_viewport_interface() #viewportWindow = viewport.get_viewport_window() # Kit104 : changed from omni.kit.viewport_legacy to omni.kit.viewport.utility.get_active_viewport_window import omni.kit.viewport.utility # Get active viewport window. active_vp_window = omni.kit.viewport.utility.get_active_viewport_window() viewport_api = active_vp_window.viewport_api # Get camera path ("/OmniverseKit_Persp" etc). cameraPath = viewport_api.camera_path.pathString print("Active camera path : " + cameraPath) # Get stage. stage = omni.usd.get_context().get_stage() #time_code = omni.timeline.get_timeline_interface().get_current_time() * stage.GetTimeCodesPerSecond() time_code = Usd.TimeCode.Default() # Get active camera. cameraPrim = stage.GetPrimAtPath(cameraPath) if cameraPrim.IsValid(): camera = UsdGeom.Camera(cameraPrim) # UsdGeom.Camera cameraV = camera.GetCamera(time_code) # Gf.Camera print("Aspect : " + str(cameraV.aspectRatio)) print("fov(H) : " + str(cameraV.GetFieldOfView(Gf.Camera.FOVHorizontal))) print("fov(V) : " + str(cameraV.GetFieldOfView(Gf.Camera.FOVVertical))) print("FocalLength : " + str(cameraV.focalLength)) print("World to camera matrix : " + str(cameraV.transform)) viewMatrix = cameraV.frustum.ComputeViewMatrix() print("View matrix : {viewMatrix}") viewInv = viewMatrix.GetInverse() # Camera position(World). cameraPos = viewInv.Transform(Gf.Vec3f(0, 0, 0)) print(f"Camera position(World) : {cameraPos}") # Camera vector(World). cameraVector = viewInv.TransformDir(Gf.Vec3f(0, 0, -1)) print(f"Camera vector(World) : {cameraVector}") projectionMatrix = cameraV.frustum.ComputeProjectionMatrix() print(f"Projection matrix : {projectionMatrix}") #cv = CameraUtil.ScreenWindowParameters(cameraV) #print(cv.screenWindow)

Python

ft-lab/omniverse_sample_scripts/Camera/CalcPanoramaCameraVector.py

from pxr import Usd, UsdGeom, CameraUtil, UsdShade, Sdf, Gf, Tf import omni.kit # IPD (cm). ipdValue = 6.4 # Get viewport. # Kit103 : changed from omni.kit.viewport to omni.kit.viewport_legacy #viewport = omni.kit.viewport_legacy.get_viewport_interface() #viewportWindow = viewport.get_viewport_window() # Kit104 : changed from omni.kit.viewport_legacy to omni.kit.viewport.utility.get_active_viewport_window import omni.kit.viewport.utility # Get active viewport window. active_vp_window = omni.kit.viewport.utility.get_active_viewport_window() viewport_api = active_vp_window.viewport_api # Get camera path ("/OmniverseKit_Persp" etc). cameraPath = viewport_api.camera_path.pathString # Get stage. stage = omni.usd.get_context().get_stage() #time_code = omni.timeline.get_timeline_interface().get_current_time() * stage.GetTimeCodesPerSecond() time_code = Usd.TimeCode.Default() # ---------------------------------. # Create new camera. # ---------------------------------. def createNewCamera (orgCamera : Gf.Camera, pathName : str, position : Gf.Vec3f, direction : Gf.Vec3f): cameraGeom = UsdGeom.Camera.Define(stage, pathName) cameraGeom.CreateFocusDistanceAttr(orgCamera.GetFocusDistanceAttr().Get()) cameraGeom.CreateFocalLengthAttr(orgCamera.GetFocalLengthAttr().Get()) cameraGeom.CreateFStopAttr(orgCamera.GetFStopAttr().Get()) # Set position. UsdGeom.XformCommonAPI(cameraGeom).SetTranslate((position[0], position[1], position[2])) # Set rotation(Y-Up (0, 1, 0)). m = Gf.Matrix4f().SetLookAt(Gf.Vec3f(0, 0, 0), direction, Gf.Vec3f(0, 1, 0)) rV = -m.ExtractRotation().Decompose(Gf.Vec3d(1, 0, 0), Gf.Vec3d(0, 1, 0), Gf.Vec3d(0, 0, 1)) UsdGeom.XformCommonAPI(cameraGeom).SetRotate((rV[0], rV[1], rV[2]), UsdGeom.XformCommonAPI.RotationOrderXYZ) # Set scale. UsdGeom.XformCommonAPI(cameraGeom).SetScale((1, 1, 1)) # ---------------------------------. # Get active camera. cameraPrim = stage.GetPrimAtPath(cameraPath) if cameraPrim.IsValid(): camera = UsdGeom.Camera(cameraPrim) # UsdGeom.Camera cameraV = camera.GetCamera(time_code) # Gf.Camera # Get view matrix. viewMatrix = cameraV.frustum.ComputeViewMatrix() # Two camera positions in the view. ipdH = ipdValue * 0.5 leftVPos = Gf.Vec3f(-ipdH, 0, 0) rightVPos = Gf.Vec3f( ipdH, 0, 0) # Camera vector(World). viewInv = viewMatrix.GetInverse() vVector = viewInv.TransformDir(Gf.Vec3f(0, 0, -1)) # Convert to camera position in world coordinates. leftWPos = viewInv.Transform(leftVPos) rightWPos = viewInv.Transform(rightVPos) # Create camera. pathStr = '/World' leftPathStr = pathStr + '/camera_left' createNewCamera(camera, leftPathStr, leftWPos, vVector) rightPathStr = pathStr + '/camera_right' createNewCamera(camera, rightPathStr, rightWPos, vVector)

Python

ft-lab/omniverse_sample_scripts/Camera/CreateCamera.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Create camera. pathName = '/World/camera' cameraGeom = UsdGeom.Camera.Define(stage, pathName) cameraGeom.CreateFocalLengthAttr(24.0) cameraGeom.CreateFocusDistanceAttr(400.0) cameraGeom.CreateFStopAttr(0.0) cameraGeom.CreateProjectionAttr('perspective') # Set position. UsdGeom.XformCommonAPI(cameraGeom).SetTranslate((0.0, 20.0, 40.0)) # Set rotation. UsdGeom.XformCommonAPI(cameraGeom).SetRotate((-20, 15.0, 0.0), UsdGeom.XformCommonAPI.RotationOrderXYZ) # Set scale. UsdGeom.XformCommonAPI(cameraGeom).SetScale((1, 1, 1)) # Change active camera. # Kit103 : changed from omni.kit.viewport to omni.kit.viewport_legacy #viewport = omni.kit.viewport_legacy.get_viewport_interface() #viewport.get_viewport_window().set_active_camera(pathName) # Kit104 : changed from omni.kit.viewport_legacy to omni.kit.viewport.utility.get_active_viewport_window import omni.kit.viewport.utility # Get active viewport window. active_vp_window = omni.kit.viewport.utility.get_active_viewport_window() viewport_api = active_vp_window.viewport_api viewport_api.set_active_camera(pathName)

Python

ft-lab/omniverse_sample_scripts/Samples/CreateSimpleCurve/CreateSimpleCurve.py

# ----------------------------------------------------------. # SplineのCurveを作成するスクリプト. # ----------------------------------------------------------. from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, UsdSkel, Sdf, Gf, Tf from scipy import interpolate import numpy as np import math import omni.ui # Get stage. stage = omni.usd.get_context().get_stage() rootPath = '/World' # --------------------------------------------------------. # 3Dの頂点座標より、スプラインとして細分割した頂点を返す. # @param[in] vList Gf.Vec3fの配列.4つ以上であること. # @param[in] divCou 分割数。len(vList)よりも大きい値のこと. # @return 再分割されたGf.Vec3fの配列. # --------------------------------------------------------. def curveInterpolation (vList, divCou : int): # XYZを配列に分離. xList = [] yList = [] zList = [] for p in vList: xList.append(p[0]) yList.append(p[1]) zList.append(p[2]) retVList = [] tck,u = interpolate.splprep([xList, yList, zList], k=3, s=0) u = np.linspace(0, 1, num=divCou, endpoint=True) spline = interpolate.splev(u, tck) for i in range(divCou): retVList.append(Gf.Vec3f(spline[0][i], spline[1][i], spline[2][i])) return retVList # --------------------------------------------------------. # 選択Primの子で球の座標を配列に格納. # @return Gf.Vec3fの配列, 半径(cm), マテリアル. # --------------------------------------------------------. def getSelectedSpheresPoint (): selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() if len(paths) == 0: return None xformCache = UsdGeom.XformCache(0) prim = stage.GetPrimAtPath(paths[0]) # retRに半径(cm)が入る。vPosList[]に頂点座標が入る. retR = -1.0 vPosList = [] pChildren = prim.GetChildren() for cPrim in pChildren: typeName = cPrim.GetTypeName() if typeName == 'Sphere': globalPose = xformCache.GetLocalToWorldTransform(cPrim) # Decompose transform. translate, rotation, scale = UsdSkel.DecomposeTransform(globalPose) # 半径を取得. if retR < 0.0: sphereGeom = UsdGeom.Sphere(cPrim) r = sphereGeom.GetRadiusAttr().Get() retR = r * scale[0] vPosList.append(translate) if len(vPosList) == 0: return None # primに割り当てられているマテリアルを取得. material = None rel = UsdShade.MaterialBindingAPI(prim).GetDirectBindingRel() pathList = rel.GetTargets() if len(pathList) > 0: materialPath = pathList[0] material = UsdShade.Material(stage.GetPrimAtPath(materialPath)) return vPosList, retR, material # --------------------------------------------------------. # 外積の計算. # --------------------------------------------------------. def calcCross (v1 : Gf.Vec3f, v2 : Gf.Vec3f): v1_2 = Gf.Vec4f(v1[0], v1[1], v1[2], 1.0) v2_2 = Gf.Vec4f(v2[0], v2[1], v2[2], 1.0) v3 = Gf.HomogeneousCross(v1_2, v2_2) return Gf.Vec3f(v3[0], v3[1], v3[2]) # --------------------------------------------------------. # 進行方向からベクトルを計算. # @param[in] vDir 進行方向のベクトル. # @return 4x4行列. # --------------------------------------------------------. def calcDirToMatrix (vDir : Gf.Vec3f): vDir0 = vDir.GetNormalized() m = Gf.Matrix4f() vX = Gf.Vec3f(1.0, 0.0, 0.0) vY = Gf.Vec3f(0.0, 1.0, 0.0) dirY = vY angleV = Gf.Dot(vDir0, vY) if math.fabs(angleV) > 0.999: dirY = vX dirX = calcCross(vDir0, dirY) dirX = dirX.GetNormalized() dirY = calcCross(dirX, vDir0) dirY = dirY.GetNormalized() m[0, 0] = dirX[0] m[0, 1] = dirX[1] m[0, 2] = dirX[2] m[1, 0] = dirY[0] m[1, 1] = dirY[1] m[1, 2] = dirY[2] m[2, 0] = vDir0[0] m[2, 1] = vDir0[1] m[2, 2] = vDir0[2] return m # --------------------------------------------------------. # 頂点の配列と半径、分割数により、チューブ状のMeshを作成. # @param[in] name 形状名. # @param[in] vList Gf.Vec3fの配列. # @param[in] radiusV 半径. # @param[in] divUCou 円の分割数. # @param[in] divVCou 進行方向での分割数. # @param[in] material 割り当てるマテリアル. # --------------------------------------------------------. def createTubeMesh (name : str, vList, radiusV : float, divUCou : int, divVCou : int, material : UsdShade.Material): pathStr = rootPath + '/cables' prim = stage.GetPrimAtPath(pathStr) if prim.IsValid() == False: UsdGeom.Xform.Define(stage, pathStr) prim = stage.GetPrimAtPath(pathStr) # 子形状に同一名がある場合は連番を付ける. newName = name index = 0 pChildren = prim.GetChildren() if pChildren != None: while True: chkF = False for cPrim in pChildren: name2 = cPrim.GetName() if name2 == newName: index += 1 newName = name + '_' + str(index) chkF = True break if chkF == False: break name = newName meshName = pathStr + '/' + name meshGeom = UsdGeom.Mesh.Define(stage, meshName) # Bind material. if material != None: UsdShade.MaterialBindingAPI(meshGeom).Bind(material) # +Zを中心とした半径radiusVのポイントを計算. circleV = [] dd = (math.pi * 2.0) / ((float)(divUCou)) dPos = 0.0 for i in range(divUCou): circleV.append(Gf.Vec3f(math.cos(dPos), math.sin(dPos), 0.0)) dPos += dd # ポリゴンメッシュのポイントと法線. m = Gf.Matrix4f() vDir0 = Gf.Vec3f(0.0, 0.0, 1.0) newVList = [] newVNList = [] vListCou = len(vList) for i in range(vListCou): if i + 1 >= vListCou: p1 = vList[i] else: p1 = vList[i] p2 = vList[(i + 1) % vListCou] vDir = (p2 - p1).GetNormalized() if i == 0: m = calcDirToMatrix(p2 - p1) vDir0 = vDir else: mInv = m.GetInverse() pV0 = mInv.TransformDir(vDir0) pV1 = mInv.TransformDir(vDir) m0 = calcDirToMatrix(pV0) m1 = calcDirToMatrix(pV1) m = (m1.GetInverse() * m0).GetInverse() * m for j in range(divUCou): p = circleV[j] p = m.Transform(Gf.Vec3f(p[0] * radiusV, p[1] * radiusV, p[2] * radiusV)) pp = p + p1 newVList.append([pp[0], pp[1], pp[2]]) pN = p.GetNormalized() newVNList.append([pN[0], pN[1], pN[2]]) vDir0 = vDir meshGeom.CreatePointsAttr(newVList) meshGeom.CreateNormalsAttr(newVNList) # 面の頂点数の配列を格納. facesCou = (vListCou - 1) * divUCou faceVCouList = [int] * (facesCou) for i in range(facesCou): faceVCouList[i] = 4 meshGeom.CreateFaceVertexCountsAttr(faceVCouList) # ポリゴンメッシュの面を配置. faceIndexList = [] iPos = 0 vCou = vListCou - 1 for i in range(vCou): for j in range(divUCou): i0 = iPos + j i1 = iPos + ((j + 1) % divUCou) if i + 1 >= vListCou: i2 = ((j + 1) % divUCou) i3 = j else: i2 = iPos + divUCou + ((j + 1) % divUCou) i3 = iPos + divUCou + j faceIndexList.append(i3) faceIndexList.append(i2) faceIndexList.append(i1) faceIndexList.append(i0) iPos += divUCou meshGeom.CreateFaceVertexIndicesAttr(faceIndexList) # ------------------------------------------. # Clicked button event. # ------------------------------------------. def onButtonClick(hDivCouIntField): hDivCou = hDivCouIntField.model.get_value_as_int() if hDivCou < 4: hDivCou = 4 # 選択Primの子で球の座標を配列に格納. retV = getSelectedSpheresPoint() if retV == None: print("Select an XForm that contains spheres.") else: vPosList, retR, material = retV # 頂点座標の配置から、細分化した頂点を計算. newVPosList = curveInterpolation(vPosList, hDivCou) # チューブ形状を作成. createTubeMesh('cable', newVPosList, retR, 12, hDivCou, material) # --------------------------------------------------------. # メイン部. # --------------------------------------------------------. # ------------------------------------------. # Create new window. my_window = omni.ui.Window("Create Curve", width=300, height=200) with my_window.frame: with omni.ui.VStack(height=0): hDivCouIntField = None with omni.ui.Placer(offset_x=8, offset_y=8): # Set label. f = omni.ui.Label("Select a Prim with multiple spheres as children.") with omni.ui.Placer(offset_x=8, offset_y=4): with omni.ui.HStack(width=300): omni.ui.Label("Number of divisions : ", width=50) hDivCouIntField = omni.ui.IntField(width=200, height=0) hDivCouIntField.model.set_value(50) with omni.ui.Placer(offset_x=8, offset_y=4): # Set button. btn = omni.ui.Button("Create", width=200, height=0) btn.set_clicked_fn(lambda f = hDivCouIntField: onButtonClick(f))

Python

ft-lab/omniverse_sample_scripts/Samples/UnitsToCentimeters/UnitsToCentimeters.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Get metersPerUnit (default : 0.01). metersPerUnit = UsdGeom.GetStageMetersPerUnit(stage) # ----------------------------------------------------------------------. # Convert the scale of Mesh and Xform so that metersPerUnit is 0.01. # ----------------------------------------------------------------------. def ConvPrimScale (_metersPerUnit, path): prim = stage.GetPrimAtPath(path) if prim.IsValid() == False: return False # Set xformOpOrder (Xform/Mesh). transformOrder = prim.GetAttribute('xformOpOrder') typeName = prim.GetTypeName() if typeName == 'Xform' or typeName == 'Mesh': tV = prim.GetAttribute('xformOp:scale') if tV.IsValid() == False: if prim.GetAttribute('xformOp:translate').IsValid() == False: prim.CreateAttribute("xformOp:translate", Sdf.ValueTypeNames.Float3, False).Set(Gf.Vec3f(0, 0, 0)) if prim.GetAttribute('xformOp:scale').IsValid() == False: prim.CreateAttribute("xformOp:scale", Sdf.ValueTypeNames.Float3, False).Set(Gf.Vec3f(1, 1, 1)) if prim.GetAttribute('xformOp:rotateXYZ').IsValid() == False: prim.CreateAttribute("xformOp:rotateXYZ", Sdf.ValueTypeNames.Float3, False).Set(Gf.Vec3f(0, 0, 0)) transformOrder = prim.CreateAttribute("xformOpOrder", Sdf.ValueTypeNames.String, False) transformOrder.Set(["xformOp:translate", "xformOp:rotateXYZ", "xformOp:scale"]) if transformOrder.IsValid() and transformOrder.Get() != None: tV = prim.GetAttribute('xformOp:scale') if tV.IsValid(): scaleV = tV.Get() scale = _metersPerUnit / 0.01 tV.Set(scaleV * scale) return True return False # ----------------------------------------------------------------------. if abs(metersPerUnit - 0.01) < 1e-5: print("The units of Stage are already centimeters.") else: # Get default prim. defaultPrim = stage.GetDefaultPrim() if defaultPrim == None or defaultPrim.IsValid() == False: print("DefaultPrim does not exist.") else: path = defaultPrim.GetPath().pathString if ConvPrimScale(metersPerUnit, path) == False: print("Failed to change DefaultPrim.") else: # Set metersPerUnit. try: UsdGeom.SetStageMetersPerUnit(stage, 0.01) print("DefaultPrim has been successfully changed.") except Exception as e: print(e)

Python

ft-lab/omniverse_sample_scripts/Samples/FlipMeshNormals/FlipMeshNormals.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, UsdSkel, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # ------------------------------------------------------------. # Flip mesh normals. # ------------------------------------------------------------. def FlipMeshNormals (prim): if prim.GetTypeName() == 'Mesh': m = UsdGeom.Mesh(prim) # If it is displayed. if m.ComputeVisibility() == 'inherited': # Get prim path. path = prim.GetPath().pathString print(prim.GetName()) pChildren = prim.GetChildren() for cPrim in pChildren: FlipMeshNormals(cPrim) # ------------------------------------------------------------. # Get selection. selection = omni.usd.get_context().get_selection() paths = selection.get_selected_prim_paths() for path in paths: prim = stage.GetPrimAtPath(path) if prim.IsValid(): FlipMeshNormals(prim)

Python

ft-lab/omniverse_sample_scripts/Settings/GetRenderingSize.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf import carb.settings # Get rendering size. # If Render Resolution is "Viewport", -1 will be set. settings = carb.settings.get_settings() width = settings.get('/app/renderer/resolution/width') height = settings.get('/app/renderer/resolution/height') print("Rendering size : " + str(width) + " x " + str(height)) # Set rendering size. #settings.set('/app/renderer/resolution/width', 1280) #settings.set('/app/renderer/resolution/height', 720)

Python

ft-lab/omniverse_sample_scripts/Settings/GetKitPath.py

import os.path import carb.tokens kitPath = os.path.abspath(carb.tokens.get_tokens_interface().resolve("${kit}")) print(kitPath)

Python

ft-lab/omniverse_sample_scripts/Settings/GetKitVersion.py

import omni.kit # Get Omniverse Kit version. kitVersion = omni.kit.app.get_app_interface().get_build_version() # 102.1.2+release.xxxx print("Kit Version : " + str(kitVersion)) # 102.1.2 print(str(" ") + kitVersion.split("+")[0])

Python

ft-lab/omniverse_sample_scripts/Settings/GetRenderMode.py

import omni.kit import carb.settings import asyncio # Get Render Mode. settings = carb.settings.get_settings() renderMode = settings.get('/rtx/rendermode') # rtx, iray activeRender = settings.get('/renderer/active') if activeRender == 'iray': print("Render Mode : Iray") else: if renderMode == 'RaytracedLighting': print("Render Mode : RTX Real-time") else: if renderMode == 'PathTracing': print("Render Mode : RTX Path-traced") else: print("Render Mode : " + renderMode) # Set Render mode. # It is safe to wait for one frame in the coroutine to change the RenderMode. async def SetRenderMode (modeName : str): await omni.kit.app.get_app().next_update_async() settings.set('/rtx/rendermode', modeName) # Set "RTX Real-time" asyncio.ensure_future(SetRenderMode('RaytracedLighting')) # Set "RTX Path-traced" asyncio.ensure_future(SetRenderMode('PathTracing'))

Python

ft-lab/omniverse_sample_scripts/Scene/OpenUSDFile.py

from pxr import Usd, UsdGeom, UsdShade, Sdf, Gf, Tf try: # Open USD File. ret = omni.usd.get_context().open_stage("xxx.usd") print("open_stage : " + str(ret)) except Exception as e: print(e)

Python

ft-lab/omniverse_sample_scripts/Scene/CloseStage.py

from pxr import Usd, UsdGeom, UsdShade, Sdf, Gf, Tf omni.usd.get_context().close_stage()

Python

ft-lab/omniverse_sample_scripts/Scene/StageUpAxis.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Get UpAxis. upAxis = UsdGeom.GetStageUpAxis(stage) if upAxis == UsdGeom.Tokens.x: print("UpAxis : X") elif upAxis == UsdGeom.Tokens.y: print("UpAxis : Y") elif upAxis == UsdGeom.Tokens.z: print("UpAxis : Z") # Set UpAxis (Y-Up). try: UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.y) except Exception as e: print(e)

Python

ft-lab/omniverse_sample_scripts/Scene/GetResolvedPath.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf try: # Open USD File. usdPath = "https://ft-lab.github.io/usd/omniverse/usd/cyawan/cyawan.usdc" ret = omni.usd.get_context().open_stage(usdPath) if ret == True: # Get stage. stage = omni.usd.get_context().get_stage() # Convert relative paths to absolute paths from Stage. # It is necessary to specify the relative path where the texture name, Reference, etc. exists on the Stage. absPath = stage.ResolveIdentifierToEditTarget("./cyawan_mat_albedo.png") # "https://ft-lab.github.io/usd/omniverse/usd/cyawan/cyawan_mat_albedo.png" print(absPath) except Exception as e: print(e)

Python

ft-lab/omniverse_sample_scripts/Scene/NewStage.py

from pxr import Usd, UsdGeom, UsdShade, Sdf, Gf, Tf omni.usd.get_context().new_stage() print("New Stage !")

Python

ft-lab/omniverse_sample_scripts/Scene/GetAllFacesCount.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # ---------------------------------------. # Get the number of faces used by PointInstancer. # ---------------------------------------. def TraversePointInstancer (prim): typeName = prim.GetTypeName() allCou = 0 if typeName == 'Mesh': m = UsdGeom.Mesh(prim) # If it is displayed. if m.ComputeVisibility() == 'inherited': # Get the number of faces of Mesh. allCou += len(m.GetFaceVertexCountsAttr().Get()) # Recursively traverse the hierarchy. pChildren = prim.GetChildren() for cPrim in pChildren: allCou += TraversePointInstancer(cPrim) return allCou # ---------------------------------------. # traverse the hierarchy. # ---------------------------------------. def TraverseHierarchy_number (depth, prim): if prim.IsValid() == None: return 0 typeName = prim.GetTypeName() allCou = 0 if typeName == 'PointInstancer': m = UsdGeom.PointInstancer(prim) # If it is displayed. if m.ComputeVisibility() == 'inherited': # Get the number of faces used by PointInstancer. facesCou = TraversePointInstancer(prim) piCou = 0 positionsA = m.GetPositionsAttr().Get() if positionsA != None: piCou = len(positionsA) allCou += facesCou * piCou return allCou if typeName == 'Mesh': m = UsdGeom.Mesh(prim) # If it is displayed. if m.ComputeVisibility() == 'inherited': # Get the number of faces of Mesh. allCou += len(m.GetFaceVertexCountsAttr().Get()) # Recursively traverse the hierarchy. pChildren = prim.GetChildren() for cPrim in pChildren: allCou += TraverseHierarchy_number(depth + 1, cPrim) return allCou # ---------------------------------------. # Get stage. stage = omni.usd.get_context().get_stage() # Get default prim. defaultPrim = stage.GetDefaultPrim() # Get root path. rootPath = '/' if defaultPrim.IsValid(): rootPath = defaultPrim.GetPath().pathString # traverse the hierarchy. tPrim = stage.GetPrimAtPath(rootPath) allFacesCou = TraverseHierarchy_number(0, tPrim) print("Number of all faces : " + str(allFacesCou))

Python

ft-lab/omniverse_sample_scripts/Scene/CreateHierarchy.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Get default prim. defaultPrim = stage.GetDefaultPrim() # Get root path. rootPath = '' if defaultPrim.IsValid(): rootPath = defaultPrim.GetPath().pathString # Create empty node(Xform). UsdGeom.Xform.Define(stage, rootPath + '/node1') # Create empty node(Xform). UsdGeom.Xform.Define(stage, rootPath + '/node1/node1_2') # Create sphere. pathName = rootPath + '/node1/sphere' sphereGeom = UsdGeom.Sphere.Define(stage, pathName) # Set radius. sphereGeom.CreateRadiusAttr(1.0) # Set position. UsdGeom.XformCommonAPI(sphereGeom).SetTranslate((-3, 0, 0)) # Create cube. pathName = rootPath + '/node1/cube' cubeGeom = UsdGeom.Cube.Define(stage, pathName) # Set position. UsdGeom.XformCommonAPI(cubeGeom).SetTranslate((0, 0, 0))

Python

ft-lab/omniverse_sample_scripts/Scene/GetMetersPerUnit.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # Get stage. stage = omni.usd.get_context().get_stage() # Get metersPerUnit (default : 0.01). metersPerUnit = UsdGeom.GetStageMetersPerUnit(stage) print("MetersPerUnit : " + str(metersPerUnit)) # Set metersPerUnit. try: UsdGeom.SetStageMetersPerUnit(stage, 0.01) except Exception as e: print(e)

Python

ft-lab/omniverse_sample_scripts/Scene/TraverseHierarchy.py

from pxr import Usd, UsdGeom, UsdPhysics, UsdShade, Sdf, Gf, Tf # ---------------------------------------. # traverse the hierarchy. # ---------------------------------------. def TraverseHierarchy (depth, prim): if prim.IsValid() == None: return indentStr = '' for i in range(depth): indentStr += ' ' # Print Prim information. name = prim.GetName() typeName = prim.GetTypeName() s = indentStr + '[ ' + name + ' ]' s += ' type : ' + typeName # If hidden. if UsdGeom.Imageable(prim).ComputeVisibility() == 'invisible': s += ' ** Hide **' print(s) if typeName == 'Mesh': # Get the number of faces of Mesh. m = UsdGeom.Mesh(prim) faceCount = len(m.GetFaceVertexCountsAttr().Get()) print(indentStr + ' Face count : ' + str(faceCount)) # Recursively traverse the hierarchy. pChildren = prim.GetChildren() for cPrim in pChildren: TraverseHierarchy(depth + 1, cPrim) # ---------------------------------------. # Get stage. stage = omni.usd.get_context().get_stage() # Get default prim. print("--- Default prim ---") defaultPrim = stage.GetDefaultPrim() if defaultPrim.IsValid(): print("DefaultPrim(Name) : " + defaultPrim.GetName()) print("DefaultPrim(Path) : " + defaultPrim.GetPath().pathString) else: print("Default Prim does not exist.") print("") # Get root path. rootPath = '/' if defaultPrim.IsValid(): rootPath = defaultPrim.GetPath().pathString print("Root path : " + rootPath) print("") # traverse the hierarchy. tPrim = stage.GetPrimAtPath(rootPath) print("--- Hierarchy ---") TraverseHierarchy(0, tPrim) print("")

Python