orientedshape3dretained.java

JAVA3D矩陈的相关类

		    newList[i] = orientedTransforms[i];
		}
		newList[viewIndex] = xform;
		orientedTransforms = newList; 
	    }
	    else {
		if (orientedTransforms[viewIndex] == null) {
		    orientedTransforms[viewIndex] = new Transform3D();
		}
	    }
	}
	return orientedTransforms[viewIndex];
    }

    // called on the parent object
    // Should be synchronized so that the user thread does not modify the
    // OrientedShape3D params while computing the transform
    synchronized void updateOrientedTransform(Canvas3D canvas, int viewIndex) {
        double angle = 0.0;
        double sign;
	boolean status;
	
	Transform3D orientedxform = getOrientedTransform(viewIndex);
	//  get viewplatforms's location in virutal world
        if (mode == OrientedShape3D.ROTATE_ABOUT_AXIS) {   // rotate about axis
	    canvas.getCenterEyeInImagePlate(viewPosition);
	    canvas.getImagePlateToVworld(xform); // xform is imagePlateToLocal
	    xform.transform(viewPosition);

	    // get billboard's transform
	    xform.set(getCurrentLocalToVworld());
	    xform.invert(); // xform is now vWorldToLocal

	    // transform the eye position into the billboard's coordinate system
	    xform.transform(viewPosition);


	    // eyeVec is a vector from the local origin to the eye pt in local
	    eyeVec.set(viewPosition);
	    eyeVec.normalize();

	    // project the eye into the rotation plane
	    status = projectToPlane(eyeVec, nAxis);

	    if (status) {
		// project the z axis into the rotation plane
		zAxis.x = 0.0;
		zAxis.y = 0.0;
		zAxis.z = 1.0;
		status = projectToPlane(zAxis, nAxis);
	    }
	    if (status) {

		// compute the sign of the angle by checking if the cross product 
		// of the two vectors is in the same direction as the normal axis
		vector.cross(eyeVec, zAxis); 
		if (vector.dot(nAxis) > 0.0) {
		    sign = 1.0;
		} else { 
		    sign = -1.0;
		}
		
		// compute the angle between the projected eye vector and the 
		// projected z

		double dot = eyeVec.dot(zAxis);
		if (dot > 1.0f) {
		    dot = 1.0f;
		} else if (dot < -1.0f) {
		    dot = -1.0f;
		}

		angle = sign*Math.acos(dot);
		
		// use -angle because xform is to *undo* rotation by angle
		aa.x = nAxis.x; 
		aa.y = nAxis.y; 
		aa.z = nAxis.z;
		aa.angle = -angle;
		orientedxform.set(aa);
	    }
	    else {
		orientedxform.setIdentity();
	    }

        } else { // rotate about point
	    // Need to rotate Z axis to point to eye, and Y axis to be 
	    // parallel to view platform Y axis, rotating around rotation pt 

	    // get the eye point 
	    canvas.getCenterEyeInImagePlate(viewPosition);

	    // derive the yUp point
	    yUpPoint.set(viewPosition);
	    yUpPoint.y += 0.01; // one cm in Physical space

	    // transform the points to the Billboard's space
	    canvas.getImagePlateToVworld(xform); // xform is ImagePlateToVworld
	    xform.transform(viewPosition);
	    xform.transform(yUpPoint);

	    // get billboard's transform
	    xform.set(getCurrentLocalToVworld());
	    xform.invert(); // xform is vWorldToLocal

	    // transfom points to local coord sys
	    xform.transform(viewPosition);
	    xform.transform(yUpPoint);

	    // Make a vector from viewPostion to 0,0,0 in the BB coord sys
	    eyeVec.set(viewPosition);
	    eyeVec.normalize();

	    // create a yUp vector
	    yUp.set(yUpPoint);
	    yUp.sub(viewPosition);
	    yUp.normalize();


	    // find the plane to rotate z
	    zAxis.x = 0.0;
	    zAxis.y = 0.0;
	    zAxis.z = 1.0;

	    // rotation axis is cross product of eyeVec and zAxis
	    vector.cross(eyeVec, zAxis); // vector is cross product

	    // if cross product is non-zero, vector is rotation axis and 
	    // rotation angle is acos(eyeVec.dot(zAxis)));
	    double length = vector.length();
	    if (length > 0.0001) {
		double dot = eyeVec.dot(zAxis);
		if (dot > 1.0f) {
		    dot = 1.0f;
		} else if (dot < -1.0f) {
		    dot = -1.0f;
		}
		angle = Math.acos(dot);
		aa.x = vector.x;
		aa.y = vector.y;
		aa.z = vector.z;
		aa.angle = -angle;
		zRotate.set(aa);
	    } else {
		// no rotation needed, set to identity (scale = 1.0)
		zRotate.set(1.0);
	    }

	    // Transform the yAxis by zRotate
	    yAxis.x = 0.0;
	    yAxis.y = 1.0;
	    yAxis.z = 0.0;
	    zRotate.transform(yAxis);

	    // project the yAxis onto the plane perp to the eyeVec 
	    status = projectToPlane(yAxis, eyeVec);


	    if (status) {
		// project the yUp onto the plane perp to the eyeVec 
		status = projectToPlane(yUp, eyeVec);
	    }

	    if (status) {
		// rotation angle is acos(yUp.dot(yAxis));
		double dot = yUp.dot(yAxis);

		// Fix numerical error, otherwise acos return NULL
		if (dot > 1.0f) {
		    dot = 1.0f;
		} else if (dot < -1.0f) {
		    dot = -1.0f;
		}

		angle = Math.acos(dot);

		// check the sign by looking a the cross product vs the eyeVec 
		vector.cross(yUp, yAxis);  // vector is cross product
		if (eyeVec.dot(vector) < 0) {
		    angle *= -1;
		} 
		aa.x = eyeVec.x;
		aa.y = eyeVec.y;
		aa.z = eyeVec.z;
		aa.angle = -angle;
		xform.set(aa); // xform is now yRotate

		// rotate around the rotation point
		vector.x = rotationPoint.x;
		vector.y = rotationPoint.y;
		vector.z = rotationPoint.z;     // vector to translate to RP
		orientedxform.set(vector);  // translate to RP
		orientedxform.mul(xform);   // yRotate
		orientedxform.mul(zRotate); // zRotate
		vector.scale(-1.0);   	    // vector to translate back
		xform.set(vector);    	    // xform to translate back 
		orientedxform.mul(xform);   // translate back
	    }
	    else {
		orientedxform.setIdentity();
	    }
		
	}
	//Scale invariant computation
	if(constantScale) {
	    // Back Xform a unit vector to local world coords
	    canvas.getInverseVworldProjection(left_xform, right_xform);

	    // the two endpts of the vector have to be transformed
	    // individually because the Xform is not affine
	    im_vec[0].set(0.0, 0.0, 0.0, 1.0);
	    im_vec[1].set(1.0, 0.0, 0.0, 1.0);
	    left_xform.transform(im_vec[0]);
	    left_xform.transform(im_vec[1]);

	    left_xform.set(getCurrentLocalToVworld());
	    left_xform.invert();
	    left_xform.transform(im_vec[0]);
	    left_xform.transform(im_vec[1]);
	    lvec.set(im_vec[1]);
	    lvec.sub(im_vec[0]);

	    // We simply need the direction of this vector
	    lvec.normalize();
	    im_vec[0].set(0.0, 0.0, 0.0, 1.0);
	    im_vec[1].set(lvec);
	    im_vec[1].w = 1.0;

	    // Forward Xfrom to clip coords
	    left_xform.set(getCurrentLocalToVworld());
	    left_xform.transform(im_vec[0]);
	    left_xform.transform(im_vec[1]);

	    canvas.getVworldProjection(left_xform, right_xform);
	    left_xform.transform(im_vec[0]);
	    left_xform.transform(im_vec[1]);

	    // Perspective division
	    im_vec[0].x /= im_vec[0].w;
	    im_vec[0].y /= im_vec[0].w;
	    im_vec[0].z /= im_vec[0].w;

	    im_vec[1].x /= im_vec[1].w;
	    im_vec[1].y /= im_vec[1].w;
	    im_vec[1].z /= im_vec[1].w;

	    lvec.set(im_vec[1]);
	    lvec.sub(im_vec[0]);

	    // Use the length of this vector to determine the scaling
	    // factor
	    double scale = 1/lvec.length();

	    // Convert to meters
	    scale *= scaleFactor*canvas.getPhysicalWidth()/2;

	    // Scale object so that it appears the same size
	    scaleXform.setScale(scale);
	    orientedxform.mul(scaleXform);
	}

    }


    private boolean projectToPlane(Vector3d projVec, Vector3d planeVec)  {
        double dis = planeVec.dot(projVec);
        projVec.x = projVec.x - planeVec.x*dis;
        projVec.y = projVec.y - planeVec.y*dis;
        projVec.z = projVec.z - planeVec.z*dis;

        double length = projVec.length();
        if (length < EPSILON) { // projVec is parallel to planeVec
	    return false;
        }
        projVec.scale(1 / length);
	return true;
    }

    void compile(CompileState compState) {

	super.compile(compState);

        mergeFlag = SceneGraphObjectRetained.DONT_MERGE;

	// don't push the static transform to orientedShape3D
        // because orientedShape3D is rendered using vertex array;
	// it's not worth pushing the transform here

        compState.keepTG = true;
    }

    void searchGeometryAtoms(UnorderList list) {
	list.add(getGeomAtom(getMirrorShape(key)));
    }
}