Lab 2 - Making Scenes in Panda 3D

Finding a Node and Applying Texture:
Add a moving image to the television screen by first finding the NodePath object representing the 'screen' sub-tree of the television model and then giving it (and only it) the texture “Models/Textures/shuttle.avi”. See also the section on Searching the Scene Graph in the Manual.

# HINT - Finding a nodepath to a named sub-node
nodepath = model.find("**/<name>")    
# HINT - Loading a new texture
mytexture = loader.loadTexture(<filename>)  # E.g. "MyTexture.png"
# HINT - Setting a texture property
model.setTexture(mytexture, 1) # Places the textur on a model 

Making a Flexible Room Generator:
Add a new class called Room (see below) which you'll use to generate a setting like the one shown in the screenshot above. The Room's constructor expects three data lists that define the shape of the room. The data lists describe the placement of 1×1 panels for walls, floor and ceiling. All list items are tuples that contain the panel x and y location, but the third value in the tuple (if there is one) depends on the type of panel being created (see below). To create a tiny room with a light in the ceiling, you would instantiate the Room class like this:

# Building a very small room using the Room class
room_pathnode = render.attachNewNode("Room") # Create an empty parent node for the Room
room = Room(room_pathnode,
            [(0,0,0),(1,0,-90),(1,-1,-180),(0,-1,-270)],  # Walls
            [(0,-1)],                                     # Floor
            [(0,0,True)])                                 # Ceiling with light

Here is the Room class, only with the code to construct walls included:

class Room:    
    def __init__(self, parent_pathnode, wall_data, floor_data, ceiling_data):
        """
        Generate a room with walls, floor and a ceiling from lists of 1x1 panel
        locations and orientations.
            'parent_pathnode' = Pathnode immediately above this one in the scene graph
            'wall_data' = List of wall panel touples: (x loc, y loc, angle)
            'floor_data' = List of floor panel touples: (x loc, y loc)
            'ceiling_data' = List of ceiling panel touples: (x loc, y loc, has light?)
        """
        self.parent = parent_pathnode
        self.wall_data = wall_data
        self.floor_data = floor_data
        self.ceiling_data = ceiling_data
        self.panel = loader.loadModel("Model/grid.egg") # This is just a rectangular polygon mesh
        self.create_floor()
        self.create_ceiling()
        self.create_walls()
        self.create_lights()
 
    def create_walls(self):
        """ Create the walls according to Room data, with panel textures """
        wall_clear    = loader.loadTexture("Models/Textures/wall_tanned_clear.png")     
        for wallpanel_data in self.wall_data:
            wallpanel = self.parent.attachNewNode("wall panel") # Create a new node
            self.panel.instanceTo(wallpanel)         # Copy the geometry into place
            wallpanel.setPos(wallpanel_data[0],wallpanel_data[1],0)
            wallpanel.setHpr(wallpanel_data[2],0,0)
            wallpanel.setTexture(wall_clear)
 
    def create_floor(self):
        """ Create the floor according to Room data """
        # Fill this in
 
    def create_ceiling(self):
        """ Create the ceiling, with ceiling light textures, according to Room data """ 
        # Fill this in
 
    def create_lights(self):
        """ Create both the ambient light and spotlights for every ceiling light """
        # Leave this for a later problem.

Fill in the code for create_floor and create_ceiling (see asset names below) and test with the data set for the tiny room above. You should instantiate the Room from within the constructor of the World class.

# USEFUL ASSETS:
# "Models/Textures/wall_tanned_clear.png" 
# "Models/Textures/floor_concrete.png"
# "Models/Textures/ceiling_tanned.png"
# "Models/Textures/ceiling_tanned_light.png"

Making Randomized Panels and a Larger Room:
Modify the create_wall method to pick a random texture for each panel for a greater variety (use the various wall panel assets below). Construct a larger room now, that resembles the room in the screenshot above, by passing the right data into the Room's constructor. The following blueprint will give you all the information you need:

# MORE USEFUL ASSETS:
# "Models/Textures/wall_tanned_clear.png" 
# "Models/Textures/wall_tanned_door.png"
# "Models/Textures/wall_tanned_window.png"
# "Models/Textures/wall_tanned_vent.png" 

Adding Lights:
Fill in the code for the create_lights method. Create one ambient light with the color (0.4,0.4,0.4,1). Create one spotlight with the color (0.6,0.6,1.0,1) and attenuation (0,0,0), facing down from the ceiling (starting at height 1.25).

# HINT - Creating lights
# Set up the global lighting for general illumination
ambient_source = AmbientLight('ambient')
ambient_source.setColor(Vec4(1,1,1,1))
ambientnp = root.attachNewNode(ambient_source)
root.setLight(ambientnp)
# Set up a spotlight for localized illumination
lens = PerspectiveLens()
lens.setNearFar(0.1, 2.0)
spot_source = Spotlight('spotlight')
spot_source.setColor(Vec4(1,1,1,1))
## spot_source.showFrustum() # Uncomment for great debug information
spot_source.setLens(lens)
spotnp = root.attachNewNode(spot_source)
spotnp.setPos(Vec3(1,1,1))
spotnp.setHpr(0,0,0)
root.setLight(spotnp)

Attaching Lights to Fixtures:
Modify the spotlight creation in the create_lights methods so that it creates a spotlight for each of the ceiling panels that have light fixtures in them.