def add_hierarchical_banner(): # ----------SHAPES--------------- cube = Shape('resources/cube.obj') left_h = Node( transform=translate(x=0.5, y=0, z=1.5) @ scale(0.02, 0.2, 0.02)) left_h.add(cube) right_h = Node( transform=translate(x=0.78, y=0, z=1.5) @ scale(0.02, 0.2, 0.02)) right_h.add(cube) main_branch = Node( transform=translate(x=0.64, y=0.05, z=1.5) @ scale(0.3, 0.1, 0.02)) main_branch.add(cube) transform_left_h = Node() transform_left_h.add(left_h) transform_right_h = Node() transform_right_h.add(right_h) transform_main_branch = Node(transform=translate(x=-0.4, y=-0.32, z=-0.2) @ rotate(axis=(0, 1, 0), angle=30)) transform_main_branch.add(main_branch, transform_left_h, transform_right_h) return transform_main_branch
def __init__(self, name, height): super().__init__(name) cylinder = load("Objects/cylinder.obj")[0] cube = load("Objects/cube/cube.obj")[0] cylinderPerlin = PerlinMesh(cylinder) door_left = Node(children=[cube], transform=translate(5, 0, 0) @ scale(10, 2, 0.7)) scale_left = Node(children=[cylinderPerlin, door_left], transform=scale(0.1, height, 0.1)) rotation_left = RotationControlNode(glfw.KEY_L, glfw.KEY_P, vec(0, 1, 0), speed=0.5, children=[scale_left]) node_left = Node(children=[rotation_left], transform=translate(-1, 0, 0)) door_right = Node(children=[cube], transform=translate(-5, 0, 0) @ scale(10, 2, 0.7)) scale_right = Node(children=[cylinderPerlin, door_right], transform=scale(0.1, height, 0.1)) rotation_right = RotationControlNode(glfw.KEY_L, glfw.KEY_P, vec(0, -1, 0), speed=0.5, children=[scale_right]) node_right = Node(children=[rotation_right], transform=translate(1, 0, 0)) self.add(node_left, node_right)
def __init__(self, ground, shape_vertex_array, shader, x=0, z=0, n_leaves=10, fire=False): # n_leaves is typically between 8 and 15 # we can provide a cylinder node if we don't want to reload one assert n_leaves > 0, "A tree should have more than 1 leaf" super().__init__(ground, x, z, y_offset_with_origin=1) # trunk of the tree #trunk = Node(transform=scale(0.5, 1, 0.5), children=[cylinder_node]) trunk = Leaf(translate(0, 0, 0), scale(0.5, 1, 0.5), shape_vertex_array, shader, (0.8, 0.3, 0.1, 1)) if fire: #optionaly set the tree on fire self.add(FireEmiter(height=n_leaves)) self.add(trunk) # adding the leaves last_leaf = trunk #new_leaf = Node(transform=translate(0, 1, 0) @ scale(4, 0.2, 4), children=[cylinder_node]) new_leaf = Leaf(translate(0, 1, 0), scale(4, 0.2, 4), shape_vertex_array, shader, (0.2, 0.6, 0.2, 1)) # every leaf is created as a children of the below one for i in range(n_leaves): last_leaf.add(new_leaf) last_leaf = new_leaf #new_leaf = Node(transform=translate(0, 2, 0) @ scale((n_leaves-2)/n_leaves, 1, (n_leaves-2)/n_leaves), children=[cylinder_node]) new_leaf = Leaf( translate(0, 2, 0), scale((n_leaves - 2) / n_leaves, 1, (n_leaves - 2) / n_leaves), shape_vertex_array, shader, (0.2 + i / 100, 0.6 + 2 * i / 100, 0.2 + i / 100, 1))
def __init__(self, p1=None, p2=None): Pattern.__init__(self) if p1 is None: p1 = StripePattern(Color(0.9, 0, 0), Color(0.9, 0.3, 0.0)) p1.transform = scale(0.2, 0.2, 0.2) * rotate_y(pi / 4) if p2 is None: p2 = StripePattern(Color(0.0, 0.0, 0.9), Color(0.0, 0.3, 0.9)) p2.transform = scale(0.2, 0.2, 0.2) * rotate_y(-pi / 4) self.p1 = p1 self.p2 = p2
def value(self, time): """ Compute each component's interpolation and compose TRS matrix """ translation = translate(self.translate_keyframes.value(time)) rotation = quaternion_matrix(self.rotate_keyframes.value(time)) scaling = scale(self.scale_keyframes.value(time)) return translation @ rotation @ scaling
def value(self, time): """ Compute each component's interpolation and compose TRS matrix """ T = translate(self.translation_keys.value(time)) R = quaternion_matrix(self.rotate_keys.value(time)) S = scale(self.scale_keys.value(time)) return T @ R @ S
def valueCycle(self, time): """ Compute each component's interpolation and compose TRS matrix """ result_translation = translate(self.translation.valueCycle(time)) result_rotation = quaternion_matrix(self.rotation.valueCycle(time)) result_scale = scale(self.scale.valueCycle(time)) return result_translation @ result_rotation @ result_scale
def test_intersect1(self): r = Ray(Point(0, 0, -5), Vector(0, 0, 1)) s = TestShape() s.set_transform(scale(2, 2, 2)) xs = s.intersect(r) self.assertTrue(s.saved_ray.origin.equals(Point(0, 0, -2.5))) self.assertTrue(s.saved_ray.direction.equals(Vector(0, 0, 0.5)))
def add_asteroid(): a_mesh = PhongMesh('resources/Asteroid/10464_Asteroid_v1_Iterations-2.obj') asteroid_base = Node( transform=translate(x=2.2, y=4, z=-10) @ scale(x=0.02)) asteroid_base.add(a_mesh) translate_keys = { 0: vec(2, 5, -11), 2: vec(1.5, 3.5, -12), 4: vec(1, 2, -13), 6: vec(0.5, 0.5, -14), 8: vec(0, -1, -15), 10: vec(-0.2, -2.5, -16), } rotate_keys = { 0: quaternion_from_euler(30, 0, 150), 2: quaternion_from_euler(45, 0, 200), 4: quaternion_from_euler(50, 0, 250), 6: quaternion_from_euler(55, 0, 300), 8: quaternion_from_euler(60, 0, 350), 10: quaternion_from_euler(65, 0, 400) } scale_keys = {0: 0.1, 2: 0.08, 4: 0.06, 6: 0.04, 8: 0.01, 10: 0.001} keynode = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys) keynode.add(asteroid_base) return keynode
def test_pattern_with_both_an_object_and_a_pattern_transformation(self): s = Sphere() s.set_transform(scale(2, 2, 2)) p = TestPattern() p.set_pattern_transform(translate(0.5, 1, 1.5)) c = p.pattern_at_shape(s, Point(2.5, 3, 3.5)) self.assertTrue(c.equals(Color(0.75, 0.5, 0.25)))
def play(EDGES): crashed = False while not crashed: for event in pygame.event.get(): if event.type == pygame.QUIT: crashed = True elif event.type == KEYDOWN: if event.key == K_SPACE: EDGES = draw3D.rect_ini(rect_width, rect_height, rect_depth, rect_x, rect_y, rect_z) if event.key == K_LEFT: move_x = -1 if event.key == K_RIGHT: move_x = 1 if event.key == K_DOWN: move_y = -1 if event.key == K_UP: move_y = 1 if event.key == K_LSHIFT: move_z = -1 if event.key == K_RSHIFT: move_z = 1 if event.key == K_1: rotate_dir = 1 if event.key == K_2: rotate_dir = 2 if event.key == K_3: rotate_dir = 3 if event.key == K_l: #scale_x = 1.01 #scale_y = 1.01 scale_z = 1.01 if event.key == K_s: #scale_x = 0.99 #scale_y = 0.99 scale_z = 0.99 else: move_x = 0 move_y = 0 move_z = 0 rotate_dir = 0 scale_x = 1.0 scale_y = 1.0 scale_z = 1.0 for i in range(len(EDGES)): EDGES[i] = transform.rotation(EDGES[i], rotate_angle, rotate_dir) EDGES[i] = transform.translation(EDGES[i], move_x, move_y, move_z) EDGES[i] = transform.scale(EDGES[i], scale_x, scale_y, scale_z) gameDisplay.fill(color.white) # set up the 3D coordinate system pygame.draw.line(gameDisplay, color.black, (0, 300), (800, 300), 1) pygame.draw.line(gameDisplay, color.black, (400, 0), (400, 600), 1) pygame.draw.line(gameDisplay, color.black, (100, 600), (700, 0), 1) draw3D.angle = angle draw3D.drawRect(EDGES, color.black) #draw3D.drawTri(EDGES[8:],color.red) pygame.display.update() clock.tick(fps)
def main(): viewer = Viewer() # SkyBox files = [ 'resources/skybox/sky_right1.png', 'resources/skybox/sky_left2.png', 'resources/skybox/sky_top3.png', 'resources/skybox/sky_bottom4.png', 'resources/skybox/sky_back6.png', 'resources/skybox/sky_front5.png' ] txt1 = Skybox_Textured(files) viewer.add(txt1) surface = Surface() surface_base = Node(transform=scale(x=0.7)) surface_base.add(surface) viewer.add(surface_base) viewer.add(add_hierarchical_model()) viewer.add(add_hierarchical_banner()) viewer.add(add_ufo_ship()) viewer.add(add_asteroid()) earth_mesh = PhongMesh('resources/Earth1/earth.obj') earth_base = Node(transform=translate(x=4, y=1.5, z=-7) @ scale(x=0.0033)) earth_base.add(earth_mesh) rotate_earth = RotatePlanet(axis=(0, 1, 0), speed=0.8) rotate_earth.add(earth_base) viewer.add(rotate_earth) jupiter_mesh = PhongMesh('resources/Jupiter/Jupiter.obj') jupiter_base = Node(transform=translate(x=-0.6, y=2, z=-10) @ rotate( axis=(1, 0, 0), angle=90) @ scale(x=0.001)) jupiter_base.add(jupiter_mesh) rotate_jupiter = RotatePlanet(axis=(0, 1, 0), speed=0.6) rotate_jupiter.add(jupiter_base) viewer.add(rotate_jupiter) sun_mesh = PhongMesh('resources/Sun/Sun.obj') sun_base = Node(transform=translate(x=-4, y=2, z=-9) @ scale(x=0.0013)) sun_base.add(sun_mesh) rotate_sun = RotatePlanet(axis=(0, 1, 0), speed=0.4) rotate_sun.add(sun_base) viewer.add(rotate_sun) # Rendering loop viewer.run()
def main(): """ create a window, add scene objects, then run rendering loop """ viewer = Viewer() # paramètre de transformation des paramètres #sol ground_size = 512 ground_offset = 20 #dinosaure characters_offset_x = 0 characters_offset_y = -20 characters_offset_z = 0 characters_scale = 15 characters_rotate_deg = 180 #forêt forest_offset = -15 forest_scale = 1.5 #skybox Skysphere_scale = 3 characters = Node( transform=translate(characters_offset_x, characters_offset_y, characters_offset_z) @ scale(characters_scale) @ rotate(axis=(0, 1, 0), angle=characters_rotate_deg)) characters.add(*load_skinned("dino/Dinosaurus_roar.dae")) forest = Node( transform=translate(0, forest_offset, 0) @ scale(forest_scale)) forest.add(*load_textured("trees9/forest.obj")) ground = Node(transform=translate(-ground_size >> 1, ground_offset, -ground_size >> 1)) ground.add(sol(ground_size)) Skysphere = Node(transform=scale(Skysphere_scale)) Skysphere.add(*load_textured("Skysphere/skysphere.obj")) scene = Node(transform=identity(), children=[characters, forest, ground, Skysphere]) viewer.add(scene) viewer.run()
def construct_forest(self, transform=identity()): for _ in range(350): self.children.extend([ add_object(self.trees[randint(0, 4)], transform=transform @ translate( randint(0, 10000), randint(0, 4000), 0) @ scale( randint(60, 100))) ])
def value(self, time): """ Compute each component's interpolation and compose TRS matrix """ translate_mat = translate(self.translate_keys.value(time)) rotate_mat = quaternion_matrix(self.rotate_keys.value(time)) scale_mat = scale(self.scale_keys.value(time)) # return the composed matrix return (translate_mat @ rotate_mat @ scale_mat)
def test_transform2(self): pfrom = Point(0, 0, 0) pto = Point(0, 0, 1) vup = Vector(0, 1, 0) t = view_transform(pfrom, pto, vup) s = scale(-1, 1, -1) self.assertTrue(matrix.equals(s, t))
def test_stripes_with_an_object_transformation(self): black = Color(0, 0, 0) white = Color(1, 1, 1) s = Sphere() s.set_transform(scale(2, 2, 2)) p = StripePattern(white, black) c = p.pattern_at_shape(s, Point(1.5, 0, 0)) self.assertTrue(c.equals(white))
def main(): """ create a window, add scene objects, then run rendering loop """ viewer = Viewer() # place instances of our basic objects # phi, theta, psi = 30, 20, 40 # # construct our robot arm hierarchy for drawing in viewer cylinder = Cylinder(40) # re-use same cylinder instance limb_shape = Node(transform=scale(1 / 4, 1 / 4, 5)) # make a thin cylinder limb_shape.add(cylinder) # common shape of arm and forearm rotate2 = RotationControlNode(glfw.KEY_E, glfw.KEY_D, (1, 0, 0)) rotate2.add(limb_shape) forearm_node = Node(transform=translate(0, 0, 5 - 1 / 4) @ rotate( (1, 0, 0), psi)) # robot arm rotation with phi angle forearm_node.add(rotate2) arm_node = Node(transform=translate(0, 0, 0.5) @ rotate( (1, 0, 0), phi)) # robot arm rotation with phi angle arm_node.add(limb_shape, forearm_node) rotate1 = RotationControlNode(glfw.KEY_F, glfw.KEY_S, (1, 0, 0)) rotate1.add(arm_node) # make a flat cylinder base_shape = Node(transform=identity(), children=[cylinder]) # viewer.add(base_node) viewer.add(TexturedPlane("control/arrows.png")) # viewer.add(Cylinder(200)) translate_keys = {0: vec(0, 0, 0), 2: vec(1, 1, 0), 4: vec(0, 0, 0)} rotate_keys = { 0: quaternion(), 2: quaternion_from_euler(180, 45, 90), 3: quaternion_from_euler(180, 0, 180), 4: quaternion() } scale_keys = {0: 1, 2: 0.5, 4: 1} # keynode = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys) base_node = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys) base_node.add(base_shape, rotate1) viewer.add(base_node) # meshes = load_textured("cube/cube/cube.obj") # meshes = load("suzanne.obj") # for m in meshes: # keynode.add(m) # viewer.add(keynode) # start rendering loop viewer.run()
def add_hierarchical_model(): # ----------SHAPES--------------- sphere_mesh = Shape('resources/sphere.obj') head_shape = Node( transform=translate(x=1, y=-0.2, z=0.03) @ scale(0.2, 0.18, 0.1)) head_shape.add(sphere_mesh) cylinder = Shape('resources/cylinder.obj') leg_shape1 = Node( transform=translate(x=1, y=-0.25, z=0.05) @ scale(0.01, 0.05, 0.01)) leg_shape1.add(cylinder) leg_shape2 = Node( transform=translate(x=0.92, y=-0.25, z=0.05) @ scale(0.01, 0.05, 0.01)) leg_shape2.add(cylinder) foot_shape1 = Node(transform=translate(x=0.92, y=0.025, z=0.291) @ scale( 0.009, 0.025, 0.01)) foot_shape1.add(cylinder) foot_shape2 = Node( transform=translate(x=1, y=0.025, z=0.291) @ scale(0.009, 0.025, 0.01)) foot_shape2.add(cylinder) # ------- Node Connections--------- transform_foot2 = Node(transform=rotate(axis=(1, 0, 0), angle=89)) transform_foot2.add(foot_shape2) transform_foot1 = Node(transform=rotate(axis=(1, 0, 0), angle=89)) transform_foot1.add(foot_shape1) transform_leg2 = Node(transform=translate(x=0, y=0, z=0)) transform_leg2.add(leg_shape2, transform_foot2) transform_leg1 = Node(transform=translate(x=0, y=0, z=0)) transform_leg1.add(leg_shape1, transform_foot1) transform_body = Node(transform=translate(x=-0.4, y=0, z=0.8)) transform_body.add(transform_leg1, transform_leg2, head_shape) trans_node = TranslationControlNode(glfw.KEY_W, glfw.KEY_S, glfw.KEY_A, glfw.KEY_D) trans_node.add(transform_body) return trans_node
def PaintShapes(self, polygons): dc = wx.PaintDC(self) segment, height = self.ScaledDimensions() dc.SetBrush(wx.Brush('#808080')) dc.SetPen(wx.Pen('#808080', 1)) for i, shape in enumerate(polygons): points = transform.scale(shape, segment, height, not self.expand, *self.DIMENSIONS) dc.DrawPolygon(points, segment * i, 0)
def test_transform2(self): r = Ray(Point(0, 0, -5), Vector(0, 0, 1)) s = Sphere() s.set_transform(scale(2, 2, 2)) xs = s.intersect(r) self.assertEqual(xs.count, 2) self.assertTrue(xs[0].t, 3) self.assertTrue(xs[1].t, 7)
def robot_arm(): # construct our robot arm hierarchy for drawing in viewer cylinder = Cylinder() # re-use same cylinder instance limb_shape = Node(transform=scale(0.1, 0.5, 0.1), name='limb shape') # make a thin cylinder limb_shape.add(cylinder) # common shape of arm and forearm forearm_node = Node(transform=translate(0, 0.5, 0), name='forearm node') forearm_node.add(limb_shape) rot_forearm_node = RotationControlNode(glfw.KEY_LEFT, glfw.KEY_RIGHT, (1, 0, 0), transform=rotate((1, 0, 0), 45), children=[forearm_node], name='rot forearm node') move_forearm_node = Node(transform=translate(0, 1, 0), children=[rot_forearm_node], name='move forearm node') # robot arm rotation with phi angle arm_node = Node(transform=translate(0, .5, 0), name='arm node') arm_node.add(limb_shape) rot_arm_node = RotationControlNode(glfw.KEY_UP, glfw.KEY_DOWN, (1, 0, 0), children=[arm_node, move_forearm_node], name='rot arm node') move_arm_node = Node(children=[rot_arm_node], name='move arm node') base_shape_size = Node(transform=scale(.5, .1, .5), children=[cylinder], name='base shape size') base_shape_rot = RotationControlNode( glfw.KEY_P, glfw.KEY_O, (0, 1, 0), transform=rotate((0, 0, 1), 0), children=[base_shape_size, move_arm_node], name='base rotation') root_node = Node(children=[base_shape_rot], name='base shape') return root_node
def value(self, time): """ Compute each component's interpolation and compose TRS matrix """ tlerp = self._linterp(time, self.ttimes, self.trans) slerp = self._linterp(time, self.stimes, self.scale) rlerp = self._qinterp(time) rmat = quaternion_matrix(rlerp) tmat = translate(*tlerp) smat = scale(slerp) transformation = tmat @ rmat @ smat return transformation
def main(): """ create a window, add scene objects, then run rendering loop """ viewer = Viewer() # default color shader shader = Shader("color.vert", "color.frag") # ---- let's make our shapes --------------------------------------- # think about it: we can re-use the same cylinder instance! cylinder = Cylinder(shader) # make a flat cylinder base_shape = Node(transform=scale(1, 0.75, 1)) base_shape.add(cylinder) # shape of robot base # make a thin cylinder arm_shape = Node(transform=translate(0, 1.5, 0) @ scale(0.5, 1.5, 0.5)) arm_shape.add(cylinder) # shape of arm # make a thin cylinder forearm_shape = Node(transform=translate(0, 1, 0) @ scale(0.5, 1, 0.5)) forearm_shape.add(cylinder) # shape of forearm # ---- construct our robot arm hierarchy --------------------------- theta = 45.0 # base horizontal rotation angle phi1 = 20.0 # arm angle phi2 = 80.0 # forearm angle transform_forearm = Node( transform=translate(0, 3, 0) @ rotate((0, 0, 1), phi2)) transform_forearm.add(forearm_shape) transform_arm = Node( transform=translate(0, 0.75, 0) @ rotate((0, 0, 1), phi1)) transform_arm.add(arm_shape, transform_forearm) transform_base = Node(transform=rotate((0, 1, 0), theta)) transform_base.add(base_shape, transform_arm) viewer.add(transform_base) # start rendering loop viewer.run()
def main(): """ create a window, add scene objects, then run rendering loop """ viewer = Viewer() # default color shader shader = Shader("color.vert", "color.frag") # think about it: we can re-use the same cylinder instance! cylinder = Cylinder(shader) # make a flat cylinder base_shape = Node(transform=scale(1, 0.7, 1)) base_shape.add(cylinder) # shape of robot base # make a thin cylinder arm_shape = Node(transform=translate(0, 3, 0) @ scale(0.1, 2.4, 0.1)) arm_shape.add(cylinder) # shape of arm # make a thin cylinder forearm_shape = Node(transform=translate(0, 7, 0) @ scale(0.1, 1.8, 0.1)) forearm_shape.add(cylinder) # shape of forearm theta = 45.0 # base horizontal rotation angle phi1 = 45.0 # arm angle phi2 = 20.0 # forearm angle transform_forearm = Node(transform=rotate((0.6, 0.5, 1), phi2)) transform_forearm.add(forearm_shape) transform_arm = Node(transform=rotate((0.3, 0.1, 0.9), phi1)) transform_arm.add(arm_shape, transform_forearm) transform_base = Node(transform=rotate((0.9, 0.1, 0.2), theta)) transform_base.add(base_shape, transform_arm) viewer.add(transform_base) # place instances of our basic objects # viewer.add(*[mesh for file in sys.argv[1:] for mesh in load(file, shader)]) # if len(sys.argv) < 2: # print('Usage:\n\t%s [3dfile]*\n\n3dfile\t\t the filename of a model in' # ' format supported by assimp.' % (sys.argv[0],)) # start rendering loop viewer.run()
def main(): """ create a window, add scene objects, then run rendering loop """ viewer = Viewer() cylinder = Cylinder() # base base_shape = Node(transform=scale(1, 0.25, 1)) base_shape.add(cylinder) # arm arm_shape = Node(transform=(translate(0, 1, 0) @ scale(0.5, 1, 0.5))) arm_shape.add(cylinder) # forearm forearm_shape = Node(transform=(translate(0, 1, 0) @ scale(0.25, 1, 0.25))) forearm_shape.add(cylinder) # ---- construct our robot arm hierarchy --------------------------- theta = 0 # base horizontal rotation angle phi1 = 0 # arm angle phi2 = 45 # forearm angle transform_forearm = Node( transform=translate(0, 2, 0) @ rotate((1, 0, 0), phi2)) transform_forearm.add(forearm_shape) transform_arm = Node(transform=rotate((1, 1, 0), phi1)) transform_arm.add(arm_shape, transform_forearm) transform_base = Node(transform=rotate((1, 1, 0), theta)) transform_base.add(base_shape, transform_arm) viewer.add(transform_base) # place instances of our basic objects # viewer.add(*[mesh for file in sys.argv[1:] for mesh in load(file)]) if len(sys.argv) < 2: print('Usage:\n\t%s [3dfile]*\n\n3dfile\t\t the filename of a model in' ' format supported by pyassimp.' % (sys.argv[0], )) # start rendering loop viewer.run()
def main(): """ create a window, add scene objects, then run rendering loop """ viewer = Viewer() # cylinder_node = Node(name='my_cylinder', transform=translate(-1, 0, 0), color=(1, 0, 0.5, 1)) # cylinder_node.add(Cylinder()) # viewer.add(cylinder_node) # place instances of our basic objects # viewer.add(*[mesh for file in sys.argv[1:] for mesh in load(file)]) # construct our robot arm hierarchy for drawing in viewer cylinder = Cylinder() # re-use same cylinder instance limb_shape = Node(transform=(scale(0.2, 2, 0.2))) # make a thin cylinder forearm_node = Node( transform=rotate(axis=vec(0, 0, 1), angle=45) @ translate( 0, 0, 0)) # robot arm rotation with phi angle forearm_node.add(limb_shape) # limb_shape = Node(transform=(scale(0.2, 2, 0.2))) # make a thin cylinder limb_shape.add(cylinder) # common shape of arm and forearm arm_node = Node(transform=rotate(axis=vec(0, 0, 1), angle=45) @ translate( 0, 0, 0)) # robot arm rotation with phi angle arm_node.add(limb_shape, forearm_node) # make a flat cylinder base_shape = Node(transform=scale(1, 0.5, 1), children=[cylinder]) base_node = Node(transform=rotate(axis=vec( 0, 1, 0), angle=45)) # robot base rotation with theta angle base_node.add(base_shape, arm_node) viewer.add(base_node) # if len(sys.argv) < 2: # print('Usage:\n\t%s [3dfile]*\n\n3dfile\t\t the filename of a model in' # ' format supported by pyassimp.' % (sys.argv[0],)) # start rendering loop viewer.run()
def __init__(self, light=Light(Point(-10, 10, -10), Color(1, 1, 1))): self.light = light s1 = Sphere() s1.material.color = Color(0.8, 1.0, 0.6) s1.material.diffuse = 0.7 s1.material.specular = 0.2 s2 = Sphere() t2 = scale(0.5, 0.5, 0.5) s2.set_transform(t2) self.objs = [s1, s2]
def __draw(self): """Applies all changes then make and return polygons""" v = self.v v = [tr.translate(i, self.init_p) for i in v] if self.ox_angle: v = [tr.rotate_ox(i, self.rotate_point, self.ox_angle) for i in v] if self.oy_angle: v = [tr.rotate_oy(i, self.rotate_point, self.oy_angle) for i in v] if self.oz_angle: v = [tr.rotate_oz(i, self.rotate_point, self.oz_angle) for i in v] v = [tr.scale(i, self.scale_point, self.sx, self.sy, self.sz) for i in v] self.__make_polygons(v)
def add_ufo_ship(): ufo_mesh = PhongMesh('resources/ufo/ufo.obj') ufo_base = Node(transform=translate(x=-0.6, y=0, z=0) @ scale(x=0.04)) ufo_base.add(ufo_mesh) translate_keys = { 0: vec(-8, 0.8, -10), 1: vec(-7, 0.7, -9), 2: vec(-6, 0.6, -8), 3: vec(-5, 0.5, -7), 4: vec(-4, 0.45, -6), 5: vec(-3, 0.38, -5), 6: vec(-2, 0.35, -4), 7: vec(-1, 0.25, -3), 8: vec(-0.3, 0.15, -2.5), 9: vec(-0.1, -0.1, -1), 10: vec(0.03, -0.25, -0.5), 11: vec(0.09, -0.44, 0.1) } rotate_keys = { 0: quaternion_from_euler(0, 0, 20), 1: quaternion_from_euler(0, 0, 20), 2: quaternion_from_euler(0, 0, 25), 3: quaternion_from_euler(0, 0, 28), 4: quaternion_from_euler(0, 0, 33), 5: quaternion_from_euler(0, 0, 35), 6: quaternion_from_euler(0, 0, 37), 7: quaternion_from_euler(0, 0, 30), 8: quaternion_from_euler(0, 0, 20), 9: quaternion_from_euler(0, 0, 15), 10: quaternion_from_euler(0, 0, 25), 11: quaternion_from_euler(0, 0, 10) } scale_keys = { 0: 0.2, 1: 0.25, 2: 0.3, 3: 0.3, 4: 0.3, 5: 0.3, 6: 0.3, 7: 0.3, 8: 0.3, 9: 0.3, 10: 0.3, 11: 0.3 } keynode = KeyFrameControlNode(translate_keys, rotate_keys, scale_keys) keynode.add(ufo_base) return keynode
def __init__(self, name='', transform=None, children=(), \ translation_matrix=translate(), scale_matrix=scale(1), rotation_quaternion=quaternion(), axe=False, height_ground=0, \ **param): # Set all the arguments self.transform, self.param, self.name, \ self.translation_matrix, self.scale_matrix, self.rotation_quaternion = \ transform, param, name, translation_matrix, scale_matrix, rotation_quaternion self.children = defaultdict(list) self.height_ground = height_ground self.add(*children) if (axe): self.add(Axis()) # Fait bugger le skinning
def update(self, delta): if self.life > 0 and self.life <= self.total_life: self.life -= delta life_ratio = self.life / self.total_life # life_ratio goes from 1 to 0 self.color = (1, life_ratio, 0, 1) self.model = scale(0.5 + 0.5 * life_ratio) @ translate( self.x_offset + self.width * life_ratio * sin(self.height * life_ratio), self.height * (1 - life_ratio), self.z_offset + self.width * life_ratio * sin(self.height * life_ratio)) else: self.life = self.total_life
def scale(self, rates): self.mat = tr.scale(self.mat, self.c, rates)