def find_closest_sprite(x,y): base_vector = Vector3(1,0,0) sprite_vector = Vector3(x,y,0).normalise() angle = (base_vector.dot(sprite_vector)) angle = math.acos(angle) angle = angle * 360.0 / (2 * math.pi) angle = int(angle) print(angle) if is_almost_equal(angle, 135, angle_fuzziness) or is_almost_equal(angle, 135 + 180, angle_fuzziness): return 0 if is_almost_equal(angle, 112, angle_fuzziness) or is_almost_equal(angle, 112 + 180, angle_fuzziness): return 1 if is_almost_equal(angle, 90, angle_fuzziness) or is_almost_equal(angle, 270, angle_fuzziness): return 2 if is_almost_equal(angle, 67, angle_fuzziness) or is_almost_equal(angle, 67 + 180, angle_fuzziness): return 3 if is_almost_equal(angle, 45, angle_fuzziness) or is_almost_equal(angle, 45 + 180, angle_fuzziness): return 4 if is_almost_equal(angle, 22, angle_fuzziness) or is_almost_equal(angle, 22 + 180, angle_fuzziness): return 5 if is_almost_equal(angle, 0, angle_fuzziness) or is_almost_equal(angle, 180, angle_fuzziness): return 6 if is_almost_equal(angle, 180 - 22, angle_fuzziness) or is_almost_equal(angle, 360 - 22, angle_fuzziness): return 6 return -1
def get(self, t, scale): t = float(scale * t) x_basis = self.p1 - self.p0 y_basis = x_basis.length() * Vector3.cross(x_basis, Vector3.k()).normalize() basis = Mat2x2.fromvectors( x_basis, y_basis ) transformed_v0 = (basis * self.v0).normalize() transformed_v1 = (basis * self.v1).normalize() slope_0 = transformed_v0.y / transformed_v0.x slope_1 = transformed_v1.y / transformed_v1.x spline = Vector3( t, (self.H2(t) * slope_0) + (self.H3(t) * slope_1) ) # f.write("{},{}\n".format( # spline.x, spline.y # )) spline_der = Vector3( scale, (self.d_H2(t, scale) * slope_0) + (self.d_H3(t, scale) * slope_1) ) return ((basis * spline) + self.p0, (basis * spline_der))
def testAgainstBruteForceIntegration(self): '''Make sure our numerical integrator is doing a decent job at estimating arc length''' self.spline = CatmullRom([ Vector3(0, 0, 0), Vector3(1, 5, 0), Vector3(2, -3, 0), Vector3(3, 0, 0) ]) seg = 0 u1 = 0 u2 = 1 gaussResult = self.spline.arcLength(seg, u1, u2) # Let's use Brute Force n = 1000 dt = 1.0 / n L = 0 t = 0 for i in range(0, n): L += self.spline.velocity(seg, t).length() * dt t += dt # within a millimeter self.assertAlmostEqual(gaussResult, L, 3)
def __init__(self): if Missile.missile_mesh is None: Missile.missile_mesh = Missile.create_missile_mesh() Missile.missile_material = Material(Color(1, 0, 0, 1), "MissileMaterial") super().__init__("Missile") # Determine the spawn position. There's 33% chance it comes from the right, 33% that it # comes from behind the mountains, and 34% chance it comes from the left self.position = Vector3(0, random.uniform(0, 3), 12) r = random.uniform(0, 100) if r > 66: self.position.x = 7 self.rotation = Quaternion.AngleAxis(Vector3(0, 1, 0), math.radians(-90)) elif r > 33: self.position.y = -2 self.position.x = random.uniform(-4, 4) self.rotation = Quaternion.AngleAxis(Vector3(1, 0, 0), math.radians(-90)) else: self.position.x = -7 self.rotation = Quaternion.AngleAxis(Vector3(0, 1, 0), math.radians(90)) # Set the mesh and material of the missile self.mesh = Missile.missile_mesh self.material = Missile.missile_material # Sets the missile linear speed self.missile_speed = 2 # Sets the rotation speed (in radians per second) self.missile_rotation_speed = 0.75
def setNextPositionScan(self, *args): self.updateFunction = self.updateLinear if('slow' in args): self.currentSpeedLimit = StewartPlatform.SERVO_SPEED_LIMIT/10 else: self.currentSpeedLimit = StewartPlatform.SERVO_SPEED_LIMIT/5 # pan actually means rotate around y-axis # and tilt means rotate around x-axis deltaAngles = (0,StewartPlatform.MOVE_SHORT_ANGLE/12*self.currentScanDirection[1],0) if(abs(self.currentPosition.rotation.y + deltaAngles[1]) > StewartPlatform.MOVE_LONG_ANGLE/3): self.currentScanDirection[1] *= -1 deltaAngles = (StewartPlatform.MOVE_SHORT_ANGLE/4*self.currentScanDirection[0],0,0) if(abs(self.currentPosition.rotation.x + deltaAngles[0]) > StewartPlatform.MOVE_LONG_ANGLE/2): self.currentScanDirection[0] *= -1 deltaAngles = (0,StewartPlatform.MOVE_SHORT_ANGLE/12*self.currentScanDirection[1],0) # move platform slightly closer to its initial height currentTranslation = self.currentPosition.translation translation = Vector3(currentTranslation.x, currentTranslation.y, currentTranslation.z*0.9) done = False while not done: rotation = Vector3(deltaAngles[0], deltaAngles[1], deltaAngles[2]) + self.currentPosition.rotation done = self.setTargetAnglesSuccessfully(translation, rotation) deltaAngles = map(lambda x:uniform(0.666,0.8)*x, deltaAngles)
def __init__(self, num_of_particles, position, lifetime, velocity=Vector3(0, -100, 0), acceleration=Vector3(0, 50, 0), x_angle=100, z_angle=100, spawn_rate=5): self.num_of_particles = num_of_particles self.position = position self.velocity = velocity self.acceleration = acceleration self.x_angle = x_angle self.z_angle = z_angle self.lifetime = lifetime self.spawn_rate = spawn_rate self.particles = [] for _ in range(num_of_particles): particle = PhysicsParticle(lifetime, velocity=velocity, acceleration=acceleration, x_angle=x_angle, z_angle=z_angle, position=position) self.particles.append(particle)
def __init__(self, name, height=DEFAULT_HEIGHT, width=DEFAULT_WIDTH, depth=DEFAULT_DEPTH, start_pos=Vector3(0, 0, 0), color=Color(0, 1, 0, 1)): self.height = height self.width = width self.depth = depth self.name = name self.position = start_pos self.rotation = Quaternion.identity() self.scale = Vector3(1, 1, 1) if (height == self.DEFAULT_HEIGHT) and ( width == self.DEFAULT_WIDTH) and (depth == self.DEFAULT_DEPTH): self.mesh = self.BLOCK_MESH else: self.mesh = Mesh.create_cube((self.width, self.height, self.depth)) self.material = Material(color, "Block Material") self.children = [] self.my_collider = AABB_Collider( Vector3(self.width, self.height, self.depth))
def setNextPositionPerlin(self, *args, **kwargs): self.updateFunction = self.updatePerlin if('slow' in args): self.currentSpeedLimit = StewartPlatform.SERVO_SPEED_LIMIT/2 else: self.currentSpeedLimit = StewartPlatform.SERVO_SPEED_LIMIT*2 t = (time()-StewartPlatform.INIT_TIME) * StewartPlatform.PERLIN_TIME_SCALE (x,y,z) = self.currentPosition.getTranslationAsList() # direction u = snoise4(x*StewartPlatform.PERLIN_POSITION_SCALE + 1*StewartPlatform.PERLIN_PHASE, y*StewartPlatform.PERLIN_POSITION_SCALE + 1*StewartPlatform.PERLIN_PHASE, z*StewartPlatform.PERLIN_POSITION_SCALE + 1*StewartPlatform.PERLIN_PHASE, t + 1*StewartPlatform.PERLIN_PHASE) v = snoise4(x*StewartPlatform.PERLIN_POSITION_SCALE + 2*StewartPlatform.PERLIN_PHASE, y*StewartPlatform.PERLIN_POSITION_SCALE + 2*StewartPlatform.PERLIN_PHASE, z*StewartPlatform.PERLIN_POSITION_SCALE + 2*StewartPlatform.PERLIN_PHASE, t + 2*StewartPlatform.PERLIN_PHASE) w = snoise4(x*StewartPlatform.PERLIN_POSITION_SCALE + 3*StewartPlatform.PERLIN_PHASE, y*StewartPlatform.PERLIN_POSITION_SCALE + 3*StewartPlatform.PERLIN_PHASE, z*StewartPlatform.PERLIN_POSITION_SCALE + 3*StewartPlatform.PERLIN_PHASE, t + 3*StewartPlatform.PERLIN_PHASE) #magnitude thisSpeedScale = StewartPlatform.PERLIN_SPEED_SCALE/3 if ('slow' in args) else StewartPlatform.PERLIN_SPEED_SCALE speed = min(StewartPlatform.PERLIN_MAX_SPEED, max(StewartPlatform.PERLIN_MIN_SPEED, thisSpeedScale*(snoise4(u,v,w,t)*0.5+0.5))) # result deltaDistances = ( u*speed, v*speed, w*speed) deltaAngles = ( snoise2(v,t)*StewartPlatform.PERLIN_ANGLE_SCALE, snoise2(w,t)*StewartPlatform.PERLIN_ANGLE_SCALE, snoise2(u,t)*StewartPlatform.PERLIN_ANGLE_SCALE) # pick new valid position translateArg = kwargs.get('translate', '') rotateArg = kwargs.get('rotate', '') done = False while not done: translation = Vector3( deltaDistances[0] if 'x' in translateArg else 0, deltaDistances[1] if 'y' in translateArg else 0, deltaDistances[2] if 'z' in translateArg else 0) + self.currentPosition.translation translation.constrain(-StewartPlatform.PERLIN_DISTANCE_LIMIT, StewartPlatform.PERLIN_DISTANCE_LIMIT) rotation = Vector3( deltaAngles[0] if 'x' in rotateArg else 0, deltaAngles[1] if 'y' in rotateArg else 0, deltaAngles[2] if 'z' in rotateArg else 0) + self.currentPosition.rotation rotation.constrain(-StewartPlatform.PERLIN_ANGLE_LIMIT, StewartPlatform.PERLIN_ANGLE_LIMIT) done = self.setTargetAnglesSuccessfully(translation, rotation) deltaDistances = map(lambda x:0.9*x, deltaDistances) deltaAngles = map(lambda x:0.9*x, deltaAngles)
def generateSphere(n, r, color): """ this will generate a sphere sitting in O and divide as mentioned """ vertexes = [] triangles = [] for d in range(n + 1): yb = 2 * r * d / n - r for i in range(n): alpha = 2 * pi * i / n rprime = sqrt(r * r - yb * yb) xb = rprime * cos(alpha) zb = rprime * sin(alpha) vertexes.append(Vector3(xb, yb, zb)) for i in range(n): start = i * n for j in range(n - 1): a = start + j b = a + 1 c = a + n d = c + 1 triangles.append(Triangle(a, d, b, color)) triangles.append(Triangle(a, c, d, color)) return Model(vertexes, triangles, Vector3(0, 0, 0), r)
def _manipulate(self, ent, amountx, amounty, lengthx, lengthy): if self.grabbed: qscale = ent.placeable.Scale scale = list((qscale.x(), qscale.y(), qscale.z())) rightvec = Vector3(r.getCameraRight()) upvec = Vector3(r.getCameraUp()) if self.grabbed_axis == self.AXIS_BLUE: mov = lengthy scale[self.grabbed_axis] -= mov else: mov = lengthx div = abs(rightvec[self.grabbed_axis]) if div == 0: div = 0.01 #not the best of ideas but... mov *= rightvec[self.grabbed_axis] / div scale[self.grabbed_axis] += mov newscale = Vec(scale[0], scale[1], scale[2]) ent.placeable.Scale = newscale self.controller.updateSelectionBox(ent) qprim = ent.prim if qprim is not None: children = qprim.GetChildren() for child_id in children: child = r.getEntity(int(child_id)) child.placeable.Scale = newscale
def _manipulate(self, ent, amountx, amounty, lengthx, lengthy): if self.grabbed and self.grabbed_axis is not None: rightvec = Vector3(r.getCameraRight()) upvec = Vector3(r.getCameraUp()) ort = ent.placeable.Orientation euler = list((0, 0, 0)) if self.grabbed_axis == self.AXIS_GREEN: #rotate z-axis #print "green axis", self.grabbed_axis mov = amountx * 30 euler[2] += mov elif self.grabbed_axis == self.AXIS_BLUE: #rotate x-axis #print "blue axis", self.grabbed_axis mov = amountx * 30 euler[1] += mov elif self.grabbed_axis == self.AXIS_RED: #rotate y-axis #print "red axis", self.grabbed_axis mov = amounty * 30 euler[0] -= mov rotationQuat = list(euler_to_quat(euler)) ort.__imul__( Quat(rotationQuat[3], rotationQuat[0], rotationQuat[1], rotationQuat[2])) ent.placeable.Orientation = ort ent.network.Orientation = ort
def setUp(self): self.spline = CatmullRom([ Vector3(0, 0, 0), Vector3(1, 0, 0), Vector3(2, 0, 0), Vector3(3, 0, 0) ])
def ray_from_ndc(self, pos): """Retrieves a ray (origin, direction) corresponding to the given position on screen. This function takes the coordinates as NDC (normalized device coordinates), in which the lower-left corner of the screen corresponds to (-1,-1) and the upper-right corresponds to (1,1). For example, to convert mouse coordinates to NDC, you could do something like: >>> mouse_pos = pygame.mouse.get_pos() >>> mouse_pos = ((mouse_pos[0] / res_x) * 2 - 1, (mouse_pos[1] / res_y) * 2 - 1) >>> origin, dir = camera.RayFromNDC(mouse_pos) Arguments: pos {2-tuple} -- Screen position in NDC (normalized device coordinates) Returns: Vector3, Vector3 - Origin and direction of the ray corresponding to that screen positions """ vpos = Vector3(pos[0], pos[1], self.near_plane) vpos.x = vpos.x * self.res_x * 0.5 vpos.y = -vpos.y * self.res_y * 0.5 inv_view_proj_matrix = self.get_camera_matrix( ) * self.get_projection_matrix() inv_view_proj_matrix.invert() direction = inv_view_proj_matrix.posmultiply_v3(vpos, 1) direction = Vector3(direction.x, direction.y, direction.z).normalized() return self.position + direction * self.near_plane, direction
def tetrahedron(): d = { Vector3(-1, -1, -1): 1, Vector3(-1, 1, 1): 2, Vector3(1, -1, 1): 3, Vector3(1, 1, -1): 4 } return tiling3_convex_hull(d)
def icosahedron(): vertices = [ v for p in [1, -1] for q in [tau, -tau] for v in [Vector3(p, q, 0), Vector3(q, 0, p), Vector3(0, p, q)] ] return tiling3_convex_hull(dict(zip(vertices, range(12))))
def rotate_yaw_pitch_row(eulers): # type: (Vector3) -> Matrix4 m = Matrix4.identity() # NOTE in zxy order m = glm.rotate(m, eulers.z, Vector3(0, 0, 1)) m = glm.rotate(m, eulers.x, Vector3(1, 0, 0)) m = glm.rotate(m, eulers.y, Vector3(0, 1, 0)) return m
def setUp(self): # 1 meter long spline self.spline = CatmullRom([ Vector3(0, 0, 0), Vector3(1, 0, 0), Vector3(2, 0, 0), Vector3(3, 0, 0) ])
def test_div(self): v1 = Vector3(1, 2, 3) v2 = Vector3(4, 5, 6) # self.assertEqual(3 / v1, (3., 3. / 2, 1.)) self.assertEqual(v1 / 3, (1. / 3, 2 / 3., 3 / 3.)) # self.assertEqual((3, 3, 3) / v1, (3. / 1., 3. / 2., 3. / 3.)) self.assertEqual(v1 / (3, 3, 3), (1. / 3, 2 / 3., 3 / 3.)) v1 /= 2 self.assertEqual(v1, (.5, 1., 1.5))
def testAddCancel(self): """ Test adding a vector and its inverse """ loc = LocationGlobalRelative(-45.6549814, 65.216548, 45.25641) vec = Vector3(85.6, -23.4, 3.4) vecInv = Vector3(-85.6, 23.4, -3.4) newloc = location_helpers.addVectorToLocation(loc, vec) newloc = location_helpers.addVectorToLocation(newloc, vecInv) dist = location_helpers.getDistanceFromPoints3d(loc, newloc) self.assertTrue(abs(dist) < ERROR)
def test_mul(self): v1 = Vector3(1, 2, 3) v2 = Vector3(4, 5, 6) self.assertEqual(3 * v1, (3, 6, 9)) self.assertEqual(v1 * 3, (3, 6, 9)) self.assertEqual((3, 3, 3) * v1, (3, 6, 9)) self.assertEqual(v1 * (3, 3, 3), (3, 6, 9)) v1 *= 2 self.assertEqual(v1, (2, 4, 6))
def __init__(self): super(Camera, self).__init__() self.aperture = 90.0 self.camera3dPosition = Vector3(0.0, 0.0, 10.0) self.view = Vector3(0.0, 0.0, -10.0) self.up = Vector3(0.0, 1.0, 0.0) self.zNearClip = 0.001 self.zFarClip = 200.0
def setNextPositionLinear(self, *args, **kwargs): self.updateFunction = self.updateLinear if ('repeat' in args): if ('slow' in args): self.currentSpeedLimit = StewartPlatform.SERVO_SPEED_LIMIT / 2 elif ('fast' in args): self.currentSpeedLimit = StewartPlatform.SERVO_SPEED_LIMIT self.setTargetAnglesSuccessfully(self.lastPosition.translation, self.lastPosition.rotation) else: if ('slow' in args): self.currentSpeedLimit = StewartPlatform.SERVO_SPEED_LIMIT / 2 else: self.currentSpeedLimit = StewartPlatform.SERVO_SPEED_LIMIT # pick new valid position translateArg = kwargs.get('translate', '') rotateArg = kwargs.get('rotate', '') deltaDistances = [0] * 3 deltaAngles = [0] * 3 if (('short' in args) or ('near' in args)): # randomly move towards -MOVE_SHORT_ or +MOVE_SHORT_ # makes a list by picking -MOVE_SHORT_ or +MOVE_SHORT_ 3 times deltaDistances = map(lambda x: choice([-1, 1]) * x, [StewartPlatform.MOVE_SHORT_DISTANCE] * 3) deltaAngles = map(lambda x: choice([-1, 1]) * x, [StewartPlatform.MOVE_SHORT_ANGLE] * 3) else: # picks new potential long targets from current position deltaDistances = map( StewartPlatform.pickLongTargetValue( StewartPlatform.MOVE_LONG_DISTANCE), self.currentPosition.getTranslationAsList()) deltaAngles = map( StewartPlatform.pickLongTargetValue( StewartPlatform.MOVE_LONG_ANGLE), self.currentPosition.getRotationAsList()) done = False while not done: translation = Vector3( deltaDistances[0] if 'x' in translateArg else 0, deltaDistances[1] if 'y' in translateArg else 0, deltaDistances[2] if 'z' in translateArg else 0) + self.currentPosition.translation rotation = Vector3( deltaAngles[0] if 'x' in rotateArg else 0, deltaAngles[1] if 'y' in rotateArg else 0, deltaAngles[2] if 'z' in rotateArg else 0) + self.currentPosition.rotation done = self.setTargetAnglesSuccessfully(translation, rotation) deltaDistances = map(lambda x: uniform(0.666, 0.8) * x, deltaDistances) deltaAngles = map(lambda x: uniform(0.666, 0.8) * x, deltaAngles)
def periodic_copies(tiling3, bounding_box, periods=[Vector3(1,0,0), Vector3(0,1,0), Vector3(0,0,1)]): gen = LatticeSearcher(len(periods)) for n in gen: t1 = tiling3.translate(sum((u*c for (u,c) in zip(periods, n)), Vector3(0,0,0))) if t1.in_box(bounding_box): yield t1 else: gen.reject()
def trace_diffuse(self, ray, scene): self.__scene = scene hit_object, hit_point, hit_normal = self.__intersect(ray) if hit_object is None: return Vector3(0.3, 0.3, 0.3) # horizon traced_color = Vector3() if hit_object.material.is_diffuse: traced_color = self.__trace_diffuse(hit_object, hit_point, hit_normal) return traced_color
def _manipulate(self, ent, amountx, amounty, lengthx, lengthy): rightvec = Vector3(r.getCameraRight()) upvec = Vector3(r.getCameraUp()) changevec = (amountx * rightvec) - (amounty * upvec) qpos = ent.placeable.Position entpos = Vector3(qpos.x(), qpos.y(), qpos.z()) newpos = entpos + changevec newpos = Vec(newpos.x, newpos.y, newpos.z) ent.placeable.Position = newpos ent.network.Position = newpos
def restrict43(t): """ Given a Tiling4, produce the Tiling3 corresponding to the cross-section consisting of the hyperplane with z coordinate = 0. For example, if t is a tiling of hypercubes, translated a little, then the result will be a cubic tiling. If you want a different hyperplane cross-section, you've got to rotate and translate the tiling first. For now, it complains if any vertices have z = 0. Of course, this should be a measure-zero event, and can be avoided by small translations. This makes the algorithm much simpler: edges in the input produce vertices in the output; faces in the input produce edges in the output, volumes in the input produce faces in the output, and hypervolumes in the input produce volumes in the output. """ for (v, x) in t.vertices.items(): if v.z == 0: raise ValueError("Vertex %s lies in cell z=0" % (v, )) # Check Cell is the right word. newv = {} for (e, l) in t.edges.items(): (v1, v2) = e if v2.z < 0 < v1.z: (v1, v2) = (v2, v1) if v1.z < 0 < v2.z: # If the edge passes through the plane z=0, then the # result will contain a vertex lying at the point of # intersection. u1 = Vector3(v1.w, v1.x, v1.y) u2 = Vector3(v2.w, v2.x, v2.y) newv[e] = ((u1 * (v2.z) - u2 * (v1.z)) / (v2.z - v1.z), l) newe = {} for (f, x) in t.faces.items(): e = frozenset(newv[e1][0] for e1 in f if e1 in newv) if e: newe[f] = (e, x) newf = {} for (g, x) in t.volumes.items(): f = frozenset(newe[f1][0] for f1 in g if f1 in newe) if f: newf[g] = (f, x) newg = {} for (h, x) in t.hypervolumes.items(): g = frozenset(newf[g1][0] for g1 in h if g1 in newf) if g: newg[h] = (g, x) return Tiling3(newv.values(), newe.values(), newf.values(), newg.values())
def dodecahedron(): vertices1 = [ Vector3(x, y, z) for x in [-1, 1] for y in [-1, 1] for z in [-1, 1] ] vertices2 = [ v for p in [tau, -tau] for q in [tau.conj(), -tau.conj()] for v in [Vector3(p, q, 0), Vector3(q, 0, p), Vector3(0, p, q)] ] return tiling3_convex_hull(dict(zip(vertices1 + vertices2, range(20))))
def __init__(self, mass=1, position=Vector3(), velocity=Vector3(), rotation=Vector3(), acceleration=Vector3()): self.mass = mass self.position = position self.velocity = velocity self.rotation = rotation self.acceleration = acceleration
def __init__(self, surface_color=Vector3(), emission_color=Vector3(), reflectivity=0.0, transparency=0.0, ior=1.0): """Creates a new material""" self.__surface_color = surface_color self.__emission_color = emission_color self.__reflectivity = reflectivity self.__transparency = transparency self.__ior = ior
def testAcceleration(self): '''For an evenly spaced straight-line spline, test that acceleration is zero''' seg = 0 u = 0 ddq = self.spline.acceleration(seg, u) self.assertEqual(ddq, Vector3(0.0, 0.0, 0.0)) u = 0.5 ddq = self.spline.acceleration(seg, u) self.assertEqual(ddq, Vector3(0.0, 0.0, 0.0)) u = 1.0 ddq = self.spline.acceleration(seg, u) self.assertEqual(ddq, Vector3(0.0, 0.0, 0.0))
def transform_vec3(self, v): """Transforms a Vector3 and returns the result as a Vector3. v -- Vector to transform """ m = self._m x, y, z = v return Vector3.from_floats( x * m[0] + y * m[4] + z * m[8] + m[12], x * m[1] + y * m[5] + z * m[9] + m[13], x * m[2] + y * m[6] + z * m[10] + m[14] )
def transform_sequence_vec3(self, points): m_0, m_1, m_2, m_3, \ m_4, m_5, m_6, m_7, \ m_8, m_9, m_10, m_11, \ m_12, m_13, m_14, m_15 = self._m return [ Vector3.from_floats ( x * m_0 + y * m_4 + z * m_8 + m_12, x * m_1 + y * m_5 + z * m_9 + m_13, x * m_2 + y * m_6 + z * m_10 + m_14 ) for x,y,z in points ]
def get_row_vec3(self, row_no): """Returns a Vector3 for a given row. row_no -- The row index """ try: r = row_no*4 x, y, z = self._m[r:r+3] return Vector3.from_floats(x, y, z) except IndexError: raise IndexError( "Row and Column should be 0, 1, 2 or 3" )
def rotate_vec3(self, v): """Rotates a Vector3 and returns the result. The translation part of the Matrix44 is ignored. v -- Vector to rotate """ m = self._m x, y, z = v return Vector3.from_floats( x * m[0] + y * m[4] + z * m[8], x * m[1] + y * m[5] + z * m[9], x * m[2] + y * m[6] + z * m[10] )
def iter_transform_vec3(self, points): """Transforms a sequence of points, and yields the result as Vector3s points -- A sequence of vectors """ m_0, m_1, m_2, m_3, \ m_4, m_5, m_6, m_7, \ m_8, m_9, m_10, m_11, \ m_12, m_13, m_14, m_15 = self._m for x, y, z in points: yield Vector3.from_floats( x * m_0 + y * m_4 + z * m_8 + m_12, x * m_1 + y * m_5 + z * m_9 + m_13, x * m_2 + y * m_6 + z * m_10 + m_14 )
def as_vec3(self): """Shorthand for converting to a vector3.""" return Vector3._from_float_sequence(self)