void MinimumVolumeSphere3DWindow::CreateScene()
{
// Create the points.
std::mt19937 mte;
std::uniform_real_distribution<float> rnd(-1.0f, 1.0f);
for (auto& v : mVertices)
{
v = { rnd(mte), rnd(mte), rnd(mte) };
}
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
MeshFactory mf;
mf.SetVertexFormat(vformat);
std::shared_ptr<ConstantColorEffect> effect;
for (int i = 0; i < NUM_POINTS; ++i)
{
mPoints[i] = mf.CreateSphere(6, 6, 0.01f);
effect = std::make_shared<ConstantColorEffect>(mProgramFactory,
Vector4<float>({ 0.5f, 0.5f, 0.5f, 1.0f }));
mPoints[i]->SetEffect(effect);
mCameraRig.Subscribe(mPoints[i]->worldTransform,
effect->GetPVWMatrixConstant());
std::shared_ptr<VertexBuffer> vbuffer = mPoints[i]->GetVertexBuffer();
Vector3<float>* vertex = vbuffer->Get<Vector3<float>>();
Vector3<float> offset = mVertices[i];
for (unsigned int j = 0; j < vbuffer->GetNumElements(); ++j)
{
vertex[j] += offset;
}
}
// Create the segments.
std::shared_ptr<VertexBuffer> vbuffer(new VertexBuffer(vformat, 12));
vbuffer->SetUsage(Resource::DYNAMIC_UPDATE);
std::shared_ptr<IndexBuffer> ibuffer(new IndexBuffer(
IP_POLYSEGMENT_DISJOINT, 6));
effect = std::make_shared<ConstantColorEffect>(mProgramFactory,
Vector4<float>({ 0.5f, 0.0f, 0.0f, 1.0f }));
mSegments = std::make_shared<Visual>(vbuffer, ibuffer, effect);
mCameraRig.Subscribe(mSegments->worldTransform,
effect->GetPVWMatrixConstant());
mSegments->Update();
// Create the sphere.
mSphere = mf.CreateSphere(16, 16, 1.0f);
effect = std::make_shared<ConstantColorEffect>(mProgramFactory,
Vector4<float>({ 0.0f, 0.0f, 0.5f, 1.0f }));
mSphere->SetEffect(effect);
mCameraRig.Subscribe(mSphere->worldTransform,
effect->GetPVWMatrixConstant());
}
//----------------------------------------------------------------------------
bool WireMeshWindow::CreateScene()
{
std::string path = mEnvironment.GetPath("WireMesh.hlsl");
std::shared_ptr<VertexShader> vshader(ShaderFactory::CreateVertex(path));
if (!vshader)
{
return false;
}
std::shared_ptr<GeometryShader> gshader(ShaderFactory::CreateGeometry(
path));
if (!gshader)
{
return false;
}
std::shared_ptr<PixelShader> pshader(ShaderFactory::CreatePixel(path));
if (!pshader)
{
return false;
}
std::shared_ptr<ConstantBuffer> parameters(
new ConstantBuffer(3 * sizeof(Vector4<float>), false));
Vector4<float>* data = parameters->Get<Vector4<float>>();
data[0] = Vector4<float>(0.0f, 0.0f, 1.0f, 1.0f); // mesh color
data[1] = Vector4<float>(0.0f, 0.0f, 0.0f, 1.0f); // edge color
data[2] = Vector4<float>((float)mXSize, (float)mYSize, 0.0f, 0.0f);
vshader->Set("WireParameters", parameters);
gshader->Set("WireParameters", parameters);
pshader->Set("WireParameters", parameters);
std::shared_ptr<ConstantBuffer> cbuffer(
new ConstantBuffer(sizeof(Matrix4x4<float>), true));
vshader->Set("PVWMatrix", cbuffer);
std::shared_ptr<VisualEffect> effect(new VisualEffect(vshader, pshader,
gshader));
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
MeshFactory mf;
mf.SetVertexFormat(vformat);
mMesh = mf.CreateSphere(16, 16, 1.0f);
mMesh->SetEffect(effect);
mMesh->Update();
SubscribeCW(mMesh, cbuffer);
return true;
}
void Delaunay3DWindow::CreateSphere()
{
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
vformat.Bind(VA_COLOR, DF_R32G32B32_FLOAT, 0);
MeshFactory mf;
mf.SetVertexFormat(vformat);
mSphere = mf.CreateSphere(8, 8, 0.025f);
std::shared_ptr<VertexColorEffect> effect =
std::make_shared<VertexColorEffect>(mProgramFactory);
mSphere->SetEffect(effect);
// Move the sphere offscreen initially.
mSphere->localTransform.SetTranslation(0.0f, 0.0f, -1000.0f);
mSphere->Update();
mCameraRig.Subscribe(mSphere->worldTransform,
effect->GetPVWMatrixConstant());
mScene->AttachChild(mSphere);
}
//----------------------------------------------------------------------------
bool PlaneMeshIntersectionWindow::CreateScene()
{
std::string path = mEnvironment.GetPath("PlaneMeshIntersection.hlsl");
std::shared_ptr<VertexShader> vshader(ShaderFactory::CreateVertex(path));
if (!vshader)
{
return false;
}
std::shared_ptr<PixelShader> pshader(ShaderFactory::CreatePixel(path));
if (!pshader)
{
return false;
}
path = mEnvironment.GetPath("DrawIntersections.hlsl");
mDrawIntersections.reset(ShaderFactory::CreateCompute(path));
float planeDelta = 0.125f;
mPMIParameters.reset(new ConstantBuffer(sizeof(PMIParameters), true));
PMIParameters& p = *mPMIParameters->Get<PMIParameters>();
p.pvMatrix = mCamera.GetProjectionViewMatrix();
p.wMatrix = Matrix4x4<float>::Identity();
p.planeVector0 = Vector4<float>(1.0f, 0.0f, 0.0f, 0.0f) / planeDelta;
p.planeVector1 = Vector4<float>(0.0f, 1.0f, 0.0f, 0.0f) / planeDelta;
vshader->Set("PMIParameters", mPMIParameters);
std::shared_ptr<VisualEffect> effect(new VisualEffect(vshader, pshader));
VertexFormat vformat;
vformat.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
MeshFactory mf;
mf.SetVertexFormat(vformat);
mMesh = mf.CreateSphere(16, 16, 1.0f);
mMesh->SetEffect(effect);
mMesh->Update();
return true;
}
void PickingWindow::CreateScene()
{
std::string path = mEnvironment.GetPath("Checkerboard.png");
std::shared_ptr<Texture2> texture(WICFileIO::Load(path, false));
mScene = std::make_shared<Node>();
VertexFormat vformat0;
vformat0.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
vformat0.Bind(VA_TEXCOORD, DF_R32G32_FLOAT, 0);
// The torus and dodecahedron are created by the mesh factory in which
// the 'visual' model bounds are computed. The points and segments
// primitives are created explicitly here, so we need to compute their
// model bounds to be used by the picking system.
MeshFactory mf;
mf.SetVertexFormat(vformat0);
mTorus = mf.CreateTorus(16, 16, 4.0f, 1.0f);
std::shared_ptr<Texture2Effect> effect = std::make_shared<Texture2Effect>(
mProgramFactory, texture, SamplerState::MIN_L_MAG_L_MIP_P,
SamplerState::CLAMP, SamplerState::CLAMP);
mTorus->SetEffect(effect);
mCameraRig.Subscribe(mTorus->worldTransform,
effect->GetPVWMatrixConstant());
mScene->AttachChild(mTorus);
mDodecahedron = mf.CreateDodecahedron();
effect = std::make_shared<Texture2Effect>(mProgramFactory, texture,
SamplerState::MIN_L_MAG_L_MIP_P, SamplerState::CLAMP,
SamplerState::CLAMP);
mDodecahedron->SetEffect(effect);
mCameraRig.Subscribe(mDodecahedron->worldTransform,
effect->GetPVWMatrixConstant());
mScene->AttachChild(mDodecahedron);
VertexFormat vformat1;
vformat1.Bind(VA_POSITION, DF_R32G32B32_FLOAT, 0);
std::shared_ptr<VertexBuffer> vbuffer(new VertexBuffer(vformat1, 4));
Vector3<float>* vertices = vbuffer->Get<Vector3<float>>();
vertices[0] = { 1.0f, 1.0f, 4.0f };
vertices[1] = { 1.0f, 2.0f, 5.0f };
vertices[2] = { 2.0f, 2.0f, 6.0f };
vertices[3] = { 2.0f, 1.0f, 7.0f };
std::shared_ptr<IndexBuffer> ibuffer(new IndexBuffer(IP_POLYPOINT, 4));
std::shared_ptr<ConstantColorEffect> cceffect =
std::make_shared<ConstantColorEffect>(mProgramFactory,
Vector4<float>({ 0.5f, 0.0f, 0.0f, 1.0f }));
mPoints = std::make_shared<Visual>(vbuffer, ibuffer, cceffect);
mPoints->UpdateModelBound();
mCameraRig.Subscribe(mPoints->worldTransform,
cceffect->GetPVWMatrixConstant());
mScene->AttachChild(mPoints);
vbuffer = std::make_shared<VertexBuffer>(vformat1, 4);
vertices = vbuffer->Get<Vector3<float>>();
vertices[0] = { -1.0f, -1.0f, 4.0f };
vertices[1] = { -1.0f, -2.0f, 5.0f };
vertices[2] = { -2.0f, -1.0f, 6.0f };
vertices[3] = { -2.0f, -2.0f, 7.0f };
ibuffer = std::make_shared<IndexBuffer>(IP_POLYSEGMENT_CONTIGUOUS, 3,
sizeof(int));
ibuffer->SetSegment(0, 0, 1);
ibuffer->SetSegment(1, 1, 2);
ibuffer->SetSegment(2, 2, 3);
cceffect = std::make_shared<ConstantColorEffect>(mProgramFactory,
Vector4<float>({ 0.0f, 0.0f, 0.5f, 1.0f }));
mSegments = std::make_shared<Visual>(vbuffer, ibuffer, cceffect);
mSegments->UpdateModelBound();
mCameraRig.Subscribe(mSegments->worldTransform,
cceffect->GetPVWMatrixConstant());
mScene->AttachChild(mSegments);
for (int i = 0; i < SPHERE_BUDGET; ++i)
{
mSphere[i] = mf.CreateSphere(8, 8, 0.125f);
cceffect = std::make_shared<ConstantColorEffect>(mProgramFactory,
Vector4<float>({ 0.0f, 0.0f, 0.0f, 1.0f }));
mSphere[i]->SetEffect(cceffect);
mCameraRig.Subscribe(mSphere[i]->worldTransform,
cceffect->GetPVWMatrixConstant());
mScene->AttachChild(mSphere[i]);
}
mTrackball.Attach(mScene);
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);
}