Metadata-Version: 1.1
Name: pyvmath
Version: 0.1.8
Summary: C++ extension Vector Mathematics Package for 3D and 2D games.
Home-page: UNKNOWN
Author: Kiharu Shishikura
Author-email: shishi@indigames.net
License: MIT
Description: pyvmath
        --------
        
        
        C++ extension Vector Mathematics Package for 3D and 2D games.
        -------------------------------------------------------------
        
        
        objects
        -----------------------------------------------
        
        vec2
        
        a 2-D vector in array-of-structures format
        
        vec3
        
        a 3-D vector in array-of-structures format
        
        vec4
        
        a 4-D vector in array-of-structures format
        
        quat
        
        quaternion in array-of-structures format
        
        mat22
        
        a 2x2 matrix in array-of-structures format
        
        mat33
        
        a 3x3 matrix in array-of-structures format
        
        mat44
        
        a 4x4 matrix in array-of-structures format
        
        
        
        functions
        -----------------------------------------------
        
        add
        
        add two vectors or two matrices
        
        c = add(a, b)
        
        
        sub
        
        sub two vectors or two matrices
        
        c = sub(a, b)
        
        
        mul
        
        multiply 2 elements
        
        c = mul(a, b)
        
        the following combinations are possible
        
        vector = vector x scalar
        
        matrix = matrix x scalar
        
        vector = matrix x vector (transform vector)
        
        matrix = matrix x matrix
        
        quatanion = quatanion x quatanion
        
        vector = vector * vector (multiply per element)
        
        
        div
        
        division vector by a scalar
        
        vector = div(vector, scalar)
        
        division vector per element
        
        vector = div(vector, vector)
        
        
        recip
        
        compute the reciprocal of a vector per element
        
        vector = recip(vector)
        
        
        sqrt
        
        compute the square root of a vector per element
        
        vector = sqrt(vector)
        
        
        rsqrt
        
        compute the reciprocal square root of a vector per element
        
        vector = rsqrt(vector)
        
        
        abs
        
        compute the absolute value of a vector per element
        
        vector = abs(vector)
        
        
        max
        
        maximum element of a vector
        
        scalar = max(vector)
        
        
        min
        
        minimum element of a vector
        
        scalar = min(vector)
        
        
        maxElem
        
        maximum of two vectors per element
        
        vector = matElem(vector,vector)
        
        
        minElem
        
        minimum of two vectors per element
        
        vector = minElem(vector, vector)
        
        
        sum
        
        compute the sum of all elements of a vector
        
        scalar = sum(vector)
        
        
        dot
        
        compute the dot product of two vectors
        
        scalar = dot(vector, vector)
        
        
        lengthSqr
        
        compute the square of the length of a vector
        
        scalar = lengthSqr(vector)
        
        
        length
        
        compute the length of a vector
        
        scalar = length(vector)
        
        
        normalize
        
        normalize a vector
        
        vector = normalize(vector)
        
        
        cross
        
        compute cross product of two vectors
        
        scalar = cross(vec2, vec2)
        
        vec3 = cross(vec3, vec3)
        
        
        lerp
        
        linear interpolation between two vectors
        
        vector = lerp(t, vector, vector)  (0<= t <= 1)
        
        
        slerp
        
        spherical linear interpolation between two vectors
        
        vector = slerp(t, vector, vector)  (0<= t <= 1)
        
        
        quat_rotation
        
        construct a quaternion
        
        quat = quat_rotation(vec3, vec3)
        
        construct a quaternion to rotate between two unit - length 3D vectors
        
        the result is unpredictable if 2 vectors point in opposite directions
        
        quat = quat_rotation(scalar, vec3)
        
        construct a quaternion to rotate around a unit-length 3D vector
        
        quat = quat_rotation(scalar)
        
        construct a quaternion to rotate around a Z(0,0,1) axis
        
        
        quat_rotationX
        
        construct a quaternion to rotate around the x axis
        
        quat = quat_rotationX(radian)
        
        
        quat_rotationY
        
        construct a quaternion to rotate around the y axis
        
        quat = quat_rotationY(radian)
        
        
        quat_rotationZ
        
        construct a quaternion to rotate around the z axis
        
        quat = quat_rotationZ(radian)
        
        
        conj
        
        compute the conjugate of a quaternion
        
        quat = conj(quat)
        
        
        squad
        
        spherical quadrangle interpolation
        
        quat = squad(t,quat, quat, quat, quat)
        
        
        rotate
        
        use a unit - length quaternion to rotate a 3D vector
        
        vec = rotate(vec, quat)
        
        
        mat_rotation
        
        construct a matrix to rotate around a unit-length 3D vector
        
        matrix = mat_rotation(radian, dimension, vector)
        
        dimension is 2 or 3 or 4 to output matrix
        
        if you omit vector, Zaxis(0,0,1) will be entered as default
        
        
        mat_rotationX
        
        construct a matrix to rotate around the Xaxis
        
        matrix = mat_rotationX(radian, dimension)
        
        dimension is 2 or 3 or 4 to output matrix
        
        
        mat_rotationY
        
        construct a matrix to rotate around the Yaxis
        
        matrix = mat_rotationY(radian, dimension)
        
        dimension is 2 or 3 or 4 to output matrix
        
        
        mat_rotationZ
        
        construct a matrix to rotate around the Zaxis
        
        matrix = mat_rotationZ(radian, dimension)
        
        dimension is 2 or 3 or 4 to output matrix
        
        
        mat_rotationZYX
        
        construct a matrix to rotate around the x, y, and z axes
        
        matrix = mat_rotationZYX( (xradian, yradian, zradian) )
        
        
        mat_identity
        
        construct an identity matrix
        
        matrix = mat_identity(dimension)
        
        dimension is 2 or 3 or 4 to output matrix
        
        
        mat_scale
        
        construct a matrix to perform scaling
        
        matrix = mat_scale(vector, dimension)
        
        dimension is 2 or 3 or 4 to output matrix
        
        
        mat_translation
        
        construct a 4x4 matrix to perform translation
        
        matrix = mat_translation(vector)
        
        
        transpose
        
        transpose of a matrix
        
        matrix = transpose(matrix)
        
        
        inverse
        
        compute the inverse of a matrix
        
        matrix = inverse(matrix)
        
        
        orthoInverse
        
        compute the inverse of a 4x4 matrix, which is expected to be an affine matrix with an orthogonal upper-left 3x3 submatrix
        
        this can be used to achieve better performance than a general inverse when the specified 4x4 matrix meets the given restrictions
        
        matrix = orthoInverse(matrix)
        
        
        determinant
        
        determinant of a matrix
        
        scalar = determinant(matrix)
        
        
        appendScale
        
        append (post-multiply) a scale transformation to a matrix
        
        faster than creating and multiplying a scale transformation matrix
        
        matrix = appendScale(matrix, vector)
        
        
        prependScale
        
        prepend (pre-multiply) a scale transformation to a 4x4 matrix
        
        faster than creating and multiplying a scale transformation matrix
        
        matrix = prependScale(matrix, vector)
        
        
        lookAt
        
        construct viewing matrix based on eye position, position looked at, and up direction
        
        matrix4 = lookAt(eyeVector, lookatVector, upVector)
        
        
        perspective
        
        construct a perspective projection matrix
        
        matrix4 = perspective(fovyRadians, aspect, zNear, zFar)
        
        
        frustum
        
        construct a perspective projection matrix based on frustum
        
        matrix4 = frustum(left, right, bottom, top, zNear, zFar)  (all scalar value)
        
        
        orthographic
        
        construct an orthographic projection matrix
        
        matrix4 = orthographic(left, right, bottom, top, zNear, zFar)  (all scalar value)
        
        
Platform: UNKNOWN
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Operating System :: MacOS :: MacOS X
Classifier: Operating System :: POSIX :: Linux
Classifier: Operating System :: Microsoft :: Windows
Classifier: Topic :: Games/Entertainment
