| Next revision | Previous revision |
| public:t-vien-10-3:lab_1_materials [2010/09/16 10:07] – created hannes | public:t-vien-10-3:lab_1_materials [2024/04/29 13:33] (current) – external edit 127.0.0.1 |
|---|
| ====== Lab 2 - Making Scenes in Panda 3D ====== | ====== Lab 1 - Introduction to Python ====== |
| |
| ===== In-Class Excercises ===== | To work through these exercises, use the reference materials on the main course page. The hints are there for a quick reference, but you'll probably need to look a few things up as well. |
| |
| ==== Before You Start ==== | - **Hello World:**\\ Create a program called **''myhello.py''** that prints "Hello World!" on the screen. \\ \\ <code python> |
| | # HINT: Typical print statement |
| * Download and unzip the [[http://www.ru.is/kennarar/hannes/classes/ve2010/Lab2Assets.zip|Lab 2 Asset File]] into your working directory (where you will be writing and running your python script). | print "This gets printed!" |
| | |
| ==== Making a Virtual Room in Panda 3D ==== | |
| | |
| {{public:t-vien-07-1:ve-lab2-screenshot.jpg|}} | |
| | |
| - **Loading and Posing an Object:**\\ Create a new python script called ''myscene.py'' that does the following: | |
| - Moves the **camera** to the location (-0.5, -3.5, 0.5), changes its heading by -45 degrees. | |
| - Loads and displays the **model** ''"Models/television.egg"'', placing it at location (2,-2,0). Scale the model down to 15% and rotate it such that you can see the front of the television screen. <code python> | |
| # HINT - A basic program showing a scene with one object from a fixed camera | |
| # NOTE - Numeric values are arbitrary in this example (you need to change them for your program) | |
| import direct.directbase.DirectStart | |
| # Disabling user controlled camera | |
| base.disableMouse() | |
| # Placing the camera in world space | |
| base.camera.setPos(1,1,1) # Location (x, y, z) | |
| base.camera.setHpr(45,45,45) # Orientation in degrees (Heading, Pitch, Roll) | |
| # Loading a new ready-made model | |
| model = loader.loadModel("MyModel.egg") # Model filename | |
| model.setScale(0.5) # Uniform scaling of the model | |
| model.setPos(1,1,1) # Location (x, y, z) | |
| model.setHpr(45,45,45) # Orientation in degrees (Heading, Pitch, Roll) | |
| # Adding the model to the Scene Graph under the root | |
| model.reparentTo(render) | |
| # Start main loop | |
| run() | |
| </code> | </code> |
| - **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 [[http://www.panda3d.org/wiki/index.php/Searching_the_Scene_Graph|Searching the Scene Graph in the Manual]].<code python> | - **Creating a Function:**\\ Add the function **''greet''** to your program, which takes a person's name as input and prints out a greeting addressed to that person. Call your new function with your own name from within the program. \\ \\ <code python> |
| # HINT - Finding a nodepath to a named sub-node | # HINT: Declaring and calling a function |
| nodepath = model.find("**/blah") | def myfunc(x): |
| # HINT - Loading a new texture | """ Prints out the value of x, regardless of type """ |
| mytexture = loader.loadTexture("MyTexture.png") | print x |
| # HINT - Setting a texture property | # Let's use our function to print out the number 3 |
| model.setTexture(mytexture, 1) | myfunc(3) |
| </code> | </code> |
| - **Creating a World Class and Simple Navigation:**\\ Now you will place your scene inside a new Python class. One reason to do this is that your code can be more modular, but another reason is that by making your class inherit methods and attributes from ''DirectObject'', you get a lot of cool functionality - including event handling! | - **Using a List:**\\ Declare a list of names, called **''friends''**, in your program and then make the program greet everyone on that list. \\ \\ <code python> |
| - Create a new class called **World**, derived from ''DirectObject'', and move the creation of the television (but not your camera) into its constructor and then instantiate this world before calling run() in your main program. Test this before continuing. | # HINT: Printing out all the members of a list, regardless of type |
| - The example below shows how the constructor can set up event handlers for specific key-strokes (in this case the key 's'). You can check the manual pages for [[http://www.panda3d.org/wiki/index.php/Event_Handlers|EventHandlers]] to understand how this works. This code makes you move the camera backwards as you hold down the 's' key. Add code for moving the camera forward with the 'w' key and for rotating the camera left and right with the 'a' and 'd' keys. You should be able to do this by accepting more events, storing more keys and adding more kinds of updates inside ''update_camera''.<code python> | mylist = [1,3,5,'A','B'] |
| from direct.showbase.DirectObject import DirectObject | for x in mylist: |
| class World(DirectObject): | print x |
| """ An interactive scene """ | </code> |
| | - **Randomness and Command Line:**\\ Instead of greeting each friend once, make the program greet one at random and repeat this process as many times as you specify on the command line when you launch it. \\ \\ <code python> |
| | # HINT: Picking a random entry |
| | import random # Import the 'random' functions module |
| | # Print a single random entry from a list |
| | print random.choice(['A',4,'B','hello']) |
| | </code><code python> |
| | # NOTE: 'random.choice' means you're calling 'choice' from |
| | # the module 'random', however, to save yourself the typing |
| | # of the module name every time you call a specific function |
| | # from it, you could also have imported it explicitly first: |
| | from random import choice |
| | print choice(['A',4,'B','hello']) |
| | </code><code python> |
| | # HINT: Reading a command line argument |
| | from sys import argv # Import the command line argument list 'argv' |
| | if (len(argv)>1): # Only if some arguments exist... |
| | print argv[1] # ...print the first argument (They are all strings) |
| | </code><code python> |
| | # HINT: Converting a string to a number and looping |
| | i = int('3') |
| | for j in range(i): # j = 0, 1, 2 |
| | print j |
| | </code> |
| | - **A Class:**\\ Add the class **''Tool''** to your program. This class represents a useful object that is made from some particular material. The problem is that the tool sometimes breaks when it is being used, depending on its material strength. You will simulate this behavior with this class. |
| | - Initialize the **''Tool''** class properties **''name''**, **''material''** and ''**working**'' in the constructor, with the first two being passed in and the last one set to the default value of **''True''**. |
| | - Add the method **''use''** to the class, which prints out "You can't use this broken [name]" if the tool is not working (''working is False''), prints out "Dang! The [name] just broke!" (ands sets ''working=False'') if a test of material strength fails (see next) or prints out "The [name] really came in handy!" if nothing catastrophic occurs. |
| | - To help with testing the material strength, declare a global dictionary called ''**material_strength**'', keyed on material names (like **''"glass", "plastic", "wood", "metal"''**) and mapping them to strength values between 0 and 100 (your choice). |
| | - The test in the **''use''** method of a tool fails if a random value in the 0 to 100 range is higher than the strength of the item's named material. |
| | - Declare a global list of instanced tools (like **''"hammer", "glasses", "blender", "raygun"''**...) and make the program use them all to see if your class works. \\ \\ <code python> |
| | # HINT: Creating a new class |
| | class MyClass: |
| | """ This is a simple class with two properties, one of which is |
| | set through a parameter passed into the constructor """ |
| | def __init__(self, x): |
| | """ Pass in a value of x, which will get stored along with the default |
| | value of y. Note that 'self' is a reference to the class instance and |
| | gets passed in automatically - but has to be included in the definition """ |
| | self.x = x |
| | self.y = "defaultY" |
| |
| def __init__(self): | def show(self): |
| """ The constructor, which builds the scene and sets up user control """ | print "I have x="+str(self.x)+" and y="+str(self.y) |
| |
| # Code for building the scene could go here... | # Let's creat an instance and call the show method |
| | c = MyClass(5) |
| # Set up movement keys | c.show() # It should print "I have x=5 and y=defaultY" |
| self.keystate = {'back':0} # Just a member variable to store the state of each key | |
| self.accept('s', self.set_keystate, ['back',1]) # Handler for 's' press | |
| self.accept('s-up', self.set_keystate, ['back',0]) # Handler for 's' release | |
| self.lasttime = 0 | |
| taskMgr.add(self.update_camera, "camerathread") # Start a new thread which then will loop | |
| # forever to update the camera position | |
| | |
| def set_keystate(self, key, state): | |
| """ Set a stored state (either 0 or 1) for a specified key ('back',...)""" | |
| self.keystate[key] = state # Updates the member variable holding the states of the keys | |
| | |
| def update_camera(self, task): | |
| """ | |
| Update camera position and/or rotation for all active key states. | |
| """ | |
| elapsed = task.time - self.lasttime | |
| if self.keystate['back'] is 1: # Checks the member variable for the current state of a given key | |
| base.camera.setPos(camera,0,-0.7*elapsed,0) # "setPos" with 4 parameters makes the translation | |
| # relative to the first parameter | |
| self.lasttime = task.time | |
| return task.cont | |
| </code><code python> | </code><code python> |
| # HINT - This might help you use a simple loop to set up the keys without having to repeat the | # HINT: Creating and using a dictionary (also called a map or a hash table) |
| # 'accept' command 8 times! | mydict = {"A":20, "B":30, "C":"Hello"} |
| key_map = (('s',['back',1]),('s-up',['back',0]), | print mydict["B"] # Prints 30, which is the value associated with the key "B" |
| ('w',['forward',1]),('w-up',['forward',0]), | |
| ('a',['left',1]),('a-up',['left',0]), | |
| ('d',['right',1]),('d-up',['right',0])) | |
| </code> | </code> |
| - **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 1x1 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:<code python> | - **List of Tuples of Objects:**\\ Make your list of friends now contain a list of tuples where the first element is the friend's name like before, but the second element should be a list of 2-3 instanced tools in that friend's possession. Make your program pick one person at random, greet them, and then ask to borrow one random tool from them and finally try to use that borrowed tool. As before, have the program repeat this as many times as you specify or until tools have been unsuccessfully used 10 times in a row (you can make the ''**use**'' method return ''**True**'' or ''**False**'' to help you keep track). \\ \\ <code python> |
| # Building a very small room using the Room class | # HINT: A tuple is an immutable sequence, unlike a list which can be modified. |
| room_pathnode = render.attachNewNode("Room") # Create an empty parent node for the Room | mytuple = (3, 5, 7) |
| room = Room(room_pathnode, | # HINT: Tuples, like other sequences can contain any types of objects |
| [(0,0,0),(1,0,-90),(1,-1,-180),(0,-1,-270)], # Walls | mytuple = (3, "Hello", MyClass(5), [7, 6, 4]) |
| [(0,-1)], # Floor | # Any contained object can be referenced |
| [(0,0,True)]) # Ceiling with light | print mytuple[1] # Prints "Hello" |
| </code>Here is the **Room** class, only with the code to construct walls included:<code python> | mytuple[2].show() # Prints "I have x=5 and y=defaultY" |
| class Room: | print mytuple[3][0] # Prints 7 |
| 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. | |
| | |
| </code>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.<code python> | |
| # USEFUL ASSETS: | |
| # "Models/Textures/wall_tanned_clear.png" | |
| # "Models/Textures/floor_concrete.png" | |
| # "Models/Textures/ceiling_tanned.png" | |
| # "Models/Textures/ceiling_tanned_light.png" | |
| </code> | </code> |
| - **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:\\ {{public:t-vien-07-1:scene_gridview.jpg|}} \\ <code python> | - **Searching Lists:**\\ Add the function **''fix''** to your program that takes in a single **''Tool''** and forces its **''working''** value to **''True''**. Declare a list of names, called **''favorites''**, and instead of quitting after 10 failed attempts at using borrowed tools, make the program fix all tools possessed by those that have their name appear on the **''favorites''** list, but not the others. Print out the names of those that got their tools fixed and let the program borrow a few more tools to see if it can now continue it's habit a bit longer. \\ \\ <code python> |
| # MORE USEFUL ASSETS: | # HINT: Finding matches between two lists |
| # "Models/Textures/wall_tanned_clear.png" | listA = [1, 3, 5, 7, 9] |
| # "Models/Textures/wall_tanned_door.png" | listB = [4, 5, 6, 8, 9] |
| # "Models/Textures/wall_tanned_window.png" | for x in listA: |
| # "Models/Textures/wall_tanned_vent.png" | if x in listB: |
| | print str(x)+" is common!" # Prints "5 is common!, 9 is common!" |
| </code> | </code> |
| - **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). <code python> | - **EXTRA: Networking and XML:**\\ Give each tool a price in some foreign currency and when you break it, print out its value in ISK. Use an up-to-date currency exchange rate, like the one you can get here in XML format: https://vefafgreidsla.tollur.is/tollalina/gengi/Innflutningur.aspx \\ \\ <code python> |
| # HINT - Creating lights | # HINT: Reading and parsing a source on the Internet |
| # Set up the global lighting for general illumination | import urllib # Module for simple Internet sockets |
| ambient_source = AmbientLight('ambient') | from xml.dom import minidom # Module for simple XML handling |
| ambient_source.setColor(Vec4(1,1,1,1)) | |
| ambientnp = root.attachNewNode(ambient_source.upcastToPandaNode()) | |
| 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.setAttenuation(Vec3(0,0,0)) | |
| ## spot_source.showFrustum() # Uncomment for great debug information | |
| spot_source.setLens(lens) | |
| spotnp = root.attachNewNode(spot_source.upcastToLensNode()) | |
| spotnp.setPos(Vec3(1,1,1)) | |
| spotnp.setHpr(0,0,0) | |
| root.setLight(spotnp) | |
| </code> | |
| - **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. | |
| |
| | # We'll call the Yahoo RSS weather service and request info for Reykjavik (ICXX0002) |
| | rssweather_socket = urllib.urlopen("http://weather.yahooapis.com/forecastrss?p=ICXX0002") |
| | rssweather_xml = minidom.parse(rssweather_socket) |
| | rssweather_socket.close() |
| | |
| | # We can extract XML elements by name (we get a list, but only take the first match) |
| | current_weather_element = rssweather_xml.getElementsByTagName("yweather:condition")[0] |
| | print "Current temperature is "+ current_weather_element.getAttribute("temp")+" deg. Farenheit" |
| | # Here we got the attribute of an element node, but to get the text of a text node, we can use node.nodeValue |
| | </code> |
| |
