bool Texture::Create(UINT w, UINT h, const void* bits)
{
bool ret = false;
mWidth = w;
mHeight = h;
ID3D11Device* device = gCore.GetDevice();
CHECK(device);
D3D11_TEXTURE2D_DESC textureDesc;
ZeroMemory(&textureDesc, sizeof(textureDesc));
textureDesc.Width = w;
textureDesc.Height = h;
textureDesc.MipLevels = 1;
textureDesc.ArraySize = 1;
textureDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
textureDesc.SampleDesc.Count = 1;
textureDesc.Usage = D3D11_USAGE_DEFAULT;
textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
textureDesc.CPUAccessFlags = 0;
textureDesc.MiscFlags = 0;
if (bits)
{
D3D11_SUBRESOURCE_DATA subres;
subres.pSysMem = bits;
subres.SysMemPitch = w * 4;
subres.SysMemSlicePitch = 0; // Not needed since this is a 2d texture
CHECK(SUCCEEDED(device->CreateTexture2D(&textureDesc, &subres, &mPtr)));
}
else
{
CHECK(SUCCEEDED(device->CreateTexture2D(&textureDesc, nullptr, &mPtr)));
}
D3D11_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc;
shaderResourceViewDesc.Format = textureDesc.Format;
shaderResourceViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;
shaderResourceViewDesc.Texture2D.MipLevels = 1;
CHECK(SUCCEEDED(device->CreateShaderResourceView(mPtr, &shaderResourceViewDesc, &mSRV)));
D3D11_SAMPLER_DESC samplerDesc;
ZeroMemory(&samplerDesc, sizeof(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.ComparisonFunc = D3D11_COMPARISON_NEVER;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
CHECK(SUCCEEDED(device->CreateSamplerState(&samplerDesc, &mSampler)));
ret = true;
Exit0:
return ret;
}
static bool grabFrameD3D11(IDXGISwapChain *swap)
{
ID3D11Device *device = 0;
ID3D11DeviceContext *context = 0;
ID3D11Texture2D *tex = 0, *captureTex = 0;
if (FAILED(swap->GetBuffer(0, IID_ID3D11Texture2D, (void**)&tex)))
return false;
D3D11_TEXTURE2D_DESC desc;
tex->GetDevice(&device);
tex->GetDesc(&desc);
// re-creating the capture staging texture each frame is definitely not the most efficient
// way to handle things, but it frees me of all kind of resource management trouble, so
// here goes...
desc.MipLevels = 1;
desc.ArraySize = 1;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.Usage = D3D11_USAGE_STAGING;
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
desc.MiscFlags = 0;
if(FAILED(device->CreateTexture2D(&desc,0,&captureTex)))
printLog("video/d3d11: couldn't create staging texture for gpu->cpu download!\n");
else
setCaptureResolution(desc.Width,desc.Height);
device->GetImmediateContext(&context);
context->CopySubresourceRegion(captureTex,0,0,0,0,tex,0,0);
D3D11_MAPPED_SUBRESOURCE mapped;
bool grabOk = false;
if(captureTex && SUCCEEDED(context->Map(captureTex,0,D3D11_MAP_READ,0,&mapped)))
{
switch(desc.Format)
{
case DXGI_FORMAT_R8G8B8A8_UNORM:
blitAndFlipRGBAToCaptureData((unsigned char *) mapped.pData,mapped.RowPitch);
grabOk = true;
break;
default:
printLog("video/d3d11: unsupported backbuffer format, can't grab pixels!\n");
break;
}
context->Unmap(captureTex,0);
}
tex->Release();
if(captureTex) captureTex->Release();
context->Release();
device->Release();
return grabOk;
}
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;
}
vpResult vprBlendStateDX11::init()
{
vprDeviceDX11* dx11Device = static_cast<vprDeviceDX11*>(m_device);
ID3D11Device* nativeDevice = dx11Device->getNativeDevice();
D3D11_BLEND_DESC nativeDesc;
ZeroMemory(&nativeDesc, sizeof(nativeDesc));
nativeDesc.AlphaToCoverageEnable = m_desc.m_alphaToCoverageEnable;
nativeDesc.IndependentBlendEnable = m_desc.m_independentBlendEnable;
// TODO add a numRenderTargetDescs ?
for (int i = 0; i < 8; ++i)
{
vprRenderTargetBlendDesc& blendDesc = m_desc.m_renderTarget[i];
D3D11_RENDER_TARGET_BLEND_DESC& nativeBlendDesc = nativeDesc.RenderTarget[i];
nativeBlendDesc.SrcBlend = blendToDX11[blendDesc.m_srcBlend];
nativeBlendDesc.DestBlend = blendToDX11[blendDesc.m_destBlend];
nativeBlendDesc.BlendOp = blendOpToDX11[blendDesc.m_blendOp];
nativeBlendDesc.SrcBlendAlpha = blendToDX11[blendDesc.m_srcBlendAlpha];
nativeBlendDesc.DestBlendAlpha = blendToDX11[blendDesc.m_destBlendAlpha];
nativeBlendDesc.BlendOpAlpha = blendOpToDX11[blendDesc.m_blendOp];
nativeBlendDesc.RenderTargetWriteMask = blendDesc.m_renderTargetWriteMask;
}
if (FAILED(nativeDevice->CreateBlendState(&nativeDesc, &m_nativeState)))
{
return VP_FAILURE;
}
return VP_SUCCESS;
}
vpResult vprRasterizerStateDX11::init()
{
vprDeviceDX11* dx11Device = static_cast<vprDeviceDX11*>(m_device);
ID3D11Device* nativeDevice = dx11Device->getNativeDevice();
D3D11_RASTERIZER_DESC nativeDesc;
ZeroMemory(&nativeDesc, sizeof(nativeDesc));
nativeDesc.FillMode = fillModeToDX11[m_desc.m_fillMode];
nativeDesc.CullMode = cullModeToDX11[m_desc.m_cullMode];
nativeDesc.FrontCounterClockwise = m_desc.m_frontCounterClockwise ? TRUE : FALSE;
nativeDesc.DepthBias = m_desc.m_depthBias;
nativeDesc.DepthBiasClamp = m_desc.m_depthBiasClamp;
nativeDesc.SlopeScaledDepthBias = m_desc.m_slopeScaledDepthBias;
nativeDesc.DepthClipEnable = m_desc.m_depthClipEnable ? TRUE : FALSE;
nativeDesc.MultisampleEnable = TRUE;
nativeDesc.ScissorEnable = m_desc.m_scissorEnable ? TRUE : FALSE;
nativeDesc.AntialiasedLineEnable = m_desc.m_antialiasedLineEnable ? TRUE : FALSE;
if (FAILED(nativeDevice->CreateRasterizerState(&nativeDesc, &m_nativeState)))
{
return VP_FAILURE;
}
return VP_SUCCESS;
}
vpResult vprDepthStencilStateDX11::init()
{
vprDeviceDX11* dx11Device = static_cast<vprDeviceDX11*>(m_device);
ID3D11Device* nativeDevice = dx11Device->getNativeDevice();
D3D11_DEPTH_STENCIL_DESC nativeDesc;
ZeroMemory(&nativeDesc, sizeof(nativeDesc));
nativeDesc.DepthEnable = m_desc.m_depthEnable ? TRUE : FALSE;
nativeDesc.DepthWriteMask = m_desc.m_depthWriteEnable ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO;
nativeDesc.DepthFunc = comparisonFuncToDX11[m_desc.m_depthFunc];
nativeDesc.StencilEnable = m_desc.m_depthEnable ? TRUE : FALSE;
nativeDesc.StencilReadMask = m_desc.m_stencilReadMask;
nativeDesc.StencilWriteMask = m_desc.m_stencilWriteMask;
nativeDesc.FrontFace.StencilFailOp = stencilOpToDX11[m_desc.m_frontFace.m_stencilFailOp];
nativeDesc.FrontFace.StencilDepthFailOp = stencilOpToDX11[m_desc.m_frontFace.m_stencilDepthFailOp];
nativeDesc.FrontFace.StencilPassOp = stencilOpToDX11[m_desc.m_frontFace.m_stencilPassOp];
nativeDesc.FrontFace.StencilFunc = comparisonFuncToDX11[m_desc.m_frontFace.m_stencilFunc];
nativeDesc.BackFace.StencilFailOp = stencilOpToDX11[m_desc.m_backFace.m_stencilFailOp];
nativeDesc.BackFace.StencilDepthFailOp = stencilOpToDX11[m_desc.m_backFace.m_stencilDepthFailOp];
nativeDesc.BackFace.StencilPassOp = stencilOpToDX11[m_desc.m_backFace.m_stencilPassOp];
nativeDesc.BackFace.StencilFunc = comparisonFuncToDX11[m_desc.m_backFace.m_stencilFunc];
if (FAILED(nativeDevice->CreateDepthStencilState(&nativeDesc, &m_nativeState)))
{
return VP_FAILURE;
}
return VP_SUCCESS;
}
//-----------------------------------------------------------------------------
void CPUTRenderStateBlockDX11::CreateNativeResources()
{
// Now, create the DX render state items
ID3D11Device *pDevice = CPUT_DX11::GetDevice();
HRESULT hr;
hr = pDevice->CreateBlendState( &mStateDesc.BlendDesc, &mpBlendState );
ASSERT( SUCCEEDED(hr), _L("Failed to create blend state.") );
hr = pDevice->CreateDepthStencilState( &mStateDesc.DepthStencilDesc, &mpDepthStencilState );
ASSERT( SUCCEEDED(hr), _L("Failed to create depth stencil state.") );
hr = pDevice->CreateRasterizerState( &mStateDesc.RasterizerDesc, &mpRasterizerState );
ASSERT( SUCCEEDED(hr), _L("Failed to create rasterizer state.") );
// TODO: how to map samplers to shaders?
// Each type can have different samplers assigned (VS, PS, GS, etc.)
// How does DX treat them? 16 unified? or 16 each?
// For now, just read 16 samplers, and set to all stages
for( UINT ii=0; ii<mNumSamplers; ii++ )
{
hr = pDevice->CreateSamplerState( &mStateDesc.SamplerDesc[ii], &mpSamplerState[ii] );
ASSERT( SUCCEEDED(hr), _L("Failed to create sampler state.") );
}
} // CPUTRenderStateBlockDX11::CreateDXResources()
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;
}
}
void CFullscreenTriangleDrawer::DrawDX11( ID3D11ShaderResourceView* pTextureSRV )
{
ID3D11Device* pDevice = static_cast<ID3D11Device*>( gD3DDevice );
ID3D11DeviceContext* pContext = NULL;
pDevice->GetImmediateContext( &pContext );
CDX11StateGuard stateGuard;
pContext->IASetInputLayout( NULL );
pContext->IASetIndexBuffer( NULL, DXGI_FORMAT_UNKNOWN, 0 );
pContext->IASetVertexBuffers( 0, 0, NULL, NULL, NULL );
pContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
pContext->VSSetShader( m_pVertexShader11, NULL, 0 );
pContext->PSSetShader( m_pPixelShader11, NULL, 0 );
ID3D11SamplerState* pNullSampler[] = { NULL };
pContext->PSSetSamplers( 0, 1, pNullSampler );
pContext->PSSetShaderResources( 0, 1, &pTextureSRV );
pContext->OMSetBlendState( m_pBlendState11, NULL, 0xFFFFFFFF );
// Draw
pContext->Draw( 3, 0 );
}
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 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 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;
}
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 eve::dx11::SamplerStates::Init(eve::dx11::Device* device)
{
ID3D11Device* d = device->GetDevice();
D3D11_SAMPLER_DESC samplerDesc;
ZeroMemory(&samplerDesc, sizeof(D3D11_SAMPLER_DESC));
D3D11_TEXTURE_ADDRESS_MODE addressMode = D3D11_TEXTURE_ADDRESS_MODE::D3D11_TEXTURE_ADDRESS_CLAMP;
samplerDesc.AddressU = addressMode;
samplerDesc.AddressV = addressMode;
samplerDesc.AddressW = addressMode;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_FUNC::D3D11_COMPARISON_ALWAYS;
samplerDesc.Filter = D3D11_FILTER::D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT;
samplerDesc.MaxAnisotropy = 0;
samplerDesc.MaxLOD = FLT_MAX;
samplerDesc.MinLOD = FLT_MIN;
samplerDesc.MipLODBias = 0;
d->CreateSamplerState(&samplerDesc, &this->m_pPointClamp);
samplerDesc.Filter = D3D11_FILTER::D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR;
d->CreateSamplerState(&samplerDesc, &this->m_pLinearClamp);
addressMode = D3D11_TEXTURE_ADDRESS_MODE::D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressU = addressMode;
samplerDesc.AddressV = addressMode;
samplerDesc.AddressW = addressMode;
d->CreateSamplerState(&samplerDesc, &this->m_pLinearWrap);
}
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 TgcDX11Effect::internalAddSampler(TgcEffectValues::Sampler sampler)
{
ID3D11Device* device = ((TgcDX11Renderer*)GuiController::Instance->renderer)->device;
//Create a texture sampler state description.
D3D11_SAMPLER_DESC samplerDesc;
samplerDesc.Filter = this->getFilter(sampler.filter);
samplerDesc.AddressU = this->getAddressMode(sampler.addressU);
samplerDesc.AddressV = this->getAddressMode(sampler.addressV);
samplerDesc.AddressW = this->getAddressMode(sampler.addressW);
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = sampler.borderColor.R;
samplerDesc.BorderColor[1] = sampler.borderColor.G;
samplerDesc.BorderColor[2] = sampler.borderColor.B;
samplerDesc.BorderColor[3] = sampler.borderColor.A;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
//Create the texture sampler state.
ID3D11SamplerState* samplerState = NULL;
HRESULT result = device->CreateSamplerState(&samplerDesc, &samplerState);
this->dxSampleStates[sampler.textureName] = samplerState;
}
EErrorCode::Type SamplerState::Initialize( void )
{
ID3D11Device *pDevice = (ID3D11Device*)GraphicsDevice::GetInstance()->GetNakedDevice();
D3D11_SAMPLER_DESC desc;
desc.Filter = DX11Mapping::ToDXFilter( m_desc.filter );
desc.AddressU = DX11Mapping::ToDXTextureAddressMode( m_desc.addressU );
desc.AddressV = DX11Mapping::ToDXTextureAddressMode( m_desc.addressV );
desc.AddressW = DX11Mapping::ToDXTextureAddressMode( m_desc.addressW );
desc.MipLODBias = m_desc.mipLODBias;
desc.MaxAnisotropy = m_desc.maxAnisotropy;
desc.ComparisonFunc = DX11Mapping::ToDXComparisonFunc( m_desc.comparisonFunc );
PSX_MemCopyPerByte( desc.BorderColor, m_desc.borderColor, sizeof(m_desc.borderColor) );
desc.MinLOD = m_desc.minLOD;
desc.MaxLOD = m_desc.maxLOD;
if ( pDevice->CreateSamplerState( &desc, &m_pSamplerState ) != S_OK )
{
PSX_PushError( "Failed to create sampler state." );
return EErrorCode::GRAPHICS;
}
return EErrorCode::OKAY;
}
bool Texture::LoadXOR() {
width_ = height_ = 256;
unsigned char *buf = new unsigned char[width_*height_*4];
for (int y = 0; y < 256; y++) {
for (int x = 0; x < 256; x++) {
buf[(y*width_ + x)*4 + 0] = x^y;
buf[(y*width_ + x)*4 + 1] = x^y;
buf[(y*width_ + x)*4 + 2] = x^y;
buf[(y*width_ + x)*4 + 3] = 0xFF;
}
}
GL_CHECK();
ID3D11Device *ctx;
D3D11_TEXTURE2D_DESC desc;
desc.Width = width_;
desc.Height = height_;
desc.MipLevels = 0;
desc.ArraySize = 1;
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
if (FAILED(ctx->CreateTexture2D(&desc, 0, &tex_))) {
FLOG("Failed creating XOR texture");
}
SetTextureParameters(ZIM_GEN_MIPS);
GL_CHECK();
delete [] buf;
return true;
}
//-------------------------------------------------------------------------
// @Create needed sampler states for the textures here
//-------------------------------------------------------------------------
bool TextureManager::createSamplerStates(const DeviceManager& deviceManager)
{
//Setup sampler state here
D3D11_SAMPLER_DESC samplerStateDesc;
samplerStateDesc.Filter = D3D11_FILTER_ANISOTROPIC;
samplerStateDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerStateDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerStateDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerStateDesc.MipLODBias = 0.0f;
samplerStateDesc.MaxAnisotropy = 16;
samplerStateDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
samplerStateDesc.BorderColor[0] = 0.0f;
samplerStateDesc.BorderColor[1] = 0.0f;
samplerStateDesc.BorderColor[2] = 0.0f;
samplerStateDesc.BorderColor[3] = 0.0f;
samplerStateDesc.MinLOD = -3.402823466e+38F;
samplerStateDesc.MaxLOD = 3.402823466e+38F;
ID3D11Device* device = deviceManager.getDevice();
HRESULT hr = device->CreateSamplerState(&samplerStateDesc, &m_samplerState);
if (FAILED( hr ) )
{
MSG_TRACE_CHANNEL("TEXTUREMANAGER", "Failed to create sampler state: 0x%x", hr )
return false;
}
return true;
}
//=================================================================================================
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."));
}
}
//----------------------------------------------------------------------------
void DX11GeometryShader::DisableUAView(ID3D11DeviceContext* context,
unsigned int bindPoint)
{
if (mDXObject)
{
ID3D11Device* device = nullptr;
context->GetDevice(&device);
if (!device)
{
LogError("Cannot access device of context.");
return;
}
if (device->GetFeatureLevel() == D3D_FEATURE_LEVEL_11_1)
{
ID3D11UnorderedAccessView* uaViews[1] = { nullptr };
unsigned int initialCounts[1] = { 0xFFFFFFFFu };
context->OMSetRenderTargetsAndUnorderedAccessViews(
D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL, nullptr,
nullptr, bindPoint, 1, uaViews, initialCounts);
}
else
{
LogError("D3D11.1 is required for UAVs in geometry shaders.");
}
device->Release();
}
}
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 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 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 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;
}
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 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;
}
ID3D11BlendState *Clear11::getBlendState(const gl::ClearParameters &clearParams, const std::vector<RenderTarget11*>& rts)
{
GLuint clientVersion = mRenderer->getCurrentClientVersion();
ClearBlendInfo blendKey = { 0 };
for (unsigned int i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
{
if (i < rts.size())
{
GLint internalFormat = rts[i]->getInternalFormat();
blendKey.maskChannels[i][0] = clearParams.clearColor ? (clearParams.colorMaskRed && gl::GetRedBits(internalFormat, clientVersion) > 0) : false;
blendKey.maskChannels[i][1] = clearParams.clearColor ? (clearParams.colorMaskGreen && gl::GetGreenBits(internalFormat, clientVersion) > 0) : false;
blendKey.maskChannels[i][2] = clearParams.clearColor ? (clearParams.colorMaskBlue && gl::GetBlueBits(internalFormat, clientVersion) > 0) : false;
blendKey.maskChannels[i][3] = clearParams.clearColor ? (clearParams.colorMaskAlpha && gl::GetAlphaBits(internalFormat, clientVersion) > 0) : false;
}
else
{
blendKey.maskChannels[i][0] = false;
blendKey.maskChannels[i][1] = false;
blendKey.maskChannels[i][2] = false;
blendKey.maskChannels[i][3] = false;
}
}
ClearBlendStateMap::const_iterator i = mClearBlendStates.find(blendKey);
if (i != mClearBlendStates.end())
{
return i->second;
}
else
{
D3D11_BLEND_DESC blendDesc = { 0 };
blendDesc.AlphaToCoverageEnable = FALSE;
blendDesc.IndependentBlendEnable = (rts.size() > 1) ? TRUE : FALSE;
for (unsigned int i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
{
blendDesc.RenderTarget[i].BlendEnable = FALSE;
blendDesc.RenderTarget[i].RenderTargetWriteMask = gl_d3d11::ConvertColorMask(blendKey.maskChannels[i][0],
blendKey.maskChannels[i][1],
blendKey.maskChannels[i][2],
blendKey.maskChannels[i][3]);
}
ID3D11Device *device = mRenderer->getDevice();
ID3D11BlendState* blendState = NULL;
HRESULT result = device->CreateBlendState(&blendDesc, &blendState);
if (FAILED(result) || !blendState)
{
ERR("Unable to create a ID3D11BlendState, HRESULT: 0x%X.", result);
return NULL;
}
mClearBlendStates[blendKey] = blendState;
return blendState;
}
}
void initAll(ID3D11Device& device,
ID3D11DeviceContext& context,
ShaderResources& shaderResources)
{
assert(shaderResources.mDiffuseMapSRV == nullptr);
assert(shaderResources.mCSResultsSRV == nullptr);
assert(shaderResources.mCSResultsUAV == nullptr);
ID3D11Resource* texture = nullptr;
//
// Diffuse Map
//
HRESULT result = CreateDDSTextureFromFile(&device,
L"Resources/Textures/brick.dds",
&texture,
&shaderResources.mDiffuseMapSRV);
DxErrorChecker(result);
texture->Release();
//
// Create compute shader texture
//
D3D11_TEXTURE2D_DESC groupResultsTexDesc;
groupResultsTexDesc.Width = 512;
groupResultsTexDesc.Height = 512;
groupResultsTexDesc.MipLevels = 1;
groupResultsTexDesc.ArraySize = 1;
groupResultsTexDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
groupResultsTexDesc.SampleDesc.Count = 1;
groupResultsTexDesc.SampleDesc.Quality = 0;
groupResultsTexDesc.Usage = D3D11_USAGE_DEFAULT;
groupResultsTexDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS;
groupResultsTexDesc.CPUAccessFlags = 0;
groupResultsTexDesc.MiscFlags = 0;
ID3D11Texture2D* groupResultsTex = nullptr;
assert(Globals::gDirect3DData.mDevice);
result = device.CreateTexture2D(&groupResultsTexDesc, 0, &groupResultsTex);
DxErrorChecker(result);
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
srvDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MostDetailedMip = 0;
srvDesc.Texture2D.MipLevels = 1;
result = device.CreateTexture2D(&groupResultsTexDesc, 0, &groupResultsTex);
result = device.CreateShaderResourceView(groupResultsTex, &srvDesc, &shaderResources.mCSResultsSRV);
D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc;
uavDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
uavDesc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D;
uavDesc.Texture2D.MipSlice = 0;
result = device.CreateUnorderedAccessView(groupResultsTex, &uavDesc, &shaderResources.mCSResultsUAV);
// Views save a reference to the texture so we can release our reference.
groupResultsTex->Release();
}
EGLint SwapChain11::resize(EGLint backbufferWidth, EGLint backbufferHeight)
{
ID3D11Device *device = mRenderer->getDevice();
if (device == NULL)
{
return EGL_BAD_ACCESS;
}
// Can only call resize if we have already created our swap buffer and resources
ASSERT(mSwapChain && mBackBufferTexture && mBackBufferRTView);
if (mBackBufferTexture)
{
mBackBufferTexture->Release();
mBackBufferTexture = NULL;
}
if (mBackBufferRTView)
{
mBackBufferRTView->Release();
mBackBufferRTView = NULL;
}
// Resize swap chain
DXGI_FORMAT backbufferDXGIFormat = gl_d3d11::ConvertRenderbufferFormat(mBackBufferFormat);
HRESULT result = mSwapChain->ResizeBuffers(2, backbufferWidth, backbufferHeight, backbufferDXGIFormat, 0);
if (FAILED(result))
{
ERR("Error resizing swap chain buffers: 0x%08X", result);
release();
if (d3d11::isDeviceLostError(result))
{
return EGL_CONTEXT_LOST;
}
else
{
return EGL_BAD_ALLOC;
}
}
result = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mBackBufferTexture);
ASSERT(SUCCEEDED(result));
if (SUCCEEDED(result))
{
d3d11::SetDebugName(mBackBufferTexture, "Back buffer texture");
}
result = device->CreateRenderTargetView(mBackBufferTexture, NULL, &mBackBufferRTView);
ASSERT(SUCCEEDED(result));
if (SUCCEEDED(result))
{
d3d11::SetDebugName(mBackBufferRTView, "Back buffer render target");
}
return resetOffscreenTexture(backbufferWidth, backbufferHeight);
}
