void BlendedAnimationsWindow::CreateScene()
{
mWireState = std::make_shared<RasterizerState>();
mWireState->fillMode = RasterizerState::FILL_WIREFRAME;
mScene = std::make_shared<Node>();
mScene->AttachChild(mManager->GetRoot());
// Create a floor to walk on.
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
vformat.Bind(VA_NORMAL, DF_R32G32B32_FLOAT, 0);
vformat.Bind(VA_TEXCOORD, DF_R32G32_FLOAT, 0);
MeshFactory mf;
mf.SetVertexFormat(vformat);
mFloor = mf.CreateRectangle(2, 2, 1024.0f, 2048.0f);
mFloor->name = "Floor";
mScene->AttachChild(mFloor);
std::shared_ptr<VertexBuffer> vbuffer = mFloor->GetVertexBuffer();
vbuffer->SetUsage(Resource::DYNAMIC_UPDATE);
unsigned int numVertices = vbuffer->GetNumElements();
Vertex* vertex = vbuffer->Get<Vertex>();
for (unsigned int i = 0; i < numVertices; ++i)
{
vertex[i].tcoord[0] *= 64.0f;
vertex[i].tcoord[1] *= 256.0f;
}
std::string textureName = mEnvironment.GetPath("Grating.png");
std::shared_ptr<Texture2> texture(WICFileIO::Load(textureName, true));
texture->AutogenerateMipmaps();
std::shared_ptr<Texture2Effect> effect = std::make_shared<Texture2Effect>(
mProgramFactory, texture, SamplerState::MIN_L_MAG_L_MIP_L,
SamplerState::WRAP, SamplerState::WRAP);
mFloor->SetEffect(effect);
mCameraRig.Subscribe(mFloor->worldTransform, effect->GetPVWMatrixConstant());
for (auto const& subscriber : mManager->GetSubscribers())
{
mCameraRig.Subscribe(subscriber.first->worldTransform, subscriber.second);
}
GetMeshes(mScene);
mTrackball.Attach(mScene);
mTrackball.Update(mApplicationTime);
}
void BSplineSurfaceFitterWindow::CreateScene()
{
// Begin with a flat 64x64 height field.
int const numSamples = 64;
float const extent = 8.0f;
VertexFormat hfformat;
hfformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
hfformat.Bind(VA_TEXCOORD, DF_R32G32_FLOAT, 0);
MeshFactory mf;
mf.SetVertexFormat(hfformat);
mHeightField = mf.CreateRectangle(numSamples, numSamples, extent, extent);
int numVertices = numSamples * numSamples;
VertexPT* hfvertices = mHeightField->GetVertexBuffer()->Get<VertexPT>();
// Set the heights based on a precomputed height field. Also create a
// texture image to go with the height field.
std::string path = mEnvironment.GetPath("BTHeightField.png");
std::shared_ptr<Texture2> texture(WICFileIO::Load(path, false));
std::shared_ptr<Texture2Effect> txeffect =
std::make_shared<Texture2Effect>(mProgramFactory, texture,
SamplerState::MIN_L_MAG_L_MIP_P, SamplerState::CLAMP,
SamplerState::CLAMP);
mHeightField->SetEffect(txeffect);
std::mt19937 mte;
std::uniform_real_distribution<float> symmr(-0.05f, 0.05f);
std::uniform_real_distribution<float> intvr(32.0f, 64.0f);
unsigned char* data = (unsigned char*)texture->Get<unsigned char>();
std::vector<Vector3<float>> samplePoints(numVertices);
for (int i = 0; i < numVertices; ++i)
{
unsigned char value = *data;
float height = 3.0f*((float)value) / 255.0f + symmr(mte);
*data++ = (unsigned char)intvr(mte);
*data++ = 3 * (128 - value / 2) / 4;
*data++ = 0;
data++;
hfvertices[i].position[2] = height;
samplePoints[i] = hfvertices[i].position;
}
// 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.
int const numControls = 32;
int const degree = 3;
BSplineSurfaceFit<float> fitter(degree, numControls, numSamples, degree,
numControls, numSamples, &samplePoints[0]);
VertexFormat ffformat;
ffformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
ffformat.Bind(VA_COLOR, DF_R32G32B32A32_FLOAT, 0);
mf.SetVertexFormat(ffformat);
mFittedField = mf.CreateRectangle(numSamples, numSamples, extent, extent);
VertexPC* ffvertices = mFittedField->GetVertexBuffer()->Get<VertexPC>();
Vector4<float> translucent{ 1.0f, 1.0f, 1.0f, 0.5f };
for (int i = 0; i < numVertices; ++i)
{
float u = 0.5f*(ffvertices[i].position[0] / extent + 1.0f);
float v = 0.5f*(ffvertices[i].position[1] / extent + 1.0f);
ffvertices[i].position = fitter.GetPosition(u, v);
ffvertices[i].color = translucent;
}
std::shared_ptr<VertexColorEffect> vceffect =
std::make_shared<VertexColorEffect>(mProgramFactory);
mFittedField->SetEffect(vceffect);
mCameraRig.Subscribe(mHeightField->worldTransform,
txeffect->GetPVWMatrixConstant());
mCameraRig.Subscribe(mFittedField->worldTransform,
vceffect->GetPVWMatrixConstant());
mTrackball.Attach(mHeightField);
mTrackball.Attach(mFittedField);
mTrackball.Update();
}
void LightsWindow::CreateScene()
{
// Copper color for the planes.
Vector4<float> planeAmbient{ 0.2295f, 0.08825f, 0.0275f, 1.0f };
Vector4<float> planeDiffuse{ 0.5508f, 0.2118f, 0.066f, 1.0f };
Vector4<float> planeSpecular{ 0.580594f, 0.223257f, 0.0695701f, 51.2f };
// Gold color for the spheres.
Vector4<float> sphereAmbient{ 0.24725f, 0.2245f, 0.0645f, 1.0f };
Vector4<float> sphereDiffuse{ 0.34615f, 0.3143f, 0.0903f, 1.0f };
Vector4<float> sphereSpecular{ 0.797357f, 0.723991f, 0.208006f, 83.2f };
// Various parameters shared by the lighting constants. The geometric
// parameters are dynamic, modified by UpdateConstants() whenever the
// camera or scene moves. These include camera model position, light
// model position, light model direction, and model-to-world matrix.
Vector4<float> darkGray{ 0.1f, 0.1f, 0.1f, 1.0f };
Vector4<float> lightGray{ 0.75f, 0.75f, 0.75f, 1.0f };
float angle = 0.125f*(float)GTE_C_PI;
Vector4<float> lightSpotCutoff{ angle, cos(angle), sin(angle), 1.0f };
mLightWorldPosition[SVTX] = { 4.0f, 4.0f - 8.0f, 8.0f, 1.0f };
mLightWorldPosition[SPXL] = { 4.0f, 4.0f + 8.0f, 8.0f, 1.0f };
mLightWorldDirection = { -1.0f, -1.0f, -1.0f, 0.0f };
Normalize(mLightWorldDirection);
std::shared_ptr<Material> material[LNUM][GNUM];
std::shared_ptr<Lighting> lighting[LNUM][GNUM];
std::shared_ptr<LightCameraGeometry> geometry[LNUM][GNUM];
for (int lt = 0; lt < LNUM; ++lt)
{
for (int gt = 0; gt < GNUM; ++gt)
{
material[lt][gt] = std::make_shared<Material>();
lighting[lt][gt] = std::make_shared<Lighting>();
geometry[lt][gt] = std::make_shared<LightCameraGeometry>();
}
}
// Initialize the directional lighting constants.
material[LDIR][GPLN]->ambient = planeAmbient;
material[LDIR][GPLN]->diffuse = planeDiffuse;
material[LDIR][GPLN]->specular = planeSpecular;
lighting[LDIR][GPLN]->ambient = lightGray;
material[LDIR][GSPH]->ambient = sphereAmbient;
material[LDIR][GSPH]->diffuse = sphereDiffuse;
material[LDIR][GSPH]->specular = sphereSpecular;
lighting[LDIR][GSPH]->ambient = lightGray;
// Initialize the point lighting constants.
material[LPNT][GPLN]->ambient = planeAmbient;
material[LPNT][GPLN]->diffuse = planeDiffuse;
material[LPNT][GPLN]->specular = planeSpecular;
lighting[LPNT][GPLN]->ambient = darkGray;
material[LPNT][GSPH]->ambient = sphereAmbient;
material[LPNT][GSPH]->diffuse = sphereDiffuse;
material[LPNT][GSPH]->specular = sphereSpecular;
lighting[LPNT][GSPH]->ambient = darkGray;
// Initialize the spot lighting constants.
material[LSPT][GPLN]->ambient = planeAmbient;
material[LSPT][GPLN]->diffuse = planeDiffuse;
material[LSPT][GPLN]->specular = planeSpecular;
lighting[LSPT][GPLN]->ambient = darkGray;
lighting[LSPT][GPLN]->spotCutoff = lightSpotCutoff;
material[LSPT][GSPH]->ambient = sphereAmbient;
material[LSPT][GSPH]->diffuse = sphereDiffuse;
material[LSPT][GSPH]->specular = sphereSpecular;
lighting[LSPT][GSPH]->ambient = darkGray;
lighting[LSPT][GSPH]->spotCutoff = lightSpotCutoff;
// Create the effects.
for (int gt = 0; gt < GNUM; ++gt)
{
for (int st = 0; st < SNUM; ++st)
{
mEffect[LDIR][gt][st] = std::make_shared<DirectionalLightEffect>(
mProgramFactory, mUpdater, st,
material[LDIR][gt], lighting[LDIR][gt], geometry[LDIR][gt]);
mEffect[LPNT][gt][st] = std::make_shared<PointLightEffect>(
mProgramFactory, mUpdater, st,
material[LPNT][gt], lighting[LPNT][gt], geometry[LPNT][gt]);
mEffect[LSPT][gt][st] = std::make_shared<SpotLightEffect>(
mProgramFactory, mUpdater, st,
material[LSPT][gt], lighting[LSPT][gt], geometry[LSPT][gt]);
}
}
// Create the planes and spheres.
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
vformat.Bind(VA_NORMAL, DF_R32G32B32_FLOAT, 0);
MeshFactory mf;
mf.SetVertexFormat(vformat);
mPlane[SVTX] = mf.CreateRectangle(128, 128, 8.0f, 8.0f);
mPlane[SVTX]->localTransform.SetTranslation(0.0f, -8.0f, 0.0f);
mTrackball.Attach(mPlane[SVTX]);
mPlane[SPXL] = mf.CreateRectangle(128, 128, 8.0f, 8.0f);
mPlane[SPXL]->localTransform.SetTranslation(0.0f, +8.0f, 0.0f);
mTrackball.Attach(mPlane[SPXL]);
mSphere[SVTX] = mf.CreateSphere(64, 64, 2.0f);
mSphere[SVTX]->localTransform.SetTranslation(0.0f, -8.0f, 2.0f);
mTrackball.Attach(mSphere[SVTX]);
mSphere[SPXL] = mf.CreateSphere(64, 64, 2.0f);
mSphere[SPXL]->localTransform.SetTranslation(0.0f, +8.0f, 2.0f);
mTrackball.Attach(mSphere[SPXL]);
mTrackball.Update();
mCaption[LDIR] = "Directional Light (left per vertex, right per pixel)";
mCaption[LPNT] = "Point Light (left per vertex, right per pixel)";
mCaption[LSPT] = "Spot Light (left per vertex, right per pixel)";
UseLightType(LDIR);
}