void D3D9Mesh::CreateText(const char *string, char *FontName, int FontHeight, float deviation, float depth, bool bold, bool italic) { //just call the DirectX function to create the text FreeMemory(); LPD3DXMESH TextMesh; HDC hdc = CreateCompatibleDC( NULL ); HFONT hFont; HFONT hFontOld; INT nHeight = -MulDiv( FontHeight, GetDeviceCaps(hdc, LOGPIXELSY), 72 ); hFont = CreateFont(nHeight, 0, 0, 0, bold ? FW_BOLD : FW_NORMAL, italic, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, FontName); hFontOld = (HFONT)SelectObject(hdc, hFont); if(FAILED(D3DXCreateText(GetD3DDevice(), hdc, string, deviation, depth, &TextMesh, NULL, NULL))) _asm int 3; SelectObject(hdc, hFontOld); DeleteObject( hFont ); DeleteDC( hdc ); TextMesh->CloneMeshFVF(D3DMeshOptions, D3DMeshFVF, GetD3DDevice(), &_Mesh); TextMesh->Release(); SetColor(RGBColor::White); GenerateNormals(); }
void D3D9Mesh::CreateTeapot(float radius) { //just call the DirectX function to create the teapot FreeMemory(); LPD3DXMESH teapot; D3DXCreateTeapot(GetD3DDevice(), &teapot, NULL); teapot->CloneMeshFVF(D3DMeshOptions, D3DMeshFVF, GetD3DDevice(), &_Mesh); teapot->Release(); Stretch(radius); SetColor(RGBColor::White); GenerateNormals(); }
ID3D11SamplerState* RenderState::GetComparisonLinear()const{ if (!pImpl->m_ComparisonLinearPtr){ auto Dev = App::GetApp()->GetDeviceResources(); ID3D11Device* pDx11Device = Dev->GetD3DDevice(); D3D11_SAMPLER_DESC comparisonSamplerDesc; ZeroMemory(&comparisonSamplerDesc, sizeof(D3D11_SAMPLER_DESC)); comparisonSamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_BORDER; comparisonSamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_BORDER; comparisonSamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_BORDER; comparisonSamplerDesc.BorderColor[0] = 1.0f; comparisonSamplerDesc.BorderColor[1] = 1.0f; comparisonSamplerDesc.BorderColor[2] = 1.0f; comparisonSamplerDesc.BorderColor[3] = 1.0f; comparisonSamplerDesc.MinLOD = 0.f; comparisonSamplerDesc.MaxLOD = D3D11_FLOAT32_MAX; comparisonSamplerDesc.MipLODBias = 0.f; comparisonSamplerDesc.MaxAnisotropy = 0; comparisonSamplerDesc.ComparisonFunc = D3D11_COMPARISON_LESS_EQUAL; comparisonSamplerDesc.Filter = D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR; ThrowIfFailed( pDx11Device->CreateSamplerState(&comparisonSamplerDesc, &pImpl->m_ComparisonLinearPtr), L"比較用サンプラーの作成に失敗しました", L"pDx11Device->CreateSamplerState(&comparisonSamplerDesc, &pImpl->m_ComparisonSampler_linear)", L"RenderState::GetComparisonLinear()" ); } return pImpl->m_ComparisonLinearPtr.Get(); }
//------------------------------------------------------------- // Trigger the render of indexed primitives //------------------------------------------------------------- void VCND3D9Shader::RenderIndexedPrimitive( VCNUInt faceCount, VCNUInt vertexCount, VCNInt primitiveType /*= D3DPT_TRIANGLELIST*/ ) { HRESULT hr = S_FALSE; // Get a pointer to the D3D device LPDIRECT3DDEVICE9 device = GetD3DDevice(); // Start the technique and commit all the data VCNUInt numPasses; hr = mShader->Begin( &numPasses, 0 ); VCN_ASSERT( SUCCEEDED(hr) ); // Render all the passes of this technique (generally only 1). for( VCNUInt i=0; i<numPasses; ++i ) { // Start the pass hr = mShader->BeginPass( i ); VCN_ASSERT( SUCCEEDED(hr) ); // Render indexed primitives hr = device->DrawIndexedPrimitive( (D3DPRIMITIVETYPE)primitiveType, 0, 0, vertexCount, 0, faceCount ); VCN_ASSERT( hr != D3DERR_INVALIDCALL && "VCNDXShader::RenderIndexedPrimitive - D3DERR_INVALIDCALL!" ); VCN_ASSERT( SUCCEEDED(hr) && "VCNDXShader::RenderIndexedPrimitive - DRAW FAILED!" ); // End the pass hr = mShader->EndPass(); VCN_ASSERT( SUCCEEDED(hr) ); } hr = mShader->End(); VCN_ASSERT( SUCCEEDED(hr) ); }
//-------------------------------------------------------------------------------------- // void RenderState::Impl::CreateRasterizerState( // D3D11_CULL_MODE cullMode, //カリング // D3D11_FILL_MODE fillMode, //塗り // ID3D11RasterizerState** pResult, //受け取るインターフェイス // bool Scissor = false //画面分割するかどうか // ); // 用途: ラスタライザステートを作成するヘルパー関数 // 戻り値: なし //-------------------------------------------------------------------------------------- void RenderState::Impl::CreateRasterizerState(D3D11_CULL_MODE cullMode, D3D11_FILL_MODE fillMode, ID3D11RasterizerState** pResult, bool Scissor){ try{ auto Dev = App::GetApp()->GetDeviceResources(); auto pDx11Device = Dev->GetD3DDevice(); D3D11_RASTERIZER_DESC desc; ZeroMemory(&desc, sizeof(desc)); desc.CullMode = cullMode; desc.FillMode = fillMode; desc.DepthClipEnable = true; desc.MultisampleEnable = true; desc.ScissorEnable = Scissor; HRESULT hr = pDx11Device->CreateRasterizerState(&desc, pResult); if (FAILED(hr)){ // 初期化失敗 throw BaseException( L"ラスタライザステート作成に失敗しました。", L"if(FAILED(pDx11Device->CreateRasterizerState()))", L"RenderState::Impl::CreateRasterizerState()" ); } } catch (...){ throw; } }
ID3D11BlendState* RenderState::GetAlphaBlendEx()const{ if (!pImpl->m_AlphaBlendExPtr){ auto Dev = App::GetApp()->GetDeviceResources(); auto pDx11Device = Dev->GetD3DDevice(); D3D11_BLEND_DESC desc; ZeroMemory(&desc, sizeof(desc)); desc.RenderTarget[0].BlendEnable = true; desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA; desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; // desc.RenderTarget[0].DestBlend = D3D11_BLEND_DEST_ALPHA; desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE; desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; HRESULT hr = pDx11Device->CreateBlendState(&desc, &pImpl->m_AlphaBlendExPtr); if (FAILED(hr)){ // 初期化失敗 throw BaseException( L"ブレンドステート作成に失敗しました。", L"if(FAILED(pDx11Device->CreateBlendState()))", L"BasicState::GetAlphaBlendEx()" ); } } return pImpl->m_AlphaBlendExPtr.Get(); }
HRESULT WrappedIDXGIFactory2::staticCreateSwapChainForHwnd( IDXGIFactory2 *factory, IUnknown *pDevice, HWND hWnd, const DXGI_SWAP_CHAIN_DESC1 *pDesc, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *pFullscreenDesc, IDXGIOutput *pRestrictToOutput, IDXGISwapChain1 **ppSwapChain) { ID3DDevice *wrapDevice = GetD3DDevice(pDevice); if(wrapDevice) { if(!RenderDoc::Inst().GetCaptureOptions().AllowFullscreen && pFullscreenDesc) { pFullscreenDesc = NULL; } HRESULT ret = factory->CreateSwapChainForHwnd(wrapDevice->GetRealIUnknown(), hWnd, pDesc, pFullscreenDesc, pRestrictToOutput, ppSwapChain); if(SUCCEEDED(ret)) { *ppSwapChain = new WrappedIDXGISwapChain3(*ppSwapChain, hWnd, wrapDevice); } return ret; } else { RDCERR("Creating swap chain with non-hooked device!"); } return factory->CreateSwapChainForHwnd(pDevice, hWnd, pDesc, pFullscreenDesc, pRestrictToOutput, ppSwapChain); }
//-------------------------------------------------------------------------------------- // void RenderState::Impl::CreateBlendState( // D3D11_BLEND srcBlend, //ソースブレンド // D3D11_BLEND destBlend, //デストブレンド // ID3D11BlendState** pResult //受け取るインターフェイス // ); // 用途: ブレンドステートを作成するヘルパー関数 // 戻り値: なし //-------------------------------------------------------------------------------------- void RenderState::Impl::CreateBlendState(D3D11_BLEND srcBlend, D3D11_BLEND destBlend, ID3D11BlendState** pResult){ try{ auto Dev = App::GetApp()->GetDeviceResources(); auto pDx11Device = Dev->GetD3DDevice(); D3D11_BLEND_DESC desc; ZeroMemory(&desc, sizeof(desc)); desc.RenderTarget[0].BlendEnable = (srcBlend != D3D11_BLEND_ONE) || (destBlend != D3D11_BLEND_ZERO); desc.RenderTarget[0].SrcBlend = desc.RenderTarget[0].SrcBlendAlpha = srcBlend; desc.RenderTarget[0].DestBlend = desc.RenderTarget[0].DestBlendAlpha = destBlend; desc.RenderTarget[0].BlendOp = desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; HRESULT hr = pDx11Device->CreateBlendState(&desc, pResult); if (FAILED(hr)){ // 初期化失敗 throw BaseException( L"ブレンドステート作成に失敗しました。", L"if(FAILED(pDx11Device->CreateBlendState()))", L"RenderState::Impl::CreateBlendState()" ); } } catch (...){ throw; } }
bool LoadDDSTextureStatic(const char* texturePath, TextureInfo& o_textureInfo) { //Get devices context of D3D IDirect3DDevice9* pD3DDevice = GetD3DDevice(); if (!pD3DDevice) return false; IDirect3DTexture9* pResultTexture = NULL; const unsigned int useDimensionsFromFile = D3DX_DEFAULT_NONPOW2; const unsigned int useMipMapsFromFile = D3DX_FROM_FILE; const DWORD staticTexture = 0; const D3DFORMAT useFormatFromFile = D3DFMT_FROM_FILE; const D3DPOOL letD3dManageMemory = D3DPOOL_MANAGED; const DWORD useDefaultFiltering = D3DX_DEFAULT; const D3DCOLOR noColorKey = 0; D3DXIMAGE_INFO imageInfo; PALETTEENTRY* noColorPalette = NULL; const HRESULT result = D3DXCreateTextureFromFileEx(pD3DDevice, texturePath, useDimensionsFromFile, useDimensionsFromFile, useMipMapsFromFile, staticTexture, useFormatFromFile, letD3dManageMemory, useDefaultFiltering, useDefaultFiltering, noColorKey, &imageInfo, noColorPalette, &pResultTexture); o_textureInfo._width = (float)imageInfo.Width; o_textureInfo._height = (float)imageInfo.Height; o_textureInfo._texture = (tTexture)pResultTexture; return true; }
void HUDManager::Render() { HRESULT hr; IDirect3DDevice9 *Device; Device = GetD3DDevice(); if (!Device) { _MESSAGE("No valid D3D Device."); return; } if(!sprite) { hr=D3DXCreateSprite(Device,&sprite); if (FAILED(hr)||!sprite) { _MESSAGE("Create sprite failed."); return; } } sprite->Begin(0); for(::std::vector<Sprite*>::iterator i=ScreenElementList.begin(); i!=ScreenElementList.end(); i++) { (*i)->Render(sprite); } sprite->End(); return; }
//レンダリングターゲットを開始する void DefaultRenderTarget::StartRenderTarget(){ auto Dev = App::GetApp()->GetDeviceResources(); auto pD3D11Device = Dev->GetD3DDevice(); auto pD3D11DeviceContext = Dev->GetD3DDeviceContext(); ID3D11RenderTargetView* pV = pImpl->m_D3D11RenderTargetView.Get(); //レンダリングターゲットとステンシルを設定 pD3D11DeviceContext->OMSetRenderTargets(1, &pV, pImpl->m_DepthStencilView.Get()); //ビューポートの設定 if (pImpl->m_Stage.expired()){ throw BaseException( L"ステージが無効です", L"if (pImpl->m_Stage.expired())", L"DefaultRenderTarget::StartRenderTarget()" ); } auto StagePtr = pImpl->m_Stage.lock(); pD3D11DeviceContext->RSSetViewports(1, StagePtr->GetTargetViewPortRealPtr()); //シェーダーリソースビューのクリア ID3D11ShaderResourceView* pNull[1] = { nullptr }; pD3D11DeviceContext->PSSetShaderResources(0, _countof(pNull), pNull); pD3D11DeviceContext->PSSetShaderResources(1, _countof(pNull), pNull); //シェーダーは指定しない pD3D11DeviceContext->VSSetShader(nullptr, nullptr, 0); pD3D11DeviceContext->PSSetShader(nullptr, nullptr, 0); pD3D11DeviceContext->GSSetShader(nullptr, nullptr, 0); //ブレンドは指定しない pD3D11DeviceContext->OMSetBlendState(nullptr, nullptr, 0xffffffff); }
//レンダリングターゲットをクリアする void ShadowMapRenderTarget::ClearViews(){ auto Dev = App::GetApp()->GetDeviceResources(); auto pD3D11Device = Dev->GetD3DDevice(); auto pD3D11DeviceContext = Dev->GetD3DDeviceContext(); //シャドウマップクリア pD3D11DeviceContext->ClearDepthStencilView(pImpl->m_DepthStencilView.Get(), D3D11_CLEAR_DEPTH, 1.0, 0); }
HRESULT WrappedIDXGIFactory2::staticCreateSwapChainForComposition(IDXGIFactory2 *factory, IUnknown *pDevice, const DXGI_SWAP_CHAIN_DESC1 *pDesc, IDXGIOutput *pRestrictToOutput, IDXGISwapChain1 **ppSwapChain) { ID3DDevice *wrapDevice = GetD3DDevice(pDevice); if(!RenderDoc::Inst().GetCaptureOptions().AllowFullscreen) { RDCWARN("Impossible to disallow fullscreen on call to CreateSwapChainForComposition"); } if(wrapDevice) { HRESULT ret = factory->CreateSwapChainForComposition(wrapDevice->GetRealIUnknown(), pDesc, pRestrictToOutput, ppSwapChain); if(SUCCEEDED(ret)) { HWND wnd = NULL; (*ppSwapChain)->GetHwnd(&wnd); *ppSwapChain = new WrappedIDXGISwapChain3(*ppSwapChain, wnd, wrapDevice); } return ret; } else { RDCERR("Creating swap chain with non-hooked device!"); } return factory->CreateSwapChainForComposition(pDevice, pDesc, pRestrictToOutput, ppSwapChain); }
HRESULT WrappedIDXGIFactory::staticCreateSwapChain(IDXGIFactory *factory, IUnknown *pDevice, DXGI_SWAP_CHAIN_DESC *pDesc, IDXGISwapChain **ppSwapChain) { ID3DDevice *wrapDevice = GetD3DDevice(pDevice); if(wrapDevice) { if(!RenderDoc::Inst().GetCaptureOptions().AllowFullscreen && pDesc) { pDesc->Windowed = TRUE; } HRESULT ret = factory->CreateSwapChain(wrapDevice->GetRealIUnknown(), pDesc, ppSwapChain); if(SUCCEEDED(ret)) { *ppSwapChain = new WrappedIDXGISwapChain3(*ppSwapChain, pDesc ? pDesc->OutputWindow : NULL, wrapDevice); } return ret; } RDCERR("Creating swap chain with non-hooked device!"); return factory->CreateSwapChain(pDevice, pDesc, ppSwapChain); }
//シェーダリソースビューの作成 ComPtr<ID3D11ShaderResourceView> GameObject::CreateShaderResView(const wstring& TextureFileName){ //テクスチャ作成 DirectX::TexMetadata metadata; DirectX::ScratchImage image; ThrowIfFailed( DirectX::LoadFromWICFile(TextureFileName.c_str(), 0, &metadata, image), L"テクスチャの読み込みに失敗しました", TextureFileName, L"GameObject::CreateShaderResView()" ); //デバイスとコンテキストインターフェイスの取得 //デバイスの取得 auto Dev = App::GetApp()->GetDeviceResources(); ID3D11Device* pDx11Device = Dev->GetD3DDevice(); ID3D11DeviceContext* pID3D11DeviceContex = Dev->GetD3DDeviceContext(); //ミューテックス std::mutex Mutex; ComPtr<ID3D11ShaderResourceView> ResView; Util::DemandCreate(ResView, Mutex, [&](ID3D11ShaderResourceView** pResult) -> HRESULT { // 画像からシェーダリソースViewの作成 return ThrowIfFailed(CreateShaderResourceView(pDx11Device, image.GetImages(), image.GetImageCount(), metadata, pResult), L"シェーダーリソースビューを作成できません", L"if( FAILED( CreateShaderResourceView() ) )", L"Texture::Impl::Impl()" ); }); return ResView; }
void D3D9Mesh::LoadFromXFile(const String &Filename) { String FilenameCopy = Filename; FreeMemory(); LPD3DXBUFFER Adjacency, Materials, EffectInstances; DWORD MaterialCount; LPD3DXMESH LoadedMesh; //call the DirectX function to load from an XFile, D3DXLoadMeshFromX(FilenameCopy.CString(), D3DMeshOptions, GetD3DDevice(), &Adjacency, &Materials, &EffectInstances, &MaterialCount, &LoadedMesh); //get rid of the components we don't care about Adjacency->Release(); Materials->Release(); EffectInstances->Release(); //and copy the part we do care about (the _Mesh) into our _Mesh in the right format. LoadedMesh->CloneMeshFVF(D3DMeshOptions, D3DMeshFVF, GetD3DDevice(), &_Mesh); LoadedMesh->Release(); }
//------------------------------------------------------------- // Make the shader active //------------------------------------------------------------- void VCND3D9Shader::Bind() { // Select the technique HRESULT hr = mShader->SetTechnique( mTechnique ); VCN_ASSERT( SUCCEEDED(hr) ); // Set the vertex declaration for this kind of shader hr = GetD3DDevice()->SetVertexDeclaration( mVertexDeclaration->GetDeclaration() ); VCN_ASSERT( SUCCEEDED(hr) ); }
IDirect3DVertexDeclaration9* RenderCore::CreateVertexDeclaration(D3DVERTEXELEMENT9* pVertexElements) { IDirect3DVertexDeclaration9* ret = 0; if(FAILED(GetD3DDevice()->CreateVertexDeclaration(pVertexElements, &ret))) { // Push error-code into the error-pipeline return 0; } return ret; }
void RenderCore::Clear(D3DCOLOR Color, float Z, DWORD Stencil, DWORD Count, const D3DRECT *pRects) { DWORD Flags = D3DCLEAR_TARGET; if(m_RCDesc.m_PresentParameters.EnableAutoDepthStencil) { Flags |= D3DCLEAR_ZBUFFER; } GetD3DDevice()->Clear(Count, pRects, Flags, Color, Z, Stencil); }
IDirect3DIndexBuffer9* RenderCore::CreateIndexBuffer(unsigned int NumOfIndices, D3DFORMAT Format, D3DPOOL Pool, DWORD Usage) { IDirect3DIndexBuffer9* ret = 0; if(FAILED(GetD3DDevice()->CreateIndexBuffer(NumOfIndices * GetSizeOfIndex(Format), Usage, Format, Pool, &ret, 0))) { // Push error-code into the error-pipeline return 0; } return ret; }
IDirect3DVertexBuffer9* RenderCore::CreateVertexBuffer(unsigned int NumOfVertices, unsigned int SizeOfVertex, DWORD dwFVF, D3DPOOL Pool, DWORD Usage) { IDirect3DVertexBuffer9* ret = 0; if(FAILED(GetD3DDevice()->CreateVertexBuffer(NumOfVertices * SizeOfVertex, Usage, dwFVF, Pool, &ret, 0))) { // Push error-code into the error-pipeline return 0; } return ret; }
void TextureDesc::SetTexture() { //Get devices context of D3D IDirect3DDevice9* pD3DDevice = GetD3DDevice(); if (!pD3DDevice) return; if (_samplerID == UINT_MAX) return; //Set the Texture IDirect3DBaseTexture9* pTexture = _pTextureInfo? (IDirect3DBaseTexture9*)_pTextureInfo->_texture : NULL; HRESULT result = pD3DDevice->SetTexture(_samplerID, pTexture); assert(SUCCEEDED(result)); }
void D3D9Mesh::Allocate(UINT VertexCount, UINT FaceCount) { FreeMemory(); if(VertexCount == 0 || FaceCount == 0) { return; } D3DXCreateMeshFVF(FaceCount, VertexCount, D3DMeshOptions, D3DMeshFVF, GetD3DDevice(), &_Mesh); //tell DirectX to allocate space for the _Mesh Lock(); //toggle the buffer locking just to clear things up Unlock(); //we want the buffers unlocked whenever possible }
void RenderManager::Init(int32 _frameBufferWidth, int32 _frameBufferHeight) { DetectRenderingCapabilities(); if (!FLAT_COLOR) FLAT_COLOR = ColorOnlyEffect::Create(renderer); if (!TEXTURE_MUL_FLAT_COLOR) TEXTURE_MUL_FLAT_COLOR= TextureMulColorEffect::Create(renderer); if (!TEXTURE_MUL_FLAT_COLOR_ALPHA_TEST) TEXTURE_MUL_FLAT_COLOR_ALPHA_TEST = TextureMulColorAlphaTestEffect::Create(renderer); #if defined(__DAVAENGINE_DIRECTX9__) currentState.direct3DDevice = GetD3DDevice(); #endif RenderManager::LockNonMain(); currentState.Reset(false); hardwareState.Reset(true); #if defined(__DAVAENGINE_OPENGL__) #if !defined(__DAVAENGINE_IPHONE__) && !defined(__DAVAENGINE_ANDROID__)//Dizz: glDisableClientState functions are not supported by GL ES 2.0 glDisableClientState(GL_VERTEX_ARRAY); oldVertexArrayEnabled = 0; glDisableClientState(GL_NORMAL_ARRAY); oldNormalArrayEnabled = 0; for (int k = 0; k < RenderState::MAX_TEXTURE_LEVELS; ++k) { glClientActiveTexture(GL_TEXTURE0 + k); glDisableClientState(GL_TEXTURE_COORD_ARRAY); oldTextureCoordArrayEnabled[k] = 0; } glClientActiveTexture(GL_TEXTURE0); glDisableClientState(GL_COLOR_ARRAY); oldColorArrayEnabled = 0; RenderManager::UnlockNonMain(); #endif #endif frameBufferWidth = _frameBufferWidth; frameBufferHeight = _frameBufferHeight; #if defined (__DAVAENGINE_OPENGL__) // Logger::Debug("[RenderManager::Init] orientation: %d x %d", frameBufferWidth, frameBufferHeight); #else // Logger::Debug("[RenderManager::Init] orientation: %d x %d ", frameBufferWidth, frameBufferHeight); #endif // TODO: Rethink of initialization concepts because they changed pointerArraysRendererState = pointerArraysCurrentState = 0; }
void VCND3D9Shader::RenderIndexedPrimitive( VCNPrimitiveType primitiveType, VCNInt baseVertexIndex, VCNUInt minVertexIndex, VCNUInt numVertices, VCNUInt startIndex, VCNUInt primCount) { HRESULT hr = S_FALSE; // Get a pointer to the D3D device LPDIRECT3DDEVICE9 device = GetD3DDevice(); // Render primitives hr = device->DrawIndexedPrimitive( (D3DPRIMITIVETYPE)primitiveType, baseVertexIndex, minVertexIndex, numVertices, startIndex, primCount); VCN_ASSERT( hr != D3DERR_INVALIDCALL && "VCNDXShader::RenderIndexedPrimitive - D3DERR_INVALIDCALL!" ); VCN_ASSERT( SUCCEEDED(hr) && "VCNDXShader::RenderIndexedPrimitive - DRAW FAILED!" ); }
//レンダリングターゲットを終了する void DefaultRenderTarget::EndRenderTarget(){ auto Dev = App::GetApp()->GetDeviceResources(); auto pD3D11Device = Dev->GetD3DDevice(); auto pD3D11DeviceContext = Dev->GetD3DDeviceContext(); //ステータスのポインタ //auto RenderStatePtr = App::GetApp()->GetRenderState(); //シェーダーリソースビューのクリア ID3D11ShaderResourceView* pNull[1] = { nullptr }; pD3D11DeviceContext->PSSetShaderResources(0, _countof(pNull), pNull); pD3D11DeviceContext->PSSetShaderResources(1, _countof(pNull), pNull); //シェーダーは指定しない pD3D11DeviceContext->VSSetShader(nullptr, nullptr, 0); pD3D11DeviceContext->PSSetShader(nullptr, nullptr, 0); pD3D11DeviceContext->GSSetShader(nullptr, nullptr, 0); //ブレンドは指定しない pD3D11DeviceContext->OMSetBlendState(nullptr, nullptr, 0xffffffff); }
void D3D9Mesh::NPatchEnhance(float segs, bool quadratic) { DWORD *adj; Unlock(); //get the _Mesh adjacency (needed by NPatchEnhance) GenerateAdj(adj); LPD3DXMESH sphere; //do the n-patching using the DirectX function D3DXTessellateNPatches(_Mesh, adj, segs, quadratic, &sphere, NULL); FreeMemory(); //load the data into sphere->CloneMeshFVF(D3DMeshOptions, D3DMeshFVF, GetD3DDevice(), &_Mesh); sphere->Release(); delete[] adj; }
void D3D9Mesh::SimplifyToVertices(UINT Count) { Lock(); Unlock(); DWORD *Adj; Clean(1e-6f, Adj); LPD3DXMESH NewMesh = NULL; D3DAlwaysValidate(D3DXSimplifyMesh(_Mesh, Adj, NULL, NULL, Count, D3DXMESHSIMP_VERTEX, &NewMesh), "D3DXSimplifyMesh"); _Mesh->Release(); D3DAlwaysValidate(NewMesh->CloneMeshFVF(D3DMeshOptions, D3DMeshFVF, GetD3DDevice(), &_Mesh), "CloneMeshFVF"); NewMesh->Release(); delete[] Adj; Lock(); Unlock(); }
/* ----------------------------------------------------------------------------- TextureManager ----------------------------------------------------------------------------- */ rxTextureManager::rxTextureManager() { gCore.resources->SetManager( Asset_Texture2D, this ); // Create a 1x1 texture filled with white color. { const DXGI_FORMAT textureFormat = DXGI_FORMAT_R8G8B8A8_UNORM; const UINT textureWidth = 1; const UINT textureHeight = 1; DX11::Texture2DDescription texDesc( textureFormat, textureWidth, textureHeight ); texDesc .ArraySize_(1) .MipLevels_(1) .SampleCount_(1) .SampleQuality_(0) .Usage_(D3D11_USAGE_IMMUTABLE) .BindFlags_(D3D11_BIND_SHADER_RESOURCE) .CPUAccessFlags_(0) ; R8G8B8A8 whiteColorRGBA; whiteColorRGBA.asU32 = BITS_ALL; D3D11_SUBRESOURCE_DATA initialData; initialData.pSysMem = &whiteColorRGBA; initialData.SysMemPitch = sizeof whiteColorRGBA; initialData.SysMemSlicePitch = nil; ID3D11Device* pD3DDevice = GetD3DDevice(); dxchk(pD3DDevice->CreateTexture2D( &texDesc, &initialData, c_cast(ID3D11Texture2D**) &m_defaultTexture.pTexture.Ptr )); D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; D3D_GetTexture2D_ShaderResourceView_Desc( textureFormat, srvDesc ); dxchk(pD3DDevice->CreateShaderResourceView( m_defaultTexture.pTexture, &srvDesc, &m_defaultTexture.pSRV.Ptr )); } }
void D3D9Mesh::Clean(float Epsilon, DWORD* &AdjDataOut) { Assert(_Mesh != NULL, "Clean called on empty _Mesh."); LPD3DXMESH NewMesh; DWORD *AdjData = new DWORD[3 * _Mesh->GetNumFaces()]; AdjDataOut = new DWORD[3 * _Mesh->GetNumFaces()]; DWORD *FaceRemap = new DWORD[3 * _Mesh->GetNumFaces()]; /*D3DXWELDEPSILONS Eps; Eps.Position = Epsilon; Eps.BlendWeights = 1.0f; Eps.Normal = 1.0f; Eps.PSize = 1.0f; Eps.Specular = 1.0f; Eps.Diffuse = 1.0f; Eps.Tangent = 1.0f; Eps.Binormal = 1.0f; Eps.TessFactor = 1.0f; for(UINT _Indices = 0; _Indices < 8; _Indices++) { Eps.Texcoord[_Indices] = 1.0f; }*/ CleanVerticesAndTriangles(); Unlock(); //D3DAlwaysValidate(_Mesh->GenerateAdjacency(Epsilon, AdjDataOut)); //D3DAlwaysValidate(D3DXWeldVertices(_Mesh, D3DXWELDEPSILONS_WELDPARTIALMATCHES, &Eps, AdjDataOut, AdjData, FaceRemap, NULL)); //D3DAlwaysValidate(D3DXWeldVertices(_Mesh, D3DXWELDEPSILONS_WELDALL | D3DXWELDEPSILONS_WELDPARTIALMATCHES, NULL, AdjDataOut, AdjData, FaceRemap, NULL)); //CleanTriangles(); D3DAlwaysValidate(_Mesh->GenerateAdjacency(Epsilon, AdjData), "GenerateAdjacency"); D3DAlwaysValidate(D3DXCleanMesh(D3DXCLEAN_SIMPLIFICATION, _Mesh, AdjData, &NewMesh, AdjDataOut, NULL), "D3DXCleanMesh"); _Mesh->Release(); D3DAlwaysValidate(NewMesh->CloneMeshFVF(D3DMeshOptions, D3DMeshFVF, GetD3DDevice(), &_Mesh), "CloneMeshFVF"); NewMesh->Release(); Lock(); Unlock(); delete[] AdjData; delete[] FaceRemap; }