def build_displaylist(self, width, height): cls = Card width, height = width / 2.0, height / 2.0 vertlist = [ euclid.Point3(-width, -height, 0), euclid.Point3(width, -height, 0), euclid.Point3(width, height, 0), euclid.Point3(-width, height, 0) ] cls.vertlist = vertlist tc = self._texture.tex_coords cardlist = glGenLists(1) glNewList(cardlist, GL_COMPILE) glBegin(GL_QUADS) glTexCoord2f(tc[0], tc[1]) glVertex3f(*tuple(vertlist[0])) glTexCoord2f(tc[3], tc[4]) glVertex3f(*tuple(vertlist[1])) glTexCoord2f(tc[6], tc[7]) glVertex3f(*tuple(vertlist[2])) glTexCoord2f(tc[9], tc[10]) glVertex3f(*tuple(vertlist[3])) glEnd() glEndList() return cardlist
def build_borderedlist(self): cls = StackCard width = self.border.width / 2.0 height = self.border.height / 2.0 vertlist = [ euclid.Point3(-width, -height, 0), euclid.Point3(width, -height, 0), euclid.Point3(width, height, 0), euclid.Point3(-width, height, 0) ] tc = self.border.tex_coords cardlist = glGenLists(1) cls.borderedlist = cardlist glNewList(cardlist, GL_COMPILE) glBegin(GL_QUADS) glTexCoord2f(tc[0], tc[1]) glVertex3f(*tuple(vertlist[0])) glTexCoord2f(tc[3], tc[4]) glVertex3f(*tuple(vertlist[1])) glTexCoord2f(tc[6], tc[7]) glVertex3f(*tuple(vertlist[2])) glTexCoord2f(tc[9], tc[10]) glVertex3f(*tuple(vertlist[3])) glEnd() glEndList()
def add_to(self, batch): '''Add the meshes to a batch applying model transformations''' for mesh in self.mesh_list: for group in mesh.groups: vertices = [] normals = [] for index in xrange(0, len(group.vertices), 3): tv = self.transforms * euclid.Point3( group.vertices[index], group.vertices[index + 1], group.vertices[index + 2]) vertices.extend(tv[:]) tn = self.transforms * euclid.Point3( group.normals[index], group.normals[index + 1], group.normals[index + 2]) if self.normalize: tn = tn.normalized() normals.extend(tn[:]) batch.add( len(vertices) // 3, GL_TRIANGLES, group.material, ('v3f/static', tuple(vertices)), ('n3f/static', tuple(normals)), ('t2f/static', tuple(group.tex_coords)), )
def multicolored_border(self): width = self.border.width / 2.0 height = self.border.height / 2.0 vertlist = [ euclid.Point3(-width, -height, 0), euclid.Point3(width, -height, 0), euclid.Point3(width, height, 0), euclid.Point3(-width, height, 0) ] tc = self.border.tex_coords color1, color2 = self.color glBegin(GL_QUADS) glColor4f(color1[0], color1[1], color1[2], self.alpha) glTexCoord2f(tc[0], tc[1]) glVertex3f(*tuple(vertlist[0])) glColor4f(color2[0], color2[1], color2[2], self.alpha) glTexCoord2f(tc[3], tc[4]) glVertex3f(*tuple(vertlist[1])) glColor4f(color2[0], color2[1], color2[2], self.alpha) glTexCoord2f(tc[6], tc[7]) glVertex3f(*tuple(vertlist[2])) glColor4f(color1[0], color1[1], color1[2], self.alpha) glTexCoord2f(tc[9], tc[10]) glVertex3f(*tuple(vertlist[3])) glEnd()
def __init__(self, focus=(1, 0, 0), FoV=90, width=180, height=180, rotation=(0, 0, 0), translation=P3(0, 0, 0), zoom=1.0): if len(focus) != 3 or type(focus) != tuple: raise TypeError("'focus' must be a tuple of length 3.") self.focus = euclid.Point3(focus[0], focus[1], focus[2]) self.FoV = float(FoV) self.LRAngle = math.radians(self.FoV) self.width = int(width) self.height = int(height) self.aspectRatio = float(self.width) / self.height if len(rotation) != 3 or type(rotation) != tuple: raise TypeError("'rotation' must be a tuple of length 3.") self.rotation = (math.radians(rotation[0]), math.radians(rotation[1]), math.radians(rotation[2])) if len(translation) != 3: raise TypeError("'translation' must be a Point3 or Vector3.") self.translation = translation self.zoom = float(zoom) self.calculateRepr() # calculate representation
def build_ray(self, mouse_x, mouse_y, button, w, h): """ build ray: from mouse position to a 3D ray (in world coordinate) starting from camera eye position """ #viewport coordinates to normalized device coordinates x = 2 * mouse_x / w - 1 y = 2 * mouse_y / h - 1 #call projection matrix and model view matrix M_proj = (gl.GLfloat * 16)() M_modelview = (gl.GLfloat * 16)() gl.glGetFloatv(gl.GL_PROJECTION_MATRIX, M_proj) gl.glGetFloatv(gl.GL_MODELVIEW_MATRIX, M_modelview) M_proj = euclid.Matrix4.new(*(list(M_proj))) M_modelview = euclid.Matrix4.new(*(list(M_modelview))) M_proj_inversed = M_proj.inverse() M_modelview_inversed = M_modelview.inverse() #homogeneous clip coordinates vector_clip = euclid.Vector3(x, y, -1) #eye coordinates vector_eye = M_proj_inversed * vector_clip vector_eye = euclid.Vector3(vector_eye[0], vector_eye[1], -1) #world coordinates vector_world = M_modelview_inversed * vector_eye vector_world.normalize() # print(vector_world); # print(M_modelview_inversed); #build ray, starting point is camera eye position ray = euclid.Ray3( euclid.Point3(M_modelview_inversed[12], M_modelview_inversed[13], M_modelview_inversed[14]), vector_world) return ray
def __init__(self, origin=euclid.Point3(0., 0., 0.), squaresize=4, normal=euclid.Vector3(0., 0., 1.), roughness=1.0, transparency=0.0, refractionIndex=1.0): super().__init__(color=(255, 255, 255), roughness=roughness, transparency=transparency, refractionIndex=refractionIndex) self.shape = euclid.Plane(origin, normal) normal = normal.normalized() self.squaresize = squaresize # let's find the unit vectors ux = euclid.Vector3(0., 1., 0.) uy = euclid.Vector3(0., 0., 1.) un = euclid.Vector3(1., 0., 0.) # 'original' normal # rotation axis axis = un.cross(normal) # cos(angle) between normal and unit normal angle = normal.dot(un) angle = math.acos(angle) rotation = euclid.Quaternion.new_rotate_axis(angle, axis) self.unitx = rotation * ux self.unity = rotation * uy
def render_tree(n=10, r=False): glLineWidth(2.) glColor4f(.5, .5, .5, .5) glBegin(GL_LINES) _tree_branch(n - 1, euclid.Line3(euclid.Point3(0., 0., 0.), euclid.Vector3(0., 1., 0.), 1.), r) glEnd()
def init(self): self.camera = Camera(euclid.Point3(0,15, 0)) self.mainplayer_status = StatusView() self.otherplayer_status = StatusView(is_opponent=True) self.mana_controller = ManaController(self.mainplayer_status.manapool, self.otherplayer_status.manapool, self) self.x_controller = XSelector(self.mainplayer_status.manapool, self.otherplayer_status.manapool, self) self.card_selector = CardSelector(self.mainplayer_status, self.otherplayer_status, self) #self.game_status = GameStatus() self.phase_status = PhaseStatus() self.phase_bar = PhaseBar() self.phase_controller = PhaseController(self.phase_status, self) self.status_controller = StatusController(self.mainplayer_status, self.otherplayer_status, self.phase_status, self) self.selection = SelectionList() self.list_selector = SelectController(self.selection, self) self.msg_dialog = MessageDialog() self.msg_controller = MessageController(self.msg_dialog, self) self.table = Table() self.mainplay = PlayView(z=3) self.otherplay = PlayView(z=-3, is_opponent_view=True) self.play_controller = PlayController(self.mainplay, self.otherplay, self) self.damage_assignment = DamageSelector(self.mainplay, self.otherplay, self) self.distribution_assignment = DistributionSelector(self.mainplay, self.otherplay, self) self.player_hand = HandView() self.hand_controller = HandController(self.player_hand, self) self.otherplayer_hand = HandView(is_opponent=True) self.otherhand_controller = HandController(self.otherplayer_hand, self) self.stack = StackView() self.stack_controller = StackController(self.stack, self) self.zone_animator = ZoneAnimator(self) self._keep_priority = False self.finish_turn = False self.p1_stop_next = False self.p2_stop_next = False
def rot(x, y, z, rx, ry, rz, c): cx, cy, cz = c[:3] x = x - cx y = y - cy z = z - cz my = euclid.Matrix4.new_rotatey(ry * math.pi / 180.0) mz = euclid.Matrix4.new_rotatez(rz * math.pi / 180.0) if rz: mx = euclid.Matrix4.new_rotatez(rz * math.pi / 180.0) x, y, z = mx * euclid.Point3(x, y, z) if rx: mx = euclid.Matrix4.new_rotatex(rx * math.pi / 180.0) x, y, z = mx * euclid.Point3(x, y, z) if ry: mx = euclid.Matrix4.new_rotatey(ry * math.pi / 180.0) x, y, z = mx * euclid.Point3(x, y, z) return [x + cx, y + cy, z + cz]
def draw_lathe(point_fn, slices, texr=RING_TEXTURE_RADIUS): vertices = [] normals = [] tex_coords = [] a = 0 incr = 2 * pi / slices lastslice = [(r, 0, z, r) for (r, z) in point_fn(slices)] for i in range(slices + 1): ca, sa = cos(a), sin(a) newslice = [(ca * r, sa * r, z, r) for (r, z) in point_fn(i)] lastp = None for ((x1, y1, z1, r1), (x2, y2, z2, r2)) in zip(lastslice, newslice): p = euclid.Point3(x1, y1, z1) if lastp: t1 = euclid.Vector3(x2 - x1, y2 - y1, z2 - z1) t2 = p - lastp n = t1.cross(t2) normal = (n.x, n.y, n.z) else: normal = (0, 0, -1) lastp = p r1 = (r1 + abs(z1)) / texr / 2 r2 = (r2 + abs(z2)) / texr / 2 normals.extend(normal) tex_coords.extend((ca * r2 + .5, sa * r2 + .5)) vertices.extend((x2, y2, z2)) normals.extend(normal) tex_coords.extend((ca * r1 + .5, sa * r1 + .5)) vertices.extend((x1, y1, z1)) lastslice = newslice a += incr vertices = (GLfloat * len(vertices))(*vertices) normals = (GLfloat * len(normals))(*normals) tex_coords = (GLfloat * len(tex_coords))(*tex_coords) count = 2 * len(lastslice) counts = [count for i in range(slices + 1)] counts = (GLint * len(counts))(*counts) firsts = range(0, (slices + 1) * count, count) firsts = (GLint * len(firsts))(*firsts) glPushAttrib(GL_ENABLE_BIT) glEnable(GL_NORMALIZE) glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT) glEnableClientState(GL_VERTEX_ARRAY) glEnableClientState(GL_NORMAL_ARRAY) glEnableClientState(GL_TEXTURE_COORD_ARRAY) glVertexPointer(3, GL_FLOAT, 0, vertices) glNormalPointer(GL_FLOAT, 0, normals) glTexCoordPointer(2, GL_FLOAT, 0, tex_coords) if gl_info.have_version(1, 4): glMultiDrawArrays(GL_QUAD_STRIP, firsts, counts, slices + 1) else: for first in firsts: glDrawArrays(GL_QUAD_STRIP, first, count) glPopClientAttrib() glPopAttrib()
def selection_ray(self, x, y): self.setup() model_view = (GLdouble * 16)() glGetDoublev(GL_MODELVIEW_MATRIX, model_view) projection = (GLdouble * 16)() glGetDoublev(GL_PROJECTION_MATRIX, projection) viewport = (GLint * 4)() glGetIntegerv(GL_VIEWPORT, viewport) x1, y1, z1 = GLdouble(), GLdouble(), GLdouble() x2, y2, z2 = GLdouble(), GLdouble(), GLdouble() gluUnProject(x, y, 0, model_view, projection, viewport, x1, y1, z1) gluUnProject(x, y, 1, model_view, projection, viewport, x2, y2, z2) ray = euclid.Ray3(euclid.Point3(x1.value, y1.value, z1.value), euclid.Point3(x2.value, y2.value, z2.value)) ray.v.normalize() self.reset() return ray
def collide_floor(self, segment): # aabox for line segment q1 = segment.p q2 = segment.p + segment.v p1 = euclid.Point3(min(q1.x, q2.x), min(q1.y, q2.y), min(q1.z, q2.z)) p2 = euclid.Point3(max(q1.x, q2.x), max(q1.y, q2.y), max(q1.z, q2.z)) best = None best_poly = None for poly in self.get_polygons_within_aabox(p1, p2): if poly.plane.n.dot(up) < 0.7: # 45 degree or less only continue p = poly.intersect_line3(segment) if p is not None: if best is None or p.y > best.y: best = p best_poly = poly return best, best_poly
def __init__(self, cwidth=180, cheight=180): self.BackgroundColor = (255, 0, 255) self.objects = [] self.camera = Camera(zoom=0.15, rotation=(0, 16, -4), width=cwidth, height=cheight) # light source is a single point for now self.light = euclid.Point3(0.0, 0.0, 0.0)
def test_add(self): a = (3.0, 7.0, 11.0) b = (1.0, 2.0, 3.0) va = eu.Vector3(*a) vb = eu.Vector3(*b) self.assertTrue(isinstance(va + vb, eu.Vector3)) self.assertEqual(repr(va + vb), 'Vector3(%.2f, %.2f, %.2f)' % (4.0, 9.0, 14.0)) c = (13.0, 17.0, 23.0) pc = eu.Point3(*c) d = (31.0, 37.0, 41.0) pd = eu.Point3(*d) self.assertTrue(isinstance(va + pc, eu.Point3)) self.assertTrue(isinstance(pc + pd, eu.Vector3)) self.assertTrue(isinstance(va + b, eu.Vector3)) self.assertEqual(va + vb, va + b)
def main(): T = int(raw_input()) for case in xrange(T): N = int(raw_input()) position = euclid.Vector3() velocity = euclid.Vector3() for _ in xrange(N): x, y, z, vx, vy, vz = map(float, raw_input().split()) position += euclid.Vector3(x, y, z) velocity += euclid.Vector3(vx, vy, vz) position /= N velocity /= N if velocity == euclid.Vector3(): d_min = abs(position - euclid.Point3()) t_min = 0. else: position = euclid.Point3(position.x, position.y, position.z) ray = euclid.Ray3(position, velocity) connection = ray.connect(euclid.Point3()) d_min = abs(connection) t_min = abs(connection.p1 - position) / abs(velocity) print 'Case #%d: %1.8f %1.8f' % (case + 1, d_min, t_min)
def set_c(self, c): '''Set the extents based on the center value and our dimensions. ''' if isinstance(c, euclid.Point3): pass elif isinstance(c, euclid.Vector3): c = euclid.Point3(c.x, c.y, c.z) else: c = euclid.Point3(*c) c = self.__c = c x = (c.x - self.dx/2, c.x + self.dx/2) self.xmin = min(x) self.xmax = max(x) y = (c.y - self.dy/2, c.y + self.dy/2) self.ymin = min(y) self.ymax = max(y) z = (c.z - self.dz/2, c.z + self.dz/2) self.zmin = min(z) self.zmax = max(z)
def parseconfig(config): data = json.loads(config) objectlist, lights = [], [] for conf in data["objects"]: if conf["type"] == "sphere": posx, posy, posz = conf["position"] r = conf["radius"] col = conf["color"] roughness = conf["roughness"] obj = objects.CollidableSphere(position=euclid.Point3( posx, posy, posz), radius=r, color=col, roughness=roughness) elif conf["type"] == "plane": orix, oriy, oriz = conf["origin"] normx, normy, normz = conf["normal"] roughness = conf["roughness"] obj = objects.CollidablePlane( origin=euclid.Point3(orix, oriy, oriz), normal=euclid.Vector3(normx, normy, normz), roughness=roughness) objectlist.append(obj) for conf in data["lights"]: x, y, z = conf lights.append(objects.Light(position=euclid.Point3(x, y, z))) conf = data["camera"] imgw, imgh = conf["imageDim"] scrw, scrh = conf["screenDim"] focal = conf["focallength"] camera = Camera(imageDim=(imgw, imgh), focallength=focal, screenDim=(scrw, scrh)) scene = Scene(camera=camera, objects=objectlist, lights=lights) scene.skycolor = tuple(data["skycolor"]) depth = data["depth"] return camera, depth, lights, objectlist, scene
def __init__(self, position=euclid.Point3(0., 0., 0.), color=(255, 255, 0), radius=1., roughness=1.0, transparency=0.0, refractionIndex=1.0): super().__init__(color=color, roughness=roughness, transparency=transparency, refractionIndex=refractionIndex) self.position = position self.radius = radius self.shape = euclid.Sphere(self.position, self.radius)
def __init__(self, screenDim=(4, 4), imageDim=(64, 64), translation=euclid.Point3(0., 0., 0.), rotation=euclid.Quaternion(), focallength=1.0): self.translation = translation self.rotation = rotation self.focallength = focallength # distance from camera to screen # Screen width is the real-world width/height of the screen self.screenw = screenDim[0] self.screenh = screenDim[1] # Image width is the number of pixels in the screen self.imagew = imageDim[0] self.imageh = imageDim[1]
def test_swizzle_get(self): xyz = (1.0, 2.0, 3.0) v3 = eu.Point3(*xyz) self.assertEqual(v3.x, xyz[0]) self.assertEqual(v3.y, xyz[1]) self.assertEqual(v3.z, xyz[2]) self.assertEqual(v3.xy, (xyz[0], xyz[1])) self.assertEqual(v3.xz, (xyz[0], xyz[2])) self.assertEqual(v3.yz, (xyz[1], xyz[2])) self.assertEqual(v3.yx, (xyz[1], xyz[0])) self.assertEqual(v3.zx, (xyz[2], xyz[0])) self.assertEqual(v3.zy, (xyz[2], xyz[1])) self.assertEqual(v3.xyz, xyz) self.assertEqual(v3.xzy, (xyz[0], xyz[2], xyz[1])) self.assertEqual(v3.zyx, (xyz[2], xyz[1], xyz[0])) self.assertEqual(v3.zxy, (xyz[2], xyz[0], xyz[1])) self.assertEqual(v3.yxz, (xyz[1], xyz[0], xyz[2])) self.assertEqual(v3.yzx, (xyz[1], xyz[2], xyz[0]))
def process_rule(rule, rules, depth, verts, faces, matrix = euclid.Matrix4.new_identity()): if (depth < 1): return for statement in rule: xform = parse_xform(statement["transforms"]) count = statement["count"] for n in xrange(count): matrix *= xform if "call" in statement: next_rule = pick_rule(statment["call"]["rules"], rules) cloned_matrix = matrix.copy() process_rule(rules[next_rule], rules, depth - 1, verts, faces, cloned_matrix) elif "instance" in statment: shape_name = statement["instance"]["shape"] shape_verts, shape_faces = shapes[shape_name] n = len(verts) for v in shape_verts: transformed_vert = matrix * euclid.Point3(*v) verts.append(transformed_vert[:]) for i, j, k in shape_faces: faces.append((i+n, j+n, k+n)) else: print "Malformed statement" return
# elif data[0] == 'f': # vi_1, vi_2, vi_3 = data[1:4] # faces.extend((vi_1,vi_2,vi_3)) #point1=[0,0]; #point2=[0,1]; #point3=[1,1]; #point4=[1,0]; # #x=np.arange(4); #y=np.array([point1,point2,point3,point4]); #cs=interpolate.CubicSpline(x,y); #plt.plot(y[:,0],y[:,1]); #plt.plot(cs(xs)[:,0],cs(xs)[:,1]) #plt.show() ray1 = euclid.Ray3(euclid.Point3(0, 0, 0), euclid.Point3(1, 1, 1)) ray2 = euclid.Ray3(euclid.Point3(1, 1, 0), euclid.Point3(1, 1, -0.5)) def line_intersect(ray1, ray2): """ find intersection point between two lines """ small_num = 0.000001 den = ray2.v.cross(ray1.v) d = den.magnitude() t = -1 #if not paralleled if d > small_num: g = ray2.p - ray1.p num = ray2.v.cross(g)
def load(self, path): self.clear() with open(path) as obj_file: for line in obj_file.readlines(): # reads the file line by line data = line.split() #print(data); if len(data) == 0 or data[0] not in ['v', 'vn', 'vt', 'f']: continue # every line that begins with a 'v' is a vertex if data[0] == 'v': x, y, z = data[1:4] self.vertices.extend( (float(x) * 10, float(y) * 10, float(z) * 10)) # every line that begins with a 'vn' is a vertex normal if data[0] == 'vn': x_n, y_n, z_n = data[1:4] self.vertex_nomals.extend( (float(x_n), float(y_n), float(z_n))) # every line that begins with a 'vt' is a text coordinate if data[0] == 'vt': t_u, t_v = data[1:3] self.text_coord.extend((float(t_u), float(t_v))) # every line that begins with an 'f' is a face # loads the faces elif data[0] == 'f': # quads # Note: in obj files the first index is 1, so we must subtract one for each # retrieved value if len(data) == 5: vi_1, vi_2, vi_3, vi_4 = data[1:5] self.quad_indices.extend( (int(vi_1) - 1, int(vi_2) - 1, int(vi_3) - 1, int(vi_4) - 1)) # triangles # Note: in obj files the first index is 1, so we must subtract one for each # retrieved value elif len(data) == 4: #triangles with complete info vi_1, vi_2, vi_3 = data[1:4] if '//' in data[1]: vi_1 = vi_1.split('//') vi_2 = vi_2.split('//') vi_3 = vi_3.split('//') self.triangle_indices.extend( (int(vi_1[0]) - 1, int(vi_2[0]) - 1, int(vi_3[0]) - 1)) self.normal_indices.extend( (int(vi_1[1]) - 1, int(vi_2[1]) - 1, int(vi_3[1]) - 1)) elif '/' in data[1]: vi_1 = vi_1.split('/') vi_2 = vi_2.split('/') vi_3 = vi_3.split('/') self.triangle_indices.extend( (int(vi_1[0]) - 1, int(vi_2[0]) - 1, int(vi_3[0]) - 1)) self.text_indices.extend( (int(vi_1[1]) - 1, int(vi_2[1]) - 1, int(vi_3[1]) - 1)) self.normal_indices.extend( (int(vi_1[2]) - 1, int(vi_2[2]) - 1, int(vi_3[2]) - 1)) else: self.triangle_indices.extend( (int(vi_1) - 1, int(vi_2) - 1, int(vi_3) - 1)) points_indices = [] for i in range(len(self.quad_indices) // 4): #put all indices for a quad into points-indices, and then separate it into 2 triangles points_indices.extend( (self.quad_indices[4 * i], self.quad_indices[4 * i + 1], self.quad_indices[4 * i + 2], self.quad_indices[4 * i + 3])) p1 = euclid.Point3(self.vertices[3 * points_indices[0]], self.vertices[3 * points_indices[0] + 1], self.vertices[3 * points_indices[0] + 2]) p2 = euclid.Point3(self.vertices[3 * points_indices[1]], self.vertices[3 * points_indices[1] + 1], self.vertices[3 * points_indices[1] + 2]) p3 = euclid.Point3(self.vertices[3 * points_indices[2]], self.vertices[3 * points_indices[2] + 1], self.vertices[3 * points_indices[2] + 2]) p4 = euclid.Point3(self.vertices[3 * points_indices[3]], self.vertices[3 * points_indices[3] + 1], self.vertices[3 * points_indices[3] + 2]) self.triangles.append(Triangle(points_indices[0],points_indices[1],points_indices[2],\ p1,p2,p3)) self.triangles.append(Triangle(points_indices[2],points_indices[3],points_indices[0],\ p3,p4,p1)) points_indices.clear() points_indices.clear() for i in range(len(self.triangle_indices) // 3): #put all indices for a triangle into points_indices points_indices.extend((self.triangle_indices[3 * i], self.triangle_indices[3 * i + 1], self.triangle_indices[3 * i + 2])) p1 = euclid.Point3(self.vertices[3 * points_indices[0]], self.vertices[3 * points_indices[0] + 1], self.vertices[3 * points_indices[0] + 2]) p2 = euclid.Point3(self.vertices[3 * points_indices[1]], self.vertices[3 * points_indices[1] + 1], self.vertices[3 * points_indices[1] + 2]) p3 = euclid.Point3(self.vertices[3 * points_indices[2]], self.vertices[3 * points_indices[2] + 1], self.vertices[3 * points_indices[2] + 2]) self.triangles.append(Triangle(points_indices[0],points_indices[1],points_indices[2],\ p1,p2,p3)) points_indices.clear()
# Note that this changes em1, but not nm1! em1_copy = em1.copy() aseq( em1.pre_translate(8, 7) * ev1, nm1.pre_translate(8, 7) * nv1, '5 translate apply') em1 = em1_copy aseq(em1, nm1, 'foo') # Test that Vec2Array application works rvals = [(np.random.random(), np.random.random()) for i in range(6)] nmv = nm1 * npeuclid.Vec2Array(rvals) for i, v in enumerate(rvals): aseq(em1 * euclid.Point2(*v), nmv[i], 'Vec2 array apply: Point %d' % i) ev1 = euclid.Point3(1, 2, 3) nv1 = npeuclid.Vec3(1, 2, 3) aseq(ev1, nv1, 'Point3') et1 = euclid.Matrix4.new_scale(1, 2, 3) nt1 = npeuclid.Affine3.new_scale(1, 2, 3) aseq(et1, nt1, 'Scale3') ev2 = et1 * ev1 nv2 = nt1 * nv1 aseq(ev2, nv2, 'Scaled3 point') heading, attitude, bank = [math.degrees(v) for v in (10, 20, 30)] et2 = euclid.Matrix4.new_rotate_euler(heading, attitude, bank) nt2 = npeuclid.Affine3.new_rotate_euler(heading, attitude, bank) ev3 = et2 * ev1
def make_spline(p0, p1, p2, p3, roll0, roll1, width, segments): verts = [] colors = [] uvs = [] trackColor = (255, 255, 255) width = width * 0.5 for i in range(0, segments): t = i / float(segments) color = (255 * t, 0, 255 - (255 * t)) (x0, dx0) = spline(t, p0.x, p1.x, p2.x, p3.x) (y0, dy0) = spline(t, p0.y, p1.y, p2.y, p3.y) (z0, dz0) = spline(t, p0.z, p1.z, p2.z, p3.z) at0 = euclid.Point3(x0, y0, z0) d0 = euclid.Vector3(dx0, dy0, dz0) d0.normalize() up = euclid.Vector3(0.0, 0.0, 1.0) roll = roll0 + (roll1 - roll0) * (3.0 * t * t - 2.0 * t * t * t) (forward, normal, perp) = project(d0, up) print(forward, perp, normal) # left back leftOffset = perp * -width rollTransform = euclid.Matrix4.new_rotate_axis(roll * math.pi / 180.0, forward) leftOffset = rollTransform * leftOffset pos = at0 + leftOffset verts.append(pos) colors.append(color) uvs.append((0.0, 0.0)) # right back rightOffset = perp * width rollTransform = euclid.Matrix4.new_rotate_axis(roll * math.pi / 180.0, forward) rightOffset = rollTransform * rightOffset pos = at0 + rightOffset verts.append(pos) colors.append(color) uvs.append((1.0, 0.0)) t = (i + 1) / float(segments) color = (255 * t, 0, 255 - (255 * t)) (x1, dx1) = spline(t, p0.x, p1.x, p2.x, p3.x) (y1, dy1) = spline(t, p0.y, p1.y, p2.y, p3.y) (z1, dz1) = spline(t, p0.z, p1.z, p2.z, p3.z) at1 = euclid.Point3(x1, y1, z1) d1 = euclid.Vector3(dx1, dy1, dz1) d1.normalize() roll = roll0 + (roll1 - roll0) * (3.0 * t * t - 2.0 * t * t * t) (forward, normal, perp) = project(d1, up) # left front leftOffset = perp * -width rollTransform = euclid.Matrix4.new_rotate_axis(roll * math.pi / 180.0, d1) leftOffset = rollTransform * leftOffset pos = at1 + leftOffset verts.append(pos) colors.append(color) uvs.append((0.0, 1.0)) # right front rightOffset = perp * width rollTransform = euclid.Matrix4.new_rotate_axis(roll * math.pi / 180.0, d1) rightOffset = rollTransform * rightOffset pos = at1 + rightOffset verts.append(pos) colors.append(color) uvs.append((1.0, 1.0)) faces = [] for i in range(0, segments): faces.append(((i * 4), (i * 4 + 1), (i * 4 + 2))) faces.append(((i * 4 + 2), (i * 4 + 1), (i * 4 + 3))) return {"vertices": verts, "faces": faces, "colors": colors, "uvs": uvs}
def make_vertex(point): return euclid.Point3(point["x"], point["y"], point["z"])
def getViewMatrix(self): translate = -1 * euclid.Point3(*self.group.translate) scale = euclid.Point3(1.0 / self.group.scale[0], 1.0 / self.group.scale[1], 0) return euclid.Matrix4.new_scale(*scale).translate(*translate)
def worldPosFromMouse(self, mousePos): a, b = self.screenToAmbient(*mousePos) x1, y1, z1 = self.getViewMatrix() * euclid.Point3(a, b, 0) return x1, y1
def __init__(self, position=euclid.Point3(0., 0., 0.), size=1.): self.position = position # a Point3 self.size = size