Java Vector3.normalize方法代码示例

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
private void attackDestroyer(double x, double y, double z) {
    // Make target vector
    Random rand = new Random();
    Vector3 targetVec = new Vector3(mDestroyer.object.getX()+rand.nextInt(20),
            mDestroyer.object.getY()+rand.nextInt(20),
            mDestroyer.object.getZ()+rand.nextInt(20));
    targetVec.subtract(x, y, z);
    targetVec.normalize();
    targetVec.multiply(3);
    // clone object and add to scene
    Object3D missileObj = mMissileObj.clone();
    missileObj.setX(x+targetVec.x);
    missileObj.setY(y+targetVec.y);
    missileObj.setZ(z+targetVec.z);
    missileObj.setColor(FRIENDLY_MISSILE_COLOR);
    mRenderer.getCurrentScene().addChild(missileObj);
    //mMissileObj.addChild(missileObj);
    // make Missile instance and set location and target
    Missile missile = new Missile(x+targetVec.x, y+targetVec.y, z+targetVec.z,
            Missile.FROM_MOTHERSHIP, missileObj);
    targetVec.multiply(20);
    missile.setTarget(targetVec.x, targetVec.y, targetVec.z);
    synchronized (mMissiles) {
        mMissiles.add(missile);
    }
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
private void applyRotation()
{
    if (mIsRotating)
    {
        mapToSphere((float) mPrevScreenCoord.getX(), (float) mPrevScreenCoord.getY(), mPrevSphereCoord);
        mapToSphere((float) mCurrScreenCoord.getX(), (float) mCurrScreenCoord.getY(), mCurrSphereCoord);

        Vector3 rotationAxis = mPrevSphereCoord.clone();
        rotationAxis.cross(mCurrSphereCoord);
        rotationAxis.normalize();

        double rotationAngle = Math.acos(Math.min(1, mPrevSphereCoord.dot(mCurrSphereCoord)));
        mCurrentOrientation.fromAngleAxis(rotationAxis, MathUtil.radiansToDegrees(rotationAngle));
        mCurrentOrientation.normalize();

        Quaternion q = new Quaternion(mStartOrientation);
        q.multiply(mCurrentOrientation);

        mEmpty.setOrientation(q);
    }
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
public void fire() {
    if(mLastFireTime + MISSILE_INTERVAL > System.currentTimeMillis()) {
        return;
    }
    // clone object and add to scene
    Object3D missileObj = mMissileObj.clone();
    missileObj.setX(mCameraBox.getX());
    missileObj.setY(mCameraBox.getY());
    missileObj.setZ(mCameraBox.getZ());
    missileObj.setColor(FRIENDLY_MISSILE_COLOR);
    mRenderer.getCurrentScene().addChild(missileObj);
    //mMissileObj.addChild(missileObj);
    // make Missile instance and set location and target
    Missile missile = new Missile(mCameraBox.getX(), mCameraBox.getY(), mCameraBox.getZ(),
            Missile.FROM_FRIENDLY, missileObj);
    Vector3 targetVec = new Vector3(mHeadViewForward);
    targetVec.normalize();
    targetVec.multiply(30);
    missile.setTarget(mCameraBox.getX() + targetVec.x,
            mCameraBox.getY() + targetVec.y,
            mCameraBox.getZ() + targetVec.z);
    synchronized (mMissiles) {
        mMissiles.add(missile);
    }
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
private Matrix4 createLightViewProjectionMatrix(DirectionalLight light) {
	//
	// -- Get the frustum corners in world space
	//
	mCamera.getFrustumCorners(mFrustumCorners, true);
	//
	// -- Get the frustum centroid
	//
	mFrustumCentroid.setAll(0, 0, 0);
	for(int i=0; i<8; i++)
		mFrustumCentroid.add(mFrustumCorners[i]);
	mFrustumCentroid.divide(8.0);
	
	//
	// -- 
	//
	
	BoundingBox lightBox = new BoundingBox(mFrustumCorners);
	double distance = mFrustumCentroid.distanceTo(lightBox.getMin());
	Vector3 lightDirection = light.getDirectionVector().clone();
	lightDirection.normalize();
	Vector3 lightPosition = Vector3.subtractAndCreate(mFrustumCentroid, Vector3.multiplyAndCreate(lightDirection, distance));
          
	//
	// -- 
	//
	
	mLightViewMatrix.setToLookAt(lightPosition, mFrustumCentroid, Vector3.Y);
	
	for(int i=0; i<8; i++)
		mFrustumCorners[i].multiply(mLightViewMatrix);
          
          BoundingBox b = new BoundingBox(mFrustumCorners);
          mLightProjectionMatrix.setToOrthographic(b.getMin().x, b.getMax().x, b.getMin().y, b.getMax().y, -b.getMax().z, -b.getMin().z);

          mLightModelViewProjectionMatrix.setAll(mLightProjectionMatrix);
          mLightModelViewProjectionMatrix.multiply(mLightViewMatrix);
	return mLightModelViewProjectionMatrix;
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
/**
 * Sets this {@link Quaternion}'s components from the given axis vector and angle around the axis.
 * 
 * @param axis {@link Vector3} The axis to set rotation on.
 * @param angle double The rotation angle in degrees.
 * @return A reference to this {@link Quaternion} to facilitate chaining.
 */
public Quaternion fromAngleAxis(final Vector3 axis, final double angle) {
	if (!axis.isUnit()) axis.normalize();
	double radian = Math.toRadians(angle); //MathUtil.degreesToRadians(angle);
	double halfAngle = radian * .5;
	double halfAngleSin = Math.sin(halfAngle);
	w = Math.cos(halfAngle);
	x = halfAngleSin * axis.x;
	y = halfAngleSin * axis.y;
	z = halfAngleSin * axis.z;
	return this;
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
protected Quaternion quaternionFromVector(Vector3 vec) {
	vec.normalize();
	final double angle = MathUtil.radiansToDegrees(Math.acos(Vector3.dot(mForwardVec, vec)));
	final Quaternion q = new Quaternion();
	q.fromAngleAxis(mTmpQuatVector.crossAndSet(mForwardVec, vec), angle);
	return q;
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
private Vector3 calculateFaceNormal(int[] vertexIDs) {
	ArrayList<Vector3> vertices = mVertices.get(mObjects);
	Vector3 v1 = vertices.get(vertexIDs[0]);
	Vector3 v2 = vertices.get(vertexIDs[2]);
	Vector3 v3 = vertices.get(vertexIDs[1]);

	Vector3 vector1 = Vector3.subtractAndCreate(v2, v1);
	Vector3 vector2 = Vector3.subtractAndCreate(v3, v1);

	Vector3 normal = Vector3.crossAndCreate(vector1, vector2);
	normal.normalize();
	return normal;
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
private void mapToSphere(final float x, final float y, Vector3 out)
{
    float lengthSquared = x * x + y * y;
    if (lengthSquared > 1)
    {
        out.setAll(x, y, 0);
        out.normalize();
    }
    else
    {
        out.setAll(x, y, Math.sqrt(1 - lengthSquared));
    }
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
/**
 * Intersects a ray defined by a start and end point and a triangle.
 * @param rayStart Startpoint of the ray
 * @param rayEnd Endpoint of the ray
 * @param t1 The first vertex of the triangle
 * @param t2 The second vertex of the triangle
 * @param t3 The third vertex of the triangle
 * @param hitPoint The intersection point (optional)
 * @return True if there is an intersection, false otherwise.
 */
public static boolean intersectRayTriangle(Vector3 rayStart, Vector3 rayEnd, Vector3 t1, Vector3 t2, Vector3 t3, Vector3 hitPoint) {
	Vector3 rayDir = Vector3.subtractAndCreate(rayEnd, rayStart);
	rayDir.normalize();
	p.set(t1, t2, t3);
	if (!intersectRayPlane(rayStart, rayEnd, p, i)) return false;
	
	v0.subtractAndSet(t3, t1);
	v1.subtractAndSet(t2, t1);
	v2.subtractAndSet(i, t1);
	
	double dot00 = v0.dot(v0);
	double dot01 = v0.dot(v1);
	double dot02 = v0.dot(v2);
	double dot11 = v1.dot(v1);
	double dot12 = v1.dot(v2);
	
	double denom = dot00 * dot11 - dot01 * dot01;
	if (denom == 0) return false;
	
	double u = (dot11 * dot02 - dot01 * dot12) / denom;
	double v = (dot00 * dot12 - dot01 * dot02) / denom;
	
	if (u >= 0 && v >= 0 && u + v <= 1) {
		if (hitPoint != null) hitPoint.setAll(i);
		return true;
	} else
		return false;
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
/**
 * Calculates a transformation matrix based on a point, a normal and the up gravity vector.
 * The coordinate frame of the target transformation will be Z forward, X left, Y up.
 */
public static Matrix4 matrixFromPointNormalUp(double[] point, double[] normal, Vector3 up) {
    Vector3 zAxis = new Vector3(normal);
    zAxis.normalize();
    Vector3 xAxis = new Vector3();
    xAxis.crossAndSet(up, zAxis);
    xAxis.normalize();
    Vector3 yAxis = new Vector3();
    yAxis.crossAndSet(xAxis, zAxis);
    yAxis.normalize();

    double[] rot = new double[16];

    rot[Matrix4.M00] = xAxis.x;
    rot[Matrix4.M10] = xAxis.y;
    rot[Matrix4.M20] = xAxis.z;

    rot[Matrix4.M01] = yAxis.x;
    rot[Matrix4.M11] = yAxis.y;
    rot[Matrix4.M21] = yAxis.z;

    rot[Matrix4.M02] = zAxis.x;
    rot[Matrix4.M12] = zAxis.y;
    rot[Matrix4.M22] = zAxis.z;

    rot[Matrix4.M33] = 1;

    Matrix4 m = new Matrix4(rot);
    m.setTranslation(point[0], point[1], point[2]);

    return m;
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
private Matrix4 createLightViewProjectionMatrix(DirectionalLight light) {
	//
	// -- Get the frustum corners in world space
	//
	mCamera.getFrustumCorners(mFrustumCorners, true);
	//
	// -- Get the frustum centroid
	//
	mFrustumCentroid.setAll(0, 0, 0);
	for(int i=0; i<8; i++)
		mFrustumCentroid.add(mFrustumCorners[i]);
	mFrustumCentroid.divide(8.0);

	//
	// --
	//

	BoundingBox lightBox = new BoundingBox(mFrustumCorners);
	double distance = mFrustumCentroid.distanceTo(lightBox.getMin());
	Vector3 lightDirection = light.getDirectionVector().clone();
	lightDirection.normalize();
	Vector3 lightPosition = Vector3.subtractAndCreate(mFrustumCentroid, Vector3.multiplyAndCreate(lightDirection, distance));

	//
	// --
	//

	mLightViewMatrix.setToLookAt(lightPosition, mFrustumCentroid, Vector3.Y);

	for(int i=0; i<8; i++)
		mFrustumCorners[i].multiply(mLightViewMatrix);

          BoundingBox b = new BoundingBox(mFrustumCorners);
          mLightProjectionMatrix.setToOrthographic(b.getMin().x, b.getMax().x, b.getMin().y, b.getMax().y, -b.getMax().z, -b.getMin().z);

          mLightModelViewProjectionMatrix.setAll(mLightProjectionMatrix);
          mLightModelViewProjectionMatrix.multiply(mLightViewMatrix);
	return mLightModelViewProjectionMatrix;
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
/**
 * Sets this {@link Quaternion}'s components from the given axis vector and angle around the axis.
 *
 * @param axis {@link Vector3} The axis to set rotation on.
 * @param angle double The rotation angle in degrees.
 * @return A reference to this {@link Quaternion} to facilitate chaining.
 */
public Quaternion fromAngleAxis(final Vector3 axis, final double angle) {
	if (!axis.isUnit()) axis.normalize();
	double radian = Math.toRadians(angle); //MathUtil.degreesToRadians(angle);
	double halfAngle = radian * .5;
	double halfAngleSin = Math.sin(halfAngle);
	w = Math.cos(halfAngle);
	x = halfAngleSin * axis.x;
	y = halfAngleSin * axis.y;
	z = halfAngleSin * axis.z;
	return this;
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
private void attackMothership(double x, double y, double z, int from) {
    // Make target vector
    Vector3 targetVec = new Vector3(mMothershipObj.getX(), mMothershipObj.getY(), mMothershipObj.getZ());
    double distance = targetVec.distanceTo(x, y, z);
    targetVec.subtract(x, y, z);
    targetVec.normalize();
    if(distance > 50) {
        targetVec.multiply(30);
    } else {
        targetVec.multiply(3);
    }

    // clone object and add to scene
    Object3D missileObj = mMissileObj.clone();
    missileObj.setX(x+targetVec.x);
    missileObj.setY(y+targetVec.y);
    missileObj.setZ(z+targetVec.z);
    missileObj.setColor(ENEMY_MISSILE_COLOR);
    mRenderer.getCurrentScene().addChild(missileObj);
    //mMissileObj.addChild(missileObj);
    // make Missile instance and set location and target
    Missile missile = new Missile(x+targetVec.x, y+targetVec.y, z+targetVec.z,
            from, missileObj);
    targetVec.multiply((distance+10)/3);
    missile.setTarget(mMothershipObj.getX(), mMothershipObj.getY(), mMothershipObj.getZ());
    if(distance > 50) {
        missile.setSpeed(0.75);
    }
    synchronized (mMissiles) {
        mMissiles.add(missile);
    }
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
public float[] calculateNormals(int[] indices) {
	float[] vertices = new float[mGeometry.getVertices().capacity()];
	mGeometry.getVertices().get(vertices).position(0);
	float[] faceNormals = new float[indices.length];
	float[] vertNormals = new float[vertices.length];

	int numIndices = indices.length;
	int numVertices = vertices.length;
	int id1, id2, id3, vid1, vid2, vid3;
	Vector3 v1 = new Vector3();
	Vector3 v2 = new Vector3();
	Vector3 v3 = new Vector3();
	Vector3 normal = new Vector3();
	
	// -- calculate face normals
	for(int i=0; i<numIndices; i+=3) {
		id1 = indices[i];
		id2 = indices[i+1];
		id3 = indices[i+2];
		
		vid1 = id1 * 3;
		vid2 = id2 * 3;
		vid3 = id3 * 3;
		
		v1.setAll(vertices[vid1], vertices[vid1+1], vertices[vid1+2]);
		v2.setAll(vertices[vid2], vertices[vid2+1], vertices[vid2+2]);
		v3.setAll(vertices[vid3], vertices[vid3+1], vertices[vid3+2]);
		
		Vector3 vector1 = Vector3.subtractAndCreate(v2, v1);
           Vector3 vector2 = Vector3.subtractAndCreate(v3, v1);
           
           normal = Vector3.crossAndCreate(vector1, vector2);
           normal.normalize();
           
           faceNormals[i] = (float) normal.x;
           faceNormals[i+1] = (float) normal.y;
           faceNormals[i+2] = (float) normal.z;

	}
	// -- calculate vertex normals
	
	Vector3 vertexNormal = new Vector3();
	
	for(int i=0; i<numVertices; i+=3) {
		int vIndex = i / 3;
		
		vertexNormal.setAll(0, 0, 0);			
		
		for(int j=0; j<numIndices; j+=3)
		{
			id1 = indices[j];
			id2 = indices[j+1];
			id3 = indices[j+2];
			
			if(id1 == vIndex || id2 == vIndex || id3 == vIndex) {
				vertexNormal.add(faceNormals[j], faceNormals[j+1], faceNormals[j+2]);
			}
		}
		vertexNormal.normalize();
		vertNormals[i] = (float) vertexNormal.x;
		vertNormals[i+1] = (float) vertexNormal.y;
		vertNormals[i+2] = (float) vertexNormal.z;
	}
	//mGeometry.setNormals(vertNormals);
	faceNormals = null;
	v1 = null;
	v2 = null;
	v3 = null;
	return vertNormals;
}
 

import org.rajawali3d.math.vector.Vector3; //导入方法依赖的package包/类
protected void readFaces(InputStream buffer) throws IOException {
	int triangles = readShort(buffer);
	Vector3[] normals = new Vector3[triangles];
	ArrayList<Integer> indices = new ArrayList<Integer>();

	for (int i = 0; i < triangles; i++) {
		int[] vertexIDs = new int[3];
		vertexIDs[0] = readShort(buffer);
		vertexIDs[1] = readShort(buffer);
		vertexIDs[2] = readShort(buffer);
		readShort(buffer);

		indices.add(vertexIDs[0]);
		indices.add(vertexIDs[1]);
		indices.add(vertexIDs[2]);

		Vector3 normal = calculateFaceNormal(vertexIDs);
		normals[i] = normal;
	}

	mNormals.add(new Vector3[triangles]);
	mIndices.add(indices);

	int numVertices = mVertices.get(mObjects).size();
	int numIndices = indices.size();

	ArrayList<Vector3> vertNormals = new ArrayList<Vector3>();

	for (int i = 0; i < numVertices; i++) {

		Vector3 vertexNormal = new Vector3();

		for (int j = 0; j < numIndices; j += 3) {
			int id1 = indices.get(j);
			int id2 = indices.get(j + 1);
			int id3 = indices.get(j + 2);

			if (id1 == i || id2 == i || id3 == i) {
				vertexNormal.add(normals[j / 3]);
			}
		}
		vertexNormal.normalize();
		vertNormals.add(vertexNormal);
	}

	mVertNormals.add(vertNormals);
}