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)
