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); }