//----------------------------------------------------------------------------
void ClipMesh::CreateScene ()
{
mScene = new0 Node();
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT3, 0);
// The plane is fixed at z = 0.
mPlane.SetNormal(AVector::UNIT_Z);
mPlane.SetConstant(0.0f);
mMeshPlane = StandardMesh(vformat).Rectangle(32, 32, 16.0f, 16.0f);
VisualEffectInstance* instance =
VertexColor3Effect::CreateUniqueInstance();
instance->GetEffect()->GetWireState(0,0)->Enabled = true;
mMeshPlane->SetEffectInstance(instance);
mScene->AttachChild(mMeshPlane);
VertexBufferAccessor vba(mMeshPlane);
Float3 green(0.0f, 1.0f, 0.0f);
int i;
for (i = 0; i < vba.GetNumVertices(); ++i)
{
vba.Color<Float3>(0, i) = green;
}
// Get the positions and indices for a torus.
mTorus = StandardMesh(vformat).Torus(64, 64, 4.0f, 1.0f);
instance = VertexColor3Effect::CreateUniqueInstance();
mTorusWireState = instance->GetEffect()->GetWireState(0, 0);
mTorus->SetEffectInstance(instance);
mScene->AttachChild(mTorus);
vba.ApplyTo(mTorus);
mTorusVerticesMS.resize(vba.GetNumVertices());
mTorusVerticesWS.resize(vba.GetNumVertices());
Float3 black(0.0f, 0.0f, 0.0f);
for (i = 0; i < vba.GetNumVertices(); ++i)
{
mTorusVerticesMS[i] = vba.Position<Float3>(i);
mTorusVerticesWS[i] = mTorusVerticesMS[i];
vba.Color<Float3>(0, i) = black;
}
IndexBuffer* ibuffer = mTorus->GetIndexBuffer();
int numIndices = ibuffer->GetNumElements();
int* indices = (int*)ibuffer->GetData();
mTorusIndices.resize(numIndices);
memcpy(&mTorusIndices[0], indices, numIndices*sizeof(int));
Update();
}
//----------------------------------------------------------------------------
void VolumeFog::CreateScene ()
{
// Create a screen-space camera for the background image.
mScreenCamera = ScreenTarget::CreateCamera();
// Create a screen polygon for the background image.
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
mScreenPolygon = ScreenTarget::CreateRectangle(vformat, GetWidth(),
GetHeight(), 0.0f, 1.0f, 0.0f, 1.0f, 1.0f);
std::string skyName = Environment::GetPathR("BlueSky.wmtf");
Texture2D* skyTexture = Texture2D::LoadWMTF(skyName);
Texture2DEffect* skyEffect = new0 Texture2DEffect();
mScreenPolygon->SetEffectInstance(skyEffect->CreateInstance(skyTexture));
// Create the scene graph for the terrain.
mScene = new0 Node();
// Begin with a flat height field.
vformat = VertexFormat::Create(3,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT4, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
mMesh = StandardMesh(vformat).Rectangle(64, 64, 8.0f, 8.0f);
mScene->AttachChild(mMesh);
// Set the heights based on a precomputed height field. Also create a
// texture image to go with the height field.
std::string heightFieldName = Environment::GetPathR("HeightField.wmtf");
Texture2D* heightTexture = Texture2D::LoadWMTF(heightFieldName);
unsigned char* data = (unsigned char*)heightTexture->GetData(0);
Float4 white(1.0f, 1.0f, 1.0f, 0.0f);
VertexBufferAccessor vba(mMesh);
for (int i = 0; i < vba.GetNumVertices(); ++i)
{
unsigned char value = *data;
float height = 3.0f*value/255.0f + 0.05f*Mathf::SymmetricRandom();
*data++ = (unsigned char)Mathf::IntervalRandom(32.0f, 64.0f);
*data++ = 3*(128 - value/2)/4;
*data++ = 0;
*data++ = 255;
vba.Position<Float3>(i)[2] = height;
// The fog color is white. The alpha channel is filled in by the
// function UpdateFog().
vba.Color<Float4>(0, i) = white;
}
UpdateFog();
std::string effectFile = Environment::GetPathR("VolumeFog.wmfx");
VolumeFogEffect* effect = new0 VolumeFogEffect(effectFile);
mMesh->SetEffectInstance(effect->CreateInstance(heightTexture));
}
//----------------------------------------------------------------------------
void BlendedAnimations::CreateScene ()
{
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
mScene = new0 Node();
mScene->AttachChild(mManager.GetRoot());
// Create a floor to walk on.
VertexFormat* vformat = VertexFormat::Create(3,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_NORMAL, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
mFloor = StandardMesh(vformat).Rectangle(2, 2, 1024.0f, 2048.0f);
VertexBufferAccessor vba(mFloor);
for (int i = 0; i < vba.GetNumVertices(); ++i)
{
Float2& tcoord = vba.TCoord<Float2>(0, i);
tcoord[0] *= 64.0f;
tcoord[1] *= 256.0f;
}
std::string textureName = Environment::GetPathR("Grating.wmtf");
Texture2D* texture = Texture2D::LoadWMTF(textureName);
texture->GenerateMipmaps();
mFloor->SetEffectInstance(Texture2DEffect::CreateUniqueInstance(texture,
Shader::SF_LINEAR_LINEAR, Shader::SC_REPEAT, Shader::SC_REPEAT));
mScene->AttachChild(mFloor);
ComputeVisibleSet(mScene);
}
//----------------------------------------------------------------------------
void PointInPolyhedron::CreateScene ()
{
mScene = new0 Node();
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
// Create a semitransparent sphere mesh.
VertexFormat* vformatMesh = VertexFormat::Create(1,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0);
TriMesh* mesh = StandardMesh(vformatMesh).Sphere(16, 16, 1.0f);
Material* material = new0 Material();
material->Diffuse = Float4(1.0f, 0.0f, 0.0f, 0.25f);
VisualEffectInstance* instance = MaterialEffect::CreateUniqueInstance(
material);
instance->GetEffect()->GetAlphaState(0, 0)->BlendEnabled = true;
mesh->SetEffectInstance(instance);
// Create the data structures for the polyhedron that represents the
// sphere mesh.
CreateQuery(mesh);
// Create a set of random points. Points inside the polyhedron are
// colored white. Points outside the polyhedron are colored blue.
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT3, 0);
int vstride = vformat->GetStride();
VertexBuffer* vbuffer = new0 VertexBuffer(1024, vstride);
VertexBufferAccessor vba(vformat, vbuffer);
Float3 white(1.0f, 1.0f, 1.0f);
Float3 blue(0.0f, 0.0f, 1.0f);
for (int i = 0; i < vba.GetNumVertices(); ++i)
{
Vector3f random(Mathf::SymmetricRandom(),
Mathf::SymmetricRandom(), Mathf::SymmetricRandom());
vba.Position<Vector3f>(i) = random;
if (mQuery->Contains(random))
{
vba.Color<Float3>(0, i) = white;
}
else
{
vba.Color<Float3>(0, i) = blue;
}
}
DeleteQuery();
mPoints = new0 Polypoint(vformat, vbuffer);
mPoints->SetEffectInstance(VertexColor3Effect::CreateUniqueInstance());
mScene->AttachChild(mPoints);
mScene->AttachChild(mesh);
}
//----------------------------------------------------------------------------
TriMesh* Delaunay3D::CreateSphere () const
{
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT3, 0);
TriMesh* mesh = StandardMesh(vformat).Sphere(8, 8, 0.01f);
mesh->SetEffectInstance(VertexColor3Effect::CreateUniqueInstance());
mesh->Culling = Spatial::CULL_ALWAYS;
return mesh;
}
//----------------------------------------------------------------------------
TriMesh* FoucaultPendulum::CreateFloor ()
{
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
TriMesh* floor = StandardMesh(vformat).Rectangle(2, 2, 32.0f, 32.0f);
std::string path = Environment::GetPathR("Wood.wmtf");
Texture2D* texture = Texture2D::LoadWMTF(path);
floor->SetEffectInstance(Texture2DEffect::CreateUniqueInstance(texture,
Shader::SF_LINEAR, Shader::SC_CLAMP_EDGE, Shader::SC_CLAMP_EDGE));
return floor;
}
//----------------------------------------------------------------------------
void WaterDropFormation::CreatePlane ()
{
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
mPlane = StandardMesh(vformat).Rectangle(2, 2, 8.0f, 16.0f);
std::string path = Environment::GetPathR("StoneCeiling.wmtf");
Texture2D* texture = Texture2D::LoadWMTF(path);
mPlane->SetEffectInstance(Texture2DEffect::CreateUniqueInstance(texture,
Shader::SF_LINEAR, Shader::SC_CLAMP_EDGE, Shader::SC_CLAMP_EDGE));
mTrnNode->AttachChild(mPlane);
}
//----------------------------------------------------------------------------
void IntersectTriangleCylinder::CreateScene ()
{
mScene = new0 Node();
mCullState = new0 CullState();
mCullState->Enabled = false;
mRenderer->SetOverrideCullState(mCullState);
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT3, 0);
int vstride = vformat->GetStride();
VertexBuffer* vbuffer = new0 VertexBuffer(3, vstride);
VertexBufferAccessor vba(vformat, vbuffer);
vba.Position<Vector3f>(0) = (const Vector3f&)mTriangleMVertex0;
vba.Color<Float3>(0, 0) = Float3(0.0f, 0.0f, 1.0f);
vba.Position<Vector3f>(1) = (const Vector3f&)mTriangleMVertex1;
vba.Color<Float3>(0, 1) = Float3(0.0f, 0.0f, 1.0f);
vba.Position<Vector3f>(2) = (const Vector3f&)mTriangleMVertex2;
vba.Color<Float3>(0, 2) = Float3(0.0f, 0.0f, 1.0f);
IndexBuffer* ibuffer = new0 IndexBuffer(3, sizeof(int));
int* indices = (int*)ibuffer->GetData();
indices[0] = 0;
indices[1] = 1;
indices[2] = 2;
mTMesh = new0 TriMesh(vformat, vbuffer, ibuffer);
mTMesh->SetEffectInstance(
VertexColor3Effect::CreateUniqueInstance());
mTMesh->LocalTransform.SetTranslate(APoint(0.0f, 1.125f, 0.0f));
mCMesh = StandardMesh(vformat).Cylinder(8, 16, mCylinderRadius,
mCylinderHeight, false);
vba.ApplyTo(mCMesh);
for (int i = 0; i < vba.GetNumVertices(); ++i)
{
vba.Color<Float3>(0, i) = Float3(1.0f, 0.0f, 0.0f);
}
mCMesh->SetEffectInstance(
VertexColor3Effect::CreateUniqueInstance());
mScene->AttachChild(mTMesh);
mScene->AttachChild(mCMesh);
}
//----------------------------------------------------------------------------
void NonuniformScale::CreateScene ()
{
mScene = new0 Node();
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
mMesh = StandardMesh(vformat).Dodecahedron();
std::string path = Environment::GetPathR("Flower.wmtf");
Texture2D* texture = Texture2D::LoadWMTF(path);
mMesh->SetEffectInstance(Texture2DEffect::CreateUniqueInstance(texture,
Shader::SF_LINEAR, Shader::SC_CLAMP_EDGE, Shader::SC_CLAMP_EDGE));
mScene->AttachChild(mMesh);
}
//----------------------------------------------------------------------------
TriMesh* ConvexHull3D::CreateSphere ()
{
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT3, 0);
Float3 white(1.0f, 1.0f, 1.0f);
float radius = 0.01f;
TriMesh* sphere = StandardMesh(vformat).Sphere(8, 8, radius);
VertexBufferAccessor vba(sphere);
for (int i = 0; i < vba.GetNumVertices(); ++i)
{
vba.Color<Float3>(0, i) = white;
}
sphere->SetEffectInstance(VertexColor3Effect::CreateUniqueInstance());
return sphere;
}
//----------------------------------------------------------------------------
void SphereMaps::CreateScene ()
{
mScene = new0 Node();
mTrnNode = new0 Node();
mScene->AttachChild(mTrnNode);
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_NORMAL, VertexFormat::AT_FLOAT3, 0);
TriMesh* mesh = StandardMesh(vformat).Torus(64, 64, 1.0f, 0.5f);
mTrnNode->AttachChild(mesh);
std::string effectFile = Environment::GetPathR("SphereMap.wmfx");
SphereMapEffect* effect = new0 SphereMapEffect(effectFile);
std::string environmentName = Environment::GetPathR("SphereMap.wmtf");
Texture2D* environmentTexture = Texture2D::LoadWMTF(environmentName);
mesh->SetEffectInstance(effect->CreateInstance(environmentTexture));
}
//----------------------------------------------------------------------------
BspNode* BspNodes::CreateNode (const Vector2f& v0, const Vector2f& v1,
VertexColor3Effect* effect, const Float3& color)
{
// Create the model-space separating plane.
Vector2f dir = v1 - v0;
AVector normal(dir[1], -dir[0], 0.0f);
normal.Normalize();
float constant = normal[0]*v0[0] + normal[1]*v0[1];
HPlane modelPlane(normal, constant);
// Create the BSP node.
BspNode* bsp = new0 BspNode(modelPlane);
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT3, 0);
// Create the rectangle representation of the model plane and set the
// vertex colors to the specified color.
float xExtent = 0.5f*dir.Length();
float yExtent = 0.125f;
TriMesh* rect = StandardMesh(vformat).Rectangle(2, 2, xExtent, yExtent);
VertexBufferAccessor vba(rect);
for (int i = 0; i < 4; ++i)
{
vba.Color<Float3>(0, i) = color;
}
rect->SetEffectInstance(effect->CreateInstance());
// Set the position and orientation for the world-space plane.
APoint trn(0.5f*(v0[0] + v1[0]), 0.5f*(v0[1] + v1[1]), yExtent + 0.001f);
HMatrix zRotate(AVector::UNIT_Z, Mathf::ATan2(dir.Y(),dir.X()));
HMatrix xRotate(AVector::UNIT_X, Mathf::HALF_PI);
HMatrix rotate = zRotate*xRotate;
rect->LocalTransform.SetTranslate(trn);
rect->LocalTransform.SetRotate(rotate);
bsp->AttachCoplanarChild(rect);
return bsp;
}
//----------------------------------------------------------------------------
void ConvexHull3D::CreateScene ()
{
mScene = new0 Node();
mTrnNode = new0 Node();
mScene->AttachChild(mTrnNode);
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
mCullState = new0 CullState();
mCullState->Enabled = false;
mRenderer->SetOverrideCullState(mCullState);
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT3, 0);
TriMesh* sphere = StandardMesh(vformat).Sphere(8, 8, 0.01f);
sphere->SetEffectInstance(VertexColor3Effect::CreateUniqueInstance());
mTrnNode->SetChild(1, sphere);
// The current file is "Data/data01.txt".
LoadData();
}
//----------------------------------------------------------------------------
TriMesh* RoughPlaneSolidBox::CreateGround ()
{
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
TriMesh* ground = StandardMesh(vformat).Rectangle(2, 2, 32.0f, 32.0f);
// Change the texture repeat.
VertexBufferAccessor vba(ground);
for (int i = 0; i < vba.GetNumVertices(); ++i)
{
Float2& tcoord = vba.TCoord<Float2>(0, i);
tcoord[0] *= 8.0f;
tcoord[1] *= 8.0f;
}
std::string path = Environment::GetPathR("Gravel.wmtf");
Texture2D* texture = Texture2D::LoadWMTF(path);
ground->SetEffectInstance(Texture2DEffect::CreateUniqueInstance(texture,
Shader::SF_LINEAR, Shader::SC_REPEAT, Shader::SC_REPEAT));
return ground;
}
//----------------------------------------------------------------------------
void GeodesicHeightField::CreateScene ()
{
mScene = new0 Node();
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
mCullState = new0 CullState();
mCullState->Enabled = false;
mRenderer->SetOverrideCullState(mCullState);
// Create the ground. It covers a square with vertices (1,1,0), (1,-1,0),
// (-1,1,0), and (-1,-1,0).
VertexFormat* vformat = VertexFormat::Create(3,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_NORMAL, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
const int xSize = 64;
const int ySize = 64;
const float xExtent = 1.0f;
const float yExtent = 1.0f;
mMesh = StandardMesh(vformat).Rectangle(xSize, ySize, xExtent, yExtent);
// Create a B-Spline height field. The heights of the control point are
// defined in an input file. The input file is structured as
//
// numUCtrlPoints numVCtrlPoints UDegree VDegree
// z[0][0] z[0][1] ... z[0][numV-1]
// z[1][0] z[1][1] ... z[1][numV_1]
// :
// z[numU-1][0] z[numU-1][1] ... z[numU-1][numV-1]
std::string path = Environment::GetPathR("ControlPoints.txt");
std::ifstream inFile(path.c_str());
int numUCtrlPoints, numVCtrlPoints, uDegree, vDegree;
double height;
inFile >> numUCtrlPoints;
inFile >> numVCtrlPoints;
inFile >> uDegree;
inFile >> vDegree;
Vector3d** ctrlPoints = new2<Vector3d>(numUCtrlPoints, numVCtrlPoints);
int i;
for (i = 0; i < numUCtrlPoints; ++i)
{
double u = (double)(xExtent*(-1.0f + 2.0f*i/(numUCtrlPoints-1)));
for (int j = 0; j < numVCtrlPoints; ++j)
{
double v = (double)(yExtent*(-1.0f + 2.0f*j/(numVCtrlPoints-1)));
inFile >> height;
ctrlPoints[i][j] = Vector3d(u, v, height);
}
}
inFile.close();
mSurface = new0 BSplineRectangled(numUCtrlPoints, numVCtrlPoints,
ctrlPoints, uDegree, vDegree, false, false, true, true);
delete2(ctrlPoints);
VertexBufferAccessor vba(mMesh);
for (i = 0; i < vba.GetNumVertices(); ++i)
{
Vector3f& position = vba.Position<Vector3f>(i);
double u = (double)((position.X() + xExtent)/(2.0f*xExtent));
double v = (double)((position.Y() + yExtent)/(2.0f*yExtent));
position.Z() = (float)mSurface->P(u,v).Z();
}
mMesh->UpdateModelSpace(Visual::GU_NORMALS);
// Attach an effect that uses lights, material, and texture.
mMesh->SetEffectInstance(CreateEffectInstance());
mScene->AttachChild(mMesh);
// Create the geodesic calculator.
mGeodesic = new0 BSplineGeodesicd(*mSurface);
mGeodesic->Subdivisions = 6;
mGeodesic->Refinements = 1;
mGeodesic->SearchRadius = 0.1;
mGeodesic->RefineCallback = &GeodesicHeightField::RefineCallback;
mPQuantity = (1 << mGeodesic->Subdivisions) + 1;
}
//----------------------------------------------------------------------------
void CubeMaps::CreateScene ()
{
// Create the root of the scene.
mScene = new0 Node();
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
// Create the walls of the cube room. Each of the six texture images is
// RGBA 64-by-64.
Node* room = new0 Node();
mScene->AttachChild(room);
// Index buffer shared by the room walls.
IndexBuffer* ibuffer = new0 IndexBuffer(6, sizeof(int));
int* indices = (int*)ibuffer->GetData();
indices[0] = 0; indices[1] = 1; indices[2] = 3;
indices[3] = 0; indices[4] = 3; indices[5] = 2;
// The vertex format shared by the room walls.
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
int vstride = vformat->GetStride();
VertexBufferAccessor vba;
// The texture effect shared by the room walls.
Texture2DEffect* effect = new0 Texture2DEffect(Shader::SF_LINEAR);
VertexBuffer* vbuffer;
TriMesh* wall;
std::string textureName;
// +x wall
vbuffer = new0 VertexBuffer(4, vstride);
vba.ApplyTo(vformat, vbuffer);
vba.Position<Float3>(0) = Float3(+1.0f, -1.0f, -1.0f);
vba.Position<Float3>(1) = Float3(+1.0f, -1.0f, +1.0f);
vba.Position<Float3>(2) = Float3(+1.0f, +1.0f, -1.0f);
vba.Position<Float3>(3) = Float3(+1.0f, +1.0f, +1.0f);
vba.TCoord<Float2>(0, 0) = Float2(0.0f, 0.0f);
vba.TCoord<Float2>(0, 1) = Float2(1.0f, 0.0f);
vba.TCoord<Float2>(0, 2) = Float2(0.0f, 1.0f);
vba.TCoord<Float2>(0, 3) = Float2(1.0f, 1.0f);
wall = new0 TriMesh(vformat, vbuffer, ibuffer);
room->AttachChild(wall);
textureName = Environment::GetPathR("XpFace.wmtf");
Texture2D* xpTexture = Texture2D::LoadWMTF(textureName);
wall->SetEffectInstance(effect->CreateInstance(xpTexture));
// -x wall
vbuffer = new0 VertexBuffer(4, vstride);
vba.ApplyTo(vformat, vbuffer);
vba.Position<Float3>(0) = Float3(-1.0f, -1.0f, +1.0f);
vba.Position<Float3>(1) = Float3(-1.0f, -1.0f, -1.0f);
vba.Position<Float3>(2) = Float3(-1.0f, +1.0f, +1.0f);
vba.Position<Float3>(3) = Float3(-1.0f, +1.0f, -1.0f);
vba.TCoord<Float2>(0, 0) = Float2(0.0f, 0.0f);
vba.TCoord<Float2>(0, 1) = Float2(1.0f, 0.0f);
vba.TCoord<Float2>(0, 2) = Float2(0.0f, 1.0f);
vba.TCoord<Float2>(0, 3) = Float2(1.0f, 1.0f);
wall = new0 TriMesh(vformat, vbuffer, ibuffer);
room->AttachChild(wall);
textureName = Environment::GetPathR("XmFace.wmtf");
Texture2D* xmTexture = Texture2D::LoadWMTF(textureName);
wall->SetEffectInstance(effect->CreateInstance(xmTexture));
// +y wall
vbuffer = new0 VertexBuffer(4, vstride);
vba.ApplyTo(vformat, vbuffer);
vba.Position<Float3>(0) = Float3(+1.0f, +1.0f, +1.0f);
vba.Position<Float3>(1) = Float3(-1.0f, +1.0f, +1.0f);
vba.Position<Float3>(2) = Float3(+1.0f, +1.0f, -1.0f);
vba.Position<Float3>(3) = Float3(-1.0f, +1.0f, -1.0f);
vba.TCoord<Float2>(0, 0) = Float2(0.0f, 0.0f);
vba.TCoord<Float2>(0, 1) = Float2(1.0f, 0.0f);
vba.TCoord<Float2>(0, 2) = Float2(0.0f, 1.0f);
vba.TCoord<Float2>(0, 3) = Float2(1.0f, 1.0f);
wall = new0 TriMesh(vformat, vbuffer, ibuffer);
room->AttachChild(wall);
textureName = Environment::GetPathR("YpFace.wmtf");
Texture2D* ypTexture = Texture2D::LoadWMTF(textureName);
wall->SetEffectInstance(effect->CreateInstance(ypTexture));
// -y wall
vbuffer = new0 VertexBuffer(4, vstride);
vba.ApplyTo(vformat, vbuffer);
vba.Position<Float3>(0) = Float3(+1.0f, -1.0f, -1.0f);
vba.Position<Float3>(1) = Float3(-1.0f, -1.0f, -1.0f);
vba.Position<Float3>(2) = Float3(+1.0f, -1.0f, +1.0f);
vba.Position<Float3>(3) = Float3(-1.0f, -1.0f, +1.0f);
vba.TCoord<Float2>(0, 0) = Float2(0.0f, 0.0f);
vba.TCoord<Float2>(0, 1) = Float2(1.0f, 0.0f);
vba.TCoord<Float2>(0, 2) = Float2(0.0f, 1.0f);
vba.TCoord<Float2>(0, 3) = Float2(1.0f, 1.0f);
wall = new0 TriMesh(vformat, vbuffer, ibuffer);
room->AttachChild(wall);
textureName = Environment::GetPathR("YmFace.wmtf");
Texture2D* ymTexture = Texture2D::LoadWMTF(textureName);
wall->SetEffectInstance(effect->CreateInstance(ymTexture));
// +z wall
vbuffer = new0 VertexBuffer(4, vstride);
vba.ApplyTo(vformat, vbuffer);
vba.Position<Float3>(0) = Float3(+1.0f, -1.0f, +1.0f);
vba.Position<Float3>(1) = Float3(-1.0f, -1.0f, +1.0f);
vba.Position<Float3>(2) = Float3(+1.0f, +1.0f, +1.0f);
vba.Position<Float3>(3) = Float3(-1.0f, +1.0f, +1.0f);
vba.TCoord<Float2>(0, 0) = Float2(0.0f, 0.0f);
vba.TCoord<Float2>(0, 1) = Float2(1.0f, 0.0f);
vba.TCoord<Float2>(0, 2) = Float2(0.0f, 1.0f);
vba.TCoord<Float2>(0, 3) = Float2(1.0f, 1.0f);
wall = new0 TriMesh(vformat, vbuffer, ibuffer);
room->AttachChild(wall);
textureName = Environment::GetPathR("ZpFace.wmtf");
Texture2D* zpTexture = Texture2D::LoadWMTF(textureName);
wall->SetEffectInstance(effect->CreateInstance(zpTexture));
// -z wall
vbuffer = new0 VertexBuffer(4, vstride);
vba.ApplyTo(vformat, vbuffer);
vba.Position<Float3>(0) = Float3(-1.0f, -1.0f, -1.0f);
vba.Position<Float3>(1) = Float3(+1.0f, -1.0f, -1.0f);
vba.Position<Float3>(2) = Float3(-1.0f, +1.0f, -1.0f);
vba.Position<Float3>(3) = Float3(+1.0f, +1.0f, -1.0f);
vba.TCoord<Float2>(0, 0) = Float2(0.0f, 0.0f);
vba.TCoord<Float2>(0, 1) = Float2(1.0f, 0.0f);
vba.TCoord<Float2>(0, 2) = Float2(0.0f, 1.0f);
vba.TCoord<Float2>(0, 3) = Float2(1.0f, 1.0f);
wall = new0 TriMesh(vformat, vbuffer, ibuffer);
room->AttachChild(wall);
textureName = Environment::GetPathR("ZmFace.wmtf");
Texture2D* zmTexture = Texture2D::LoadWMTF(textureName);
wall->SetEffectInstance(effect->CreateInstance(zmTexture));
// A sphere to reflect the environment via a cube map. The colors will
// be used to modulate the cube map texture.
vformat = VertexFormat::Create(3,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_NORMAL, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT3, 0);
vstride = vformat->GetStride();
mSphere = StandardMesh(vformat).Sphere(64, 64, 0.125f);
room->AttachChild(mSphere);
// Generate random vertex colors for the sphere. The StandardMesh class
// produces a sphere with duplicated vertices along a longitude line.
// This allows texture coordinates to be assigned in a manner that treats
// the sphere as if it were a rectangle mesh. For vertex colors, we want
// the duplicated vertices to have the same color, so a hash table is used
// to look up vertex colors for the duplicates.
vba.ApplyTo(mSphere);
std::map<Float3,Float3> dataMap;
for (int i = 0; i < vba.GetNumVertices(); ++i)
{
Float3& position = vba.Position<Float3>(i);
Float3& color = vba.Color<Float3>(0, i);
std::map<Float3,Float3>::iterator iter = dataMap.find(position);
if (iter != dataMap.end())
{
color = iter->second;
}
else
{
color[0] = 0.0f;
color[1] = Mathf::IntervalRandom(0.5f, 0.75f);
color[2] = Mathf::IntervalRandom(0.75f, 1.0f);
dataMap.insert(std::make_pair(position, color));
}
}
// Create the cube map and attach it to the sphere.
std::string effectFile = Environment::GetPathR("CubeMap.wmfx");
CubeMapEffect* cubeMapEffect = new0 CubeMapEffect(effectFile);
ShaderFloat* reflectivity = new0 ShaderFloat(1);
(*reflectivity)[0] = 0.5f;
std::string cubeName = Environment::GetPathR("CubeMap.wmtf");
TextureCube* cubeTexture = TextureCube::LoadWMTF(cubeName);
cubeTexture->GenerateMipmaps();
mCubeMapInstance = cubeMapEffect->CreateInstance(cubeTexture,
reflectivity, false);
mSphere->SetEffectInstance(mCubeMapInstance);
// Allow culling to be disabled on the sphere so when you move inside
// the sphere, you can see the previously hidden facets and verify that
// the cube image for those facets is correctly oriented.
mSphereCullState = cubeMapEffect->GetCullState(0, 0);
}
//----------------------------------------------------------------------------
bool NonlocalBlowup::OnInitialize ()
{
if (!WindowApplication3::OnInitialize())
{
return false;
}
#ifdef RUN_CONSOLE
RunConsole();
return false;
#endif
mScene = new0 Node();
mScene->LocalTransform.SetRotate(HMatrix(
0.80475128f, 0.59107417f, -0.054833174f, 0.0f,
-0.17529237f, 0.32487807f, 0.92936903f, 0.0f,
0.56714010f, -0.73829913f, 0.36505684f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f));
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
TriMesh* mesh = StandardMesh(vformat).Rectangle(256, 256, 16.0f, 16.0f);
mScene->AttachChild(mesh);
std::string gridName = Environment::GetPathR("Grid.wmtf");
Texture2D* gridTexture = Texture2D::LoadWMTF(gridName);
gridTexture->GenerateMipmaps();
Texture1D* colorTexture = new0 Texture1D(Texture::TF_A8R8G8B8, 8, 1);
unsigned char* color = (unsigned char*)colorTexture->GetData(0);
color[ 0] = 128; color[ 1] = 128; color[ 2] = 128; color[ 3] = 255;
color[ 4] = 255; color[ 5] = 0; color[ 6] = 128; color[ 7] = 255;
color[ 8] = 255; color[ 9] = 0; color[10] = 0; color[11] = 255;
color[12] = 0; color[13] = 255; color[14] = 0; color[15] = 255;
color[16] = 0; color[17] = 255; color[18] = 255; color[19] = 255;
color[20] = 0; color[21] = 128; color[22] = 255; color[23] = 255;
color[24] = 0; color[25] = 0; color[26] = 255; color[27] = 255;
color[28] = 255; color[29] = 255; color[30] = 255; color[31] = 255;
float dt = 0.01f, dx = 1.0f, dy = 1.0f;
// Uncomment only one of these at a time.
NonconvexDomain0p50(dt, dx, dy);
//SquareSymmetric0p01(dt, dx, dy);
//SquareSymmetric0p50(dt, dx, dy);
//SquareSymmetric0p99(dt, dx, dy);
//SquareGaussX0p50(dt, dx, dy);
//SquareGaussXY0p50(dt, dx, dy);
//SquareGaussFour0p50(dt, dx, dy);
DisplacementEffect* effect = new0 DisplacementEffect();
mesh->SetEffectInstance(effect->CreateInstance(mHeightTexture,
gridTexture, colorTexture, mDomainTexture));
// Set up the camera so that it looks at the graph from slightly above
// the xy-plane and at a skewed angle/direction of view.
mCamera->SetFrustum(60.0f, GetAspectRatio(), 1.0f, 10000.0f);
APoint camPosition(0.0f, 3.46f, 42.97f);
AVector camDVector(0.0f, 0.0f, -1.0f);
AVector camUVector(0.0f, 1.0f, 0.0f);
AVector camRVector = camDVector.Cross(camUVector);
mCamera->SetFrame(camPosition, camDVector, camUVector, camRVector);
// Initial update of objects.
mScene->Update();
// Initial culling of scene.
mCuller.SetCamera(mCamera);
mCuller.ComputeVisibleSet(mScene);
InitializeCameraMotion(0.01f, 0.01f);
InitializeObjectMotion(mScene);
return true;
}
//----------------------------------------------------------------------------
void BillboardNodes::CreateScene ()
{
mScene = new0 Node();
mCullState = new0 CullState();
mRenderer->SetOverrideCullState(mCullState);
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
// All triangle meshes have this common vertex format. Use StandardMesh
// to create these meshes.
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
StandardMesh stdMesh(vformat);
// Create the ground. It covers a square with vertices (1,1,0), (1,-1,0),
// (-1,1,0), and (-1,-1,0). Multiply the texture coordinates by a factor
// to enhance the wrap-around.
mGround = stdMesh.Rectangle(2, 2, 16.0f, 16.0f);
VertexBufferAccessor vba(mGround);
int i;
for (i = 0; i < vba.GetNumVertices(); ++i)
{
Float2& tcoord = vba.TCoord<Float2>(0, i);
tcoord[0] *= 128.0f;
tcoord[1] *= 128.0f;
}
// Create a texture effect for the ground.
std::string path = Environment::GetPathR("Horizontal.wmtf");
Texture2D* texture = Texture2D::LoadWMTF(path);
VisualEffectInstance* instance = Texture2DEffect::CreateUniqueInstance(
texture, Shader::SF_LINEAR_LINEAR, Shader::SC_REPEAT,
Shader::SC_REPEAT);
mGround->SetEffectInstance(instance);
mScene->AttachChild(mGround);
// Create a rectangle mesh. The mesh is in the xy-plane. Do not apply
// local transformations to the mesh. Use the billboard node transforms
// to control the mesh location and orientation.
mRectangle = stdMesh.Rectangle(2, 2, 0.125f, 0.25f);
// Create a texture effect for the rectangle and for the torus.
Texture2DEffect* geomEffect = new0 Texture2DEffect(Shader::SF_LINEAR);
path = Environment::GetPathR("RedSky.wmtf");
texture = Texture2D::LoadWMTF(path);
mRectangle->SetEffectInstance(geomEffect->CreateInstance(texture));
// Create a billboard node that causes a rectangle to always be facing
// the camera. This is the type of billboard for an avatar.
mBillboard0 = new0 BillboardNode(mCamera);
mBillboard0->AttachChild(mRectangle);
mScene->AttachChild(mBillboard0);
// The billboard rotation is about its model-space up-vector (0,1,0). In
// this application, world-space up is (0,0,1). Locally rotate the
// billboard so it's up-vector matches the world's.
mBillboard0->LocalTransform.SetTranslate(APoint(-0.25f, 0.0f, 0.25f));
mBillboard0->LocalTransform.SetRotate(HMatrix(AVector::UNIT_X,
Mathf::HALF_PI));
// Create a torus mesh. Do not apply local transformations to the mesh.
// Use the billboard node transforms to control the mesh location and
// orientation.
mTorus = StandardMesh(vformat, false).Torus(16, 16, 1.0f, 0.25f);
mTorus->LocalTransform.SetUniformScale(0.1f);
// Create a texture effect for the torus. It uses the RedSky image that
// the rectangle uses.
mTorus->SetEffectInstance(geomEffect->CreateInstance(texture));
// Create a billboard node that causes an object to always be oriented
// the same way relative to the camera.
mBillboard1 = new0 BillboardNode(mCamera);
mBillboard1->AttachChild(mTorus);
mScene->AttachChild(mBillboard1);
// The billboard rotation is about its model-space up-vector (0,1,0). In
// this application, world-space up is (0,0,1). Locally rotate the
// billboard so it's up-vector matches the world's.
mBillboard1->LocalTransform.SetTranslate(APoint(0.25f, 0.0f, 0.25f));
mBillboard1->LocalTransform.SetRotate(HMatrix(AVector::UNIT_X,
Mathf::HALF_PI));
#ifdef DEMONSTRATE_VIEWPORT_BOUNDING_RECTANGLE
// The screen camera is designed to map (x,y,z) in [0,1]^3 to (x',y,'z')
// in [-1,1]^2 x [0,1].
mSSCamera = new0 Camera(false);
mSSCamera->SetFrustum(0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f);
mSSCamera->SetFrame(APoint::ORIGIN, AVector::UNIT_Z, AVector::UNIT_Y,
AVector::UNIT_X);
// Create a semitransparent screen rectangle.
VertexFormat* ssVFormat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT4, 0);
int ssVStride = ssVFormat->GetStride();
VertexBuffer* ssVBuffer = new0 VertexBuffer(4, ssVStride);
VertexBufferAccessor ssVba(ssVFormat, ssVBuffer);
Float4 ssColor(0.0f, 0.0f, 1.0f, 0.25f);
ssVba.Position<Float3>(0) = Float3(0.0f, 0.0f, 0.0f);
ssVba.Position<Float3>(1) = Float3(1.0f, 0.0f, 0.0f);
ssVba.Position<Float3>(2) = Float3(1.0f, 1.0f, 0.0f);
ssVba.Position<Float3>(3) = Float3(0.0f, 1.0f, 0.0f);
ssVba.Color<Float4>(0, 0) = ssColor;
ssVba.Color<Float4>(0, 1) = ssColor;
ssVba.Color<Float4>(0, 2) = ssColor;
ssVba.Color<Float4>(0, 3) = ssColor;
IndexBuffer* ssIBuffer = new0 IndexBuffer(6, sizeof(int));
int* indices = (int*)ssIBuffer->GetData();
indices[0] = 0; indices[1] = 1; indices[2] = 2;
indices[3] = 0; indices[4] = 2; indices[5] = 3;
mSSRectangle = new0 TriMesh(ssVFormat, ssVBuffer, ssIBuffer);
mSSRectangle->Update();
// Create a vertex color effect for the screen rectangle.
VertexColor4Effect* ssEffect = new0 VertexColor4Effect();
mSSRectangle->SetEffectInstance(ssEffect->CreateInstance());
// Alpha blending must be enabled to obtain the semitransparency.
ssEffect->GetAlphaState(0, 0)->BlendEnabled = true;
#endif
}
//----------------------------------------------------------------------------
void IntersectConvexPolyhedra::CreateScene ()
{
mScene = new0 Node();
mMotionObject = mScene;
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT3, 0);
int vstride = vformat->GetStride();
// Attach a dummy intersection mesh. If the intersection is nonempty,
// the Culling flag will be modified to CULL_DYNAMIC. The intersection
// is drawn as a solid.
mMeshIntersection = StandardMesh(vformat).Tetrahedron();
VertexBufferAccessor vba(mMeshIntersection);
Float3 green(0.0f, 1.0f, 0.0f);
int i, j;
for (i = 0; i < vba.GetNumVertices(); ++i)
{
vba.Color<Float3>(0, i) = green;
}
mMeshIntersection->SetEffectInstance(
VertexColor3Effect::CreateUniqueInstance());
mMeshIntersection->Culling = Spatial::CULL_ALWAYS;
mScene->AttachChild(mMeshIntersection);
// The first polyhedron is an ellipsoid.
ConvexPolyhedronf::CreateEggShape(Vector3f::ZERO, 1.0f, 1.0f, 2.0f, 2.0f,
4.0f, 4.0f, 3, mWorldPoly0);
// Build the corresponding mesh.
int numVertices = mWorldPoly0.GetNumVertices();
int numTriangles = mWorldPoly0.GetNumTriangles();
int numIndices = 3*numTriangles;
VertexBuffer* vbuffer = new0 VertexBuffer(numVertices, vstride);
IndexBuffer* ibuffer = new0 IndexBuffer(numIndices, sizeof(int));
Float3 red(1.0f, 0.0f, 0.0f);
vba.ApplyTo(vformat, vbuffer);
for (i = 0; i < numVertices; ++i)
{
vba.Position<Vector3f>(i) = mWorldPoly0.Point(i);
vba.Color<Float3>(0,i) = red;
}
int* indices = (int*)ibuffer->GetData();
for (i = 0; i < numTriangles; ++i)
{
const MTTriangle& triangle = mWorldPoly0.GetTriangle(i);
for (j = 0; j < 3; ++j)
{
indices[3*i + j] = mWorldPoly0.GetVLabel(triangle.GetVertex(j));
}
}
mMeshPoly0 = new0 TriMesh(vformat, vbuffer, ibuffer);
VisualEffectInstance* instance =
VertexColor3Effect::CreateUniqueInstance();
instance->GetEffect()->GetWireState(0, 0)->Enabled = true;
mMeshPoly0->SetEffectInstance(instance);
mMeshPoly0->LocalTransform.SetTranslate(APoint(0.0f, 2.0f, 0.0f));
mScene->AttachChild(mMeshPoly0);
// The second polyhedron is egg shaped.
ConvexPolyhedronf::CreateEggShape(Vector3f::ZERO, 2.0f, 2.0f, 4.0f, 4.0f,
5.0f, 3.0f, 4, mWorldPoly1);
// Build the corresponding mesh.
numVertices = mWorldPoly1.GetNumVertices();
numTriangles = mWorldPoly1.GetNumTriangles();
numIndices = 3*numTriangles;
vbuffer = new0 VertexBuffer(numVertices, vstride);
ibuffer = new0 IndexBuffer(numIndices, sizeof(int));
Float3 blue(0.0f, 0.0f, 1.0f);
vba.ApplyTo(vformat, vbuffer);
for (i = 0; i < numVertices; ++i)
{
vba.Position<Vector3f>(i) = mWorldPoly1.Point(i);
vba.Color<Float3>(0, i) = blue;
}
indices = (int*)ibuffer->GetData();
for (i = 0; i < numTriangles; ++i)
{
const MTTriangle& triangle = mWorldPoly1.GetTriangle(i);
for (j = 0; j < 3; ++j)
{
indices[3*i + j] = mWorldPoly1.GetVLabel(triangle.GetVertex(j));
}
}
mMeshPoly1 = new0 TriMesh(vformat, vbuffer, ibuffer);
instance = VertexColor3Effect::CreateUniqueInstance();
instance->GetEffect()->GetWireState(0, 0)->Enabled = true;
mMeshPoly1->SetEffectInstance(instance);
mMeshPoly1->LocalTransform.SetTranslate(APoint(0.0f, -2.0f, 0.0f));
mScene->AttachChild(mMeshPoly1);
ComputeIntersection();
}
//----------------------------------------------------------------------------
void BSplineSurfaceFitter::CreateScene ()
{
mScene = new0 Node();
mWireState = new0 WireState();
mRenderer->SetOverrideWireState(mWireState);
mCullState = new0 CullState();
mCullState->Enabled = false;
mRenderer->SetOverrideCullState(mCullState);
// Begin with a flat 64x64 height field.
const int numSamples = 64;
const float extent = 8.0f;
VertexFormat* vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_TEXCOORD, VertexFormat::AT_FLOAT2, 0);
mHeightField = StandardMesh(vformat).Rectangle(numSamples, numSamples,
extent, extent);
mScene->AttachChild(mHeightField);
// Set the heights based on a precomputed height field. Also create a
// texture image to go with the height field.
std::string path = Environment::GetPathR("HeightField.wmtf");
Texture2D* texture = Texture2D::LoadWMTF(path);
VisualEffectInstance* instance = Texture2DEffect::CreateUniqueInstance(
texture, Shader::SF_LINEAR, Shader::SC_CLAMP_EDGE,
Shader::SC_CLAMP_EDGE);
mHeightField->SetEffectInstance(instance);
unsigned char* data = (unsigned char*)texture->GetData(0);
VertexBufferAccessor vba(mHeightField);
Vector3f** samplePoints = new2<Vector3f>(numSamples, numSamples);
int i;
for (i = 0; i < vba.GetNumVertices(); ++i)
{
unsigned char value = *data;
float height = 3.0f*((float)value)/255.0f +
0.05f*Mathf::SymmetricRandom();
*data++ = (unsigned char)Mathf::IntervalRandom(32.0f, 64.0f);
*data++ = 3*(128 - value/2)/4;
*data++ = 0;
data++;
vba.Position<Vector3f>(i).Z() = height;
samplePoints[i % numSamples][i / numSamples] =
vba.Position<Vector3f>(i);
}
// Compute a B-Spline surface with NxN control points, where N < 64.
// This surface will be sampled to 64x64 and displayed together with the
// original height field for comparison.
const int numCtrlPoints = 32;
const int degree = 3;
BSplineSurfaceFitf fitter(degree, numCtrlPoints, numSamples, degree,
numCtrlPoints, numSamples, samplePoints);
delete2(samplePoints);
vformat = VertexFormat::Create(2,
VertexFormat::AU_POSITION, VertexFormat::AT_FLOAT3, 0,
VertexFormat::AU_COLOR, VertexFormat::AT_FLOAT4, 0);
mFittedField = StandardMesh(vformat).Rectangle(numSamples, numSamples,
extent, extent);
mScene->AttachChild(mFittedField);
vba.ApplyTo(mFittedField);
Float4 translucent(1.0f, 1.0f, 1.0f, 0.5f);
for (i = 0; i < vba.GetNumVertices(); ++i)
{
float u = 0.5f*(vba.Position<Vector3f>(i).X()/extent + 1.0f);
float v = 0.5f*(vba.Position<Vector3f>(i).Y()/extent + 1.0f);
vba.Position<Vector3f>(i) = fitter.GetPosition(u, v);
vba.Color<Float4>(0,i) = translucent;
}
instance = VertexColor4Effect::CreateUniqueInstance();
mFittedField->SetEffectInstance(instance);
instance->GetEffect()->GetAlphaState(0, 0)->BlendEnabled = true;
}