rendermolecule.java

JAVA3D矩陈的相关类

				useAlpha) {
				renderBin.addDirtyReferenceGeometry(geo);
			    }
			}
		    }
		}
		addRAs = addRAs.nextAdd;
		renderAtom.nextAdd = null;
		renderAtom.prevAdd = null;
		if (renderAtom.isOriented()) {
		    renderBin.orientedRAs.add(renderAtom);

		}
		// If transparent and not in bg geometry and is depth sorted transparency
		if (!isOpaqueOrInOG && (textureBin.environmentSet.lightBin.geometryBackground == null)&&
		    (renderBin.transpSortMode == View.TRANSPARENCY_SORT_GEOMETRY)) {
		    GeometryRetained geo = null;
		    int k = 0;
		    while (geo == null && k < renderAtom.rListInfo.length) {
			geo = renderAtom.rListInfo[k].geometry();
			k++;
		    }
		    if (geo != null) {
			if (renderAtom.parentTInfo != null && renderAtom.parentTInfo[k-1] != null) {
			    renderBin.updateTransparentInfo(renderAtom);
			}
			// Newly added renderAtom
			else {
			    renderBin.addTransparentObject(renderAtom);
			}
		    }
		    // Moving within the renderBin

		}
	    }

	    if ((primaryMoleculeType &DLIST_MOLECULE) != 0 && primaryChanged) {

		// If a renderAtom is added to the display list
		// structure then add this to the dirty list of rm
		// for which the display list needs to be recreated
		renderBin.addDirtyRenderMolecule(this);
		vwcBounds.set(null);
		r = primaryRenderAtomList;
		while (r != null) {
		    vwcBounds.combine(r.renderAtom.localeVwcBounds);
		    r = r.next;
		}
		primaryChanged = false;
	    }


	    if ((onUpdateList & LOCALE_CHANGED) != 0) {
		handleLocaleChange();
	    }

	    if (locale != renderBin.locale) {
		translate();
	    }
	}
	else {
	    // The flag LOCALE_CHANGED only gets sets when there is a new additon
	    // There are cases when RM updateObject() get called (due to addition
	    // in renderBin - see processTransformChanged()), we need to
	    // evaluate locale change for this  case as well
	    if (renderBin.localeChanged) {
		handleLocaleChange();
	    }

	    if (locale != renderBin.locale) {
		translate();
	    }

            if ((onUpdateList & UPDATE_BACKGROUND_TRANSFORM) != 0) {
                i = localToVworldIndex[NodeRetained.LAST_LOCAL_TO_VWORLD];
                localeLocalToVworld[i].getRotation(infLocalToVworld[i]);
            }
	    
	    // No new renderAtoms were added, but need to	
	    // recompute vwcBounds in response to xform change
	    if ((onUpdateList & BOUNDS_RECOMPUTE_UPDATE) != 0) {
		vwcBounds.set(null);
		r = primaryRenderAtomList;
		while (r != null) {
		    vwcBounds.combine(r.renderAtom.localeVwcBounds);
		    r = r.next;
		}
	    }	    
	}

	// Clear all bits except the IN_DIRTY_LIST
	onUpdateList &= IN_DIRTY_RENDERMOLECULE_LIST;

	numEditingRenderAtoms = numRenderAtoms;
    }

    boolean canBeInDisplayList(GeometryRetained geo, GeometryAtom ga) {
        if (ga.source.sourceNode instanceof MorphRetained) {
            return false;
        }

	return geo.canBeInDisplayList(ga.alphaEditable);
    }

    // If dlist will be altered due to alpha or ignoreVertexColors, then don't
    // put in a separate dlist that can be shared ...
    final boolean geoNotAltered(GeometryArrayRetained geo) {
	return !(((geo.vertexFormat & GeometryArray.COLOR) != 0) && 
		 (textureBin.attributeBin.ignoreVertexColors || useAlpha));
    }
    
    int evalRinfoGroupType(RenderAtomListInfo r) {
	int groupType = 0;

	GeometryRetained geo = r.geometry();
	if (geo == null)
	    return groupType;

	if ((primaryMoleculeType & (COMPRESSED_MOLECULE |
				    RASTER_MOLECULE     |
				    TEXT3D_MOLECULE	|	
				    ORIENTEDSHAPE3D_MOLECULE)) != 0) {
	    groupType = RenderAtom.OTHER;
	}
	else if (canBeInDisplayList(geo, r.renderAtom.geometryAtom)) {
	    // if geometry is under share group we immediate set the
	    // dlistID to something other than -1
	    if ( !((GeometryArrayRetained)geo).isShared ||
		// if we do a compiled and push the transform down to
		// Geometry, we can't share the displayList
		(r.renderAtom.geometryAtom.source.staticTransform != null)) {
		// If the molecule is already defined to be SEPARATE_DLIST_PER_RINFO_MOLECULE
		// continue adding in that mode even if it was switched back to
		// no depth sorted mode
		//		System.err.println("isOpaqueOrInOG ="+isOpaqueOrInOG+" primaryMoleculeType ="+primaryMoleculeType+" renderBin.transpSortMode ="+renderBin.transpSortMode);
		if (primaryMoleculeType == SEPARATE_DLIST_PER_RINFO_MOLECULE) {
		    groupType = RenderAtom.SEPARATE_DLIST_PER_RINFO;
		}
		else {
		    if (isOpaqueOrInOG ||
			renderBin.transpSortMode == View.TRANSPARENCY_SORT_NONE) {
			groupType = RenderAtom.DLIST;
		    }
		    else {
			groupType = RenderAtom.SEPARATE_DLIST_PER_RINFO;
		    }
		}

	    } else if (geoNotAltered((GeometryArrayRetained)r.geometry()) ) {
		groupType = RenderAtom.SEPARATE_DLIST_PER_GEO;
	    }
	    else {
		groupType = RenderAtom.VARRAY;
	    }
	}
	else {
	    groupType = RenderAtom.VARRAY;
	}
	return groupType;
    }

    /**
     * Adds the given RenderAtom to this RenderMolecule.
     */
    void addRenderAtom(RenderAtom renderAtom, RenderBin rb) {
	int i, n;
	RenderAtomListInfo r;
	int index;

	renderAtom.envSet = textureBin.environmentSet;
	renderAtom.renderMolecule = this;
	renderAtom.dirtyMask &= ~RenderAtom.NEED_SEPARATE_LOCALE_VWC_BOUNDS;

        AppearanceRetained raApp = renderAtom.geometryAtom.source.appearance;

	MaterialRetained mat = (raApp == null)? null : raApp.material;
        if (!soleUser && material != mat) {
	    // no longer sole user
            material = definingMaterial;        
        }

        if ((geometryType & SURFACE) != 0) {
	    PolygonAttributesRetained pgAttrs = 
		(raApp == null)? null : raApp.polygonAttributes;
            if (!soleUser && polygonAttributes != pgAttrs) {
	        // no longer sole user 
                polygonAttributes = definingPolygonAttributes; 
            }

        } 
	if ((geometryType & LINE) != 0) {
	    LineAttributesRetained lnAttrs = 
		(raApp == null)? null : raApp.lineAttributes;
            if (!soleUser && lineAttributes != lnAttrs) {
	        // no longer sole user 
                lineAttributes = definingLineAttributes;	
            }

        }  
	if ((geometryType & POINT) != 0) {
	    PointAttributesRetained pnAttrs = 
		(raApp == null)? null : raApp.pointAttributes;
	    if (!soleUser && pointAttributes != pnAttrs) {
	        // no longer sole user 
                pointAttributes = definingPointAttributes; 	
            }
        }

	ColoringAttributesRetained coAttrs = 
	    (raApp == null)? null : raApp.coloringAttributes;
        if (!soleUser && coloringAttributes != coAttrs) {
	    // no longer sole user 
            coloringAttributes = definingColoringAttributes; 
        }

	TransparencyAttributesRetained trAttrs = 
	    (raApp == null)? null : raApp.transparencyAttributes;
        if (!soleUser && transparency != trAttrs) {
	    // no longer sole user 
            transparency = definingTransparency;    	
        }

	

	// If the renderAtom is being inserted first time, then evaluate
	// the groupType to determine if need separate localeVwcBounds
	if (!renderAtom.inRenderBin()) {
	    for (i = 0; i < renderAtom.rListInfo.length; i++) {
		if (renderAtom.rListInfo[i].geometry() == null)
		    continue;
		int groupType = evalRinfoGroupType(renderAtom.rListInfo[i]);
		if (groupType != RenderAtom.DLIST) {
		    renderAtom.dirtyMask |= RenderAtom.NEED_SEPARATE_LOCALE_VWC_BOUNDS;
		}
	    }
	}
	if (renderAtom.removed == this) {
	    // Remove the renderAtom from the list of removeRAs
	    // If this is at the head of the list
	    if (renderAtom == removeRAs) {
		removeRAs = renderAtom.nextRemove;
		if (removeRAs != null)
		    removeRAs.prevRemove = null;
		renderAtom.nextRemove = null;
		renderAtom.prevRemove = null;
	    }
	    // Somewhere in the middle
	    else {
		renderAtom.prevRemove.nextRemove = renderAtom.nextRemove;
		if (renderAtom.nextRemove != null)
		    renderAtom.nextRemove.prevRemove = renderAtom.prevRemove;
		renderAtom.nextRemove = null;
		renderAtom.prevRemove = null;
	    }

	    renderAtom.removed = null;
	    // Redo any dlist etc, because it has been added
	    for ( i = 0; i < renderAtom.rListInfo.length; i++) {
		if (renderAtom.rListInfo[i].geometry() == null)
		    continue;
		if ((renderAtom.rListInfo[i].groupType & RenderAtom.DLIST) != 0)
		    renderBin.addDirtyRenderMolecule(this);
		else if ((renderAtom.rListInfo[i].groupType & RenderAtom.SEPARATE_DLIST_PER_RINFO) != 0) {
		    renderBin.addDlistPerRinfo.add(renderAtom.rListInfo[i]);
		}
		else if ((renderAtom.rListInfo[i].groupType & RenderAtom.SEPARATE_DLIST_PER_GEO) != 0)
		    renderBin.addGeometryDlist(renderAtom.rListInfo[i]);

	    }
	    if (removeRAs == null) 
		rb.removeRenderAtomInRMList.remove(this);
	}
	else {
	    // Add this renderAtom to the addList
	    if (addRAs == null) {
		addRAs = renderAtom;
		renderAtom.nextAdd = null;
		renderAtom.prevAdd = null;
	    }
	    else {
		renderAtom.nextAdd = addRAs;
		renderAtom.prevAdd = null;
		addRAs.prevAdd = renderAtom;
		addRAs = renderAtom;
	    }
	    renderAtom.added = this;
	    if (onUpdateList == 0)
		rb.objUpdateList.add(this);
	    onUpdateList |= NEW_RENDERATOMS_UPDATE;

	}
	if (renderBin.localeChanged && !doInfinite) {
	    if (onUpdateList == 0)
		rb.objUpdateList.add(this);
	    onUpdateList |= LOCALE_CHANGED;
	}

	// inform the texture bin that this render molecule is no longer
	// in zombie state

	if (numEditingRenderAtoms == 0) {
	    textureBin.incrActiveRenderMolecule();
	}
	numEditingRenderAtoms++;
    }

    /**
     * Removes the given RenderAtom from this RenderMolecule.
     */
    void removeRenderAtom(RenderAtom r) {
	int index;

	r.renderMolecule = null; 
	if (r.added == this) {
	    //Remove this renderAtom from the addRAs list

	    // If this is at the head of the list
	    if (r == addRAs) {
		addRAs = r.nextAdd;
		if (addRAs != null)
		    addRAs.prevAdd = null;
		r.nextAdd = null;
		r.prevAdd = null;
	    }
	    // Somewhere in the middle
	    else {
		r.prevAdd.nextAdd = r.nextAdd;
		if (r.nextAdd != null)
		    r.nextAdd.prevAdd = r.prevAdd;
		r.nextAdd = null;
		r.prevAdd = null;
	    }
		
	    r.added = null;
	    r.envSet = null;
	    // If the number of renderAtoms is zero, and it is on the
	    // update list for adding new renderatroms only (not for
	    // bounds update), then remove this rm from the update list

	    // Might be expensive to remove this entry from the renderBin
	    // objUpdateList, just let it call the renderMolecule
	    /*
	      if (addRAs == null) { 
	      if (onUpdateList == NEW_RENDERATOMS_UPDATE){
	      renderBin.objUpdateList.remove(renderBin.objUpdateList.indexOf(this));
	      }
	      onUpdateList &= ~NEW_RENDERATOMS_UPDATE;
	      }
	    */
	    
	}
	else {
	    // Add this renderAtom to the remove list
	    if (removeRAs == null) {
		removeRAs = r;
		r.nextRemove = null;
		r.prevRemove = null;
	    }
	    else {
		r.nextRemove = removeRAs;
		r.prevRemove = null;
		removeRAs.prevRemove = r;
		removeRAs = r;
	    }
	    r.removed = this;
	}

	// Add it to the removeRenderAtom List , in case the renderMolecule
	// needs to be removed
	if (!renderBin.removeRenderAtomInRMList.contains(this)) {
	    renderBin.removeRenderAtomInRMList.add(this);
	}

	// decrement the number of editing render atoms in this render molecule
	numEditingRenderAtoms--;

	// if there is no more editing render atoms, inform the texture bin
	// that this render molecule is going to zombie state

	if (numEditingRenderAtoms == 0) {
	    textureBin.decrActiveRenderMolecule();
	}
    }

    /**
     * Recalculates the vwcBounds for a RenderMolecule
     */
    void recalcBounds() {
	RenderAtomListInfo ra;

	if (primaryRenderMethod ==
	    VirtualUniverse.mc.getDisplayListRenderMethod()) {
	    vwcBounds.set(null);
	    ra = primaryRenderAtomList;
	    while (ra != null) {
		vwcBounds.combine(ra.renderAtom.localeVwcBounds);
		ra = ra.next;
	    }
	}
    }

    void evalAlphaUsage(RenderingAttributesRetained renderAttrs,
			TextureUnitStateRetained[] texUnits) {
        boolean alphaBlend, alphaTest, textureBlend = false;

        alphaBlend =
            definingTransparency != null &&
            definingTransparency.transparencyMode !=
	    TransparencyAttributes.NONE &&
	    (VirtualUniverse.mc.isD3D() ||
	     !VirtualUniverse.mc.isD3D() &&
	     definingTransparency.transparencyMode !=
	     TransparencyAttributes.SCREEN_DOOR);

	
	if (texUnits != null) {
	    for (int i = 0; 
		 textureBlend == false && i < texUnits.length;
		 i++) {
		if (texUnits[i] != null &&
		    texUnits[i].texAttrs != null) {
		    textureBlend = textureBlend || 
            		(texUnits[i].texAttrs.textureMode ==
			 TextureAttributes.BLEND);
		}
	    }
	}

        alphaTest =
            renderAttrs != null && renderAttrs.alphaTestFunction != RenderingAttributes.ALWAYS;
	
	boolean oldUseAlpha = useAlpha;