import com.bulletphysics.dynamics.DynamicsWorld;

import java.awt.*;
import java.util.Vector;

import javax.media.j3d.Transform3D;
import javax.media.opengl.GL;
import javax.vecmath.Vector3d;

import javax.imageio.ImageIO;
import java.awt.image.*;

import //weka.core.
        matrix.Matrix;

import java.util.UUID;

//import net.sourceforge.sizeof.SizeOf;
public class Object3D extends Vector<Object3D> implements java.io.Serializable, iSendInfo //, aurelienribon.tweenengine.TweenAccessor<Object3D>
{
    //static final long serialVersionUID = -607422624994562685L;
    static final long serialVersionUID = 5022536242724664900L;
    
    // Use GetUUID for backward compatibility with null.
    private UUID uuid = UUID.randomUUID();
    
    // TEMPORARY for versions. No need to be transient.
    mocap.reader.BVHReader.BVHResult savebvh;
    Object3D saveskeleton;
    
    // FileObject
    Object3D savefilecontent;
    //
    
    String skyboxname;
    String skyboxext;
    
    Object3D[] versionlist;
    int versionindex = -1;    
        
    java.util.Hashtable<java.util.UUID, Object3D> versiontable; // = new java.util.Hashtable<java.util.UUID, Object3D>();
    
    ScriptNode scriptnode;

    void deepCopyNode(Object3D other)
    {
        other.skyboxname = skyboxname;
        other.skyboxext = skyboxext;
        
        if (toParent != null)
        {
            other.toParent = LA.newMatrix();
            other.fromParent = LA.newMatrix();
            LA.matCopy(toParent, other.toParent);
            LA.matCopy(fromParent, other.fromParent);
            if (toParentMarked != null)
            {
                other.toParentMarked = LA.newMatrix();
                other.fromParentMarked = LA.newMatrix();
                LA.matCopy(toParentMarked, other.toParentMarked);
                LA.matCopy(fromParentMarked, other.fromParentMarked);
            }
        }
        else
        {
            if (other.toParent == null)
//                assert(other.toParent == null);
//                new Exception().printStackTrace();
                System.err.println("null parent: " + other);
        }
        
        /*
        double ident[][] = LA.newMatrix();
        if (bRep == null)
        other.bRep = null;
        else
        other.bRep = new BoundaryRep(bRep, ident);
         */
        // Really new...
        //other.editWindow = null;
        if (name == null)
            other.name = null;
        else
            other.name = new String(name);

        if (material != null)
        {
            other.material = new cMaterial(material);
        } else
        {
            other.material = null;
        }

        other.GetTextures().name = GetTextures().name;
        
        CopyExtraMaterial(other);
        
        other.touched = touched;
        other.softtouched = softtouched;
        
        other.random = random;
        other.link2master = link2master;
        other.transformcount = transformcount;
        other.marked = marked;
        other.skip = skip;
        other.count = count;
        other.flipV = flipV;
        other.live = live;
        other.rewind = rewind;
        other.hide = hide;
        other.texres = texres;
        other.speedup = speedup;
        other.height = height;
        other.depth = depth;
    }

    int VersionCount()
    {
        int count = 0;
        
        if (versionlist != null)
            for (int i = versionlist.length; --i >= 0;)
            {
                if (versionlist[i] != null)
                    count++;
            }
        
        return count;
    }
    
        void InitOthers()
        {
                if (projectedVertices == null || projectedVertices.length <= 2)
                {
                    projectedVertices = new Object3D.cVector2[3];
                }
                for (int i = 0; i < 3; i++)
                {
                    projectedVertices[i] = new cVector2(); // Others
                }
                projectedVertices[0].x = 100; // bump
                projectedVertices[1].y = 1000; // punchthrough. only for png
        }

    void MinMax(cVector minima, cVector maxima)
    {
        for (int xyz = 0; xyz < 3; xyz++)
        {
            if (min.get(xyz) < minima.get(xyz))
            {
                minima.set(xyz, min.get(xyz));
            }
            if (max.get(xyz) > maxima.get(xyz))
            {
                maxima.set(xyz, max.get(xyz));
            }
        }
    }
    
    void WriteTo(java.io.Writer writer) throws Exception
    {
    }
    
    float GetGround(cVector floor)
    {
        if (blockloop)
            return 0;
        
        if (fromParent != null)
        {
            LA.xformPos(floor, fromParent, floor);
        }
        
        float maxheight = Float.NEGATIVE_INFINITY;
        
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i);
            if (child == null)
                continue;
            blockloop = true;
            float g = child.GetGround(new cVector(floor));
            if (g != Float.NEGATIVE_INFINITY)
            {
                if (maxheight < g)
                    maxheight = g;
            }
            blockloop = false;
        }
        
        if (bRep != null)
        {
            float g = bRep.GetGround(floor);
            if (g != Float.NEGATIVE_INFINITY)
            {
                if (maxheight < g)
                    maxheight = g;
            }
        }
        
        return maxheight;
    }
    
    // for overwrite
    public static int GEOMETRY = 1, MATERIAL = 2, TRANSFORM = 4, NAME = 8, TEXTURE = 16, UV = 32, COLOR = 64;
//    public static final int COLOR = 1, MATERIAL = 2, TEXTURE = 4, GEOMETRY = 8, TRANSFORM = 16, NAME = 32, UV = 64;
    
//    transient boolean reduced; // for morph reduction
    
    transient com.bulletphysics.linearmath.Transform cache; // for fast merge
    transient com.bulletphysics.linearmath.Transform cache_1; // for fast merge

    transient Object3D transientsupport; // for cloning
    transient boolean transientlink2master;

    void SaveSupports()
    {
        if (blockloop)
            return;

        transientsupport = support;
        transientlink2master = link2master;

        support = null;
        link2master = false;

        if (bRep != null)
        {
            bRep.SaveSupports();
        }

        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i);
            if (child == null)
                continue;
            blockloop = true;
            child.SaveSupports();
            blockloop = false;
        }
    }

    void RestoreSupports()
    {
        if (blockloop)
            return;

        support = transientsupport;
        link2master = transientlink2master;
        transientsupport = null;
        transientlink2master = false;

        if (bRep != null)
        {
            bRep.RestoreSupports();
        }

        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i);
            if (child == null)
                continue;
            blockloop = true;
            child.RestoreSupports();
            blockloop = false;
        }
    }

    boolean HasBigData()
    {
        if (blockloop)
            return false;

        if (bRep != null)
        {
            return true;
        }
        
        blockloop = true;
        
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i);
            if (child == null)
                continue;
            if (child.HasBigData())
            {
                blockloop = false;
                return true;
            }
        }
        
        blockloop = false;
        return false;
    }

    void ExtractBigData(java.util.Hashtable<java.util.UUID, Object3D> hashtable)
    {
        if (blockloop)
            return;

        Object3D o;
        
        boolean isnew = false;
        
        if (hashtable.containsKey(GetUUID()))
        {
            o = hashtable.get(GetUUID());

            Grafreed.Assert(this.bRep == o.bRep);
            //if (this.bRep != null)
            //    assert(this.bRep.support == o.transientrep);
            if (this.support != null)
                assert(this.support.bRep == o.transientrep);
        }
        else
        {
            isnew = true;
            
            o = new Object3D("copy of " + this.name);

            hashtable.put(GetUUID(), o);
        }

        //if (!blockloop)
        {
            blockloop = true;

            for (int i=0; i<Size(); i++)
            {
                get(i).ExtractBigData(hashtable);
            }

            blockloop = false;
        }

        //if (isnew)
            ExtractBigData(o);
    }

    void ExtractBigData(Object3D o)
    {
        //System.err.println("ExtractBigData : " + this + " --> " + o);
        
        if (o.bRep != null)
            Grafreed.Assert(o.bRep == this.bRep);
        
        o.bRep = this.bRep;
// July 2019       if (this.bRep != null)
//        {
//            o.transientrep = this.bRep.support;
//            o.bRep.support = null;
//        }
        o.selection = this.selection;
        //o.versionlist = this.versionlist;
        //o.versionindex = this.versionindex;
        
        if (this.support != null)
        {
            if (o.transientrep != null)
                Grafreed.Assert(o.transientrep == this.support.bRep);

            o.transientrep = this.support.bRep;
            this.support.bRep = null;
        }
        
        //    o.support = this.support;
        //    o.fileparent = this.fileparent;
        //    if (this.bRep != null)
        //        o.bRep = this.bRep.support;
        
        this.bRep = null;
    //    if (this.bRep != null)
    //        this.bRep.support = null;
    //    this.support = null;
    //    this.fileparent = null;
    }

//    Object3D GetObject(java.util.UUID uuid)
//    {
//        if (this.uuid.equals(uuid))
//            return this;
//            
//        if (blockloop)
//            return null;
//
//        blockloop = true;
//
//        for (int i=0; i<Size(); i++)
//        {
//            Object3D o = get(i).GetObject(uuid);
//            
//            if (o != null)
//                return o;
//        }
//        
//        blockloop = false;
//        
//        return null;
//    }
    
    transient boolean tag;

    void TagObjects(Object3D o, boolean tag)
    {
        if (blockloop)
            return;

        o.tag = tag;
        
        if (o == this)
            return;
        
        blockloop = true;

        for (int i=0; i<Size(); i++)
        {
            get(i).TagObjects(o, tag);
        }
        
        blockloop = false;
    }

    boolean HasTags()
    {
        if (blockloop)
            return false;

        blockloop = true;

        boolean hasTags = false;
        
        for (int i=0; i<Size(); i++)
        {
            hasTags |= get(i).tag || get(i).HasTags();
            
            if (hasTags)
                break;
        }
        
        blockloop = false;
        
        return hasTags;
    }

    void RestoreBigData(java.util.Hashtable<java.util.UUID, Object3D> hashtable)
    {
        if (blockloop)
            return;

        if (!hashtable.containsKey(GetUUID()))
            return;

        Object3D o = hashtable.get(GetUUID());

        RestoreBigData(o);

        blockloop = true;

        //hashtable.remove(GetUUID());

        for (int i=0; i<Size(); i++)
        {
            get(i).RestoreBigData(hashtable);
        }
        
        blockloop = false;
    }

    void RestoreBigData(Object3D o)
    {
        //System.err.println("RestoreBigData : " + this + " <-- " + o);
        Grafreed.Assert(this.bRep == null);
        
        this.bRep = o.bRep;
        if (this.support != null && o.transientrep != null)
        {
            this.support.bRep = o.transientrep;
        }
        
        this.selection = o.selection;
        
        //this.versionlist = o.versionlist;
        //this.versionindex = o.versionindex;
// July 2019        if (this.bRep != null)
//            this.bRep.support = o.transientrep;
    //    this.support = o.support;
    //    this.fileparent = o.fileparent;
    }

// MOCAP SUPPORT
    double tx,ty,tz,rx,ry,rz;
    
    public static final int FIXED_AXES = 0, MOVING_AXES = 1;
    public static final int RX = 0, RY = 1, RZ = 2; // for specifying rotation order
    public static final int TX = 3, TY = 4, TZ = 5;
    public static final int NO_NAME = -1, SMALL_NAME = 0, BIG_NAME = 1;
    String _name;
    int _index;
    boolean _isRoot;
    //boolean _isHip;
    boolean _isBone;
//    private Bone _parent;
//    private Bone[] _children = new Bone[0];
//    transient BoneGeom _boneGeom; // the displayed geometry of the bone/joint
//    transient JointGeom _jointGeom;
//    private Switch _textSwitch;
//    transient TransformGroup _baseTransTG
//            ,_transTG
//            ,_baseRotTG
//            ,_rotTG
//            ,_invBaseRotTG
//            ;
//    Transform3D _t1 = new Transform3D();
//    Transform3D _t2 = new Transform3D();
//    Transform3D _transTF = new Transform3D();
//    Transform3D _tworld = new Transform3D();
//    Vector3d _trans = new Vector3d();
    int[] _dof = new int[0]; // rotation order
    int _numDOF = 0;
//    boolean _translationEnabled = true; // translation can be switched off
//    boolean _rotationEnabled = true; // rotation can be switched off
    int _rotationType = FIXED_AXES; // Euler rotation type
//    double _scale = 1d; // scale is applied to all translational components
// MOCAP SUPPORT

        void SetDynamics(DynamicsWorld d)
        {
            if (blockloop)
                return;
            
            blockloop = true;
            
            for (int i=Size(); --i>=0;)
            {
                Object3D obj = get(i);

                obj.SetDynamics(d);
            }
            
            blockloop = false;
        }
        
        void ResetDynamics(DynamicsWorld d)
        {
            if (blockloop)
                return;
            
            blockloop = true;
            
            for (int i=Size(); --i>=0;)
            {
                Object3D obj = get(i);

                obj.ResetDynamics(d);
            }
            
            blockloop = false;
        }
        
        void ResetRandom()
        {
            if (blockloop)
                return;
            
            blockloop = true;
            
            for (int i=Size(); --i>=0;)
            {
                Object3D obj = get(i);

                if (obj == null)
                    continue; // mars 2014
                
                obj.ResetRandom();
            }
            
            blockloop = false;
        }
    
	/**
	 * Gets one or many values from the target object associated to the
	 * given tween type. It is used by the Tween Engine to determine starting
	 * values.
	 *
	 * @param target The target object of the tween.
	 * @param tweenType An integer representing the tween type.
	 * @param returnValues An array which should be modified by this method.
	 * @return The count of modified slots from the returnValues array.
	 */
	public int getValues(Object3D target, int tweenType, float[] returnValues)
        {
//        System.out.println("getValues " + target + " to " + this);
//        new Exception().printStackTrace();
            returnValues[0] = (float)toParent[3][0];
            returnValues[1] = (float)toParent[3][1];
            returnValues[2] = (float)toParent[3][2];
            
            return 3;
        }

	/**
	 * This method is called by the Tween Engine each time a running tween
	 * associated with the current target object has been updated.
	 *
	 * @param target The target object of the tween.
	 * @param tweenType An integer representing the tween type.
	 * @param newValues The new values determined by the Tween Engine.
	 */
	public void setValues(Object3D target, int tweenType, float[] newValues)
        {
//        System.out.println("setValues " + target + " to " + newValues[0]);
//        new Exception().printStackTrace();
            toParent[3][0] = newValues[0];
            toParent[3][1] = newValues[1];
            toParent[3][2] = newValues[2];
        }
    

        String GetName()
        {
            if (name != null)
                return name;
            
            if (parent == null)
                return "nullparent";
            
            return parent.GetName() + "#";
        }
        
    boolean live = false;
    transient boolean keepdontselect;
    boolean dontselect = false;
    boolean hide = false;
    boolean link2master = false; // performs reset support/master at each frame
    boolean marked = false; // animation node
    boolean skip = false; // centroid issue
    boolean skipmocap = false; // mocap data
    
    boolean random = false;
    boolean speedup = false;
    boolean rewind = false;
    
    // Option to sort triangles, e.g. for transparency.
    boolean sort = false;
    
    float NORMALPUSH = 0;
    
    Object3D support;
    
    Object3D GetObject()
    {
        return this;
    }
    
    void SortBySize()
    {
        boolean sorted = false;

        while (!sorted)
        {
            sorted = true;
            
            for (int i=0; i<Size()-1; i++)
            {
                Object3D obji = get(i);
                Object3D objj = get(i+1);
                
                if (obji.MemorySize() < objj.MemorySize())
                {
                    set(i, objj);
                    set(i+1, obji);
                    
                    sorted = false;
                }
            }
        }
    }
    
    void SortByName()
    {
        boolean sorted = false;

        while (!sorted)
        {
            sorted = true;
            
            for (int i=0; i<Size()-1; i++)
            {
                Object3D obji = get(i);
                Object3D objj = get(i+1);
                
                if (obji.GetName().compareTo(objj.GetName()) > 0)
                {
                    set(i, objj);
                    set(i+1, obji);
                    
                    sorted = false;
                }
            }
        }
    }
    
    transient int memorysize; // needs to be transient, dunno why
    
    int MemorySize()
    {
        if (memorysize == 0)
        {
            try
            {
                Object3D obj = this;

                Object3D parent = obj.parent;
                obj.parent = null;
                Object3D support = obj.support;
                obj.support = null;

                java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
                java.io.ObjectOutputStream out = new java.io.ObjectOutputStream(baos);

                out.writeObject(obj);

                obj.parent = parent;
                obj.support = support;

                memorysize = baos.toByteArray().length;
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        
        return memorysize;
    }
    
    void Slower()
    {
        maxcount *= 2;
        transformcount *= 2;

        Matrix m = new Matrix(fromParent);
        Matrix sqm = m.sqrt();
        fromParent = sqm.getArray();

        m = new Matrix(toParent);
        sqm = m.sqrt();
        toParent = sqm.getArray();
    }
    
    void Faster()
    {
        if (maxcount > 1)
        {
            maxcount /= 2;
            transformcount /= 2;

            LA.matConcat(toParent, toParent, toParent);
            LA.matConcat(fromParent, fromParent, fromParent);
        }
    }
    
    void SwitchMark()
    {
        Object3D copy = this;
        
            Camera parentcam = Globals.theRenderer.ManipCamera();
            
            if (Globals.theRenderer.ManipCamera() == Globals.theRenderer.Cameras()[0])
            {
                parentcam = Globals.theRenderer.Cameras()[1];
            }
            
            if (Globals.theRenderer.ManipCamera() == Globals.theRenderer.Cameras()[1])
            {
                parentcam = Globals.theRenderer.Cameras()[0];
            }
        
        if (this == parentcam)
        {
            //assert(this instanceof Camera);
            
            for (int count = parentcam.GetTransformCount(); --count>=0;)
                LA.xformPos(Globals.theRenderer.TargetLookAt(), parentcam.toParent, Globals.theRenderer.TargetLookAt());
        }
        
        copy.marked ^= true;

        if (copy.marked)
        {
            copy.Mark();
        } else
        {
            copy.Unmark();
        }

        copy.SwapMark();
        
        if (this == parentcam)
        {
            //assert(this instanceof Camera);
            
            for (int count = parentcam.GetTransformCount(); --count>=0;)
                LA.xformPos(Globals.theRenderer.TargetLookAt(), parentcam.fromParent, Globals.theRenderer.TargetLookAt());
        }

        copy.Touch(); // display list issue
    }
    
    void Mark()
    {
        if (toParent == null)
        {
            toParent = LA.newMatrix();
            fromParent = LA.newMatrix();
        }
        
        if (toParentMarked == null)
        {
            if (maxcount != 1)
            {
                //new Exception().printStackTrace();
            }
            
            toParentMarked = LA.newMatrix();
            fromParentMarked = LA.newMatrix();
        }

        LA.matCopy(toParent, toParentMarked);
        LA.matCopy(fromParent, fromParentMarked);

        int loops = maxcount;

        while (loops > 1)
        {
            Matrix m = new Matrix(fromParentMarked);
            Matrix sqm = m.sqrt();
            fromParentMarked = sqm.getArray();

            m = new Matrix(toParentMarked);
            sqm = m.sqrt();
            toParentMarked = sqm.getArray();

            loops >>= 1;
        }
    }
    
    void Unmark()
    {
        Object3D copy = this;
        if (copy.toParentMarked == null)
        {
            copy.toParentMarked = LA.newMatrix();
            copy.fromParentMarked = LA.newMatrix();

            LA.matCopy(copy.toParent, copy.toParentMarked);
            LA.matCopy(copy.fromParent, copy.fromParentMarked);

            int loops = copy.maxcount;

            while (loops > 1)
            {
                LA.matConcat(copy.toParentMarked, copy.toParentMarked, copy.toParentMarked);
                LA.matConcat(copy.fromParentMarked, copy.fromParentMarked, copy.fromParentMarked);

                loops >>= 1;
            }
        }
    }
    
    void SwapMark()
    {
        double[][] tempmat = toParent;
        toParent = toParentMarked;
        toParentMarked = tempmat;

        tempmat = fromParent;
        fromParent = fromParentMarked;
        fromParentMarked = tempmat;
    }
    
    // Mark again according to current position (transformcount).
    void Remark()
    {
        if (globalTransform == null)
        {
            globalTransform = new double[4][4];
        }

        LA.matIdentity(globalTransform);

//        if (link2master) // if !marked?
//        {
//            // PATCH for global reset
//            maxcount = transformcount; // 1;
//        }

        int tcount = //maxcount; //
                        transformcount; // GetTransformCount();

        if (tcount == 0)
            tcount = 1;

        for (int i=tcount; --i>=0;)
            LA.matConcat(globalTransform, toParent, globalTransform);
        LA.matCopy(globalTransform, toParent);

        LA.matIdentity(globalTransform);
        for (int i=tcount; --i>=0;)
            LA.matConcat(globalTransform, fromParent, globalTransform);
        LA.matCopy(globalTransform, fromParent);

        transformcount = maxcount; // 1;
        Mark(); //maxcount = 0;
        SwapMark();
    }
    
    void Reset()
    {
        if (scriptnode != null)
        {
            scriptnode.Reset();
        }
//        Reset(false);
//    }
//    
//    void Reset(boolean fromscript)
//    {
        // marde pour serialization de Texture
        resetmaxcount();
        resettransformcount();
        resetstep();
        
        if (!marked)
        {
            transformcount = 0; // may 2014
            //ResetRecur();
            return;
        }
        
        if (Globals.fromscript)
        {
            transformcount = 0;
            return;
        }
        
//        if (hide)
//        {
////            if (maxcount > 10)
////                maxcount /= 10;
////            else
////                assert(maxcount == 1);
//            if (globalTransform == null)
//            {
//                globalTransform = new double[4][4];
//            }
//            
//            LA.matIdentity(globalTransform);
//            
//            if (link2master)
//            {
//                // PATCH for global reset
//                maxcount = transformcount; // 1;
//            }
//            
//            int tcount = maxcount; // transformcount; // GetTransformCount();
//            
//            if (tcount == 0)
//                tcount = 1;
//            
//            for (int i=tcount; --i>=0;)
//                LA.matConcat(globalTransform, toParent, globalTransform);
//            LA.matCopy(globalTransform, toParent);
//            
//            LA.matIdentity(globalTransform);
//            for (int i=tcount; --i>=0;)
//                LA.matConcat(globalTransform, fromParent, globalTransform);
//            LA.matCopy(globalTransform, fromParent);
//
//            transformcount = 1;
//            maxcount = 0;
//        }
//        else
        if (false) // link2master && fromParent != null)
        {
            maxcount *= 2;

            //fromParent[0][0] = 33;
            //fromParent[1][0] = 24;
            //fromParent[0][1] = 48;
            //fromParent[1][1] = 57;
            
            Matrix m = new Matrix(fromParent);
            Matrix sqm = m.sqrt();
            fromParent = sqm.getArray();
            
            m = new Matrix(toParent);
            sqm = m.sqrt();
            toParent = sqm.getArray();
            
//            toParent[3][0] /= 2;
//            toParent[3][1] /= 2;
//            toParent[3][2] /= 2;
//            fromParent[3][0] *= 2;
//            fromParent[3][1] *= 2;
//            fromParent[3][2] *= 2;
        }
        else
            transformcount = 0;
    }
    
    void Forward()
    {
        // marde pour serialization de Texture
        resetmaxcount();
        resettransformcount();
        resetstep();
        
        transformcount = maxcount;
    }
    
    void Step()
    {
        // marde pour serialization de Texture
        resetmaxcount();
        resettransformcount();
        resetstep();
        
        if (!marked)
        {
            //StepRecur();
            return;
        }
        
//        if (hide)
//        {
//            maxcount = 0; // *= 10;
//        }
//        else
        if (false) // link2master && toParent != null)
        {
            maxcount /= 2;
            
            LA.matConcat(toParent, toParent, toParent);
            LA.matConcat(fromParent, fromParent, fromParent);
//            LA.matInvert(toParent, fromParent);
            
//            toParent[3][0] *= 2;
//            toParent[3][1] *= 2;
//            toParent[3][2] *= 2;
//            fromParent[3][0] /= 2;
//            fromParent[3][1] /= 2;
//            fromParent[3][2] /= 2;
        }
        else
            transformcount++;
    }

    int maxcount;
    int transformcount;
    int step;
    
    void resetmaxcount()
    {
    }
    
    void resettransformcount()
    {
    }
    
    void resetstep()
    {
    }
    
    void setmaxcount(int i)
    {
        maxcount = i;
    }
    
    void settransformcount(int i)
    {
        transformcount = i;
    }
    
    void setstep(int i)
    {
        step = i;
    }
    
//    int acceleration;
    
    int delay;
    int countdown;
    
    transient int currentframe; // do only one step per frame
    
    int GetTransformCount()
    {
        // patch pour serialization de Texture
        resetmaxcount();
        resettransformcount();
        resetstep();
        
        if (this instanceof Mocap || this instanceof cMesh)
        {
            return 1;
        }
        
        if (step == 0)
            step = 1;
        if (maxcount == 0)
            maxcount = 128; // 2048; // 4;
//        if (acceleration == 0)
//            acceleration = 10;
        if (delay == 0) // serial
        {
            countdown = delay = 5;
        }
        
        int factor = 1;
        
   //     if (!CameraPane.AntialiasingEnabled())
   //     {
   //         factor = 4; // patch for 2x2 antialiasing only
   //     }
        
//        if (CameraPane.FAST)
//        {
//            // aout 2013
//            factor = CameraPane.STEP;
//        }
        
        if (marked && Globals.isLIVE() && live &&
                //TEMP21aug2018
                (Globals.DrawMode() == iCameraPane.SHADOW || !Globals.RENDERSHADOW || !Globals.COMPUTESHADOWWHENLIVE) &&
                currentframe != Globals.framecount)
        {
            currentframe = Globals.framecount;
            
//            System.err.println("transformcount = " + transformcount);
//            System.err.println("factor = " + factor);
//            System.err.println("maxcount = " + maxcount);
//            System.err.println("step = " + step);
            
            boolean changedir = random && Math.random() < 0.01; // && !link2master;

            if (transformcount*factor >= maxcount && (rewind || random) ||
                    (step == 1 && changedir))
            {
                countdown = 1;
                delay = speedup?8:1;
                //delay = 0; // 10;
                if (rewind) // link2master patch for loop
                    transformcount = 0;
                else
                    step = -1;
                
                changedir = false;
            }
            if (transformcount <= 0 || (step == -1 && changedir))
            {
                countdown = 1;
                delay = speedup?8:1;
                //delay = 0; // 10;
                step = 1;
            }

            if (--countdown == 00) // || link2master) // patch for loop
            {
                if (CameraPane.FAST)
                    transformcount += step * CameraPane.STEP;
                else
                    transformcount += step;
                delay--;
                if (delay == 0)
                    delay = 1;
                countdown = delay;
            }

//            if (maxcount <= 1000)
//            {
//                //if (step < acceleration)
//                if (transformcount < acceleration*(acceleration+1)/2)
//                    step += 1;
//
//                if (transformcount > maxcount - acceleration*(acceleration+1)/2)
//                    step -= 1;
//            }
        }
        
        if (marked) // live)
        {
//            if (transformcount < 10)
//                return transformcount*transformcount;
//            else
//            if (transformcount > maxcount-10)
//                return transformcount*transformcount;
//            else
//            if (transformcount > 1)
//                System.out.println("Transform count (" + this + ") = " + transformcount);
                return transformcount * factor;
        }
        else
        {
            if (maxcount == 4) // grosse patch
                return 1;
            else
                return 1; // may 2013 maxcount;
        }
    }

    
    boolean IsStatic()
    {
//        return true;
        
//        if (material == null || material.multiply)
//            return true;
//        
//        if (projectedVertices != null && projectedVertices.length > 2 && projectedVertices[2].y >= 10000)
//            return false;
//        
//        // Transparent objects are dynamic because we have to sort the triangles.
//        return material.opacity > 0.99;
        
        return !sort;
    }
    
    boolean IsOpaque()
    {
//        return true;
        
//        if (material == null || material.multiply)
//            return true;
//        
//        return material.opacity > 0.99;
        
        return !sort;
    }
    
    Object3D()
    {
        this("Default Object");
        
        toParent = LA.newMatrix();
        fromParent = LA.newMatrix();
    }

    Object3D(String oname)
    {
        super(0, 0); // Vector
        centerPt = null; // new Point(0, 0);
        startMat = null; // new double[4][4];
        name = oname;
        toParent = null; // LA.newMatrix();
        fromParent = null; // LA.newMatrix();
        bRep = null; // new BoundaryRep();

        if (oname != null && oname.equals("LeftHand"))
        {
            name = oname;
        }
        
        /*
        float hue = (float)Math.random();
        Color col;
        col = Color.getHSBColor(hue, 0.5f, 1f);
        aColor = new Color(col.getRed(), col.getGreen(), col.getBlue(), 192);
        col = Color.getHSBColor(hue, 0.5f, 1f);
        aColorSelect = new Color(col.getRed(), col.getGreen(), col.getBlue());
        col = Color.getHSBColor(hue, 0.5f, 0.2f);
        aLineColor = new Color(col.getRed(), col.getGreen(), col.getBlue());
        col = Color.getHSBColor(hue, 0.5f, 1);
        aLineColorSelect = new Color(col.getRed(), col.getGreen(), col.getBlue());
         */

        //InitColorTable();
        viewCode = -1; // cache for transparency
    }
    
    Color tmpFillColor = null; // new Color(0,0,0);
	/*
    //transient Color[] colorTable = new Color[100];
    void InitColorTable()
    {
    int len = colorTable.length;
    for (int i=0; i<len; i++)
    {
    colorTable[i] = new Color(aColor.getRed() * i / len,
    aColor.getGreen() * i / len,
    aColor.getBlue() * i / len, 128);
    }
    }
     */

    Object3D deepCopy()
    {
        // ??? display list failure!! ---->>>    return (Object3D) Applet3D.clone(this);
        Object3D obj = new Object3D();
        deepCopySelf(obj);
        return obj;
    }

    public Object clone()
    {
        return Grafreed.clone(this);
    }

    Object3D copyExpand()
    {
        // parent problem...
        //	return this;

        // will share the geometry
        assert (!(this instanceof Composite));
        
        Object3D obj = deepCopy(); // Never called for Composite
        obj.count = 2;
        return obj;
    }

    boolean HasLoops()
    {
        return false;
    }
    
    void ResetUUIDs()
    {
        if (blockloop)
        {
            return;
        }

        this.uuid = null;
        
        blockloop = true;

        for (int i = 0; i < Size(); i++)
        {
            Object3D obj = (Object3D) Children().get(i);

            if (obj != null)
            {
                obj.ResetUUIDs();
            }
        }

        blockloop = false;
    }

    boolean IsInfinite()
    {
        if (blockloop)
        {
            return true;
        }

        blockloop = true;

        for (int i = 0; i < Children().size(); i++)
        {
            Object3D obj = (Object3D) Children().get(i);

            if (obj == null)
            {
                //new Exception().printStackTrace();
                //return true;
                continue;
            }
            if (obj.IsInfinite())
            {
                blockloop = false;
                return true;
            }
        }

        blockloop = false;
        return false;
    }

    void CopyExtraMaterial(Object3D other)
    {
        if (projectedVertices != null && projectedVertices.length > 0)
        {
            other.projectedVertices = new cVector2[3];
            other.projectedVertices[0] = new cVector2();
            other.projectedVertices[1] = new cVector2();
            other.projectedVertices[2] = new cVector2();
            other.projectedVertices[2].y = 1;
            if (projectedVertices[0] != null) // ??
            {
                other.projectedVertices[0].x = projectedVertices[0].x; // bump
                other.projectedVertices[0].y = projectedVertices[0].y; // noise
            }
            if (projectedVertices.length > 1)
            {
                if (projectedVertices[1] != null) // ??
                {
                    other.projectedVertices[1].x = projectedVertices[1].x; // borderfade
                    other.projectedVertices[1].y = projectedVertices[1].y; // fog
                }
                if (projectedVertices.length > 2)
                {
                    if (projectedVertices[2] != null) // ??
                    {
                        other.projectedVertices[2].x = projectedVertices[2].x; // noise power
                        other.projectedVertices[2].y = projectedVertices[2].y; // opacity power
                    }
                }
            }
        }
    }
    
    // copy this into other
    void deepCopySelf(Object3D other)
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        other.parent = parent;
        
        //System.out.println("COPY " + this + " to " + other);
        //new Exception().printStackTrace();
        deepCopyNode(other);

        other.bRep = bRep; // Share the geometry
        
        other.support = support; // Share the support

// aout 2013        if (/*displaylist != -1 &&*/other.displaylist != displaylist)
//        {
//            CameraPane.RemoveList(other.displaylist);
//            other.displaylist = displaylist; // Share
//        }
//
//        CameraPane.AddDuplicate(displaylist);
        
        Object3D c = (Object3D) other;
//        if (selection != null)
//        {
////            assert(false); // ?!?!?!?!?!
//            c.selection = /*(Vector)*/ (Object3D) selection.clone();
//        } else
//        {
//            c.selection = new Object3D(); // Vector(0, 0);
//        }
        assert (c.Children() == c);
//??        c.clear();
    /**/
        c.Children().setSize(Children().Size());
        for (int i=0; i < Children().Size(); i++)
        {
            Object3D obj = (Object3D)Children().get(i);
            if (IsContainedIn(obj))
            {
//            assert(false); // ?!?!?!?!?!
                c.Children().setElementAt(c, i);
            }
            else
            {
                obj = obj.deepCopy();
                obj.parent = c;
                c.Children().setElementAt(obj, i);
            }
        }
    /**/
        
    //other.displaylist = -1;
    //other.Touch();
        blockloop = false;
    }

    void overwriteNode(Object3D other, int mask)
    {
      //  System.err.println("overwrite " + other + " to " + this);
        //new Exception().printStackTrace();

//        LA.matCopy(other.toParent, toParent);
//        LA.matCopy(other.fromParent, fromParent);
        
        if ((mask & GEOMETRY) != 0)
        {
            if (bRep != null)
            {
                bRep.overwriteThis(other.bRep==null?other.transientrep:other.bRep);
                CameraPane.RemoveList(bRep.displaylist);
                bRep.displaylist = 0; // june 2013 -1;
            }
            else
            {
                //assert(other.bRep == null);
                bRep = other.bRep;
            }
            
//            if (bRep != null)
//            {
//                CameraPane.RemoveList(bRep.displaylist);
//                bRep.displaylist = 0; // june 2013 -1;
//            }
//            else
//                bRep = bRep;
        }
            
        /* Use a MASK = GEO/MAT
        */
        if ((mask & NAME) != 0)
        {
            if (bRep == null || other.bRep == null || bRep.VertexCount() != other.bRep.VertexCount()) // don't rename leaves. june 2014
            {
                if (other.name != null)
                    name = new String(other.name);
            }
            //else name = null;
            else if (bRep != null && other.bRep != null)
            {
                System.out.println("" + name + " to " + other.name + ": not renamed (same mesh).");
            }
        }

        if ((mask & UV) != 0)
        {
            if (bRep != null)
            {
                BoundaryRep otherrep = other.bRep==null?other.transientrep:other.bRep;
                
                if (bRep.VertexCount() == otherrep.VertexCount())
                {
                    for (int i=0; i<bRep.VertexCount(); i++)
                    {
                        Vertex v2 = bRep.GetVertex(i);
                        Vertex v = null; // otherrep.GetVertex(i);

                        double dist2 = Double.MAX_VALUE;
                        int mini = 0;
                        
                        // closest vertex
                        for (int j=0; j<otherrep.VertexCount(); j++)
                        {
                            v = otherrep.GetVertex(j);
                            
                            v0.set(v2);
                            v0.sub(v);
                            
                            if (dist2 > v0.dot(v0))
                            {
                                dist2 = v0.dot(v0);
                                mini = j;
                            }
                        }
                        
                        v = otherrep.GetVertex(mini);
                        
                        v2.s = v.s;
                        v2.t = v.t;
                        
                        bRep.SetVertex(v2, i); // if trimmed
                    }
                }
            }
            else
                assert(other.bRep == null);
            
            if (bRep != null)
            {
                CameraPane.RemoveList(bRep.displaylist);
                bRep.displaylist = 0; // june 2013 -1;
            }
            else
                bRep = bRep;
        }

//        if ((mask & MATERIAL) != 0)
//        {
//            if (other.material != null)
//            {
//                material = new cMaterial(other.material);
//            } else
//            {
//                //assert(other.material == null);
//                //material = null; // ?
//            }
//        }
//
//        if ((mask & TEXTURE) != 0)
//            GetTextures().name = other.GetTextures().name;
        SetAttributes(other, mask);
        
        if ((mask & TRANSFORM) != 0)
        {
            if (other.toParent != null)
            {
                if (toParent == null)
                {
                    toParent = LA.newMatrix();
                    fromParent = LA.newMatrix();
                }
                
                LA.matCopy(other.toParent, toParent);
                LA.matCopy(other.fromParent, fromParent);
                
                if (other.toParentMarked != null)
                {
                    toParentMarked = LA.newMatrix();
                    fromParentMarked = LA.newMatrix();
                    LA.matCopy(other.toParentMarked, toParentMarked);
                    LA.matCopy(other.fromParentMarked, fromParentMarked);
                }
                
                //live = other.live;
                marked = other.marked;
                maxcount = other.maxcount;
                transformcount = other.transformcount;
                step = other.step;
                delay = other.delay;
                countdown = other.countdown;
                if (material == null)
                    material = other.material; // for selection
            }
            else
            {
                //assert(toParent == null);
//                if (toParent != null)
                toParent = null;
                fromParent = null;
            }
        }
        
        /*
        if (projectedVertices != null && projectedVertices.length > 0)
        {
            other.projectedVertices = new cVector2[3];
            other.projectedVertices[0] = new cVector2();
            other.projectedVertices[1] = new cVector2();
            other.projectedVertices[2] = new cVector2();
            other.projectedVertices[2].y = 1;
            if (projectedVertices[0] != null) // ??
            {
                other.projectedVertices[0].x = projectedVertices[0].x; // bump
                other.projectedVertices[0].y = projectedVertices[0].y; // noise
            }
            if (projectedVertices.length > 1)
            {
                if (projectedVertices[1] != null) // ??
                {
                    other.projectedVertices[1].x = projectedVertices[1].x; // borderfade
                    other.projectedVertices[1].y = projectedVertices[1].y; // fog
                }
                if (projectedVertices.length > 2)
                {
                    if (projectedVertices[2] != null) // ??
                    {
                        other.projectedVertices[2].x = projectedVertices[2].x; // noise power
                        other.projectedVertices[2].y = projectedVertices[2].y; // opacity power
                    }
                }
            }
        }
         */

        touched = true;
        softtouched = true;
    }

    void morphNode(Object3D other, int index, double[] morphweights)
    {
        //assert(other == morphobject);
        
//        double totalweight = 0;
//
//        for (int i=0; i<morphweights.length; i++)
//        {
//            totalweight += morphweights[i];
//        }
        
        if (bRep != null)
        {
            Object3D firstobject = other.get(0);

            if (index != -1)
                firstobject = firstobject.get(index);
            
            BoundaryRep firstrep = firstobject.bRep==null ? firstobject.transientrep : firstobject.bRep;

            double totalweight = 0;
            
            for (int m=morphweights.length; --m>=0;)
            {
                totalweight += morphweights[m];
            }
            
            //if (bRep.VertexCount() == otherrep.VertexCount())
            {
                for (int i=bRep.VertexCount(); --i>=0;)
                {
                    Vertex v2 = firstrep.GetVertex(i);
                    //Vertex v = null; // otherrep.GetVertex(i);

                    double x = v2.x;
                    double y = v2.y;
                    double z = v2.z;
                    
                    double nx = v2.norm.x;
                    double ny = v2.norm.y;
                    double nz = v2.norm.z;
                    
                    for (int m=morphweights.length; --m>=0;)
                    {
                        Object3D otherobject = other.get(m);
                        
                        if (index != -1)
                            otherobject = otherobject.get(index);
                        
                        BoundaryRep otherrep = otherobject.bRep==null ? otherobject.transientrep : otherobject.bRep;
                        
//                        if (bRep.VertexCount() != otherrep.VertexCount())
//                        {
//                            new Exception().printStackTrace();
//                            continue;
//                        }
                        
                        Vertex v = otherrep.GetVertex(i);
                        
                        double weight = morphweights[m];
                        
                        if (weight == 0)
                            continue;
                        
//                        x += weight * (v.x - v2.x);
//                        y += weight * (v.y - v2.y);
//                        z += weight * (v.z - v2.z);
//                        nx += weight * (v.norm.x - v2.norm.x);
//                        ny += weight * (v.norm.y - v2.norm.y);
//                        nz += weight * (v.norm.z - v2.norm.z);
                        x += weight * v.x;
                        y += weight * v.y;
                        z += weight * v.z;
                        
                        nx += weight * v.norm.x;
                        ny += weight * v.norm.y;
                        nz += weight * v.norm.z;
                    }

                    x -= totalweight * v2.x;
                    y -= totalweight * v2.y;
                    z -= totalweight * v2.z;
                    
                    nx -= totalweight * v2.norm.x;
                    ny -= totalweight * v2.norm.y;
                    nz -= totalweight * v2.norm.z;

                    Vertex v3 = bRep.GetVertex(i);
                    
                    v3.x = x;
                    v3.y = y;
                    v3.z = z;
                    
                    double length = Math.sqrt(nx*nx + ny*ny + nz*nz);
                    
                    v3.norm.x = nx / length;
                    v3.norm.y = ny / length;
                    v3.norm.z = nz / length;

                    bRep.SetVertex(v3, i); // if trimmed
                }
            }
        }
        else
            assert(other.bRep == null);

        if (bRep != null)
        {
            CameraPane.RemoveList(bRep.displaylist);
            bRep.displaylist = 0; // june 2013 -1;
        }
        else
            bRep = bRep;

        touched = true;
        softtouched = true;
    }

    void linkVerticesNode(Object3D other)
    {
    //    if (other == null)
    //        return;
        
        if (other != null)
        {
            BoundaryRep.SEUIL = other.material.cameralight;

            // Set default to 0.1
            BoundaryRep.SEUIL /= 4; // 2;
            System.out.println("SEUIL = " + BoundaryRep.SEUIL);
        }
        
        System.out.println("Link this = " + this + "; support = " + other);
        
        //if (bRep != null)
        //    bRep.linkVerticesThis(other.bRep);
        if (bRep != null)
        {
            //assert(other.bRep != null);
            BoundaryRep usedrep = null;
            
            if (other != null)
            {
                usedrep = other.bRep;

                if (usedrep == null)
                    usedrep = other.transientrep;
            }
            
            //assert(usedrep != null);
            if (usedrep == null && other != null)
            {
                new Exception().printStackTrace();
            }
            else
                bRep.linkVerticesThis(usedrep, other==null?null:null); // june 2013 other.GlobalTransformInv());
        }
        else
        {
            if (transientrep != null)
            {
                BoundaryRep usedrep = null;
                
                if (other != null)
                {
                    usedrep = other.bRep;

                    if (usedrep == null)
                        usedrep = other.transientrep;
                }

                if (usedrep != null || other != null)
                    transientrep.linkVerticesThis(usedrep, other==null?null:null); // june 2013 other.GlobalTransformInv());
                else
                //assert(usedrep != null);
                    new Exception().printStackTrace();
            }
        }
    //    else
    //        assert(other.bRep == null);

        
//        System.out.println("Done.");
        
//        touched = true;
//        softtouched = true;
//        CameraPane.RemoveList(displaylist);
//        displaylist = -1;
    }
    
    void setMasterNode(Object3D other, boolean smooth)
    {
        //other.getBounds(min,max,true);
        //System.out.println("Link object " + this + " to " + other);
        if (name != null && name.contains("pantsstraps"))
        {
            name = name;
        }
        
        if (bRep != null)
        {
            //assert(other.bRep != null);
            BoundaryRep usedrep = other.bRep;

            if (usedrep == null)
                usedrep = other.transientrep;
            
            //assert(usedrep != null);
            if (usedrep == null)
            {
                System.err.println(this);
                System.err.println("other = " + other);
                new Exception().printStackTrace();
            }
            else
                bRep.setMasterThis(usedrep, null /* june 2013 other.GlobalTransformInv()*/, smooth, marked);
        }
        else
        {
            BoundaryRep usedrep = other.bRep;

            if (usedrep == null)
            {
                if (other.transientrep == null)
                    other.Revert();

                usedrep = other.transientrep;
            }

            //assert(usedrep != null);
            if (usedrep == null)
            {
                new Exception().printStackTrace();
                return;
            }

            if (transientrep == null)
                Revert();
            
            if (transientrep != null)
            {
                transientrep.setMasterThis(usedrep, null /* june 2013 other.GlobalTransformInv()*/, smooth, marked);
            }
        }

        Touch();
//        touched = true;
//        softtouched = true;
//        CameraPane.RemoveList(displaylist);
//        displaylist = -1;
    }
    
    void resetMasterNode(boolean smooth)
    {
        //System.err.println("Reset support this = " + this + "; support = " + support);
        if (support != null)
            setMasterNode(support, smooth);
        //support.
        //getBounds(min,max,true);
    }
    
    void overwriteThis(Object3D other, int mask)
    {
        if (blockloop)
            return;
        
        if ((mask & NAME) != 0)
            mask = mask;
        
        overwriteNode(other, mask);
        
//        assert(Size() == other.Size());
        
        for (int i=Size(); --i>=0;)
        {
            Object3D obj = get(i);
            
            Object3D obj2 = null;
            
            if ((mask & NAME) == 0 && obj.name != null)
            {
                obj2 = other.get(obj.name);

                // june 2014
                if (obj2 == null && other.bRep == null)
                {
                    // Not found. We cannot continue with an empty geometry.
                    if (other.Size() == Size())
                    {
                        // we try at the same index
                        obj2 = other.get(i);
                    }
                    else
                    {
                        new Exception("Geometry mismatch: " + obj + " of " + this).printStackTrace();
                    }
                }
            }
            else
            {
                if (i < other.Size())
                    obj2 = other.get(i); // no choice
            }

            if (obj2 != null)
            {
                blockloop = true;
                obj.overwriteThis(obj2, mask); //i));
                blockloop = false;
            }
        }
    }
    
    void morphThis(Object3D other, int index, double[] morphweights)
    {
        if (blockloop)
            return;
        
        morphNode(other, index, morphweights);
        
//        assert(Size() == other.Size());
        
        for (int i=Size(); --i>=0;)
        {
            Object3D obj = get(i);
            
            Object3D obj2 = null;
            
            if (obj.name != null)
            {
                obj2 = other.get(obj.name);
            }
            else
            {
                if (i < other.Size())
                    obj2 = other.get(i); // no choice
            }

            if (obj2 != null)
            {
                blockloop = true;
                obj.morphThis(obj2, i, morphweights);
                blockloop = false;
            }
        }
    }
    
    void generateMeshes() // Object3D group)
    {
        if (blockloop)
            return;

        blockloop = true;

        if (bRep != null)
        {
            cMesh s = new cMesh(this);
            s.setup();
            DecCount();
            parent.addChild(s);
        }
        
        int size = Size();
        for (int i=0; i<size; i++)
        //for (int i=Size(); --i>=0;)
        {
            Object3D obj = get(i);
            
            obj.generateMeshes();
        }
        
        blockloop = false;
    }
    
    void ExtractGeometries(Object3D group, boolean clone)
    {
        if (blockloop)
            return;

        blockloop = true;

        if (transientrep != null)
        {
            assert(bRep == null);
            Object3D o = new Object3D((clone?"Ge:":"Li:") + this.name);
            o.bRep = transientrep;
            if (clone)
                o.bRep = (BoundaryRep) Grafreed.clone(transientrep);
            o.CreateMaterial();
            o.SetAttributes(this, -1);
            //parent
                    group.addChild(o);
        }
        
        if (bRep != null)
        {
            assert(transientrep == null);
            Object3D o = new Object3D((clone?"Ge:":"Li:") + this.name);
            o.bRep = bRep;
            if (clone)
                o.bRep = (BoundaryRep) Grafreed.clone(bRep);
            o.CreateMaterial();
            //o.overwriteThis(this, -1);
            o.SetAttributes(this, -1);
            //parent
                    group.addChild(o);
        }
        
        int size = Size();
        for (int i=0; i<size; i++)
        //for (int i=Size(); --i>=0;)
        {
            Object3D obj = get(i);
            
            if (obj.bRep == null)
            {
                Object3D newgroup = new Object3D((clone?"Ge:":"Li:") + obj.name);

                obj.ExtractGeometries(newgroup, clone);

                group.addChild(newgroup);
            }
            else
            {
                obj.ExtractGeometries(group, clone);
            }
        }
        
        blockloop = false;
    }
    
//    void CloneGeometries()
//    {
//        if (blockloop)
//            return;
//
//        blockloop = true;
//
//        if (transientrep != null)
//        {
//            assert(bRep == null);
//            Object3D o = new Object3D("Geometry:" + this.name);
//            o.bRep = (BoundaryRep) GrafreeD.clone(transientrep);
//            o.CreateMaterial();
//            parent.addChild(o);
//        }
//        
//        if (bRep != null)
//        {
//            assert(transientrep == null);
//            Object3D o = new Object3D("Geometry:" + this.name);
//            o.bRep = (BoundaryRep) GrafreeD.clone(bRep);
//            o.CreateMaterial();
//            parent.addChild(o);
//        }
//        
//        int size = Size();
//        for (int i=0; i<size; i++)
//        //for (int i=Size(); --i>=0;)
//        {
//            Object3D obj = get(i);
//            
//            obj.CloneGeometries();
//        }
//        
//        blockloop = false;
//    }
    
    //@SuppressWarnings("CallToThreadDumpStack")
    Object3D get(String n)
    {
        if (blockloop)
            return null;

        blockloop = true;

        int count = 0;

        Object3D theobj = null;
        
        for (int i=Size(); --i>=0;)
        {
            Object3D obj = get(i);
            
            if (obj.name == null)
                continue; // can't be a null one
            
            // Try perfect match first.
            if (n.equals(obj.name))
            {
                theobj = obj;
                count++;
            }
        }
        
        // not needed: n = n.split(":")[0]; // Poser generates a count
        
    if (count != 1)
        for (int i=Size(); --i>=0;)
        {
            Object3D obj = get(i);
            
            if (obj.name == null)
                continue; // can't be a null one
            
            String name = obj.name.split(":")[0]; // Poser generates a count
            //if (n.startsWith(obj.name))
            if (n.contains(name))
            {
                theobj = obj;
                count++;
            }
        }
        
        blockloop = false;

        if (count != 1)
        {
            if (count > 1)
                new Exception().printStackTrace();
            return null;
        }
        else
            return theobj;
    }
    
    void linkVerticesThis(Object3D other)
    {
        if (blockloop)
            return;

        blockloop = true;

        if (bRep != null) // && !bRep.trimmed)
        {
            support = other;

            link2master = support != null;

            if (support != null && bRep.trimmed)
            {
                System.out.println("Untrim " + this);
                bRep.Untrim();
            }
            
            linkVerticesNode(other);
        }
        
        //if (bRep != null)
        //    bRep.linkVerticesThis(other, other.GlobalTransformInv());
        
//        assert(Size() == other.Size());
        
        for (int i=0; i < Size(); i++)
        {
            Object3D obj = get(i);
            
            if (other == null)
            {
                obj.linkVerticesThis(null);
            }
            else
            {
                Object3D obj2 = other.get(obj.name);

                if (obj2 != null)
                    obj.linkVerticesThis(obj2);
                else
                {
                    obj2 = other;
                    if (other.bRep == null)
                    {
                        // Not found. We cannot continue with an empty geometry.
                        if (other.Size() == Size())
                        {
                            // we try at the same index
                            obj2 = other.get(i);
                        }
                        else
                        {
                            new Exception("Support mismatch").printStackTrace();
                        }
                    }
                    obj.linkVerticesThis(obj2);
                }
            }
        }
        
        blockloop = false;
    }
    
    void ClearReferences()
    {
        if (blockloop)
            return;

        blockloop = true;

        for (int i=0; i < Size(); i++)
        {
            Object3D obj = get(i);
            
            obj.ClearReferences();
        }
        
        blockloop = false;
    }
    
    void setMasterThis(Object3D other, boolean smooth)
    {
        if (blockloop)
            return;

        blockloop = true;

        setMasterNode(other, smooth);
        
    //    assert(Size() == other.Size());
        
        for (int i=0; i < Size(); i++)
        {
            Object3D obj = get(i);
            
            Object3D obj2 = other.get(obj.name);
            
            if (obj2 != null)
                obj.setMasterThis(obj2, smooth);
            else
                obj.setMasterThis(other, smooth);
        }
        
        blockloop = false;
    }
    
    void RelinkToSupport()
    {
        if (blockloop)
            return;

//        setMasterNode(other, smooth);
        
        if (bRep != null)
        {
        //    assert(bRep.support == support.bRep);
            
            Object3D sup = support;
            
            support = null;
            bRep.support = null;
            
            linkVerticesThis(null);
            linkVerticesThis(sup);
        }
        
        for (int i=0; i < Size(); i++)
        {
            Object3D obj = get(i);
            
            blockloop = true;
            obj.RelinkToSupport();
            blockloop = false;
        }
        
    }
    
    void resetMaster(boolean smooth)
    {
        if (blockloop)
            return;

        blockloop = true;

        resetMasterNode(smooth);
        
    //    assert(Size() == other.Size());
        
        for (int i=0; i < Size(); i++)
        {
            Object3D obj = get(i);
            obj.resetMaster(smooth);
        }
        
        blockloop = false;
    }
    
    void poseMeshThis(Object3D other)
    {
        if (blockloop)
            return;

        blockloop = true;

        if (this instanceof cMesh)
        {
            if (other != null)
            {
        //        assert(other instanceof cMesh);
            }

            cMesh meshthis = (cMesh) this;

            /*
            if (meshthis.Phys == null)
                meshthis.InitPhysics();

            meshthis.Phys.SetPose(other);
             */
            meshthis.pose = other;
        }
        
     //   if (other != null)
     //       assert(Size() == other.Size());
        
        for (int i=0; i < Size(); i++)
        {
            Object3D obj = get(i);
            
            if (other != null)
            {
                Object3D obj2 = other.get(obj.name);
                
                if (obj2 == null) // ?
                    obj2 = other.get(i);
                    
                obj.poseMeshThis(obj2);
            }
            else
                obj.poseMeshThis(null);
        }
        
        blockloop = false;
    }
    
    void ResetTransparency()
    {
        //System.out.println("ResetTransparency " + this); //new Exception().printStackTrace();
        viewCode = -1;
        if (parent != null)
        {
            parent.ResetTransparency();
        }
    }

    void ClearMaterial()
    {
        // nov 2012 if (parent != null)
        {
            material = null;
       //     if (projectedVertices.length > 0)
       //     {
       //         projectedVertices[0] = null;
       //     } // Others
            SoftTouch();
            ResetTransparency();
        }
    }

    void ClearMaterialS()
    {
        if (selection.size() == 0)
        {
            //super.ClearMaterial();
        } else
        {
            for (int i = 0; i < selection.size(); i++)
            {
                Object3D o = (Object3D) selection.get(i);
                if (o == this)
                {
                    //super.
                            ClearMaterial();
                    continue;
                }
                o.ClearMaterial();
            }
        }
    }
    
    void CreateMaterial()
    {
        CreateMaterial(false);
    }
    
    void CreateMaterialS(boolean multiply)
    {
        if (selection.size() == 0)
        {
            //super.CreateMaterial(multiply);
        } else
        {
            for (int i = 0; i < selection.size(); i++)
            {
                Object3D o = (Object3D) selection.get(i);
                if (o != this)
                {
                    o.CreateMaterial(multiply);
                } else
                {
                    //super.
                            CreateMaterial(multiply);
                }
            }
        }
    }
    
    void CreateMaterial(boolean multiply)
    {
        if (/*parent != null &&*/ material == null)
        {
            material = new cMaterial(GetMaterial());
            
            InitOthers();
            
            material.multiply = multiply;
            
            if (multiply)
            {
                material.color = 
                material.modulation =
                material.metalness =
                material.diffuse =
                material.specular =
                material.shininess =
                material.shift =
                material.ambient =
                material.lightarea =
                material.factor =
                material.velvet =
                material.sheen =
                material.subsurface =
                material.bump =
                material.aniso =
                material.anisoV =
                material.cameralight =
                material.diffuseness =
                material.shadow =
                material.texture =
                material.opacity =
                material.fakedepth =
                material.shadowbias = 0.5f;
            }
            
            SoftTouch();
            ResetTransparency();
        }
    }

    void setParent(Object3D /*Composite*/ parent)
    {
        this.parent = parent;
    }
    
    
    transient // mar 2014
            boolean blockloop = false;
    transient // june 2014
            boolean blockdraw = false;

    boolean IsContainedIn(Object o)
    {
        if (this == o)
        {
            return true;
        }

        if (parent == null)
        {
            return false;
        }

        if (blockloop)
        {
            blockloop = false;
            return false;
        }

        boolean b = false;
        try
        {
            /*parent.*/            blockloop = true;
            b = parent.IsContainedIn(o);
            /*parent.*/            blockloop = false;
        } catch (Error e)
        {
            System.out.println(e);
        }

        return b;
    }

    void UpdateMaterial(cMaterial anchor, cMaterial current, boolean propagate)
    {
        if (blockloop)
        {
            return;
        }

//        super.UpdateMaterial(anchor, current, false);
        if (material != null)
        {
            material.UpdateMaterial(anchor, current);
        }

        if (!propagate)
        {
            return;
        }

        for (int i = 0; i < Children().size(); i++)
        {
            Object3D child = (Object3D) Children().reserve(i);
            if (child == null)
                continue;
            blockloop = true;
            child.UpdateMaterial(anchor, current, propagate);
            blockloop = false;
            Children().release(i);
        }

        int temp = count;

        count = 0; // try leaf
        for (int i = 0; i < Children().size(); i++)
        {
            Object3D child = (Object3D) Children().reserve(i);
            if (child == null)
                continue;
            blockloop = true;
            child.UpdateMaterial(anchor, current, propagate);
            blockloop = false;
            Children().release(i);
        }

        count = temp;
    }

    void openEditWindow(GroupEditor callee, boolean newWindow) // , boolean root)
    {
   // NEW sept2012
        if (editWindow == null || (newWindow && editWindow != callee.GetEditor()))
        {
            createEditWindow(callee, newWindow); //, root);
        /*
        if(editWindow != null)
        {
        editWindow.setTitle(name);
        editWindow.show();
        }
         */
        }
        else
        {
            //((ObjEditor)editWindow).SetupUI2(null);
            if (objectUI != null)
                ((ObjEditor)objectUI).pinButton.setSelected(pinned);
            else
                //new Exception().printStackTrace();
                System.err.println("objectUI is null");
        }
    }

    void createEditWindow(GroupEditor callee, boolean newWindow) //, boolean root)
    {
        if (newWindow)
        {
                new Exception().printStackTrace();
            System.exit(0);
            if (parent != null)
            {
                editWindow = new ObjEditor(this, deepCopy(), callee);
            } else
            {
                editWindow = new ObjEditor(this, this, callee);
            }

            editWindow.SetupWindow(); // PATCH!!
        } else
        {
            objectUI = new ObjEditor(this, callee);
            editWindow = objectUI.GetEditor();
            ((ObjEditor) objectUI).SetupUI2(callee);
        }
    }

    void closeEditWindow()
    {
        if (editWindow != null)
        {
            editWindow.Clear();
            editWindow.frame.dispose();
        }
        editWindow = null;
    }

    void refreshEditWindow()
    {
        if (editWindow != null)
        {
            editWindow.refreshContents();
        }
        else
        {
            if (manipWindow != null)
            {
                manipWindow.refreshContents();
            }
        }
                
    //if (parent != null)
    //parent.refreshEditWindow();
    }

//    public void applySelf()
//    {
//        if (editWindow != null)
//        {
//            editWindow.applySelf();
//        }
//
//        refreshEditWindow();
//    }

//    void ClearUI()
//    {
//        CloseUI();
//    }

    static int debugdepth; // 
    
    void ClearUI()
    {
        if (blockloop)
        {
            return;
        }
        
        //super.ClearUI();
        CloseUI();
        for (int i = 0; i < Children().Size(); i++)
        {
            Object3D child = (Object3D) Children().get(i); // reserve(i);
            if (child == null)
                continue;
            blockloop = true;
            if (debugdepth == 0)
                i = - -i;
            if (debugdepth == 1)
                i = - -i;
            if (debugdepth == 2)
                i = - -i;
            debugdepth++;
            child.ClearUI();
            debugdepth--;
            blockloop = false;
            //Children().release(i);
        }
    }

    void addSelectee(Object3D child)
    {
        // We accept multiple link...
        if (false) // selectees.indexOf(child) != -1)
        {
            //assert (selectees.indexOf(child) == -1);
            System.out.println("Child = " + child + "; this = " + this);
            new Exception().printStackTrace();
        }

        if (selection != null)
            selection.addElement(child);
    //? child.SoftTouch();
    }

    void removeSelectee(Object3D child)
    {
        selection.removeElement(child);
    //? child.SoftTouch();
    }

    transient private Object3D childToDrag;
    
    transient private int doSomething;
//    transient private Object3D childToDrag;
    private static final int doNothing = 0;
    private static final int editSelf = 1;
    private static final int editChild = 2;
    
    void drawEditHandles(//ClickInfo info,
            int level)
    {
        if (level == 0)
        {
            if (selection == null)
                return;
            
            Object3D selectee;
            for (java.util.Enumeration e = selection.elements(); e.hasMoreElements(); selectee.drawEditHandles(//info,
                                                                                                        level + 1))
            {
                selectee = (Object3D) e.nextElement();
            }

        } else
        {
            //super.
                    drawEditHandles0(//info,
                            level + 1);
        }
    }

    boolean doEditClick(//ClickInfo info,
            int level)
    {
        doSomething = 0;
        if (level == 0)
        {
            return doParentClick(); //info);
        }
        if (//super.
                doEditClick0(//info,
                    level))
        {
            doSomething = 1;
            return true;
        } else
        {
            return false;
        }
    }

    boolean doParentClick() //ClickInfo info)
    {
        if (selection == null)
        {
            new Exception().printStackTrace();
            return false;
        }
        
        boolean retval = false;

        for (java.util.Enumeration e = selection.elements(); e.hasMoreElements();)
        {
            Object3D selectee = (Object3D) e.nextElement();
            if (selectee.doEditClick(//info,
                    1))
            {
                childToDrag = selectee;
                doSomething = 2;
                //return true;
                retval = true;
            }
        }

        return retval;
    }

    void doEditDrag(//ClickInfo clickInfo,
            boolean opposite)
    {
        switch (doSomething)
        {
            case 1: // '\001'
                //super.
                        doEditDrag0(//clickInfo,
                                opposite);
                break;

            case 2: // '\002'
                // Use childToDrag for specific selection
                for (int i = 0; i < selection.size(); i++)
                {
                    Object3D sel = selection.get(i);
                    //System.out.println(" sel = " + sel);
                    if (sel != this) // childToDrag != this)
                    {
                        //sel.hitSomething = childToDrag.hitSomething;
                        //childToDrag.doEditDrag(info);
                        sel.doEditDrag(//clickInfo,
                                opposite);
                    } else
                    {
                        //super.
                                doEditDrag0(//clickInfo,
                                        opposite);
                    }
                }
                break;
        }
    }

    Object3D Children()
    {
        return this;
    }
    
    boolean doSelection(ClickInfo info, Rectangle r, int level)
    {
        if (level == 0)
        {
            deselectAll();
        }
        
        new Exception().printStackTrace();
        
        ClickInfo newInfo = new ClickInfo();
        newInfo.flags = info.flags;
        newInfo.bounds = info.bounds;
        newInfo.camera = info.camera;
        newInfo.g = info.g;
        newInfo.toScreen = info.toScreen;

        if (newInfo.toScreen == null)
        {
            newInfo.toScreen = info.camera.toScreen;
        }
        if (level > 0)
        {
            newInfo.toScreen = new double[4][4];
            LA.matConcat(toParent, info.toScreen, newInfo.toScreen);
        }
        boolean temp = false;
        Object3D child;
        int nb = Children().size();
        for (int i = 0; i < nb; i++)
        {
            child = (Object3D) Children().reserve(i);
            boolean doSelect = child.doSelection(newInfo, r, level + 1);
            Children().release(i);

            if (doSelect)
            {
                temp = true;
                if (level == 0)
                {
                    addSelectee(child);
                }
            }
        }

        if (level == 0 && editWindow != null)
        {
            editWindow.refreshContents();
        }
        return temp;
    }

    void deselectAll()
    {
        childToDrag = null;

        if (selection == null)
            selection = new Object3D(); // new Exception().printStackTrace();
        else
            selection.clear();
    //? SoftTouch();
    }

    void ClearSelection(boolean all)
    {
        if (all || (selection.size() > 0 && selection.get(0) == this))
        {
            selection.clear();
            for (Object3D child : this)
            {
                child.ClearUI();
            }
            this.clear();
        } else
        {
            Object3D selectee;
            for (; selection.size() > 0; selectee.ClearUI(), removeChild(selectee))
            {
                selectee = (Object3D) selection.elementAt(0);
            }
        }

        childToDrag = null;

        Touch();
    }
    
    void GenUVS()
    {
        selection.GenUVs();
//        for (int i=0; i<selection.size(); i++)
//        {
//            Object3D selectee = (Object3D) selection.elementAt(i);
//            selectee.GenUVs();
//        }

        //Touch();
    }

    void GenNormalsS(boolean crease)
    {
        selection.GenNormals(crease);
//        for (int i=0; i<selection.size(); i++)
//        {
//            Object3D selectee = (Object3D) selection.elementAt(i);
//            selectee.GenNormals(crease);
//        }

        //Touch();
    }

    void GenNormalsMeshS()
    {
        selection.GenNormalsMesh();
//        for (int i=0; i<selection.size(); i++)
//        {
//            Object3D selectee = (Object3D) selection.elementAt(i);
//            selectee.GenNormals(crease);
//        }

        //Touch();
    }

    void ClearColorsS()
    {
        selection.ClearColors();
//        for (int i=0; i<selection.size(); i++)
//        {
//            Object3D selectee = (Object3D) selection.elementAt(i);
//            selectee.ClearColors();
//        }

        //Touch();
    }

    void StripifyS()
    {
        selection.Stripify();
        
//        for (int i=0; i<selection.size(); i++)
//        {
//            Object3D selectee = (Object3D) selection.elementAt(i);
//            selectee.Stripify();
//        }

        //Touch();
    }

    void UnstripifyS()
    {
        selection.Unstripify();
        
//        for (int i=0; i<selection.size(); i++)
//        {
//            Object3D selectee = (Object3D) selection.elementAt(i);
//            selectee.Stripify();
//        }

        //Touch();
    }

    void TrimS()
    {
        selection.Trim();
//        for (int i=0; i<selection.size(); i++)
//        {
//            Object3D selectee = (Object3D) selection.elementAt(i);
//            selectee.Trim();
//        }

        //Touch();
    }

    void UntrimS()
    {
        selection.Untrim();
//        for (int i=0; i<selection.size(); i++)
//        {
//            Object3D selectee = (Object3D) selection.elementAt(i);
//            selectee.Untrim();
//        }

        //Touch();
    }

    void ReverseNormalsS()
    {
        selection.ReverseNormals();
//        for (int i=0; i<selection.size(); i++)
//        {
//            Object3D selectee = (Object3D) selection.elementAt(i);
//            selectee.ReverseNormals();
//        }

        //Touch();
    }
    
    void ParseS(iParse obj)
    {
        selection.Parse(obj);
//        for (int i=0; i<selection.size(); i++)
//        {
//            Object3D selectee = (Object3D) selection.elementAt(i);
//            selectee.Parse(obj);
//        }

        //Touch();
    }
    
    void ReverseTrianglesS()
    {
        selection.ReverseTriangles();
//        for (int i=0; i<selection.size(); i++)
//        {
//            Object3D selectee = (Object3D) selection.elementAt(i);
//            selectee.ReverseTriangles();
//        }

        //Touch();
    }
    
    void GenUVs()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        GenUVs0();
        for (int i = 0; i < Children().Size(); i++)
        {
            Object3D child = (Object3D) Children().get(i); // reserve(i);
            
            if (child == null)
                continue;
            
            child.GenUVs();
//            Children().release(i);
        }
        blockloop = false;
    }

    void GenNormals(boolean crease)
    {
        if (blockloop)
            return;
        
        blockloop = true;
        GenNormals0(crease);
        for (int i = 0; i < Children().Size(); i++)
        {
            Object3D child = (Object3D) Children().get(i); // reserve(i);
            if (child == null)
                continue;
            child.GenNormals(crease);
//            Children().release(i);
        }
        blockloop = false;
    }

    void GenNormalsMesh()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        GenNormalsMesh0();
        for (int i = 0; i < Children().Size(); i++)
        {
            Object3D child = (Object3D) Children().get(i); // reserve(i);
            if (child == null)
                continue;
            child.GenNormalsMesh();
//            Children().release(i);
        }
        blockloop = false;
    }

    void GenNormalsMINE()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        GenNormalsMINE0();
        for (int i = 0; i < Children().Size(); i++)
        {
            Object3D child = (Object3D) Children().get(i); // reserve(i);
            if (child == null)
                continue;
            child.GenNormalsMINE();
//            Children().release(i);
        }
        blockloop = false;
    }

    void ClearColors()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        ClearColors0();
        for (int i = 0; i < Children().size(); i++)
        {
            Object3D child = (Object3D) Children().get(i); // reserve(i);
            
            if (child == null)
                continue;
            
            child.ClearColors();
//            Children().release(i);
        }
        blockloop = false;
    }

    void Stripify()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        Stripify0();
        for (int i = 0; i < Children().Size(); i++)
        {
            Object3D child = (Object3D) Children().get(i); // reserve(i);
            
            if (child == null)
                continue;
            
            child.Stripify();
//            Children().release(i);
        }
        
        blockloop = false;
    }

    void Unstripify()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        Unstripify0();
        for (int i = 0; i < Children().Size(); i++)
        {
            Object3D child = (Object3D) Children().get(i); // reserve(i);
            
            if (child == null)
                continue;
            
            child.Unstripify();
//            Children().release(i);
        }
        
        blockloop = false;
    }

    void ReverseNormals()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        ReverseNormals0();
        for (int i = 0; i < Children().Size(); i++)
        {
            Object3D child = (Object3D) Children().get(i); // reserve(i);
            
            if (child == null)
                continue;
            
            child.ReverseNormals();
//            Children().release(i);
        }
        
        blockloop = false;
    }

    void Parse(iParse obj)
    {
        if (blockloop)
            return;
        
        blockloop = true;
        Parse0(obj);
        for (int i = 0; i < Children().Size(); i++)
        {
            Object3D child = (Object3D) Children().get(i); // reserve(i);
            
            if (child == null)
                continue;
            
            child.Parse(obj);
//            Children().release(i);
        }
        
        blockloop = false;
    }
    
    void ReverseTriangles()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        ReverseTriangles0();
        for (int i = 0; i < Children().Size(); i++)
        {
            Object3D child = (Object3D) Children().get(i); // reserve(i);
            
            if (child == null)
                continue;
            
            child.ReverseTriangles();
//            Children().release(i);
        }
        
        blockloop = false;
    }

    
    void GenUVs0()
    {
        if (bRep != null)
        {
            bRep.GenUV(); //1);
            //bRep.UnfoldUV();
            Touch();
        }
    }

    void GenNormals0(boolean crease)
    {
        if (bRep != null)
        {
            //bRep.GenerateNormals2(crease); // in-place doesn't work. it gives wrong normals (diamond artifact).
            bRep.GenerateNormals(crease);
            if (!bRep.trimmed)
                bRep.MergeNormals();
            Touch();
        }
    }

    void GenNormalsMesh0()
    {
        if (bRep != null)
        {
            bRep.GenerateNormalsMesh();
            Touch();
        }
    }

    void GenNormalsMINE0()
    {
        if (bRep != null)
        {
            bRep.MergeNormals(); //.GenerateNormalsMINE();
            Touch();
        }
    }

static double[][] tempmat = LA.newMatrix();

transient double[][] texturemat;

void KeepTextureMatrices()
{
    if (blockloop)
        return;
    
    blockloop = true;
    
    texturemat = null;
    
    if (this instanceof Texture || this instanceof TextureNode)
    {
        texturemat = toParent;
        toParent = null;
    }
    
    for (int i=Size(); --i>=0;)
    {
        Object3D v = get(i);

        v.KeepTextureMatrices();
    }
    
    blockloop = false;
}
            
void RestoreTextureMatrices()
{
    if (blockloop)
        return;
    
    blockloop = true;
    
    if (this instanceof Texture || this instanceof TextureNode)
    {
        toParent = texturemat;
        texturemat = null;
    }
    
    for (int i=Size(); --i>=0;)
    {
        Object3D v = get(i);

        v.RestoreTextureMatrices();
    }
    
    blockloop = false;
}
            
    public void ResetTransform(int mask)
    {
        Object3D obj = this;
        
        if (mask == -1)
        {
            if (obj instanceof Camera) // jan 2014
            {
                LA.matIdentity(obj.toParent);
                LA.matIdentity(obj.fromParent);
            }
            else
            {
                obj.toParent = null; // jan 2014 LA.matIdentity(obj.toParent);
                obj.fromParent = null; // LA.matIdentity(obj.fromParent);
            }
            return;
        }
        
        if ((mask&2) != 0) // Scale/rotation
        {
            obj.toParent[0][0] = obj.toParent[1][1] = obj.toParent[2][2] = 1;
            obj.toParent[0][1] = obj.toParent[1][0] = obj.toParent[2][0] = 0;
            obj.toParent[0][2] = obj.toParent[1][2] = obj.toParent[2][1] = 0;
            obj.fromParent[0][0] = obj.fromParent[1][1] = obj.fromParent[2][2] = 1;
            obj.fromParent[0][1] = obj.fromParent[1][0] = obj.fromParent[2][0] = 0;
            obj.fromParent[0][2] = obj.fromParent[1][2] = obj.fromParent[2][1] = 0;
        }
        if ((mask&1) != 0) // Translation
        {
            if (obj.toParent != null)
            {
                obj.toParent[3][0] = obj.toParent[3][1] = obj.toParent[3][2] = 0;
                obj.fromParent[3][0] = obj.fromParent[3][1] = obj.fromParent[3][2] = 0;
            }
        }
    }
    
    public void Scale(int scale)
    {
        Object3D obj = this;
        
        obj.toParent[0][0] = obj.toParent[1][1] = obj.toParent[2][2] = scale;
        obj.toParent[0][1] = obj.toParent[1][0] = obj.toParent[2][0] = 0;
        obj.toParent[0][2] = obj.toParent[1][2] = obj.toParent[2][1] = 0;
        obj.fromParent[0][0] = obj.fromParent[1][1] = obj.fromParent[2][2] = 1/scale;
        obj.fromParent[0][1] = obj.fromParent[1][0] = obj.fromParent[2][0] = 0;
        obj.fromParent[0][2] = obj.fromParent[1][2] = obj.fromParent[2][1] = 0;
    }
    
    public void TextureRatioTransform(int axis)
    {
        cTexture tex = GetTextures();

        com.sun.opengl.util.texture.TextureData texturedata = null;

        try
        {
            texturedata = Globals.theRenderer.GetTextureData(tex, false, texres);
        }
        catch (Exception e)
        {
            System.err.println("FAIL TextureRatio: " + this);
        }
        
        LA.matIdentity(Object3D.mat);
        Object3D.mat[axis][axis] = (double)texturedata.getWidth() / texturedata.getHeight();

        if (toParent == null)
        {
            toParent = LA.newMatrix();
            fromParent = LA.newMatrix();
        }

        ResetTransform(2);
        
        LA.matConcat(Object3D.mat, fromParent, fromParent);
        LA.matInvert(fromParent, toParent);
    }

    void TextureRatio(int axis)
    {
        if (blockloop)
            return;

        blockloop = true;
        
        TextureRatioTransform(axis);
        
        for (int i=Size(); --i>=0;)
        {
            Object3D v = get(i);

            v.TextureRatio(axis);
        }

        blockloop = false;
    }

    void TransformChildren()
    {
        if (toParent != null)
        {
            for (int i=Size(); --i>=0;)
            {
                Object3D v = get(i);

                if (v.toParent == null)
                {
                    v.toParent = LA.newMatrix();
                    v.fromParent = LA.newMatrix();
                }

//                LA.matConcat(v.toParent, toParent, v.toParent);
//                LA.matConcat(fromParent, v.fromParent, v.fromParent);
                LA.matConcat(toParent, v.toParent, v.toParent);
                LA.matConcat(v.fromParent, fromParent, v.fromParent);
            }

            toParent = null; // LA.matIdentity(toParent);
            fromParent = null; // LA.matIdentity(fromParent);

            Touch();
        }
    }
    
    void TransformGeometry()
    {
        Object3D obj = this;
        
//        if (obj.toParent == null)
//            return;

        if (obj.bRep != null)
        {
            if (obj.toParent != null)
                for (int i=obj.bRep.VertexCount(); --i>=0;)
                {
                    Vertex v = obj.bRep.GetVertex(i);

                    LA.xformPos(v, obj.toParent, v);
                    LA.matTranspose(obj.fromParent, tempmat);
                    //LA.xformPos(v.norm, obj.toParent, v.norm); // "RIGID"
                    if (v.norm != null) // nov 2013
                        LA.xformPos(v.norm, tempmat, v.norm);

                    obj.bRep.SetVertex(v, i);
                }

            obj.toParent = null; // LA.matIdentity(obj.toParent);
            obj.fromParent = null; // LA.matIdentity(obj.fromParent);

            obj.Touch();
        }
        else
        {
            for (int i=obj.Size(); --i>=0;)
            {
                Object3D v = obj.get(i);

                //if (!(obj instanceof Texture) && !(v instanceof Texture))
                {
                    if (v.toParent == null)
                    {
                        v.toParent = LA.newMatrix();
                        v.fromParent = LA.newMatrix();
                    }
                    
                    if (obj.toParent != null)
                    {
                        LA.matConcat(v.toParent, obj.toParent, v.toParent);
                        LA.matConcat(obj.fromParent, v.fromParent, v.fromParent);
                    }
                }
                
                v.TransformGeometry();
            }

            //if (!(obj instanceof Texture))
            {
                obj.toParent = null; // LA.matIdentity(obj.toParent);
                obj.fromParent = null; // LA.matIdentity(obj.fromParent);

                obj.Touch();
            }
        }
    }
    
    static boolean AOdone = false;
    
    void Stripify0()
    {
        //AOdone = false;
        if (bRep != null)
        {
            try
            {
                bRep.Stripify();
            }
            catch (Exception e)
            {
                System.err.println("STRIP FAILS: " + this);
                e.printStackTrace();
                System.err.println("STRIP FAILS: " + this);
            }
            Touch();
        }
    }
    
    void Unstripify0()
    {
        //AOdone = false;
        if (bRep != null)
        {
            try
            {
                bRep.Unstripify();
            }
            catch (Exception e)
            {
                System.err.println("UNSTRIP FAILS: " + this);
                e.printStackTrace();
                System.err.println("UNSTRIP FAILS: " + this);
            }
            Touch();
        }
    }
    
    void Trim()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        if (bRep != null)
        {
            bRep.Trim();
            Touch();
        }
        
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            child.Trim();
//            release(i);
        }
        
        blockloop = false;
    }

    void Untrim()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        if (bRep != null)
        {
            bRep.Untrim();
            Touch();
        }
        
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            child.Untrim();
//            release(i);
        }
        
        blockloop = false;
    }

    void ClearColors0()
    {
        AOdone = false;
        if (bRep != null)
        {
            bRep.ClearColors();
            Touch();
        }
    }

    void ReverseNormals0()
    {
        if (bRep != null)
        {
            bRep.ReverseNormals();
            Touch();
        }
    }

    void Parse0(iParse obj)
    {
        if (bRep != null)
        {
            //bRep.Parse(obj);

            for (int i = 0; i < bRep.VertexCount(); i++)
            {
                Vertex v = bRep.GetVertex(i);
                obj.Vertex(this, v);
            }
        
            if (!bRep.stripified)
            {
                for (int i = 0; i < bRep.FaceCount(); i++)
                {
                    Face f = bRep.GetFace(i);
                    obj.Face(this, f);
                }
            }
    
            Touch();
        }
    }

    void ReverseTriangles0()
    {
        if (bRep != null)
        {
            bRep.ReverseTriangles();
            Touch();
        }
    }

    void ReduceMesh(boolean reduction34, boolean onlyone)
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        if (bRep != null)
        {
            //bRep.RemoveOneTriangle();
        System.out.println();
        System.out.println("Reducing " + this);
        if (name != null && name.contains("lockpickstraps"))
            name = name;
        
        BoundaryRep sup = bRep.support;
        bRep.support = null;
        BoundaryRep temprep = (BoundaryRep) Grafreed.clone(bRep);
//            bRep.SplitInTwo(onlyone); // thread...
        
        while(temprep.SplitInTwo(reduction34, onlyone));
        
            bRep = temprep;
            bRep.support = sup;
            Touch();
        }
        else
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            child.ReduceMesh(reduction34, onlyone);
           // release(i);
        }
        
        blockloop = false;
    }

    void IncreaseMesh()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        if (bRep != null)
        {
            //bRep.RemoveOneTriangle();
        System.out.println("Increasing " + this);
            bRep.IncreaseMesh();
            Touch();
        }
        else
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            child.IncreaseMesh();
//            release(i);
        }
        
        blockloop = false;
    }

    void ClipMesh(Object3D clip)
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        if (bRep != null)
        {
            //bRep.RemoveOneTriangle();
        System.out.println("Clipping " + this);
            bRep.ClipMesh(clip, GlobalTransformInv());
            Touch();
        }
        else
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            child.ClipMesh(clip);
//            release(i);
        }
        
        blockloop = false;
    }

    void SmoothMesh()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        if (bRep != null)
        {
            //bRep.RemoveOneTriangle();
        System.out.println("Smoothing " + this);
            bRep.SmoothMesh();
            Touch();
        }
        else
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            child.SmoothMesh();
//            release(i);
        }
        
        blockloop = false;
    }

    void ClearMaterials()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        ClearMaterial();
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i);
            if (child == null)
                continue;
            child.ClearMaterials();
        }
        
        blockloop = false;
    }
    
    void ClearVersionList()
    {
        this.versionlist = null;
        this.versionindex = -1;
        this.versiontable = null;
    }
    
    void ClearVersions()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        ClearVersionList();
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i);
            if (child == null)
                continue;
            child.ClearVersions();
        }
        
        blockloop = false;
    }
    
    void FlipV(boolean flip)
    {
        flipV = flip;
        Touch();
        
        if (blockloop)
            return;
        
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            blockloop = true;
            child.FlipV(flip);
            blockloop = false;
        //    release(i);
        }
    }
    
    void LiveLeaves(boolean h)
    {
        if (blockloop)
            return;
        
        if (//marked || // does not make sense
                (bRep != null || material != null)) // borderline...
            live = h;
        
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            blockloop = true;
            child.LiveLeaves(h);
            blockloop = false;
        //    release(i);
        }
    }
    
    void SupportLeaves(boolean h)
    {
        if (blockloop)
            return;
        
        //if (bRep != null)
        if (//marked || // does not make sense
                (bRep != null || material != null)) // borderline...
            link2master = h;
        
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            blockloop = true;
            child.SupportLeaves(h);
            blockloop = false;
        //    release(i);
        }
    }
    
    void HideLeaves(boolean h)
    {
        if (blockloop)
            return;
        
        if (//marked || // does not make sense
                (bRep != null || material != null)) // borderline...
            hide = h;
        
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            blockloop = true;
            child.HideLeaves(h);
            blockloop = false;
         //   release(i);
        }
    }
    
    void MarkLeaves(boolean h)
    {
        if (blockloop)
            return;
        
        if (bRep != null || material != null) // borderline...
            marked = h;
        
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            blockloop = true;
            child.MarkLeaves(h);
            blockloop = false;
         //   release(i);
        }
    }
    
    void RewindLeaves(boolean h)
    {
        if (blockloop)
            return;
        
        if (bRep != null || material != null) // borderline...
            rewind = h;
        
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            blockloop = true;
            child.RewindLeaves(h);
            blockloop = false;
         //   release(i);
        }
    }
    
    void RandomLeaves(boolean h)
    {
        if (blockloop)
            return;
        
        if (bRep != null || material != null) // borderline...
            random = h;
        
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            blockloop = true;
            child.RandomLeaves(h);
            blockloop = false;
         //   release(i);
        }
    }
    
    void SetTexRes(int tr)
    {
        texres = tr;
        
        for (int i = 0; i < size(); i++)
        {
            Object3D child = (Object3D) reserve(i);
            if (child == null)
                continue;
            child.SetTexRes(tr);
            release(i);
        }
    }
    
    //transient
            BoundaryRep transientrep = null;
                
    BoundaryRep GetBRep()
    {
        if (bRep == null)
            return transientrep;
        
        return bRep;
    }
    
    void Revert()
    {
//        assert(false);
    }
    
    void RevertMeshes()
    {
        // BLOCKLOOP
        if (this instanceof cMesh)
        {
            ((cMesh)this).Revert();
            Touch();
        }
        
        for (int i = 0; i < size(); i++)
        {
            Object3D child = (Object3D) reserve(i);
            
            if (child == null)
                continue;
            
            child.RevertMeshes();
            release(i);
        }
    }
    
    void ResetAll()
    {
        if (blockloop)
            return;
        
        //if (this instanceof cMesh)
        {
            //((cMesh)this).
                    Reset();
            Touch();
        }
        
        for (int i = 0; i < size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            
            if (child == null)
                continue;
            
            blockloop = true;
            child.ResetAll();
            blockloop = false;
            //release(i);
        }
    }
    
    void StepAll()
    {
        if (blockloop)
            return;
        
        Step();
        Touch();
        
        StepRecur();
    }
    
    void StepRecur()
    {
        for (int i = 0; i < size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            
            if (child == null)
                continue;
            
            blockloop = true;
            child.StepAll();
            blockloop = false;
            //release(i);
        }
    }
    
    void ClearList()
    {
        if (bRep != null)
        {
            if (bRep.displaylist > 0)
            {
                CameraPane.RemoveList(bRep.displaylist);
            }
            bRep.displaylist = 0; // june 2013 -1;
            Touch();
        }
    }

    void retile()
    {
        retile(false);
    }

    void retile(boolean forced)
    {
    }

    void recalculate()
    {
        Touch();
    }

    void generatePOV(StringBuffer buffer)
    {
        generateNameComment(buffer);
    }

    void generateNameComment(StringBuffer buffer)
    {
        generateIndent(buffer);
        buffer.append("// ");
        buffer.append(name);
        buffer.append("\n");
    }

    void generateTransform(StringBuffer buffer)
    {
        if (LA.isIdentity(toParent))
        {
            generateIndent(buffer);
            buffer.append("    // identity transformation\n");
        } else
        {
            povDepth += 4;
            generateIndent(buffer);
            buffer.append("matrix <\n");
            povDepth += 4;
            for (int i = 0; i < 4; i++)
            {
                generateIndent(buffer);
                for (int j = 0; j < 3; j++)
                {
                    buffer.append(toParent[i][j]);
                    if (i != 3 || j != 2)
                    {
                        buffer.append(", ");
                    }
                }

                buffer.append("\n");
            }

            povDepth -= 4;
            generateIndent(buffer);
            buffer.append(">\n");
            povDepth -= 4;
        }
    }

    void generateIndent(StringBuffer buffer)
    {
        for (int i = 0; i < povDepth; i++)
        {
            buffer.append(' ');
        }

    }

    void getAverage(cVector average, boolean xform)
    {
        average.set(0,0,0);
        
        BoundaryRep usedrep = bRep;
        
        if (usedrep == null)
            usedrep = transientrep;

        if (usedrep == null)
            return;

        for (int i = 0; i < usedrep.VertexCount(); i++)
        {
            Vertex v = usedrep.GetVertex(i);
            
            average.add(v);
        }
        
        average.mul(1.0/usedrep.VertexCount());
        
        if (xform)
        {
            LA.xformPos(average, toParent, average);
        }
    }
    
    void getAverage(cVector average, boolean xform, double distance)
    {
        cStatic.point2.set(0,0,0);
        
        if (bRep == null)
        {
            return;
        }
        
        int count = 0;

        for (int i = 0; i < bRep.VertexCount(); i++)
        {
            Vertex v = bRep.GetVertex(i);

            cStatic.point1.set(v);
            cStatic.point1.sub(average); // means anchor
            
            if (cStatic.point1.dot(cStatic.point1) > distance*distance)
                continue;

            count++;
            cStatic.point2.add(v);
        }
        
        if (count > 0)
            cStatic.point2.mul(1.0/count);
        
        if (xform)
        {
            LA.xformPos(cStatic.point2, toParent, cStatic.point2);
        }
        
        average.set(cStatic.point2);
    }
    
    void TransformMesh(double[][] t)
    {
        if (blockloop)
            return;

        blockloop = true;

        for (int i=Size(); --i>=0;)
        {
            Object3D obj = get(i);
            
            obj.TransformMesh(t);
        }
        
        blockloop = false;

        if (bRep == null)
        {
            return;
        }

        bRep.Transform(t);
        
        Touch();
    }
    
    transient cVector min;
    transient cVector max;
    
    void getBounds(cVector minima, cVector maxima, boolean xform)
    {
        if (name != null && name.contains("Geometry:Mesh:Body"))
            name = name;
        
        minima.x = minima.y = minima.z = Double.POSITIVE_INFINITY;
        maxima.x = maxima.y = maxima.z = Double.NEGATIVE_INFINITY;

//    cVector min = new cVector();
//    cVector max = new cVector();
//    
        if (blockloop)
            return;
        
        if (min == null)
        {
            min = new cVector();
            max = new cVector();
        }
        
        for (int i = 0; i<Size(); i++)
        {
            Object3D child = (Object3D) get(i); //reserve(i);
            if (child == null)
                continue;
            
            if (Grafreed.RENDERME > 0)
            {
                if (child instanceof Merge)
                    ((Merge)child).renderme();
                
                if (child instanceof SwitchNode)
                    ((SwitchNode)child).Update();

                if (child.NeedSupport())
                    child.resetMasterNode(false); // live);
            }
                
            if (child.hide && !(child instanceof Merge) || child.skip)
            //if (child.hide)
            {
                //release(i);
                continue;
            }
            
                blockloop = true;
            child.getBounds(min, max, true); // xform);
                blockloop = false;
            //release(i);
            
            MinMax(minima, maxima);
        }
        
        if (bRep != null)
        {
            bRep.getBounds(minima, maxima, xform?this:null);
        }

        if (false) // xform)
        {
            transformBounds(minima, maxima);
        }
    }

    boolean getCentroid(cVector centroid, boolean xform)
    {
// for speaker        assert(false);
        if (blockloop)
            return false;
        
        if (min == null) // ???
        {
            min = new cVector();
            max = new cVector();
        }
        
        centroid.x = centroid.y = centroid.z = 0;
        
        int count = 0;
            
        if (size() > 0)
        {
            for (int i = size(); --i >= 0;)
            {
                Object3D child = (Object3D) reserve(i);
                if (child == null)
                    continue;
                if (child.hide && !(child instanceof Merge) || child.skip) // || child.size() == 0)
                {
                    release(i);
                    continue;
                }
                
                blockloop = true;
                boolean success = child.getCentroid(min, true); // xform);
                blockloop = false;
                release(i);

                if (!success)
                    continue;
                
                count++;
                centroid.x += min.x;
                centroid.y += min.y;
                centroid.z += min.z;
            }

            if (count == 0)
                return false; // fail
            
            assert(count > 0);
            {
                centroid.x /= count;
                centroid.y /= count;
                centroid.z /= count;
            }
        }
        
        if (bRep != null)
        {
            bRep.getCentroid(min, null);
            
            if (count > 0)
            {
                // ???
                assert(false);
                centroid.x += min.x; centroid.x /= 2;
                centroid.y += min.y; centroid.y /= 2;
                centroid.z += min.z; centroid.z /= 2;
            }
            else
                centroid.set(min);
        }
        else
        {
            //assert(count > 0);
            if (count == 0)
                return false;
        }

        if (xform && !(this instanceof Texture || this instanceof TextureNode))
        {
            for (int loop=GetTransformCount(); --loop>=0;)
            {
                LA.xformPos(centroid, toParent, centroid);
            }
            //LA.xformPos(centroid, toParent, centroid);
        }
        
        return true;
    }

    boolean getCentroid(cVector centroid) //, Object3D root)
    {
        if (blockloop)
            return false;
        
        //GraphreeD.tracein(this);
        
        if (min == null) // ???
        {
            min = new cVector();
            max = new cVector();
        }
        
        centroid.x = centroid.y = centroid.z = 0;
        
        int count = 0;
            
        if (size() > 0)
        {
            for (int i=0; i<size(); i++)
            {
                Object3D child = (Object3D) reserve(i);
                if (child == null)
                    continue;
                
                if (Grafreed.RENDERME > 0)
                {
                    if (child instanceof Merge)
                        ((Merge)child).renderme();
                    
                    if (child instanceof SwitchNode)
                        ((SwitchNode)child).Update();

                    if (child.NeedSupport())
                        child.resetMasterNode(false); // live);
                }
                    
                if (child.hide && !(child instanceof Merge) || child.skip) // || child.size() == 0)
                {
                    release(i);
                    continue;
                }
                
                blockloop = true;
                boolean success = child.getCentroid(min); // , this); // xform);
                blockloop = false;
                release(i);

                if (!success)
                    continue;
                
                count++;
                centroid.x += min.x;
                centroid.y += min.y;
                centroid.z += min.z;
            }

            if (count == 0)
                return false; // fail
            
            assert(count > 0);
            {
                centroid.x /= count;
                centroid.y /= count;
                centroid.z /= count;
            }
        }
        
        if (bRep != null)
        {
            bRep.getCentroid(min, this);
            
            if (count > 0)
            {
                // ???
                assert(false);
                centroid.x += min.x; centroid.x /= 2;
                centroid.y += min.y; centroid.y /= 2;
                centroid.z += min.z; centroid.z /= 2;
            }
            else
                centroid.set(min);
            
//            if (root != null && !(this instanceof Texture))
//            {
//                root.TransformToWorld(centroid);
//            }
        }
        else
        {
            //assert(count > 0);
            if (count == 0)
                return false;
        }

        //GraphreeD.traceout(this, centroid);
        
        return true;
    }

    boolean getFloor(cVector floor, boolean xform)
    {
        assert(false);
        
        if (blockloop)
            return false;
        
        if (min == null) // ???
        {
            min = new cVector();
            max = new cVector();
        }
        
        floor.x = floor.z = 0; //
        floor.y = Float.MAX_VALUE;
        
        int count = 0;
            
        if (size0() > 0)
        {
            for (int i = size0(); --i >= 0;)
            {
                Object3D child = (Object3D) reserve0(i);
                if (child == null)
                    continue;
                if (child.hide && !(child instanceof Merge) || child.skip) // || child.size() == 0)
                {
                    release(i);
                    continue;
                }
                blockloop = true;
                boolean success = child.getFloor(min, true); // xform);
                blockloop = false;
                release(i);

                if (!success)
                    continue;
                
                count++;
                if (floor.y > min.y)
                {
                    floor.y = min.y;
                    floor.x = min.x;
                    floor.z = min.z;
                }
            }

            if (count == 0)
                return false; // fail
//            
//            assert(count > 0);
//            {
//                centroid.x /= count;
//                centroid.z /= count;
//            }
        }
        
        if (bRep != null)
        {
            bRep.getFloor(min);
            
//            if (count > 0)
//            {
//                // ???
//                assert(false);
//                centroid.x += min.x; centroid.x /= 2;
//                centroid.y += min.y; centroid.y /= 2;
//                centroid.z += min.z; centroid.z /= 2;
//            }
//            else
                floor.set(min);
        }
        else
        {
            //assert(count > 0);
            if (count == 0)
                return false;
        }

        if (xform && !(this instanceof Texture || this instanceof TextureNode))
        {
            for (int loop=GetTransformCount(); --loop>=0;)
            {
                LA.xformPos(floor, toParent, floor);
            }
//            LA.xformPos(centroid, toParent, centroid);
        }
        
        return true;
    }

    long getFloor(cVector floor) //, Object3D root)
    {
        if (blockloop)
            return 0;
        
        long ID = 0;
        
        //GraphreeD.tracein(this);
        
        if (min == null) // ???
        {
            min = new cVector();
            max = new cVector();
        }
        
        floor.x = floor.z = 0; //
        floor.y = Float.MAX_VALUE;
        
        int count = 0;
            
        if (size/*0*/() > 0)
        {
            //for (int i = size/*0*/(); --i >= 0;)
            for (int i=0; i<size(); i++)
            {
                Object3D child = (Object3D) reserve/*0*/(i);
                if (child == null)
                    continue;
                
                if (Grafreed.RENDERME > 0)
                {
                    if (child instanceof Merge)
                        ((Merge)child).renderme();
                    
                    if (child instanceof SwitchNode)
                        ((SwitchNode)child).Update();

                    if (child.NeedSupport())
                        child.resetMasterNode(false); // live);
                }
                                        
                if (child.hide && !(child instanceof Merge/*Mocap??*/) /* && !child.live may 2014 */ || child.skip) // || child.size() == 0)
                {
                    release(i);
                    continue;
                }
                
                blockloop = true;
                long floorid = child.getFloor(min); //, this); // xform);
                blockloop = false;
                release(i);

                if (floorid == 0) // !success)
                    continue;

                count++;
                if (floor.y > min.y)
                {
                    ID = floorid * System.identityHashCode(child);
                
                    floor.y = min.y;
                    floor.x = min.x;
                    floor.z = min.z;
                }
            }
            
            //Dump(true);

            if (count == 0)
                return 0; // fail
//            
//            assert(count > 0);
//            {
//                centroid.x /= count;
//                centroid.z /= count;
//            }
        }
        
        boolean retval = true;
        
        if (bRep != null)
        {
            ID = bRep.getFloor(min, this);
            
//            if (count > 0)
//            {
//                // ???
//                assert(false);
//                centroid.x += min.x; centroid.x /= 2;
//                centroid.y += min.y; centroid.y /= 2;
//                centroid.z += min.z; centroid.z /= 2;
//            }
//            else
                floor.set(min);
                
//            if (root != null && !(this instanceof Texture))
//            {
//                root.TransformToWorld(floor);
//            }
        }
        else
        {
            //assert(count > 0);
            if (count == 0)
                ID = 0; // retval = false;
        }

        //GraphreeD.traceout(this, floor);
        
        return ID; // retval;
    }
    
    void RepairParent()
    {
        if (blockloop)
            return;
        
        for (int i=0; i<Size(); i++)
        {
            if (get(i).parent != this)
            {
System.err.println(get(i) + ": parent mismatch! " + ((get(i).parent == null)?"NULL":get(i).parent.GetPath()) + " vs " + GetPath());                
                get(i).parent = this;
            }
                blockloop = true;
            get(i).RepairParent();
                blockloop = false;
        }
    }
    
    void RepairShadow()
    {
        if (blockloop)
            return;
        
        if (this.material != null)
            this.InitOthers();
                
        for (int i=0; i<Size(); i++)
        {               
                blockloop = true;
            get(i).RepairShadow();
                blockloop = false;
        }
    }
    
    void RepairSOV()
    {
        if (blockloop)
            return;

        String texname = this.GetPigmentTexture();
        
        if (texname.startsWith("sov"))
        {
            String[] s = texname.split("/");

            String[] sname = s[1].split("Color.pn");
            
            texname = sname[0];
            
            if (sname.length > 1)
            {
                texname += "Color.jpg";
            }
            
            this.SetPigmentTexture("sov/" + texname);
        }
                
        texname = this.GetBumpTexture();
        
        if (texname.startsWith("sov"))
        {
            String[] s = texname.split("/");

            String[] sname = s[1].split("Bump.pn");
            
            texname = sname[0];
            
            if (sname.length > 1)
            {
                texname += "Bump.jpg";
            }
            
            this.SetBumpTexture("sov/" + texname);
        }
                
        for (int i=0; i<Size(); i++)
        {               
                blockloop = true;
            get(i).RepairSOV();
                blockloop = false;
        }
    }
    
    void RepairTexture()
    {
        if (this instanceof FileObject || blockloop)
            return;
        
        for (int i=0; i<size(); i++)
        {
            Object3D child = get(i);
            
            boolean replace = false;
            
            if (child instanceof Texture)
            {
                replace = true;
                Texture childtex = (Texture) child;
                TextureNode tex = new TextureNode();
                tex.name = childtex.name;
                tex.toParent = childtex.toParent;
                tex.fromParent = childtex.fromParent;
                tex.maxcount = childtex.maxcount;
                tex.transformcount = childtex.transformcount;
                tex.step = childtex.step;
                for (int j=0; j<child.size(); j++)
                {
                    tex.addChild(child.get(j));
                }
                child = tex;
            }
            
            blockloop = true;
            child.RepairTexture();
            blockloop = false;
            
//            try
//            {
            if (replace)
                set(i, child);
//            }
//            catch (Exception e)
//            {
//                e.printStackTrace();
//            }
        }
    }
    
//    int GetTransformCount()
//    {
//        return 1;
//    }

    void transformBounds(cVector minima, cVector maxima)
    {
        if (this instanceof Texture || this instanceof TextureNode)
        {
            return;
        }
        //for (int i=0; i < 3; i++)
        {
            tbMin.x = tbMin.y = tbMin.z = Double.POSITIVE_INFINITY; // ??? 1E+10;
            tbMax.x = tbMax.y = tbMax.z = Double.NEGATIVE_INFINITY; // -1E+10;
        }

        if (minima.x == Double.POSITIVE_INFINITY) // 1E10)
        {
            return;
        }

        for (int i = 0; i < 8; i++)
        {
            tbIn.x = i >= 4 ? maxima.x : minima.x;
            tbIn.y = (i / 2) % 2 != 0 ? maxima.y : minima.y;
            tbIn.z = i % 2 != 0 ? maxima.z : minima.z;
      //      tbOut.set(tbIn);
            for (int loop=GetTransformCount(); --loop>=0;)
            {
                LA.xformPos(tbIn, toParent, tbIn); // Out);
                //tbIn.set(tbOut);
            }
            tbOut.set(tbIn); //
            for (int j = 0; j < 3; j++)
            {
                if (tbOut.get(j) < tbMin.get(j))
                {
                    tbMin.set(j, tbOut.get(j));
                }
                if (tbOut.get(j) > tbMax.get(j))
                {
                    tbMax.set(j, tbOut.get(j));
                }
            }

        }

        LA.vecCopy(tbMin, minima);
        LA.vecCopy(tbMax, maxima);
    }

    void untransform(double x, double y, double z, cVector pnt)
    {
        if (fromParent == null) // aout 2013
        {
            pnt.x = x;
            pnt.y = y;
            pnt.z = z;
            return;
        }
        
        pnt.x = x * fromParent[0][0] + y * fromParent[1][0] + z * fromParent[2][0] + fromParent[3][0];
        pnt.y = x * fromParent[0][1] + y * fromParent[1][1] + z * fromParent[2][1] + fromParent[3][1];
        pnt.z = x * fromParent[0][2] + y * fromParent[1][2] + z * fromParent[2][2] + fromParent[3][2];
    }
    
    static Vertex[] vv = new Vertex[0];

    static class FaceInfo
    {
        cVector normal = new cVector();
        cVector pqnormal = new cVector();
        cVector qrnormal = new cVector();
        cVector rpnormal = new cVector();
        
        Vertex p;
    }
    
    transient FaceInfo[] faces = null;
    
    boolean insideMesh(double x, double y, double z, boolean untransform)
    {
        if (count <= 0)
        {
            return false;
        }

        // sept 2013
        if (true)
        {
            if (untransform)
            {
                untransform(x, y, z, v0);
            } else
            {
                LA.setVector(v0, x, y, z);
            }

            return bRep.inside(v0, this);
        }
        
        if (bRep == null)
        {
            System.out.println("INSIDE NULL OBJECT");
            return false;
        } else
        {
            if (faces == null || faces.length != bRep.FaceCount() /*???*/)
            {
                faces = new FaceInfo[bRep.FaceCount()];
                
                for (int i = bRep.FaceCount(); --i >= 0;)
                {
                    FaceInfo fi = faces[i] = new FaceInfo();
                    
                    Face f = bRep.GetFace(i);

                    if (f == null)
                        f = null;
                    
                    fi.p = bRep.GetVertex(f.p);
                    Vertex q = bRep.GetVertex(f.q);
                    Vertex r = bRep.GetVertex(f.r);

                    LA.vecSub(q, fi.p, v2);
                    LA.vecSub(r, fi.p, v3);
                    LA.vecCross(v2, v3, fi.normal);
                    LA.vecCross(fi.p, q, fi.pqnormal);
                    LA.vecCross(q, r, fi.qrnormal);
                    LA.vecCross(r, fi.p, fi.rpnormal);
                }
            }

            if (untransform)
            {
                untransform(x, y, z, v0);
            } else
            {
                LA.setVector(v0, x, y, z);
            }

            boolean inside = true;

            for (int i = bRep.FaceCount(); --i >= 0;)
            {
                FaceInfo f = faces[i];

                boolean ins = true;

                //LA.vecSub(f.p, v0, v5);
                v5.x = v0.x - f.p.x;
                v5.y = v0.y - f.p.y;
                v5.z = v0.z - f.p.z;
                
                //if (v5.dot(f.normal) > 0)
                if (v5.x*f.normal.x + v5.y*f.normal.y + v5.z*f.normal.z > 0)
                {
                    ins = false;
                }
//                else
//                {
//                    //if (f.pqnormal.dot(v0) < 0)
//                    if (f.pqnormal.x*v0.x + f.pqnormal.y*v0.y + f.pqnormal.z*v0.z < 0)
//                    {
//                        ins = false;
//                    } else
//                    {
//                        //if (f.qrnormal.dot(v0) < 0)
//                        if (f.qrnormal.x*v0.x + f.qrnormal.y*v0.y + f.qrnormal.z*v0.z < 0)
//                        {
//                            ins = false;
//                        } else
//                        {
//                            //if (f.rpnormal.dot(v0) < 0)
//                            if (f.rpnormal.x*v0.x + f.rpnormal.y*v0.y + f.rpnormal.z*v0.z < 0)
//                            {
//                                ins = false;
//                            }
//                        }
//                    }
//                }

//                inside ^= ins;
                
                if (!ins)
                {
                    inside = false;
                    break;
                }
            }

            return inside;
        }
    }
    
    boolean insideMesh0(double x, double y, double z, boolean untransform)
    {
        if (count <= 0)
        {
            return false;
        }

        if (bRep == null)
        {
            System.out.println("INSIDE NULL OBJECT");
            return false;
        } else
        {
            int j = bRep.VertexCount();
            if (vv.length < j)
            {
                vv = new Vertex[j];
            }

            for (; --j >= 0;)
            {
                vv[j] = bRep.GetVertex(j);
            }

            if (untransform)
            {
                untransform(x, y, z, v0);
            } else
            {
                LA.setVector(v0, x, y, z);
            }

            boolean inside = false;

            for (int i = bRep.FaceCount(); --i >= 0;)
            {
                Face f = bRep.GetFace(i);

                Vertex p = vv[f.p];
                Vertex q = vv[f.q];
                Vertex r = vv[f.r];

                boolean ins = true;

                LA.vecSub(p, r, v2);
                LA.vecSub(p, q, v3);
                LA.vecCross(v2, v3, v4);
                LA.vecSub(p, v0, v5);
                //LA.vecSub(q,v0, v6);
                //LA.vecSub(r,v0, v7);
                if (v5.dot(v4) > 0)
                {
                    ins = false;
                } else
                {
                    LA.vecCross(p, q, v1);
                    if (v1.dot(v0) < 0) // ^ v1.dot(r) < 0)
                    {
                        ins = false;
                    } else
                    {
                        LA.vecCross(q, r, v1);
                        if (v1.dot(v0) < 0) // ^ v1.dot(p) < 0)
                        {
                            ins = false;
                        } else
                        {
                            LA.vecCross(r, p, v1);
                            if (v1.dot(v0) < 0) // ^ v1.dot(q) < 0)
                            {
                                ins = false;
                            }
                        }
                    }
                }

                inside ^= ins;
            }

            return inside;
        }
    }

    void boxInside(double x[], double y[], double z[], boolean aflag[])
    {
    }
    
    
    boolean inside(double x, double y, double z, boolean xform)
    {
        if (count <= 0)
        {
            return false;
        }
        
    //    assert(xform);
        //System.out.println("inside = " + x + ", " + y + ", " + z);
        if (xform && fromParent != null)
        {
            untransform(x, y, z, cStatic.point1);
            x = cStatic.point1.x;
            y = cStatic.point1.y;
            z = cStatic.point1.z;
        }

        boolean inside = false;
        
        if (bRep != null)
        {
            if (insideMesh(x,y,z, true))
            {
                return true;
            }
        }

        for (int i = Children().size() - 1; i >= 0; i--)
        {
            Object3D child = (Object3D) Children().reserve(i);
            if (child == null)
                continue;
            if (child.inside(x, y, z, true)) // xform))
            {
                inside = true;
            }
            Children().release(i);
            if (inside)
            {
                break;
            }
        }

        return inside;
    }


    void draw(ClickInfo info, int level, boolean select)
    {
        drawSelf(info, level, select);
    }
    
    Object3D GetRoot()
    {
        if (parent == null)
            return this;
        
        return parent.GetRoot();
    }
    
    Object3D GetFileRoot()
    {
        if (overflow)
            return null;
        
        overflow = true;
            
        Object3D pfr = null;
        
        if (parent == null && fileparent == null)
            pfr = this;
        
        if (parent == null && fileparent != null) // V4.gfd???
            pfr = fileparent;
        
        if (pfr == null && parent == null)
            pfr = this;
        
        if (pfr == null)
            pfr = parent.GetFileRoot();
        
        overflow = false;
        
        return pfr;
    }
    
    cTreePath GetPath()
    {
        if (parent == null || blockloop)
            return new cTreePath(this);
        
        blockloop = true;
        cTreePath path = new cTreePath(parent.GetPath(), this);
        blockloop = false;
        
        return path;
    }
    
    Object3D GetObject(String[] tp, int index)
    {
        if (blockloop)
            return null;
        
        if (index >= tp.length)
            return this;
        else
        {
            for (int i = 0; i < size(); i++)
            {
                Object3D child = (Object3D) get(i); // reserve(i);

                if (child == null)
                    continue;
                
                //release(i);
                
                if (child.GetName().equals(tp[index]))
                {
                    blockloop = true;
                    Object3D o = child.GetObject(tp, index+1);
                    blockloop = false;
                    return o;
                }
            }
            return null;
        }
    }

    cTreePath GetTreePath(String[] tp, int index)
    {
        if (blockloop)
            return null;
        
        if (index >= tp.length)
            return new cTreePath(this);
        else
        {
            for (int i = 0; i < size(); i++)
            {
                Object3D child = (Object3D) get(i); // july 2013 reserve(i);

                if (child == null)
                    continue;
                
                //release(i);
                
                if (child.GetName().equals(tp[index]))
                {
                    blockloop = true;
                    cTreePath ctp = new cTreePath(this, child.GetTreePath(tp, index+1));
                    blockloop = false;
                    
                    return ctp;
                }
            }
            return null;
        }
    }

    cTreePath SelectLeaf(int indexcount, boolean deselect)
    {
        if (hide || dontselect)
            return null;
        
        if (count <= 0)
        {
            return null;
        }

        if (HasTransparency())
            return null;
        
        //assert parent != null;

        //System.out.println("Select : " + this);

        if (GetBRep() != null)
        {
            return CameraPane.Match(indexcount) ? new cTreePath(this) : null;
        } else
        {
            return null;
        }
    }
    
    ObjEditor GetWindow()
    {
        if (editWindow != null)
            return editWindow;
        
        return manipWindow;
    }
    
    cTreePath Select(int indexcount, boolean deselect)
    {
        if (hide || dontselect)
            return null;
            
        if (count <= 0)
        {
            return null;
        }

        if (GetBRep() != null)
        {
            cTreePath tp = SelectLeaf(indexcount, deselect);
            
//            //HANDLE
//            if (tp != null || !(this instanceof BezierPatch))
//                return tp;
            if (tp != null)
                return tp;
        }

        for (int i = 0; i < size(); i++)
        {
            Object3D child = (Object3D) reserve(i);

            if (child == null)
                continue;
            if (!child.HasTransparency())
            {
                cTreePath leaf = child.Select(indexcount, deselect);

                release(i);

                if (leaf != null)
                {
                    cTreePath tp = new cTreePath(this, leaf);
                    ObjEditor window = GetWindow();
                    if (window != null)
                    {
                        //System.out.println("editWindow = " + editWindow + " vs " + this);
                        window.Select(tp, deselect, true);
                    }

                    return tp;
                }
            } else
            {
                release(i);
            }
        }

        for (int i = 0; i < size(); i++)
        {
            Object3D child = (Object3D) reserve(i);

            if (child == null)
                continue;
            
            if (child.HasTransparency() && child.size() != 0)
            {
                cTreePath leaf = child.Select(indexcount, deselect);

                release(i);

                if (leaf != null)
                {
                    cTreePath tp = new cTreePath(this, leaf);
                    ObjEditor window = GetWindow();
                    if (window != null)
                    {
                        window.Select(tp, deselect, true);
                    }

                    return tp;
                }
            } else
            {
                release(i);
            }
        }

        return null;
    }

    /*transient*/ double[][] globalTransform = null; // new double[4][4];

    double[][] GlobalTransform()
    {
        if (globalTransform == null)
        {
            globalTransform = new double[4][4];
        }

        if (fromParent != null && !(this instanceof Texture || this instanceof TextureNode))
        {
            LA.matIdentity(globalTransform);
            for (int i=GetTransformCount(); --i>=0;)
                LA.matConcat(globalTransform, fromParent, globalTransform);
//            LA.matCopy(fromParent, globalTransform);
        }
        else
        {
            LA.matIdentity(globalTransform);
        }

        if (parent != null)
        //??
            //LA.matConcat(globalTransform, parent.GlobalTransform(), globalTransform);
        {
            LA.matConcat(parent.GlobalTransform(), globalTransform, globalTransform);
        }

        //System.out.println("Object = " + this + ";\n toParent = " + CameraPane.Matrix(toParent) + ";\n global = " + CameraPane.Matrix(globalTransform));

        return globalTransform;
    }

    double[][] GlobalTransformInv()
    {
        if (globalTransform == null)
        {
            globalTransform = new double[4][4];
        }

        if (blockloop)
        {
            LA.matIdentity(globalTransform);
            return globalTransform;
        }
        
        if (toParent != null && !(this instanceof Texture || this instanceof TextureNode))
        {
            LA.matIdentity(globalTransform);
            for (int i=GetTransformCount(); --i>=0;)
                LA.matConcat(globalTransform, toParent, globalTransform);
//            LA.matCopy(toParent, globalTransform);
        }
        else
        {
            LA.matIdentity(globalTransform);
        }

        if (parent != null) // || fileparent != null) // && parent.attributes == 0)
        //?? LA.matConcat(globalTransform, parent.GlobalTransform(), globalTransform);
        {
            blockloop = true;
            LA.matConcat(globalTransform, (parent!=null?parent:fileparent).GlobalTransformInv(), globalTransform);
            blockloop = false;
        }

        //System.out.println("Object = " + this + ";\n toParent = " + CameraPane.Matrix(toParent) + ";\n global = " + CameraPane.Matrix(globalTransform));

        return globalTransform;
    }

    void PreprocessOcclusion(iCameraPane cp)
    {
        /*
        if (AOdone)
            return;
        
        AOdone = true;
        */
        if (blockloop)
            return;
        
        if (count <= 0 || this instanceof Light)
            return;
        
        if (bRep != null)
        {
            System.out.println("processing " + this + ": " + bRep.VertexCount() // getRawVertices().length / 3)
                                                                    + " vertices...");
            bRep.PreprocessOcclusion(cp, GlobalTransformInv());
            Touch();
        }
        
        int nb = size();
        for (int i = 0; i < nb; i++)
        {
            // WARNING LOOP
            Object3D child = (Object3D) Children().reserve(i);
            //Object3D child = (Object3D) get(i);

            if (child == null)
                continue;

            blockloop = true;
            child.PreprocessOcclusion(cp);
            blockloop = false;

            Children().release(i);
        }
    }

    void addChild(Object3D child)
    {
        //new Exception().printStackTrace();
        /*children.*/addElement(child);
        /**/
        //System.out.println("Add " + child + " to " + this);
        //System.out.println("iscontained? " + IsContainedIn(child));
                 /**/
        if (child.parent == null || !IsContainedIn(child)) // criss de patch de fou...
        {
            child.setParent(this);
        //System.out.println("Set parent = " + child.parent);
        }

        Touch();
    }
    
//    void removeChild(Object3D child)
//    {
//    }
    void removeChild(Object3D child)
    {
        if (blockloop)
            return;
        
        /*
        child.setParent(null);
        Children().removeElement(child);
         */
        //System.out.println("child = " + child);
        //System.out.println("child.parent = " + child.parent);
        //System.out.println("this = " + this);

        if (Children().indexOf(child) >= 0)
        {
            child.setParent(null);
            Children().removeElement(child);
        } else
        {
            //	removeChild(child.parent);
            for (int i = 0; i < Children().size(); i++)
            {
                Object3D obj = (Object3D) Children().reserve(i);
                if (obj == null)
                    continue;
        blockloop = true;
                obj.removeChild(child);
        blockloop = false;
                Children().release(i);
            }
        }

        if (selection != null)
            selection.removeElement(child);

        Touch();
    }


    cTreePath GetTreePath()
    {
        if (parent == null || parent.IsContainedIn(this))
        {
            return new cTreePath(this);
        }

        return new cTreePath(parent.GetTreePath(), this);
    }

    void AppendSelectionTreePaths(Vector tps)
    {
    }
//    transient int displaylist = 0; // -1;
    transient boolean touched = true;
    transient boolean softtouched = true;

    void Touch()
    {
        memorysize = 0;
        
        CameraPane.touched = true;
        
        // should use blockloop instead...
        viewCode = -1;
        if (count <= 0)
        {
            return;
        }
        //System.out.println("Touch " + this); // new Exception().printStackTrace();
        //new Exception().printStackTrace();
        touched = true;

    softtouched = true;
    if (bRep != null)
    {
        CameraPane.RemoveList(bRep.displaylist);
        bRep.displaylist = 0; // june 2013 -1;
    }
        
        if (parent != null)
        {
            count--;
            parent.Touch();
            count++;
        } else //
        if (editWindow != null)
        {
            //editWindow.cameraView.lighttouched = true;
            Globals.lighttouched = true;
        }
    }

    void SoftTouch()
    {
        //System.out.println("SoftTouch " + this); //new Exception().printStackTrace();
        viewCode = -1;
        softtouched = true;
    CameraPane.touched = true;
    //touched = true; // tempo
    //if (parent != null)
    //	parent.Touch();
    }

    void HardTouch()
    {
        //System.out.println("HardTouch " + this); // new Exception().printStackTrace();
        //new Exception().printStackTrace();
        touched = true;
        CameraPane.touched = true;
    //if (parent != null)
    //	parent.Touch();
        
        if (bRep != null) // jan 2014
            bRep.vertextable = null;
    }

    transient
            boolean metablock; // grrr
    
    void ResetBlockLoop()
    {
        if (metablock)
            return;
        
        metablock = true;
        
        blockloop = false;
        
        for (int i = 0; i < Size(); i++)
        {
            Object3D child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            child.ResetBlockLoop();
        //    release(i);
        }
        
        metablock = false;
    }
    
    void ResetDisplayList()
    {
        if (blockloop)
            return;
        
        blockloop = true;
        
        //System.out.println("Reset " + this); // new Exception().printStackTrace();
        //new Exception().printStackTrace();
        if (bRep != null)
        {
            CameraPane.RemoveList(bRep.displaylist);
            bRep.displaylist = 0; // june 2013 -1;
        }
        
        touched = true;
        CameraPane.touched = true;
        
        // Patch...
        if (parent != null)
        {
            if (selection == null)
                selection = new Object3D();
            selection.clear();
        }

        Object3D child;
        int nb = Size();
        for (int i = 0; i < nb; i++)
        {
            child = (Object3D) get(i); // reserve(i);
            if (child == null)
                continue;
            child.ResetDisplayList();
        //    release(i);
        }
        
        blockloop = false;
    }

    void ResetSelectable()
    {
        if (blockloop)
            return;
        
        blockloop = true;

        keepdontselect = dontselect;
        dontselect = true;
        
        Object3D child;
        int nb = Size();
        for (int i = 0; i < nb; i++)
        {
            child = (Object3D) get(i);
            if (child == null)
                continue;
            child.ResetSelectable();
        }
        
        blockloop = false;
    }

    void RestoreSelectable()
    {
        if (blockloop)
            return;
        
        blockloop = true;

        dontselect = keepdontselect;
        
        Object3D child;
        int nb = Size();
        for (int i = 0; i < nb; i++)
        {
            child = (Object3D) get(i);
            if (child == null)
                continue;
            child.RestoreSelectable();
        }
        
        blockloop = false;
    }

    boolean IsSelected()
    {
        if (parent == null)
        {
            return false;
        }

        return true; // parent.IsSelected(this);
    }

    transient Object3D selection; // ??? = new Object3D(); // new selectees...
    
    protected void finalize()
    {
    //System.out.println(this + " (id=" + list + ") HAS BEEN DESTROYED...");
    //CameraPane.RemoveList(list);
    }
    
    String GetToolTip()
    {
        if (parent instanceof Mocap)
            return parent.GetToolTip();
        
        return name!=null?name:"NULL";
    }
    
    cTexture texture = null; // new cTexture("SERIAL");
    cTexture textures = null; // new cTexture("SERIAL");
    cTexture usedtextures = null; // new cTexture("SERIAL");

    cTexture GetTextures()
    {
        if (usedtextures == null)
        {
            // convert "texture" and "textures"
            if (texture == null && textures == null)
            {
                usedtextures = new cTexture(":");
            }
            else
            {
                if (texture == null)
                {
                    usedtextures = textures;
                }
                else
                {
                    usedtextures = texture;
                }
            }
        }
        
        return usedtextures;
    }
    
    static String GetPigment(cTexture fullname)
    {
        if (fullname == null)
            return "";
        
        if (fullname.pigment != null)
        {
            return fullname.pigment;
        }
        
   //     System.out.println("Fullname = " + fullname);
        
        // Does not work on Windows due to C:
//        if (fullname.name.indexOf(":") == -1)
//            return fullname.name;
//        
//        return fullname.name.substring(0,fullname.name.indexOf(":"));
        
        String[] split = fullname.name.split(":");
        
        if (split.length == 0)
        {
                return fullname.pigment = "";
        }
        
        if (split.length <= 2)
        {
                if (fullname.name.endsWith(":"))
                {
                        // Windows
                        return fullname.pigment = fullname.name.substring(0, fullname.name.length()-1);
                }
                
                return fullname.pigment = split[0];
        }
        
        // Windows
        assert(split.length == 4);
        
        return fullname.pigment = split[0] + ":" + split[1];
    }
    
    static String GetBump(cTexture fullname)
    {
        if (fullname == null)
            return "";
        
        if (fullname.bump != null)
        {
            return fullname.bump;
        }
        
  //      System.out.println("Fullname = " + fullname);
        // Does not work on Windows due to C:
//        if (fullname.name.indexOf(":") == -1)
//            return "";
//
//        return fullname.name.substring(fullname.name.indexOf(":")+1,fullname.name.length());
        String[] split = fullname.name.split(":");
        
        if (split.length == 0)
        {
                return fullname.bump = "";
        }
        
        if (split.length == 1)
        {
                return fullname.bump = "";
        }
        
        if (split.length == 2)
        {
                if (fullname.name.endsWith(":"))
                {
                        // Windows
                        return fullname.bump = "";
                }
                
                return fullname.bump = split[1];
        }
        
        // Windows
        assert(split.length == 4);
        
        return fullname.bump = split[2] + ":" + split[3];
    }
    
    String GetPigmentTexture()
    {
        return GetPigment(GetTextures());
    }
    
    String GetBumpTexture()
    {
        return GetBump(GetTextures());
    }
    
    void SetPigmentTexture(String tex)
    {
        if (tex != null && tex.toLowerCase().endsWith("tr.jpg"))
        {
            System.out.println("Processing transparency map... " + tex);
            
            try
            {
                BufferedImage tr = ImageIO.read(new java.io.File(tex));
                String pig = tex.substring(0, tex.length()-7);
                System.out.println("Processing pigment map... " + pig + ".jpg");
                BufferedImage pigment = ImageIO.read(new java.io.File(pig + ".jpg"));
                
//                assert(tr.getWidth() == pigment.getWidth());
//                assert(tr.getHeight() == pigment.getHeight());
                
                int minwidth = tr.getWidth();
                int minheight = tr.getHeight();
                
                if (minwidth > pigment.getWidth())
                {
                    minwidth = pigment.getWidth();
                }
                if (minheight > pigment.getHeight())
                {
                    minheight = pigment.getHeight();
                }
                
                BufferedImage rendImage = new BufferedImage(minwidth, minheight, BufferedImage.TYPE_INT_ARGB); // ImageIO.read(infile);
                
                for (int i=0; i<minwidth; i++)
                {
                    for (int j=0; j<minheight; j++)
                    {
                        int pix = pigment.getRGB(i * pigment.getWidth() / minwidth, j * pigment.getHeight() / minheight);
                        
                        pix &= 0xFFFFFF;
                        
                        int trpix = tr.getRGB(i * tr.getWidth() / minwidth, j * tr.getHeight() / minheight);
                        
                        trpix <<= 24; // -> Alpha
                        
                        rendImage.setRGB(i,j, pix | trpix);
                    }
                }
                //rendImage.setRGB(0,0,VPheight/16*16,VPwidth/2*2,pixels,VPheight*(VPwidth-1),-VPheight);
                ImageIO.write(rendImage, "png", new java.io.File(pig + ".png"));
                
                tex = pig + ".png";
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        
        System.out.print("Pigment = " + tex);
        System.out.print("; texture = " + texture);
        System.out.print("; textures = " + textures);
        System.out.println("; usedtextures = " + usedtextures);
        
        if (GetTextures() == null) // What is that??
            GetTextures().name = ":";
        
        String texname = tex;
        
        if (tex == null)
            texname = "";
        
        GetTextures().name = texname + ":" + GetBump(GetTextures());

        GetTextures().pigment = null;
        
        Touch();
    }

    void ResetPigmentTexture()
    {
        if (blockloop)
            return;
        
        SetPigmentTexture(null);
        
        int nb = Size();
        for (int i = 0; i < nb; i++)
        {
            Object3D child = (Object3D) get(i);

            if (child == null)
                continue;

            blockloop = true;
            child.ResetPigmentTexture();
            blockloop = false;
        }
    }
    
    UUID GetUUID()
    {
        if (uuid == null)
        {
            // Serial
            uuid = UUID.randomUUID();
        }
        
        return uuid;
    }
    
    Object3D GetObject(UUID uid)
    {
        if (blockloop)
            return null;
        
        if (GetUUID().equals(uid))
            return this;
        
        int nb = Size();
        for (int i = 0; i < nb; i++)
        {
            Object3D child = (Object3D) get(i);

            if (child == null)
                continue;

            blockloop = true;
            Object3D obj = child.GetObject(uid);
            blockloop = false;
            if (obj != null)
                return obj;
        }
        
        return null;
    }
    
    void SetBumpTexture(String tex)
    {
        if (GetTextures() == null)
            GetTextures().name = ":";
        
        String texname = tex;
        
        if (tex == null)
            texname = "";
        
        GetTextures().name = Object3D.GetPigment(GetTextures()) + ":" + texname;
        
        GetTextures().bump = null;
        
        Touch();
    }

    void ResetBumpTexture()
    {
        if (blockloop)
            return;
        
        SetBumpTexture(null);
        
        int nb = Size();
        for (int i = 0; i < nb; i++)
        {
            Object3D child = (Object3D) get(i);

            if (child == null)
                continue;

            blockloop = true;
            child.ResetBumpTexture();
            blockloop = false;
        }
    }
    
    void EmbedTextures(boolean embed)
    {
        if (blockloop)
            return;
        
        //if (GetTextures() != null)
        if (embed)
            CameraPane.EmbedTextures(GetTextures());
        else
        {
            GetTextures().pigmentdata = null;
            GetTextures().bumpdata = null;
            GetTextures().pw = 0;
            GetTextures().ph = 0;
            GetTextures().bw = 0;
            GetTextures().bh = 0;
        }
        
        int nb = Size();
        for (int i = 0; i < nb; i++)
        {
            Object3D child = (Object3D) get(i);

            if (child == null)
                continue;

            blockloop = true;
            child.EmbedTextures(embed);
            blockloop = false;
        }
    }
    
    void draw(iCameraPane display, Object3D /*Composite*/ root, boolean selected, boolean blocked)
    {
        Draw(display, root, selected, blocked);
    }
    
    boolean NeedSupport()
    {
        return
                CameraPane.SUPPORT && (!CameraPane.movingcamera || (!Globals.FREEZEONMOVE && Globals.isLIVE())) && link2master && /*live &&*/ support != null
                 // PROBLEM with CROWD!!
                    && (Globals.DrawMode() == iCameraPane.SHADOW || !Globals.RENDERSHADOW || Globals.CROWD);
    }
    
    static boolean DEBUG_SELECTION = false;
    
    boolean IsLive()
    {
        if (live)
            return true;
        
        if (parent == null)
            return false;
        
        return parent.IsLive();
    }
    
    boolean IsDynamic()
    {
        return live && bRep != null;
    }
    
    void Draw(iCameraPane display, Object3D /*Composite*/ root, boolean selected, boolean blocked)
    {
        Invariants(); // june 2013
            
        if (support != null)
        {
        //    System.err.println("Draw " + this + " Frame # " + ((Mocap)((Merge)support).object).frame);
        }
        
        if (display.DrawMode() == iCameraPane.SELECTION &&
                (hide || dontselect))
            return;

        if (name != null && name.contains("sclera"))
            name = name;
        
        if (NeedSupport())
            resetMasterNode(live);
        
//        if (hide)
//            return; // NEW!
        
        if (name != null && name.contains("sclera"))
            name = name;
        
        if (this instanceof Checker)
            return;
        
        if (display.DrawMode() == display.SHADOW && PASSTEST)
            return;
        
        if (count <= 0)
        {
            return;
        }

        if ((//display.DrawMode() == CameraPane.SHADOW ||
                display.DrawMode() == iCameraPane.SELECTION || display.IsDebugSelection()) && HasTransparency())
        {
            return;
        }
        
        //javax.media.opengl.GL gl = display.GetGL();

        /*
        if (touched)
        {
        if (list != -1)
        {
        System.out.println("del list " + list);
        gl.glDeleteLists(list,1);
        }
        list = -1;
        touched = false;
        }
         */

        if (support != null)
            support = support;
        
        boolean usecalllists = !IsDynamic() &&
                                    IsStatic() && GetBRep() != null && (!CameraPane.SUPPORT || support == null || !link2master); // !(this instanceof cSpring) && !(this instanceof BezierPatch);
        //boolean usecalllists = false; //!IsLive(); // IsStatic() && GetBRep() != null && (!CameraPane.SUPPORT || support == null) && !link2master; // !(this instanceof cSpring) && !(this instanceof BezierPatch);
        
        //usecalllists &= display.DrawMode() == display.DEFAULT; // Don't compute list in shadow pass.
        
        if (!usecalllists && bRep != null && bRep.displaylist > 0)
        {
            CameraPane.RemoveList(bRep.displaylist);
            bRep.displaylist = 0;
        }
   //     usecalllists &= !(parent instanceof RandomNode);
   //     usecalllists = false;

        if (display.DrawMode() == display.SHADOW)
            //GetBRep() != null)
            usecalllists = !!usecalllists;
        //System.out.println("draw " + this);
        //new Exception().printStackTrace();

        boolean compiled = false;

        boolean selectmode = display.DrawMode() == display.SELECTION || display.IsDebugSelection();
        
        if (!selectmode && //display.DrawMode() != display.SELECTION &&
                //(touched || (bRep != null && bRep.displaylist <= 0)))
                (Globals.isLIVE() && Globals.COMPUTESHADOWWHENLIVE || touched && Globals.COMPUTESHADOWWHENLIVE)) // || (bRep != null && bRep.displaylist <= 0)))
        {
            Globals.lighttouched = true;
        } // all panes...
        
        //if (usecalllists && display.DrawMode() != display.SELECTION && display.DrawMode() != display.SHADOW &&
        if (bRep != null && usecalllists && !selectmode && // june 2013 display.DrawMode() != display.SHADOW &&
                (touched || (bRep != null && bRep.displaylist <= 0)))
        {
            if (!(this instanceof Composite))
                touched = false;
            //if (displaylist == -1 && usecalllists)
            if (bRep.displaylist <= 0 && usecalllists) // && display.DrawMode() == display.DEFAULT) // june 2013
            {
                bRep.displaylist = display.GenList();
                assert(bRep.displaylist != 0);
//        System.err.println("glGenLists: " + bRep.displaylist + " for " + this);
                //System.out.println("\tgen list " + list);
    //            CameraPane.AddDuplicate(bRep.displaylist);
            }

            //System.out.println("\tnew list " + list);
            //gl.glDrawBuffer(gl.GL_NONE);
            if (usecalllists && bRep.displaylist > 0)
            {
//            System.err.println("new list " + bRep.displaylist + " for " + this);
                display.NewList(bRep.displaylist);
            }
            
            CallList(display, root, selected, blocked);
            
          //  compiled = true;
            if (usecalllists && bRep.displaylist > 0)
            {
//            System.err.println("end list " + bRep.displaylist + " for " + this);
                display.EndList();
            }
            //gl.glDrawBuffer(gl.GL_BACK);
            // XXX touched = false;
            Globals.lighttouched = true; // all panes...
        }

        //touched = GetBRep() == null; // this instanceof Composite || this instanceof FileObject; // false;
        touched = false;

        if (this instanceof Texture || this instanceof TextureNode)
        {
            //System.out.println("Texture = " + toParent);
            display.PushTextureMatrix(ToParent(), GetTransformCount());
        } else
        {
            //System.out.println("Model = " + toParent);
         //   if (!(this instanceof cMesh) || !((cMesh)this).live)
//            Invariants(); // june 2013
                display.PushMatrix(ToParent(), GetTransformCount());
         //   else
         //       display.PushMatrix();
                
            if (this instanceof Sphere)
            {
     //       //assert(LA.isIdentity(toParent));
     //           LA.matIdentity(mat);
     //           cVector c = ((Sphere)this).center;
     //           LA.matTranslate(mat, c.x, c.y, c.z);
     //       //System.out.println("Center = " + c);
     //           display.MultMatrix(mat);
            }
            if (!cLinker.stack.empty()) // cLinker.stack.peek() != null)
            {
                cVector peek = cLinker.stack.peek();
                LA.xformPos(peek, fromParent, peek);
            }
        }
        
        boolean culled = false;
        
        // frustum culling
        if (CameraPane.FRUSTUM && !blocked && !IsInfinite() && GetBRep() != null // && GetBRep().VertexCount() != 1260 // default grid
                && display.DrawMode() != iCameraPane.SELECTION)
        {
            if (display.DrawMode() == iCameraPane.SHADOW)
            {
                if (!link2master // tricky to cull in shadow mode.
                         && GetBRep().FrustumCull(this, null, display.LightCamera(), true))
                {
                    //System.out.print("CULLED");
                    culled = true;
                }
            }
            else
                //GetBRep().getBounds(v0, v1, this);
                if (GetBRep().FrustumCull(this, null, display.RenderCamera(), false))
                    culled = true;
            
//            LA.xformPos(v0, display.renderCamera.toScreen, v0);
//            
//            System.out.print("v0 = " + v0);
//            
//            LA.xformPos(v1, display.renderCamera.toScreen, v1);
//            
//            System.out.println("; v1 = " + v1);
//            
//            double fov =  display.renderCamera.shaper_fovy * Math.PI / 180;
//
//            // average
//            v2.set(v1);
//            v2.add(v0);
//            v2.mul(0.5);
//            
//            if (v2.z > 0)
//                return; // behind
//            
//            double atan00x = Math.abs(Math.atan2(v2.x,-v2.z));
//            double atan00y = Math.abs(Math.atan2(v2.y,-v2.z));
//            
//            System.out.print("FOV = " + fov);
//            System.out.print("; X = " + atan00x);
//            System.out.println("; Y = " + atan00y);
//            
//            if (atan00x > fov/4 ||
//                atan00y > fov/4 ||
//                false)
//                return;
        }


        if (!culled)
        if (display.DrawMode() == display.SELECTION || display.IsDebugSelection())
        {
            if (GetBRep() != null)
            {
                display.NextIndex();
                
                // vertex color conflict : gl.glCallList(list);
                DrawNode(display, root, selected);
                if (this instanceof BezierPatch)
                {
                    //drawSelf(display, root, selected);
                }
            }
            //else
            {
                drawSelf(display, root, selected, blocked);
            }
            
//            if (!(this instanceof Composite))
//            {
//                for (int i = 0; i < size(); i++)
//                {
//                    Object3D child = (Object3D) reserve(i);
//                    if (child == null)
//                        continue;
//
//                    child.draw(display, root, selected, blocked);
//
//                    release(i);
//                }
//            }
        } else
        {
            /*
            float[] color = { aColor.getRed() / 255.0f, aColor.getGreen() / 255.0f, aColor.getBlue() / 255.0f, 1 };
            gl.glMaterialfv(gl.GL_FRONT, gl.GL_AMBIENT_AND_DIFFUSE, color, 0);
            color[0] /= 2;
            color[1] /= 2;
            color[2] /= 2;
            gl.glMaterialfv(gl.GL_BACK, gl.GL_AMBIENT_AND_DIFFUSE, color, 0);
             */
                display.PushMaterial(this, selected);

            //System.out.println("call list " + list);
            //System.out.println();
            if (//selected)
                root != null && root.selection != null && root.selection.indexOf(this) != -1)
            {
                display.DrawString(this); // GetToolTip());
            }

    cTexture tex = null;

    if (//display.drawMode != display.SHADOW &&
            !selectmode//display.drawMode != display.SELECTION
            )
    {
        tex = GetTextures();
    }

    boolean failedPigment = false;
    boolean failedBump = false;
    
    CameraPane.lastObject = this;
    try
    {
        display.BindPigmentTexture(tex, texres);
    }
    catch (Exception e)
    {
    //    System.err.println("FAILED: " + this);
        failedPigment = true;
    }
           
    try
    {
        display.BindBumpTexture(tex, texres);
    }
    catch (Exception e)
    {
        //System.err.println("FAILED: " + this);
        failedBump = true;
    }
           
            if (!compiled)
            {
                if (bRep == null || (bRep != null && bRep.displaylist <= 0) || !IsStatic() /*???*/)
                {
                    CallList(display, root, selected, blocked);
                } else
                {
                    if (!display.IsFrozen() || selected)
                    {
                        if (bRep == null)
                            bRep = null;
                        
//        System.err.println("glCallList: " + bRep.displaylist + " for " + this);
                        assert(bRep.displaylist != 0);
                        display.CallList(bRep.displaylist);
// june 2013            drawSelf(display, root, selected);
                    }
                }
                
                assert (!(this instanceof Composite));
                {
// CRASH MOCAP!!                   for (int i = 0; i < size(); i++)
//                    {
//                        Object3D child = (Object3D) reserve(i);
//                        if (child == null)
//                            continue;
//
//                        child.draw(display, root, selected, blocked);
//
//                        release(i);
//                    }
                }
            }

    if (!failedBump)
        display.ReleaseBumpTexture(tex);

    if (!failedPigment)
        display.ReleasePigmentTexture(tex);

    display.PopMaterial(this, selected);
        }

        if (this instanceof Texture || this instanceof TextureNode)
        {
            display.PopTextureMatrix(FromParent());
        } else
        {
            /*
            System.out.println("PUSH2");
            LA.matPrint(fromParent);
            LA.matInvert(toParent, display.tmpmat);
            System.out.println("REAL2");
            LA.matPrint(display.tmpmat);
            System.out.println();
             */

            if (this instanceof Sphere)
            {
         //       LA.matIdentity(mat);
         //       cVector c = ((Sphere)this).center;
         //       LA.matTranslate(mat, -c.x, -c.y, -c.z);
         //       display.MultMatrix(mat);
            }
            
        //    if (!(this instanceof cMesh) || !((cMesh)this).live)
                display.PopMatrix(FromParent());
        //    else
        //        display.PopMatrix();
                
            if (!cLinker.stack.empty()) // cLinker.stack.peek() != null)
            {
                LA.xformPos(cLinker.stack.peek(), toParent, cLinker.stack.peek());
            }
        }

        softtouched = false;
//        
//        if (CameraPane.SUPPORT && link2master && /*live &&*/ support != null && display.drawMode != display.SHADOW)
//            resetMasterNode();
    }

    void CallList(iCameraPane display, Object3D /*Composite*/ root, boolean selected, boolean blocked)
    {
        if (GetBRep() != null)
        {
            DrawNode(display, root, selected);
            if (this instanceof BezierPatch)
            {
                //drawSelf(display, root, selected);
            }
        }
        else
        {
            drawSelf(display, root, selected, blocked);
        }
    }

    boolean doSelection0(ClickInfo info, Rectangle r, int level)
    {
        return doSelectionSelf(info, r, level);
    }

    boolean doSelectionSelf(ClickInfo info, Rectangle r, int level)
    {
        if (true) // bRep == null || level == 0)
        {
            return false;
        }
        int hc = info.bounds.x + info.bounds.width / 2;
        int vc = info.bounds.y + info.bounds.height / 2;
        //double mat[][] = new double[4][4];
        double[][] toscreen = info.toScreen;
        if (toscreen == null)
        {
            toscreen = info.camera.toScreen;
        }
        LA.matConcat(toParent, toscreen, mat);
        Vertex vertices[] = bRep.transform(mat);

        boolean perspective = info.camera.perspective;
        //? height = info.bounds.height;

        //System.out.println("focal? = " + info.camera.focalLength);
        for (int i = 0; i < vertices.length; i++)
        {
            Vertex vert = vertices[i];

            if (perspective)
            {
                vert./*pos.*/z /= height;
                vert./*pos.*/x /= vert./*pos.*/z;
                vert./*pos.*/y /= vert./*pos.*/z;
            }

            int x = hc + (int) vert./*pos.*/x;
            int y = vc - (int) vert./*pos.*/y;
            if (r.contains(x, y))
            {
                return true;
            }
        }

        return false;
    }
    
    static double[][] mat = new double[4][4];
    static int[] Xs = new int[3];
    static int[] Ys = new int[3];
    //static java.awt.Polygon triangle = new java.awt.Polygon(Xs, Ys, 3);
    static cVector v0 = new cVector();
    static cVector v1 = new cVector();
    static cVector v2 = new cVector();
    static cVector v3 = new cVector();
    static cVector v4 = new cVector();
    static cVector v5 = new cVector();
    static cVector v6 = new cVector();
    static cVector v7 = new cVector();
    static cVector v8 = new cVector();
    double[] model = null; // new double[16];

    static boolean PASSTEST;
    
    boolean flipV = false; // true;
    int texres = 0; // 0 = low, 1 = normal, 2 = high res texture
    
    void drawSelf(iCameraPane display, Object3D /*Composite*/ root, boolean selected, boolean blocked)
    {
        if (display.DrawMode() == iCameraPane.SELECTION && dontselect)
            return;
        
        if (hide)
            return;
        // shadow optimisation
//        if (display.drawMode == CameraPane.SELECTION && hide)
//            return;
//
//        if (!marked)
//        {
//            if (hide)
//                return;
//        }
//        else
//        {
//            if (display.drawMode == CameraPane.DEFAULT && !hide)
//                return;
//            
//            if (display.drawMode == CameraPane.SHADOW && hide)
//                return;
//        }
        
        
        //if (size() == 0)
        {
            DrawNode(display, root, selected);
            //return;
        }
//    }
//
//    void drawSelfOld(CameraPane display, Object3D /*Composite*/ root, boolean selected)
//    {
        if (count <= 0) // || display.IsFreezed())
        {
            return;
        }

        //if (depth == 0)
        //return;
        //Applet3D.tracein("draw", this);
        /*
        cTexture tex = null;

        if (display.drawMode != display.SELECTION &&
                display.drawMode != display.SHADOW) // transparency map?
        {
            tex = GetTextures();
        }

        //System.out.println("Object = " + this);

//        if (
            display.BindTextures(tex); // )
        */
        
//        {
//  // ???????????????????????????          Touch();
//        }

display.PushMaterial2(this, selected);

        Object3D child;
        boolean sel;
        int nb = size();
        /*
        for (int i=0; i<nb; i++, child.draw(display, selected || child.IsSelected())) // , level + 1, sel))
        {
        child = (Object3D) children.get(i);
        //sel = select;
        //if (level == 0 && IsSelected(child))
        sel = true;
        }
         */
        //depth -= 1;
        for (int i = 0; i < nb; i++)
        {
            child = (Object3D) reserve(i);
            if (child == null)
                continue;

            if (!child.HasTransparency())
            {
                sel = root != null && root.selection != null && root.selection.indexOf(child) != -1;
           //     GrafreeD.tracein("draw ", child);
                boolean wasblocked = blockdraw;
                blockdraw = true;
                child.draw(display, root, selected || sel, wasblocked || blocked); //  || child.IsSelected());
                blockdraw = false;
           // GrafreeD.traceout("draw ", child);
            }

            release(i);
        }
        /*
        for (int i = 0; i < nb; i++)
        {
            child = (Object3D) children.reserve(i);

            if (child.HasTransparency())
            {
                sel = root.selectees != null && root.selectees.indexOf(child) != -1;
                //Applet3D.tracein("T draw", child);
                child.draw(display, root, selected || sel); // || child.IsSelected());
            //Applet3D.traceout("draw", child);
            }

            children.release(i);
        }
         */
        //depth += 1;

display.PopMaterial2(this);        
/*
        display.ReleaseTextures(tex);
 */
    //Applet3D.traceout("draw", this);
    }
    
    boolean drawingstarted;

    //static cVector min,max;
    
    void DrawNode(iCameraPane display, Object3D /*Composite*/ root, boolean selected)
    {
        if (display.DrawMode() == display.SHADOW && projectedVertices != null && projectedVertices.length > 2 && projectedVertices[2].y >= 10000)
            return; // no shadow for transparent objects
        
        if (display.DrawMode() == iCameraPane.SELECTION && dontselect)
            return;
        
        if (hide)
            return;
        
        if (scriptnode != null)
        {
            scriptnode.DrawNode(display, root, selected);
        }
        
        // shadow optimisation
//        if (display.drawMode == CameraPane.SELECTION && hide)
//            return;
//
//        if (!marked)
//        {
//            if (hide)
//                return;
//        }
//        else
//        {
//            if (display.drawMode == CameraPane.DEFAULT && !hide)
//                return;
//            
//            if (display.drawMode == CameraPane.SHADOW && hide)
//                return;
//        }
        
        //if(count <= 0)
        //    return;
        if (this instanceof BezierPatch)
        {
            //drawSelf(display, root, selected);
            //return;
        }

        if (bRep == null)
        {
            //System.out.println("NULL boundary : " + this);
            return;
        }
        
        //bRep.GenUV(1/material.diffuseness);
//        bRep.lock = true;

        //javax.media.opengl.GL gl = display.GetGL();

        if (CameraPane.BOXMODE && !selected) // || CameraPane.movingcamera)
        {
            int fc = bRep.FaceCount();
            int vc = bRep.VertexCount();
            
            if (true) // fc > 100 || vc > 100)
            {
                if (min == null) // ???
                {
                    min = new cVector();
                    max = new cVector();
                }

                bRep.getMinMax(min, max, 100);
                
                display.DrawBox(min, max);
                
                return;
            }
        }
        
        drawingstarted = true;
        
        /*
        cTexture tex = null;

        if (display.drawMode != display.SELECTION &&
                display.drawMode != display.SHADOW)
        {
            tex = GetTextures();
        }

//        boolean bound = false;
        
//        if (
           display.BindTextures(tex); //)
        */
        
//        {
//            bound = true;
//// ?>????????????????????????            Touch();
//        }
        //else
        //    System.out.println("Object = " + this);

        boolean select = true; // false;

        // PATCH to clear verticesCopy
        if (bRep.trimmed)
        {
            bRep.getRawVertices();
        }

        //try
        //{
        if (bRep.stripified)
        {
            //throw new Error();

            boolean selectmode = display.DrawMode() == display.SELECTION || display.IsDebugSelection();

            int[] strips = bRep.getRawIndices();

            if (strips == null)
            {
                // dec 2012
                new Exception().printStackTrace();
                return;
            }
            
            if (dontselect)
            {
                //bRep.GenerateNormalsMINE();
            }
            
            display.DrawGeometry(bRep, flipV, selectmode);
        } else // catch (Error e)
        {
            // TRIANGLE ARRAY
            if (IsOpaque()) // Static())
            {
                    display.StartTriangles();
                int facecount = bRep.FaceCount();
                for (int i = 0; i < facecount; i++)
                {
          //              System.out.print("list = ");
          //          for (int k = 0; k < facecount; k++)
          //          {
          //              Face face = bRep.GetFace(k);
          //              System.out.print("[" + face.p + ", " + face.q + ", " + face.r + "] ");
          //          }
          //              System.out.println();

                    int index = 16; // bRep.VertexCount()/2;

                    if (bRep.FaceCount() != facecount)
                        index = 16;
                    
                    Face face = bRep.GetFace(i);
                    
                    if (bRep.FaceCount() != facecount)
                        index = 16;
                    
  //  if (face.p == index || face.q == index || face.r == index)
  //      continue;

                    // random
                    if (false) // ???? !IsStatic() && i<facecount-1)
                    {
                        int randomi = (int)(Math.random()*(facecount-i)) + i;

                        Face facerand = bRep.GetFace(randomi);
                        int k = face.p; face.p = facerand.p; facerand.p = k;
                        k = face.q; face.q = facerand.q; facerand.q = k;
                        k = face.r; face.r = facerand.r; facerand.r = k;
          //              System.out.println("randomi = " + randomi);
          //              System.out.print("    swap = ");
          //          for (k = 0; k < facecount; k++)
          //          {
          //              Face face2 = bRep.GetFace(k);
          //              System.out.print("[" + face2.p + ", " + face2.q + ", " + face2.r + "] ");
          //          }
          //              System.out.println();

                    }

          //          System.out.println("face = " + face.p + ", " + face.q + ", " + face.r);
                    Vertex p = bRep.GetVertex(face.p);
                    Vertex q = bRep.GetVertex(face.q);
                    Vertex r = bRep.GetVertex(face.r);

//                    v1.set(q);
//                    v1.sub(p);
//                    v2.set(r);
//                    v2.sub(p);
//
//                    v3.cross(v1, v2); // triangle normal
//                    v3.normalize();
//
//               //     if (p.norm.dot(v3) > -0.5 &&
//               //         q.norm.dot(v3) > -0.5 &&
//               //         r.norm.dot(v3) > -0.5)
//               //         continue;

                    display.DrawFace(this, p, q, r, face);
                }
                    display.EndTriangles();
            }
            else
            {
                // SORT
                int facecount = bRep.FaceCount();
                
                if (facescompare == null || facescompare.length != facecount)
                {
                    facescompare = new FaceCompare[facecount];
                    
                    for (int k=0; k<facecount; k++)
                    {
                        facescompare[k] = new FaceCompare(k);
                    }
                    
                    center = new cVector();
                }
                else
                {
                    for (int k=0; k<facecount; k++)
                    {
                        facescompare[k].distance = -1;
                    }
                }
                
                //System.out.println("SORT");
                
                java.util.Arrays.sort(facescompare);

                display.StartTriangles();
                for (int i = 0; i < facecount; i++)
                {
                    Face face = bRep.GetFace(facescompare[i].index);
                    
//    if (face.p == 0 || face.q == 0 || face.r == 0)
//        continue;

                    Vertex p = bRep.GetVertex(face.p);
                    Vertex q = bRep.GetVertex(face.q);
                    Vertex r = bRep.GetVertex(face.r);

                    display.DrawFace(this, p, q, r, face);
                }
                display.EndTriangles();
            }
            
            if (false) // live && support != null && support.bRep != null) // debug weights
            {
                    /*
                gl.glDisable(gl.GL_LIGHTING);
                float[] colorV = new float[3];
                
                cVector tmp = new cVector();
                
                //for (int object = 1; object < support.bRep.startvertices.length; object++)
                    //for (int i = support.bRep.startvertices[object-1]; i < support.bRep.startvertices[object]; i++)
                for (int i = 0; i < bRep.VertexCount()
                        ; i++)
                {
                    Vertex p = bRep.GetVertex(i);
                    
                    if (p.vertexlinks == null)
                        continue;
                    
                //    CameraPane.selectedpoint.
                //        getAverage(cStatic.point1, true);
                    cStatic.point1.set(0,0,0);
                    LA.xformPos(cStatic.point1, CameraPane.selectedpoint.toParent, cStatic.point1);

                    cStatic.point1.sub(p);
                    
                    if (cStatic.point1.dot(cStatic.point1) > 0.00001)
                        continue;
                    
            //        assert(p.weights[0] >= p.weights[1]);
                    
                    for (int object = 0; object < p.vertexlinks.length; object++)
                    {
                        if (p.weights[object] == 0) // /p.totalweight < 0.01)
                        {
                            //assert(p.weights[object] == 0);
                            continue;
                        }
                        
                        if (p.vertexlinks[object] == -1)
                            continue;
                        
                        Vertex q = support.bRep.GetVertex(p.vertexlinks[object]);
                        cVector n = q.norm;

                        int color = object+1;
                        colorV[2] = color&1;
                        colorV[1] = (color&2)>>1;
                        colorV[0] = (color&4)>>2;

                        colorV[0] *= p.weights[object]/p.totalweight;
                        colorV[1] *= p.weights[object]/p.totalweight;
                        colorV[2] *= p.weights[object]/p.totalweight;
                        
                gl.glColor3f(colorV[0], colorV[1], colorV[2]);
                gl.glMaterialfv(gl.GL_FRONT, gl.GL_DIFFUSE, colorV, 0);
                gl.glMaterialfv(gl.GL_BACK, gl.GL_DIFFUSE, colorV, 0);

                    //    gl.glColor3f(1, 1, 0);
                        gl.glBegin(gl.GL_LINES);
                        gl.glVertex3d(p.x, p.y, p.z);
                        gl.glVertex3d(q.x, q.y, q.z);
                        gl.glEnd();

                        Vertex s = support.bRep.GetVertex(p.vertexlinks2[object]);

                        gl.glColor3f(1, 1, 1);
                        gl.glBegin(gl.GL_LINES);
                        gl.glVertex3d(s.x, s.y, s.z);
                        gl.glVertex3d(q.x, q.y, q.z);
                        gl.glEnd();

//                        gl.glColor3f(1, 0, 1);
//                        gl.glBegin(gl.GL_LINES);
//                        gl.glVertex3d(q.x, q.y, q.z);
//                        tmp.set(n);
//                        tmp.mul(0.005);
//                        tmp.add(q);
//                        gl.glVertex3d(tmp.x, tmp.y, tmp.z);
//                        gl.glEnd();
                    }
                }
                     */
            }
        }

//        bRep.lock = false;
        /*
   //     if (bound)
            display.ReleaseTextures(tex);
         */
    }

    transient cVector center;
    
    class FaceCompare implements Comparable
    {
        int index;
        double distance = -1;
        
        FaceCompare(int k)
        {
            index = k;
        }
        
        public int compareTo(Object o)
        {
            FaceCompare facecomp = (FaceCompare) o;
            
            return (DistanceToCamera() < facecomp.DistanceToCamera()) ? 1 : -1;
        }
        
        double DistanceToCamera()
        {
            if (distance == -1)
            {
                Face face = bRep.GetFace(index);

                Vertex p = bRep.GetVertex(face.p);
                Vertex q = bRep.GetVertex(face.q);
                Vertex r = bRep.GetVertex(face.r);

                center.set(p);
                center.add(q);
                center.add(r);
                center.mul(1.0/3);
                
                center.sub(Globals.theRenderer.EyeCamera().location);
                
                distance = center.dot(center);
            }
            
            return distance;
        }
    }
    
    transient FaceCompare[] facescompare = null;
    
    void Print(Vertex v)
    {
        //System.err.println("(" + v.x + ", " + v.y + ", " + v.z + ")");
    }
    
    void drawSelf(ClickInfo info, int level, boolean select)
    {
        if (bRep == null)
        {
            System.out.println("NULL boundary 2 : " + this);
            return;
        }

        int hc = info.bounds.x + info.bounds.width / 2;
        int vc = info.bounds.y + info.bounds.height / 2;
        //double mat[][];
        double[][] toscreen = info.toScreen;
        if (toscreen == null)
        {
            toscreen = info.camera.toScreen;
        }

        if (level == 0)
        {
            //mat = info.toScreen;
            LA.matCopy(toscreen, mat);
        } else
        {
            //mat = new double[4][4];
            LA.matConcat(toParent, toscreen, mat);
        }

        Vertex vertices[] = bRep.transform(mat);

        boolean perspective = info.camera.perspective;
        assert (false);
        height = info.bounds.height;
        v0.set(info.camera.location);
        LA.vecSub(v0, info.camera.lookAt, v1);
        // SERIAL PATCH depth = (double) v1.length();
        //System.out.println("depth = " + depth);

        projectVertices(vertices, hc, vc, perspective);

        /*
        if (perspective)
        {
        for (int i=0; i<vertices.length; i++)
        {
        clipAndProject(height, vertices[i]);
        }
        }
         */

        //if (select) info.g.setColor(aColorSelect);
        //else info.g.setColor(aColor);

        if (info.camera.focalLength != 1)
        {
            for (int i = 0; i < vertices.length; i++)
            {
                Vertex vert = vertices[i];
                vert./*pos.*/x *= info.camera.focalLength; // * height;
                vert./*pos.*/y *= info.camera.focalLength; // * height;
            }
        }

        if (select)
        {
            fillColor = aColorSelect;
            lineColor = aLineColorSelect;
        } else
        {
            fillColor = aColor;
            lineColor = aLineColor;
        }

        for (int i = 0; i < bRep.FaceCount(); i++)
        {
            Face face = bRep.GetFace(i);
            // backfacing culling
            //if (face.norm == null || face.norm.z > 0)
            {
                Vertex pv = vertices[face.p];
                Vertex qv = vertices[face.q];
                Vertex rv = vertices[face.r];

                LA.vecSub(pv/*.pos*/, qv/*.pos*/, v0);
                LA.vecSub(pv/*.pos*/, rv/*.pos*/, v1);
                LA.vecCross(v0, v1, v2);

                if (perspective)
                {
                    double dot = LA.vecDot(v2, pv/*.pos*/);

                    face.dot = (int/*float*/) (dot / LA.vecLen(v2) / LA.vecLen(pv/*.pos*/));
                } else
                {
                    face.dot = (int/*float*/) (v2.z / LA.vecLen(v2));
                }
            }
        }

        for (int pass = 0; pass <= 1; pass++)
        {
            for (int i = 0; i < bRep.FaceCount(); i++)
            {
                Face face = bRep.GetFace(i);
                // backfacing culling
                //if (face.norm == null || face.norm.z > 0)
                {
                    //Vertex pv = vertices[face.p];
                    //Vertex qv = vertices[face.q];
                    //Vertex rv = vertices[face.r];

                    //LA.vecSub(pv/*.pos*/,qv/*.pos*/, v0);
                    //LA.vecSub(pv/*.pos*/,rv/*.pos*/, v1);
                    //LA.vecCross(v0,v1, v2);

                    //double dot = LA.vecDot(v2, pv/*.pos*/);

                    double dot = face.dot;

                    //if ((dot > 0) ^ (pass == 0))
                    if ((dot > 0) ^ (pass == 0))
                    {
                        Vertex pv = vertices[face.p];
                        Vertex qv = vertices[face.q];
                        Vertex rv = vertices[face.r];

                        //LA.vecNormalize(v2);
                        //LA.vecCopy(pv/*.pos*/, v0);
                        //LA.vecNormalize(v0);

                        //int j = (int) (LA.vecDot(v2, v0) * colorTable.length);
                        int j;

                        //if (!perspective)
                        j = (int) (dot * // / LA.vecLen(v2) / LA.vecLen(pv/*.pos*/) *
                                100); // colorTable.length);
                        //else
                        //	j = (int) (v2.z * // / LA.vecLen(v2) *
                        //		colorTable.length);

                        //if ((j > 0) ^ (pass == 0))
                        {
                            if (j > 0)
                            {
                                if (select)
                                {
                                    mode = EDGE;
                                } // |POINT;
                                else
                                {
                                    mode = FACE;
                                }
                            //pv.touched = true;
                            //qv.touched = true;
                            //rv.touched = true;
                            } else
                            {
                                if (select)
                                {
                                    mode = 0;
                                } // FACE; // |POINT;
                                else
                                {
                                    mode = EDGE;
                                }
                                j = -j;
                            }
                            /*
                            if (j == colorTable.length)
                            {
                            j -= 1;
                            }
                             */
                            fillColor = aColor; // tmpFillColor; //.set(aColor.getRed() * dot,
                            //aColor.getGreen() * dot,
                            //aColor.getBlue() * dot, 128); //colorTable[j];
                            drawFace(pv/*.pos*/, qv/*.pos*/, rv/*.pos*/,
                                    face.p, face.q, face.r,
                                    hc, vc,
                                    info.g, perspective);
                        }
                    }
                }
            }
        }

    /*
    if (false) // select)
    {
    info.g.setColor(lineColor);
    for (int i=0; i < vertices.length; i++)
    {
    Vertex vert = vertices[i];
    //if (perspective && LA.vecDot(vert.norm, vert) > 0 ||
    //!perspective && vert.norm.z > 0)
    if (vert.touched)
    {
    vert.touched = false;
    int x; // = hc + (int)usep.x;
    int y; // = vc - (int)usep.y;
    //if (perspective)
    //{
    cVector2 usep;
    usep = projectedVertices[i];
    x = usep.x;
    y = usep.y;
    //vert.z /= height;
    //vert.x /= vert.z;
    //vert.y /= vert.z;
    //}
    //else
    //{
    //usep = vert;
    //}
    info.g.fillOval(x-3, y-3, 7, 7);
    }
    }
    }
     */
    }

    void projectVertices(Vertex[] vertices, int hc, int vc, boolean perspective)
    {
        assert (false);
        if (projectedVertices.length < vertices.length)
        {
            projectedVertices = new cVector2[vertices.length];
            for (int i = 0; i < vertices.length; i++)
            {
                projectedVertices[i] = new cVector2();
            }
        }

        for (int i = 0; i < vertices.length; i++)
        {
            if (perspective)
            {
                project(vertices, i, hc, vc);
            } else
            {
                projectPara(vertices, i, hc, vc);
            }
        }
    }

    void project(Vertex[] v, int i, int hc, int vc)
    {
        cVector2 p = projectedVertices[i];
        cVector q = v[i]/*.pos*/;
        //p.z = q.z / height;
        p.x = (int) (hc + height * q.x / q.z);
        p.y = (int) (vc - height * q.y / q.z);
    }

    void projectPara(Vertex[] v, int i, int hc, int vc)
    {
        cVector2 p = projectedVertices[i];
        cVector q = v[i]/*.pos*/;
        p.x = (int) (hc + 200 * q.x); // /depth);
        p.y = (int) (vc - 200 * q.y); // /depth);
    }

    void clipAndProject(cVector pv, cVector qv, cVector rv, int behind)
    {
        if (behind == 1)
        {
            if (qv.z < 1)
            {
                LA.vecCopy(qv, pp);
                LA.vecCopy(rv, qq);
                LA.vecCopy(pv, rr);
            } else if (rv.z < 1)
            {
                LA.vecCopy(rv, pp);
                LA.vecCopy(pv, qq);
                LA.vecCopy(qv, rr);
            }
            double t = (1 - rr.z) / (pp.z - rr.z);
            ss.x = rr.x + t * (pp.x - rr.x);
            ss.y = rr.y + t * (pp.y - rr.y);
            ss.z = 1;
            t = (1 - qq.z) / (pp.z - qq.z);
            pp.x = qq.x + t * (pp.x - qq.x);
            pp.y = qq.y + t * (pp.y - qq.y);
            pp.z = 1;
        } else if (behind == 2)
        {
            if (qv.z >= 1)
            {
                LA.vecCopy(qv, pp);
                LA.vecCopy(rv, qq);
                LA.vecCopy(pv, rr);
            } else if (rv.z >= 1)
            {
                LA.vecCopy(rv, pp);
                LA.vecCopy(pv, qq);
                LA.vecCopy(qv, rr);
            }
            double t = (1.0 - qq.z) / (pp.z - qq.z);
            qq.x += t * (pp.x - qq.x);
            qq.y += t * (pp.y - qq.y);
            qq.z = 1;
            t = (1.0 - rr.z) / (pp.z - rr.z);
            rr.x += t * (pp.x - rr.x);
            rr.y += t * (pp.y - rr.y);
            rr.z = 1;
        }

        //pp.x *= height / pp.z;
        pp.z /= height;
        pp.x /= pp.z;
        pp.y /= pp.z;
        qq.z /= height;
        qq.x /= qq.z;
        qq.y /= qq.z;
        rr.z /= height;
        rr.x /= rr.z;
        rr.y /= rr.z;

        if (behind == 1)
        {
            ss.z /= height;
            ss.x /= ss.z;
            ss.y /= ss.z;
        }
    }

    // not used...
    void Toggle(int attr)
    {
        attributes ^= attr;
        ClearList();
    }

//    transient cVector buffer;
    
    double getFieldStrength(double x, double y, double z)
    {
//        if (buffer == null)
//            buffer = new cVector();
        
//        untransform(inpnt.x, inpnt.y, inpnt.z, buffer);
        untransform(x, y, z, cStatic.point1);
        x = cStatic.point1.x;
        y = cStatic.point1.y;
        z = cStatic.point1.z;
        
        double total = 0;
        
        int nb = size();
        
        for (int i = 0; i < nb; i++)
        {
            Object3D child = (Object3D) reserve(i);

            total += child.getFieldStrength(x,y,z);

            release(i);
        }
        
        return total;
    }
    
    void drawFace(cVector pv, cVector qv, cVector rv,
                  int indexp, int indexq, int indexr,
                  int hc, int vc, Graphics g, boolean perspective)
    {
        int behind = 0;

        cVector2 usep;
        cVector2 useq;
        cVector2 user;
        cVector2 uses = null;

        if (perspective)
        {
            if (pv.z < 1)
            {
                behind++;
            }
            if (qv.z < 1)
            {
                behind++;
            }
            if (rv.z < 1)
            {
                behind++;
            }

            if (behind == 3)
            {
                return;
            }

            if (behind != 0)
            {
                //LA.vecCopy(pv, pp);
                //LA.vecCopy(qv, qq);
                //LA.vecCopy(rv, rr);

                clipAndProject(pv, qv, rv, behind);

                pp2.x = (int) (hc + pp.x);
                pp2.y = (int) (vc - pp.y);
                qq2.x = (int) (hc + qq.x);
                qq2.y = (int) (vc - qq.y);
                rr2.x = (int) (hc + rr.x);
                rr2.y = (int) (vc - rr.y);

                if (behind == 1)
                {
                    ss2.x = (int) (hc + ss.x);
                    ss2.y = (int) (vc - ss.y);
                }

                usep = pp2;
                useq = qq2;
                user = rr2;
                uses = ss2;
            } else
            {
                usep = projectedVertices[indexp];
                useq = projectedVertices[indexq];
                user = projectedVertices[indexr];
            }
        } else
        {
            usep = projectedVertices[indexp];
            useq = projectedVertices[indexq];
            user = projectedVertices[indexr];
        //usep = pv;
        //useq = qv;
        //user = rv;
        }

        if (!perspective || behind == 0)
        {
            //g.drawLine(hc + (short)(int)pp.x, vc - (short)(int)pp.y, hc + (short)(int)qq.x, vc - (short)(int)qq.y);
            //g.drawLine(hc + (short)(int)qq.x, vc - (short)(int)qq.y, hc + (short)(int)rr.x, vc - (short)(int)rr.y);
            //g.drawLine(hc + (short)(int)rr.x, vc - (short)(int)rr.y, hc + (short)(int)pp.x, vc - (short)(int)pp.y);
            int Xs0 = Xs[0] = /*hc + (short)(int)*/ usep.x;
            int Ys0 = Ys[0] = /*vc - (short)(int)*/ usep.y;
            int Xs1 = Xs[1] = /*hc + (short)(int)*/ useq.x;
            int Ys1 = Ys[1] = /*vc - (short)(int)*/ useq.y;
            int Xs2 = Xs[2] = /*hc + (short)(int)*/ user.x;
            int Ys2 = Ys[2] = /*vc - (short)(int)*/ user.y;
            if ((mode & FACE) != 0)
            {
                g.setColor(fillColor);
                g.fillPolygon(Xs, Ys, 3); // triangle);
            }
            if ((mode & EDGE) != 0)
            {
                g.setColor(lineColor);
                g.drawPolygon(Xs, Ys, 3); // triangle);
            }
            /*
            CameraPane.allXs[CameraPane.allCount]   = Xs[0];
            CameraPane.allYs[CameraPane.allCount++] = Ys[0];
            CameraPane.allXs[CameraPane.allCount]   = Xs[1];
            CameraPane.allYs[CameraPane.allCount++] = Ys[1];
            CameraPane.allXs[CameraPane.allCount]   = Xs[2];
            CameraPane.allYs[CameraPane.allCount++] = Ys[2];
             */
            if (CameraPane.Xmin > Xs0)
            {
                CameraPane.Xmin = Xs0;
            }
            if (CameraPane.Xmin > Xs1)
            {
                CameraPane.Xmin = Xs1;
            }
            if (CameraPane.Xmin > Xs2)
            {
                CameraPane.Xmin = Xs2;
            }
            if (CameraPane.Xmax < Xs0)
            {
                CameraPane.Xmax = Xs0;
            }
            if (CameraPane.Xmax < Xs1)
            {
                CameraPane.Xmax = Xs1;
            }
            if (CameraPane.Xmax < Xs2)
            {
                CameraPane.Xmax = Xs2;
            }
            if (CameraPane.Ymin > Ys0)
            {
                CameraPane.Ymin = Ys0;
            }
            if (CameraPane.Ymin > Ys1)
            {
                CameraPane.Ymin = Ys1;
            }
            if (CameraPane.Ymin > Ys2)
            {
                CameraPane.Ymin = Ys2;
            }
            if (CameraPane.Ymax < Ys0)
            {
                CameraPane.Ymax = Ys0;
            }
            if (CameraPane.Ymax < Ys1)
            {
                CameraPane.Ymax = Ys1;
            }
            if (CameraPane.Ymax < Ys2)
            {
                CameraPane.Ymax = Ys2;
            }
        } else if (behind == 1)
        {
            g.drawLine(/*hc +*/(short) (int) usep.x, /*vc -*/ (short) (int) usep.y, /*hc +*/ (short) (int) useq.x, /*vc -*/ (short) (int) useq.y);
            g.drawLine(/*hc +*/(short) (int) useq.x, /*vc -*/ (short) (int) useq.y, /*hc +*/ (short) (int) user.x, /*vc -*/ (short) (int) user.y);
            g.drawLine(/*hc +*/(short) (int) user.x, /*vc -*/ (short) (int) user.y, /*hc +*/ (short) (int) uses.x, /*vc -*/ (short) (int) uses.y);
        } else
        {
            g.drawLine(/*hc +*/(short) (int) user.x, /*vc -*/ (short) (int) user.y, /*hc +*/ (short) (int) usep.x, /*vc -*/ (short) (int) usep.y);
            g.drawLine(/*hc +*/(short) (int) usep.x, /*vc -*/ (short) (int) usep.y, /*hc +*/ (short) (int) useq.x, /*vc -*/ (short) (int) useq.y);
        }
    }

    static ClickInfo clickInfo = new ClickInfo();
        
    protected void calcHotSpot(cVector in, //ClickInfo clickInfo,
            Point outPt, Rectangle outRec)
    {
        int hc = clickInfo.bounds.x + clickInfo.bounds.width / 2;
        int vc = clickInfo.bounds.y + clickInfo.bounds.height / 2;
        double[][] toscreen = clickInfo.toScreen;
        if (toscreen == null)
        {
            toscreen = new Camera(clickInfo.camera.viewCode).toScreen;
        }
        cVector vec = in;
        LA.xformPos(in, toscreen, in);
        //System.out.println("Distance = " + info.camera.Distance());
        vec.x *= 100 * clickInfo.camera.SCALE / clickInfo.camera.Distance();
        vec.y *= 100 * clickInfo.camera.SCALE / clickInfo.camera.Distance();
        outPt.x = hc + (int) vec.x;
        outPt.y = vc - (int) vec.y;
        outRec.x = outPt.x - 3;
        outRec.y = outPt.y - 3;
        outRec.width = outRec.height = 6;
    }

    protected Rectangle calcHotSpot(cVector in//, ClickInfo clickInfo
            )
    {
        Point pt = new Point(0, 0);
        Rectangle rec = new Rectangle();
        calcHotSpot(in, //clickInfo,
                pt, rec);
        return rec;
    }

    void drawEditHandles0(//ClickInfo clickInfo,
            int level)
    {
        if (level == 0)
        {
            return;
        } else
        {
            cVector origin = new cVector();
            //LA.xformPos(origin, toParent, origin);
            if (this.clickInfo == null)
                this.clickInfo = new ClickInfo();
            
            Rectangle spot = calcHotSpot(origin); //, clickInfo);
            Rectangle boundary = new Rectangle();
            boundary.x = spot.x - 30;
            boundary.y = spot.y - 30;
            boundary.width = spot.width + 60;
            boundary.height = spot.height + 60;
            clickInfo.g.setColor(Color.white);
            int spotw = spot.x + spot.width;
            int spoth = spot.y + spot.height;
            clickInfo.g.fillRect(spot.x, spot.y, spot.width, spot.height);
//            if (CameraPane.Xmin > spot.x)
//            {
//                CameraPane.Xmin = spot.x;
//            }
//            if (CameraPane.Xmax < spotw)
//            {
//                CameraPane.Xmax = spotw;
//            }
//            if (CameraPane.Ymin > spot.y)
//            {
//                CameraPane.Ymin = spot.y;
//            }
//            if (CameraPane.Ymax < spoth)
//            {
//                CameraPane.Ymax = spoth;
//            }
//            if (CameraPane.Xmin > spot.x)
//            {
//                CameraPane.Xmin = spot.x;
//            }
//            if (CameraPane.Xmax < spotw)
//            {
//                CameraPane.Xmax = spotw;
//            }
//            if (CameraPane.Ymin > spot.y)
//            {
//                CameraPane.Ymin = spot.y;
//            }
//            if (CameraPane.Ymax < spoth)
//            {
//                CameraPane.Ymax = spoth;
//            }
            // bonhommes info.g.drawLine(spotw, spoth, spotw, spoth - boundary.height/2); // 15
            //info.g.drawLine(spotw, spoth, spotw - boundary.width/2, spoth); // 15
            spot.translate(32, 0);
            clickInfo.g.setColor(Color.yellow);
            clickInfo.g.fillRect(spot.x, spot.y, spot.width, spot.height);
            
            spot.translate(32, 64);
            spotw = spot.x + spot.width;
            spoth = spot.y + spot.height;
            clickInfo.g.setColor(Color.cyan);
            clickInfo.g.fillRect(spot.x, spot.y, spot.width, spot.height);
//            if (CameraPane.Xmin > spot.x)
//            {
//                CameraPane.Xmin = spot.x;
//            }
//            if (CameraPane.Xmax < spotw)
//            {
//                CameraPane.Xmax = spotw;
//            }
//            if (CameraPane.Ymin > spot.y)
//            {
//                CameraPane.Ymin = spot.y;
//            }
//            if (CameraPane.Ymax < spoth)
//            {
//                CameraPane.Ymax = spoth;
//            }
            clickInfo.g.setColor(Color.green);
            clickInfo.g.drawArc(boundary.x + clickInfo.DX, boundary.y + clickInfo.DY,
                    (int)(boundary.width * clickInfo.W), (int)(boundary.height * clickInfo.W), 0, 360);
            //info.g.drawArc(spot.x, spotw, spot.width/2, boundary.height/2, 0, 360);
//            if (CameraPane.Xmin > boundary.x)
//            {
//                CameraPane.Xmin = boundary.x;
//            }
//            if (CameraPane.Xmax < boundary.x + boundary.width)
//            {
//                CameraPane.Xmax = boundary.x + boundary.width;
//            }
//            if (CameraPane.Ymin > boundary.y)
//            {
//                CameraPane.Ymin = boundary.y;
//            }
//            if (CameraPane.Ymax < boundary.y + boundary.height)
//            {
//                CameraPane.Ymax = boundary.y + boundary.height;
//            }
            return;
        }
    }

    boolean doEditClick0(//ClickInfo clickInfo, 
                int level)
    {
        if (level == 0)
        {
            return false;
        }

        boolean retval = false;

        startX = clickInfo.x;
        startY = clickInfo.y;

        hitSomething = -1;
        cVector origin = new cVector();
        //LA.xformPos(origin, toParent, origin);
        Rectangle spot = new Rectangle();
        if (centerPt == null)
        {
            centerPt = new Point(0, 0);
        }
        calcHotSpot(origin, //info,
                centerPt, spot);
        if (spot.contains(clickInfo.x, clickInfo.y))
        {
            hitSomething = hitCenter;
            retval = true;
        }
        spot.translate(32, 0);
        if (spot.contains(clickInfo.x, clickInfo.y))
        {
            hitSomething = hitRotate;
            retval = true;
        }
        spot.translate(0, 32);
        spot.translate(32, 0);
        spot.translate(0, 32);
        if (spot.contains(clickInfo.x, clickInfo.y))
        {
            hitSomething = hitScale;
            
        double scale = 0.005f * clickInfo.camera.Distance();
                double hScale = (double) (clickInfo.x - centerPt.x) / 64;
                double sign = 1;
                if (hScale < 0)
                {
                    sign = -1;
                }
                hScale = sign*Math.pow(sign*hScale, scale * 50);
                if (hScale < 0.01)
                {
                    //hScale = 0.01;
                }
                
                double vScale = (double) (clickInfo.y - centerPt.y) / 64;
                sign = 1;
                if (vScale < 0)
                {
                    sign = -1;
                }
                vScale = sign*Math.pow(sign*vScale, scale * 50);
                if (vScale < 0.01)
                {
                    //vScale = 0.01;
                }
                
                clickInfo.scale = Math.sqrt(hScale*hScale + vScale*vScale);
                
            retval = true;
        }

        if (!retval)
        {
            return false;
        }

        //System.out.println("info.modifiers = " + info.modifiers);
        modified = (clickInfo.modifiers & CameraPane.SHIFT) != 0; // Was META
        //System.out.println("modified = " + modified);
        //new Exception().printStackTrace();
        //viewCode = info.pane.renderCamera.viewCode;
        if (startMat == null)
        {
            startMat = new double[4][4];
        }

        if (toParent == null)
        {
            toParent = LA.newMatrix();
            fromParent = LA.newMatrix();
        }
        
        boolean wasmarked = marked;
        
        if (marked)
            SwitchMark();

        LA.matCopy(toParent, startMat);

        if (wasmarked)
            SwitchMark();

        return true;
    }

    void doEditDrag0(//ClickInfo info,
            boolean opposite)
    {
        if (hitSomething == 0)
        {
            return;
        }
        
        boolean wasmarked = marked;
        
        if (marked)
            SwitchMark();

        //System.out.println("hitSomething = " + hitSomething);

        double scale = 0.005f * clickInfo.camera.Distance();
        
        cVector xlate = new cVector();
        //cVector xlate2 = new cVector();
        switch (hitSomething)
        {
            default:
                assert (false);
                break;

            case hitCenter: // Translate
                
                scale *= 0.05f * Globals.theRenderer.RenderCamera().Distance();
                
                // Modified could snap
                if (//modified ||
                        opposite)
                {
                    //assert(false);
                            /*
                    double scale = (double)((info.x - startX) + 32) / 32;
                    if (scale < 0.01)
                    scale = 0.01;
                    if (scale > 100)
                    scale = 100;
                    LA.matCopy(startMat, toParent);
                    for (int i=0; i < 3; i++)
                    {
                    xlate.set(i, toParent[3][i]);
                    toParent[3][i] = 0;
                    }
                    LA.matScale(toParent, scale, scale, scale);
                    for (int i=0; i < 3; i++)
                    toParent[3][i] = xlate.get(i);
                    LA.matInvert(toParent, fromParent);
                     */
                    cVector delta = LA.newVector(0, 0, startY - clickInfo.y);
                    LA.xformDir(delta, new Camera(clickInfo.camera.viewCode).fromScreen, delta);

                    LA.matCopy(startMat, toParent);
                    LA.matTranslate(toParent, delta.x * scale, delta.y * scale, delta.z * scale);
                    //LA.matHomogene(toParent, delta.x * scale, delta.y * scale, delta.z * scale);
                    LA.matInvert(toParent, fromParent);
                } else
                {
                    //LA.xformDir(delta, info.camera.fromScreen, delta);
                    cVector up = new cVector(clickInfo.camera.up);
                    cVector away = new cVector();
                    //cVector right2 = new cVector();
                    //LA.vecCross(up, cVector.Z, right);
                    //System.out.println("UP = " + up);
                    if (// ??? !CameraPane.LOCALTRANSFORM &&
                            parent != null) // ?
                    {
                        LA.matInvert(parent.GlobalTransform(), ClickInfo.matbuffer);
                    } else
                    {
                        System.out.println("PARENT WAS NULL");
                        LA.matIdentity(ClickInfo.matbuffer);
                    }
                    LA.xformDir(up, ClickInfo.matbuffer, up);
    //                if (!CameraPane.LOCALTRANSFORM)
                        LA.xformDir(up, Globals.theRenderer.RenderCamera().toScreen, up);
                    LA.xformDir(clickInfo.camera.away, ClickInfo.matbuffer, away);
    //                if (!CameraPane.LOCALTRANSFORM)
                        LA.xformDir(away, Globals.theRenderer.RenderCamera().toScreen, away);
                    //LA.vecCross(up, cVector.Z, right2);

                    cVector delta = LA.newVector(clickInfo.x - startX, startY - clickInfo.y, 0);

                    //System.out.println("DELTA0 = " + delta);
                    //System.out.println("AWAY = " + info.camera.away);
                    //System.out.println("UP = " + info.camera.up);
                    if (away.z > 0)
                    {
                        if (clickInfo.camera.up.x == 0) // LA.vecDot(right, right2)<0)
                        {
                            delta.x = -delta.x;
                        } else
                        {
                            delta.y = -delta.y;
                        }
                    }

                    double angle = Math.atan2(up.y, up.x) - Math.PI / 2; // - Math.atan2(info.camera.up.x, info.camera.up.y); // ??
                    LA.matIdentity(ClickInfo.matbuffer);
                    LA.matZRotate(ClickInfo.matbuffer, -angle);
                    //System.out.println("DELTA1 = " + delta);
                    LA.xformDir(delta, ClickInfo.matbuffer, delta);
                    //System.out.println("DELTA2 = " + delta);
                    LA.xformDir(delta, new Camera(clickInfo.camera.viewCode).fromScreen, delta);
                    LA.matCopy(startMat, toParent);
                    //System.out.println("DELTA3 = " + delta);
                    LA.matTranslate(toParent, delta.x * scale, delta.y * scale, delta.z * scale);
                    LA.matInvert(toParent, fromParent);
                //LA.matPrint(toParent);
                }
                break;

            case hitRotate: // rotate
                int dx = clickInfo.x - centerPt.x;
                int dy = -(clickInfo.y - centerPt.y);
                double angle = (double) Math.atan2(dx, dy);
                angle = -(1.570796 - angle);

                //System.out.println("scale = " + scale);
                angle *= scale * 50;

                if (modified)
                {
                    // Rotate 45 degrees
                    angle /= (Math.PI / 4);
                    angle = Math.floor(angle + 0.5);
                    angle *= (Math.PI / 4);
                }
                LA.matCopy(startMat, toParent);
                /**/
                for (int i = 0; i < 3; i++)
                {
                    xlate.set(i, toParent[3][i]);
                    toParent[3][i] = 0;
                }
                /**/

                switch (clickInfo.pane.RenderCamera().viewCode)
                {
                    case 1: // '\001'
                        LA.matZRotate(toParent, angle);
                        break;

                    case 2: // '\002'
                        LA.matYRotate(toParent, -angle);
                        break;

                    case 3: // '\003'
                        LA.matXRotate(toParent, angle);
                        break;
                    default:
                        assert false;
                }
                /**/
                for (int i = 0; i < 3; i++)
                {
                    toParent[3][i] = xlate.get(i);
                }
                /**/

                LA.matInvert(toParent, fromParent);
                break;

            case hitScale: // scale
                double hScale = (double) (clickInfo.x - centerPt.x) / 64;
                double sign = 1;
                if (hScale < 0)
                {
                    sign = -1;
                }
                hScale = sign*Math.pow(sign*hScale, scale * 50);
                if (hScale < 0.01)
                {
                    //hScale = 0.01;
                }
                
                double vScale = (double) (clickInfo.y - centerPt.y) / 64;
                sign = 1;
                if (vScale < 0)
                {
                    sign = -1;
                }
                vScale = sign*Math.pow(sign*vScale, scale * 50);
                if (vScale < 0.01)
                {
                    //vScale = 0.01;
                }
                
                LA.matCopy(startMat, toParent);
                /**/
                for (int i = 0; i < 3; i++)
                {
                    xlate.set(i, toParent[3][i]);
                    toParent[3][i] = 0;
                }
                /**/

                double totalScale = Math.sqrt(hScale*hScale + vScale*vScale) / clickInfo.scale;
                        
                if (totalScale < 0.01)
                {
                    totalScale = 0.01;
                }
                
                switch (clickInfo.pane.RenderCamera().viewCode)
                {
                    case 3: // '\001'
                        if (modified || opposite)
                        {
                            if (modified) // && opposite)
                                LA.matScale(toParent, totalScale, totalScale, totalScale);
                            else
                            //LA.matScale(toParent, 1, hScale, vScale);
                                LA.matScale(toParent, totalScale, 1, 1);
                        } // vScale, 1);
                        else
                        {
                            // EXCEPTION!
                            LA.matScale(toParent, 1, totalScale, totalScale);
                        } // vScale, 1);
                        break;

                    case 2: // '\002'
                        if (modified || opposite)
                        {
                            if (modified) // && opposite)
                                LA.matScale(toParent, totalScale, totalScale, totalScale);
                            else
                                //LA.matScale(toParent, hScale, 1, vScale);
                                LA.matScale(toParent, 1, totalScale, 1);
                        } else
                        {
                            LA.matScale(toParent, totalScale, 1, totalScale);
                        }
                        break;

                    case 1: // '\003'
                        if (modified || opposite)
                        {
                            if (modified) // && opposite)
                                LA.matScale(toParent, totalScale, totalScale, totalScale);
                            else
                                //LA.matScale(toParent, hScale, vScale, 1);
                                LA.matScale(toParent, 1, 1, totalScale);
                        } else
                        {
                            LA.matScale(toParent, totalScale, totalScale, 1);
                        }
                        break;
                }
                /**/
                for (int i = 0; i < 3; i++)
                {
                    toParent[3][i] = xlate.get(i);
                }
                /**/

                LA.matInvert(toParent, fromParent);
                break;
        }

        if (wasmarked)
            SwitchMark();

        if (parent == null)
        {
            System.out.println("NULL PARENT");
            //new Exception().printStackTrace();
        } else
        {
            if (parent instanceof BezierPatch)
            {
		((BezierSurface)parent.parent).currentHandle = (Sphere)this;
            //    parent.parent.recalculate();
            }
            else
                parent.Touch();
        } // NEW ...
        
        
        clickInfo.pane.repaint();
    }

    boolean overflow = false;
    
    void TransformToWorld(cVector out) // , cVector out)
    {
        if (overflow)
            return;
        
        overflow = true;
            
        // june 2013 ???       assert (in == out);
        cVector in = out;
        if (toParent != null && !(this instanceof Texture || this instanceof TextureNode))
        {
            for (int loop=GetTransformCount(); --loop>=0;)
            {
                LA.xformPos(in, toParent, out);
                // june 2013  out.set(in);
                // july 2013:
                in.set(out);
            }
        }
        if (parent != null || fileparent != null)
        {
            (parent!=null?parent:fileparent).TransformToWorld(out); //, out);
        }
        
        overflow = false;
    }

    void TransformToLocal(cVector out) //, cVector out)
    {
 // june 2013 ???       assert (in == out);
        cVector in = out;
        if (parent != null || fileparent != null)
        {
            (parent!=null?parent:fileparent).TransformToLocal(out); //, out);
        }
        
        if (!(this instanceof Texture || this instanceof TextureNode))
        {
            for (int loop=GetTransformCount(); --loop>=0;)
            {
                LA.xformPos(in, fromParent, out);
                // june 2013  out.set(in);
                // july 2013:
                in.set(out);
            }
        }
    }

//    void invariants()
//    {
//    }

    void invariants()
    {
        //GraphreeD.tracein(this);
        for (int i = 0; i < Children().size(); i++)
        {
            Object3D child = (Object3D) Children().reserve(i);
            if (child == null)
                continue;
            
            if (child.parent != null && child.parent != this)
            {
                System.err.println("INVARIANT FAIL: " + this);
                child.parent = this;
            }
            child.invariants();
            Children().release(i);
        }

//        assert selection != null;
        //GraphreeD.traceout(this);
    }
    
    public boolean equals(Object o)
    {
        return this == o;
        //return GetObject() == ((Object3D)o).GetObject();
    }

    static class cVector2 implements java.io.Serializable
    {
        int x;
        int y;
    }

    public String toString()
    {
        //SizeOf.skipStaticField(true);
        //SizeOf.turnOnDebug();

        //return super.toString() + " (id=" + list + ")" + " (brep=" + bRep + ")";
        //return name + " (id=" + list + ")" + " (brep=" + bRep + ") " + super.toString();
        //return name + " (#tri = " + (bRep==null?0:bRep.VertexCount()) + ") " + super.toString();
        
        String objname;
        
        if (false) //parent != null)
        {
            objname = name + " " + System.identityHashCode(this) + " (" + parent.name + " " + System.identityHashCode(parent) + ")";
        } else
        {
            objname = GetName() + (Math.abs(count) == 1000 ? (count == 1000 ? " " : " * ") : (" (" + (count - 1) + ")")) + /*(IsSelected()?"(selected) ":"") + (touched?"(touched) ":"") */ "";
        } //  + super.toString();
    //return name + " (" + (SizeOf.deepSizeOf(this)/1024) + "K) " + this.getClass().getName();
        
        if (!Globals.ADVANCED)
            return objname;
        
        return objname + " " + System.identityHashCode(this) + " " + GetUUID();
    }

    public int hashCode()
    {
        // Fuck Vector...
        return System.identityHashCode(this);
    }
    
    static int tabcount = 0;
    
    void PrintTabs()
    {
        for (int i=tabcount; --i>=0;)
            System.out.print("  ");
    }
    
    public void SendInfo(String text, String style)
    {
        PrintTabs();
        System.out.println(text);
    }
    
    void Dump(boolean full)
    {
        System.err.flush();
            
        ObjEditor.AddInfo(this, this, full);
        
        tabcount++;
        for (int i=0; i<Size(); i++)
        {
            Object3D comp = (Object3D) reserve(i);
            if (comp == null)
                continue;
            comp.Dump(full);
            release(i);
        }
        tabcount--;
        
        SendInfo(toString(), "");
    }
    
    static final int WIREFRAME = 1;
    static final int FILL = 2;
    static final int BACKFACE = 4;
    
    int attributes = 0; // FILL;

    void CloseUI()
    {
        if (objectUI != null)
        {
            objectUI.closeUI();
            if (editWindow != null)
            {
                editWindow.ctrlPanel.FlushUI();
                editWindow.refreshContents();
            } // ? new
            objectUI = null;
//???
        if (parent != null)
        {
            editWindow = null;
        } // ?
        }
        else
        {
            //editWindow.closeUI();
        }
    }
    
    boolean root; // patch for edit windows
    
    String name;
    BoundaryRep bRep;
    /*transient*/ double height; // patch for linker and simplex
	/*transient*/ double depth; // used for linker distortion
	/*transient*/ cVector2[] projectedVertices = new cVector2[0];
        
    Object3D /*Composite*/ parent;
    Object3D /*Composite*/ fileparent; // In the case of FileObject
    
    double[][] toParent; // dynamic matrix
    double[][] fromParent;
    
    double[][] toParentMarked; // original matrix
    double[][] fromParentMarked;
    
    double[][] tempmatrix;
    
    double[][] ToParent()
    {
//        if (marked)
//        {
//            if (toParentMarked == null)
//            {
//                toParentMarked = LA.newMatrix();
//                LA.matCopy(toParent, toParentMarked);
//            }
//            
//            return toParentMarked;
//        }
//        else
        {
            return toParent;
        }
    }
    
    double[][] FromParent()
    {
//        if (fromParent == null)
//            return null;
//        
//        if (marked)
//        {
//            if (fromParentMarked == null)
//            {
//                fromParentMarked = LA.newMatrix();
//                LA.matCopy(fromParent, fromParentMarked);
//            }
//            
//            return fromParentMarked;
//        }
//        else
        {
            return fromParent;
        }
    }
    
//    void Assert(boolean b)
//    {
//        if (!b)
//        {
//            //assert(false);
//            new Exception().printStackTrace();
//        }
//    }
    
    
    void FullInvariants()
    {
        if (blockloop)
            return;
        
        //System.err.println("Invariants " + this);
        
        blockloop = true;
        
        Invariants();
        
        for (int i=0; i<size(); i++)
        {
            get(i).FullInvariants();
        }
        
        blockloop = false;
    }
    
    void Invariants()
    {
//        if (name != null && name.contains("eyesocket"))
//        {
//            name = name;
//        }
        if (min == null) // ???
        {
            min = new cVector();
            max = new cVector();
        }
        
        if (false) // Can crawl!!
        {
            Object3D sourcenode = GetFileRoot();

            if (sourcenode != null && !sourcenode.name.contains("rclab"))
            {
                getBounds(min, max, true);

                if (min.y != Double.POSITIVE_INFINITY && min.y > 2)
                {
    //                sourcenode.getBounds(min, max, true);
                    sourcenode.getBounds(v0, v1, true);
    //                sourcenode.toParent = sourcenode.toParent;
    //                get(0).toParent = get(0).toParent;
    //                sourcenode.GlobalTransform();
                }
            }
        }
        
        //Dump(true);
        
        if (support != null)
        {
            assert(bRep != null);
            if (!(support instanceof GenericJoint)) // support.bRep != null)
                Grafreed.Assert(support.bRep == bRep.support);
        }
        else
        {
            //assert(bRep == null || bRep.support == null);
            if (bRep != null && bRep.support != null)
            {
                System.err.println("NOT A NULL SUPPORT FOR BREP: " + this);
                bRep.support = null;
            }
        }
        
        if (toParent == null)
            return;
        
        if (tempmatrix == null)
            tempmatrix = new double[4][4];
        
        LA.matConcat(fromParent, toParent, tempmatrix);
        
        //Assert(LA.isIdentityEps(tempmatrix));
        if (!LA.isIdentityEps(tempmatrix))
        {
   // TODO!!
            System.err.println("CORRUPTED MATRIX!!! " + this);
        //    new Exception().printStackTrace();
            LA.matInvert(toParent, fromParent);
        }
    }
    
    transient ObjEditor editWindow;
    transient ObjEditor manipWindow;
    
    transient boolean pinned;
    
    transient ObjectUI objectUI;
    public static int povDepth = 0;
    private static cVector tbMin = new cVector();
    private static cVector tbMax = new cVector();
    private static cVector tbIn = new cVector();
    private static cVector tbOut = new cVector();
    private static cVector pp = new cVector();
    private static cVector qq = new cVector();
    private static cVector rr = new cVector();
    private static cVector ss = new cVector();
    private static cVector2 pp2 = new cVector2();
    private static cVector2 qq2 = new cVector2();
    private static cVector2 rr2 = new cVector2();
    private static cVector2 ss2 = new cVector2();
//    private static cVector edge1 = new cVector();
//    private static cVector edge2 = new cVector();
    //private static cVector norm = new cVector();
    /*transient private*/ int hitSomething;
    static final int hitCenter = 1;
    static final int hitScale = 2;
    static final int hitRotate = 3;
    /*transient*/ /*private*/ int viewCode; // Now used for transparency cache flag
	/*transient*/ private Point centerPt;
    /*transient*/ private int startX;
    /*transient*/ private int startY;
    /*transient*/ private boolean modified;
    /*transient*/ private double startMat[][];
    Color aColor, aColorSelect;
    Color aLineColor, aLineColorSelect;
    /*transient*/ Color fillColor, lineColor;
    /*transient*/ int mode; // Now used for biparam
    static final int FACE = 1;
    static final int EDGE = 2;
    static final int POINT = 4;
    cMaterial material; // = new cMaterial();

    cMaterial GetMaterial()
    {
        //System.out.println("this = " + this);
        if (material != null || parent == null || parent.IsContainedIn(this))
        {
            return material;
        } else
        {
            return parent.GetMaterial();
        }
    }

    void SetAttributes(Object3D obj, int mask)
    {
        Object3D targ = this;
        
        targ.NORMALPUSH = obj.NORMALPUSH;
        
        if (obj.material != null)
        {
            if ((mask&MATERIAL)!=0) // ==(COLOR|MATERIAL))
            {
                if (targ.material == null)
                    // COPY targ.material = new cMaterial(tempsel.get(0).material);
                    targ.material = obj.material; // LINK
                else
                {
                    float tcolor = targ.material.color;
                    float tmodulation = targ.material.modulation;
                    
                    targ.material.Set(obj.material);
                    
                    if ((mask&COLOR)==0)
                    {
                        targ.material.color = tcolor;
                        targ.material.modulation = tmodulation;
                    }

                    if (targ.projectedVertices.length <= 2)
                    {
                        // Side effect...
                        Object3D.cVector2[] keep = targ.projectedVertices;
                        targ.projectedVertices = new Object3D.cVector2[3];
                        for (int i=0; i<3; i++)
                        {
                            if(i<keep.length)
                                targ.projectedVertices[i] = keep[i];
                            else
                                targ.projectedVertices[i] = new Object3D.cVector2();
                        }
                    }

                    if (obj.projectedVertices.length <= 2)
                    {
                        // Side effect...
                        Object3D.cVector2[] keep = obj.projectedVertices;
                        obj.projectedVertices = new Object3D.cVector2[3];
                        for (int i=0; i<3; i++)
                        {
                            if(i<keep.length)
                                obj.projectedVertices[i] = keep[i];
                            else
                            {
                                obj.projectedVertices[i] = new Object3D.cVector2();
                                if (i == 0)
                                    obj.projectedVertices[i].x = 100; // criss de bug de bump
                            }
                        }
                    }

                    for (int i=obj.projectedVertices.length; --i>=0;)
                    {
                        targ.projectedVertices[i].x = obj.projectedVertices[i].x;
                        targ.projectedVertices[i].y = obj.projectedVertices[i].y;
                    }
                }
            }
            else
                if ((mask&COLOR)!=0) // COLOR)
                {
                    //Object3D targ = group.selection.get(0);
                    if (targ.material != null)
                    {
                        targ.material.color = obj.material.color;
                        targ.material.modulation = obj.material.modulation;
                    }
                }
//                else
//                    if ((mask&MATERIAL)!=0) // MATERIAL)
//                    {
//                        //Object3D targ = group.selection.get(0);
//                        if (targ.material != null)
//                        {
//                            float tcolor = targ.material.color;
//                            float tmodulation = targ.material.modulation;
//                            targ.material.Set(obj.material);
//                            targ.material.color = tcolor;
//                            targ.material.modulation = tmodulation;
//                        }
//                    }
        }

       // if (obj.texture != null)
        {
            if ((mask&TEXTURE)!=0) // TEXTURE)
            {
                //group.selection.get(0)
                        targ.GetTextures().name = obj.GetTextures().name;
                //group.selection.get(0)
                        targ.flipV = obj.flipV;
                        targ.texres = obj.texres;
                        targ.Touch();
            }
        }
    }
    
    boolean HasTransparency()
    {
        if (true) return false;
        
        if (material == null || material.multiply)
        {
            return false;
        }

        //if (material.opacity != 1)
        //    System.out.println("HasTransparency = " + material.opacity);
        return material.opacity < 0.99;
    }
    
    int count = 2; // 1 ??

    void IncCount()
    {
        if (count == -1000)
        {
            count = 1000;
        } else if (count != 1000)
        {
            count++;
        }
    }
    
    void DecCount()
    {
        if (count == 1000)
        {
            count = -1000;
        } else if (count > 1) // 0)
        {
            count--;
        }
    }
    
    void IncDepth()
    {
        Object3D selectee;
        for (int i = 0; i < selection.size(); i++)
        {
            selectee = (Object3D) selection.elementAt(i);
            selectee.IncCount();
        }

        Touch();
    }

    void DecDepth()
    {
        Object3D selectee;
        for (int i = 0; i < selection.size(); i++)
        {
            selectee = (Object3D) selection.elementAt(i);
            selectee.DecCount();
        }

        Touch();
    }
    
    static Vertex s1 = new Vertex();
    static Vertex s2 = new Vertex();
    static Vertex s3 = new Vertex();

    boolean intersectMesh(Ray ray, IntersectResult result)
    {
        boolean success = false;
        
        if (bRep.stripified)
        {
            int[] strips = bRep.getRawIndices();
            
                // TRIANGLE STRIP ARRAY
                if (bRep.trimmed)
                {
                    float[] v = bRep.getRawVertices();

                    int count3 = 0;

                    if (v.length > 0)
                    {
                        for (int i = 0; i < strips.length; i++)
                        {
                            s1.set(v[count3], v[count3 + 1], v[count3 + 2]);
                            count3 += 3;
                            
                            s2.set(v[count3], v[count3 + 1], v[count3 + 2]);
                            count3 += 3;
                            
                            for (int j = 0; j < strips[i] - 2; j++)
                            {
                                s3.set(v[count3], v[count3 + 1], v[count3 + 2]);
                                count3 += 3;
                                
                                if (j%2 == 0)
                                      success |= intersectTriangle(ray, result, s1, s2, s3);
                                else
                                      success |= intersectTriangle(ray, result, s1, s3, s2);

                                s1.set(s2);
                                s2.set(s3);
                            }
                        }
                    }

                    assert count3 == v.length;
                }
                else // !trimmed
                {
                    int count = 0;
                    for (int i = 0; i < strips.length; i++)
                    {
                        Vertex p = bRep.GetVertex(bRep.indices[count++]);
                        Vertex q = bRep.GetVertex(bRep.indices[count++]);
                        
                        for (int j = 0; j < strips[i] - 2; j++)
                        {
                            Vertex r = bRep.GetVertex(bRep.indices[count++]);

                            if (j%2 == 0)
                                  success |= intersectTriangle(ray, result, p, q, r);
                            else
                                  success |= intersectTriangle(ray, result, p, r, q);
                            
                            p = q;
                            q = r;
                        }
                    }
                }
        } else // catch (Error e)
        {
            int facecount = bRep.FaceCount();
            for (int i = 0; i < facecount; i++)
            {
                Face face = bRep.GetFace(i);

                Vertex p = bRep.GetVertex(face.p);
                Vertex q = bRep.GetVertex(face.q);
                Vertex r = bRep.GetVertex(face.r);

                success |= intersectTriangle(ray, result, p, q, r);
            }
        }
        
        return success;
    }
    
    static cVector eye = new cVector();
    static cVector dir = new cVector();
    
    transient BBox bbox = null;
    
    boolean intersect(Ray ray, IntersectResult result)
    {
        double eyex = ray.eyePoint.x;
        double eyey = ray.eyePoint.y;
        double eyez = ray.eyePoint.z;
        
        double dirx = ray.viewDirection.x;
        double diry = ray.viewDirection.y;
        double dirz = ray.viewDirection.z;
        
        if (this.fromParent != null)
        {
            eye.x = eyex;
            eye.y = eyey;
            eye.z = eyez;
            dir.x = dirx;
            dir.y = diry;
            dir.z = dirz;
            
            LA.xformPos(eye, this.fromParent, eye);
            LA.xformDir(dir, this.fromParent, dir);
            
            ray.eyePoint.x = eye.x;
            ray.eyePoint.y = eye.y;
            ray.eyePoint.z = eye.z;

            ray.viewDirection.x = dir.x;
            ray.viewDirection.y = dir.y;
            ray.viewDirection.z = dir.z;
        }
        
        boolean success = false;
        
        boolean touch = false;
        
        if (bRep != null)
        {
            if (bbox == null)
            {
                bbox = new BBox();
                
                cVector min = new cVector();
                cVector max = new cVector();
                
                this.getBounds(min, max, false);
                
                bbox.min.x = min.x;
                bbox.min.y = min.y;
                bbox.min.z = min.z;
                
                bbox.max.x = max.x;
                bbox.max.y = max.y;
                bbox.max.z = max.z;
            }
            
            if (bbox.intersect(ray, result))
            {
                success |= intersectMesh(ray, result);
            }
            else
            {
                //this.hide = true;
                touch = true;
            }
        }
        
        for (int i=0; i<size(); i++)
        {
            Object3D child = (Object3D) reserve(i);
            
            if (child == null)
                continue;

            success |= child.intersect(ray, result);
            release(i);
        }
        
        ray.eyePoint.x = eyex;
        ray.eyePoint.y = eyey;
        ray.eyePoint.z = eyez;
        
        ray.viewDirection.x = dirx;
        ray.viewDirection.y = diry;
        ray.viewDirection.z = dirz;
        
//        if (touch)
//            this.Touch(); // refresh display list
            
        return success;
    }

    static Vector3d edge1 = new Vector3d();
    static Vector3d edge2 = new Vector3d();
    static Vector3d P = new Vector3d();
    static Vector3d T = new Vector3d();
    static Vector3d Q = new Vector3d();
    
    private boolean intersectTriangle(Ray ray, IntersectResult result, Vertex v1, Vertex v2, Vertex v3)
    {
        /*
        Fast, Minimum Storage Ray/Triangle Intersection, Moller et al.
        
        Reference: http://www.cs.virginia.edu/~gfx/Courses/2003/ImageSynthesis/papers/Acceleration/Fast%20MinimumStorage%20RayTriangle%20Intersection.pdf
         */

        // Calculate edges of the triangle
        edge1.set(v2.x - v1.x, v2.y - v1.y, v2.z - v1.z);
        edge2.set(v3.x - v1.x, v3.y - v1.y, v3.z - v1.z);

        // Calculate the determinant (U parameter)
        P.cross(ray.viewDirection, edge2);
        double det = edge1.dot(P);

        if (det > -1e-9 && det < 1e-9)
        {
            return false;
        }	// Ray lies in plane of triangle

        double invDet = 1 / det;

        // Calculate distance from vertex1 to ray origin
        T.set(ray.eyePoint.x - v1.x, ray.eyePoint.y - v1.y, ray.eyePoint.z - v1.z);

        double U = (T.dot(P)) * invDet;	// Calculate U parameter

        if (U < 0.f || U > 1.f)
        {
            return false;
        }	// Intersection lies outside of the triangle

        // Calculate V parameter
        Q.cross(T, edge1);

        double V = ray.viewDirection.dot(Q) * invDet;

        if (V < 0.f || (U + V) > 1.f)
        {
            return false;
        }	// Intersection lies outside of the triangle

        double t = edge2.dot(Q) * invDet;

        if (t > 1e-9)	// Triangle and ray intersects
        {
            //result.isIntersected = true;
            //result.id = id;

            if (false) // isShadow)
            {
                result.t = t;
                return true;
            } else if (t < result.t)
            {
                result.object = this;

                result.t = t;

                //result.p.x = ray.eyePoint.x + ray.viewDirection.x * t;
                //result.p.y = ray.eyePoint.y + ray.viewDirection.y * t;
                //result.p.z = ray.eyePoint.z + ray.viewDirection.z * t;

                result.n.cross(edge1, edge2);
                result.n.normalize();
            }
            
            return true;
        }
        
        return false;
    }

    public int Size()
    {
        //this.elementData
        return super.size();
    }

    public int size()
    {
        ////GraphreeD.trace("SIZE " + this + " = ", super.size());
        //System.out.println("SIZE = " + this + " " + super.size());
        //assert (count >= 0);
        if (count <= 0)
        {
            return 0;
        } else
        {
            return super.size();
        }
    }

    public int size0()
    {
        ////GraphreeD.trace("SIZE " + this + " = ", super.size());
        //System.out.println("SIZE = " + this + " " + super.size());
        //assert (count >= 0);
        if (count < 0)
        {
            return 0;
        } else
        {
            return super.size();
        }
    }

    public Object3D reserve(int i)
    {
        //GraphreeD.tracein("RESERVE " + this + " = ", i);
        Object3D child = super.get(i);
        //Applet3D.tracein("RESERVE ", child);

        if (child.count <= 1) // july 2013 ??? 1) // ??? == 0)
            return null;
        
        child.count--;
        //assert (child.count >= 0);

        return child;
    }

    public Object3D reserve0(int i)
    {
        if (super.size() == 0)
        {
            return null;
        }
        
        //GraphreeD.tracein("RESERVE " + this + " = ", i);
        Object3D child = super.get(i);
        //Applet3D.tracein("RESERVE ", child);

        if (child.count <= 0) // july 2013 ??? 1) // ??? == 0)
            return null;
        
        child.count--;
        //assert (child.count >= 0);

        return child;
    }

    public void release(int i)
    {
        //GraphreeD.traceout("RELEASE " + this + " = ", i);
     //   Object3D child = super.get(i);
     //   //Applet3D.traceout("RELEASE ", child);
     //   child.count++;

        super.get(i).count++;
    //assert (child.count >= 0);
    }
    
    /*
    public synchronized int indexOf(Object elem, int index)
    {
	if (elem == null) {
	    for (int i = index ; i < elementCount ; i++)
		if (elementData[i]==null)
		    return i;
	} else {
	    for (int i = index ; i < elementCount ; i++)
		if (((Object3D)elementData[i]).GetObject().equals(elem))
		    return i;
	}
	return -1;
    }
     */
}