void M2EffectRender::CreateRibbons()
{
const D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
//{ "LIFE", 0, DXGI_FORMAT_R32_FLOAT, 0, 20, D3D11_INPUT_PER_VERTEX_DATA, 0 },
//{ "THETA", 0, DXGI_FORMAT_R32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 20, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
ID3D11Device* device = GetApp()->GetDevice();
D3DX11_PASS_DESC PassDesc;
RibbonData_.gpRenderParticles->GetPassByIndex( 0 )->GetDesc( &PassDesc ) ;
device->CreateInputLayout( layout, 3, PassDesc.pIAInputSignature,
PassDesc.IAInputSignatureSize, &RibbonData_.gpVertexLayout ) ;
ID3D11Buffer* pBuffer;
RibbonData_.ParticleBuffers.resize(Owner_->header.nRibbonEmitters);
for (size_t i =0; i < Owner_->header.nRibbonEmitters; ++i)
{
D3D11_BUFFER_DESC BDesc;
BDesc.ByteWidth = sizeof( RibbonVertex ) * 4 * MAX_PARTICLES;
BDesc.Usage = D3D11_USAGE_DYNAMIC;
BDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
BDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
BDesc.MiscFlags = 0;
device->CreateBuffer( &BDesc, NULL, &pBuffer );
RibbonData_.ParticleBuffers.at(i) = pBuffer;
}
}
int InputLayout::init(InputLayout& obj, const VertexFormat& vf, const void* code, size_t length)
{
NYX_ASSERT(obj._input_layout == nullptr);
ID3D11Device* device = RenderDevice::device();
D3D11_INPUT_ELEMENT_DESC descs[VertexFormat::MAX_ELEMENT_COUNT];
size_t element_count = vf.element_count();
for (size_t i = 0; i < element_count; ++i)
{
const VertexFormat::Element& elem = vf.element(i);
descs[i].SemanticName = vertex_semantic_to_string(elem.semantic);
descs[i].SemanticIndex = elem.semantic_index;
descs[i].Format = to_dxgi(elem.format);
descs[i].InputSlot = elem.input_slot;
descs[i].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
descs[i].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
descs[i].InstanceDataStepRate = 0;
}
HRESULT hr = device->CreateInputLayout(descs, element_count, code, length, &obj._input_layout);
if (FAILED(hr))
{
term(obj);
return 1;
}
return 0;
}
void InstancedBasic::SetInputLayout()
{
D3D11_INPUT_ELEMENT_DESC vertexDesc[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "WORLD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 0, D3D11_INPUT_PER_INSTANCE_DATA, 1 }, //인스탄스 설정
{ "WORLD", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 16, D3D11_INPUT_PER_INSTANCE_DATA, 1 }, //인스탄스 설정
{ "WORLD", 2, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 32, D3D11_INPUT_PER_INSTANCE_DATA, 1 }, //인스탄스 설정
{ "WORLD", 3, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 48, D3D11_INPUT_PER_INSTANCE_DATA, 1 }, //인스탄스 설정
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, 64, D3D11_INPUT_PER_INSTANCE_DATA, 1 }, //인스탄스 설정
};
D3DX11_PASS_DESC passDesc;
_technique = _fx->GetTechniqueByIndex(0);
_technique->GetPassByIndex(0)->GetDesc(&passDesc);
ID3D11Device* device = RenderDevice::Get()->GetDevice();
assert(device != nullptr);
device->CreateInputLayout(vertexDesc, 8, passDesc.pIAInputSignature, passDesc.IAInputSignatureSize, &_inputLayout);
assert(_inputLayout != nullptr);
}
void SwapChain11::initPassThroughResources()
{
ID3D11Device *device = mRenderer->getDevice();
ASSERT(device != NULL);
// Make sure our resources are all not allocated, when we create
ASSERT(mQuadVB == NULL && mPassThroughSampler == NULL);
ASSERT(mPassThroughIL == NULL && mPassThroughVS == NULL && mPassThroughPS == NULL);
D3D11_BUFFER_DESC vbDesc;
vbDesc.ByteWidth = sizeof(d3d11::PositionTexCoordVertex) * 4;
vbDesc.Usage = D3D11_USAGE_DYNAMIC;
vbDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
vbDesc.MiscFlags = 0;
vbDesc.StructureByteStride = 0;
HRESULT result = device->CreateBuffer(&vbDesc, NULL, &mQuadVB);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mQuadVB, "Swap chain quad vertex buffer");
D3D11_SAMPLER_DESC samplerDesc;
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 0;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
samplerDesc.BorderColor[0] = 0.0f;
samplerDesc.BorderColor[1] = 0.0f;
samplerDesc.BorderColor[2] = 0.0f;
samplerDesc.BorderColor[3] = 0.0f;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
result = device->CreateSamplerState(&samplerDesc, &mPassThroughSampler);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mPassThroughSampler, "Swap chain pass through sampler");
D3D11_INPUT_ELEMENT_DESC quadLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
result = device->CreateInputLayout(quadLayout, 2, g_VS_Passthrough, sizeof(g_VS_Passthrough), &mPassThroughIL);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mPassThroughIL, "Swap chain pass through layout");
result = device->CreateVertexShader(g_VS_Passthrough, sizeof(g_VS_Passthrough), NULL, &mPassThroughVS);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mPassThroughVS, "Swap chain pass through vertex shader");
result = device->CreatePixelShader(g_PS_PassthroughRGBA, sizeof(g_PS_PassthroughRGBA), NULL, &mPassThroughPS);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mPassThroughPS, "Swap chain pass through pixel shader");
}
void InitializeShaders()
{
D3D11_INPUT_ELEMENT_DESC inputDescription[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
// Load Vertex Shader --------------------------------------
ID3DBlob* vsBlob;
D3DReadFileToBlob(L"SampleVertexShader.cso", &vsBlob);
// Create the shader on the device
mDevice->CreateVertexShader(
vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(),
NULL,
&mVertexShader);
// Before cleaning up the data, create the input layout
if (inputDescription) {
if (mInputLayout != NULL) ReleaseMacro(mInputLayout);
mDevice->CreateInputLayout(
inputDescription, // Reference to Description
2, // Number of elments inside of Description
vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(),
&mInputLayout);
}
// Clean up
vsBlob->Release();
// Load Pixel Shader ---------------------------------------
ID3DBlob* psBlob;
D3DReadFileToBlob(L"SamplePixelShader.cso", &psBlob);
// Create the shader on the device
mDevice->CreatePixelShader(
psBlob->GetBufferPointer(),
psBlob->GetBufferSize(),
NULL,
&mPixelShader);
// Clean up
psBlob->Release();
// Constant buffers ----------------------------------------
D3D11_BUFFER_DESC cBufferTransformDesc;
cBufferTransformDesc.ByteWidth = sizeof(mMatrixBuffer);
cBufferTransformDesc.Usage = D3D11_USAGE_DEFAULT;
cBufferTransformDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cBufferTransformDesc.CPUAccessFlags = 0;
cBufferTransformDesc.MiscFlags = 0;
cBufferTransformDesc.StructureByteStride = 0;
mDevice->CreateBuffer(&cBufferTransformDesc, NULL, &mConstantBuffer);
}
void Effect::CreateInputLayout(const string& group, const string& technique, const string& pass, const D3D11_INPUT_ELEMENT_DESC* desc, U32 numElements) {
_ASSERT(desc);
ID3D11Device* device = GraphicsManager::Get()->GetDevice();
PassData& passData = FindPassData(group, technique, pass);
if (!passData.inputLayout) {
DXCall(device->CreateInputLayout(desc, numElements, passData.inputSignature, passData.inputSignatureSize, &(passData.inputLayout)));
}
}
HRESULT DeferredPipeline::OutputMerger::_initialise_vertex_layout(ID3D11Device & device, ID3D10Blob & compiled_vertex_shader)
{
D3D11_INPUT_ELEMENT_DESC layout[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
return device.CreateInputLayout(layout, (sizeof(layout) / sizeof(layout[0])), compiled_vertex_shader.GetBufferPointer(), compiled_vertex_shader.GetBufferSize(), &_vertex_input_layout);
}
HRESULT CAniShader::Init()
{
D3D11_INPUT_ELEMENT_DESC tInputLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "BONES", 0, DXGI_FORMAT_R32G32B32A32_UINT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "BONES", 1, DXGI_FORMAT_R32G32B32A32_UINT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "WEIGHTS", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "WEIGHTS", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
UINT iElementNum = ARRAYSIZE(tInputLayout);
DWORD swFlag = D3DCOMPILE_ENABLE_STRICTNESS;
#if defined( DEBUG ) || defined( _DEBUG )
swFlag |= D3D10_SHADER_DEBUG;
#endif
ID3DBlob* pBlob = NULL, *pErrorBlob = NULL;
ID3D11Device* pDevice = m_pDevice->GetDevice();
if (SUCCEEDED(D3DX11CompileFromFile(L"../bin/Data/Fx/VertexAni.fx", NULL, NULL,
"VS", "vs_4_0", swFlag, 0, NULL, &pBlob, &pErrorBlob, NULL)))
{
pDevice->CreateVertexShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &m_pVertexShader);
pDevice->CreateInputLayout(
tInputLayout, iElementNum, pBlob->GetBufferPointer(), pBlob->GetBufferSize(), &m_pVertexLayout);
}
else
{
if (pErrorBlob) { FAILED_CHECK_MSG(E_FAIL, L"셰이더 컴파일 실패"); }
else { FAILED_CHECK_MSG(E_FAIL, L"셰이더 파일이 존재하지 않습니다."); }
return E_FAIL;
}
pBlob = pErrorBlob = NULL;
if (SUCCEEDED(D3DX11CompileFromFile(L"../bin/Data/Fx/VertexAni.fx", NULL, NULL,
"PS", "ps_4_0", swFlag, 0, NULL, &pBlob, &pErrorBlob, NULL)))
{
pDevice->CreatePixelShader(pBlob->GetBufferPointer(), pBlob->GetBufferSize(), NULL, &m_pPixelShader);
}
else
{
if (pErrorBlob) { FAILED_CHECK_MSG(E_FAIL, L"셰이더 컴파일 실패"); }
else { FAILED_CHECK_MSG(E_FAIL, L"셰이더 파일이 존재하지 않습니다."); }
return E_FAIL;
}
::Safe_Release(pBlob);
::Safe_Release(pErrorBlob);
return S_OK;
}
bool H3DVertexShader::Create(const TCHAR* shader_file , const TCHAR* main_func_name , const TCHAR* profile ,
const D3D11_INPUT_ELEMENT_DESC* input_elem_desc , uint32_t input_elem_num )
{
HRESULT result = S_OK;
ID3D10Blob* err_msg = NULL;
ID3D10Blob* vscode_buffer = NULL;
// 编译shader代码
result = D3DX11CompileFromFile( shader_file, NULL, NULL, main_func_name, profile
, D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL,
&vscode_buffer, &err_msg, NULL);
if(FAILED(result))
{
if(err_msg)
{
OutputDebugStringA((char*)(err_msg->GetBufferPointer()));
OutputDebugStringA("\n");
}
else
{
OutputDebugString(_T("Missing Shader File\n"));
}
H3D_SAFE_RELEASE(err_msg);
return false;
}
void* vscode_buf_pointer = vscode_buffer->GetBufferPointer();
uint32_t vscode_buf_size = vscode_buffer->GetBufferSize();
ID3D11Device* device = H3DRenderer::GetSingletonPtr()->GetDevice();
result = device->CreateVertexShader(
vscode_buf_pointer, vscode_buf_size, NULL, &vertex_shader_);
if(FAILED(result))
{
return false;
}
// 创建input layout对象
result = device->CreateInputLayout( input_elem_desc , input_elem_num ,
vscode_buf_pointer, vscode_buf_size, &input_layout_);
if(FAILED(result))
{
return false;
}
H3D_SAFE_RELEASE(err_msg);
H3D_SAFE_RELEASE(vscode_buffer);
return true;
}
void TgcDX11Effect::init(const TgcVertexBuffer* vertexBuffer)
{
ID3D11Device* device = ((TgcDX11Renderer*)GuiController::Instance->renderer)->device;
TgcDX11InputLayout* inputLayout = ((TgcDX11InputLayout*)((TgcDX11VertexBuffer*)vertexBuffer)->inputLayout);
//Create the input layout
if(inputLayout->layout == NULL)
{
HRESULT result = device->CreateInputLayout(inputLayout->layoutDesc, inputLayout->elements.size(),
this->vertexShaderBuffer->GetBufferPointer(), this->vertexShaderBuffer->GetBufferSize(), &(inputLayout->layout));
if(FAILED(result))
{
GuiController::Instance->logger->logError("Could not create InputLayout");
}
}
}
void SpriteShader::SetInputLayout()
{
ID3D11Device *dev = (ID3D11Device*)EngineCore::GetGraphicsAPI()->GetDevice();
D3D11_INPUT_ELEMENT_DESC ied[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
dev->CreateInputLayout(
ied,
2,
vsBlob->GetBufferPointer(),
vsBlob->GetBufferSize(),
&pLayout
);
}
ID3D11InputLayout* graphics::createVertexInputLayout( GraphicsSystem& graphicsSystem, const ShaderPlatformData& shaderData, const D3D11_INPUT_ELEMENT_DESC* pElements, uint elementCount )
{
ID3D11Device* pDevice = GraphicsSystemPlatform::getDevice( graphicsSystem );
ID3D11InputLayout* pLayout = nullptr;
const HRESULT result = pDevice->CreateInputLayout(
pElements,
(UINT)elementCount,
shaderData.pShaderCode,
(UINT)shaderData.shaderCodeLength,
&pLayout
);
if ( result == S_OK )
{
return pLayout;
}
return nullptr;
}
void TerrainShader::InitializeShaders(ID3D11DeviceContext* deviceContext)
{
// Helper to get device.
ID3D11Device* device = DX::GetDevice(deviceContext);
DX::ThrowIfFailed(device->CreateVertexShader(TerrainShaders::TerrainVertexShaderBytecode, sizeof(TerrainShaders::TerrainVertexShaderBytecode), nullptr, vertexShader.GetAddressOf()));
DX::ThrowIfFailed(device->CreatePixelShader(TerrainShaders::TerrainPixelShaderBytecode, sizeof(TerrainShaders::TerrainPixelShaderBytecode), nullptr, pixelShader.GetAddressOf()));
DX::ThrowIfFailed(device->CreateInputLayout(DirectX::VertexPositionNormalColorDualTexture::InputElements, DirectX::VertexPositionNormalColorDualTexture::InputElementCount, TerrainShaders::TerrainVertexShaderBytecode, sizeof(TerrainShaders::TerrainVertexShaderBytecode), inputLayout.GetAddressOf()));
states = std::make_unique<DirectX::CommonStates>(device);
// Load textures
DirectX::CreateWICTextureFromFile(device, L"Data/color.png", nullptr, texture0.ReleaseAndGetAddressOf());
DirectX::CreateDDSTextureFromFile(device, L"Data/base.dds", nullptr, texture1.ReleaseAndGetAddressOf());
DirectX::CreateWICTextureFromFile(device, L"Data/red.dds", nullptr, texture2.ReleaseAndGetAddressOf());
DirectX::CreateDDSTextureFromFile(device, L"Data/green.dds", nullptr, texture3.ReleaseAndGetAddressOf());
DirectX::CreateWICTextureFromFile(device, L"Data/blue.dds", nullptr, texture4.ReleaseAndGetAddressOf());
constantBuffer.Create(device);
lightBuffer.Create(device);
}
bool init(ID3D11Device* dev, int argc, char** argv)
{
this->dev = dev;
ensure(dev->CreateVertexShader(g_vs, sizeof(g_vs), NULL, &vs));
ensure(dev->CreateHullShader(g_hs, sizeof(g_hs), NULL, &hs));
ensure(dev->CreateDomainShader(g_ds, sizeof(g_ds), NULL, &ds));
ensure(dev->CreatePixelShader(g_ps, sizeof(g_ps), NULL, &ps));
D3D11_INPUT_ELEMENT_DESC elements[1] =
{
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,
0, D3D11_INPUT_PER_VERTEX_DATA, 0},
};
ensure(dev->CreateInputLayout(elements, 1, g_vs, sizeof(g_vs), &layout));
D3D11_BUFFER_DESC bufferd;
bufferd.ByteWidth = sizeof(vertex_data);
bufferd.Usage = D3D11_USAGE_IMMUTABLE;
bufferd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufferd.CPUAccessFlags = 0;
bufferd.MiscFlags = 0;
bufferd.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA buffersd;
buffersd.pSysMem = vertex_data;
ensure(dev->CreateBuffer(&bufferd, &buffersd, &vb));
D3D11_BUFFER_DESC cbd;
cbd.ByteWidth = (sizeof(cb_frame_t) + 15) & ~15;
cbd.Usage = D3D11_USAGE_DYNAMIC;
cbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
cbd.MiscFlags = 0;
cbd.StructureByteStride = 0;
ensure(dev->CreateBuffer(&cbd, NULL, &cb_frame));
return true;
}
void D3D11Mesh::LoadAndBuildMeshFromOBJFile(LPCWSTR filename, D3D11ShaderProgram* shader)
{
Triangle* mesh;
m_numtriangles = importOBJMesh(filename, &mesh);
m_shader = shader;
unsigned int offset = sizeof(Vector3);
D3D11_INPUT_ELEMENT_DESC vertlayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, offset, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 2*offset, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
ID3D11Device* pDevice = shader->GetDevice();
ID3DBlob* pVSBlob = shader->GetVSBlob();
HRESULT hr = pDevice->CreateInputLayout(vertlayout, ARRAYSIZE(vertlayout), pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(), &m_vertexLayout);
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DEFAULT;
bd.ByteWidth = sizeof(Vertex)*m_numtriangles*3;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA initData;
ZeroMemory(&initData, sizeof(initData));
initData.pSysMem = &(mesh[0].m_vertices[0].m_position[0]);
pDevice->CreateBuffer(&bd, &initData, &m_vertexBuffer);
delete [] mesh;
}
vpResult vprInputLayoutDX11::init()
{
vprDeviceDX11* dx11Device = static_cast<vprDeviceDX11*>(m_device);
ID3D11Device* nativeDevice = dx11Device->getNativeDevice();
D3D11_INPUT_ELEMENT_DESC nativeDescs[vprInputElementIndex::COUNT];
for (int i = 0; i < m_desc.m_numElements; ++i)
{
D3D11_INPUT_ELEMENT_DESC& desc = nativeDescs[i];
ZeroMemory(&desc, sizeof(desc));
vprInputElementDesc& inputElementDesc = m_desc.m_inputElementDescs[i];
desc.SemanticName = inputElementIndexToSemanticNameDX11[inputElementDesc.m_index];
desc.SemanticIndex = inputElementIndexToSemanticIndexDX11[inputElementDesc.m_index];
desc.Format = resourceFormatToDXGIFormat(inputElementDesc.m_format);
desc.InputSlot = inputElementDesc.m_inputSlot;
desc.AlignedByteOffset = inputElementDesc.m_alignedByteOffset;
if (inputElementDesc.m_perInstanceData)
{
desc.InputSlotClass = D3D11_INPUT_PER_INSTANCE_DATA;
desc.InstanceDataStepRate = inputElementDesc.m_instanceDataStepRate;
}
else
{
desc.InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
desc.InstanceDataStepRate = 0;
}
}
if (FAILED(nativeDevice->CreateInputLayout(nativeDescs, m_desc.m_numElements, VP_NULL, 0, &m_nativeInputLayout)))
{
return VP_FAILURE;
}
return VP_SUCCESS;
}
bool CD3DVertexShader::CreateInternal()
{
ID3D11Device* pDevice = g_Windowing.Get3D11Device();
CLog::Log(LOGDEBUG, __FUNCTION__ " - Create the vertex shader.");
// Create the vertex shader
if (FAILED(pDevice->CreateVertexShader(m_VSBuffer->GetBufferPointer(), m_VSBuffer->GetBufferSize(), nullptr, &m_VS)))
{
CLog::Log(LOGERROR, __FUNCTION__ " - Failed to Create the vertex shader.");
SAFE_RELEASE(m_VSBuffer);
return false;
}
CLog::Log(LOGDEBUG, __FUNCTION__ " - create the input layout.");
if (FAILED(pDevice->CreateInputLayout(m_vertexLayout, m_vertexLayoutSize, m_VSBuffer->GetBufferPointer(), m_VSBuffer->GetBufferSize(), &m_inputLayout)))
{
CLog::Log(LOGERROR, __FUNCTION__ " - Failed to create the input layout.");
return false;
}
return true;
}
void Directx::TShader::MakeLayout(const SoyGraphics::TGeometryVertex& Vertex,ArrayBridge<uint8>&& CompiledShader,const std::string& ShaderName,ID3D11Device& Device)
{
Array<D3D11_INPUT_ELEMENT_DESC> Layouts;
for ( int e=0; e<Vertex.mElements.GetSize(); e++ )
{
auto& Element = Vertex.mElements[e];
auto& Layout = Layouts.PushBack();
memset( &Layout, 0, sizeof(Layout) );
Layout.SemanticName = Element.mName.c_str();
Layout.Format = GetType( Element.mType, Element.mArraySize );
Layout.SemanticIndex = Element.mIndex;
Layout.InputSlot = 0;
Layout.AlignedByteOffset = 0; // D3D11_APPEND_ALIGNED_ELEMENT
Layout.InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
Layout.InstanceDataStepRate = 0;
}
auto Result = Device.CreateInputLayout( Layouts.GetArray(), Layouts.GetSize(), CompiledShader.GetArray(), CompiledShader.GetDataSize(), &mLayout.mObject );
std::stringstream Error;
Error << "CreateInputLayout(" << ShaderName << ")";
Directx::IsOkay( Result, Error.str() );
}
void IvPointRendererD3D11::Setup()
{
sVertexShader[kPFormat] = sVertexShaderPFormat;
sVertexShader[kCPFormat] = sVertexShaderCPFormat;
sVertexShader[kNPFormat] = sVertexShaderNPFormat;
sVertexShader[kCNPFormat] = sVertexShaderCNPFormat;
sVertexShader[kTCPFormat] = sVertexShaderTCPFormat;
sVertexShader[kTNPFormat] = sVertexShaderTNPFormat;
sFragmentShader[kPFormat] = sFragmentShaderP;
sFragmentShader[kCPFormat] = sFragmentShaderCP;
sFragmentShader[kNPFormat] = sFragmentShaderCP;
sFragmentShader[kCNPFormat] = sFragmentShaderCP;
sFragmentShader[kTCPFormat] = sFragmentShaderTCP;
sFragmentShader[kTNPFormat] = sFragmentShaderTCP;
for (int format = 0; format < kVertexFormatCount; ++format)
{
// create the shaders
sShaders[format] = IvRenderer::mRenderer->GetResourceManager()->CreateShaderProgram(
IvRenderer::mRenderer->GetResourceManager()->CreateVertexShaderFromString(
sVertexShader[format]),
IvRenderer::mRenderer->GetResourceManager()->CreateFragmentShaderFromString(
sFragmentShader[format]));
// create the vertex layout
D3D11_INPUT_ELEMENT_DESC* elements = nullptr;
UINT numElements = 0;
const char* shaderString = nullptr;
switch (format)
{
case kPFormat:
elements = sPFormatElements;
numElements = sizeof(sPFormatElements) / sizeof(D3D11_INPUT_ELEMENT_DESC);
shaderString = sVertexShaderPFormat;
break;
case kCPFormat:
elements = sCPFormatElements;
numElements = sizeof(sCPFormatElements) / sizeof(D3D11_INPUT_ELEMENT_DESC);
shaderString = sVertexShaderCPFormat;
break;
case kNPFormat:
elements = sNPFormatElements;
numElements = sizeof(sNPFormatElements) / sizeof(D3D11_INPUT_ELEMENT_DESC);
shaderString = sVertexShaderNPFormat;
break;
case kCNPFormat:
elements = sCNPFormatElements;
numElements = sizeof(sCNPFormatElements) / sizeof(D3D11_INPUT_ELEMENT_DESC);
shaderString = sVertexShaderCNPFormat;
break;
case kTCPFormat:
elements = sTCPFormatElements;
numElements = sizeof(sTCPFormatElements) / sizeof(D3D11_INPUT_ELEMENT_DESC);
shaderString = sVertexShaderTCPFormat;
break;
case kTNPFormat:
elements = sTNPFormatElements;
numElements = sizeof(sTNPFormatElements) / sizeof(D3D11_INPUT_ELEMENT_DESC);
shaderString = sVertexShaderTNPFormat;
break;
}
ID3DBlob* code;
ID3DBlob* errorMessages = nullptr;
// compile the shader to assembly
// it's not ideal to compile the vertex shader again, but we only have to
// go through this process once to create the layout
if (FAILED(D3DCompile(shaderString, strlen(shaderString) + 1, nullptr, nullptr, nullptr, "vs_main", "vs_4_0",
D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_DEBUG, 0, &code, &errorMessages)))
{
const char* errors = reinterpret_cast<const char*>(errorMessages->GetBufferPointer());
DEBUG_OUT("Vertex shader error: ");
DEBUG_OUT(errors << std::endl);
errorMessages->Release();
ASSERT(false);
return;
}
if (errorMessages)
{
errorMessages->Release();
}
ID3D11Device* device = static_cast<IvRendererD3D11*>(IvRenderer::mRenderer)->GetDevice();
if (FAILED(device->CreateInputLayout(elements, numElements, code->GetBufferPointer(), code->GetBufferSize(), &sInputLayout[format])))
{
code->Release();
ASSERT(false);
return;
}
code->Release();
}
// create the quad buffer
float xCoord = 1.0f / static_cast<float>(IvRenderer::mRenderer->GetWidth());
float yCoord = 1.0f / static_cast<float>(IvRenderer::mRenderer->GetHeight());
IvPVertex verts[4] =
{
IvVector3(xCoord, -yCoord, 0.0f),
IvVector3(xCoord, yCoord, 0.0f),
IvVector3(-xCoord, -yCoord, 0.0f),
IvVector3(-xCoord, yCoord, 0.0f)
};
sQuadBuffer = IvRenderer::mRenderer->GetResourceManager()->CreateVertexBuffer(kPFormat, 4, verts, kImmutableUsage);
}
// WinMain
int APIENTRY _tWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow )
{
HRESULT hr;
// ウィンドウクラスを登録
WNDCLASSEX wcex = {
sizeof( WNDCLASSEX ), // cbSize
CS_HREDRAW | CS_VREDRAW, // style
WndProc, // lpfnWndProc
0, // cbClsExtra
0, // cbWndExtra
hInstance, // hInstance
NULL, // hIcon
NULL, // hCursor
( HBRUSH )( COLOR_WINDOW + 1 ), // hbrBackGround
NULL, // lpszMenuName
g_className, // lpszClassName
NULL // hIconSm
};
if ( ! RegisterClassEx( &wcex ) )
{
MessageBox( NULL, _T( "失敗: RegisterClassEx()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "RegisterClassEx: ok\n" ) );
// ウィンドウサイズを計算
RECT r = { 0, 0, 800, 450 }; // 800x450 (16:9)
if ( ! AdjustWindowRect( &r, WS_OVERLAPPEDWINDOW, FALSE ) )
{
MessageBox( NULL, _T( "失敗: AdjustWindowRect()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "AdjustWindowRect: ok (%d, %d)－(%d, %d)\n" ), r.left, r.top, r.right, r.bottom );
// ウィンドウ生成
HWND hWnd;
hWnd = CreateWindow( g_className,
g_windowName,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
0,
r.right - r.left,
r.bottom - r.top,
NULL,
NULL,
hInstance,
NULL );
if ( hWnd == NULL )
{
MessageBox( NULL, _T( "失敗: CreateWindow()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "CreateWindow: ok\n" ) );
// ウィンドウ表示
ShowWindow(hWnd, nCmdShow);
dtprintf( _T( "ShowWindow: ok\n" ) );
// スワップチェイン設定
DXGI_SWAP_CHAIN_DESC scDesc = {
{
1280, // BufferDesc.Width
720, // BufferDesc.Height
{
60, // BufferDesc.RefreshRate.Numerator
1 // BufferDesc.RefreshRate.Denominator
},
DXGI_FORMAT_R16G16B16A16_FLOAT, // BufferDesc.Format
DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED, // BufferDesc.ScanlineOrdering
DXGI_MODE_SCALING_CENTERED // BufferDesc.Scaling
},
{
1, // SampleDesc.Count
0 // SampleDesc.Quality
},
DXGI_USAGE_RENDER_TARGET_OUTPUT, // BufferUsage
1, // BufferCount
hWnd, // OutputWindow
TRUE, // Windowed
DXGI_SWAP_EFFECT_DISCARD, // SwapEffect
DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH // Flags
};
// Direct3D11 デバイス・デバイスコンテキスト・スワップチェーン生成
ID3D11Device * pDevice = NULL;
ID3D11DeviceContext * pDeviceContext = NULL;
IDXGISwapChain * pSwapChain = NULL;
D3D_FEATURE_LEVEL feature;
hr = D3D11CreateDeviceAndSwapChain( NULL,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
0,
NULL,
0,
D3D11_SDK_VERSION,
&scDesc,
&pSwapChain,
&pDevice,
&feature,
&pDeviceContext );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: D3D11CreateDeviceAndSwapChain()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "D3D11CreateDeviceAndSwapChain: ok (pDevice: 0x%p, pDeviceContext: 0x%p, pSwapChain: 0x%p, feature: 0x%4x)\n" ),
pDevice,
pDeviceContext,
pSwapChain,
( int ) feature );
// バックバッファテクスチャ取得
ID3D11Texture2D * pBackBuffer = NULL;
hr = pSwapChain->GetBuffer( 0, __uuidof( pBackBuffer ), reinterpret_cast< void ** >( &pBackBuffer ) );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: IDXGISwapChain::GetBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "IDXGISwapChain::GetBuffer: ok (pBackBuffer: 0x%p)\n" ), pBackBuffer );
// レンダーターゲットビュー生成
ID3D11RenderTargetView * pRenderTargetView = NULL;
hr = pDevice->CreateRenderTargetView( pBackBuffer, NULL, &pRenderTargetView );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateRenderTargetView()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateRenderTargetView: ok (pRenderTargetView: 0x%p)\n" ), pRenderTargetView );
// レンダーターゲットビューをバインド
pDeviceContext->OMSetRenderTargets( 1, &pRenderTargetView, NULL );
dtprintf( _T( "ID3D11DeviceContext::OMSetRenderTargets: ok\n" ) );
// バックバッファはもうここでは使わない
COM_SAFE_RELEASE( pBackBuffer );
// ビューポートをバインド
D3D11_VIEWPORT viewport = {
0.0f, // TopLeftX
0.0f, // TopLeftY
1280.0f, // Width
720.0f, // Height
0.0f, // MinDepth
1.0f // MaxDepth
};
pDeviceContext->RSSetViewports( 1, &viewport );
dtprintf( _T( "ID3D11DeviceContext::RSSetViewports: ok\n" ) );
// 頂点データ
float vertices[ 5 ][ 7 ] = {
// Xaxis Yaxis Zaxis 赤 緑 青 Alpha
{ 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f }, // 原点
{ -0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 1.0f }, // 左上
{ 0.5f, 0.5f, 0.5f, 1.0f, 1.0f, 0.0f, 1.0f }, // 右上
{ 0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f }, // 右下
{ -0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f } // 左下
};
// 入力エレメント記述子
D3D11_INPUT_ELEMENT_DESC verticesDesc[] = {
{ "IN_POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "IN_COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, sizeof(float)*3, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
// 頂点バッファを生成
D3D11_BUFFER_DESC vertexBufferDesc = {
5 * sizeof( float ) * 7, // ByteWidth
D3D11_USAGE_DEFAULT, // Usage
D3D11_BIND_VERTEX_BUFFER, // BindFlags
0, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteStride
};
D3D11_SUBRESOURCE_DATA vertexResourceData = { vertices };
ID3D11Buffer * pVertexBuffer = NULL;
hr = pDevice->CreateBuffer( &vertexBufferDesc, &vertexResourceData, &pVertexBuffer );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pVertexBuffer: 0x%p)\n" ), pVertexBuffer );
// 頂点バッファをバインド
UINT strides[] = { sizeof( float ) * 7 };
UINT offsets[] = { 0 };
pDeviceContext->IASetVertexBuffers( 0, 1, &pVertexBuffer, strides, offsets );
dtprintf( _T( "ID3D11DeviceContext::IASetVertexBuffers: ok\n" ) );
// インデックスデータ
unsigned int indices[] = { 0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 1 };
// インデックスバッファを生成
D3D11_BUFFER_DESC indexBufferDesc = {
sizeof( unsigned int ) * 12, // ByteWidth
D3D11_USAGE_DEFAULT, // Usage
D3D11_BIND_INDEX_BUFFER, // BindFlags
0, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteStride
};
D3D11_SUBRESOURCE_DATA indexResourceData = { indices };
ID3D11Buffer * pIndexBuffer = NULL;
hr = pDevice->CreateBuffer( &indexBufferDesc, &indexResourceData, &pIndexBuffer );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pIndexBuffer: 0x%p)\n" ), pIndexBuffer );
// インデックスバッファをバインド
pDeviceContext->IASetIndexBuffer( pIndexBuffer, DXGI_FORMAT_R32_UINT, 0 );
dtprintf( _T( "ID3D11DeviceContext::IASetIndexBuffer: ok\n" ) );
// プリミティブタイプを設定
pDeviceContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
dtprintf( _T( "ID3D11DeviceContext::IASetPrimitiveTopology: ok\n" ) );
// 頂点シェーダを作成
ID3D11VertexShader * pVertexShader = NULL;
hr = pDevice->CreateVertexShader( g_vs_constant, sizeof( g_vs_constant ), NULL, &pVertexShader );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateVertexShader()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateVertexShader: ok (pVertexShader: 0x%p)\n" ), pVertexShader );
// ピクセルシェーダを作成
ID3D11PixelShader * pPixelShader = NULL;
hr = pDevice->CreatePixelShader( g_ps_constant, sizeof( g_ps_constant ), NULL, &pPixelShader );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreatePixelShader()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreatePixelShader: ok (pPixelShader: 0x%p)\n" ), pPixelShader );
// シェーダをバインド
pDeviceContext->VSSetShader( pVertexShader, NULL, 0 );
dtprintf( _T( "ID3D11DeviceContext::VSSetShader: ok\n" ) );
pDeviceContext->PSSetShader( pPixelShader, NULL, 0 );
dtprintf( _T( "ID3D11DeviceContext::PSSetShader: ok\n" ) );
pDeviceContext->GSSetShader( NULL, NULL, 0 );
pDeviceContext->HSSetShader( NULL, NULL, 0 );
pDeviceContext->DSSetShader( NULL, NULL, 0 );
// 入力レイアウトを生成
ID3D11InputLayout * pInputLayout = NULL;
hr = pDevice->CreateInputLayout( verticesDesc, 2, g_vs_constant, sizeof( g_vs_constant ), &pInputLayout );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateInputLayout()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateInputLayout: ok (pInputLayout: 0x%p)\n" ), pInputLayout );
// 入力レイアウトをバインド
pDeviceContext->IASetInputLayout( pInputLayout );
dtprintf( _T( "ID3D11DeviceContext::IASetInputLayout: ok\n" ) );
MSG msg;
while ( 1 )
{
// メッセージを取得
if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
if ( msg.message == WM_QUIT )
{
dtprintf( _T( "PeekMessage: WM_QUIT\n" ) );
break;
}
// メッセージ処理
DispatchMessage( &msg );
}
else
{
// レンダーターゲットをクリア
const float clear[ 4 ] = { 0.0f, 0.0f, 1.0f, 1.0f }; // RGBA
pDeviceContext->ClearRenderTargetView( pRenderTargetView, clear );
// 描画
pDeviceContext->DrawIndexed( 12, 0, 0 );
pSwapChain->Present( 1, 0 );
// ちょっとだけ待つ
Sleep( 5 );
}
}
// シェーダをアンバインド
pDeviceContext->VSSetShader( NULL, NULL, 0 );
pDeviceContext->PSSetShader( NULL, NULL, 0 );
// デバイス・リソース解放
COM_SAFE_RELEASE( pInputLayout );
COM_SAFE_RELEASE( pPixelShader );
COM_SAFE_RELEASE( pVertexShader );
COM_SAFE_RELEASE( pIndexBuffer );
COM_SAFE_RELEASE( pVertexBuffer );
COM_SAFE_RELEASE( pRenderTargetView );
COM_SAFE_RELEASE( pSwapChain );
COM_SAFE_RELEASE( pDeviceContext );
COM_SAFE_RELEASE( pDevice );
return msg.wParam;
}
void CGFXShader::SetVertexFormat(VertexElement format[], uint32 nElem)
{
if(m_pIL != NULL)
{
m_pIL->Release();
}
//DXGI_FORMAT_R32G32B32_FLOAT
ID3D11Device* pDevice = cgD3D11GetDevice(m_pCG);
D3D11_INPUT_ELEMENT_DESC* layout = new D3D11_INPUT_ELEMENT_DESC[nElem];
for(uint32 i = 0; i < nElem; ++i)
{
switch(format[i].semantic)
{
case VertexElement::POSITION:
layout[i].SemanticName = "POSITION";
break;
case VertexElement::NORMAL:
layout[i].SemanticName = "NORMAL";
break;
case VertexElement::COLOR:
layout[i].SemanticName = "COLOR";
break;
case VertexElement::POSITION_T:
layout[i].SemanticName = "POSITIONT";
break;
case VertexElement::TEXCOORD:
layout[i].SemanticName = "TEXCOORD";
break;
default:
break;
}
switch(format[i].type)
{
case VertexElement::VE_FLOAT1:
layout[i].Format = DXGI_FORMAT_R32_FLOAT;
break;
case VertexElement::VE_FLOAT2:
layout[i].Format = DXGI_FORMAT_R32G32_FLOAT;
break;
case VertexElement::VE_FLOAT3:
layout[i].Format = DXGI_FORMAT_R32G32B32_FLOAT;
break;
case VertexElement::VE_FLOAT4:
layout[i].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
break;
case VertexElement::VE_UINT32:
layout[i].Format = DXGI_FORMAT_R32_UINT;
break;
default:
break;
}
layout[i].SemanticIndex = format[i].element_slot;
layout[i].InputSlot = 0;
layout[i].AlignedByteOffset = 0;
layout[i].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
layout[i].InstanceDataStepRate = 0;
}
CGpass pass = cgGetFirstPass( m_pTechnique );
ID3D10Blob * pVSBuf = cgD3D11GetIASignatureByPass( pass );
pDevice->CreateInputLayout( layout, nElem, pVSBuf->GetBufferPointer(), pVSBuf->GetBufferSize(), &m_pIL );
}
void SwapChain11::initPassThroughResources()
{
if (mPassThroughResourcesInit)
{
return;
}
TRACE_EVENT0("gpu.angle", "SwapChain11::initPassThroughResources");
ID3D11Device *device = mRenderer->getDevice();
ASSERT(device != NULL);
// Make sure our resources are all not allocated, when we create
ASSERT(mQuadVB == NULL && mPassThroughSampler == NULL);
ASSERT(mPassThroughIL == NULL && mPassThroughVS == NULL && mPassThroughPS == NULL);
D3D11_BUFFER_DESC vbDesc;
vbDesc.ByteWidth = sizeof(d3d11::PositionTexCoordVertex) * 4;
vbDesc.Usage = D3D11_USAGE_DYNAMIC;
vbDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
vbDesc.MiscFlags = 0;
vbDesc.StructureByteStride = 0;
HRESULT result = device->CreateBuffer(&vbDesc, NULL, &mQuadVB);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mQuadVB, "Swap chain quad vertex buffer");
D3D11_SAMPLER_DESC samplerDesc;
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 0;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
samplerDesc.BorderColor[0] = 0.0f;
samplerDesc.BorderColor[1] = 0.0f;
samplerDesc.BorderColor[2] = 0.0f;
samplerDesc.BorderColor[3] = 0.0f;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
result = device->CreateSamplerState(&samplerDesc, &mPassThroughSampler);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mPassThroughSampler, "Swap chain pass through sampler");
D3D11_INPUT_ELEMENT_DESC quadLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
result = device->CreateInputLayout(quadLayout, 2, g_VS_Passthrough2D, sizeof(g_VS_Passthrough2D), &mPassThroughIL);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mPassThroughIL, "Swap chain pass through layout");
result = device->CreateVertexShader(g_VS_Passthrough2D, sizeof(g_VS_Passthrough2D), NULL, &mPassThroughVS);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mPassThroughVS, "Swap chain pass through vertex shader");
result = device->CreatePixelShader(g_PS_PassthroughRGBA2D, sizeof(g_PS_PassthroughRGBA2D), NULL, &mPassThroughPS);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mPassThroughPS, "Swap chain pass through pixel shader");
// Use the default rasterizer state but without culling
D3D11_RASTERIZER_DESC rasterizerDesc;
rasterizerDesc.FillMode = D3D11_FILL_SOLID;
rasterizerDesc.CullMode = D3D11_CULL_NONE;
rasterizerDesc.FrontCounterClockwise = FALSE;
rasterizerDesc.DepthBias = 0;
rasterizerDesc.SlopeScaledDepthBias = 0.0f;
rasterizerDesc.DepthBiasClamp = 0.0f;
rasterizerDesc.DepthClipEnable = TRUE;
rasterizerDesc.ScissorEnable = FALSE;
rasterizerDesc.MultisampleEnable = FALSE;
rasterizerDesc.AntialiasedLineEnable = FALSE;
result = device->CreateRasterizerState(&rasterizerDesc, &mPassThroughRS);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mPassThroughRS, "Swap chain pass through rasterizer state");
mPassThroughResourcesInit = true;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR cmdLine, int cmdShow)
{
DXTInputHandlerDefault inputHandler;
DXTWindowEventHandlerDefault eventHandler;
DXTWindow window(hInstance, &inputHandler, &eventHandler);
DXTRenderParams params;
params.Extent = { 800, 600 };
params.UseVSync = true;
params.Windowed = true;
HRESULT result;
result = window.Initialize(params, "DXT Example (DirectX 11)");
if (SUCCEEDED(result))
{
ID3D11Device* device;
ID3D11DeviceContext* context;
IDXGISwapChain* swapChain;
result = DXTInitDevice(params, &window, &swapChain, &device, &context);
if (SUCCEEDED(result))
{
eventHandler.SetSwapChain(swapChain);
FLOAT clearColor[] = { 0.5f, 0.5f, 1.0f, 1.0f };
D3D11_INPUT_ELEMENT_DESC inputDesc[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, sizeof(float) * 3, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, sizeof(float) * 5, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
UINT elementCount = 3;
UINT stride = 8 * sizeof(FLOAT);
UINT offset = 0;
UINT indexCount = 0;
FLOAT deltaTime = 0.016f;
DXTSphericalCamera camera;
DXTFirstPersonCameraController cameraController(&camera, &inputHandler);
inputHandler.AddInputInterface(&cameraController);
cameraController.Velocity = 40.0f;
cameraController.RotationVelocity = 0.005f;
camera.Position = DirectX::XMFLOAT3(20.0f, 20.0f, 20.0f);
camera.LookAt(DirectX::XMFLOAT3(0.0f, 0.0f, 0.0f));
ID3D11RenderTargetView* renderTargetView;
ID3D11Texture2D* depthBuffer;
ID3D11DepthStencilView* depthBufferView;
ID3D11VertexShader* vertexShader;
ID3D11PixelShader* pixelShader;
DXTBytecodeBlob vertexBytecode;
ID3D11DepthStencilState* depthState;
ID3D11RasterizerState* rasterizerState;
ID3D11Buffer* vertexBuffer;
ID3D11Buffer* indexBuffer;
ID3D11InputLayout* inputLayout;
ID3D11Buffer* transformBuffer;
DXTCreateRenderTargetFromBackBuffer(swapChain, device, &renderTargetView);
DXTCreateDepthStencilBuffer(device, params.Extent.Width, params.Extent.Height, DXGI_FORMAT_D24_UNORM_S8_UINT, &depthBuffer, &depthBufferView);
DXTVertexShaderFromFile(device, "VertexShader.cso", &vertexShader, &vertexBytecode);
DXTPixelShaderFromFile(device, "PixelShader.cso", &pixelShader);
DXTCreateDepthStencilStateDepthTestEnabled(device, &depthState);
DXTCreateRasterizerStateSolid(device, &rasterizerState);
DXTLoadStaticMeshFromFile(device, "mesh.ase", DXTVertexAttributePosition | DXTVertexAttributeUV | DXTVertexAttributeNormal,
DXTIndexTypeShort, &vertexBuffer, &indexBuffer, &indexCount);
DXTCreateBuffer(device, sizeof(DirectX::XMFLOAT4X4) * 2, D3D11_BIND_CONSTANT_BUFFER, D3D11_CPU_ACCESS_WRITE, D3D11_USAGE_DYNAMIC, &transformBuffer);
device->CreateInputLayout(inputDesc, elementCount, vertexBytecode.Bytecode, vertexBytecode.BytecodeLength, &inputLayout);
vertexBytecode.Destroy();
window.Present(false);
while (!window.QuitMessageReceived())
{
window.MessagePump();
if (inputHandler.IsKeyDown(VK_ESCAPE))
break;
cameraController.Update(deltaTime);
XMFLOAT4X4 ViewProj;
XMFLOAT4X4 World;
camera.GetViewProjectionMatrix(&ViewProj, params.Extent);
XMStoreFloat4x4(&World, XMMatrixIdentity());
D3D11_MAPPED_SUBRESOURCE subres;
context->Map(transformBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &subres);
XMFLOAT4X4* ptr = (XMFLOAT4X4*)subres.pData;
ptr[0] = World;
ptr[1] = ViewProj;
context->Unmap(transformBuffer, 0);
D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (FLOAT)params.Extent.Width, (FLOAT)params.Extent.Height, 0.0f, 1.0f };
context->ClearRenderTargetView(renderTargetView, clearColor);
context->ClearDepthStencilView(depthBufferView, D3D11_CLEAR_DEPTH, 1.0f, 0);
context->OMSetDepthStencilState(depthState, 0);
context->OMSetRenderTargets(1, &renderTargetView, depthBufferView);
context->RSSetState(rasterizerState);
context->RSSetViewports(1, &viewport);
context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
context->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
context->IASetIndexBuffer(indexBuffer, DXGI_FORMAT_R16_UINT, 0);
context->IASetInputLayout(inputLayout);
context->VSSetShader(vertexShader, nullptr, 0);
context->PSSetShader(pixelShader, nullptr, 0);
context->VSSetConstantBuffers(0, 1, &transformBuffer);
context->DrawIndexed(indexCount, 0, 0);
swapChain->Present(1, 0);
}
swapChain->SetFullscreenState(false, nullptr);
transformBuffer->Release();
depthBufferView->Release();
depthBuffer->Release();
inputLayout->Release();
vertexBuffer->Release();
indexBuffer->Release();
depthState->Release();
rasterizerState->Release();
vertexShader->Release();
pixelShader->Release();
renderTargetView->Release();
swapChain->Release();
context->Release();
device->Release();
}
window.Destroy();
}
}
bool SetupRendering(osvr::renderkit::GraphicsLibrary library) {
// Make sure our pointers are filled in correctly.
if (library.D3D11 == nullptr) {
std::cerr << "SetupRendering: No D3D11 GraphicsLibrary, this should "
"not happen"
<< std::endl;
return false;
}
ID3D11Device* device = library.D3D11->device;
ID3D11DeviceContext* context = library.D3D11->context;
// Setup vertex shader
auto hr = device->CreateVertexShader(g_triangle_vs, sizeof(g_triangle_vs),
nullptr, vertexShader.GetAddressOf());
if (FAILED(hr)) {
return false;
}
// Setup pixel shader
hr = device->CreatePixelShader(g_triangle_ps, sizeof(g_triangle_ps),
nullptr, pixelShader.GetAddressOf());
if (FAILED(hr)) {
return false;
}
// Set the input layout
ID3D11InputLayout* vertexLayout;
D3D11_INPUT_ELEMENT_DESC layout[] = {
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0,
D3D11_INPUT_PER_VERTEX_DATA, 0},
};
hr = device->CreateInputLayout(layout, _countof(layout), g_triangle_vs,
sizeof(g_triangle_vs), &vertexLayout);
if (SUCCEEDED(hr)) {
context->IASetInputLayout(vertexLayout);
vertexLayout->Release();
vertexLayout = nullptr;
}
// Create vertex buffer
SimpleVertex vertices[3];
vertices[0].Pos.x = 0.0f;
vertices[0].Pos.y = 0.5f;
vertices[0].Pos.z = 0.5f;
vertices[1].Pos.x = 0.5f;
vertices[1].Pos.y = -0.5f;
vertices[1].Pos.z = 0.5f;
vertices[2].Pos.x = -0.5f;
vertices[2].Pos.y = -0.5f;
vertices[2].Pos.z = 0.5f;
CD3D11_BUFFER_DESC bufferDesc(sizeof(SimpleVertex) * _countof(vertices),
D3D11_BIND_VERTEX_BUFFER);
D3D11_SUBRESOURCE_DATA subResData = {vertices, 0, 0};
hr = device->CreateBuffer(&bufferDesc, &subResData, &g_vertexBuffer);
// Describe how depth and stencil tests should be performed.
// In particular, that they should not be for this 2D example
// where we want to render a triangle no matter what.
D3D11_DEPTH_STENCIL_DESC depthStencilDescription = {};
depthStencilDescription.DepthEnable = false;
depthStencilDescription.StencilEnable = false;
// Create depth stencil state and set it.
hr = device->CreateDepthStencilState(&depthStencilDescription,
&g_depthStencilState);
if (FAILED(hr)) {
std::cerr << "SetupRendering: Could not create depth/stencil state"
<< std::endl;
return false;
}
return true;
}
bool D11State::init() {
HRESULT hr;
ID3D11Texture2D* pBackBuffer = NULL;
hr = pSwapChain->GetBuffer(0, __uuidof(*pBackBuffer), (LPVOID*)&pBackBuffer);
if (FAILED(hr)) {
ods("D3D11: pSwapChain->GetBuffer failure!");
return false;
}
hr = pDevice->CreateDeferredContext(0, &pDeviceContext);
// Depending on the device settings a deferred context may not be createable
// for example if it is a SINGLETHREADED device.
// (See http://msdn.microsoft.com/en-us/library/windows/desktop/ff476505%28v=vs.85%29.aspx)
// We handle the expected failure and failure fallback in the same way -
// by trying to use an immediate context.
if (FAILED(hr) || !pDeviceContext) {
ods("D3D11: Failed to create DeferredContext (0x%x). Getting ImmediateContext", hr);
pDevice->GetImmediateContext(&pDeviceContext);
D11CreateStateBlock(pDeviceContext, &pOrigStateBlock);
D11CreateStateBlock(pDeviceContext, &pMyStateBlock);
pOrigStateBlock->Capture();
bDeferredContext = false;
} else {
bDeferredContext = true;
}
D3D11_TEXTURE2D_DESC backBufferSurfaceDesc;
pBackBuffer->GetDesc(&backBufferSurfaceDesc);
ZeroMemory(&vp, sizeof(vp));
vp.Width = static_cast<float>(backBufferSurfaceDesc.Width);
vp.Height = static_cast<float>(backBufferSurfaceDesc.Height);
vp.MinDepth = 0;
vp.MaxDepth = 1;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
pDeviceContext->RSSetViewports(1, &vp);
hr = pDevice->CreateRenderTargetView(pBackBuffer, NULL, &pRTV);
if (FAILED(hr)) {
ods("D3D11: pDevice->CreateRenderTargetView failed!");
return false;
}
pDeviceContext->OMSetRenderTargets(1, &pRTV, NULL);
// Settings for an "over" operation.
// https://en.wikipedia.org/w/index.php?title=Alpha_compositing&oldid=580659153#Description
D3D11_BLEND_DESC blend;
ZeroMemory(&blend, sizeof(blend));
blend.RenderTarget[0].BlendEnable = TRUE;
blend.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;
blend.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blend.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blend.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blend.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
blend.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blend.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
pDevice->CreateBlendState(&blend, &pBlendState);
if (FAILED(hr)) {
ods("D3D11: pDevice->CreateBlendState failed!");
return false;
}
pDeviceContext->OMSetBlendState(pBlendState, NULL, 0xffffffff);
hr = pDevice->CreateVertexShader(g_vertex_shader, sizeof(g_vertex_shader), NULL, &pVertexShader);
if (FAILED(hr)) {
ods("D3D11: Failed to create vertex shader.");
return false;
}
hr = pDevice->CreatePixelShader(g_pixel_shader, sizeof(g_pixel_shader), NULL, &pPixelShader);
if (FAILED(hr)) {
ods("D3D11: Failed to create pixel shader.");
return false;
}
pTexture = NULL;
pSRView = NULL;
// Define the input layout
D3D11_INPUT_ELEMENT_DESC layout[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
hr = pDevice->CreateInputLayout(layout, ARRAY_NUM_ELEMENTS(layout), g_vertex_shader, sizeof(g_vertex_shader), &pVertexLayout);
if (FAILED(hr)) {
ods("D3D11: pDevice->CreateInputLayout failure!");
return false;
}
pDeviceContext->IASetInputLayout(pVertexLayout);
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_DYNAMIC;
bd.ByteWidth = VERTEXBUFFER_SIZE;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bd.MiscFlags = 0;
hr = pDevice->CreateBuffer(&bd, NULL, &pVertexBuffer);
if (FAILED(hr)) {
ods("D3D11: pDevice->CreateBuffer failure!");
return false;
}
DWORD indices[] = {
0,1,3,
1,2,3,
};
ZeroMemory(&bd, sizeof(bd));
bd.Usage = D3D11_USAGE_IMMUTABLE;
bd.ByteWidth = sizeof(DWORD) * 6;
bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA InitData;
ZeroMemory(&InitData, sizeof(InitData));
InitData.pSysMem = indices;
hr = pDevice->CreateBuffer(&bd, &InitData, &pIndexBuffer);
if (FAILED(hr)) {
ods("D3D11: pDevice->CreateBuffer failure!");
return false;
}
// Set index buffer
pDeviceContext->IASetIndexBuffer(pIndexBuffer, DXGI_FORMAT_R32_UINT, 0);
// Set primitive topology
pDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
if (!bDeferredContext) {
pMyStateBlock->Capture();
pOrigStateBlock->Apply();
}
pBackBuffer->Release();
return true;
}
bool ShadowMappingShader::InitializeShader(const char * i_vsFileName, const char * i_psFileName)
{
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[3];
unsigned int numElements;
D3D11_SAMPLER_DESC samplerDesc;
D3D11_BUFFER_DESC matrixBufferDesc;
D3D11_BUFFER_DESC lightBufferDesc;
D3D11_BUFFER_DESC lightBufferDesc2;
// Initialize the pointers this function will use to null.
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
// Compile the vertex shader code.
result = D3DX11CompileFromFile(i_vsFileName, NULL, NULL, "ShadowVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL,
&vertexShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if (errorMessage)
{
outputShaderErrorMessage(errorMessage, i_vsFileName);
}
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
MessageBox(System::Window::GetWindwsHandle(), i_vsFileName, "Missing Shader File", MB_OK);
}
return false;
}
// Compile the pixel shader code.
result = D3DX11CompileFromFile(i_psFileName, NULL, NULL, "ShadowPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL,
&pixelShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if (errorMessage)
{
outputShaderErrorMessage(errorMessage, i_psFileName);
}
// If there was nothing in the error message then it simply could not find the file itself.
else
{
MessageBox(System::Window::GetWindwsHandle(), i_psFileName, "Missing Shader File", MB_OK);
}
return false;
}
ID3D11Device* device = GraphicsDX::GetDevice();
// Create the vertex shader from the buffer.
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
return false;
}
// Create the pixel shader from the buffer.
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
return false;
}
// Create the vertex input layout description.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
polygonLayout[2].SemanticName = "NORMAL";
polygonLayout[2].SemanticIndex = 0;
polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[2].InputSlot = 0;
polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[2].InstanceDataStepRate = 0;
// Get a count of the elements in the layout.
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// Create the vertex input layout.
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(),
&m_layout);
if (FAILED(result))
{
return false;
}
// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
// Create a wrap texture sampler state description.
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
// Create the texture sampler state.
result = device->CreateSamplerState(&samplerDesc, &m_sampleStateWrap);
if (FAILED(result))
{
return false;
}
// Create a clamp texture sampler state description.
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
// Create the texture sampler state.
result = device->CreateSamplerState(&samplerDesc, &m_sampleStateClamp);
if (FAILED(result))
{
return false;
}
// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
return false;
}
// Setup the description of the light dynamic constant buffer that is in the pixel shader.
lightBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
lightBufferDesc.ByteWidth = sizeof(LightBufferType);
lightBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
lightBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
lightBufferDesc.MiscFlags = 0;
lightBufferDesc.StructureByteStride = 0;
// Create the constant buffer pointer so we can access the pixel shader constant buffer from within this class.
result = device->CreateBuffer(&lightBufferDesc, NULL, &m_lightBuffer);
if (FAILED(result))
{
return false;
}
// Setup the description of the light dynamic constant buffer that is in the vertex shader.
lightBufferDesc2.Usage = D3D11_USAGE_DYNAMIC;
lightBufferDesc2.ByteWidth = sizeof(LightBufferType2);
lightBufferDesc2.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
lightBufferDesc2.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
lightBufferDesc2.MiscFlags = 0;
lightBufferDesc2.StructureByteStride = 0;
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
result = device->CreateBuffer(&lightBufferDesc2, NULL, &m_lightBuffer2);
if (FAILED(result))
{
return false;
}
return true;
}
void
D3D11hud::Init(int width, int height)
{
Hud::Init(width, height);
ID3D11Device *device = NULL;
_deviceContext->GetDevice(&device);
// define font texture
D3D11_TEXTURE2D_DESC texDesc;
texDesc.Width = FONT_TEXTURE_WIDTH;
texDesc.Height = FONT_TEXTURE_HEIGHT;
texDesc.MipLevels = 1;
texDesc.ArraySize = 1;
texDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
texDesc.SampleDesc.Count = 1;
texDesc.SampleDesc.Quality = 0;
texDesc.Usage = D3D11_USAGE_DEFAULT;
texDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
texDesc.CPUAccessFlags = 0;
texDesc.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA subData;
subData.pSysMem = font_image;
subData.SysMemPitch = FONT_TEXTURE_WIDTH*4;
subData.SysMemSlicePitch = FONT_TEXTURE_WIDTH*FONT_TEXTURE_HEIGHT*4;
HRESULT hr = device->CreateTexture2D(&texDesc, &subData, &_fontTexture);
assert(_fontTexture);
// shader resource view
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
ZeroMemory(&srvDesc, sizeof(srvDesc));
srvDesc.Format = texDesc.Format;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MostDetailedMip = 0;
srvDesc.Texture2D.MipLevels = texDesc.MipLevels;
device->CreateShaderResourceView(_fontTexture, &srvDesc, &_shaderResourceView);
assert(_shaderResourceView);
D3D11_SAMPLER_DESC samplerDesc;
ZeroMemory(&samplerDesc, sizeof(samplerDesc));
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = samplerDesc.AddressV = samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
device->CreateSamplerState(&samplerDesc, &_samplerState);
assert(_samplerState);
ID3DBlob* pVSBlob;
ID3DBlob* pPSBlob;
pVSBlob = d3d11CompileShader(s_VS, "vs_main", "vs_4_0");
pPSBlob = d3d11CompileShader(s_PS, "ps_main", "ps_4_0");
assert(pVSBlob);
assert(pPSBlob);
D3D11_INPUT_ELEMENT_DESC inputElementDesc[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, sizeof(float)*2, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, sizeof(float)*5, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
device->CreateInputLayout(inputElementDesc, ARRAYSIZE(inputElementDesc),
pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(),
&_inputLayout);
assert(_inputLayout);
device->CreateVertexShader(pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(),
NULL, &_vertexShader);
assert(_vertexShader);
device->CreatePixelShader(pPSBlob->GetBufferPointer(),
pPSBlob->GetBufferSize(),
NULL, &_pixelShader);
assert(_pixelShader);
D3D11_RASTERIZER_DESC rasDesc;
rasDesc.FillMode = D3D11_FILL_SOLID;
rasDesc.CullMode = D3D11_CULL_NONE;
rasDesc.FrontCounterClockwise = FALSE;
rasDesc.DepthBias = 0;
rasDesc.DepthBiasClamp = 0;
rasDesc.SlopeScaledDepthBias = 0.0f;
rasDesc.DepthClipEnable = FALSE;
rasDesc.ScissorEnable = FALSE;
rasDesc.MultisampleEnable = FALSE;
rasDesc.AntialiasedLineEnable = FALSE;
device->CreateRasterizerState(&rasDesc, &_rasterizerState);
assert(_rasterizerState);
// constant buffer
D3D11_BUFFER_DESC cbDesc;
cbDesc.Usage = D3D11_USAGE_DYNAMIC;
cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
cbDesc.MiscFlags = 0;
cbDesc.ByteWidth = sizeof(CB_HUD_PROJECTION);
device->CreateBuffer(&cbDesc, NULL, &_constantBuffer);
assert(_constantBuffer);
}
// WinMain
int APIENTRY _tWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow )
{
HRESULT hr;
// ウィンドウクラスを登録
WNDCLASSEX wcex = {
sizeof( WNDCLASSEX ), // cbSize
CS_HREDRAW | CS_VREDRAW, // style
WndProc, // lpfnWndProc
0, // cbClsExtra
0, // cbWndExtra
hInstance, // hInstance
NULL, // hIcon
NULL, // hCursor
( HBRUSH )( COLOR_WINDOW + 1 ), // hbrBackGround
NULL, // lpszMenuName
g_className, // lpszClassName
NULL // hIconSm
};
if ( ! RegisterClassEx( &wcex ) )
{
MessageBox( NULL, _T( "失敗: RegisterClassEx()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "RegisterClassEx: ok\n" ) );
// ウィンドウサイズを計算
RECT r = { 0, 0, 800, 450 }; // 800x450 (16:9)
if ( ! AdjustWindowRect( &r, WS_OVERLAPPEDWINDOW, FALSE ) )
{
MessageBox( NULL, _T( "失敗: AdjustWindowRect()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "AdjustWindowRect: ok (%d, %d)－(%d, %d)\n" ), r.left, r.top, r.right, r.bottom );
// ウィンドウ生成
HWND hWnd;
hWnd = CreateWindow( g_className,
g_windowName,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
0,
r.right - r.left,
r.bottom - r.top,
NULL,
NULL,
hInstance,
NULL );
if ( hWnd == NULL )
{
MessageBox( NULL, _T( "失敗: CreateWindow()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "CreateWindow: ok\n" ) );
// ウィンドウ表示
ShowWindow(hWnd, nCmdShow);
dtprintf( _T( "ShowWindow: ok\n" ) );
// スワップチェイン設定
DXGI_SWAP_CHAIN_DESC scDesc = {
{
1280, // BufferDesc.Width
720, // BufferDesc.Height
{
60, // BufferDesc.RefreshRate.Numerator
1 // BufferDesc.RefreshRate.Denominator
},
DXGI_FORMAT_R16G16B16A16_FLOAT, // BufferDesc.Format
DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED, // BufferDesc.ScanlineOrdering
DXGI_MODE_SCALING_CENTERED // BufferDesc.Scaling
},
{
1, // SampleDesc.Count
0 // SampleDesc.Quality
},
DXGI_USAGE_RENDER_TARGET_OUTPUT, // BufferUsage
1, // BufferCount
hWnd, // OutputWindow
TRUE, // Windowed
DXGI_SWAP_EFFECT_DISCARD, // SwapEffect
DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH // Flags
};
// Direct3D11 デバイス・デバイスコンテキスト・スワップチェーンを生成
ID3D11Device * pDevice = NULL;
ID3D11DeviceContext * pDeviceContext = NULL;
IDXGISwapChain * pSwapChain = NULL;
D3D_FEATURE_LEVEL feature;
hr = D3D11CreateDeviceAndSwapChain( NULL,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
0,
NULL,
0,
D3D11_SDK_VERSION,
&scDesc,
&pSwapChain,
&pDevice,
&feature,
&pDeviceContext );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: D3D11CreateDeviceAndSwapChain()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "D3D11CreateDeviceAndSwapChain: ok (pDevice: 0x%p, pDeviceContext: 0x%p, pSwapChain: 0x%p, feature: 0x%4x)\n" ),
pDevice,
pDeviceContext,
pSwapChain,
( int ) feature );
// バックバッファテクスチャを取得
ID3D11Texture2D * pBackBuffer = NULL;
hr = pSwapChain->GetBuffer( 0, __uuidof( pBackBuffer ), reinterpret_cast< void ** >( &pBackBuffer ) );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: IDXGISwapChain::GetBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "IDXGISwapChain::GetBuffer: ok (pBackBuffer: 0x%p)\n" ), pBackBuffer );
// レンダーターゲットビューを生成
ID3D11RenderTargetView * pRenderTargetView = NULL;
hr = pDevice->CreateRenderTargetView( pBackBuffer, NULL, &pRenderTargetView );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateRenderTargetView()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateRenderTargetView: ok (pRenderTargetView: 0x%p)\n" ), pRenderTargetView );
// デプス・ステンシルバッファとなるテクスチャを生成
D3D11_TEXTURE2D_DESC depthStencilBufferDesc = {
1280, // Width
720, // Height
1, // MipLevels
1, // ArraySize
DXGI_FORMAT_D32_FLOAT, // Format
{
1, // SampleDesc.Count
0 // SampleDesc.Quality
},
D3D11_USAGE_DEFAULT, // Usage
D3D11_BIND_DEPTH_STENCIL, // BindFlags
0, // CPUAccessFlags
0 // MiscFlags
};
ID3D11Texture2D * pDepthStencilBuffer = NULL;
hr = pDevice->CreateTexture2D( &depthStencilBufferDesc, NULL, &pDepthStencilBuffer );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateTexture2D()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateTexture2D: ok (pDepthStencilBuffer: 0x%p)\n" ), pDepthStencilBuffer );
// デプス・ステンシルビューを生成
ID3D11DepthStencilView * pDepthStencilView = NULL;
hr = pDevice->CreateDepthStencilView( pDepthStencilBuffer, NULL, &pDepthStencilView );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateDepthStencilView()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateDepthStencilView: ok (pDepthStencilView: 0x%p)\n" ), pDepthStencilView );
// レンダーターゲットビューとデプス・ステンシルビューをバインド
ID3D11RenderTargetView * pRenderTargetViews[] = { pRenderTargetView };
pDeviceContext->OMSetRenderTargets( 1, pRenderTargetViews, pDepthStencilView );
dtprintf( _T( "ID3D11DeviceContext::OMSetRenderTargets: ok\n" ) );
// バックバッファはもうここでは使わない
COM_SAFE_RELEASE( pBackBuffer );
// ビューポートをバインド
D3D11_VIEWPORT viewport = {
0.0f, // TopLeftX
0.0f, // TopLeftY
1280.0f, // Width
720.0f, // Height
0.0f, // MinDepth
1.0f // MaxDepth
};
pDeviceContext->RSSetViewports( 1, &viewport );
dtprintf( _T( "ID3D11DeviceContext::RSSetViewports: ok\n" ) );
// 頂点データ
float vertices[ 8 ][ 7 ] = {
// Xaxis Yaxis Zaxis 赤 緑 青 Alpha
{ -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f }, // 手前左上
{ 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f }, // 手前右上
{ 0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f }, // 手前右下
{ -0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f }, // 手前左下
{ -0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f }, // 奥左上
{ 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 1.0f, 1.0f }, // 奥右上
{ 0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f }, // 奥右下
{ -0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f } // 奥左下
};
// 頂点バッファを生成
D3D11_BUFFER_DESC vertexBufferDesc = {
sizeof( vertices ), // ByteWidth
D3D11_USAGE_DEFAULT, // Usage
D3D11_BIND_VERTEX_BUFFER, // BindFlags
0, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteStride
};
D3D11_SUBRESOURCE_DATA vertexResourceData = { vertices };
ID3D11Buffer * pVertexBuffer = NULL;
hr = pDevice->CreateBuffer( &vertexBufferDesc, &vertexResourceData, &pVertexBuffer );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pVertexBuffer: 0x%p)\n" ), pVertexBuffer );
// 頂点バッファをバインド
UINT strides[] = { sizeof( float ) * 7 };
UINT offsets[] = { 0 };
pDeviceContext->IASetVertexBuffers( 0, 1, &pVertexBuffer, strides, offsets );
dtprintf( _T( "ID3D11DeviceContext::IASetVertexBuffers: ok\n" ) );
// インデックスデータ
unsigned int indices[] = { 0, 1, 2, 0, 2, 3, // 手前
4, 0, 3, 4, 3, 7, // 左
1, 5, 6, 1, 6, 2, // 右
0, 4, 5, 0, 5, 1, // 上
2, 6, 7, 2, 7, 3, // 下
5, 4, 7, 5, 7, 6
}; // 裏
// インデックスバッファを生成
D3D11_BUFFER_DESC indexBufferDesc = {
sizeof( indices ), // ByteWidth
D3D11_USAGE_DEFAULT, // Usage
D3D11_BIND_INDEX_BUFFER, // BindFlags
0, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteStride
};
D3D11_SUBRESOURCE_DATA indexResourceData = { indices };
ID3D11Buffer * pIndexBuffer = NULL;
hr = pDevice->CreateBuffer( &indexBufferDesc, &indexResourceData, &pIndexBuffer );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pIndexBuffer: 0x%p)\n" ), pIndexBuffer );
// インデックスバッファをバインド
pDeviceContext->IASetIndexBuffer( pIndexBuffer, DXGI_FORMAT_R32_UINT, 0 );
dtprintf( _T( "ID3D11DeviceContext::IASetIndexBuffer: ok\n" ) );
// プリミティブタイプを設定
pDeviceContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
dtprintf( _T( "ID3D11DeviceContext::IASetPrimitiveTopology: ok\n" ) );
// 頂点シェーダ用の定数バッファを作成
D3D11_BUFFER_DESC VSConstantBufferDesc = {
sizeof( D3DXMATRIX ) * 3, // ByteWidth
D3D11_USAGE_DYNAMIC, // Usage
D3D11_BIND_CONSTANT_BUFFER, // BindFlags
D3D11_CPU_ACCESS_WRITE, // CPUAccessFlags
0, // MiscFlags
0 // StructureByteStride
};
ID3D11Buffer * pVSConstantBuffer = NULL;
hr = pDevice->CreateBuffer( &VSConstantBufferDesc, NULL, &pVSConstantBuffer );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pVSConstantBuffer: 0x%p)\n" ), pVSConstantBuffer );
// 定数バッファをバインド
pDeviceContext->VSSetConstantBuffers( 0, 1, &pVSConstantBuffer );
dtprintf( _T( "ID3D11DeviceContext::VSSetConstantBuffers: ok\n" ) );
// 頂点シェーダを作成
ID3D11VertexShader * pVertexShader = NULL;
hr = pDevice->CreateVertexShader( g_vs_perspective, sizeof( g_vs_perspective ), NULL, &pVertexShader );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateVertexShader()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateVertexShader: ok (pVertexShader: 0x%p)\n" ), pVertexShader );
// ピクセルシェーダを作成
ID3D11PixelShader * pPixelShader = NULL;
hr = pDevice->CreatePixelShader( g_ps_constant, sizeof( g_ps_constant ), NULL, &pPixelShader );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreatePixelShader()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreatePixelShader: ok (pPixelShader: 0x%p)\n" ), pPixelShader );
// シェーダをバインド
pDeviceContext->VSSetShader( pVertexShader, NULL, 0 );
dtprintf( _T( "ID3D11DeviceContext::VSSetShader: ok\n" ) );
pDeviceContext->PSSetShader( pPixelShader, NULL, 0 );
dtprintf( _T( "ID3D11DeviceContext::PSSetShader: ok\n" ) );
pDeviceContext->GSSetShader( NULL, NULL, 0 );
pDeviceContext->HSSetShader( NULL, NULL, 0 );
pDeviceContext->DSSetShader( NULL, NULL, 0 );
// 入力エレメント記述子
D3D11_INPUT_ELEMENT_DESC verticesDesc[] = {
{ "IN_POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "IN_COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, sizeof(float)*3, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
// 入力レイアウトを生成
ID3D11InputLayout * pInputLayout = NULL;
hr = pDevice->CreateInputLayout( verticesDesc, 2, g_vs_perspective, sizeof( g_vs_perspective ), &pInputLayout );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateInputLayout()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateInputLayout: ok (pInputLayout: 0x%p)\n" ), pInputLayout );
// 入力レイアウトをバインド
pDeviceContext->IASetInputLayout( pInputLayout );
dtprintf( _T( "ID3D11DeviceContext::IASetInputLayout: ok\n" ) );
// ラスタライザステートを生成
D3D11_RASTERIZER_DESC rasterizerStateDesc = {
D3D11_FILL_SOLID, // FillMode
// D3D11_FILL_WIREFRAME, // FillMode (ワイヤーフレーム表示)
D3D11_CULL_BACK, // CullMode
// D3D11_CULL_NONE, // CullMode (カリングなし)
FALSE, // FrontCounterClockwise
0, // DepthBias
0.0f, // DepthBiasClamp
0.0f, // SlopeScaledDepthBias
TRUE, // DepthClipEnable
FALSE, // ScissorEnable
FALSE, // MultisampleEnable
FALSE // AntialiasedLineEnable
};
ID3D11RasterizerState * pRasterizerState = NULL;
hr = pDevice->CreateRasterizerState( &rasterizerStateDesc, &pRasterizerState );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateRasterizerState()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateRasterizerState: ok (pRasterizerState: 0x%p)\n" ), pRasterizerState );
// ラスタライザステートをバインド
pDeviceContext->RSSetState( pRasterizerState );
dtprintf( _T( "ID3D11DeviceContext::RSSetState: ok\n" ) );
// デプス・ステンシルステートを生成
D3D11_DEPTH_STENCIL_DESC depthStencilStateDesc = {
TRUE, // DepthEnable
D3D11_DEPTH_WRITE_MASK_ALL, // DepthWriteMask
D3D11_COMPARISON_LESS, // DepthFunc
FALSE, // StencilEnable
D3D11_DEFAULT_STENCIL_READ_MASK, // StencilReadMask
D3D11_DEFAULT_STENCIL_WRITE_MASK, // StencilWriteMask
{
D3D11_STENCIL_OP_KEEP, // FrontFace.StencilFailOp
D3D11_STENCIL_OP_KEEP, // FrontFace.StencilDepthFailOp
D3D11_STENCIL_OP_KEEP, // FrontFace.StencilPassOp
D3D11_COMPARISON_ALWAYS // FrontFace.StencilFunc
},
{
D3D11_STENCIL_OP_KEEP, // BackFace.StencilFailOp
D3D11_STENCIL_OP_KEEP, // BackFace.StencilDepthFailOp
D3D11_STENCIL_OP_KEEP, // BackFace.StencilPassOp
D3D11_COMPARISON_ALWAYS // BackFace.StencilFunc
}
};
ID3D11DepthStencilState * pDepthStencilState = NULL;
hr = pDevice->CreateDepthStencilState( &depthStencilStateDesc, &pDepthStencilState );
if ( FAILED( hr ) )
{
MessageBox( NULL, _T( "失敗: ID3D11Device::CreateDepthStencilState()" ), _T( "エラー" ), MB_OK | MB_ICONERROR );
return 0;
}
dtprintf( _T( "ID3D11Device::CreateDepthStencilState: ok (pDepthStencilState: 0x%p)\n" ), pDepthStencilState );
// デプス・ステンシルステートをバインド
pDeviceContext->OMSetDepthStencilState( pDepthStencilState, 0 );
dtprintf( _T( "ID3D11DeviceContext::OMSetDepthStencilState: ok\n" ) );
MSG msg;
while ( 1 )
{
// メッセージを取得
if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
if ( msg.message == WM_QUIT )
{
dtprintf( _T( "PeekMessage: WM_QUIT\n" ) );
break;
}
// メッセージ処理
DispatchMessage( &msg );
}
else
{
HRESULT hr;
static unsigned int count = 0;
float theta = ( count++ / 200.0f ) * ( 3.141593f / 2.0f );
// World-View-Projection 行列をそれぞれ生成
D3DXMATRIX world, view, projection;
D3DXMatrixIdentity( &world );
const D3DXVECTOR3 eye( 1.8f * 1.414214f * -cosf( theta ), 1.8f, 1.8f * 1.414214f * sinf( theta ) );
const D3DXVECTOR3 at( 0.0f, 0.0f, 0.0f );
const D3DXVECTOR3 up( 0.0f, 1.0f, 0.0f );
D3DXMatrixLookAtRH( &view, &eye, &at, &up );
D3DXMatrixPerspectiveFovRH( &projection, 3.141593f / 4.0f, 1280.0f / 720.0f, 1.0f, 10000.0f );
// 頂点シェーダ用定数バッファへアクセス
D3D11_MAPPED_SUBRESOURCE mapped;
hr = pDeviceContext->Map( pVSConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped );
if ( SUCCEEDED( hr ) )
{
D3DXMATRIX * mapped_m = static_cast< D3DXMATRIX * >( mapped.pData );
mapped_m[0] = world;
mapped_m[1] = view;
mapped_m[2] = projection;
// 後始末
pDeviceContext->Unmap( pVSConstantBuffer, 0 );
}
// レンダーターゲットビューをクリア
const float clear[ 4 ] = { 0.0f, 0.0f, 0.3f, 1.0f }; // RGBA
pDeviceContext->ClearRenderTargetView( pRenderTargetView, clear );
// デプス・ステンシルビューをクリア
pDeviceContext->ClearDepthStencilView( pDepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0 );
// 描画
pDeviceContext->DrawIndexed( 36, 0, 0 );
pSwapChain->Present( 1, 0 );
// ちょっとだけ待つ
Sleep( 5 );
}
}
// シェーダをアンバインド
pDeviceContext->VSSetShader( NULL, NULL, 0 );
pDeviceContext->PSSetShader( NULL, NULL, 0 );
// デバイス・リソース解放
COM_SAFE_RELEASE( pDepthStencilState );
COM_SAFE_RELEASE( pRasterizerState );
COM_SAFE_RELEASE( pInputLayout );
COM_SAFE_RELEASE( pPixelShader );
COM_SAFE_RELEASE( pVertexShader );
COM_SAFE_RELEASE( pVSConstantBuffer );
COM_SAFE_RELEASE( pIndexBuffer );
COM_SAFE_RELEASE( pVertexBuffer );
COM_SAFE_RELEASE( pDepthStencilView );
COM_SAFE_RELEASE( pDepthStencilBuffer );
COM_SAFE_RELEASE( pRenderTargetView );
COM_SAFE_RELEASE( pSwapChain );
COM_SAFE_RELEASE( pDeviceContext );
COM_SAFE_RELEASE( pDevice );
return msg.wParam;
}
void BaseShader::Initialize(std::string vsFile, std::string psFile)
{
if (m_bInit)
{
LogManager::GetInstance().Warning("You've already initialized this Shader (%p)", this);
return;
}
HRESULT result;
ID3D10Blob* errorMessage = nullptr;
ID3D10Blob* vertexShaderBuffer = nullptr;
ID3D10Blob* pixelShaderBuffer = nullptr;
ID3D11Device* device = Application::GetInstance().GetGraphicsDevice()->GetDXSystem()->GetDevice();
result = D3DX11CompileFromFile(vsFile.c_str(), nullptr, nullptr, "main", "vs_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, nullptr, &vertexShaderBuffer, &errorMessage, nullptr);
if (FAILED(result))
{
if (errorMessage)
{
LogManager::GetInstance().Trace("[HLSL] %s", (const char*)errorMessage->GetBufferPointer());
}
else
{
LogManager::GetInstance().Warning("InitializeShader missing shader file (%s)", vsFile);
}
return;
}
result = D3DX11CompileFromFile(psFile.c_str(), nullptr, nullptr, "main", "ps_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, nullptr, &pixelShaderBuffer, &errorMessage, nullptr);
if (FAILED(result))
{
if (errorMessage)
{
LogManager::GetInstance().Trace("[HLSL] %s", (const char*)errorMessage->GetBufferPointer());
}
else
{
LogManager::GetInstance().Warning("InitializeShader missing shader file (%s)", psFile);
}
return;
}
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), nullptr, &m_vertexShader);
if (FAILED(result))
{
LogManager::GetInstance().Error("InitializeShader could not create vertex shader");
return;
}
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), nullptr, &m_pixelShader);
if (FAILED(result))
{
LogManager::GetInstance().Error("InitializeShader could not create pixel shader");
return;
}
std::vector<D3D11_INPUT_ELEMENT_DESC> polygonLayout;
ID3D11ShaderReflection* vertexShaderReflection = nullptr;
ID3D11ShaderReflection* pixelShaderReflection = nullptr;
result = D3DReflect(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&vertexShaderReflection);
if (FAILED(result))
{
LogManager::GetInstance().Error("BaseShader: Could not peek into the VertexShader");
return;
}
result = D3DReflect(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), IID_ID3D11ShaderReflection, (void**)&pixelShaderReflection);
if (FAILED(result))
{
LogManager::GetInstance().Error("BaseShader: Could not peek into the PixelShader");
return;
}
D3D11_SHADER_DESC pixelDesc;
pixelShaderReflection->GetDesc(&pixelDesc);
for (unsigned int i = 0; i < pixelDesc.BoundResources; i++)
{
D3D11_SHADER_INPUT_BIND_DESC inputDesc;
pixelShaderReflection->GetResourceBindingDesc(i, &inputDesc);
//BindCount is the size of the array
if (inputDesc.Type == D3D_SIT_TEXTURE)
{
m_supportedTextures[inputDesc.BindPoint] = true;
}
}
D3D11_SHADER_DESC shaderDesc;
vertexShaderReflection->GetDesc(&shaderDesc);
for (unsigned int i = 0; i < shaderDesc.InputParameters; i++)
{
D3D11_SIGNATURE_PARAMETER_DESC paramDesc;
vertexShaderReflection->GetInputParameterDesc(i, ¶mDesc);
D3D11_INPUT_ELEMENT_DESC elementDesc;
elementDesc.SemanticName = paramDesc.SemanticName;
elementDesc.SemanticIndex = paramDesc.SemanticIndex;
elementDesc.InputSlot = 0;
elementDesc.AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
elementDesc.InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
elementDesc.InstanceDataStepRate = 0;
if (paramDesc.Mask == 1)
{
switch (paramDesc.ComponentType)
{
case D3D_REGISTER_COMPONENT_UINT32:
elementDesc.Format = DXGI_FORMAT_R32_UINT;
break;
case D3D_REGISTER_COMPONENT_SINT32:
elementDesc.Format = DXGI_FORMAT_R32_SINT;
break;
case D3D_REGISTER_COMPONENT_FLOAT32:
elementDesc.Format = DXGI_FORMAT_R32_FLOAT;
break;
default:
LogManager::GetInstance().Error("Shader: Unknown RegisterComponentType, Mask = 1");
return;
}
}
else if (paramDesc.Mask <= 3)
{
switch (paramDesc.ComponentType)
{
case D3D_REGISTER_COMPONENT_UINT32:
elementDesc.Format = DXGI_FORMAT_R32G32_UINT;
break;
case D3D_REGISTER_COMPONENT_SINT32:
elementDesc.Format = DXGI_FORMAT_R32G32_SINT;
break;
case D3D_REGISTER_COMPONENT_FLOAT32:
elementDesc.Format = DXGI_FORMAT_R32G32_FLOAT;
break;
default:
LogManager::GetInstance().Error("Shader: Unknown RegisterComponentType, Mask <= 3");
return;
}
}
else if (paramDesc.Mask <= 7)
{
switch (paramDesc.ComponentType)
{
case D3D_REGISTER_COMPONENT_UINT32:
elementDesc.Format = DXGI_FORMAT_R32G32B32_UINT;
break;
case D3D_REGISTER_COMPONENT_SINT32:
elementDesc.Format = DXGI_FORMAT_R32G32B32_SINT;
break;
case D3D_REGISTER_COMPONENT_FLOAT32:
elementDesc.Format = DXGI_FORMAT_R32G32B32_FLOAT;
break;
default:
LogManager::GetInstance().Error("Shader: Unknown RegisterComponentType, Mask <= 7");
return;
}
}
else if (paramDesc.Mask <= 15)
{
switch (paramDesc.ComponentType)
{
case D3D_REGISTER_COMPONENT_UINT32:
elementDesc.Format = DXGI_FORMAT_R32G32B32A32_UINT;
break;
case D3D_REGISTER_COMPONENT_SINT32:
elementDesc.Format = DXGI_FORMAT_R32G32B32A32_SINT;
break;
case D3D_REGISTER_COMPONENT_FLOAT32:
elementDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
break;
default:
LogManager::GetInstance().Error("Shader: Unknown RegisterComponentType, Mask <= 15");
return;
}
}
polygonLayout.push_back(elementDesc);
}
result = device->CreateInputLayout(&polygonLayout[0], polygonLayout.size(), vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
LogManager::GetInstance().Error("Shader: Failed to create the input layout");
return;
}
vertexShaderReflection->Release();
vertexShaderReflection = nullptr;
pixelShaderReflection->Release();
pixelShaderReflection = nullptr;
D3D11_SAMPLER_DESC samplerDesc;
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
LogManager::GetInstance().Error("InitializeShader could not create the texture sampler state");
return;
}
m_bInit = true;
}
bool MultiTextureShader::InitializeShader(Graphics* graphics,std::wstring vertexShaderFilename,std::wstring pixelShaderFilename)
{
// create a little structure to handle
// shader buffer and size
struct ShaderBuffer
{
unsigned int Size;
void* Buffer;
};
ShaderBuffer vertexBuffer, pixelBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D11_SAMPLER_DESC samplerDesc;
ID3D11Device* device = graphics->GetDevice();
memset(&vertexBuffer,0,sizeof(ShaderBuffer));
memset(&pixelBuffer,0,sizeof(ShaderBuffer));
// load the compiled shaders
vertexBuffer.Buffer = LoadCompiledShader(vertexShaderFilename, vertexBuffer.Size);
pixelBuffer.Buffer = LoadCompiledShader(pixelShaderFilename, pixelBuffer.Size);
// set the shaders
if(FAILED(device->CreateVertexShader(vertexBuffer.Buffer,vertexBuffer.Size,nullptr,&m_vertexShader)))
return false;
if(FAILED(device->CreatePixelShader(pixelBuffer.Buffer,pixelBuffer.Size,nullptr,&m_pixelShader)))
return false;
// create the vertex input layout
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
// get a count of the elements in the layout
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// create the vertex input layout
if(FAILED(device->CreateInputLayout(polygonLayout,numElements,vertexBuffer.Buffer,
vertexBuffer.Size,&m_layout)))
return false;
// released the vertex shader buffer and pixel shader buffers
// since they are no longer needed
delete vertexBuffer.Buffer;
delete pixelBuffer.Buffer;
// initialize our constant buffer
m_matrixBuffer.Initialize(device);
// create a texture sampler state description
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
//memset(&samplerDesc.BorderColor,0,sizeof(FLOAT)*4);
samplerDesc.BorderColor[0] = 0.0f;
samplerDesc.BorderColor[1] = 0.0f;
samplerDesc.BorderColor[2] = 0.0f;
samplerDesc.BorderColor[3] = 0.0f;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
// create the texture sampler
if(FAILED(device->CreateSamplerState(&samplerDesc,&m_sampleState)))
return false;
return true;
}
