Java Quaternionf类代码示例

import org.joml.Quaternionf; //导入依赖的package包/类
/**
 * Creates a new cone at the specified position
 * using the specified rotation and scale.
 * 
 * @param position - Position of the cone.
 * @param rotation - Rotation of the cone.
 * @param scale - Scale of the cone.
 */
public Cone(Vector3f position, Quaternionf rotation, float scale) {
	super();

	height = 1;
	radius = 1;
	sides = 10;
	
	generateVertices();
	generateNormals();
	generateTextureCoordinates();
	
	Mesh mesh = new Mesh(cone_positions, cone_texture_coordinates, cone_normals, cone_indices);
	Material mat = new Material();
	
	mesh.setMaterial(mat);
	setMesh(mesh);
	
	setPosition(position.x, position.y, position.z);
	setRotation(rotation);
	setScale(scale);
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
/**
 * Creates a new sphere at the specified position
 * using the specified rotation and scale. Then 
 * subdivides the sphere with the specified amount of iterations.
 * 
 * @param position - Position of the sphere.
 * @param rotation - Rotation of the sphere.
 * @param scale - Scale of the sphere.
 * @param iterations - Number of subdivisions.
 */
public Sphere(Vector3f position, Quaternionf rotation, float scale, int iterations) {
	super();
	
	generateVertices();
	subdivide(iterations);
	generateNormals();
	generateTextureCoordinates();
	
	Mesh mesh = new Mesh(sphere_positions, sphere_texture_coordinates, sphere_normals, sphere_indices);
	Material mat = new Material();
	
	mesh.setMaterial(mat);
	setMesh(mesh);
	
	setPosition(position.x, position.y, position.z);
       setRotation(rotation);
       setScale(scale);
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
/**
 * Creates a new cylinder at the specified position
 * using the specified rotation and scale.
 * 
 * @param position - Position of the cylinder.
 * @param rotation - Rotation of the cylinder.
 * @param scale - Scale of the cylinder.
 */
public Cylinder(Vector3f position, Quaternionf rotation, float scale) {
	super();
	
	height = 1;
	radius = 1;
	sides = 10;
	
	generateVertices();
	generateNormals();
	generateTextureCoordinates();
	
	Mesh mesh = new Mesh(cylinder_positions, cylinder_texture_coordinates, cylinder_normals, cylinder_indices);
	Material mat = new Material();
	
	mesh.setMaterial(mat);
	setMesh(mesh);
	
	setPosition(position.x, position.y, position.z);
	setRotation(rotation);
	setScale(scale);
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
/**
 * Creates a new cube at the specified position
 * using the specified rotation, scale and color.
 *
 * @param position - Position of the cube.
 * @param rotation - Rotation of the cube.
 * @param scale - Scale of the cube.
 * @param color - Color of the cube.
 */
public Cube(Vector3f position, Quaternionf rotation, float scale, Color color) {
    super();

    Mesh mesh = new Mesh(CUBE_POSITIONS, CUBE_TEXTURE_COORDINATES, CUBE_NORMALS, CUBE_INDICES);
    Material mat = new Material();

    mat.setAmbientColor(color.toVector4f());
    mat.setDiffuseColor(color.toVector4f());
    mat.setSpecularColor(color.toVector4f());

    mesh.setMaterial(mat);
    setMesh(mesh);

    setPosition(position.x, position.y, position.z);
    setRotation(rotation);
    setScale(scale);
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
/**
 * 
 * @param pitch
 * @param yaw
 * @param roll
 * @return
 */
public static Quaternionf toQuat(float pitch, float yaw, float roll) {
	Quaternionf quat = new Quaternionf();
	
	float t0 = (float) Math.cos(yaw * 0.5f);
	float t1 = (float) Math.sin(yaw * 0.5f);
	float t2 = (float) Math.cos(roll * 0.5f);
	float t3 = (float) Math.sin(roll * 0.5f);
	float t4 = (float) Math.cos(pitch * 0.5f);
	float t5 = (float) Math.sin(pitch * 0.5f);
	
	quat.w = t0 * t2 * t4 + t1 * t3 * t5;
	quat.x = t0 * t3 * t4 - t1 * t2 * t5;
	quat.y = t0 * t2 * t5 + t1 * t3 * t4;
	quat.z = t1 * t2 * t4 - t0 * t3 * t5;
	
	return quat;
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
private void move(int delta) {
    movementVector.zero();

    if (input.isForwardPressed()) {
        movementVector.add(-1, 0, 0);
    }
    if (input.isBackwardsPressed())
        movementVector.add(1, 0, 0);
    if (input.isLeftPressed())
        movementVector.add(0, 0, 1);
    if (input.isRightPressed())
        movementVector.add(0, 0, -1);
    Quaternionf rotation = Transforms.getAbsoluteRotation(getOwner(), new Quaternionf());
    if (movementVector.lengthSquared() >= 1.0f) {
        movementVector.normalize();
        movementVector.rotate(rotation);
        movementVector.mul(MOV_SPEED * delta);
        physicsProperty.applyCentralForce(movementVector);
    }
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
private void move(int delta) {
        if (input.isKeyDown(VK_SHIFT))
            cameraSpeed = CAMERA_SPEED * 3;
        else cameraSpeed = CAMERA_SPEED;

        movementVector.zero();
        if (input.isKeyDown(VK_W)) {
            movementVector.add(0, 0, -1);
//            getOwner().triggerEvent(new Envelope(new InputEvent(VK_W)));
        }
        if (input.isKeyDown(VK_S))
            movementVector.add(0, 0, 1);
        if (input.isKeyDown(VK_A))
            movementVector.add(-1, 0, 0);
        if (input.isKeyDown(VK_D))
            movementVector.add(1, 0, 0);
        Quaternionf rotation = Transforms.getAbsoluteRotation(getOwner(), new Quaternionf());
        if (movementVector.lengthSquared() >= 1.0f) {
            movementVector.normalize();
            movementVector.rotate(rotation);
            movementVector.mul(cameraSpeed * delta);
            transformProperty.move(movementVector);
        }
    }
 

import org.joml.Quaternionf; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param worldSpace True if the target position and rotation are in world space, false if they are local.
 * @param targetPosition Target position to smooth to.
 * @param targetRotation Target rotation to smooth to.
 * @param positionDamping Amount of positional damping while smoothing.
 * @param rotationDamping Amount of rotational damping while smoothing.
 */
public SmoothToComponent(boolean worldSpace, Vector3f targetPosition, Quaternionf targetRotation, float positionDamping, float rotationDamping) {
    // Set the world space mode
    this.worldSpace = worldSpace;

    // Copy the target position and rotation if set
    if(targetPosition != null)
        this.targetPosition.set(targetPosition);
    if(targetRotation != null)
        this.targetRotation.set(targetRotation);

    // Set whether to use the target position and rotation
    this.useTargetPosition = targetPosition != null;
    this.useTargetRotation = targetRotation != null;

    // Set the positional and rotational damping
    this.positionDamping = positionDamping;
    this.rotationDamping = rotationDamping;
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
public CameraInternal(Rect viewport, float fieldOfView, float zNear, float zFar, int depth)
{
	Events.onWindowResize.addListener(windowResizeEvent = () -> updateProjection());
	
	// TODO; Change skybox to default skybox
	Skybox.setTexture(Assets2.load(Cubemap.class, "skybox/skybox.jpg"));
	
	this.clearFlags = CameraClearFlags.SolidColor;
	this.clearColor = Color.BLACK;
	
	this.position = new Vector3f();
	this.rotation = new Quaternionf();
	
	this.viewport = viewport;
	this.fieldOfView = fieldOfView;
	this.zNear = zNear;
	this.zFar = zFar;
	this.depth = depth;
	
	updateProjection();
	
	main = main == null ? this : main;
	cameras.add(this);
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
private static void buildTransFormationMatrices(AINodeAnim aiNodeAnim, Node node) {
    int numFrames = aiNodeAnim.mNumPositionKeys();
    AIVectorKey.Buffer positionKeys = aiNodeAnim.mPositionKeys();
    AIVectorKey.Buffer scalingKeys = aiNodeAnim.mScalingKeys();
    AIQuatKey.Buffer rotationKeys = aiNodeAnim.mRotationKeys();

    for (int i = 0; i < numFrames; i++) {
        AIVectorKey aiVecKey = positionKeys.get(i);
        AIVector3D vec = aiVecKey.mValue();

        Matrix4f transfMat = new Matrix4f().translate(vec.x(), vec.y(), vec.z());

        AIQuatKey quatKey = rotationKeys.get(i);
        AIQuaternion aiQuat = quatKey.mValue();
        Quaternionf quat = new Quaternionf(aiQuat.x(), aiQuat.y(), aiQuat.z(), aiQuat.w());
        transfMat.rotate(quat);

        if (i < aiNodeAnim.mNumScalingKeys()) {
            aiVecKey = scalingKeys.get(i);
            vec = aiVecKey.mValue();
            transfMat.scale(vec.x(), vec.y(), vec.z());
        }

        node.addTransformation(transfMat);
    }
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
/**
 * Default constructor for the Entity class.
 * Sets the mesh to null, position and rotation to vectors of 0s
 * and scale to 1.
 */
protected  Entity() {
	selected = false;
	
    position = new Vector3f(0, 0, 0);
    rotation =  new Quaternionf();
    
    scale = 1;
    
    texturePosition = 0;
    insideFrustrumCulling = true;
    disableFrustrumCulling = false;
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
public Matrix4f buildModelMatrix(Entity entity) {
	Quaternionf rotation = entity.getRotation();
	Vector3f position = entity.getPosition();
	
	return modelMatrix.translationRotateScale(position.x, position.y, position.z, 
			rotation.x, rotation.y, rotation.z, rotation.w, 
			entity.getScale(), entity.getScale(), entity.getScale());
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
@Override
public Quaternionf getRotation(Quaternionf dst)
{
	this.parent.getRotation(dst);
	dst.mul(super.rotation);
	return dst;
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
@Override
public Quaternionf getRotation(Quaternionf dst)
{
	this.parent.getRotation(dst);
	dst.mul(super.quaternion());
	return dst;
}
 

import org.joml.Quaternionf; //导入依赖的package包/类
public static Quaternionf calculateQuaternion(float x, float y, float z) {
    Quaternionf orientation = new Quaternionf(x, y, z, 0);
    float temp = 1.0f - (orientation.x * orientation.x) - (orientation.y * orientation.y) -
            (orientation.z * orientation.z);
    if (temp < 0.0f) {
        orientation.w = 0.0f;
    } else {
        orientation.w = -(float) (Math.sqrt(temp));
    }
    return orientation;
}