groupretained.java

JAVA3D矩陈的相关类

		s.scopedNodesViewList = new ArrayList();
	    }

	    if (this instanceof OrderedGroupRetained && linkNode == null) {
                // set this regardless of refCount
		s.ogList.add(this);
		s.ogChildIdList.add(new Integer(childIndex));
		s.ogCIOList.add(this);
		int[] newArr = null;
		OrderedGroupRetained og = (OrderedGroupRetained)this;
		if(og.userChildIndexOrder != null) {
		    newArr = new int[og.userChildIndexOrder.length];
		    System.arraycopy(og.userChildIndexOrder, 0, newArr,
				     0, og.userChildIndexOrder.length);
		}
		s.ogCIOTableList.add(newArr);
		
	    }

            // Issue 312: always initialize s.viewLists
            s.viewLists = viewLists;

            TargetsInterface transformInterface, switchInterface;
            transformInterface = initTransformStates(s, false);
            switchInterface = initSwitchStates(s, this, child, linkNode, false);

            child.clearLive(s);

            CachedTargets[] newCtArr = null;
            newCtArr = updateTransformStates(s, transformInterface, false);
            updateSwitchStates(s, switchInterface, false);

	    // We're sending multiple messages in the call, inorder to
	    // have all these messages to be process as an atomic operation.
	    // We need to create an array of messages to MasterControl, this
	    // will ensure that all these messages will get the same time stamp.

	    // If it is called from "moveTo",  messages is not null.
	    if (messages == null) {
		int numMessages = 1;
		if(s.ogList.size() > 0) {
		    numMessages++;
		}
		else {
		    sendOGMessage = false;
		}

		if(s.changedViewGroup != null) {
		    numMessages++;
		}
		else {
		    sendVSGMessage = false;
		}

		messages = new J3dMessage[numMessages];
		messageIndex = 0;
		for(int mIndex=0; mIndex < numMessages; mIndex++) {
		    messages[mIndex] = new J3dMessage();
		}
		sendMessages = true;
	    }

	    if(sendOGMessage) {
		destroyMessage = messages[messageIndex++];
		destroyMessage.threads = J3dThread.UPDATE_RENDER | 
		    J3dThread.UPDATE_RENDERING_ENVIRONMENT;
		destroyMessage.type = J3dMessage.ORDERED_GROUP_REMOVED;
		destroyMessage.universe = universe;
		destroyMessage.args[0] = s.ogList.toArray();
		destroyMessage.args[1] = s.ogChildIdList.toArray();
		destroyMessage.args[3] = s.ogCIOList.toArray();
		destroyMessage.args[4] = s.ogCIOTableList.toArray();
	    }

            // Issue 312: We need to send the REMOVE_NODES message to the
            // RenderingEnvironmentStructure before we send VIEWSPECIFICGROUP_CLEAR,
            // since the latter clears the list of views that is referred to by
            // scopedNodesViewList and used by removeNodes.
	    destroyMessage = messages[messageIndex++];            
            destroyMessage.threads = s.notifyThreads;
            destroyMessage.type = J3dMessage.REMOVE_NODES;
            destroyMessage.universe = universe;
            destroyMessage.args[0] = s.nodeList.toArray();
	    
	    if (newCtArr != null) {
                destroyMessage.args[1] = transformInterface;
                destroyMessage.args[2] = newCtArr;
	    } else {
                destroyMessage.args[1] = null;
                destroyMessage.args[2] = null;
	    } 
	    if (s.viewScopedNodeList != null) {
		destroyMessage.args[3] = s.viewScopedNodeList;
		destroyMessage.args[4] = s.scopedNodesViewList;
	    }

	    if(sendVSGMessage) {
		destroyMessage = messages[messageIndex++];            
		destroyMessage.threads =  J3dThread.UPDATE_RENDERING_ENVIRONMENT;
		destroyMessage.type = J3dMessage.VIEWSPECIFICGROUP_CLEAR;
		destroyMessage.universe = universe;
		destroyMessage.args[0] = s.changedViewGroup;
		destroyMessage.args[1] = s.keyList;
	    }

            if (sendMessages == true) {
		VirtualUniverse.mc.processMessage(messages);
	    }
	    
	    s.reset(null); // for GC
        }
    }

    TargetsInterface initTransformStates(SetLiveState s, boolean isSetLive) {

        int numPaths = (inSharedGroup)? s.keys.length : 1;
        TargetsInterface ti = getClosestTargetsInterface(
                                        TargetsInterface.TRANSFORM_TARGETS);


	if (isSetLive) {
            s.currentTransforms = localToVworld;
            s.currentTransformsIndex = localToVworldIndex;
            s.localToVworldKeys = localToVworldKeys;
            s.localToVworld = s.currentTransforms;
            s.localToVworldIndex = s.currentTransformsIndex;

            s.parentTransformLink = parentTransformLink;
            if (parentTransformLink != null) {
                if (parentTransformLink instanceof TransformGroupRetained) {
		    TransformGroupRetained tg;
                    tg = (TransformGroupRetained) parentTransformLink;
                    s.childTransformLinks = tg.childTransformLinks;
                } else {
		    SharedGroupRetained sg;
                    sg = (SharedGroupRetained) parentTransformLink;
                    s.childTransformLinks = sg.childTransformLinks;
                }
            }
	}

	int transformLevels[] = new int[numPaths];
	findTransformLevels(transformLevels);
	s.transformLevels = transformLevels;
	
	if (ti != null) {
	    Targets[] newTargets = new Targets[numPaths];
	    for(int i=0; i<numPaths; i++) {
		if (s.transformLevels[i] >= 0) {		    
		    newTargets[i] = new Targets();
		} else {
		    newTargets[i] = null;
		}
	    }
	    s.transformTargets = newTargets;
	    
	    // XXXX: optimization for targetThreads computation, require
	    // cleanup in GroupRetained.doSetLive()
	    //s.transformTargetThreads = 0;
	}
        
	return ti;
    }

    CachedTargets[] updateTransformStates(SetLiveState s,
				TargetsInterface ti, boolean isSetLive) {
        CachedTargets[] newCtArr = null;

        if (ti != null) {
	    if (isSetLive) {
                CachedTargets ct;
                int newTargetThreads = 0;
                int hkIndex;

                newCtArr = new CachedTargets[localToVworld.length];

                // update targets
                if (! inSharedGroup) {
                    if (s.transformTargets[0] != null) {
                        ct = ti.getCachedTargets(
                                    TargetsInterface.TRANSFORM_TARGETS, 0, -1);
                        if (ct != null) {
                            newCtArr[0] = s.transformTargets[0].snapShotAdd(ct);
                        }
                    } else {
                        newCtArr[0] = null;
                    }
                } else {
                    for (int i=0; i<s.keys.length; i++) {

                        if (s.transformTargets[i] != null) {
                            ct = ti.getCachedTargets(
                                TargetsInterface.TRANSFORM_TARGETS, i, -1);
                            if (ct != null) {
                                newCtArr[i] =
                                        s.transformTargets[i].snapShotAdd(ct);
                            }
                        } else {
                            newCtArr[i] = null;
                        }
                    }
                }
            } else {

                CachedTargets ct;
                int hkIndex;

                newCtArr = new CachedTargets[localToVworld.length];

                if (! inSharedGroup) {
                    if (s.transformTargets[0] != null) {
                        ct = ti.getCachedTargets(
                                    TargetsInterface.TRANSFORM_TARGETS, 0, -1);
                        if (ct != null) {
                            newCtArr[0] =
                                s.transformTargets[0].snapShotRemove(ct);
                        }
                    } else {
                        newCtArr[0] = null;
                    }
                } else {
                    for (int i=0; i<s.keys.length; i++) {
                        if (s.transformTargets[i] != null) {
                            ct = ti.getCachedTargets(
                                TargetsInterface.TRANSFORM_TARGETS, i, -1);
                            if (ct != null) {
                                newCtArr[i] =
                                    s.transformTargets[i].snapShotRemove(ct);
                            }
                        } else {
                            newCtArr[i] = null;
                        }
                    }
                }
	    }
            // update target threads and propagate change to above
            // nodes in scene graph

	    ti.updateTargetThreads(TargetsInterface.TRANSFORM_TARGETS,
	    			   newCtArr);
	    ti.resetCachedTargets(TargetsInterface.TRANSFORM_TARGETS,
	    			  newCtArr, -1);
	    
        }
        return newCtArr;
    }

    TargetsInterface initSwitchStates(SetLiveState s, 
				NodeRetained parentNode, NodeRetained childNode,
				NodeRetained linkNode, boolean isSetLive) {
        NodeRetained child;
	NodeRetained parent;
	int i,j;

	findSwitchInfo(s, parentNode, childNode, linkNode);
        TargetsInterface ti = getClosestTargetsInterface(
                                        TargetsInterface.SWITCH_TARGETS);
        if (ti != null) {
            Targets[] newTargets = null;
            int numPaths = (inSharedGroup)? s.keys.length : 1;
            newTargets = new Targets[numPaths];
            for(i=0; i<numPaths; i++) {
                if (s.switchLevels[i] >= 0) {
                    newTargets[i] = new Targets();
                } else {
                    newTargets[i] = null;
                }
            }
            s.switchTargets = newTargets;
        }

	if (isSetLive) {
	    // set switch states
            if (nodeType == NodeRetained.SWITCH) {
                i = parentSwitchLinkChildIndex;
                s.childSwitchLinks = (ArrayList)childrenSwitchLinks.get(i);
                s.parentSwitchLink = this;

            } else {
                if (nodeType == NodeRetained.SHAREDGROUP) {
                    i = parentSwitchLinkChildIndex;
                    s.childSwitchLinks = (ArrayList)childrenSwitchLinks.get(i);
                    s.parentSwitchLink = this;

                } else {
		    s.parentSwitchLink = parentSwitchLink;
                    if (parentSwitchLink != null) {
                        i = parentSwitchLinkChildIndex;
                        s.childSwitchLinks = (ArrayList)
                                parentSwitchLink.childrenSwitchLinks.get(i);
                    }
                }
            }
            if (ti != null) {
                s.switchStates = ti.getTargetsData(
					TargetsInterface.SWITCH_TARGETS,
					parentSwitchLinkChildIndex);
            } else {
                s.switchStates = new ArrayList(1);
                s.switchStates.add(new SwitchState(false));
            }
	} 
        return ti;
    }

    void updateSwitchStates(SetLiveState s, TargetsInterface ti, 
				boolean isSetLive) {

        // update switch leaves's compositeSwitchMask for ancestors
        // and update switch leaves' switchOn flag if at top level switch

        if (ti != null) {
	    if (isSetLive) {
                CachedTargets[] newCtArr = null;
                CachedTargets ct;

                newCtArr = new CachedTargets[localToVworld.length];

                // update targets
                if (! inSharedGroup) {

                    if (s.switchTargets[0] != null) {
                        ct = ti.getCachedTargets(
                                TargetsInterface.SWITCH_TARGETS, 0,
                                        parentSwitchLinkChildIndex);
                        if (ct != null) {
                            newCtArr[0] = s.switchTargets[0].snapShotAdd(ct);
                        } else {
                            newCtArr[0] = s.switchTargets[0].snapShotInit();
                        }
		    } else {
                        newCtArr[0] = null;
		    }
                } else {
                    for (int i=0; i<s.keys.length; i++) {
                        if (s.switchTargets[i] != null) {
                            ct = ti.getCachedTargets(
                                TargetsInterface.SWITCH_TARGETS, i, 
                                        parentSwitchLinkChildIndex);
                            if (ct != null) {
                                newCtArr[i] = 
					s.switchTargets[i].snapShotAdd(ct);
                            } else {
                                newCtArr[i] =
                                        s.switchTargets[i].snapShotInit();
                            }
			} else {
                            newCtArr[i] = null;
                        }
                    }
                }
                ti.resetCachedTargets(TargetsInterface.SWITCH_TARGETS,
                                        newCtArr, parentSwitchLinkChildIndex);
                if (ti instanceof SwitchRetained) {
                    ((SwitchRetained)ti).traverseSwitchParent();
                } else if (ti instanceof SharedGroupRetained) {
                    ((SharedGroupRetained)ti).traverseSwitchParent();
                }
	    } else {
                CachedTargets ct;

                CachedTargets[] newCtArr = 
			new CachedTargets[localToVworld.length];

                if (! inSharedGroup) {
                    if (s.switchTargets[0] != null) {
                        ct = ti.getCachedTargets(
                                    TargetsInterface.SWITCH_TARGETS, 0,
                                    parentSwitchLinkChildIndex);
                        if (ct != null) {
                            newCtArr[0] =
                                s.switchTargets[0].snapShotRemove(ct);
                        }
		    } else {
                        newCtArr[0] = null;
                    }
                } else {
                    for (int i=0; i<s.keys.length; i++) {
                        if (s.switchTargets[i] != null) {
                            ct = ti.getCachedTargets(
                                    TargetsInterface.SWITCH_TARGETS, i,
                                    parentSwitchLinkChildIndex);

                            if (ct != null) {
                                newCtArr[i] =
                                    s.switchTargets[i].snapShotRemove(ct);
                            }
			} else {
                            newCtArr[i] = null;
                        }
                    }
                }
                ti.resetCachedTargets(TargetsInterface.SWITCH_TARGETS,
                                        newCtArr, parentSwitchLinkChildIndex);
            }
        }
    }

    void appendChildrenData() {
    }
    void insertChildrenData(int index) {
    }
    void removeChildrenData(int index) {
    }

    TargetsInterface getClosestTargetsInterface(int type) {
        return (type == TargetsInterface.TRANSFORM_TARGETS)?
                (TargetsInterface)parentTransformLink:
                (TargetsInterface)parentSwitchLink;
    }


    synchronized void updateLocalToVworld() {
	NodeRetained child;
	
	// For each children call .....
	for (int i=children.size()-1; i>=0; i--) {
	    child = (NodeRetained)children.get(i);
	    if(child != null)
		child.updateLocalToVworld();
	}
    }

    void setNodeData(SetLiveSta