Exemplo n.º 1
0
void LightingDemo2::buildCigar()
{
    GeometryGenerator::MeshData cig;
    GeometryGenerator geoGen;
    geoGen.CreateCigarPack(15.f, cig);

    std::vector<Vertex::PosNormalTex> vertices(cig.Vertices.size());
    for (UINT i = 0; i < cig.Vertices.size(); ++i)
    {
        vertices[i].Pos    = cig.Vertices[i].Position;
        vertices[i].Normal = cig.Vertices[i].Normal;
        vertices[i].Tex    = cig.Vertices[i].TexC;
    }
    D3D11_BUFFER_DESC vbd;
    vbd.Usage = D3D11_USAGE_IMMUTABLE;
    vbd.ByteWidth = sizeof(Vertex::PosNormalTex) * cig.Vertices.size();
    vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vbd.CPUAccessFlags = 0;
    vbd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA vinitData;
    vinitData.pSysMem = &vertices[0];
    HR(md3dDevice->CreateBuffer(&vbd, &vinitData, &mCigVB));

    D3D11_BUFFER_DESC ibd;
    ibd.Usage = D3D11_USAGE_IMMUTABLE;
    ibd.ByteWidth = sizeof(UINT) * cig.Indices.size();
    ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
    ibd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA iinitData;
    iinitData.pSysMem = &cig.Indices[0];
    HR(md3dDevice->CreateBuffer(&ibd, &iinitData, &mCigIB));
}
void D3DPBRApp::BuildGeometry()
{
	GeometryGenerator::MeshData sphere;
	GeometryGenerator geoGen;
	geoGen.CreateSphere(5.f, 40, 40, sphere);
	m_indexnum = sphere.Indices.size();
	std::vector<Vertex::Basic32> vertices(sphere.Vertices.size());
	for (int i = 0; i < vertices.size(); i++)
	{
		vertices[i].Normal = sphere.Vertices[i].Normal;
		vertices[i].Pos = sphere.Vertices[i].Position;
		vertices[i].Tangent = sphere.Vertices[i].TangentU;
		vertices[i].Tex = sphere.Vertices[i].TexC;
	}

	D3D11_BUFFER_DESC dbd;
	dbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
	dbd.ByteWidth = sizeof(Vertex::Basic32) * vertices.size();
	dbd.CPUAccessFlags = 0;
	dbd.StructureByteStride = 0;
	dbd.MiscFlags = 0;
	dbd.Usage = D3D11_USAGE_DEFAULT;
	D3D11_SUBRESOURCE_DATA vinitdata;
	vinitdata.pSysMem = &vertices[0];

	HR(md3dDevice->CreateBuffer(&dbd, &vinitdata, &m_pVB));

	std::vector<UINT> indeces(sphere.Indices.begin(), sphere.Indices.end());

	dbd.BindFlags = D3D11_BIND_INDEX_BUFFER;
	dbd.ByteWidth = sizeof(UINT) * m_indexnum;
	vinitdata.pSysMem = &indeces[0];

	HR(md3dDevice->CreateBuffer(&dbd, &vinitdata, &m_pIB));
}
Exemplo n.º 3
0
bool cGridMesh::Init()
{
	// 1. Á¤Á¡ Á¤º¸¸¦ ÃßÃâÇÑ´Ù.
	GeometryGenerator::MeshData grid;
	GeometryGenerator geoGen;

	geoGen.CreateGrid(160.0f, 160.0f, 50, 50, grid);

	m_GridIndexCount = static_cast<UINT>(grid.Indices.size());

	// 2. °¢ Á¤Á¡¿¡ ³ôÀÌ ÇÔ¼ö¸¦ Àû¿ëÇÏ°í ±× ³ôÀÌ¿¡ µû¸¥ »ö»óµµ ÀûÀýÈ÷ ¼³Á¤ÇÑ´Ù.
	// ±×µÚ ¹öÆÛ¸¦ »ý¼ºÇÑ´Ù.

	std::vector<Vertex::Simple> vertices(grid.Vertices.size());
	for (int i = 0; i < grid.Vertices.size(); ++i)
	{
		XMFLOAT3 p = grid.Vertices[i].Position;

		// Á¤Á¡ÀÇ ³ôÀ̸¦ ±¸ÇÑ´Ù.
		p.y = GetHeight(p.x, p.z);

		vertices[i].Pos = p;

		// ³ôÀÌ¿¡ ±âÃÊÇؼ­ Á¤Á¡ÀÇ »ö»óÀ» ¼³Á¤ÇÑ´Ù.
		if (p.y < -10.0f)
		{
			// Çغ¯ÀÇ ¸ð·¡»ö.
			vertices[i].Color = XMFLOAT4(1.0f, 0.96f, 0.62f, 1.0f);
		}
		else if(p.y < 5.0f)
		{
			// ¹àÀº ³ìȲ»ö.
			vertices[i].Color = XMFLOAT4(0.48f, 0.77f, 0.46f, 1.0f);
		}
		else if (p.y < 12.0f)
		{
			// £Àº ³ìȲ»ö.
			vertices[i].Color = XMFLOAT4(0.1f, 0.48f, 0.19f, 1.0f);
		}
		else if (p.y < 20.0f)
		{
			// £Àº °¥»ö
			vertices[i].Color = XMFLOAT4(0.1f, 0.48f, 0.19f, 1.0f);
		}
		else
		{
			// ʼn»ö(´«)
			vertices[i].Color = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
		}
	}

	// ¹öÆÛ¸¦ »ý¼ºÇÑ´Ù.
	m_VB = MyDirectUtil::CreateVertexBuffer(&vertices[0], sizeof(Vertex::Simple) * static_cast<UINT>(vertices.size()), g_pD3DDevice);
	m_IB = MyDirectUtil::CreateIndexBuffer(&grid.Indices[0], sizeof(UINT) * m_GridIndexCount, g_pD3DDevice);

	return true;
}
Exemplo n.º 4
0
void DXBox::BuildBuffers(ID3D11Device* md3dDevice)
{
	GeometryGenerator::MeshData box;

	GeometryGenerator geoGen;
	geoGen.CreateBox(1.0f, 1.0f, 1.0f, box);

	// Cache the vertex offsets to each object in the concatenated vertex buffer.
	mBoxVertexOffset      = 0;

	// Cache the index count of each object.
	mBoxIndexCount      = box.Indices.size();

	// Cache the starting index for each object in the concatenated index buffer.
	mBoxIndexOffset      = 0;
	
	UINT totalVertexCount = box.Vertices.size();

	UINT totalIndexCount = mBoxIndexCount;

	// Extract the vertex elements we are interested in and pack the
	// vertices of all the meshes into one vertex buffer.
	std::vector<Vertex::Basic32> vertices(totalVertexCount);

	UINT k = 0;
	for(size_t i = 0; i < box.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos    = box.Vertices[i].Position;
		vertices[k].Normal = box.Vertices[i].Normal;
		vertices[k].Tex    = box.Vertices[i].TexC;
	}

	D3D11_BUFFER_DESC vbd;
	vbd.Usage = D3D11_USAGE_IMMUTABLE;
	vbd.ByteWidth = sizeof(Vertex::Basic32) * totalVertexCount;
	vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
	vbd.CPUAccessFlags = 0;
	vbd.MiscFlags = 0;
	D3D11_SUBRESOURCE_DATA vinitData;
	vinitData.pSysMem = &vertices[0];
	HR(md3dDevice->CreateBuffer(&vbd, &vinitData, &mBoxVB));

	// Pack the indices of all the meshes into one index buffer.
	std::vector<UINT> indices;
	indices.insert(indices.end(), box.Indices.begin(), box.Indices.end());

	D3D11_BUFFER_DESC ibd;
	ibd.Usage = D3D11_USAGE_IMMUTABLE;
	ibd.ByteWidth = sizeof(UINT) * totalIndexCount;
	ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
	ibd.CPUAccessFlags = 0;
	ibd.MiscFlags = 0;
	D3D11_SUBRESOURCE_DATA iinitData;
	iinitData.pSysMem = &indices[0];
	HR(md3dDevice->CreateBuffer(&ibd, &iinitData, &mBoxIB));
}
Exemplo n.º 5
0
void WavesCSApp::BuildLandGeometry()
{
    GeometryGenerator geoGen;
    GeometryGenerator::MeshData grid = geoGen.CreateGrid(160.0f, 160.0f, 50, 50);

    //
    // Extract the vertex elements we are interested and apply the height function to
    // each vertex.  In addition, color the vertices based on their height so we have
    // sandy looking beaches, grassy low hills, and snow mountain peaks.
    //

    std::vector<Vertex> vertices(grid.Vertices.size());
    for(size_t i = 0; i < grid.Vertices.size(); ++i)
    {
        auto& p = grid.Vertices[i].Position;
        vertices[i].Pos = p;
        vertices[i].Pos.y = GetHillsHeight(p.x, p.z);
        vertices[i].Normal = GetHillsNormal(p.x, p.z);
		vertices[i].TexC = grid.Vertices[i].TexC;
    }

    const UINT vbByteSize = (UINT)vertices.size() * sizeof(Vertex);

    std::vector<std::uint16_t> indices = grid.GetIndices16();
    const UINT ibByteSize = (UINT)indices.size() * sizeof(std::uint16_t);

	auto geo = std::make_unique<MeshGeometry>();
	geo->Name = "landGeo";

	ThrowIfFailed(D3DCreateBlob(vbByteSize, &geo->VertexBufferCPU));
	CopyMemory(geo->VertexBufferCPU->GetBufferPointer(), vertices.data(), vbByteSize);

	ThrowIfFailed(D3DCreateBlob(ibByteSize, &geo->IndexBufferCPU));
	CopyMemory(geo->IndexBufferCPU->GetBufferPointer(), indices.data(), ibByteSize);

	geo->VertexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), vertices.data(), vbByteSize, geo->VertexBufferUploader);

	geo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), indices.data(), ibByteSize, geo->IndexBufferUploader);

	geo->VertexByteStride = sizeof(Vertex);
	geo->VertexBufferByteSize = vbByteSize;
	geo->IndexFormat = DXGI_FORMAT_R16_UINT;
	geo->IndexBufferByteSize = ibByteSize;

	SubmeshGeometry submesh;
	submesh.IndexCount = (UINT)indices.size();
	submesh.StartIndexLocation = 0;
	submesh.BaseVertexLocation = 0;

	geo->DrawArgs["grid"] = submesh;

	mGeometries["landGeo"] = std::move(geo);
}
Exemplo n.º 6
0
Wave::Wave(float width, float depth, UINT m, UINT n)
: m_Time(0)
, m_Width(width)
, m_Depth(depth)
, m_M(m)
, m_N(n)
{
	GeometryGenerator gen;

	gen.CreateGrid(*m_Data, width, depth, m, n);
}
void D3DTextureDemo::BuildLandGemetryBuffers()
{
	GeometryGenerator::MeshData grid;
	GeometryGenerator landGenerator;
	landGenerator.createGrid(160.0f, 160.0f, 50, 50, grid);

	mLandIndexCount = grid.Indices.size();
	std::vector<Vertex> vertices(grid.Vertices.size());
	for(size_t i = 0; i < grid.Vertices.size(); ++i)
	{
		XMFLOAT3 p = grid.Vertices[i].Position;

		p.y = GetHillHeight(p.x, p.z);
		
		vertices[i].Pos    = p;
		vertices[i].Normal = GetHillNormal(p.x, p.z);
		vertices[i].Tex    = grid.Vertices[i].TexC;
	}

	D3D11_BUFFER_DESC vbd;
	vbd.Usage               = D3D11_USAGE_IMMUTABLE;
	vbd.ByteWidth           = sizeof(Vertex) * grid.Vertices.size();
	vbd.BindFlags           = D3D11_BIND_VERTEX_BUFFER;
	vbd.CPUAccessFlags      = 0;
	vbd.MiscFlags           = 0;
	vbd.StructureByteStride = 0;

	D3D11_SUBRESOURCE_DATA vinitData;
	vinitData.pSysMem = &vertices[0];
	HR(m_d3dDevice->CreateBuffer(
		&vbd,
		&vinitData,
		&mLandVB),
		L"Create Vertex Buffer");

	D3D11_BUFFER_DESC ibd;
	ibd.Usage               = D3D11_USAGE_IMMUTABLE;
	ibd.ByteWidth           = sizeof(UINT) * mLandIndexCount;
	ibd.BindFlags           = D3D11_BIND_INDEX_BUFFER;
	ibd.CPUAccessFlags      = 0;
	ibd.MiscFlags           = 0;
	ibd.StructureByteStride = 0;

	D3D11_SUBRESOURCE_DATA iinitData;
	iinitData.pSysMem = &grid.Indices[0];
	HR(m_d3dDevice->CreateBuffer(
		&ibd,
		&iinitData,
		&mLandIB),
		L"Create Index Buffer");
}
Exemplo n.º 8
0
void BlendApp::BuildLandGeometryBuffers()
{
	GeometryGenerator::MeshData grid;
 
	GeometryGenerator geoGen;

	geoGen.CreateGrid(160.0f, 160.0f, 50, 50, grid);

	mLandIndexCount = grid.Indices.size();

	//
	// Extract the vertex elements we are interested and apply the height function to
	// each vertex.  
	//

	std::vector<Vertex> vertices(grid.Vertices.size());
	for(UINT i = 0; i < grid.Vertices.size(); ++i)
	{
		XMFLOAT3 p = grid.Vertices[i].Position;

		p.y = GetHillHeight(p.x, p.z);
		
		vertices[i].Pos    = p;
		vertices[i].Normal = GetHillNormal(p.x, p.z);
		vertices[i].Tex    = grid.Vertices[i].TexC;
	}

    D3D11_BUFFER_DESC vbd;
    vbd.Usage = D3D11_USAGE_IMMUTABLE;
	vbd.ByteWidth = sizeof(Vertex) * grid.Vertices.size();
    vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vbd.CPUAccessFlags = 0;
    vbd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA vinitData;
    vinitData.pSysMem = &vertices[0];
    HR(md3dDevice->CreateBuffer(&vbd, &vinitData, &mLandVB));

	//
	// Pack the indices of all the meshes into one index buffer.
	//

	D3D11_BUFFER_DESC ibd;
    ibd.Usage = D3D11_USAGE_IMMUTABLE;
	ibd.ByteWidth = sizeof(UINT) * mLandIndexCount;
    ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
    ibd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA iinitData;
	iinitData.pSysMem = &grid.Indices[0];
    HR(md3dDevice->CreateBuffer(&ibd, &iinitData, &mLandIB));
}
Exemplo n.º 9
0
void WavesCSApp::BuildBoxGeometry()
{
	GeometryGenerator geoGen;
	GeometryGenerator::MeshData box = geoGen.CreateBox(8.0f, 8.0f, 8.0f, 3);

	std::vector<Vertex> vertices(box.Vertices.size());
	for (size_t i = 0; i < box.Vertices.size(); ++i)
	{
		auto& p = box.Vertices[i].Position;
		vertices[i].Pos = p;
		vertices[i].Normal = box.Vertices[i].Normal;
		vertices[i].TexC = box.Vertices[i].TexC;
	}

	const UINT vbByteSize = (UINT)vertices.size() * sizeof(Vertex);

	std::vector<std::uint16_t> indices = box.GetIndices16();
	const UINT ibByteSize = (UINT)indices.size() * sizeof(std::uint16_t);

	auto geo = std::make_unique<MeshGeometry>();
	geo->Name = "boxGeo";

	ThrowIfFailed(D3DCreateBlob(vbByteSize, &geo->VertexBufferCPU));
	CopyMemory(geo->VertexBufferCPU->GetBufferPointer(), vertices.data(), vbByteSize);

	ThrowIfFailed(D3DCreateBlob(ibByteSize, &geo->IndexBufferCPU));
	CopyMemory(geo->IndexBufferCPU->GetBufferPointer(), indices.data(), ibByteSize);

	geo->VertexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), vertices.data(), vbByteSize, geo->VertexBufferUploader);

	geo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), indices.data(), ibByteSize, geo->IndexBufferUploader);

	geo->VertexByteStride = sizeof(Vertex);
	geo->VertexBufferByteSize = vbByteSize;
	geo->IndexFormat = DXGI_FORMAT_R16_UINT;
	geo->IndexBufferByteSize = ibByteSize;

	SubmeshGeometry submesh;
	submesh.IndexCount = (UINT)indices.size();
	submesh.StartIndexLocation = 0;
	submesh.BaseVertexLocation = 0;

	geo->DrawArgs["box"] = submesh;

	mGeometries["boxGeo"] = std::move(geo);
}
Exemplo n.º 10
0
void BlendApp::BuildCrateGeometryBuffers()
{
	GeometryGenerator::MeshData box;

	GeometryGenerator geoGen;
	geoGen.CreateBox(1.0f, 1.0f, 1.0f, box);

	//
	// Extract the vertex elements we are interested in and pack the
	// vertices of all the meshes into one vertex buffer.
	//

	std::vector<Vertex> vertices(box.Vertices.size());

	for(UINT i = 0; i < box.Vertices.size(); ++i)
	{
		vertices[i].Pos    = box.Vertices[i].Position;
		vertices[i].Normal = box.Vertices[i].Normal;
		vertices[i].Tex    = box.Vertices[i].TexC;
	}

    D3D11_BUFFER_DESC vbd;
	ZeroMemory(&vbd, sizeof(vbd));
    vbd.Usage = D3D11_USAGE_IMMUTABLE;
    vbd.ByteWidth = sizeof(Vertex) * box.Vertices.size();
    vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vbd.CPUAccessFlags = 0;
    vbd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA vinitData;
    vinitData.pSysMem = &vertices[0];
    HR(md3dDevice->CreateBuffer(&vbd, &vinitData, &mBoxVB));

	//
	// Pack the indices of all the meshes into one index buffer.
	//

	D3D11_BUFFER_DESC ibd;
	ZeroMemory(&ibd, sizeof(ibd));
    ibd.Usage = D3D11_USAGE_IMMUTABLE;
	ibd.ByteWidth = sizeof(UINT) * box.Indices.size();
    ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
    ibd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA iinitData;
    iinitData.pSysMem = &box.Indices[0];
    HR(md3dDevice->CreateBuffer(&ibd, &iinitData, &mBoxIB));
}
Exemplo n.º 11
0
void WavesCSApp::BuildWavesGeometry()
{
	GeometryGenerator geoGen;
	GeometryGenerator::MeshData grid = geoGen.CreateGrid(160.0f, 160.0f, mWaves->RowCount(), mWaves->ColumnCount());

	std::vector<Vertex> vertices(grid.Vertices.size());
	for(size_t i = 0; i < grid.Vertices.size(); ++i)
	{
		vertices[i].Pos = grid.Vertices[i].Position;
		vertices[i].Normal = grid.Vertices[i].Normal;
		vertices[i].TexC = grid.Vertices[i].TexC;
	}

	std::vector<std::uint32_t> indices = grid.Indices32;

	UINT vbByteSize = mWaves->VertexCount()*sizeof(Vertex);
	UINT ibByteSize = (UINT)indices.size()*sizeof(std::uint32_t);

	auto geo = std::make_unique<MeshGeometry>();
	geo->Name = "waterGeo";

	ThrowIfFailed(D3DCreateBlob(vbByteSize, &geo->VertexBufferCPU));
	CopyMemory(geo->VertexBufferCPU->GetBufferPointer(), vertices.data(), vbByteSize);

	ThrowIfFailed(D3DCreateBlob(ibByteSize, &geo->IndexBufferCPU));
	CopyMemory(geo->IndexBufferCPU->GetBufferPointer(), indices.data(), ibByteSize);

	geo->VertexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), vertices.data(), vbByteSize, geo->VertexBufferUploader);

	geo->IndexBufferGPU = d3dUtil::CreateDefaultBuffer(md3dDevice.Get(),
		mCommandList.Get(), indices.data(), ibByteSize, geo->IndexBufferUploader);

	geo->VertexByteStride = sizeof(Vertex);
	geo->VertexBufferByteSize = vbByteSize;
	geo->IndexFormat = DXGI_FORMAT_R32_UINT;
	geo->IndexBufferByteSize = ibByteSize;

	SubmeshGeometry submesh;
	submesh.IndexCount = (UINT)indices.size();
	submesh.StartIndexLocation = 0;
	submesh.BaseVertexLocation = 0;

	geo->DrawArgs["grid"] = submesh;

	mGeometries["waterGeo"] = std::move(geo);
}
Exemplo n.º 12
0
Sky::Sky(ID3D11Device* device, const std::wstring& cubemapFilename, float skySphereRadius)
{
	HR(D3DX11CreateShaderResourceViewFromFileW(device, cubemapFilename.c_str(), 0, 0, &mCubeMapSRV, 0));

	GeometryGenerator::MeshData sphere;
	GeometryGenerator geoGen;
	geoGen.CreateSphere(skySphereRadius, 30, 30, sphere);

	std::vector<XMFLOAT3> vertices(sphere.Vertices.size());

	for(size_t i = 0; i < sphere.Vertices.size(); ++i)
	{
		vertices[i] = sphere.Vertices[i].Position;
	}

    D3D11_BUFFER_DESC vbd;
    vbd.Usage = D3D11_USAGE_IMMUTABLE;
	vbd.ByteWidth = sizeof(XMFLOAT3) * vertices.size();
    vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vbd.CPUAccessFlags = 0;
    vbd.MiscFlags = 0;
	vbd.StructureByteStride = 0;

    D3D11_SUBRESOURCE_DATA vinitData;
    vinitData.pSysMem = &vertices[0];

    HR(device->CreateBuffer(&vbd, &vinitData, &mVB));
	

	mIndexCount = sphere.Indices.size();

	D3D11_BUFFER_DESC ibd;
    ibd.Usage = D3D11_USAGE_IMMUTABLE;
    ibd.ByteWidth = sizeof(USHORT) * mIndexCount;
    ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
	ibd.StructureByteStride = 0;
    ibd.MiscFlags = 0;

	std::vector<USHORT> indices16;
	indices16.assign(sphere.Indices.begin(), sphere.Indices.end());

    D3D11_SUBRESOURCE_DATA iinitData;
    iinitData.pSysMem = &indices16[0];

    HR(device->CreateBuffer(&ibd, &iinitData, &mIB));
}
Exemplo n.º 13
0
Terrain::Terrain(const std::string& filename)
:ModelObject()
{
	//Update(10);

	std::unique_ptr<Highmap> map = std::make_unique<Highmap>();

	map->Load(filename);

	GeometryGenerator gen;

	gen.CreateFromHightMap(*m_Data, map.get());
	//GeometryGenerator gen;

	//gen.ComputeNormals(*m_Data);

}
Exemplo n.º 14
0
void DuckHuntMain::BuildScreenQuadGeometryBuffers()
{
	GeometryGenerator::MeshData quad;

	GeometryGenerator geoGen;
	geoGen.CreateFullscreenQuad(quad);

	//
	// Extract the vertex elements we are interested in and pack the
	// vertices of all the meshes into one vertex buffer.
	//

	std::vector<Vertex::Basic32> vertices(quad.Vertices.size());

	for (UINT i = 0; i < quad.Vertices.size(); ++i)
	{
		vertices[i].Pos = quad.Vertices[i].Position;
		vertices[i].Normal = quad.Vertices[i].Normal;
		vertices[i].Tex = quad.Vertices[i].TexC;
	}

	D3D11_BUFFER_DESC vbd;
	vbd.Usage = D3D11_USAGE_IMMUTABLE;
	vbd.ByteWidth = sizeof(Vertex::Basic32) * quad.Vertices.size();
	vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
	vbd.CPUAccessFlags = 0;
	vbd.MiscFlags = 0;
	D3D11_SUBRESOURCE_DATA vinitData;
	vinitData.pSysMem = &vertices[0];
	HR(md3dDevice->CreateBuffer(&vbd, &vinitData, &mScreenQuadVB));

	//
	// Pack the indices of all the meshes into one index buffer.
	//

	D3D11_BUFFER_DESC ibd;
	ibd.Usage = D3D11_USAGE_IMMUTABLE;
	ibd.ByteWidth = sizeof(UINT) * quad.Indices.size();
	ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
	ibd.CPUAccessFlags = 0;
	ibd.MiscFlags = 0;
	D3D11_SUBRESOURCE_DATA iinitData;
	iinitData.pSysMem = &quad.Indices[0];
	HR(md3dDevice->CreateBuffer(&ibd, &iinitData, &mScreenQuadIB));
}
Exemplo n.º 15
0
void LightDemo::BuildLandBuffers()
{
   	GeometryGenerator::MeshData land;
	GeometryGenerator geoGen;

	geoGen.CreateGrid(160.0f, 160.0f, 50, 50, land);

	m_landIndexCount = land.indices.size();

	// Extract the vertex elements we are interested and apply the height function to
	// each vertex.  In addition, color the vertices based on their height so we have
	// sandy looking beaches, grassy low hills, and snow mountain peaks.

	std::vector<Vertex> vertices(land.vertices.size());
	for(size_t i = 0; i < land.vertices.size(); ++i)
	{
		XMFLOAT3 p = land.vertices[i].position;

		p.y = GetHeight(p.x, p.z);

		vertices[i].pos   = p;
        vertices[i].normal = GetHillNormal(p.x, p.z);
	}

    D3D11_BUFFER_DESC vbd;
    vbd.Usage = D3D11_USAGE_IMMUTABLE;
	vbd.ByteWidth = sizeof(Vertex) * land.vertices.size();
    vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vbd.CPUAccessFlags = 0;
    vbd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA vinitData;
    vinitData.pSysMem = &vertices[0];
    HR(m_dxDevice->CreateBuffer(&vbd, &vinitData, m_landVB.GetAddressOf()));

	// Pack the indices of all the meshes into one index buffer.
	D3D11_BUFFER_DESC ibd;
    ibd.Usage = D3D11_USAGE_IMMUTABLE;
	ibd.ByteWidth = sizeof(uint32) * m_landIndexCount;
    ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
    ibd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA iinitData;
	iinitData.pSysMem = &land.indices[0];
    HR(m_dxDevice->CreateBuffer(&ibd, &iinitData, m_landIB.GetAddressOf()));
}
Exemplo n.º 16
0
void App::buildGeometryBuffers( void )
{
    GeometryGenerator::MeshData grid;
    GeometryGenerator geoGen;

    geoGen.createGrid( 160.f, 160.f, 50, 50, grid );
    mGridIndexCount = static_cast<UINT>( grid.indices.size() );

    std::vector<Vertex> vertices( grid.vertices.size() );
    for ( size_t i = 0; i < grid.vertices.size(); ++i ) {
        DirectX::XMFLOAT3 p = grid.vertices[i].position;

        p.y = getHeight( p.x, p.z );

        vertices[i].Pos = p;

        vertices[i].Color = DirectX::XMFLOAT4( 0.f, 0.5f, 0.f, 1.f );
    }

    D3D11_BUFFER_DESC bd;
    ZeroMemory( &bd, sizeof( bd ) );
    bd.Usage = D3D11_USAGE_IMMUTABLE;
    bd.ByteWidth = sizeof( Vertex ) * grid.vertices.size();
    bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    bd.CPUAccessFlags = 0;
    bd.MiscFlags = 0;
    bd.StructureByteStride = 0;

    D3D11_SUBRESOURCE_DATA initData;
    ZeroMemory( &initData, sizeof( initData ) );
    initData.pSysMem = &vertices[0];
    HR( mD3DDevice->CreateBuffer( &bd, &initData, &mVB ) );

    D3D11_BUFFER_DESC ibd;
    ZeroMemory( &ibd, sizeof( ibd ) );
    ibd.Usage = D3D11_USAGE_IMMUTABLE;
    ibd.ByteWidth = sizeof( UINT ) * mGridIndexCount; //!
    ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
    ibd.MiscFlags = 0;
    ibd.StructureByteStride = 0;
    D3D11_SUBRESOURCE_DATA iinitData;
    iinitData.pSysMem = &grid.indices[0];
    HR( mD3DDevice->CreateBuffer( &ibd, &iinitData, &mIB ) );
}
Exemplo n.º 17
0
void Shadow::CreateShadow(XMFLOAT3 playerPos, ID3D11DeviceContext* dc,ID3D11Device* dv)
{
	XMMATRIX view = mCam.View();
	XMMATRIX proj = mCam.Proj();
	XMMATRIX viewProj = mCam.ViewProj();
	GeometryGenerator::MeshData sphere;
	GeometryGenerator geoMake;
	
	world = XMLoadFloat4x4(&mSphereWorld);
	worldInvTranspose = MathHelper::InverseTranspose(world);
	worldViewProj = world*view*proj;
	geoMake.CreateSphere(0.5f, 20, 20, sphere);

	Effects::BasicFX->SetWorld(world);
	Effects::BasicFX->SetWorldInvTranspose(worldInvTranspose);
	Effects::BasicFX->SetWorldViewProj(worldViewProj);
	Effects::BasicFX->SetTexTransform(XMMatrixIdentity());
	mSphereIndexCount = sphere.Indices.size();
	mSphereIndexOffset = 0;
//	mSphereVertexCount = sphere.Vertices.size();
	UINT totalVertexCount = sphere.Vertices.size();
	UINT totalIndexCount = sphere.Indices.size();
	std::vector<Vertex::PosNormalTexTan> vertices(totalVertexCount);
	UINT k = 0;
	for (size_t i = 0; i < sphere.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos = sphere.Vertices[i].Position;
		vertices[k].Normal = sphere.Vertices[i].Normal;
		vertices[k].Tex = sphere.Vertices[i].TexC;
		//vertices[k].TangentU = sphere.Vertices[i].TangentU;
	}
	D3D11_BUFFER_DESC vbd;
	vbd.Usage = D3D11_USAGE_IMMUTABLE;
	vbd.ByteWidth = sizeof(Vertex::PosNormalTexTan) * totalVertexCount;
	vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
	vbd.CPUAccessFlags = 0;
	vbd.MiscFlags = 0;
	D3D11_SUBRESOURCE_DATA vinitData;
	vinitData.pSysMem = &vertices[0];
	HR(dv->CreateBuffer(&vbd, &vinitData, &mShapesVB));
	dc->DrawIndexed(mSphereIndexCount, 0, 0);
}
Exemplo n.º 18
0
GSphere::GSphere() : GObject()
{ 
	GeometryGenerator geoGen;
	GeometryGenerator::MeshData sphere;
	geoGen.CreateSphere(0.5f, 20, 20, sphere);

	mVertexCount = sphere.Vertices.size();
	mIndexCount = sphere.Indices.size();

	mVertices.resize(mVertexCount);
	for (size_t i = 0; i < mVertexCount; ++i)
	{
		mVertices[i].Pos = sphere.Vertices[i].Position;
		mVertices[i].Normal = sphere.Vertices[i].Normal;
		mVertices[i].Tex = sphere.Vertices[i].TexC;
	}

	mIndices.resize(mIndexCount);
	mIndices.insert(mIndices.begin(), sphere.Indices.begin(), sphere.Indices.end());
}
Exemplo n.º 19
0
bool cCylinder::Init()
{
	GeometryGenerator::MeshData grid;
	GeometryGenerator geoGen;

	geoGen.CreateCylinder(10.0f, 5.0f, 10.0f, 6, 6, grid);

	m_GridIndexCount = static_cast<UINT>(grid.Indices.size());

	std::vector<Vertex::Simple> vertices(grid.Vertices.size());
	for (UINT i = 0; i < grid.Vertices.size(); ++i)
	{
		vertices[i].Pos		= grid.Vertices[i].Position;
		vertices[i].Color	= (const float*)&Colors::Black;
	}

	m_VB = MyDirectUtil::CreateVertexBuffer(&vertices[0], sizeof(Vertex::Simple) * static_cast<UINT>(vertices.size()), g_pD3DDevice);
	m_IB = MyDirectUtil::CreateIndexBuffer(&grid.Indices[0], sizeof(UINT) * m_GridIndexCount, g_pD3DDevice);

	return false;
}
Exemplo n.º 20
0
void TreeBillboardApp::BuildCrateBuffers()
{
    GeometryGenerator::MeshData box;

	GeometryGenerator geoGen;
	geoGen.CreateBox(1.0f, 1.0f, 1.0f, box);

	// Extract the vertex elements we are interested in and pack the
	// vertices of all the meshes into one vertex buffer.
	std::vector<Vertex::Basic32> vertices(box.vertices.size());

	for(UINT i = 0; i < box.vertices.size(); ++i)
	{
		vertices[i].Pos    = box.vertices[i].position;
		vertices[i].Normal = box.vertices[i].normal;
		vertices[i].Tex    = box.vertices[i].texC;
	}

    D3D11_BUFFER_DESC vbd;
    vbd.Usage = D3D11_USAGE_IMMUTABLE;
    vbd.ByteWidth = sizeof(Vertex::Basic32) * box.vertices.size();
    vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vbd.CPUAccessFlags = 0;
    vbd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA vinitData;
    vinitData.pSysMem = &vertices[0];
    HR(m_dxDevice->CreateBuffer(&vbd, &vinitData, m_boxVB.GetAddressOf()));

	// Pack the indices of all the meshes into one index buffer.
	D3D11_BUFFER_DESC ibd;
    ibd.Usage = D3D11_USAGE_IMMUTABLE;
	ibd.ByteWidth = sizeof(UINT) * box.indices.size();
    ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
    ibd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA iinitData;
    iinitData.pSysMem = &box.indices[0];
    HR(m_dxDevice->CreateBuffer(&ibd, &iinitData, m_boxIB.GetAddressOf()));
}
Exemplo n.º 21
0
void TexWaves::BuildLandGeometry()
{
    GeometryGenerator geoGen;
    GeometryGenerator::MeshData grid = geoGen.CreateGrid(160.0f, 160.0f, 50, 50);

    std::vector<FrameResource::Vertex> vertices(grid.Vertices.size());
    for (size_t i = 0; i < grid.Vertices.size(); i++)
    {
        auto& p = grid.Vertices[i].Position;
        vertices[i].Pos = p;
        vertices[i].Pos.y = GetHillsHeight(p.x, p.z);
        vertices[i].Normal = GetHillsNormal(p.z, p.z);
        vertices[i].TexC = grid.Vertices[i].TexCoord;
    }
    const UINT vbByteSize = (UINT)vertices.size() * sizeof(FrameResource::Vertex);
    std::vector<std::uint16_t> indices = grid.GetIndices16();
    const UINT ibByteSize = (UINT)indices.size() * sizeof(uint16_t);

    auto geo = std::make_unique<MeshGeometry>();
    geo->Name = "landGeo";

    geo->VertexBufferGPU = D3DUtil::CreateDefaultBuffer(_device.Get(), _commandList.Get(), vertices.data(), vbByteSize, geo->VertexBufferUploader);
    geo->IndexBufferGPU = D3DUtil::CreateDefaultBuffer(_device.Get(), _commandList.Get(), indices.data(), ibByteSize, geo->IndexBufferUploader);

    geo->VertexByteStride = sizeof(FrameResource::Vertex);
    geo->VertexBufferByteSize = vbByteSize;
    geo->IndexFormat = DXGI_FORMAT_R16_UINT;
    geo->IndexBufferByteSize = ibByteSize;

    SubmeshGeometry submesh;
    submesh.IndexCount = (UINT)indices.size();
    submesh.StartIndexLocation = 0;
    submesh.BaseVertexLocation = 0;

    geo->DrawArgs["grid"] = submesh;
    _geometries["landGeo"] = std::move(geo);
}
Exemplo n.º 22
0
void TexWaves::BuildBoxGeometry()
{
    GeometryGenerator geoGen;
    GeometryGenerator::MeshData box = geoGen.CreateBox(8.0f, 8.0f, 8.0f, 3);

    SubmeshGeometry boxSubmesh;
    boxSubmesh.IndexCount = (UINT)box.Indices32.size();
    boxSubmesh.StartIndexLocation = 0;
    boxSubmesh.BaseVertexLocation = 0;

    std::vector<FrameResource::Vertex> vertices(box.Vertices.size());

    for (size_t i = 0; i < box.Vertices.size(); i++)
    {
        vertices[i].Pos = box.Vertices[i].Position;
        vertices[i].Normal = box.Vertices[i].Normal;
        vertices[i].TexC = box.Vertices[i].TexCoord;
    }
    std::vector<uint16_t> indices = box.GetIndices16();
    const UINT vbByteSize = sizeof(FrameResource::Vertex) * (UINT)vertices.size();
    const UINT ibByteSize = sizeof(uint16_t) * (UINT)indices.size();

    auto geo = std::make_unique<MeshGeometry>();
    geo->Name = "boxGeo";

    geo->VertexBufferGPU = D3DUtil::CreateDefaultBuffer(_device.Get(), _commandList.Get(), vertices.data(), vbByteSize, geo->VertexBufferUploader);
    geo->IndexBufferGPU = D3DUtil::CreateDefaultBuffer(_device.Get(), _commandList.Get(), indices.data(), ibByteSize, geo->IndexBufferUploader);

    geo->VertexByteStride = sizeof(FrameResource::Vertex);
    geo->VertexBufferByteSize = vbByteSize;
    geo->IndexFormat = DXGI_FORMAT_R16_UINT;
    geo->IndexBufferByteSize = ibByteSize;

    geo->DrawArgs["box"] = boxSubmesh;
    _geometries[geo->Name] = move(geo);
}
Exemplo n.º 23
0
void ObjectsRenderer::InitBase()
{
	// Init base objects
	BasicObjectData* objectData = new BasicObjectData();
	objectData->UseIndex = true;
	objectData->UseEx = true;

	// Init shapes
	GeometryGenerator::MeshData box;
	GeometryGenerator::MeshData grid;
	GeometryGenerator::MeshData cylinder;

	GeometryGenerator geoGen;
	geoGen.CreateBox(1.0f, 1.0f, 1.0f, box);
	geoGen.CreateGrid(20.0f, 30.0f, 60, 40, grid);
	geoGen.CreateCylinder(0.5f, 0.3f, 3.0f, 20, 20, cylinder);

	// Cache the vertex offsets to each object in the concatenated vertex buffer.
	int boxVertexOffset = 0;
	int gridVertexOffset = box.Vertices.size();
	int cylinderVertexOffset = gridVertexOffset + grid.Vertices.size();

	// Cache the index count of each object.
	int boxIndexCount = box.Indices.size();
	int gridIndexCount = grid.Indices.size();
	int cylinderIndexCount = cylinder.Indices.size();

	// Cache the starting index for each object in the concatenated index buffer.
	int boxIndexOffset = 0;
	int gridIndexOffset = boxIndexCount;
	int cylinderIndexOffset = gridIndexOffset + gridIndexCount;

	UINT totalVertexCount =
		box.Vertices.size() +
		grid.Vertices.size() +
		cylinder.Vertices.size();

	UINT totalIndexCount =
		boxIndexCount +
		gridIndexCount +
		cylinderIndexCount;

	// Extract the vertex elements we are interested in and pack the
	// vertices of all the meshes into one vertex buffer.

	auto& vertices = objectData->VertexDataEx;
	vertices.resize(totalVertexCount);

	UINT k = 0;
	for (size_t i = 0; i < box.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos = box.Vertices[i].Position;
		vertices[k].Normal = box.Vertices[i].Normal;
		vertices[k].Tex = box.Vertices[i].TexC;
		vertices[k].TangentU = box.Vertices[i].TangentU;
	}

	for (size_t i = 0; i < grid.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos = grid.Vertices[i].Position;
		vertices[k].Normal = grid.Vertices[i].Normal;
		vertices[k].Tex = grid.Vertices[i].TexC;
		vertices[k].TangentU = grid.Vertices[i].TangentU;
	}

	for (size_t i = 0; i < cylinder.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos = cylinder.Vertices[i].Position;
		vertices[k].Normal = cylinder.Vertices[i].Normal;
		vertices[k].Tex = cylinder.Vertices[i].TexC;
		vertices[k].TangentU = cylinder.Vertices[i].TangentU;
	}

	// Pack the indices of all the meshes into one index buffer.
	auto& indices = objectData->IndexData;
	indices.insert(indices.end(), box.Indices.begin(), box.Indices.end());
	indices.insert(indices.end(), grid.Indices.begin(), grid.Indices.end());
	indices.insert(indices.end(), cylinder.Indices.begin(), cylinder.Indices.end());

	// Set unit data
	XMFLOAT4X4 gridWorld, boxWorld, cylWorld[10];

	XMMATRIX I = XMMatrixIdentity();
	XMFLOAT4X4 One;
	XMStoreFloat4x4(&One, I);
	XMStoreFloat4x4(&gridWorld, I);

	XMMATRIX boxScale = XMMatrixScaling(3.0f, 1.0f, 3.0f);
	XMMATRIX boxOffset = XMMatrixTranslation(0.0f, 0.5f, 0.0f);
	XMStoreFloat4x4(&boxWorld, XMMatrixMultiply(boxScale, boxOffset));

	for (int i = 0; i < 5; ++i)
	{
		XMStoreFloat4x4(&cylWorld[i * 2 + 0], XMMatrixTranslation(-5.0f, 1.5f, -10.0f + i*5.0f));
		XMStoreFloat4x4(&cylWorld[i * 2 + 1], XMMatrixTranslation(+5.0f, 1.5f, -10.0f + i*5.0f));
	}

	Material gridMat, cylinderMat, boxMat;

	gridMat.Ambient = XMFLOAT4(0.8f, 0.8f, 0.8f, 1.0f);
	gridMat.Diffuse = XMFLOAT4(0.8f, 0.8f, 0.8f, 1.0f);
	gridMat.Specular = XMFLOAT4(0.8f, 0.8f, 0.8f, 16.0f);
	gridMat.Reflect = XMFLOAT4(0.0f, 0.0f, 0.0f, 1.0f);

	cylinderMat.Ambient = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
	cylinderMat.Diffuse = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
	cylinderMat.Specular = XMFLOAT4(0.8f, 0.8f, 0.8f, 16.0f);
	cylinderMat.Reflect = XMFLOAT4(0.0f, 0.0f, 0.0f, 1.0f);

	boxMat.Ambient = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
	boxMat.Diffuse = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
	boxMat.Specular = XMFLOAT4(0.8f, 0.8f, 0.8f, 16.0f);
	boxMat.Reflect = XMFLOAT4(0.0f, 0.0f, 0.0f, 1.0f);

	objectData->Units.resize(3);
	// box
	auto& unit0 = objectData->Units[0];
	unit0.VCount = box.Vertices.size();
	unit0.Base = boxVertexOffset;
	unit0.Count = boxIndexCount;
	unit0.Start = boxIndexOffset;
	unit0.Worlds.push_back(boxWorld);
	unit0.TextureFileNames.push_back(L"Media\\Textures\\stone.dds");
	unit0.NorTextureFileNames.push_back(L"Media\\Textures\\stones_nmap.dds");
	unit0.TextureTransform.push_back(One);
	unit0.Material.push_back(boxMat);
	
	// grid
	auto& unit1 = objectData->Units[1];
	unit1.VCount = grid.Vertices.size();
	unit1.Base = gridVertexOffset;
	unit1.Count = gridIndexCount;
	unit1.Start = gridIndexOffset;
	unit1.Worlds.push_back(gridWorld);
	unit1.TextureFileNames.push_back(L"Media\\Textures\\floor.dds");
	unit1.NorTextureFileNames.push_back(L"Media\\Textures\\floor_nmap.dds");
	XMFLOAT4X4 texTransform;
	XMStoreFloat4x4(&texTransform, XMMatrixScaling(6.0f, 8.0f, 1.0f));
	unit1.TextureTransform.push_back(texTransform);
	unit1.Material.push_back(gridMat);

	// cylinder
	auto& unit2 = objectData->Units[2];
	unit2.VCount = cylinder.Vertices.size();
	unit2.Base = cylinderVertexOffset;
	unit2.Count = cylinderIndexCount;
	unit2.Start = cylinderIndexOffset;
	unit2.Worlds.assign(cylWorld, cylWorld + 10);
	unit2.TextureFileNames.push_back(L"Media\\Textures\\bricks.dds");
	unit2.TextureStepRate = 10;
	unit2.NorTextureFileNames.push_back(L"Media\\Textures\\bricks_nmap.dds");
	unit2.NorTextureStepRate = 10;
	unit2.TextureTransform.push_back(One);
	unit2.TextureTransformStepRate = 10;
	unit2.Material.push_back(cylinderMat);
	unit2.MaterialStepRate = 10;

	BasicFeatureConfigure objectFeature = { 0 };
	objectFeature.LightCount = 3;
	objectFeature.TextureEnable = true;
	objectFeature.NormalEnable = true;
	/*objectFeature.TessEnable = true;
	objectFeature.TessDesc.HeightScale = 0.07f;
	objectFeature.TessDesc.MaxTessDistance = 1.0f;
	objectFeature.TessDesc.MaxTessFactor = 5.0f;
	objectFeature.TessDesc.MinTessDistance = 25.0f;
	objectFeature.TessDesc.MinTessFactor = 1.0f;*/

	m_base->Initialize(objectData, objectFeature);
}
Exemplo n.º 24
0
void ObjectsRenderer::InitSphere()
{
	// Init spheres
	BasicObjectData* objectData = new BasicObjectData();
	objectData->UseIndex = true;
	objectData->UseEx = false;

	GeometryGenerator::MeshData sphere;
	GeometryGenerator geoGen;
	geoGen.CreateSphere(0.5f, 20, 20, sphere);

	int sphereIndexCount = sphere.Indices.size();

	// Extract the vertex elements we are interested in and pack the
	// vertices of all the meshes into one vertex buffer.
	auto& vertices = objectData->VertexData;
	vertices.resize(sphere.Vertices.size());
	for (size_t i = 0; i < sphere.Vertices.size(); ++i)
	{
		vertices[i].Pos = sphere.Vertices[i].Position;
		vertices[i].Normal = sphere.Vertices[i].Normal;
		vertices[i].Tex = sphere.Vertices[i].TexC;
	}

	// Pack the indices of all the meshes into one index buffer.
	auto& indices = objectData->IndexData;
	indices.assign(sphere.Indices.begin(), sphere.Indices.end());

	// Set unit data
	XMFLOAT4X4 sphereWorld[10];
	for (int i = 0; i < 5; ++i)
	{
		XMStoreFloat4x4(&sphereWorld[i * 2 + 0], XMMatrixTranslation(-5.0f, 3.5f, -10.0f + i*5.0f));
		XMStoreFloat4x4(&sphereWorld[i * 2 + 1], XMMatrixTranslation(+5.0f, 3.5f, -10.0f + i*5.0f));
	}

	Material sphereMat;
	sphereMat.Ambient = XMFLOAT4(0.2f, 0.3f, 0.4f, 1.0f);
	sphereMat.Diffuse = XMFLOAT4(0.2f, 0.3f, 0.4f, 1.0f);
	sphereMat.Specular = XMFLOAT4(0.9f, 0.9f, 0.9f, 16.0f);
	sphereMat.Reflect = XMFLOAT4(0.4f, 0.4f, 0.4f, 1.0f);

	objectData->Units.resize(1);
	// sphere
	XMFLOAT4X4 One;
	XMStoreFloat4x4(&One, XMMatrixIdentity());
	auto& unit = objectData->Units[0];
	unit.VCount = vertices.size();
	unit.Base = 0;
	unit.Count = sphereIndexCount;
	unit.Start = 0;
	unit.Worlds.assign(sphereWorld, sphereWorld + 10);
	unit.Material.push_back(sphereMat);
	unit.MaterialStepRate = 10;
	unit.TextureFileNames.push_back(L"Media\\Textures\\stone.dds");
	unit.TextureStepRate = 10;
	unit.TextureTransform.push_back(One);
	unit.TextureTransformStepRate = 10;
	
	BasicFeatureConfigure objectFeature = { 0 };
	objectFeature.LightCount = 3;
	objectFeature.TextureEnable = true;
	objectFeature.ReflectEnable = true;
	objectFeature.ReflectFileName = L"Media\\Textures\\grasscube1024.dds";

	m_sphere->Initialize(objectData, objectFeature);
}
Exemplo n.º 25
0
void WavesApp::BuildLandGeometryBuffers()
{
	GeometryGenerator::MeshData grid;

	GeometryGenerator geoGen;
	geoGen.CreateGrid(160.f, 160.f, 50, 50, grid);
	m_uLandGridIndexCount = grid.Indices.size();

	//
	// Extract the vertex elements we are interested and apply the height function
	// to each vertex. In addition,color the vertices based on their so we have
	// sandy looking beaches,grassy low hills,and snow moutain peaks
	//
	std::vector<Vertex> vertices(grid.Vertices.size());


	for (size_t i = 0; i < grid.Vertices.size(); ++i)
	{
		XMFLOAT3 p = grid.Vertices[i].Position;
		p.y = GetHeight(p.x, p.z);
		vertices[i].Pos = p;

		if (p.y < -10.f)
		{
			//Sandy beach color
			vertices[i].Color = XMFLOAT4(1.0f,0.96f,0.62f,1.0f);
		}
		else if (p.y < 5.0f)
		{
			// Light yellow-green.
			vertices[i].Color = XMFLOAT4(0.48f, 0.77f, 0.46f, 1.0f);
		}
		else if (p.y < 12.0f)
		{
			// Dark yellow-green.
			vertices[i].Color = XMFLOAT4(0.1f, 0.48f, 0.19f, 1.0f);
		}
		else if (p.y < 20.0f)
		{
			// Dark brown.
			vertices[i].Color = XMFLOAT4(0.45f, 0.39f, 0.34f, 1.0f);
		}
		else
		{
			// White snow.
			vertices[i].Color = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
		}


	}

	{
		D3D11_BUFFER_DESC vbd;
		vbd.Usage = D3D11_USAGE_IMMUTABLE;//jingz todo 为什么CPU要访问和修改??
		vbd.ByteWidth = sizeof(Vertex) * vertices.size();
		vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
		vbd.CPUAccessFlags = 0;
		vbd.MiscFlags = 0;
		vbd.StructureByteStride = 0;
		D3D11_SUBRESOURCE_DATA initDate;
		initDate.pSysMem = &vertices[0];
		HR(m_pD3dDevice->CreateBuffer(&vbd, &initDate,&m_pLandVB));
	}

	{
		D3D11_BUFFER_DESC ibd;
		ibd.Usage = D3D11_USAGE_IMMUTABLE;//jingz todo 为什么CPU要访问和修改??
		ibd.ByteWidth = sizeof(UINT) * m_uLandGridIndexCount;
		ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
		ibd.CPUAccessFlags = 0;
		ibd.MiscFlags = 0;
		ibd.StructureByteStride = 0;
		D3D11_SUBRESOURCE_DATA initDate;
		initDate.pSysMem = &grid.Indices[0];
		HR(m_pD3dDevice->CreateBuffer(&ibd, &initDate, &m_pLandIB));
	}

}
Exemplo n.º 26
0
void D3DPBRApp::CreateLUT()
{
	D3D11_TEXTURE2D_DESC texDesc;
	texDesc.Width = 512;
	texDesc.Height = 512;
	texDesc.MipLevels = 0;
	texDesc.ArraySize = 1;
	texDesc.SampleDesc.Count = 1;
	texDesc.SampleDesc.Quality = 0;
	texDesc.Format = DXGI_FORMAT_R16G16_FLOAT;
	texDesc.Usage = D3D11_USAGE_DEFAULT;
	texDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
	texDesc.CPUAccessFlags = 0;
	texDesc.MiscFlags = 0;

	ID3D11Texture2D* LUTTex = 0;
	HR(md3dDevice->CreateTexture2D(&texDesc, 0, &LUTTex));

	//
	// Create a render target view to each cube map face 
	// (i.e., each element in the texture array).
	// 

	D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
	rtvDesc.Format = texDesc.Format;
	rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
	rtvDesc.Texture2D.MipSlice = 0;



	HR(md3dDevice->CreateRenderTargetView(LUTTex, &rtvDesc, &mLUTRTV));
	

	//
	// Create a shader resource view to the cube map.
	//

	D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
	srvDesc.Format = texDesc.Format;
	srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
	srvDesc.Texture2D.MipLevels = -1;
	srvDesc.Texture2D.MostDetailedMip = 0;


	HR(md3dDevice->CreateShaderResourceView(LUTTex, &srvDesc, &mLUTSRV));





	D3D11_TEXTURE2D_DESC depthTexDesc;
	depthTexDesc.Width = 512;
	depthTexDesc.Height = 512;
	depthTexDesc.MipLevels = 1;
	depthTexDesc.ArraySize = 1;
	depthTexDesc.SampleDesc.Count = 1;
	depthTexDesc.SampleDesc.Quality = 0;
	depthTexDesc.Format = DXGI_FORMAT_D32_FLOAT;
	depthTexDesc.Usage = D3D11_USAGE_DEFAULT;
	depthTexDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
	depthTexDesc.CPUAccessFlags = 0;
	depthTexDesc.MiscFlags = 0;

	ID3D11Texture2D* depthTex = 0;
	HR(md3dDevice->CreateTexture2D(&depthTexDesc, 0, &depthTex));

	D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
	dsvDesc.Format = depthTexDesc.Format;
	dsvDesc.Flags  = 0;
	dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
	dsvDesc.Texture2D.MipSlice = 0;
	HR(md3dDevice->CreateDepthStencilView(depthTex, &dsvDesc, &mLUTDSV));

	ReleaseCOM(depthTex);

	//
	// Viewport for drawing into cubemap.
	// 

	mLUTViewport.TopLeftX = 0.0f;
	mLUTViewport.TopLeftY = 0.0f;
	mLUTViewport.Width    = (float)512;
	mLUTViewport.Height   = (float)512;
	mLUTViewport.MinDepth = 0.0f;
	mLUTViewport.MaxDepth = 1.0f;



	GeometryGenerator::MeshData quad;
	GeometryGenerator geoGen;
	geoGen.CreateFullscreenQuad(quad);
	mQuadIndexNum = quad.Indices.size();
	
	std::vector<Vertex::Basic32> vertices(quad.Vertices.size());
	for (int i = 0; i < vertices.size(); i++)
	{
		vertices[i].Normal = quad.Vertices[i].Normal;
		vertices[i].Pos = quad.Vertices[i].Position;
		vertices[i].Tangent = quad.Vertices[i].TangentU;
		vertices[i].Tex = quad.Vertices[i].TexC;
	}

	D3D11_BUFFER_DESC dbd;
	dbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
	dbd.ByteWidth = sizeof(Vertex::Basic32) * vertices.size();
	dbd.CPUAccessFlags = 0;
	dbd.StructureByteStride = 0;
	dbd.MiscFlags = 0;
	dbd.Usage = D3D11_USAGE_DEFAULT;
	D3D11_SUBRESOURCE_DATA vinitdata;
	vinitdata.pSysMem = &vertices[0];
	
	HR(md3dDevice->CreateBuffer(&dbd, &vinitdata, &mQuadVB));

	std::vector<UINT> indeces(quad.Indices.begin(), quad.Indices.end());

	dbd.BindFlags = D3D11_BIND_INDEX_BUFFER;
	dbd.ByteWidth = sizeof(UINT) * mQuadIndexNum;
	vinitdata.pSysMem = &indeces[0];

	
	HR(md3dDevice->CreateBuffer(&dbd, &vinitdata, &mQuadIB));

	md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	md3dImmediateContext->ClearRenderTargetView(mLUTRTV, reinterpret_cast<const float*>(&Colors::Black));
	md3dImmediateContext->ClearDepthStencilView(mLUTDSV, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);
	md3dImmediateContext->OMSetRenderTargets(1, &mLUTRTV, mLUTDSV);

	md3dImmediateContext->RSSetViewports(1, &mLUTViewport);
	md3dImmediateContext->IASetInputLayout(InputLayouts::Basic32);


	ID3DX11EffectTechnique* activeMeshTech = Effects::CommonPassFX->LUTTech;

	UINT stride = sizeof(Vertex::Basic32);
	UINT offset = 0;
	D3DX11_TECHNIQUE_DESC techDesc;
	activeMeshTech->GetDesc( &techDesc );
	for(UINT p = 0; p < techDesc.Passes; ++p)
	{
		// Draw the Mesh.


		md3dImmediateContext->IASetVertexBuffers(0, 1, &mQuadVB, &stride, &offset);
		md3dImmediateContext->IASetIndexBuffer(mQuadIB, DXGI_FORMAT_R32_UINT, 0);




		activeMeshTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
		md3dImmediateContext->DrawIndexed(mQuadIndexNum, 0, 0);

		//m_pSky->Draw(md3dImmediateContext, camera);

		// Restore default
		md3dImmediateContext->RSSetState(0);
	}
	
	HR(D3DX11SaveTextureToFile(md3dImmediateContext, LUTTex, D3DX11_IFF_DDS, _T("lut.dds")));
	ReleaseCOM(LUTTex);
}
Exemplo n.º 27
0
void SuperSolarSystemApp::BuildOrbitBuffers( )
{
	GeometryGenerator geoGen;
	GeometryGenerator::MeshData orbitMash;

	geoGen.CreateCircle( 1.0f, 100, orbitMash );

	//
	// 缓存偏移信息和数量信息
	//

	mCVertexOffset[CVT_ORBIT]  = 0;

	mCIndexCount[CVT_ORBIT]	   = orbitMash.Indices.size( );

	mCIndexOffset[CVT_ORBIT]   = 0;

	//
	// 创建顶点缓冲
	//

	UINT totVertexCount =
		orbitMash.Vertices.size( );

	std::vector<Vertex::ColorObjVertex> vertices;
	vertices.resize( totVertexCount );

	XMFLOAT4 white( 1.0f, 1.0f, 1.0f, 1.0f );

	UINT k = 0;
	for ( size_t i = 0; i < orbitMash.Vertices.size( ); i++, k++ )
	{
		vertices[k].Pos    = orbitMash.Vertices[i].Position;
		vertices[k].Color  = white;
	}

	D3D11_BUFFER_DESC vbd;
	vbd.Usage = D3D11_USAGE_IMMUTABLE;
	vbd.ByteWidth = sizeof( Vertex::ColorObjVertex ) * totVertexCount;
	vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
	vbd.CPUAccessFlags = 0;
	vbd.MiscFlags = 0;
	vbd.StructureByteStride = 0;

	D3D11_SUBRESOURCE_DATA vinitData;
	vinitData.pSysMem = &vertices[0];

	HR( mD3dDevice->CreateBuffer( &vbd, &vinitData, &mColorVB ) );

	//
	// 创建索引缓冲
	//

	UINT totIndexCount =
		orbitMash.Indices.size( );

	std::vector<UINT> indices;
	indices.insert( indices.end( ), orbitMash.Indices.begin( ), orbitMash.Indices.end( ) );

	D3D11_BUFFER_DESC ibd;
	ibd.Usage = D3D11_USAGE_IMMUTABLE;
	ibd.ByteWidth = sizeof( UINT ) * totIndexCount;
	ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
	ibd.CPUAccessFlags = 0;
	ibd.MiscFlags = 0;
	ibd.StructureByteStride = 0;
	D3D11_SUBRESOURCE_DATA iinitData;
	iinitData.pSysMem = &indices[0];
	HR( mD3dDevice->CreateBuffer( &ibd, &iinitData, &mColorIB ) );
}
Exemplo n.º 28
0
// @brief 生成天体对象的Buffers
void SuperSolarSystemApp::BuildObjectBuffers( )
{
	GeometryGenerator geoGen;
	GeometryGenerator::MeshData starMash;
	GeometryGenerator::MeshData iceCubeMash;

	geoGen.CreateSphere( 1.0f, 40, 40, starMash );
	geoGen.CreateBox( 1.0f, 1.0f, 1.0f, iceCubeMash );

	//
	// 缓存偏移信息和数量信息, 以及冰立方的各个面的法向量
	//

	mLTVertexOffset[LTVT_STAR]     = 0;
	mLTVertexOffset[LTVT_ICECUBE]  = starMash.Vertices.size( );

	mLTIndexCount[LTVT_STAR]       = starMash.Indices.size( );
	mLTIndexCount[LTVT_ICECUBE]    = iceCubeMash.Indices.size( );

	mLTIndexOffset[LTVT_STAR]	   = 0;
	mLTIndexOffset[LTVT_ICECUBE]   = starMash.Indices.size( );

	for ( int i = 0; i < 6; i++ )
	{
		mIceCubeNormals[i] = iceCubeMash.Vertices[i * 4].Normal;
	}

	//
	// 创建顶点缓冲
	//

	UINT totVertexCount =
		starMash.Vertices.size( ) +
		iceCubeMash.Vertices.size( );

	std::vector<Vertex::NormalObjVertex> vertices;
	vertices.resize( totVertexCount );

	UINT k = 0;
	for ( size_t i = 0; i < starMash.Vertices.size( ); i++, k++ )
	{
		vertices[k].Pos    = starMash.Vertices[i].Position;
		vertices[k].Normal = starMash.Vertices[i].Normal;
		vertices[k].Tex    = starMash.Vertices[i].TexC;
	}

	for ( size_t i = 0; i < iceCubeMash.Vertices.size( ); i++, k++ )
	{
		vertices[k].Pos    = iceCubeMash.Vertices[i].Position;
		vertices[k].Normal = iceCubeMash.Vertices[i].Normal;
		vertices[k].Tex    = iceCubeMash.Vertices[i].TexC;
	}

	// 顶点缓冲创建第1步, 填充描述缓冲的 D3D11_BUFFER_DESC
	D3D11_BUFFER_DESC vbd;
	// Usage指定如何使用这个缓冲, 这里指定 D3D11_USAGE_IMMUTABLE, 表明缓冲一旦创建后便不再更改
	vbd.Usage = D3D11_USAGE_IMMUTABLE;
	// 按字节衡量的顶点缓冲大小
	vbd.ByteWidth = sizeof( Vertex::NormalObjVertex ) * totVertexCount;
	// 对于顶点缓冲, 指定 D3D11_BIND_VERTEX_BUFFER
	vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
	// 指定CPU如何访问缓冲, 如果之前Usage指定了D3D11_USAGE_IMMUTABLE, 那就设为0
	vbd.CPUAccessFlags = 0;
	// 在顶点缓冲中指定0
	vbd.MiscFlags = 0;
	// 这个参数只对结构缓冲有效, 其余缓冲设为0
	vbd.StructureByteStride = 0;

	// 顶点缓冲创建第2步, 填充 D3D11_SUBRESOURCE_DATA, 指定顶点数据
	D3D11_SUBRESOURCE_DATA vinitData;
	vinitData.pSysMem = &vertices[0];

	// 顶点缓冲创建第3步, 创建顶点缓冲
	HR( mD3dDevice->CreateBuffer( &vbd, &vinitData, &mLightTexVB ) );

	//
	// 创建索引缓冲
	//

	std::vector<UINT> indices;
	indices.insert( indices.end( ), starMash.Indices.begin( ), starMash.Indices.end( ) );
	indices.insert( indices.end( ), iceCubeMash.Indices.begin( ), iceCubeMash.Indices.end( ) );

	UINT totIndexCount =
		starMash.Indices.size( ) +
		iceCubeMash.Indices.size( );

	D3D11_BUFFER_DESC ibd;
	ibd.Usage = D3D11_USAGE_IMMUTABLE;
	ibd.ByteWidth = sizeof( UINT ) * totIndexCount;
	ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
	ibd.CPUAccessFlags = 0;
	ibd.MiscFlags = 0;
	ibd.StructureByteStride = 0;
	D3D11_SUBRESOURCE_DATA iinitData;
	iinitData.pSysMem = &indices[0];
	HR( mD3dDevice->CreateBuffer( &ibd, &iinitData, &mLightTexIB ) );
}
Exemplo n.º 29
0
void HillsApp::BuildGeometryBuffers()
{
	GeometryGenerator::MeshData grid;
 
	GeometryGenerator geoGen;

	geoGen.CreateGrid(160.0f, 160.0f, 50, 50, grid);

	mGridIndexCount = grid.Indices.size();

	//
	// Extract the vertex elements we are interested and apply the height function to
	// each vertex.  In addition, color the vertices based on their height so we have
	// sandy looking beaches, grassy low hills, and snow mountain peaks.
	//

	std::vector<Vertex> vertices(grid.Vertices.size());
	for(size_t i = 0; i < grid.Vertices.size(); ++i)
	{
		XMFLOAT3 p = grid.Vertices[i].Position;

		p.y = GetHeight(p.x, p.z);

		vertices[i].Pos   = p;
		
		// Color the vertex based on its height.
		if( p.y < -10.0f )
		{
			// Sandy beach color.
			vertices[i].Color = XMFLOAT4(1.0f, 0.96f, 0.62f, 1.0f);
		}
		else if( p.y < 5.0f )
		{
			// Light yellow-green.
			vertices[i].Color = XMFLOAT4(0.48f, 0.77f, 0.46f, 1.0f);
		}
		else if( p.y < 12.0f )
		{
			// Dark yellow-green.
			vertices[i].Color = XMFLOAT4(0.1f, 0.48f, 0.19f, 1.0f);
		}
		else if( p.y < 20.0f )
		{
			// Dark brown.
			vertices[i].Color = XMFLOAT4(0.45f, 0.39f, 0.34f, 1.0f);
		}
		else
		{
			// White snow.
			vertices[i].Color = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
		}
	}

    D3D11_BUFFER_DESC vbd;
    vbd.Usage = D3D11_USAGE_IMMUTABLE;
	vbd.ByteWidth = sizeof(Vertex) * grid.Vertices.size();
    vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vbd.CPUAccessFlags = 0;
    vbd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA vinitData;
    vinitData.pSysMem = &vertices[0];
    HR(md3dDevice->CreateBuffer(&vbd, &vinitData, &mVB));

	//
	// Pack the indices of all the meshes into one index buffer.
	//

	D3D11_BUFFER_DESC ibd;
    ibd.Usage = D3D11_USAGE_IMMUTABLE;
	ibd.ByteWidth = sizeof(UINT) * mGridIndexCount;
    ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
    ibd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA iinitData;
	iinitData.pSysMem = &grid.Indices[0];
    HR(md3dDevice->CreateBuffer(&ibd, &iinitData, &mIB));
}
Exemplo n.º 30
0
void TexColumnApp::BuildShapeGeometryBuffers()
{
	GeometryGenerator::MeshData box;
	GeometryGenerator::MeshData grid;
	GeometryGenerator::MeshData sphere;
	GeometryGenerator::MeshData cylinder;

	GeometryGenerator geoGen;
	geoGen.CreateBox(1.0f, 1.0f, 1.0f, box);
	geoGen.CreateGrid(20.0f, 30.0f, 60, 40, grid);
	geoGen.CreateSphere(0.5f, 20, 20, sphere);
	geoGen.CreateCylinder(0.5f, 0.3f, 3.0f, 20, 20, cylinder);

	// Cache the vertex offsets to each object in the concatenated vertex buffer.
	mBoxVertexOffset      = 0;
	mGridVertexOffset     = box.Vertices.size();
	mSphereVertexOffset   = mGridVertexOffset + grid.Vertices.size();
	mCylinderVertexOffset = mSphereVertexOffset + sphere.Vertices.size();

	// Cache the index count of each object.
	mBoxIndexCount      = box.Indices.size();
	mGridIndexCount     = grid.Indices.size();
	mSphereIndexCount   = sphere.Indices.size();
	mCylinderIndexCount = cylinder.Indices.size();

	// Cache the starting index for each object in the concatenated index buffer.
	mBoxIndexOffset      = 0;
	mGridIndexOffset     = mBoxIndexCount;
	mSphereIndexOffset   = mGridIndexOffset + mGridIndexCount;
	mCylinderIndexOffset = mSphereIndexOffset + mSphereIndexCount;
	
	UINT totalVertexCount = 
		box.Vertices.size() + 
		grid.Vertices.size() + 
		sphere.Vertices.size() +
		cylinder.Vertices.size();

	UINT totalIndexCount = 
		mBoxIndexCount + 
		mGridIndexCount + 
		mSphereIndexCount +
		mCylinderIndexCount;

	//
	// Extract the vertex elements we are interested in and pack the
	// vertices of all the meshes into one vertex buffer.
	//

	std::vector<Vertex::Basic32> vertices(totalVertexCount);

	UINT k = 0;
	for(size_t i = 0; i < box.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos    = box.Vertices[i].Position;
		vertices[k].Normal = box.Vertices[i].Normal;
		vertices[k].Tex    = box.Vertices[i].TexC;
	}

	for(size_t i = 0; i < grid.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos    = grid.Vertices[i].Position;
		vertices[k].Normal = grid.Vertices[i].Normal;
		vertices[k].Tex    = grid.Vertices[i].TexC;
	}

	for(size_t i = 0; i < sphere.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos    = sphere.Vertices[i].Position;
		vertices[k].Normal = sphere.Vertices[i].Normal;
		vertices[k].Tex    = sphere.Vertices[i].TexC;
	}

	for(size_t i = 0; i < cylinder.Vertices.size(); ++i, ++k)
	{
		vertices[k].Pos    = cylinder.Vertices[i].Position;
		vertices[k].Normal = cylinder.Vertices[i].Normal;
		vertices[k].Tex    = cylinder.Vertices[i].TexC;
	}

    D3D11_BUFFER_DESC vbd;
    vbd.Usage = D3D11_USAGE_IMMUTABLE;
    vbd.ByteWidth = sizeof(Vertex::Basic32) * totalVertexCount;
    vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    vbd.CPUAccessFlags = 0;
    vbd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA vinitData;
    vinitData.pSysMem = &vertices[0];
    HR(md3dDevice->CreateBuffer(&vbd, &vinitData, &mShapesVB));

	//
	// Pack the indices of all the meshes into one index buffer.
	//

	std::vector<UINT> indices;
	indices.insert(indices.end(), box.Indices.begin(), box.Indices.end());
	indices.insert(indices.end(), grid.Indices.begin(), grid.Indices.end());
	indices.insert(indices.end(), sphere.Indices.begin(), sphere.Indices.end());
	indices.insert(indices.end(), cylinder.Indices.begin(), cylinder.Indices.end());

	D3D11_BUFFER_DESC ibd;
    ibd.Usage = D3D11_USAGE_IMMUTABLE;
    ibd.ByteWidth = sizeof(UINT) * totalIndexCount;
    ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
    ibd.MiscFlags = 0;
    D3D11_SUBRESOURCE_DATA iinitData;
    iinitData.pSysMem = &indices[0];
    HR(md3dDevice->CreateBuffer(&ibd, &iinitData, &mShapesIB));
}