//=================================================================================================
axGfxVertexBuffer::axGfxVertexBuffer(axUInt a_uVertexCount, axUInt a_uVertexStride, axCBytes a_pVertexBuffer, axBool a_bDynamic) :
m_uVertexCount(a_uVertexCount), m_uVertexStride(a_uVertexStride), m_bDynamic(a_bDynamic)
{
ID3D11Device* pDevice = axGfxRoot::GetInstance()->GetDevice();
D3D11_BUFFER_DESC oVertexBufferDesc;
oVertexBufferDesc.ByteWidth = a_uVertexCount * a_uVertexStride;
oVertexBufferDesc.Usage = a_bDynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_IMMUTABLE;
oVertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
oVertexBufferDesc.CPUAccessFlags = a_bDynamic ? D3D11_CPU_ACCESS_WRITE : 0;
oVertexBufferDesc.MiscFlags = 0;
oVertexBufferDesc.StructureByteStride = 0;
if(a_pVertexBuffer != NULL)
{
D3D11_SUBRESOURCE_DATA oVertexData;
oVertexData.pSysMem = a_pVertexBuffer;
oVertexData.SysMemPitch = 0;
oVertexData.SysMemSlicePitch = 0;
axAssert(AX_SUCCEEDED(pDevice->CreateBuffer(&oVertexBufferDesc, &oVertexData, &m_pVertexBuffer)),
axL("Failed to create vertex buffer."));
}
else
{
axAssert(a_bDynamic, axL("Static buffers must be initialized."));
axAssert(AX_SUCCEEDED(pDevice->CreateBuffer(&oVertexBufferDesc, NULL, &m_pVertexBuffer)),
axL("Failed to create vertex buffer."));
}
}
gl::Error VertexBuffer11::initialize(unsigned int size, bool dynamicUsage)
{
SafeRelease(mBuffer);
updateSerial();
if (size > 0)
{
ID3D11Device* dxDevice = mRenderer->getDevice();
D3D11_BUFFER_DESC bufferDesc;
bufferDesc.ByteWidth = size;
bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bufferDesc.MiscFlags = 0;
bufferDesc.StructureByteStride = 0;
HRESULT result = dxDevice->CreateBuffer(&bufferDesc, NULL, &mBuffer);
if (FAILED(result))
{
return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate internal vertex buffer of size, %lu.", size);
}
}
mBufferSize = size;
mDynamicUsage = dynamicUsage;
return gl::Error(GL_NO_ERROR);
}
bool D3D11GeometryBuffer::AllocVertexBuffer(unsigned int bytes, bool dynamic)
{
D3D11_BUFFER_DESC desc;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.ByteWidth = bytes;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
desc.MiscFlags = 0;
desc.StructureByteStride = 0;
desc.Usage = dynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT;
ID3D11Device* pDevice = NULL;
m_pContext->GetDevice(&pDevice);
HRESULT ret = pDevice->CreateBuffer(&desc, NULL, &m_pVertexBuffer);
if(FAILED(ret))
{
pDevice->Release();
return false;
}
pDevice->Release();
return true;
}
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 VertexBuffer::init(VertexBuffer& obj, size_t vertex_count, size_t vertex_size, const void* data)
{
NYX_ASSERT(obj._buffer == nullptr);
ID3D11Device* device = RenderDevice::device();
D3D11_BUFFER_DESC desc;
desc.ByteWidth = vertex_count * vertex_size;
desc.Usage = D3D11_USAGE_IMMUTABLE;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
desc.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA init;
init.pSysMem = data;
init.SysMemPitch = 0;
init.SysMemSlicePitch = 0;
HRESULT hr = device->CreateBuffer(&desc, &init, &obj._buffer);
if (FAILED(hr))
{
term(obj);
return 1;
}
obj._vertex_count = vertex_count;
obj._vertex_size = vertex_size;
return 0;
}
void DX11::Shader::UpdateConstantBuffer(ID3D11DeviceContext * context, std::vector<float> & constants, ID3D11Buffer ** buffer)
{
while((constants.size() % 4) != 0)
{
constants.push_back(0.0f);
}
if(*buffer)
{
context->UpdateSubresource(*buffer, 0, 0, constants.data(), 0, 0);
}
else
{
ID3D11Device * device = 0;
context->GetDevice(&device);
if(device)
{
D3D11_SUBRESOURCE_DATA data = { 0 };
data.pSysMem = constants.data();
device->CreateBuffer(
&CD3D11_BUFFER_DESC(sizeof(float) * constants.size(), D3D11_BIND_CONSTANT_BUFFER),
&data,
buffer);
device->Release();
}
}
}
bool IndexBuffer11::initialize(unsigned int bufferSize, GLenum indexType, bool dynamic)
{
SafeRelease(mBuffer);
updateSerial();
if (bufferSize > 0)
{
ID3D11Device* dxDevice = mRenderer->getDevice();
D3D11_BUFFER_DESC bufferDesc;
bufferDesc.ByteWidth = bufferSize;
bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
bufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bufferDesc.MiscFlags = 0;
bufferDesc.StructureByteStride = 0;
HRESULT result = dxDevice->CreateBuffer(&bufferDesc, NULL, &mBuffer);
if (FAILED(result))
{
return false;
}
}
mBufferSize = bufferSize;
mIndexType = indexType;
mDynamicUsage = dynamic;
return true;
}
bool D3D11GeometryBuffer::AllocIndexBuffer(unsigned int bytes, bool dynamic)
{
// Fill in a buffer description.
D3D11_BUFFER_DESC bufferDesc;
bufferDesc.Usage = dynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT;
bufferDesc.ByteWidth = bytes;
bufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bufferDesc.MiscFlags = 0;
bufferDesc.StructureByteStride = 0;
ID3D11Device* pDevice = NULL;
m_pContext->GetDevice(&pDevice);
if(FAILED(pDevice->CreateBuffer(&bufferDesc, NULL, &m_pIndexBuffer)))
{
pDevice->Release();
return false;
}
pDevice->Release();
return true;
}
bool D3D11RenderData::AllocIndexBuffer(unsigned int bytes, void* pInitData, bool dynamic)
{
// Fill in a buffer description.
D3D11_BUFFER_DESC bufferDesc;
bufferDesc.Usage = dynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT;
bufferDesc.ByteWidth = bytes;
bufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
bufferDesc.CPUAccessFlags = dynamic ? D3D11_CPU_ACCESS_WRITE : 0;
bufferDesc.MiscFlags = 0;
bufferDesc.StructureByteStride = 0;
ID3D11Device* pDevice = NULL;
m_pContext->GetDevice(&pDevice);
D3D11_SUBRESOURCE_DATA InitData = {pInitData, 0, 0,};
if(FAILED(pDevice->CreateBuffer(&bufferDesc, pInitData == NULL ? NULL :&InitData, &m_pIndexBuffer)))
{
pDevice->Release();
return false;
}
pDevice->Release();
return true;
}
bool D3D11RenderData::AllocVertexBuffer(unsigned int bytes, void* pInitData, bool dynamic)
{
D3D11_BUFFER_DESC desc;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.ByteWidth = bytes;
desc.CPUAccessFlags = dynamic ? D3D11_CPU_ACCESS_WRITE : 0;
desc.MiscFlags = 0;
desc.StructureByteStride = 0;
desc.Usage = dynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_DEFAULT;
ID3D11Device* pDevice = NULL;
m_pContext->GetDevice(&pDevice);
D3D11_SUBRESOURCE_DATA InitData = {pInitData, 0, 0,};
HRESULT ret = pDevice->CreateBuffer(&desc, pInitData == NULL ? NULL : &InitData, &m_pVertexBuffer);
if(FAILED(ret))
{
pDevice->Release();
return false;
}
pDevice->Release();
return true;
}
bool VertexBuffer11::initialize(unsigned int size, bool dynamicUsage)
{
if (mBuffer)
{
mBuffer->Release();
mBuffer = NULL;
}
updateSerial();
if (size > 0)
{
ID3D11Device* dxDevice = mRenderer->getDevice();
D3D11_BUFFER_DESC bufferDesc;
bufferDesc.ByteWidth = size;
bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bufferDesc.MiscFlags = 0;
bufferDesc.StructureByteStride = 0;
HRESULT result = dxDevice->CreateBuffer(&bufferDesc, NULL, &mBuffer);
if (FAILED(result))
{
return false;
}
}
mBufferSize = size;
mDynamicUsage = dynamicUsage;
return true;
}
void CGUIFontTTFDX::CreateStaticIndexBuffer(void)
{
if (m_staticIndexBufferCreated)
return;
ID3D11Device* pDevice = g_Windowing.Get3D11Device();
if (!pDevice)
return;
uint16_t index[ELEMENT_ARRAY_MAX_CHAR_INDEX][6];
for (size_t i = 0; i < ELEMENT_ARRAY_MAX_CHAR_INDEX; i++)
{
index[i][0] = 4 * i;
index[i][1] = 4 * i + 1;
index[i][2] = 4 * i + 2;
index[i][3] = 4 * i + 2;
index[i][4] = 4 * i + 3;
index[i][5] = 4 * i + 0;
}
CD3D11_BUFFER_DESC desc(sizeof(index), D3D11_BIND_INDEX_BUFFER, D3D11_USAGE_IMMUTABLE);
D3D11_SUBRESOURCE_DATA initData = { 0 };
initData.pSysMem = index;
if (SUCCEEDED(pDevice->CreateBuffer(&desc, &initData, &m_staticIndexBuffer)))
m_staticIndexBufferCreated = true;
}
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 SpriteShader::CreateBuffers()
{
D3D11_BUFFER_DESC mbd;
mbd.Usage = D3D11_USAGE_DYNAMIC;
mbd.ByteWidth = sizeof(XMMATRIX);
mbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
mbd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
mbd.MiscFlags = 0;
mbd.StructureByteStride = 0;
ID3D11Device* dev = (ID3D11Device*)EngineCore::GetGraphicsAPI()->GetDevice();
dev->CreateBuffer(
&mbd,
NULL,
&gpu_vs_buffer0
);
dev->CreateBuffer(
&mbd,
NULL,
&gpu_vs_buffer1
);
D3D11_SAMPLER_DESC sd;
sd.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
sd.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
sd.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
sd.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
sd.MipLODBias = 0.0f;
sd.MaxAnisotropy = 1;
sd.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
sd.BorderColor[0] = 0;
sd.BorderColor[1] = 0;
sd.BorderColor[2] = 0;
sd.BorderColor[3] = 0;
sd.MinLOD = 0;
sd.MaxLOD = D3D11_FLOAT32_MAX;
dev->CreateSamplerState(
&sd,
&samplerState
);
}
Clear11::Clear11(Renderer11 *renderer)
: mRenderer(renderer), mClearBlendStates(StructLessThan<ClearBlendInfo>), mClearDepthStencilStates(StructLessThan<ClearDepthStencilInfo>),
mVertexBuffer(NULL), mRasterizerState(NULL), mSupportsClearView(false)
{
HRESULT result;
ID3D11Device *device = renderer->getDevice();
D3D11_BUFFER_DESC vbDesc;
vbDesc.ByteWidth = sizeof(d3d11::PositionDepthColorVertex<float>) * 4;
vbDesc.Usage = D3D11_USAGE_DYNAMIC;
vbDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
vbDesc.MiscFlags = 0;
vbDesc.StructureByteStride = 0;
result = device->CreateBuffer(&vbDesc, NULL, &mVertexBuffer);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mVertexBuffer, "Clear11 masked clear vertex buffer");
D3D11_RASTERIZER_DESC rsDesc;
rsDesc.FillMode = D3D11_FILL_SOLID;
rsDesc.CullMode = D3D11_CULL_NONE;
rsDesc.FrontCounterClockwise = FALSE;
rsDesc.DepthBias = 0;
rsDesc.DepthBiasClamp = 0.0f;
rsDesc.SlopeScaledDepthBias = 0.0f;
rsDesc.DepthClipEnable = TRUE;
rsDesc.ScissorEnable = FALSE;
rsDesc.MultisampleEnable = FALSE;
rsDesc.AntialiasedLineEnable = FALSE;
result = device->CreateRasterizerState(&rsDesc, &mRasterizerState);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mRasterizerState, "Clear11 masked clear rasterizer state");
if (renderer->getFeatureLevel() <= D3D_FEATURE_LEVEL_9_3)
{
mFloatClearShader = CreateClearShader(device, DXGI_FORMAT_R32G32B32A32_FLOAT, g_VS_ClearFloat, g_PS_ClearFloat_FL9);
}
else
{
mFloatClearShader = CreateClearShader(device, DXGI_FORMAT_R32G32B32A32_FLOAT, g_VS_ClearFloat, g_PS_ClearFloat);
}
if (renderer->isES3Capable())
{
mUintClearShader = CreateClearShader(device, DXGI_FORMAT_R32G32B32A32_UINT, g_VS_ClearUint, g_PS_ClearUint );
mIntClearShader = CreateClearShader(device, DXGI_FORMAT_R32G32B32A32_SINT, g_VS_ClearSint, g_PS_ClearSint );
}
if (renderer->getDeviceContext1IfSupported())
{
D3D11_FEATURE_DATA_D3D11_OPTIONS d3d11Options;
device->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS, &d3d11Options, sizeof(D3D11_FEATURE_DATA_D3D11_OPTIONS));
mSupportsClearView = (d3d11Options.ClearView != FALSE);
}
}
DXIndexBuffer::DXIndexBuffer(Type t, int32 size) : IndexBuffer(t,size), mInds(NULL){
mIbSize = size;
ID3D11Device* device = static_cast< DXRenderer* >(Engine::instance()->getRenderer())->getDevice();
D3D11_BUFFER_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.ByteWidth = size*t;
desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
device->CreateBuffer(&desc, NULL, &mIb);
}
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;
}
bool CGUIShaderDX::CreateBuffers()
{
ID3D11Device* pDevice = g_Windowing.Get3D11Device();
// create vertex buffer
CD3D11_BUFFER_DESC bufferDesc(sizeof(Vertex) * 4, D3D11_BIND_VERTEX_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
if (FAILED(pDevice->CreateBuffer(&bufferDesc, NULL, &m_pVertexBuffer)))
{
CLog::Log(LOGERROR, __FUNCTION__ " - Failed to create GUI vertex buffer.");
return false;
}
// Create the constant buffer for WVP
size_t buffSize = (sizeof(cbWorld) + 15) & ~15;
CD3D11_BUFFER_DESC cbbd(buffSize, D3D11_BIND_CONSTANT_BUFFER, D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE); // it can change very frequently
if (FAILED(pDevice->CreateBuffer(&cbbd, NULL, &m_pWVPBuffer)))
{
CLog::Log(LOGERROR, __FUNCTION__ " - Failed to create the constant buffer.");
return false;
}
m_bIsWVPDirty = true;
CRect viewPort;
g_Windowing.GetViewPort(viewPort);
// initial data for viewport buffer
m_cbViewPort.TopLeftX = viewPort.x1;
m_cbViewPort.TopLeftY = viewPort.y1;
m_cbViewPort.Width = viewPort.Width();
m_cbViewPort.Height = viewPort.Height();
cbbd.ByteWidth = sizeof(cbViewPort);
D3D11_SUBRESOURCE_DATA initData = { &m_cbViewPort, 0, 0 };
// create viewport buffer
if (FAILED(pDevice->CreateBuffer(&cbbd, &initData, &m_pVPBuffer)))
return false;
return true;
}
bool init(ID3D11Device* const device, ID3D11DeviceContext* const context)
{
m_device = device;
m_context = context;
{
D3D11_BUFFER_DESC desc;
desc.ByteWidth = sizeof(Vertex2D) * VertexBufferSize;
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
desc.MiscFlags = 0;
desc.StructureByteStride = 0;
if (FAILED(m_device->CreateBuffer(&desc, nullptr, &m_vertexBuffer)))
{
return false;
}
}
{
D3D11_BUFFER_DESC desc;
desc.ByteWidth = sizeof(IndexType) * IndexBufferSize;
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
desc.MiscFlags = 0;
desc.StructureByteStride = 0;
if (FAILED(m_device->CreateBuffer(&desc, nullptr, &m_indexBuffer)))
{
return false;
}
}
return true;
}
Grid::Grid(UINT n)
: n(n)
{
ID3D11DeviceContext* devcon = (ID3D11DeviceContext*)EngineCore::GetGraphicsAPI()->GetDeviceContext();
ID3D11Device* dev = (ID3D11Device*)EngineCore::GetGraphicsAPI()->GetDevice();
D3D11_BUFFER_DESC bd;
ZeroMemory(&bd, sizeof(bd));
UINT cntV = 2 * (2 * n + 1);
UINT size = cntV * sizeof(Vertex);
bd.Usage = D3D11_USAGE_DYNAMIC;
bd.ByteWidth = size;
bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
dev->CreateBuffer(
&bd,
NULL,
&buff
);
D3D11_MAPPED_SUBRESOURCE ms;
devcon->Map(
buff,
NULL,
D3D11_MAP_WRITE_DISCARD,
NULL,
&ms
);
vector<Vertex> cpu_buff;
float currX = -(float)n;
for (UINT i = 0; i < cntV / 2; ++i)
{
cpu_buff.push_back(Vertex(XMFLOAT3(currX, (float)n, 0.0f), XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f)));
cpu_buff.push_back(Vertex(XMFLOAT3(currX, -(float)n, 0.0f), XMFLOAT4(0.0f, 1.0f, 0.0f, 1.0f)));
currX += 1.0f;
}
cpu_buff[cntV / 2 - (cntV / 2) % 2].color = XMFLOAT4(0.0f, 0.0f, 1.0f, 1.0f);
cpu_buff[cntV / 2 + !((cntV / 2) % 2)].color = XMFLOAT4(0.0f, 0.0f, 1.0f, 1.0f);
memcpy(ms.pData, cpu_buff.data(), size);
devcon->Unmap(buff, 0);
}
HRESULT Graphics::CreateIndexBuffer(ID3D11Device & device, const vector<GraphicsObject::Index>& indices, ID3D11Buffer *& pBuffer)
{
D3D11_BUFFER_DESC desc;
ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
desc.ByteWidth = indices.size() * sizeof(GraphicsObject::Index);
desc.Usage = D3D11_USAGE::D3D11_USAGE_IMMUTABLE;
desc.BindFlags = D3D11_BIND_FLAG::D3D11_BIND_INDEX_BUFFER;
desc.CPUAccessFlags = 0;
D3D11_SUBRESOURCE_DATA data;
ZeroMemory(&data, sizeof(D3D11_SUBRESOURCE_DATA));
data.pSysMem = indices.data();
return device.CreateBuffer(&desc, &data, &pBuffer);;
}
bool lcMesh::AttachVertexData(D3D11_BUFFER_DESC a_oVertexDesc,D3D11_SUBRESOURCE_DATA a_oVertexData,unsigned int a_uiVertexCount,unsigned int a_uiStride)
{
//Create a Vertex Buffer with the Data of all the verts and a description of the buffer
ID3D11Device* pDevice = lcRenderer::GetDevice();
if(FAILED(pDevice->CreateBuffer(&a_oVertexDesc,&a_oVertexData,&m_pVertexBuffer)))
{
Utilities::Debug_ConsoleWrite("Could Not Create Vertex Buffer \n");
return false;
}
//Set the Amount of Verts in the Buffer
m_uiVertexCount = a_uiVertexCount;
m_uiStride = a_uiStride;
return true;
}
bool lcMesh::AttachIndexData(D3D11_BUFFER_DESC a_oIndexDesc,D3D11_SUBRESOURCE_DATA a_oIndexData,unsigned int a_uiIndexCount,unsigned int a_uiOffset)
{
//Create Index Buffer with a Description of the Indices and their data
ID3D11Device* pDevice = lcRenderer::GetDevice();
if(FAILED(pDevice->CreateBuffer(&a_oIndexDesc,&a_oIndexData,&m_pIndexBuffer)))
{
Utilities::Debug_ConsoleWrite("Could Not Create Index Buffer \n");
return false;
}
//Set the Number of Indices the buffer contains
m_uiIndexCount = a_uiIndexCount;
m_uiOffset = a_uiOffset;
return true;
}
template <class T> void initialize(std::vector<T> const & src,
DXGI_FORMAT format, ID3D11DeviceContext *deviceContext) {
size_t size = src.size()*sizeof(T);
if (size==0) {
buffer = 0;
srv = 0;
return;
}
ID3D11Device *device = 0;
deviceContext->GetDevice(&device);
assert(device);
D3D11_BUFFER_DESC bd;
bd.ByteWidth = (unsigned int)size;
bd.Usage = D3D11_USAGE_IMMUTABLE;
bd.BindFlags = D3D11_BIND_SHADER_RESOURCE;
bd.CPUAccessFlags = 0;
bd.MiscFlags = 0;
bd.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA initData;
initData.pSysMem = &src.at(0);
HRESULT hr = device->CreateBuffer(&bd, &initData, &buffer);
if (FAILED(hr)) {
Far::Error(Far::FAR_RUNTIME_ERROR,
"Error creating compute table buffer\n");
return;
}
D3D11_SHADER_RESOURCE_VIEW_DESC srvd;
ZeroMemory(&srvd, sizeof(srvd));
srvd.Format = format;
srvd.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
srvd.Buffer.FirstElement = 0;
srvd.Buffer.NumElements = (unsigned int)src.size();
hr = device->CreateShaderResourceView(buffer, &srvd, &srv);
if (FAILED(hr)) {
Far::Error(Far::FAR_RUNTIME_ERROR,
"Error creating compute table shader resource view\n");
return;
}
}
void CD3DBuffer::OnDestroyDevice(bool fatal)
{
if (fatal)
{
SAFE_RELEASE(m_buffer);
return;
}
ID3D11Device* pDevice = g_Windowing.Get3D11Device();
ID3D11DeviceContext* pContext = g_Windowing.GetImmediateContext();
if (!pDevice || !pContext || !m_buffer)
return;
D3D11_BUFFER_DESC srcDesc;
m_buffer->GetDesc(&srcDesc);
ID3D11Buffer *buffer = nullptr;
if (srcDesc.Usage != D3D11_USAGE_STAGING || 0 == (srcDesc.CPUAccessFlags & D3D11_CPU_ACCESS_READ))
{
CD3D11_BUFFER_DESC trgDesc(srcDesc);
trgDesc.Usage = D3D11_USAGE_STAGING;
trgDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
trgDesc.BindFlags = 0;
if (SUCCEEDED(pDevice->CreateBuffer(&trgDesc, NULL, &buffer)))
pContext->CopyResource(buffer, m_buffer);
}
else
buffer = m_buffer;
if (buffer != nullptr)
{
D3D11_MAPPED_SUBRESOURCE res;
if (SUCCEEDED(pContext->Map(buffer, 0, D3D11_MAP_READ, 0, &res)))
{
m_data = new unsigned char[srcDesc.ByteWidth];
memcpy(m_data, res.pData, srcDesc.ByteWidth);
pContext->Unmap(buffer, 0);
}
}
if (buffer != m_buffer)
SAFE_RELEASE(buffer);
SAFE_RELEASE(m_buffer);
}
void TgcDX11Effect::internalAddConstantBuffer(TgcEffectValues::ConstantBuffer constantBuffer)
{
ID3D11Device* device = ((TgcDX11Renderer*)GuiController::Instance->renderer)->device;
//Set buffer desc
D3D11_BUFFER_DESC bufferDesc;
bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
bufferDesc.ByteWidth = constantBuffer.size;
bufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
bufferDesc.MiscFlags = 0;
bufferDesc.StructureByteStride = 0;
// Create the constant buffer
ID3D11Buffer* cBuffer = NULL;
HRESULT result = device->CreateBuffer(&bufferDesc, NULL, &cBuffer);
this->dxConstantBuffers[constantBuffer.name] = cBuffer;
}
ID3D11Buffer* Mesh::CreateIndexBuffer(UINT* indices, UINT numIndices){
// Get the curent Device
ID3D11Device* device = DeviceManager::GetCurrentDevice();
ID3D11Buffer* iBuffer;
// Create the index buffer
D3D11_BUFFER_DESC ibd;
ibd.Usage = D3D11_USAGE_IMMUTABLE;
ibd.ByteWidth = sizeof(UINT) * numIndices; // Number of indices
ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
ibd.CPUAccessFlags = 0;
ibd.MiscFlags = 0;
ibd.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA initialIndexData;
initialIndexData.pSysMem = indices;
HR(device->CreateBuffer(&ibd, &initialIndexData, &iBuffer));
return iBuffer;
};
ID3D11Buffer* Mesh::CreateParticleVertexBuffer(void* vertices, UINT numVertices, VERTEX_TYPE vertexType){
// Get the curent Device
ID3D11Device* device = DeviceManager::GetCurrentDevice();
ID3D11Buffer* vBuffer;
// Create the vertex buffer
D3D11_BUFFER_DESC vbd;
vbd.Usage = D3D11_USAGE_DYNAMIC;
vbd.ByteWidth = Vertex::VertexSize(vertexType) * numVertices; // Number of vertices
vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vbd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
vbd.MiscFlags = 0;
vbd.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA initialVertexData;
initialVertexData.pSysMem = vertices;
HR(device->CreateBuffer(&vbd, &initialVertexData, &vBuffer));
return vBuffer;
};
bool DirectionalLightShader::Init()
{
bool ret = false;
ID3D11Device* device = gCore.GetDevice();
buffer file;
CHECK(LoadBinaryFile(file, "directional_light.cso"));
CHECK(SUCCEEDED(device->CreatePixelShader(file.ptr(), file.size(), nullptr, &mPS)));
D3D11_BUFFER_DESC buffDesc;
ZeroMemory(&buffDesc, sizeof(buffDesc));
buffDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
buffDesc.Usage = D3D11_USAGE_DYNAMIC;
buffDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
buffDesc.ByteWidth = sizeof(CBLight);
CHECK(SUCCEEDED(device->CreateBuffer(&buffDesc, nullptr, &mCB)));
ret = true;
Exit0:
return ret;
}
