renderingenvironmentstructure.java

JAVA3D矩陈的相关类

/*
 * $RCSfile: RenderingEnvironmentStructure.java,v $
 *
 * Copyright (c) 2007 Sun Microsystems, Inc. All rights reserved.
 *
 * Use is subject to license terms.
 *
 * $Revision: 1.6 $
 * $Date: 2007/04/12 17:34:06 $
 * $State: Exp $
 */

package javax.media.j3d;

import java.util.*;
import javax.vecmath.*;

/**
 * A rendering environment structure is an object that organizes lights,
 * fogs, backgrounds, clips, and model clips.
 */

class RenderingEnvironmentStructure extends J3dStructure implements ObjectUpdate {
    /**
     * The list of light nodes
     */
    ArrayList nonViewScopedLights = new ArrayList();
    HashMap viewScopedLights = new HashMap();
    int numberOfLights = 0;

    /**
     * The list of fog nodes
     */
    ArrayList nonViewScopedFogs = new ArrayList();
    HashMap viewScopedFogs = new HashMap();
    int numberOfFogs = 0;

    /**
     * The list of alternate app nodes
     */
    ArrayList nonViewScopedAltAppearances = new ArrayList();
    HashMap viewScopedAltAppearances = new HashMap();
    int numberOfAltApps = 0;

    /**
     * The list of model clip nodes
     */
    ArrayList nonViewScopedModelClips = new ArrayList();
    HashMap viewScopedModelClips = new HashMap();
    int numberOfModelClips = 0;

    /**
     * The list of background nodes
     */
    ArrayList nonViewScopedBackgrounds = new ArrayList();
    HashMap viewScopedBackgrounds = new HashMap();
    int numberOfBgs = 0;

    /**
     * The list of clip nodes
     */
    ArrayList nonViewScopedClips = new ArrayList();
    HashMap viewScopedClips = new HashMap();
    int numberOfClips = 0;

    // For closest Background selection
    BackgroundRetained[] intersectedBacks = new BackgroundRetained[1];


    // For closest Clip selection
    ClipRetained[] intersectedClips = new ClipRetained[1];

    // For closest Background, Clip, Fog selection
    Bounds[] intersectedBounds = new Bounds[1];

    Transform3D localeXform = new Transform3D();
    Vector3d localeTranslation = new Vector3d();
    Bounds localeBounds = null;

    // For closest Fog selection
    FogRetained[] intersectedFogs = new FogRetained[1];

    // for closest alternate appearance selection
    AlternateAppearanceRetained[] intersectedAltApps = new AlternateAppearanceRetained[1];

    // For closest ModelClip selection
    ModelClipRetained[] intersectedModelClips = new ModelClipRetained[1];


    // Back clip distance in V world
    double backClipDistance;

   // ArrayList of leafRetained object whose mirrorObjects
    // should be updated
    ArrayList objList = new ArrayList();

    // ArrayList of leafRetained object whose boundingleaf xform
    // should be updated
    ArrayList xformChangeList = new ArrayList();


    // freelist management of objects
    ArrayList objFreeList = new ArrayList();

    LightRetained[] retlights = new LightRetained[5];

    // variables used for processing transform messages
    boolean transformMsg = false;
    UpdateTargets targets = null;
    ArrayList blUsers = null;

    Integer ogInsert = new Integer(J3dMessage.ORDERED_GROUP_INSERTED);
    Integer ogRemove = new Integer(J3dMessage.ORDERED_GROUP_REMOVED);

    // Used to lock the intersectedBounds {used by fog, mclip etc}
    // Can used intersectedBounds itself, since this may be realloced
    Object lockObj = new Object();

    /**
     * Constructs a RenderingEnvironmentStructure object in the specified
     * virtual universe.
     */
    RenderingEnvironmentStructure(VirtualUniverse u) {
	super(u, J3dThread.UPDATE_RENDERING_ENVIRONMENT);
    }


    /**
     * Returns a object array of length 5 to save the 5 objects in the message list.
     */
    Object[] getObjectArray() {
	Object[] objs;
	int size;

	size = objFreeList.size();
	if (size == 0) {
	    objs = new Object[5];
	}
	else {
	    objs = (Object[]) objFreeList.get(size - 1);
	    objFreeList.remove(size -1);
	}
	return objs;
    }
    
    void addObjArrayToFreeList(Object[] objs) {
	int i;

	for (i = 0; i < objs.length; i++)
	    objs[i] = null;
	
	objFreeList.add(objs);
    }
    


    public void updateObject() {
	int i, j;
	Object[] args;
	LeafRetained leaf;
	Boolean masks;
	int size;

	size = objList.size();
	for (i = 0; i < size; i++) {
	    args = (Object[])objList.get(i);
	    leaf = (LeafRetained)args[0];
	    leaf.updateMirrorObject(args);
	    addObjArrayToFreeList(args);
	}
	objList.clear();

	size = xformChangeList.size();
	for (i = 0; i < size; i++) {
	    leaf = (LeafRetained)xformChangeList.get(i);
	    leaf.updateTransformChange();
	}
	xformChangeList.clear();

    }

    void processMessages(long referenceTime) {
	J3dMessage[] messages = getMessages(referenceTime);;
	J3dMessage m;
	int nMsg = getNumMessage();

	if (nMsg <= 0) {
	    return;
	}

	for (int i=0; i < nMsg; i++) {
	    m = messages[i];

	    switch (m.type) {
	    case J3dMessage.INSERT_NODES:
		insertNodes(m);
		break;
	    case J3dMessage.REMOVE_NODES:
		removeNodes(m);
		break;
	    case J3dMessage.LIGHT_CHANGED:
		updateLight((Object[])m.args);
		break;
	    case J3dMessage.BOUNDINGLEAF_CHANGED:
		updateBoundingLeaf((Object[])m.args);
		break;
	    case J3dMessage.FOG_CHANGED:
		updateFog((Object[])m.args);
		break;
	    case J3dMessage.ALTERNATEAPPEARANCE_CHANGED:
		updateAltApp((Object[])m.args);
		break;
	    case J3dMessage.SHAPE3D_CHANGED:
		updateShape3D((Object[])m.args);
		break;
	    case J3dMessage.ORIENTEDSHAPE3D_CHANGED:
		updateOrientedShape3D((Object[])m.args);
		break;
	    case J3dMessage.MORPH_CHANGED:
		updateMorph((Object[])m.args);
		break;
	    case J3dMessage.TRANSFORM_CHANGED:
		transformMsg = true;
		break;
	    case J3dMessage.SWITCH_CHANGED:
		processSwitchChanged(m);
		// may need to process dirty switched-on transform
		if (universe.transformStructure.getLazyUpdate()) {
		    transformMsg = true;
		}
		break;
	    case J3dMessage.MODELCLIP_CHANGED:
		updateModelClip((Object[])m.args);
		break;
	    case J3dMessage.BACKGROUND_CHANGED:
		updateBackground((Object[])m.args);
		break;
	    case J3dMessage.CLIP_CHANGED:
		updateClip((Object[])m.args);
		break;
	    case J3dMessage.ORDERED_GROUP_INSERTED:
		updateOrderedGroupInserted(m);
		break;
	    case J3dMessage.ORDERED_GROUP_REMOVED:
		updateOrderedGroupsRemoved(m);
		break;
	    case J3dMessage.VIEWSPECIFICGROUP_CHANGED:
		updateViewSpecificGroupChanged(m);
		break;
	    case J3dMessage.VIEWSPECIFICGROUP_INIT:
		initViewSpecificInfo(m);
		break;
	    case J3dMessage.VIEWSPECIFICGROUP_CLEAR:
		clearViewSpecificInfo(m);
		break;
	    }
	    m.decRefcount();
	}
	 
	if (transformMsg) {
	    updateTransformChange();
	    transformMsg = false;
	}
	
	VirtualUniverse.mc.addMirrorObject(this);
	
	Arrays.fill(messages, 0, nMsg, null);
    }

    void updateOrderedGroupInserted(J3dMessage m) {
	Object[] ogList = (Object[])m.args[0];
	Object[] ogChildIdList = (Object[])m.args[1];
	Object[] ogOrderedIdList = (Object[])m.args[2];
	OrderedGroupRetained og;
	int index;
	Object[] objs;

	for (int n = 0; n < ogList.length; n++) {
	    og = (OrderedGroupRetained)ogList[n];
	    og.updateChildIdTableInserted(((Integer) ogChildIdList[n]).intValue(),
					  ((Integer) ogOrderedIdList[n]).intValue()); 
	    og.incrChildCount();
	}
    }

    void updateOrderedGroupsRemoved(J3dMessage m) {
	Object[] ogList = (Object[])m.args[0];
	Object[] ogChildIdList = (Object[])m.args[1];
	OrderedGroupRetained og;
	int index;
	Object[] objs;
	
	for (int n = 0; n < ogList.length; n++) {
	    og = (OrderedGroupRetained)ogList[n];
	    og.updateChildIdTableRemoved(((Integer) ogChildIdList[n]).intValue());
	    og.decrChildCount();
	}

    }
    /**
     * This processes a switch change.
     */
    void processSwitchChanged(J3dMessage m) {
        int i;
        UnorderList arrList;
        int size;
        Object[] nodes, nodesArr;
        LeafRetained leaf;

        UpdateTargets targets = (UpdateTargets)m.args[0];

        arrList = targets.targetList[Targets.BLN_TARGETS];
        if (arrList != null) {
            BoundingLeafRetained mbleaf;
            Object[] objArr = (Object[])m.args[1];
            Object[] obj;
            size = arrList.size();
            nodesArr = arrList.toArray(false);

            for (int h=0; h<size; h++) {
                nodes = (Object[])nodesArr[h];
                obj = (Object[])objArr[h];

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

                    Object[] users = (Object[])obj[i];
                    mbleaf = (BoundingLeafRetained)nodes[i];

                    //mbleaf.switchState.updateCurrentSwitchOn();
                    for (int j = 0; j < users.length; j++) {
                        leaf = (LeafRetained)users[j];
                        if (leaf instanceof FogRetained ||
                            leaf instanceof LightRetained ||
                            leaf instanceof ModelClipRetained ||
                            leaf instanceof ClipRetained ||
                            leaf instanceof AlternateAppearanceRetained ||
                            leaf instanceof BackgroundRetained) {
                            leaf.updateBoundingLeaf();
                        }
                    }
                }
            }
        }
    }

    void insertNodes(J3dMessage m) {
	Object[] nodes = (Object[])m.args[0];
	ArrayList viewScopedNodes = (ArrayList)m.args[3];
	ArrayList scopedNodesViewList = (ArrayList)m.args[4];
	Object n;
	int i;
	GeometryAtom ga;
	int num;
	LightRetained lt;
	FogRetained fg;
	ModelClipRetained mc;
	ArrayList list;	

	for (i=0; i<nodes.length; i++) {
	    n = nodes[i];
	    if (n instanceof LightRetained) {
                lt = (LightRetained)n;
		numberOfLights++;

		// If this particulat light is not scoped, added it
		// to all the views
		if (lt.inBackgroundGroup)
		    lt.geometryBackground.lights.add(lt);
		else
		    nonViewScopedLights.add(lt);

	    } else if (n instanceof FogRetained) {
                fg = (FogRetained)n;
		numberOfFogs++;
		// If the fog is scoped to a view , then ..

		if (fg.inBackgroundGroup) {
		    fg.geometryBackground.fogs.add(fg);
		} else {
		    nonViewScopedFogs.add(fg);
		}

	    
	    } else if (n instanceof AlternateAppearanceRetained) {
		AlternateAppearanceRetained altApp = (AlternateAppearanceRetained)n;
		
		numberOfAltApps++;

		nonViewScopedAltAppearances.add(n);
	    
	    } else if (n instanceof BackgroundRetained) {
		BackgroundRetained bg = (BackgroundRetained)n;
		numberOfBgs++;

		nonViewScopedBackgrounds.add(n);

	    } else if (n instanceof ClipRetained) {
		ClipRetained cl = (ClipRetained)n;
		numberOfClips++;

		nonViewScopedClips.add(n);

	    } else if (n instanceof ModelClipRetained) {
		mc = (ModelClipRetained)n;
		numberOfModelClips++;

		nonViewScopedModelClips.add(n);

	    } 

	}


	if (viewScopedNodes != null) {
	    int size = viewScopedNodes.size();
	    int vlsize;


	    for (i = 0; i < size; i++) {
		n = (NodeRetained)viewScopedNodes.get(i);
		ArrayList vl = (ArrayList) scopedNodesViewList.get(i);
		if (n instanceof LightRetained) {
		    ((LightRetained)n).isViewScoped = true;
		    numberOfLights++;
		    vlsize = vl.size();
		    for (int k = 0; k < vlsize; k++) {
			View view = (View)vl.get(k);
			if ((list = (ArrayList)viewScopedLights.get(view)) == null) {
			    list = new ArrayList();
			    viewScopedLights.put(view, list);
			}
			list.add(n);
		    }
		} else if (n instanceof FogRetained) {
		    ((FogRetained)n).isViewScoped = true;
		    numberOfFogs++;
		    vlsize = vl.size();
		    for (int k = 0; k < vlsize; k++) {
			View view = (View)vl.get(k);