//----------------------------------------------------------------------------
void NURBSCurveExample::NextConfiguration ()
{
delete1(mTargets);
mTargets = 0;
const int numCtrlPoints = 14;
const int degree = 2;
delete1(mCtrlPoints);
mCtrlPoints = new1<Vector2f>(numCtrlPoints);
float* weights = new1<float>(numCtrlPoints);
// spline
mCtrlPoints[0] = mSpline->GetControlPoint(0);
mCtrlPoints[1] = mSpline->GetControlPoint(1);
mCtrlPoints[2] = 0.5f*(mSpline->GetControlPoint(1) +
mSpline->GetControlPoint(2));
mCtrlPoints[3] = mSpline->GetControlPoint(11);
mCtrlPoints[4] = mSpline->GetControlPoint(12);
// circle
int i, j;
for (i = 2, j = 5; i <= 10; ++i, ++j)
{
mCtrlPoints[j] = mSpline->GetControlPoint(i);
}
for (i = 0; i < numCtrlPoints; ++i)
{
weights[i] = 1.0f;
}
weights[ 6] = mSpline->GetControlWeight(3);
weights[ 8] = mSpline->GetControlWeight(5);
weights[10] = mSpline->GetControlWeight(7);
weights[12] = mSpline->GetControlWeight(9);
delete0(mSpline);
mSpline = new0 NURBSCurve2f(5, mCtrlPoints, weights, degree, false,
true);
mCircle = new0 NURBSCurve2f(9, &mCtrlPoints[5], &weights[5], degree,
true, false);
delete1(weights);
}
//----------------------------------------------------------------------------
void NURBSCurveExample::InitialConfiguration ()
{
mSimTime = 0.0f;
delete0(mSpline);
delete0(mCircle);
delete1(mCtrlPoints);
delete1(mTargets);
mCircle = 0;
const int numCtrlPoints = 13;
const int degree = 2;
mCtrlPoints = new1<Vector2f>(numCtrlPoints);
mTargets = new1<Vector2f>(numCtrlPoints);
int i;
for (i = 0; i < numCtrlPoints; ++i)
{
mCtrlPoints[i] = Vector2f(0.125f*mSize + 0.0625f*mSize*i,
0.0625f*mSize);
}
mTargets[ 0] = mCtrlPoints[ 0];
mTargets[ 1] = mCtrlPoints[ 6];
mTargets[ 2] = Vector2f(mCtrlPoints[6].X(), mH - mD);
mTargets[ 3] = Vector2f(mCtrlPoints[5].X(), mH - mD);
mTargets[ 4] = Vector2f(mCtrlPoints[5].X(), mH);
mTargets[ 5] = Vector2f(mCtrlPoints[5].X(), mH + mD);
mTargets[ 6] = Vector2f(mCtrlPoints[6].X(), mH + mD);
mTargets[ 7] = Vector2f(mCtrlPoints[7].X(), mH + mD);
mTargets[ 8] = Vector2f(mCtrlPoints[7].X(), mH);
mTargets[ 9] = Vector2f(mCtrlPoints[7].X(), mH - mD);
mTargets[10] = Vector2f(mCtrlPoints[6].X(), mH - mD);
mTargets[11] = mCtrlPoints[ 6];
mTargets[12] = mCtrlPoints[12];
float* weights = new1<float>(numCtrlPoints);
for (i = 0; i < numCtrlPoints; ++i)
{
weights[i] = 1.0f;
}
const float modWeight = 0.3f;
weights[3] = modWeight;
weights[5] = modWeight;
weights[7] = modWeight;
weights[9] = modWeight;
mSpline = new0 NURBSCurve2f(numCtrlPoints, mCtrlPoints, weights, degree,
false, true);
delete1(weights);
}
//----------------------------------------------------------------------------
void WaterDropFormation::Configuration1 ()
{
delete1(mTargets);
mTargets = 0;
const int numCtrlPoints = 14;
const int degree = 2;
delete1(mCtrlPoints);
mCtrlPoints = new1<Vector2f>(numCtrlPoints);
float* weights = new1<float>(numCtrlPoints);
// spline
mCtrlPoints[0] = mSpline->GetControlPoint(0);
mCtrlPoints[1] = mSpline->GetControlPoint(1);
mCtrlPoints[2] = 0.5f*(mSpline->GetControlPoint(1) +
mSpline->GetControlPoint(2));
mCtrlPoints[3] = mSpline->GetControlPoint(11);
mCtrlPoints[4] = mSpline->GetControlPoint(12);
// circle
int i, j;
for (i = 2, j = 5; i <= 10; ++i, ++j)
{
mCtrlPoints[j] = mSpline->GetControlPoint(i);
}
mCtrlPoints[5] = 0.5f*(mCtrlPoints[2] + mCtrlPoints[5]);
mCtrlPoints[13] = mCtrlPoints[5];
for (i = 0; i < numCtrlPoints; ++i)
{
weights[i] = 1.0f;
}
weights[ 6] = mSpline->GetControlWeight(3);
weights[ 8] = mSpline->GetControlWeight(5);
weights[10] = mSpline->GetControlWeight(7);
weights[12] = mSpline->GetControlWeight(9);
delete0(mSpline);
mSpline = new0 NURBSCurve2f(5, mCtrlPoints, weights ,degree, false,
true);
// Restrict evaluation to a subinterval of the domain.
mSpline->SetTimeInterval(0.5f, 1.0f);
mWaterSurface->SetCurve(mSpline);
mCircle = new0 NURBSCurve2f(9, &mCtrlPoints[5], &weights[5], degree,
true, false);
delete1(weights);
// Restrict evaluation to a subinterval of the domain. Why 0.375? The
// circle NURBS is a loop and not open. The curve is constructed with
// iDegree (2) replicated control points. Although the curve is
// geometrically symmetric about the vertical axis, it is not symmetric
// in t about the half way point (0.5) of the domain [0,1].
mCircle->SetTimeInterval(0.375f, 1.0f);
// Create water drop. The outside view value is set to 'false' because
// the curve (x(t),z(t)) has the property dz/dt < 0. If the curve
// instead had the property dz/dt > 0, then 'true' is the correct value
// for the outside view.
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
mWaterDrop = new0 RevolutionSurface(mCircle, mCtrlPoints[9].X(),
RevolutionSurface::REV_SPHERE_TOPOLOGY, 32, 16, false, false,
vformat);
mWaterDrop->SetEffectInstance(
mWaterEffect->CreateInstance(mWaterTexture));
mWaterRoot->AttachChild(mWaterDrop);
}
//----------------------------------------------------------------------------
void WaterDropFormation::Configuration0 ()
{
// Application loops between Configuration0() and Configuration1().
// Delete all the objects from "1" when restarting with "0".
delete1(mCtrlPoints);
delete1(mTargets);
delete0(mSpline);
delete0(mCircle);
mCircle = 0;
mSimTime = 0.0f;
mSimDelta = 0.05f;
mWaterRoot->DetachChildAt(0);
mWaterRoot->DetachChildAt(1);
mWaterSurface = 0;
mWaterDrop = 0;
// Create water surface curve of revolution.
const int numCtrlPoints = 13;
const int degree = 2;
mCtrlPoints = new1<Vector2f>(numCtrlPoints);
mTargets = new1<Vector2f>(numCtrlPoints);
int i;
for (i = 0; i < numCtrlPoints; ++i)
{
mCtrlPoints[i] = Vector2f(0.125f + 0.0625f*i, 0.0625f);
}
float h = 0.5f;
float d = 0.0625f;
float extra = 0.1f;
mTargets[ 0] = mCtrlPoints[ 0];
mTargets[ 1] = mCtrlPoints[ 6];
mTargets[ 2] = Vector2f(mCtrlPoints[6].X(), h - d - extra);
mTargets[ 3] = Vector2f(mCtrlPoints[5].X(), h - d - extra);
mTargets[ 4] = Vector2f(mCtrlPoints[5].X(), h);
mTargets[ 5] = Vector2f(mCtrlPoints[5].X(), h + d);
mTargets[ 6] = Vector2f(mCtrlPoints[6].X(), h + d);
mTargets[ 7] = Vector2f(mCtrlPoints[7].X(), h + d);
mTargets[ 8] = Vector2f(mCtrlPoints[7].X(), h);
mTargets[ 9] = Vector2f(mCtrlPoints[7].X(), h - d - extra);
mTargets[10] = Vector2f(mCtrlPoints[6].X(), h - d - extra);
mTargets[11] = mCtrlPoints[ 6];
mTargets[12] = mCtrlPoints[12];
float* weights = new1<float>(numCtrlPoints);
for (i = 0; i < numCtrlPoints; ++i)
{
weights[i] = 1.0f;
}
const float modWeight = 0.3f;
weights[3] = modWeight;
weights[5] = modWeight;
weights[7] = modWeight;
weights[9] = modWeight;
mSpline = new0 NURBSCurve2f(numCtrlPoints, mCtrlPoints, weights, degree,
false, true);
// Restrict evaluation to a subinterval of the domain.
mSpline->SetTimeInterval(0.5f, 1.0f);
delete1(weights);
// Create the water surface.
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
mWaterSurface = new0 RevolutionSurface(mSpline, mCtrlPoints[6].X(),
RevolutionSurface::REV_DISK_TOPOLOGY, 32, 16, false, true, vformat);
mWaterSurface->SetEffectInstance(
mWaterEffect->CreateInstance(mWaterTexture));
mWaterRoot->AttachChild(mWaterSurface);
mWaterRoot->Update();
}
