def test_procedural_examples(self):
from pyrr import quaternion, matrix44, vector3
import numpy as np
point = vector3.create(1.,2.,3.)
orientation = quaternion.create()
translation = vector3.create()
scale = vector3.create(1,1,1)
# translate along X by 1
translation += [1.0, 0.0, 0.0]
# rotate about Y by pi/2
rotation = quaternion.create_from_y_rotation(np.pi / 2.0)
orientation = quaternion.cross(rotation, orientation)
# create a matrix
# start our matrix off using the scale
matrix = matrix44.create_from_scale(scale)
# apply our orientation
orientation = matrix44.create_from_quaternion(orientation)
matrix = matrix44.multiply(matrix, orientation)
# apply our translation
translation_matrix = matrix44.create_from_translation(translation)
matrix = matrix44.multiply(matrix, translation_matrix)
# transform our point by the matrix
point = matrix44.apply_to_vector(matrix, point)
def test_procedural_examples(self):
from pyrr import quaternion, matrix44, vector3
import numpy as np
point = vector3.create(1.,2.,3.)
orientation = quaternion.create()
translation = vector3.create()
scale = vector3.create(1,1,1)
# translate along X by 1
translation += [1.0, 0.0, 0.0]
# rotate about Y by pi/2
rotation = quaternion.create_from_y_rotation(np.pi / 2.0)
orientation = quaternion.cross(rotation, orientation)
# create a matrix
# start our matrix off using the scale
matrix = matrix44.create_from_scale(scale)
# apply our orientation
orientation = matrix44.create_from_quaternion(orientation)
matrix = matrix44.multiply(matrix, orientation)
# apply our translation
translation_matrix = matrix44.create_from_translation(translation)
matrix = matrix44.multiply(matrix, translation_matrix)
# transform our point by the matrix
point = matrix44.apply_to_vector(matrix, point)
def test_decompose(self):
# define expectations
expected_scale = vector3.create(*[1, 1, 2], dtype='f4')
expected_rotation = quaternion.create_from_y_rotation(np.pi, dtype='f4')
expected_translation = vector3.create(*[10, 0, -5], dtype='f4')
expected_model = np.array([
[-1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, -2, 0],
[10, 0, -5, 1],
], dtype='f4')
# compose matrix using Pyrr
s = matrix44.create_from_scale(expected_scale, dtype='f4')
r = matrix44.create_from_quaternion(expected_rotation, dtype='f4')
t = matrix44.create_from_translation(expected_translation, dtype='f4')
model = s.dot(r).dot(t)
np.testing.assert_almost_equal(model, expected_model)
self.assertTrue(model.dtype == expected_model.dtype)
# decompose matrix
scale, rotation, translation = matrix44.decompose(model)
np.testing.assert_almost_equal(scale, expected_scale)
self.assertTrue(scale.dtype == expected_scale.dtype)
np.testing.assert_almost_equal(rotation, expected_rotation)
self.assertTrue(rotation.dtype == expected_rotation.dtype)
np.testing.assert_almost_equal(translation, expected_translation)
self.assertTrue(translation.dtype == expected_translation.dtype)
def GetWorldMatrix(self): if self.worldMatrix is None or self.isDirty: self.isDirty = False translation = matrix44.create_from_translation(vector3.create(self.position[0], self.position[1], 0.0)) rotation = matrix44.create_from_z_rotation(self.rotation) self.worldMatrix = matrix44.multiply(rotation, translation) return self.worldMatrix
def rotateAboutOrigin(self, xyz, t, p):
rp = p - math.pi / 2
rt = -t
q1 = quaternion.create_from_z_rotation(rp)
q2 = quaternion.create_from_x_rotation(rt)
v = vector3.create(xyz[0], xyz[1], xyz[2])
v = quaternion.apply_to_vector(q1, v)
v = quaternion.apply_to_vector(q2, v)
return v
def draw(self, time, frametime, target):
self.ctx.disable(mgl.DEPTH_TEST)
self.ctx.enable(mgl.BLEND)
self.ctx.blend_func = mgl.SRC_ALPHA, mgl.ONE_MINUS_SRC_ALPHA
m_proj = self.create_projection(90.0, 1.0, 1000.0)
# Rotate and translate
m_mv = self.create_transformation(rotation=(time * 0.0, time * 0,
time * 0),
translation=(0.0, 0.0, -40.0))
# Apply the rotation and translation from the system camera
m_mv = matrix44.multiply(m_mv, self.sys_camera.view_matrix)
gravity_pos = vector3.create(
math.sin(time) * 5,
math.cos(time) * 5,
math.sin(time / 3) * 5)
gravity_force = math.cos(time / 2) * 3.0 + 3.0
# gravity_force = 2.0
# Transform positions
self.feedback["gravity_pos"].write(gravity_pos.astype('f4').tobytes())
self.feedback["gravity_force"].value = gravity_force
self.feedback["timedelta"].value = frametime
self.particles.transform(self.feedback, self.pos)
# Draw particles
self.program["m_proj"].write(m_proj.astype('f4').tobytes())
self.program["m_mv"].write(m_mv.astype('f4').tobytes())
self.texture.use(location=0)
self.program["texture0"].value = 0
self.particles.render(self.program)
# Swap buffers
self.pos = self.pos1 if self.pos == self.pos2 else self.pos2
self.particles = self.particles1 if self.particles == self.particles2 else self.particles2
def test_create_list(self):
with self.assertRaises(ValueError):
vector3.create([1., 2., 3.])
def test_create_values(self):
result = vector3.create(1., 2., 3., dtype=np.float32)
np.testing.assert_almost_equal(result, [1., 2., 3.], decimal=5)
self.assertTrue(result.dtype == np.float32)
def test_create(self):
result = vector3.create()
np.testing.assert_almost_equal(result, [0., 0., 0.], decimal=5)
self.assertTrue(result.dtype == np.float)
def test_create_values(self):
result = vector3.create(1., 2., 3., dtype=np.float32)
np.testing.assert_almost_equal(result, [1.,2.,3.], decimal=5)
self.assertTrue(result.dtype == np.float32)
def test_create(self):
result = vector3.create()
np.testing.assert_almost_equal(result, [0.,0.,0.], decimal=5)
self.assertTrue(result.dtype == np.float)
def test_create_list(self):
with self.assertRaises(ValueError):
vector3.create([1., 2., 3.])
def __init__(self, entityName, componentInfo): Component.__init__(self, entityName, componentInfo) self.position = vector3.create(self.pos[0], self.pos[1], self.pos[2]) self.rotation = quaternion.create_from_z_rotation(self.rotAngle) self.worldMatrix = matrix44.create_identity() self.dirty = True
