sharedgroupretained.java

JAVA3D矩陈的相关类

/*
 * $RCSfile: SharedGroupRetained.java,v $
 *
 * Copyright (c) 2007 Sun Microsystems, Inc. All rights reserved.
 *
 * Use is subject to license terms.
 *
 * $Revision: 1.8 $
 * $Date: 2007/04/20 00:54:41 $
 * $State: Exp $
 */

package javax.media.j3d;

import java.util.*;

/**
 * The SharedGroup node provides the ability to share a scene graph from
 * multiple other scene graphs through the use of a Link node.
 */

class SharedGroupRetained extends GroupRetained implements TargetsInterface {

    /*
    static final int ILLEGAL_LEAF_MASK =
                          1 << NodeRetained.BACKGROUND |
                          1 << NodeRetained.BEHAVIOR |
                          1 << NodeRetained.CLIP |
                          1 << NodeRetained.LINEARFOG |
                          1 << NodeRetained.EXPONENTIALFOG |
                          1 << NodeRetained.SOUNDSCAPE |
                          1 << NodeRetained.VIEWPLATFORM |
                          1 << NodeRetained.BOUNDINGLEAF;
    */

    // The current list of child transform group nodes or link nodes
    // under a transform group
    ArrayList childTransformLinks = new ArrayList(1);

    // key which identifies a unique path from a
    // locale to this transform group
    HashKey currentKey = new HashKey();

    // key which identifies a unique path from a locale to this switch link
    HashKey switchKey = new HashKey();

    /**
     * The Shared Group Node's parent vector.
     */  
    Vector parents = new Vector(1);

    // J3d copy.
    CachedTargets[] j3dCTs = null;

    // User copy.
    CachedTargets[] cachedTargets = null;

    // A bitmask of the types in targets for transform targets
    int localTargetThreads = 0;
    // combined localTargetThreads and decendants' localTargetThreads
    int targetThreads = 0;

    ArrayList switchStates = null;

    SharedGroupRetained() {
        this.nodeType = NodeRetained.SHAREDGROUP;
    }

    // SharedGroup specific data at SetLive.
    void setAuxData(SetLiveState s, int index, int hkIndex) {
	int i, size;

	// Group's setAuxData()
	super.setAuxData(s, index, hkIndex);

	branchGroupPaths.add(hkIndex, s.branchGroupPaths.get(index));	    

        if (orderedPaths == null) {
            orderedPaths = new ArrayList(1);
        }
        orderedPaths.add(hkIndex, s.orderedPaths.get(index));

        if (switchStates == null) {
            switchStates = new ArrayList(1);
        }
        switchStates.add(hkIndex, s.switchStates.get(index));

	if (viewLists == null) {
	    viewLists = new ArrayList(1);
	}
	// If there are some ViewSpecificGroups in the path above this SharedGroup
	//	System.err.println("====> hkIndex = "+hkIndex+" s.viewLists = "+s.viewLists);
	if (s.viewLists != null) {
	    viewLists.add(hkIndex, s.viewLists.get(index));
	}
	else {
	    viewLists.add(hkIndex, null);
	}

	if (lights == null) {
	    lights = new ArrayList(1);
	}
	if (s.lights != null) {
	    lights.add(hkIndex, s.lights.get(index));
	}
	else {
	    lights.add(hkIndex, null);
	}	    

	if (fogs == null) {
	    fogs = new ArrayList(1);
	}
	if (s.fogs != null) {
	    fogs.add(hkIndex, s.fogs.get(index));
	}
	else {
	    fogs.add(hkIndex, null);
	}	    


	if (modelClips == null) {
	    modelClips = new ArrayList(1);
	}
	if (s.modelClips != null) {
	    modelClips.add(hkIndex, s.modelClips.get(index));
	}
	else {
	    modelClips.add(hkIndex, null);
	}	    


	if (altAppearances == null) {
	    altAppearances = new ArrayList(1);
	}
	if (s.altAppearances != null) {
	    altAppearances.add(hkIndex, s.altAppearances.get(index));
	}
	else {
	    altAppearances.add(hkIndex, null);
	}	    
    }

    
    void setNodeData(SetLiveState s) {
	
	// For inSharedGroup case.
	int i, j, len;	
	
	if (localToVworld == null) {
	    localToVworld = new Transform3D[s.keys.length][];
	    localToVworldIndex = new int[s.keys.length][];
	    localToVworldKeys = new HashKey[s.keys.length];
            cachedTargets = new CachedTargets[s.keys.length];
	    len=0;
	}
	else {

	    int newLen = localToVworld.length + s.keys.length;
	    
	    Transform3D newTList[][] = new Transform3D[newLen][];
	    HashKey newHList[] = new HashKey[newLen];
	    int newIndexList[][] = new int[newLen][];
            CachedTargets newTargets[] = new CachedTargets[newLen];
	    
	    len = localToVworld.length;

	    // Copy the existing data into the newly created data objects.
	    System.arraycopy(localToVworld, 0, newTList, 0, localToVworld.length);
	    System.arraycopy(localToVworldIndex, 0, newIndexList, 0,
			     localToVworldIndex.length);
	    System.arraycopy(localToVworldKeys, 0, newHList, 0,
			     localToVworldKeys.length);
            System.arraycopy(cachedTargets, 0, newTargets, 0,
                             cachedTargets.length);

	    localToVworld = newTList;
	    localToVworldIndex = newIndexList;
	    localToVworldKeys = newHList;
            cachedTargets = newTargets;
	}

	int[] hkIndex = new int[1];
	int hkIndexPlus1, blkSize;
	
        s.hashkeyIndex = new int[s.keys.length];

	// This should appear before super.setNodeData() if it exists
	s.parentBranchGroupPaths = branchGroupPaths;

	for(i=len, j=0; i<localToVworld.length; i++, j++) {

	    if(s.keys[j].equals(localToVworldKeys, hkIndex, 0, i)) {
		MasterControl.getCoreLogger().severe("Found matching hashKey in setNodeData.");
	    }
            s.hashkeyIndex[j] = hkIndex[0];

		
	    if(hkIndex[0] == i) { // Append to last.
		localToVworldKeys[i] = s.keys[j];
		localToVworld[i] = s.currentTransforms[j];
		localToVworldIndex[i] = s.currentTransformsIndex[j];
	    }
	    else { // Insert in between array elements.
		hkIndexPlus1 = hkIndex[0] + 1;
		blkSize = i - hkIndex[0];

		// Shift the later portion of array elements by one position.
		// This is the make room for the new data entry.
		System.arraycopy(localToVworldKeys, hkIndex[0], localToVworldKeys,
				 hkIndexPlus1, blkSize);
		System.arraycopy(localToVworld, hkIndex[0], localToVworld,
				 hkIndexPlus1, blkSize);
		System.arraycopy(localToVworldIndex, hkIndex[0], localToVworldIndex,
				 hkIndexPlus1, blkSize);
                System.arraycopy(cachedTargets, hkIndex[0], cachedTargets,
                                 hkIndexPlus1, blkSize);
		
		localToVworldKeys[hkIndex[0]] = s.keys[j];
		localToVworld[hkIndex[0]] = s.currentTransforms[j];
		localToVworldIndex[hkIndex[0]] = s.currentTransformsIndex[j];
	    }
	    
	    //	    System.err.println("SG: j = "+j+" hkIndex[0] = "+hkIndex[0]+" s.keys[j] = "+s.keys[j]);
	    // For now (1.2.1beta2) only. We cleanup setLive, and clearLive in
	    // next release.
	    setAuxData(s, j, hkIndex[0]);
	}

	// The SetLiveState need the reflect the new state of this SharedGroup.
	// The SetLiveState will get reset back in SetLive, after all children of this
	// node have been set live.
	s.localToVworld = localToVworld;
	s.localToVworldIndex = localToVworldIndex;
	s.localToVworldKeys = localToVworldKeys;
        s.orderedPaths = orderedPaths;
        s.switchStates = switchStates;

        // Note that s.childSwitchLinks is updated in super.setLive
        s.childTransformLinks = childTransformLinks;
        s.parentTransformLink = this;
        s.parentSwitchLink = this;
	s.viewLists = viewLists;
	s.lights = lights;
	s.fogs = fogs;
	s.altAppearances = altAppearances;
	s.modelClips = modelClips;
    }
    
    void setLive(SetLiveState s) {

	int i,j;
	Targets[] newTargets = null;
	
        // save setLiveState
	Transform3D savedLocalToVworld[][] = s.localToVworld;
	int savedLocalToVworldIndex[][] = s.localToVworldIndex;
	HashKey savedLocalToVworldKeys[] = s.localToVworldKeys;
        ArrayList savedOrderedPaths = s.orderedPaths;
	ArrayList savedViewList = s.viewLists;
	ArrayList savedLights = s.lights;
	ArrayList savedFogs = s.fogs;
	ArrayList savedMclips = s.modelClips;
	ArrayList savedAltApps = s.altAppearances;
	
	SharedGroupRetained savedLastSharedGroup = s.lastSharedGroup;
        Targets[] savedSwitchTargets = s.switchTargets;
        ArrayList savedSwitchStates = s.switchStates;
        ArrayList savedChildSwitchLinks = s.childSwitchLinks;
        GroupRetained savedParentSwitchLink = s.parentSwitchLink;
        ArrayList savedChildTransformLinks = s.childTransformLinks;
        GroupRetained savedParentTransformLink = s.parentTransformLink;
        int[] savedHashkeyIndex = s.hashkeyIndex;
	
        // update setLiveState for this node
        // Note that s.containsNodesList is updated in super.setLive
	s.lastSharedGroup = this;

        Targets[] savedTransformTargets = s.transformTargets;

        int numPaths = s.keys.length;
        newTargets = new Targets[numPaths];
        for(i=0; i<numPaths; i++) {
	    if (s.transformLevels[i] >= 0) {
                newTargets[i] = new Targets();
	    } else {
                newTargets[i] = null;
	    } 
        }
	s.transformTargets = newTargets;

        super.setLive(s);

        int hkIndex;
        for(i=0; i<numPaths; i++) {
            if (s.transformTargets[i] != null) {
		hkIndex = s.hashkeyIndex[i];
                cachedTargets[hkIndex] = s.transformTargets[i].snapShotInit();
            }
        }
        // Assign data in cachedTargets to j3dCTs.
        j3dCTs = new CachedTargets[cachedTargets.length];
        copyCachedTargets(TargetsInterface.TRANSFORM_TARGETS, j3dCTs);

        computeTargetThreads(TargetsInterface.TRANSFORM_TARGETS, cachedTargets);


        // restore setLiveState
	s.localToVworld = savedLocalToVworld;
	s.localToVworldIndex = savedLocalToVworldIndex;
	s.localToVworldKeys = savedLocalToVworldKeys;
        s.orderedPaths = savedOrderedPaths;
	s.viewLists = savedViewList;

	s.lights = savedLights;
	s.fogs = savedFogs;
	s.modelClips = savedMclips;
	s.altAppearances = savedAltApps;
	
	s.lastSharedGroup = savedLastSharedGroup;
        s.switchTargets = savedSwitchTargets;
        s.switchStates = savedSwitchStates;

        s.childSwitchLinks = savedChildSwitchLinks;
        s.parentSwitchLink = savedParentSwitchLink;
        s.childTransformLinks = savedChildTransformLinks;
        s.parentTransformLink = savedParentTransformLink;

        s.transformTargets = savedTransformTargets;
        s.hashkeyIndex = savedHashkeyIndex;
/*
// XXXX : port this
        for (int i=0; i < children.size(); i++) {
            if ((childContains[i][0] & ILLEGAL_LEAF_MASK) != 0) {
                throw new IllegalSharingException(J3dI18N.getString("SharedGroupRetained0"));            }
        }
*/
    }


    /**
     * remove the localToVworld transform for a node.
     */
    void removeNodeData(SetLiveState s) {
	
	int numChildren = children.size();
        ArrayList switchTargets;
	int i,j;

        if (refCount <= 0) {
	    localToVworld = null;
	    localToVworldIndex = null;
	    localToVworldKeys = null;
	    // restore to default and avoid calling clear() 
	    // that may clear parent reference branchGroupPaths
	    // Note that this function did not invoke super.removeNodeData()
	    branchGroupPaths = new ArrayList(1);
            orderedPaths = null;
            switchStates = null;
            cachedTargets = null;
            targetThreads = 0;
	    lights.clear();
	    fogs.clear();
	    modelClips.clear();
	    altAppearances.clear();
	}
	else {
	    int index, len;
	    
	    // Remove the localToVworld key 
	    int newLen = localToVworld.length - s.keys.length;
	
	    Transform3D[][] newTList = new Transform3D[newLen][];
	    HashKey[] newHList = new HashKey[newLen];
	    Transform3D newChildTList[][] = null;
	    int[][] newIndexList = new int[newLen][];
            CachedTargets[] newTargets = new CachedTargets[newLen];

	    int[] tempIndex = new int[s.keys.length];
	    int curStart =0, newStart =0;
	    boolean found = false;
	
	    for(i=0;i<s.keys.length;i++) {
		index = s.keys[i].equals(localToVworldKeys, 0, localToVworldKeys.length);

		tempIndex[i] = index;
	    
		if(index >= 0) {
		    found = true;		
		    if(index == curStart) {
			curStart++;
		    }
		    else {
			len = index - curStart;
			System.arraycopy(localToVworld, curStart, newTList, newStart, len);
			System.arraycopy(localToVworldIndex, curStart, newIndexList,
					 newStart, len);
			System.arraycopy(localToVworldKeys, curStart, newHList, newStart, len);
                        System.arraycopy(cachedTargets, curStart, newTargets,
                                         newStart, len);
		    
			curStart = index+1;
			newStart = newStart + len;
		    }
		}
		else {
		    found = false;
		    MasterControl.getCoreLogger().severe("Can't Find matching hashKey in SG.removeNodeData.");
		}
	    }
	
	    if((found == true) && (curStart < localToVworld.length)) {
		len = localToVworld.length - curStart;
		System.arraycopy(localToVworld, curStart, newTList, newStart, len);
		System.arraycopy(localToVworldIndex, curStart, newIndexList,
				 newStart, len);
		System.arraycopy(localToVworldKeys, curStart, newHList, newStart, len);
                System.arraycopy(cachedTargets, curStart, newTargets,
                                 newStart, len);
	    }

	    // Must be in reverse, to preserve right indexing.
	    for (i = tempIndex.length-1; i >= 0 ; i--) {
		if(tempIndex[i] >= 0) {
		    branchGroupPaths.remove(tempIndex[i]);
                    orderedPaths.remove(tempIndex[i]);
                    switchStates.remove(tempIndex[i]);
		    lights.remove(tempIndex[i]);
		    fogs.remove(tempIndex[i]);
		    modelClips.remove(tempIndex[i]);
		    altAppearances.remove(tempIndex[i]);
		}
	    }

	    localToVworld = newTList;
	    localToVworldIndex = newIndexList;
	    localToVworldKeys = newHList;
            cachedTargets = newTargets;
	}
	s.localToVworld = localToVworld;
	s.localToVworldIndex = localToVworldIndex;
	s.localToVworldKeys = localToVworldKeys;
	s.orderedPaths = orderedPaths;
	s.switchStates = switchStates;
	s.viewLists = viewLists;
	s.lights = lights;
	s.fogs = fogs;
	s.modelClips = modelClips;
	s.altAppearances = altAppearances;
    }