pickresult.java

JAVA3D矩陈的相关类

	int numint = 0;
	int indexCount = geom.getIndexCount();
	for (int i=0; i<indexCount;) {
	    triVertIdx[0] = i;
	    triCoordIdx[0] = geom.getCoordinateIndex(i++);
	    triVertIdx[1] = i;
	    triCoordIdx[1] = geom.getCoordinateIndex(i++);
	    triVertIdx[2] = i;
	    triCoordIdx[2] = geom.getCoordinateIndex(i++);
	    if (intersectTri(triVertIdx, triCoordIdx, geomIndex, pnts, pi)) {
		numint++;
		if (firstpick) return true;
	    }
	} 

	if (numint > 0) return true;
	return false;
    }

    /** 
      Intersect method for TriangleStripArray 
      */
    boolean intersectTSA (TriangleStripArray geom, int geomIndex, 
			  Point3d[] pnts, boolean firstpick, PickIntersection pi) {
	if (debug) 
	    System.out.println ("intersect: TriangleStripArray");

	boolean ccw;
	int numint = 0;
	int[] stripVertexCounts = new int [geom.getNumStrips()];
	geom.getStripVertexCounts (stripVertexCounts);
	int stripStart = 0;
	int start;
	int[] triVertIdx = new int[3];

	for (int i=0; i<stripVertexCounts.length; i++) {  

	    start = stripStart;
	    // start a new strip
	    ccw = true;
	    triVertIdx[0] = start++;
	    triVertIdx[1] = start++;

	    int end = start + stripVertexCounts[i] - 2;
	    for (int j=start; j< end; j++) {	 
		/*
		if (ccw) {
		    triVertIdx[2] = j;   
		} else {
		    triVertIdx[1] = j;   
		}
		*/
		triVertIdx[2] = j;
		if (intersectTri(triVertIdx, triVertIdx, geomIndex, pnts, pi)) {
		    numint++;
		    if (firstpick) return true;
		}

		// Advance to the next triangle, keeping the winding of the test
		// triangle correct.  
		/*
		if (ccw) {
		    triVertIdx[0] = triVertIdx[1];
		    // triVertIdx[2] remains, triVertIdx[1] will be replaced
		    ccw = false;
		} else {
		    triVertIdx[0] = triVertIdx[2];
		    // triVertIdx[1] remains, triVertIdx[2] will be replaced
		    ccw = true;
		}
		*/
		triVertIdx[0] = triVertIdx[1];
		triVertIdx[1] = triVertIdx[2];

	    }
	    stripStart += stripVertexCounts[i];
	}

	if (numint > 0) return true;
	return false;
    }

    /** 
      Intersect method for IndexedTriangleStripArray 
      */
    boolean intersectITSA (IndexedTriangleStripArray geom, int geomIndex, 
			   Point3d[] pnts, boolean firstpick, PickIntersection pi) {

	if (debug) 
	    System.out.println ("intersect: IndexedTriangleStripArray");
	int numint = 0;
	boolean ccw;

	int[] stripVertexCounts = new int [geom.getNumStrips()];
	geom.getStripIndexCounts (stripVertexCounts);
	int stripStart = 0;
	int start;
	int[] triVertIdx = new int[3];
	int[] triCoordIdx = new int[3];
	
	for (int i=0; i<stripVertexCounts.length; i++) {  

	    start = stripStart;
	    // start a new strip
	    ccw = true;
	    triCoordIdx[0] = geom.getCoordinateIndex(start);
	    triVertIdx[0] = start++;
	    triCoordIdx[1] = geom.getCoordinateIndex(start);	    
	    triVertIdx[1] = start++;
	    
	    int end = start + stripVertexCounts[i] - 2;
	    for (int j=start; j<end; j++) {	 
		if (ccw) {
		    triVertIdx[2] = j;   
		    triCoordIdx[2] = geom.getCoordinateIndex(j);
		} else {
		    triVertIdx[1] = j;   
		    triCoordIdx[1] = geom.getCoordinateIndex(j);
		}
		
		if (intersectTri(triVertIdx, triCoordIdx, geomIndex, pnts, pi)) {
		    numint++;
		    if (firstpick) return true;
		}

		// Advance to the next triangle, keeping the winding of the test
		// triangle correct.  
		if (ccw) {
		    triVertIdx[0] = triVertIdx[1];
		    // triVertIdx[2] remains, triVertIdx[1] will be replaced
		    triCoordIdx[0] = triCoordIdx[1];
		    ccw = false; 
		} else { 
		    triVertIdx[0] = triVertIdx[2];
		    // triVertIdx[1] remains, triVertIdx[2] will be replaced
		    triCoordIdx[0] = triCoordIdx[2];
		    ccw = true;
		}
	    }
	    stripStart += stripVertexCounts[i];
	}

	if (numint > 0) return true;
	return false;

    }

    /** 
      Intersect method for TriangleFanArray 
      */
    boolean intersectTFA (TriangleFanArray geom, int geomIndex, Point3d[] pnts,
			  boolean firstpick, PickIntersection pi) {

	if (debug) System.out.println("intersect: TriangleFanArray");

	int numint = 0;

	int[] stripVertexCounts = new int [geom.getNumStrips()];
	geom.getStripVertexCounts (stripVertexCounts);
	int fanStart = 0;
	int start;
	int[] triVertIdx = new int[3];
	
	// System.out.println("stripVertexCounts.length " + stripVertexCounts.length);
	for (int i=0; i<stripVertexCounts.length; i++) {

	    start = fanStart;
	    triVertIdx[0] = start++;
	    triVertIdx[1] = start++;
	    
	    int end = start + stripVertexCounts[i] - 2;
	    for (int j=start; j<end; j++) {	 
		triVertIdx[2] = j;
		if (intersectTri(triVertIdx, triVertIdx, geomIndex, pnts, pi)) {
		    numint++;
		    if (firstpick) return true;
		}
		triVertIdx[1] = triVertIdx[2];
	    }    
	    fanStart += stripVertexCounts[i];
	}
	if (numint > 0) return true;
	return false;
    }

    /** 
      Intersect method for IndexedTriangleFanArray 
      */
    boolean intersectITFA (IndexedTriangleFanArray geom, int geomIndex, 
			   Point3d[] pnts, boolean firstpick, PickIntersection pi) {

	if (debug) System.out.println ("intersect: IndexedTriangleFanArray");

	int numint = 0;
	int[] stripVertexCounts = new int [geom.getNumStrips()];
	geom.getStripIndexCounts (stripVertexCounts);
	int fanStart = 0;
	int start;
	int[] triVertIdx = new int[3];
	int[] triCoordIdx = new int[3];
	
	for (int i=0; i<stripVertexCounts.length; i++) {

	    start = fanStart;
	    triCoordIdx[0] = geom.getCoordinateIndex(start);
	    triVertIdx[0] = start++;
	    triCoordIdx[1] = geom.getCoordinateIndex(start);
	    triVertIdx[1] = start++;
	    
	    int end = start + stripVertexCounts[i] - 2;
	    for (int j=start; j<end; j++) {	 
		triVertIdx[2] = j;
		triCoordIdx[2] = geom.getCoordinateIndex(j);
		if (intersectTri(triVertIdx, triCoordIdx, geomIndex, pnts, pi)) {
		    numint++;
		    if (firstpick) return true;
		}
		triVertIdx[1] = triVertIdx[2];
		triCoordIdx[1] = triCoordIdx[2];
	    }    
	    fanStart += stripVertexCounts[i];
	}
	if (numint > 0) return true;
	return false;
    }

    /** 
      Intersect method for QuadArray 
      */
    boolean intersectQA (QuadArray geom, int geomIndex, Point3d[] pnts,
			 boolean firstpick, PickIntersection pi) {

	if (debug) System.out.println ("intersect: QuadArray");

	int[] quadVertIdx = new int[4];

	int numint = 0;
	for (int i=0; i<pnts.length;) {
	    quadVertIdx[0] = i++;
	    quadVertIdx[1] = i++;
	    quadVertIdx[2] = i++;
	    quadVertIdx[3] = i++;
	    if (intersectQuad(quadVertIdx, quadVertIdx, geomIndex, pnts, pi)) {
		numint++;
		if (firstpick) return true;
	    }
	} 

	if (numint > 0) return true;
	return false;
    }

    /** 
      Intersect method for IndexedQuadArray 
      */
    final boolean intersectIQA (IndexedQuadArray geom, int geomIndex, 
				Point3d[] pnts, boolean firstpick,
				PickIntersection pi) {

	if (debug) System.out.println ("intersect: IndexedQuadArray");

	int[] quadVertIdx = new int[4];
	int[] quadCoordIdx = new int[4];

	int numint = 0;
	int indexCount = geom.getIndexCount();
	// System.out.println ("intersect: IndexedQuadArray : indexCount " + indexCount);
	for (int i=0; i<indexCount;) {
	    quadVertIdx[0] = i;
	    quadCoordIdx[0] = geom.getCoordinateIndex(i++);
	    quadVertIdx[1] = i;
	    quadCoordIdx[1] = geom.getCoordinateIndex(i++);
	    quadVertIdx[2] = i;
	    quadCoordIdx[2] = geom.getCoordinateIndex(i++);
	    quadVertIdx[3] = i;
	    quadCoordIdx[3] = geom.getCoordinateIndex(i++);

	    if (intersectQuad(quadVertIdx, quadCoordIdx, geomIndex, pnts, pi)) {
		numint++;
		if (firstpick) return true;
	    }
	} 

	if (numint > 0) return true;
	return false;

    }

    /* ==================================================================== */
    /*                      GENERAL INTERSECT METHODS                       */
    /* ==================================================================== */
    static boolean intersectBoundingBox (Point3d coordinates[], 
					 BoundingBox box) {
	int i, j;
	int out[] = new int[6];      

	Point3d lower = new Point3d();
	Point3d upper = new Point3d();
	box.getLower (lower);
	box.getUpper (upper);
       
	//Do trivial vertex test.
	for (i=0; i<6; i++) out[i] = 0;
	for (i=0; i<coordinates.length; i++) {
	    if ((coordinates[i].x >= lower.x) && 
		(coordinates[i].x <= upper.x) &&
		(coordinates[i].y >= lower.y) && 
		(coordinates[i].y <= upper.y) &&
		(coordinates[i].z >= lower.z) && 
		(coordinates[i].z <= upper.z)) {
		// We're done! It's inside the boundingbox.
		return true;	  
	    } else {
		if (coordinates[i].x < lower.x) out[0]++; // left
		if (coordinates[i].y < lower.y) out[1]++; // bottom
		if (coordinates[i].z < lower.z) out[2]++; // back
		if (coordinates[i].x > upper.x) out[3]++; // right
		if (coordinates[i].y > upper.y) out[4]++; // top
		if (coordinates[i].z > upper.z) out[5]++; // front	  
	    }
	}
      
	if ((out[0] == coordinates.length) || (out[1] == coordinates.length) ||
	    (out[2] == coordinates.length) || (out[3] == coordinates.length) ||
	    (out[4] == coordinates.length) || (out[5] == coordinates.length)){
	    // we're done. primitive is outside of boundingbox.
	    return false;
	}      
	// Setup bounding planes.
	Point3d pCoor[] = new Point3d[4];
	for (i=0; i<4; i++) pCoor[i] = new Point3d();
      
	// left plane.
	pCoor[0].set(lower.x, lower.y, lower.z);
	pCoor[1].set(lower.x, lower.y, upper.z);
	pCoor[2].set(lower.x, upper.y, upper.z);
	pCoor[3].set(lower.x, upper.y, lower.z);
	if (intersectPolygon(pCoor, coordinates, false) == true) return true;

	// right plane.
	pCoor[0].set(upper.x, lower.y, lower.z);
	pCoor[1].set(upper.x, upper.y, lower.z);
	pCoor[2].set(upper.x, upper.y, upper.z);
	pCoor[3].set(upper.x, lower.y, upper.z);
	if (intersectPolygon(pCoor, coordinates, false) == true) return true;

	// bottom plane.
	pCoor[0].set(upper.x, lower.y, upper.z);
	pCoor[1].set(lower.x, lower.y, upper.z);
	pCoor[2].set(lower.x, lower.y, lower.z);
	pCoor[3].set(upper.x, lower.y, lower.z);
	if (intersectPolygon(pCoor, coordinates, false) == true) return true;

	// top plane.
	pCoor[0].set(upper.x, upper.y, upper.z);
	pCoor[1].set(upper.x, upper.y, lower.z);
	pCoor[2].set(lower.x, upper.y, lower.z);
	pCoor[3].set(lower.x, upper.y, upper.z);
	if (intersectPolygon(pCoor, coordinates, false) == true) return true;

	// front plane.
	pCoor[0].set(upper.x, upper.y, upper.z);
	pCoor[1].set(lower.x, upper.y, upper.z);
	pCoor[2].set(lower.x, lower.y, upper.z);
	pCoor[3].set(upper.x, lower.y, upper.z);
	if (intersectPolygon(pCoor, coordinates, false) == true) return true;
      
	// back plane.
	pCoor[0].set(upper.x, upper.y, lower.z);
	pCoor[1].set(upper.x, lower.y, lower.z);
	pCoor[2].set(lower.x, lower.y, lower.z);
	pCoor[3].set(lower.x, upper.y, lower.z);
	if (intersectPolygon(pCoor, coordinates, false) == true) return true;

	return false;
    }

    static boolean intersectBoundingSphere (Point3d coordinates[], 
					    BoundingSphere sphere) {


	int i, j;
	Vector3d tempV3D = new Vector3d();
	boolean esFlag;
	Point3d center = new Point3d();
	sphere.getCenter (center);
	double radius = sphere.getRadius ();
	//Do trivial vertex test.

	for (i=0; i<coordinates.length; i++) {
	    tempV3D.x = coordinates[i].x - center.x;
	    tempV3D.y = coordinates[i].y - center.y;
	    tempV3D.z = coordinates[i].z - center.z;
	
	    if (tempV3D.length() <= radius) {
		// We're done! It's inside the boundingSphere.
		return true;
	    }
	}

	for (i=0; i<coordinates.length; i++) {
	    if (i < (coordinates.length-1)) {
		esFlag = edgeIntersectSphere(sphere, coordinates[i], 
					     coordinates[i+1]);
	    } else {
		esFlag = edgeIntersectSphere(sphere, coordinates[i], 
					     coordinates[0]);
	    }
	    if (esFlag == true) {
		return true;
	    }
	}

	if (coordinates.length < 3) return false; // We're done with line.

	// Find rho.
	// Compute plane normal.
	Vector3d vec0 = new Vector3d(); //Edge vector from point 0 to point 1;
	Vector3d vec1 = new Vector3d(); //Edge vector from point 0 to point 2 or 3;
	Vector3d pNrm = new Vector3d();
	Vector3d pa = new Vector3d();
	Point3d q = new Point3d();
	double nLenSq, pqLen, pNrmDotPa, tq;

	// compute plane normal for coordinates.
	for (i=0; i<coordinates.length-1;) {
	    vec0.x = coordinates[i+1].x - coordinates[i].x;
	    vec0.y = coordinates[i+1].y - coordinates[i].y;
	    vec0.z = coordinates[i+1].z - coordinates[i++].z;