|
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 = 11; // 7;
|
vDivs = 4; // 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 = 12; // 8; // 19;
|
vDivs = 6; // 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;
|
}
|
