Trouble Displaying Emissive Textures

[DylanZelkin]

I cannot make the emissive material show up; the singular red color emissive works fine, but any material is a failure and causes the ball to simply be black. (i have also tried looking through a camera i placed in the world instead of the viewport and still no difference). I am new to isaaclab and I think I am likely just applying the material incorrectly, any help fixing that would be great. I believe I need to use emissive as it wont need lighting to show up which is what I need for this. I am also new to rendering though and so if this is not the correct way to get the affect I am looking for that would be great to know.

I have included here the code I am using:

import omni.usd

import omni.kit.commands

from pxr import Gf, Sdf, UsdGeom, UsdShade





class EmissiveTestBall:

    def __init__(

        self,

        prim_path: str,

        radius: float = 0.05,

        position=(0.0, 0.0, -0.5),

        color_rgb=(1.0, 1.0, 1.0),

        intensity: float = 100.0,

        texture_file: str | None = None,

    ):

        self.stage = omni.usd.get_context().get_stage()




        self.prim_path = prim_path

        self.material_path = f"{prim_path}/Looks/EmissiveBallMaterial"

        self.shader_path = f"{self.material_path}/Shader"




        self.radius = float(radius)




        self._create_or_get_ball()

        self._create_or_get_material()

        self._bind_material()




        self.update(

            position=position,

            color_rgb=color_rgb,

            intensity=intensity,

            texture_file=texture_file,

        )




    def update(

        self,

        position=None,

        color_rgb=None,

        intensity=None,

        texture_file=None,

    ):

        if position is not None:

            self.translate_op.Set(

                Gf.Vec3d(

                    float(position[0]),

                    float(position[1]),

                    float(position[2]),

                )

            )




        self.scale_op.Set(

            Gf.Vec3f(

                self.radius,

                self.radius,

                self.radius,

            )

        )




        if color_rgb is not None:

            self.shader.GetInput("emissive_color").Set(

                Gf.Vec3f(

                    float(color_rgb[0]),

                    float(color_rgb[1]),

                    float(color_rgb[2]),

                )

            )




        if intensity is not None:

            self.shader.GetInput("emission_intensity").Set(float(intensity))




        self.shader.GetInput("backface_emission").Set(True)




        if texture_file is not None:

            self.shader.GetInput("emissive_color_texture").Set(

                Sdf.AssetPath(texture_file)

            )




    def _create_or_get_ball(self):

        self.sphere = UsdGeom.Sphere.Define(self.stage, self.prim_path)

        self.sphere.GetRadiusAttr().Set(1.0)




        imageable = UsdGeom.Imageable(self.sphere.GetPrim())

        imageable.MakeVisible()




        self.sphere.GetPrim().CreateAttribute(

            "doubleSided", Sdf.ValueTypeNames.Bool

        ).Set(True)




        xformable = UsdGeom.Xformable(self.sphere.GetPrim())

        self.translate_op = xformable.AddTranslateOp()

        self.scale_op = xformable.AddScaleOp()




    def _create_or_get_material(self):

        omni.kit.commands.execute(

            "CreateMdlMaterialPrimCommand",

            mtl_url="OmniEmissive.mdl",

            mtl_name="OmniEmissive",

            mtl_path=self.material_path,

        )




        self.material = UsdShade.Material.Get(self.stage, self.material_path)

        self.shader = UsdShade.Shader.Get(self.stage, self.shader_path)




        if not self.material:

            raise RuntimeError(f"Failed to create MDL material at {self.material_path}")




        if not self.shader:

            raise RuntimeError(f"Failed to get MDL shader at {self.shader_path}")




        if not self.shader.GetInput("emissive_color"):

            self.shader.CreateInput("emissive_color", Sdf.ValueTypeNames.Color3f)

        if not self.shader.GetInput("emission_intensity"):

            self.shader.CreateInput("emission_intensity", Sdf.ValueTypeNames.Float)

        if not self.shader.GetInput("backface_emission"):

            self.shader.CreateInput("backface_emission", Sdf.ValueTypeNames.Bool)

        if not self.shader.GetInput("emissive_color_texture"):

            self.shader.CreateInput("emissive_color_texture", Sdf.ValueTypeNames.Asset)




    def _bind_material(self):

        UsdShade.MaterialBindingAPI(self.sphere.GetPrim()).Bind(self.material)

Use the class and run this from the setup_scene() method in a DirectRL class. You will see a red ball, and there will be a black ball in the scene that you cant see since the material is not correct.

    ball = EmissiveTestBall(

        "/World/EmissiveTestBall",

        radius=0.03,

        position=(0.0, 0.5, -0.3),

        color_rgb=(1.0, 0.0, 0.0),

        intensity=100.0,

    )

    ball2 = EmissiveTestBall(

        "/World/EmissiveTestBall2",

        radius=0.03,

        position=(0.0, 0.0, -0.3),

        color_rgb=(1.0, 0.0, 0.0),

        intensity=100.0,

        texture_file=r"stars.jpg"

    )

`

I have included here the image I am trying to use as my material (I have tried other images and materials and I get the same problems).

thanks c: