def tumble(self, hdelta, vdelta): """ This is equivalent of rotating the camera around it's target point while maintaining the direction vector; to reflect the change in view the camera will be rotated by the additive inverse of the deltas. @param hdelta The horizontal delta (the up vector rotation) @param vdelta The vertical delta (the right vector rotation) @see Maya Rotation defintions (http://download.autodesk.com/global/docs/maya2013/en_us/index.html?url=files/Viewing_the_scene_Tumble_track_dolly_or_tilt_the_view.htm,topicNumber=d30e15213) @see Rotation algorithm (http://gamedev.stackexchange.com/questions/20758/how-can-i-orbit-a-camera-about-its-target-point) """ # Get the current look at vector (e.g inverse direction) idirection = self._position - self._target # Rotate the y-axis (aka 'up' vector) which is the plane normal coming out of the x-z plane. # The x-z plane is typically the horizontal plane and the yaw angle is measured by the horizontal delta parameter. hrotation = - hdelta * self._pixelradians M = Matrix4x4.rotation( hrotation, self.__camera_upvector__ ) idirection = M * idirection self._up = M * self._up right = (self._up ^ idirection).normalized() # Now rotate the x-axis (aka 'right' vector) which is the plane normal coming out of the y-z plane. # The y-z plane is typically the vertical plane and the pitch angle is measured by the vertical delta parameter. vrotation = - vdelta * self._pixelradians M = Matrix4x4.rotation( vrotation, right ) idirection = M * idirection self._up = M * self._up # Update the camera's position self._position = self._target + idirection self._updateProjectionMatrix()
def _generateMatrix(self): """ Generates a transformation matrix from internal data. @returns A Matrix4x4 representation of the transformation component. """ t = self.__translation.matrix() if self.__translation else Matrix4x4.identity() r = self.__rotation.matrix() if self.__rotation else Matrix4x4.identity() s = self.__scale.matrix() if self.__scale else Matrix4x4.identity() return t * r * s
def _generateMatrix(self): """ Generates a transformation matrix from internal data. @returns A Matrix4x4 representation of the transformation component. """ t = self.__translation.matrix( ) if self.__translation else Matrix4x4.identity() r = self.__rotation.matrix( ) if self.__rotation else Matrix4x4.identity() s = self.__scale.matrix() if self.__scale else Matrix4x4.identity() return t * r * s
def _generateMatrix(self): """ Generates a transformation matrix from internal data. @returns A Matrix4x4 representation of the transformation component. """ return Matrix4x4.identity()
def _generateMatrix(self): """ Generates a transformation matrix from internal data. @returns A Matrix4x4 representation of the transformation component. """ return Matrix4x4.scale(self.__factor, self.__point)
def _generateProjectionMatrix(self): """ Generates a LookAt matrix from internal data. @returns A Matrix4x4 representation of camera's LookAt component. """ return Matrix4x4.lookAt(self._position, self._target, self._up, False)
def __init__(self, matrix=Matrix4x4.identity()): """ Constructor. @param m The initial transformation matrix value. """ super(TransformationComponent, self).__init__() self.__matrix = matrix
def _generateMatrix(self): """ Generates a transformation matrix from internal data. @returns A Matrix4x4 representation of the transformation component. """ radians = math.radians(self.angle) return Matrix4x4.rotation(radians, self.__axis, self.__point)
def paint_enter(self): """ Implements the GLNodeAdapter's paint_enter method for an OpenGL Render operation. """ GL.glPushAttrib(GL.GL_ENABLE_BIT | GL.GL_DEPTH_BUFFER_BIT | GL.GL_LINE_BIT | GL.GL_CURRENT_BIT) GL.glPushClientAttrib(GL.GL_CLIENT_VERTEX_ARRAY_BIT) GL.glMatrixMode(GL.GL_MODELVIEW) GL.glPushMatrix() GL.glMultMatrixf(self._node.matrix().data()) GL.glColor(self._node.color.getRgbF()) # The positive Z-axis is the default direction for Cylinder Quadrics in OpenGL. # If our vector is not parallel to the z-axis, e.g. (0, 0, Z), then rotate it. # 1) Get a normal from the z-v plane # 2) Get the angle inbetween z-v on the plane (see vector dot product) # 3) Rotate the normal by that angle. v = self._node.axis m = Matrix4x4.identity() if v.x != 0 or v.y != 0: zaxis = Vector3D(0,0,1) angle = zaxis.angle(v) normal = zaxis.crossproduct(v, True) m *= Matrix4x4.rotation(angle, normal) # The positive Z-axis is the default direction fo Cylinder Quadrics in OpenGL. # If our z is negative, we need to flip the cylinder if v.z < 0: yaxis = Vector3D(1,0,0) m *= Matrix4x4.rotation(math.radians(180), yaxis) GL.glMultMatrixf(m.data()) q = self.__quadric r = self._node.radius h = self._node.length sl = self._node.slices st = self._node.stacks lp = self._node.loops GLU.gluQuadricDrawStyle (q, GLU.GLU_FILL) GLU.gluQuadricNormals (q, GLU.GLU_SMOOTH) GLU.gluQuadricOrientation(q, GLU.GLU_OUTSIDE) self._glcylinder(q, r, h, sl, st, lp)
def roll(self, delta): """ Executes a rotation operation around the z-axis This is equivalent of rotating the camera around it's z-axis; to reflect the change in view the camera will be rotated by the additive inverse of the delta. @param delta The rotation delta (the change in rotating around the direction vector) """ # Get the current look at vector (e.g inverse direction) direction = self._target - self._position # Rotate the z-axis (aka 'look at' vector) which is the plane normal coming out of the x-y plane. # Since we're rotating the x-y plane, the concept of vertical or horizontal delta doesn't apply; it's # a straight up spin of the look at vector rotation = - delta * self._pixelradians M = Matrix4x4.rotation( rotation, direction ) self._up = M * self._up self._updateProjectionMatrix()