class Sphere extends Biparam implements java.io.Serializable
{
//    void DrawNode(CameraPane display, Object3D /*Composite*/ root, boolean selected) {}
    
    static final long serialVersionUID = -962102766850477208L;

    boolean handle;
    
    /**/
    Sphere(float x, float y, float z)
    {
        this(false);

        radius = 0.05f;
        uDivs = 7;
        vDivs = 6;

        center = new cVector();
        center.set(x, y, z);

        //refreshCenter(center);

        retile();
        recalculate();
    }
    /**/

    Sphere()
    {
        this(true);
    }

    Sphere(Sphere s)
    {
        s.deepCopySelf(this);
    }

    public Sphere(boolean recalc)
    {
        toParent = LA.newMatrix();
        fromParent = LA.newMatrix();
        
        inPnt = new cVector();
        name = "Sphere";
        //uDivs = vDivs = 16;
        uDivs = 8; // 19;
        vDivs = 8; // 18;
        minUDivs = 3;
        minVDivs = 2;
        //center = new cVector();
        radius = 0.5;
        if (recalc)
        {
            retile();
            recalculate();
        }
    }

    void refreshCenter(cVector c)
    {
        /**/
        toParent[3][0] = c.x; // - center.x;
        toParent[3][1] = c.y; // - center.y;
        toParent[3][2] = c.z; // - center.z;

        fromParent[3][0] = -c.x; // + center.x;
        fromParent[3][1] = -c.y; // + center.y;
        fromParent[3][2] = -c.z; // + center.z;
    /**/
    //center.set(0,0,0);
    }

    cVector getCenter()
    {
        //assert(center.x == 0);
        //assert(center.y == 0);
        //assert(center.z == 0);
        
     //   if (center == null)
     //       center = new cVector();
        
        cVector c = new cVector(center);

        for (int i=GetTransformCount(); --i>=0;)
            LA.xformPos(c, toParent, c);

        return c;
    }

    Object3D deepCopy()
    {
        Sphere e = new Sphere();
        deepCopySelf(e);
        return e;
    }

    protected void deepCopyNode(Object3D other)
    {
        super.deepCopyNode(other);
        Sphere e = (Sphere) other;
        if (center != null)
        {
            e.center = new cVector(center);
            //LA.vecCopy(center, e.center);
        }
        e.radius = radius;
    }

    void generatePOV(StringBuffer buffer)
    {
        generateNameComment(buffer);
        generateIndent(buffer);
        buffer.append("sphere { ");
     //   LA.toPOVRay(center, buffer);
        buffer.append(", ");
     //   buffer.append(radius);
        buffer.append("\n");
        generateTransform(buffer);
        generateIndent(buffer);
        buffer.append("}\n");
    }

    double uStretch()
    {
        return 2;
    }
    
    double vFlip(double v)
    {
        return 1-v;
    }
    
    Vertex biparamFunction(double u, double v)
    {
        double uAng = LA.toRadians(u * 360);
        double vAng = LA.toRadians(v * 180);
        double z = (double) (Math.sin(vAng) * Math.cos(uAng)) * radius;
        double x = (double) (Math.sin(vAng) * Math.sin(uAng)) * radius;
        double y = (double) (-Math.cos(vAng)) * radius;
        Vertex temp = new Vertex();
        temp.norm = LA.newVector(x, y, z);
        //temp.pos = new cVector();
        if (center != null)
            LA.vecAdd(temp.norm, center, temp/*.pos*/);
        else
            LA.vecCopy(temp.norm, temp/*.pos*/);
        LA.vecNormalize(temp.norm);
        
        temp.y += radius;
        
        return temp;
    }

    void createEditWindow(GroupEditor callee, boolean newWindow)
    {
        //editWindow = (new SphereEditor(this, deepCopy(), callee)).GetEditor();
        if (newWindow)
        {
            objectUI = new SphereEditor(this, deepCopy(), callee);
        } else
        {
            objectUI = new SphereEditor(this, callee);
        }
        editWindow = objectUI.GetEditor();
    }

//    void getBounds(cVector minima, cVector maxima, boolean xform)
//    {
//        //for (int i=0; i < 3; i++)
//        {
//            minima.x = /*center.x*/ - 1; // radius;
//            minima.y = /*center.y*/ - 1; // radius;
//            minima.z = /*center.z*/ - 1; // radius;
//            //maxima[i] = center[i] + radius;
//            maxima.x = /*center.x*/ + 1; // radius;
//            maxima.y = /*center.y*/ + 1; // radius;
//            maxima.z = /*center.z*/ + 1; // radius;
//        }
//
//        //System.out.println("BoundsS = " + minima + " - " + maxima);
//        if (xform)
//        {
//            transformBounds(minima, maxima);
//        }
//    //System.out.println("BoundsS2 = " + minima + " - " + maxima);
//    }

    boolean inside(double x, double y, double z, boolean xform)
    {
        if (xform)
        {
            untransform(x, y, z, inPnt);
        } else
        {
            LA.setVector(inPnt, x, y, z);
        }
       // LA.vecSub(inPnt, center, inPnt);
        double f = inPnt.x * inPnt.x + inPnt.y * inPnt.y + inPnt.z * inPnt.z - radius * radius;

        boolean inside = f <= 0;

        if (depth != -1 && (height <= 0 ^ inside))
        {
            Simplex.atom = this;
        }
        height = f;
        depth = 0;

        return inside;
    }
    
    cVector center;
    double radius;
    cVector inPnt;
}