canvasviewcache.java

JAVA3D矩陈的相关类

		leftEyeInImagePlate.y = (leftEye.y + rightEye.y) / 2.0;
		leftEyeInImagePlate.z = (leftEye.z + rightEye.z) / 2.0;
		break;

	    case View.LEFT_EYE_VIEW:
		leftEyeInImagePlate.set(leftEye);
		break;

	    case View.RIGHT_EYE_VIEW:
		leftEyeInImagePlate.set(rightEye);
		break;

	    }

	    // Set right as well just in case
	    rightEyeInImagePlate.set(leftEyeInImagePlate);
	}
	else {
	    leftEyeInImagePlate.set(leftEye);
	    rightEyeInImagePlate.set(rightEye);
	}

	// Denote that eyes-in-ImagePlate fields have changed so that
	// these new values can be sent to the AudioDevice
        if (this.viewCache.view.soundScheduler != null)
            this.viewCache.view.soundScheduler.setListenerFlag(
                 SoundScheduler.EYE_POSITIONS_CHANGED);
    }

    private void cacheEyePosCoexistenceRelative(Point3d leftManualEyeInCoexistence,
						Point3d rightManualEyeInCoexistence) {

	tPnt1.set(leftManualEyeInCoexistence);
	viewCache.coexistenceToTrackerBase.transform(tPnt1);
	screenViewCache.trackerBaseToImagePlate.transform(tPnt1);
	tPnt1.add(coexistenceCenter);

	tPnt2.set(rightManualEyeInCoexistence);
	viewCache.coexistenceToTrackerBase.transform(tPnt2);
	screenViewCache.trackerBaseToImagePlate.transform(tPnt2);
	tPnt2.add(coexistenceCenter);

	cacheEyePosScreenRelative(tPnt1, tPnt2);

    }

    /**
     * Compute the head-tracked eye position for the right and
     * left eyes.
     */
    private void computeTrackedEyePosition() {
	if ((J3dDebug.devPhase) && (J3dDebug.canvasViewCache >= J3dDebug.LEVEL_2)) {
	    System.err.println("computeTrackedEyePosition:");
	    System.err.println("viewCache.headTrackerToTrackerBase:");
	    System.err.println(viewCache.headTrackerToTrackerBase);

	    System.err.println("viewCache.headToHeadTracker:");
	    System.err.println(viewCache.headToHeadTracker);
	}

	if (viewCache.viewPolicy != View.HMD_VIEW) {
	    if ((J3dDebug.devPhase) && (J3dDebug.canvasViewCache >= J3dDebug.LEVEL_2)) {
		System.err.println("screenViewCache.trackerBaseToImagePlate:");
		System.err.println(screenViewCache.trackerBaseToImagePlate);
	    }

	    headToLeftImagePlate.set(coexistenceCenter);
	    headToLeftImagePlate.mul(screenViewCache.trackerBaseToImagePlate);
	    headToLeftImagePlate.mul(viewCache.headTrackerToTrackerBase);
	    headToLeftImagePlate.mul(viewCache.headToHeadTracker);

	    headToLeftImagePlate.transform(viewCache.leftEyePosInHead,
					   leftTrackedEyeInImagePlate);

	    headToLeftImagePlate.transform(viewCache.rightEyePosInHead,
					   rightTrackedEyeInImagePlate);
	}
	else {
	    if ((J3dDebug.devPhase) && (J3dDebug.canvasViewCache >= J3dDebug.LEVEL_2)) {
		System.err.println("headTrackerToLeftImagePlate:");
		System.err.println(headTrackerToLeftImagePlate);
	    }

	    headToLeftImagePlate.mul(headTrackerToLeftImagePlate,
				     viewCache.headToHeadTracker);

	    headToLeftImagePlate.transform(viewCache.leftEyePosInHead,
					   leftTrackedEyeInImagePlate);

	    if(useStereo) {
		headToRightImagePlate.mul(headTrackerToRightImagePlate,
					  viewCache.headToHeadTracker);

		headToRightImagePlate.transform(viewCache.rightEyePosInHead,
						rightTrackedEyeInImagePlate);
	    }
	    else { // HMD_VIEW with no stereo.
		headToLeftImagePlate.transform(viewCache.rightEyePosInHead,
					       rightTrackedEyeInImagePlate);
	    }

	}

	if ((J3dDebug.devPhase) && (J3dDebug.canvasViewCache >= J3dDebug.LEVEL_2)) {
	    System.err.println("headToLeftImagePlate:");
	    System.err.println(headToLeftImagePlate);
	    System.err.println("headToRightImagePlate:");
	    System.err.println(headToRightImagePlate);

	}
    }

    /**
     * Routine to cache the current eye position in image plate
     * coordinates.
     */
    private void cacheEyePosition() {
	if (viewCache.compatibilityModeEnable) {
	    // XXXX: Compute compatibility mode eye position in ImagePlate???
	    cacheEyePosScreenRelative(leftManualEyeInImagePlate,
				      rightManualEyeInImagePlate);
	}
	else if (viewCache.getDoHeadTracking()) {
	    computeTrackedEyePosition();
	    cacheEyePosScreenRelative(leftTrackedEyeInImagePlate,
				      rightTrackedEyeInImagePlate);
	}
	else {
	    switch (viewCache.windowEyepointPolicy) {

	    case View.RELATIVE_TO_FIELD_OF_VIEW:
		cacheEyePosFixedField();
		break;

	    case View.RELATIVE_TO_WINDOW:
		cacheEyePosWindowRelative();
		break;

	    case View.RELATIVE_TO_SCREEN:
		cacheEyePosScreenRelative(leftManualEyeInImagePlate,
					  rightManualEyeInImagePlate);
		break;

	    case View.RELATIVE_TO_COEXISTENCE:
 		cacheEyePosCoexistenceRelative(viewCache.leftManualEyeInCoexistence,
					       viewCache.rightManualEyeInCoexistence);
		break;
	    }
	}

	// Compute center eye
	centerEyeInImagePlate.add(leftEyeInImagePlate, rightEyeInImagePlate);
	centerEyeInImagePlate.scale(0.5);

	// Compute derived value of nominalEyeOffsetFromNominalScreen
	if (viewCache.windowEyepointPolicy == View.RELATIVE_TO_FIELD_OF_VIEW)
	    nominalEyeOffset = centerEyeInImagePlate.z;
	else
	    nominalEyeOffset = viewCache.nominalEyeOffsetFromNominalScreen;

	if ((J3dDebug.devPhase) && (J3dDebug.canvasViewCache >= J3dDebug.LEVEL_1)) {
	    System.err.println("leftEyeInImagePlate = " +
			       leftEyeInImagePlate);
	    System.err.println("rightEyeInImagePlate = " +
			       rightEyeInImagePlate);
	    System.err.println("centerEyeInImagePlate = " +
			       centerEyeInImagePlate);
	    System.err.println("nominalEyeOffset = " +
			       nominalEyeOffset);
	    System.err.println();
	}
    }

    private void computePlateToVworld() {
	if (viewCache.compatibilityModeEnable) {
	    // XXXX: implement this correctly for compat mode
	    leftPlateToVworld.setIdentity();
	    vworldToLeftPlate.setIdentity();
	}
	else {
	    try {
		leftPlateToVpc.invert(vpcToLeftPlate);
	    }
	    catch (SingularMatrixException e) {
		leftPlateToVpc.setIdentity();
		/*
		  System.err.println("SingularMatrixException encountered when doing" +
		  " leftPlateToVpc invert");
		  */
	    }

	    leftPlateToVworld.mul(vpcToVworld, leftPlateToVpc);
	    vworldToLeftPlate.mul(vpcToLeftPlate, vworldToVpc);

	    if(useStereo) {
		try {
		    rightPlateToVpc.invert(vpcToRightPlate);
		}
		catch (SingularMatrixException e) {
		    rightPlateToVpc.setIdentity();
		    /*
		      System.err.println("SingularMatrixException encountered when doing" +
		      " rightPlateToVpc invert");
		      */
		}

		rightPlateToVworld.mul(vpcToVworld, rightPlateToVpc);
		vworldToRightPlate.mul(vpcToRightPlate, vworldToVpc);

	    }

	    if((J3dDebug.devPhase) && (J3dDebug.canvasViewCache >= J3dDebug.LEVEL_2)) {
		System.err.println("vpcToVworld:");
		System.err.println(vpcToVworld);
		System.err.println("vpcToLeftPlate:");
		System.err.println(vpcToLeftPlate);
		if(useStereo) {
		    System.err.println("vpcToRightPlate:");
		    System.err.println(vpcToRightPlate);

		}

	    }
	}

	// Denote that eyes-in-ImagePlate fields have changed so that
	// these new values can be sent to the AudioDevice
        if (this.viewCache.view.soundScheduler != null)
            this.viewCache.view.soundScheduler.setListenerFlag(
                 SoundScheduler.IMAGE_PLATE_TO_VWORLD_CHANGED);
    }


    private void computeHeadToVworld() {
        // Concatenate headToLeftImagePlate with leftPlateToVworld

	if (viewCache.compatibilityModeEnable) {
	    // XXXX: implement this correctly for compat mode
	    headToVworld.setIdentity();
	}
	else {
	    headToVworld.mul(leftPlateToVworld, headToLeftImagePlate);

	    if((J3dDebug.devPhase) && (J3dDebug.canvasViewCache >= J3dDebug.LEVEL_2)) {
		System.err.println("leftPlateToVworld:");
		System.err.println(leftPlateToVworld);
		System.err.println("headToLeftImagePlate:");
		System.err.println(headToLeftImagePlate);
		System.err.println("...gives -> headToVworld:");
		System.err.println(headToVworld);
	    }
	}

	// Denote that eyes-in-ImagePlate fields have changed so that
	// these new values can be sent to the AudioDevice
        if (this.viewCache.view.soundScheduler != null)
            this.viewCache.view.soundScheduler.setListenerFlag(
                 SoundScheduler.HEAD_TO_VWORLD_CHANGED);
    }

    private void computeVpcToCoexistence() {
	// Create a transform with the view platform to coexistence scale
	tMat1.set(viewPlatformScale);

	// XXXX: Is this really correct to ignore HMD?

	if (viewCache.viewPolicy != View.HMD_VIEW) {
	    switch (viewCache.coexistenceCenterInPworldPolicy) {
	    case View.NOMINAL_SCREEN :
		switch (viewCache.viewAttachPolicy) {
		case View.NOMINAL_SCREEN:
		    tMat2.setIdentity();
		    break;
		case View.NOMINAL_HEAD:
		    tVec1.set(0.0, 0.0, nominalEyeOffset);
		    tMat2.set(tVec1);
		    break;
		case View.NOMINAL_FEET:
		    tVec1.set(0.0, -viewCache.nominalEyeHeightFromGround,
			      nominalEyeOffset);
		    tMat2.set(tVec1);
		    break;
		}

		break;
	    case View.NOMINAL_HEAD :
		switch (viewCache.viewAttachPolicy) {
		case View.NOMINAL_SCREEN:
		    tVec1.set(0.0, 0.0, -nominalEyeOffset);
		    tMat2.set(tVec1);
		    break;
		case View.NOMINAL_HEAD:
		    tMat2.setIdentity();
		    break;
		case View.NOMINAL_FEET:
		    tVec1.set(0.0, -viewCache.nominalEyeHeightFromGround,
			      0.0);
		    tMat2.set(tVec1);
		    break;
		}
		break;
	      case View.NOMINAL_FEET:
		switch (viewCache.viewAttachPolicy) {
		case View.NOMINAL_SCREEN:
		    tVec1.set(0.0,
			      viewCache.nominalEyeHeightFromGround, -nominalEyeOffset);
		    tMat2.set(tVec1);
		    break;
		case View.NOMINAL_HEAD:
		    tVec1.set(0.0, viewCache.nominalEyeHeightFromGround,
			      0.0);
		    tMat2.set(tVec1);

		    break;
		case View.NOMINAL_FEET:
		    tMat2.setIdentity();
		    break;
		}
		break;
	    }

	    vpcToCoexistence.mul(tMat2, tMat1);
	}
	else {
	    vpcToCoexistence.set(tMat1);
	}

	if((J3dDebug.devPhase) && (J3dDebug.canvasViewCache >= J3dDebug.LEVEL_2)) {
	    System.err.println("vpcToCoexistence:");
	    System.err.println(vpcToCoexistence);
	}
    }

    private void computeCoexistenceCenter() {

	if ((!viewCache.compatibilityModeEnable) &&
	    (viewCache.viewPolicy != View.HMD_VIEW) &&
	    (viewCache.coexistenceCenteringEnable) &&
	    (viewCache.coexistenceCenterInPworldPolicy == View.NOMINAL_SCREEN)) {

	    // Compute the coexistence center in image plate coordinates

	    // Image plate cordinates have their orgin in the lower
	    // left hand corner of the CRT visiable raster.
	    // The nominal coexistence center is at the *center* of
	    // targeted area: either the window or screen, depending
	    // on policy.
	    if (viewCache.windowMovementPolicy == View.VIRTUAL_WORLD) {
		coexistenceCenter.x = physicalScreenWidth / 2.0;
		coexistenceCenter.y = physicalScreenHeight / 2.0;
		coexistenceCenter.z = 0.0;
	    }
	    else { // windowMovementPolicy == PHYSICAL_WORLD
		coexistenceCenter.x = physicalWindowCenter.x;
		coexistenceCenter.y = physicalWindowCenter.y;
		coexistenceCenter.z = 0.0;
	    }
	}
	else {
	    coexistenceCenter.set(0.0, 0.0, 0.0);
	}

	if(J3dDebug.devPhase) {
	    if (J3dDebug.canvasViewCache >= J3dDebug.LEVEL_1) {
		System.err.println("coexistenceCenter = " + coexistenceCenter);
	    }
	}
    }

    private void computeCoexistenceToPlate() {
	if (viewCache.compatibilityModeEnable) {
	    // XXXX: implement this correctly
	    coexistenceToLeftPlate.setIdentity();
	    return;
	}

	if (viewCache.viewPolicy != View.HMD_VIEW) {
	    coexistenceToLeftPlate.set(coexistenceCenter);
	    coexistenceToLeftPlate.mul(screenViewCache.trackerBaseToImagePlate);
	    coexistenceToLeftPlate.mul(viewCache.coexistenceToTrackerBase);

	    if(useStereo) {
		coexistenceToRightPlate.set(coexistenceToLeftPlate);
	    }
	}
	else {
	    coexistenceToLeftPlate.mul(headTrackerToLeftImagePlate,
				       viewCache.trackerBaseToHeadTracker);
	    coexistenceToLeftPlate.mul(viewCache.coexistenceToTrackerBase);

	    if(useStereo) {
		coexistenceToRightPlate.mul(headTrackerToRightImagePlate,
					    viewCache.trackerBaseToHeadTracker);
		coexistenceToRightPlate.mul(viewCache.coexistenceToTrackerBase);
	    }
	}

	if((J3dDebug.devPhase) && (J3dDebug.canvasViewCache >= J3dDebug.LEVEL_2)) {
	    System.err.println("coexistenceToLeftPlate:");
	    System.err.println(coexistenceToLeftPlate);
	    if(useStereo) {
		System.err.println("coexistenceToRightPlate:");
		System.err.println(coexistenceToRightPlate);

	    }
	}