modelclipretained.java

JAVA3D矩陈的相关类

	    else {
		if (mirrorModelClip.regionOfInfluence != null) {
		    mirrorModelClip.region = 
			((Bounds)mirrorModelClip.regionOfInfluence).copy(mirrorModelClip.region);
		    mirrorModelClip.region.transform(mirrorModelClip.regionOfInfluence,
						     getCurrentLocalToVworld());
		}
		else {
		    mirrorModelClip.region = null;
		}
		
	    }
	} 

	if ((component & BOUNDS_CHANGED) != 0) {
	    mirrorModelClip.regionOfInfluence = (Bounds) objs[2];
	    if (mirrorModelClip.boundingLeaf == null) {
		if (objs[2] != null) {
		    mirrorModelClip.region = 
			((Bounds)mirrorModelClip.regionOfInfluence).copy(mirrorModelClip.region);
		    
		    mirrorModelClip.region.transform(mirrorModelClip.regionOfInfluence,
						     getCurrentLocalToVworld());
		}
		else {
		    mirrorModelClip.region = null;
		}
	    }
	} 

	if ((component & SCOPE_CHANGED) != 0) {
            Object[] scopeList = (Object[])objs[2];
            ArrayList addList = (ArrayList)scopeList[0];
            ArrayList removeList = (ArrayList)scopeList[1];
            boolean isScoped = ((Boolean)scopeList[2]).booleanValue();

            if (addList != null) {
                mirrorModelClip.isScoped = isScoped;
                for (int i = 0; i < addList.size(); i++) {
		    Shape3DRetained obj = ((GeometryAtom)addList.get(i)).source;
		    obj.addModelClip(mirrorModelClip);
                }
            }

            if (removeList != null) {
                mirrorModelClip.isScoped = isScoped;
                for (int i = 0; i < removeList.size(); i++) {
		    Shape3DRetained obj = ((GeometryAtom)removeList.get(i)).source;
		    obj.removeModelClip(mirrorModelClip);
                }
            }
        }

	if ((component & ENABLES_CHANGED) != 0) {
	    Boolean[] en = ((Boolean[]) objs[2]);

	    mirrorModelClip.enables[0] = en[0].booleanValue();
	    mirrorModelClip.enables[1] = en[1].booleanValue();
	    mirrorModelClip.enables[2] = en[2].booleanValue();
	    mirrorModelClip.enables[3] = en[3].booleanValue();
	    mirrorModelClip.enables[4] = en[4].booleanValue();
	    mirrorModelClip.enables[5] = en[5].booleanValue();
            mirrorModelClip.enableFlag = mirrorModelClip.enables[0] |
					mirrorModelClip.enables[1] |
					mirrorModelClip.enables[2] |
					mirrorModelClip.enables[3] |
					mirrorModelClip.enables[4] |
					mirrorModelClip.enables[5] ;
	} else if ((component & ENABLE_CHANGED) != 0) {
	    int planeNum = ((Integer)objs[2]).intValue();

	    mirrorModelClip.enables[planeNum] = ((Boolean)objs[3]).booleanValue();
            mirrorModelClip.enableFlag = mirrorModelClip.enables[0] |
					mirrorModelClip.enables[1] |
					mirrorModelClip.enables[2] |
					mirrorModelClip.enables[3] |
					mirrorModelClip.enables[4] |
					mirrorModelClip.enables[5] ;
	} 
    }


    /** Note: This routine will only be called on
     * the mirror object - will update the object's
     * cached region and transformed region
     */
    void updateBoundingLeaf() {
        if (boundingLeaf != null && boundingLeaf.switchState.currentSwitchOn) {
            region = boundingLeaf.transformedRegion;
        } else {
            if (regionOfInfluence != null) {
		region = regionOfInfluence.copy(region);
                region.transform(regionOfInfluence, getCurrentLocalToVworld());
            } else {
                region = null;
            }
        }
    }


    void setLive(SetLiveState s) {
	GroupRetained group;

	super.doSetLive(s);

	if (inSharedGroup) {
	    throw new
		IllegalSharingException(J3dI18N.getString("ModelClipRetained1"));
	}

	// Create the mirror object


        if (mirrorModelClip == null) {
	    mirrorModelClip = (ModelClipRetained)this.clone();
	    mirrorModelClip.boundingLeaf = null;
	    mirrorModelClip.sgModelClip = this;
	}
	if ((s.viewScopedNodeList != null) && (s.viewLists != null)) {
	    s.viewScopedNodeList.add(mirrorModelClip);
	    s.scopedNodesViewList.add(s.viewLists.get(0));
	} else {
	    s.nodeList.add(mirrorModelClip);
	}

	// If bounding leaf is not null, add the mirror object as a user
	// so that any changes to the bounding leaf will be received
	if (boundingLeaf != null) {
	    boundingLeaf.mirrorBoundingLeaf.addUser(mirrorModelClip);
	}
        // process switch leaf
        if (s.switchTargets != null &&
                        s.switchTargets[0] != null) {
            s.switchTargets[0].addNode(mirrorModelClip, Targets.ENV_TARGETS);
        }
        mirrorModelClip.switchState = (SwitchState)s.switchStates.get(0);

	// add this model clip to the transform target
        if (s.transformTargets != null && s.transformTargets[0] != null) {
            s.transformTargets[0].addNode(mirrorModelClip, Targets.ENV_TARGETS);
	    s.notifyThreads |= J3dThread.UPDATE_TRANSFORM;
	}

        s.notifyThreads |= J3dThread.UPDATE_RENDERING_ENVIRONMENT|
            J3dThread.UPDATE_RENDER;
	super.markAsLive();


	// Initialize the mirror object, this needs to be done, when
	// renderBin is not accessing any of the fields
	J3dMessage createMessage = new J3dMessage();
	createMessage.threads = J3dThread.UPDATE_RENDERING_ENVIRONMENT;
	createMessage.universe = universe;
	createMessage.type = J3dMessage.MODELCLIP_CHANGED;
	createMessage.args[0] = this;
	// a snapshot of all attributes that needs to be initialized
	// in the mirror object
	createMessage.args[1]= new Integer(INIT_MIRROR);
	ArrayList addScopeList = new ArrayList();
	for (int i = 0; i < scopes.size(); i++) {
	    group = (GroupRetained)scopes.get(i);
	    tempKey.reset();
	    group.addAllNodesForScopedModelClip(mirrorModelClip, addScopeList, tempKey);
	}
	Object[] scopeInfo = new Object[2];
	scopeInfo[0] = ((scopes.size() > 0) ? Boolean.TRUE:Boolean.FALSE);
	scopeInfo[1] = addScopeList;	
	createMessage.args[2] = scopeInfo;
	createMessage.args[3] = xformPlanes.clone();

	Object[] obj = new Object[3];
	obj[0] = boundingLeaf;
	obj[1] = (regionOfInfluence != null?regionOfInfluence.clone():null);
	obj[2] = enables.clone();
	createMessage.args[4] = obj;
	VirtualUniverse.mc.processMessage(createMessage);

	
    }


    /**
     * This clearLive routine first calls the superclass's method, then
     * it removes itself to the list of model clip
     */
    void clearLive(SetLiveState s) {

        super.clearLive(s);
        s.notifyThreads |= J3dThread.UPDATE_RENDERING_ENVIRONMENT|
            J3dThread.UPDATE_RENDER;
        if (s.switchTargets != null &&
                        s.switchTargets[0] != null) {
            s.switchTargets[0].addNode(mirrorModelClip, Targets.ENV_TARGETS);
        }
        // Remove this mirror light as users of the bounding leaf
        if (mirrorModelClip.boundingLeaf != null)
            mirrorModelClip.boundingLeaf.removeUser(mirrorModelClip);

	if ((s.viewScopedNodeList != null) && (s.viewLists != null)) {
	    s.viewScopedNodeList.add(mirrorModelClip);
	    s.scopedNodesViewList.add(s.viewLists.get(0));
	} else {
	    s.nodeList.add(mirrorModelClip);
	}
        if (s.transformTargets != null && s.transformTargets[0] != null) {
            s.transformTargets[0].addNode(mirrorModelClip, Targets.ENV_TARGETS);
	    s.notifyThreads |= J3dThread.UPDATE_TRANSFORM;
        }


	if (scopes.size() > 0) {
	    J3dMessage createMessage = new J3dMessage();
	    createMessage.threads = J3dThread.UPDATE_RENDERING_ENVIRONMENT;
	    createMessage.universe = universe;
	    createMessage.type = J3dMessage.MODELCLIP_CHANGED;
	    createMessage.args[0] = this;
	    createMessage.args[1]= new Integer(CLEAR_MIRROR);
	    ArrayList removeScopeList = new ArrayList();
	    for (int i = 0; i < scopes.size(); i++) {
		GroupRetained group = (GroupRetained)scopes.get(i);
		tempKey.reset();
		group.removeAllNodesForScopedModelClip(mirrorModelClip, removeScopeList, tempKey);
	    }
	    createMessage.args[2] = removeScopeList;
	    VirtualUniverse.mc.processMessage(createMessage);
	}
    }

   // This is called on the parent object
    void clearMirrorObject(Object[] args) {
	Shape3DRetained shape;
	ArrayList shapeList = (ArrayList)args[2];
	ArrayList removeScopeList = new ArrayList();
	
	for (int i = 0; i < shapeList.size(); i++) {
	    shape = ((GeometryAtom)shapeList.get(i)).source;
	    shape.removeModelClip(mirrorModelClip);
	}

	mirrorModelClip.isScoped = false;	

    }
    

    // Clone the retained side only, internal use only
    protected Object clone() {
        ModelClipRetained mc = (ModelClipRetained)super.clone();

        mc.planes = new Vector4d[6];
	for (int i = 0; i < 6; i++) {
	     mc.planes[i] = new Vector4d(this.planes[i]);
	     mc.xformPlanes[i] = new Vector4d(this.xformPlanes[i]);
	}

        mc.enables = new boolean[6];
        getEnables(mc.enables);

	// Derive the enables flag
        mc.enableFlag = (mc.enables[0] |
			 mc.enables[1] |
			 mc.enables[2] |
			 mc.enables[3] |
			 mc.enables[4] |
			 mc.enables[5] );	

        mc.inImmCtx = false;
        mc.region = null;
        mc.sgModelClip = null;
        mc.mirrorModelClip = null;
	mc.environmentSets = new UnorderList(1, EnvironmentSet.class);

	if (regionOfInfluence != null) {
	    mc.regionOfInfluence = (Bounds) regionOfInfluence.clone();
	}

        return mc;
    }


    // Called on mirror object
    void updateImmediateTransformChange() {
        // If bounding leaf is null, tranform the bounds object
        if (boundingLeaf == null) {
            if (regionOfInfluence != null) {
		region = regionOfInfluence.copy(region);
                region.transform(regionOfInfluence,
				 sgModelClip.getCurrentLocalToVworld());
            }

        }
    }


    void printPlane(int index, String string) 
    {
	System.err.println(string + " : < " + planes[index].toString() 
		+ " > " + enables[index]);
    } 

    void printPlanes(String string, Vector4d[] planes) 
    {
	System.err.println(string);
	printPlane(0, "[0]");
	printPlane(1, "[1]");
	printPlane(2, "[2]");
	printPlane(3, "[3]");
	printPlane(4, "[4]");
	printPlane(5, "[5]");
    }


    void printEnables(String string, boolean[] enables) 
    {
	System.err.println(string);
	System.err.println("[0] : < " + enables[0] + " >");
	System.err.println("[1] : < " + enables[1] + " >");
	System.err.println("[2] : < " + enables[2] + " >");
	System.err.println("[3] : < " + enables[3] + " >");
	System.err.println("[4] : < " + enables[4] + " >");
	System.err.println("[5] : < " + enables[5] + " >");
    }

   final void sendMessage(int attrMask, Object attr1, Object attr2) {
	J3dMessage createMessage = new J3dMessage();
	createMessage.threads = targetThreads;
	createMessage.type = J3dMessage.MODELCLIP_CHANGED;
        createMessage.universe = universe;
	createMessage.args[0] = this;
	createMessage.args[1]= new Integer(attrMask);
	createMessage.args[2] = attr1;
	createMessage.args[3] = attr2;
	VirtualUniverse.mc.processMessage(createMessage);
    }

    void mergeTransform(TransformGroupRetained staticTransform) {
	super.mergeTransform(staticTransform);

	if (regionOfInfluence != null) {
            regionOfInfluence.transform(staticTransform.transform);
	}

	Transform3D xform = staticTransform.getNormalTransform();
	for (int i = 0; i < 6; i++) {
	     xform.transform(planes[i], xformPlanes[i]);
	}
    }
    void getMirrorObjects(ArrayList leafList, HashKey key) {
	leafList.add(mirrorModelClip);
    }
}