Renderer::Renderer() { scene_to_render = nullptr; default_render_shader = new Shader("default_vertex", "default_pixel"); gbuffer_normal_texture = new Texture (D3DXVECTOR3( g_screenWidth, g_screenHeight,1), nullptr, DXGI_FORMAT_R8G8B8A8_UNORM , 0); gbuffer_specular_texture = new Texture(D3DXVECTOR3( g_screenWidth, g_screenHeight,1), nullptr, DXGI_FORMAT_R8G8B8A8_UNORM , 0); gbuffer_albedo_texture = new Texture (D3DXVECTOR3( g_screenWidth, g_screenHeight,1), nullptr, DXGI_FORMAT_R8G8B8A8_UNORM , 0); screen_texture = new Texture(D3DXVECTOR3(g_screenWidth, g_screenHeight, 1), nullptr, DXGI_FORMAT_R8G8B8A8_UNORM, 0); gbuffer_shader = new Shader("default_vertex", "gbuffer_pixel"); full_deferred_diffuse_lighting_shader = new Shader("direct_vertex_position", "full_deferred_diffuse_lighting"); use_postfx = false; camera_ = nullptr; lighting_constants_buffer_gpu = CreateConstantBuffer(sizeof(LightingConstantsBuffer)); mesh_constants_buffer_gpu = CreateConstantBuffer(sizeof(MeshConstantsBuffer)); frame_constans_buffer_gpu = CreateConstantBuffer(sizeof(FrameConstantsBuffer)); SetConstantBufferToSlot(0, frame_constans_buffer_gpu); SetConstantBufferToSlot(1, mesh_constants_buffer_gpu); SetConstantBufferToSlot(2, lighting_constants_buffer_gpu); }
void RenderingContext::Create() { Microsoft::WRL::ComPtr<ID3DBlob> VertexShaderBlob; Microsoft::WRL::ComPtr<ID3DBlob> PixelShaderBlob; GraphicsContext::LoadAndCompileShader(VertexShaderBlob, PixelShaderBlob, IDR_SHADER11, "5_0"); CreateShaders(VertexShaderBlob, PixelShaderBlob); CreateInputLayout(VertexShaderBlob); CreateConstantBuffer(CameraConstantBuffer, sizeof(CameraConstantBufferType)); CreateConstantBuffer(ObjectConstantBuffer, sizeof(ObjectConstantBufferType)); }
bool CEffectVertexShader::Load() { CreateShaderMacro(); ID3DBlob *l_VSBlob = NULL; bool l_Loaded = LoadShader(m_Filename, m_EntryPoint, m_ShaderModel, &l_VSBlob); if (!l_Loaded) return false; /*CRenderManager &l_RenderManager = UABEngine.GetRenderManager(); ID3D11Device *l_Device = l_RenderManager.GetDevice();*/ CRenderManager* l_RenderManager = UABEngine.GetRenderManager(); ID3D11Device *l_Device = l_RenderManager->GetDevice(); HRESULT l_HR = l_Device->CreateVertexShader(l_VSBlob->GetBufferPointer(), l_VSBlob->GetBufferSize(), NULL, &m_VertexShader); if (FAILED(l_HR)) { l_VSBlob->Release(); return false; } if (m_VertexType == "MV_POSITION_NORMAL_TEXTURE_VERTEX") l_Loaded = MV_POSITION_NORMAL_TEXTURE_VERTEX::CreateInputLayout(l_RenderManager, l_VSBlob, &m_VertexLayout); else //Info("Vertex type '%s' not recognized on CEffectVertexShader::Load", m_VertexType.c_str()); printf("Vertex type '%s' not recognized on CEffectVertexShader::Load", m_VertexType.c_str()); l_VSBlob->Release(); if (!l_Loaded) return false; return CreateConstantBuffer(); }
LineRenderer::LineRenderer(ID3D11Device* device) { // create vertex buffer. uint32_t vertCount = 1000; m_vbPC = CreateVertexBuffer(device, VertexFormat::VF_PC, NULL, vertCount, D3D11_USAGE_DYNAMIC); assert(m_vbPC); // compile shaders ID3DBlob* vsBlob = CompileShaderFromResource(L"LineShader.hlsl", "VS","vs_4_0", NULL); ID3DBlob* psBlob = CompileShaderFromResource(L"LineShader.hlsl", "PS","ps_4_0", NULL); assert(vsBlob); assert(psBlob); m_vsShader = CreateVertexShader(device, vsBlob); m_psShader = CreatePixelShader(device, psBlob); assert(m_vsShader); assert(m_psShader); m_vertexLayoutPC = CreateInputLayout(device, vsBlob, VertexFormat::VF_PC); // create constant buffer. m_perframeCB = CreateConstantBuffer(device,sizeof(Matrix)); vsBlob->Release(); psBlob->Release(); }
void D3D11Renderer::InitRendererResources() { static int passes = 0; assert(passes++ == 0); if (!m_transformBuffer) CreateConstantBuffer(&m_transformBuffer, sizeof(XMFLOAT4X4), false, 0); }
bool CEffectPixelShader::Load() { ID3DBlob *l_PSBlob = NULL; bool l_Loaded = LoadShader(m_Filename.c_str(), m_EntryPoint.c_str(), m_ShaderModel.c_str(), &l_PSBlob); if (!l_Loaded) return false; ID3D11Device *l_Device = CEngine::GetSingleton().GetRenderManager()->GetDevice(); HRESULT l_HR = l_Device->CreatePixelShader(l_PSBlob->GetBufferPointer(), l_PSBlob->GetBufferSize(), NULL, &m_PixelShader); l_PSBlob->Release(); return CreateConstantBuffer(); }
bool CEffectShader::CreateConstantBuffer() { CreateConstantBuffer(SCENE_CONSTANT_BUFFER_ID, sizeof(CSceneEffectParameters)); CreateConstantBuffer(LIGHT_CONSTANT_BUFFER_ID, sizeof(CLightEffectParameters)); CreateConstantBuffer(ANIMATED_CONSTANT_BUFFER_ID, sizeof(CAnimatedModelEffectParameters)); /*CreateConstantBuffer( SCENE_CONSTANT_BUFFER_ID, 60*sizeof(float)); CreateConstantBuffer( LIGHT_CONSTANT_BUFFER_ID, 80*sizeof(float)); CreateConstantBuffer( ANIMATED_CONSTANT_BUFFER_ID, 640*sizeof(float));*/ /*CRenderManager* l_RenderManager=UABEngine.GetRenderManager(); ID3D11Device *l_Device=l_RenderManager->GetDevice(); D3D11_BUFFER_DESC l_BufferDescription; ZeroMemory(&l_BufferDescription, sizeof(l_BufferDescription)); l_BufferDescription.Usage=D3D11_USAGE_DEFAULT; l_BufferDescription.ByteWidth=sizeof(CEffectParameters); l_BufferDescription.BindFlags=D3D11_BIND_CONSTANT_BUFFER; l_BufferDescription.CPUAccessFlags=0; if( FAILED(l_Device->CreateBuffer(&l_BufferDescription, NULL,&m_ConstantBuffer))) return false;*/ return true; }
bool CEffectPixelShader::Load() { CreateShaderMacro(); ID3DBlob *l_PSBlob = NULL; bool l_Loaded = LoadShader(m_Filename.c_str(), m_EntryPoint.c_str(), m_ShaderModel.c_str(), &l_PSBlob); if (!l_Loaded) return false; /*CRenderManager &l_RenderManager = UABEngine.GetRenderManager(); ID3D11Device *l_Device = l_RenderManager.GetDevice();*/ CRenderManager* l_RenderManager = UABEngine.GetRenderManager(); ID3D11Device *l_Device = l_RenderManager->GetDevice(); HRESULT l_HR = l_Device->CreatePixelShader(l_PSBlob->GetBufferPointer(), l_PSBlob->GetBufferSize(), NULL, &m_PixelShader); l_PSBlob->Release(); return CreateConstantBuffer(); }
void CubeObject::OnCreate() { CreateBuffers(); m_Scale = Vec3(1.0f, 1.0f, 1.0f); m_Qt.identity(); m_Pos = Vec3(0, 0, 0.0); ///ルートシグネチャ作成 CreateRootSignature(); ///デスクプリタヒープ作成 CreateDescriptorHeap(); ///コンスタントバッファ作成 CreateConstantBuffer(); ///パイプラインステート作成 CreatePipelineState(); ///コマンドリスト作成 CreateCommandList(); //コンスタントバッファの更新 UpdateConstantBuffer(); }
TiledSpriteGroup::TiledSpriteGroup() { InitDrawable(); CountOfSprites=0; SpriteBase=0; mTiledTextureRegion=0; vertices=0; AbsTextureCoordinate(0.0f,0.0f,1.0f,1.0f); HalfTexSize(0,0); VB_Stride = sizeof( Tuxis::Vertex::SpriteGroupVertex ); VB_Offset = 0; mShader = DefaultShaderBase::Instance()->mShaderTiledSpriteGroup; CreateConstantBuffer(sizeof(XMMATRIX),D3D11_USAGE_DEFAULT); }
//-------------------------------------------------------------------------------------- // // OnCreateDevice // // Called when the device is created to create resources for hair rendering // //-------------------------------------------------------------------------------------- HRESULT TressFXRenderer::OnCreateDevice(ID3D11Device* pd3dDevice, int winWidth, int winHeight, bool bShortCutOn) { HRESULT hr; AMD_V_RETURN(CreateShaderAndLayout(pd3dDevice)); AMD_V_RETURN(CreateTextureAndViews(pd3dDevice)); AMD_V_RETURN(CreateConstantBuffer(pd3dDevice)); AMD_V_RETURN(CreateVertexBuffers(pd3dDevice)); AMD_V_RETURN(CreateRenderStateObjects(pd3dDevice)); if (bShortCutOn) { m_ShortCut.OnCreateDevice(pd3dDevice, winWidth, winHeight); } else { AMD_V_RETURN(CreatePPLL(pd3dDevice, winWidth, winHeight, false)); } return S_OK; }
bool BaseApp::Init( HWND hWnd ) { DeviceDx11& refDevice = DeviceDx11::GetInstance(); if( !refDevice.InitDevice( hWnd ) ) { return false; } if( !SetUpDxResource( &refDevice ) ) { return false; } if( !BuildShader( &refDevice ) ) { return false; } m_pObject = new Object(); m_pObject->Init(); if( !CreateVertexBuffer() ) { return false; } if( !CreateIndexBuffer() ) { return false; } if( !CreateConstantBuffer() ) { return false; } return true; }
void Text::Initialize() { mShader = DefaultShaderBase::Instance()->mShaderText; CreateConstantBuffer(sizeof(XMMATRIX),D3D11_USAGE_DEFAULT); SavedStrings.clear(); }
void Sandbox::FluidSimulator::CreateDeviceResources( _No_args_ ) { Sehnsucht::IO::BasicLoader loader( m_d3dDevice, m_wicFactory ); auto loaderPtr = &loader; { // Create shaders loaderPtr->LoadShader( L"DiffusionJacobiCs2.cso", m_diffusionJacobiCs.GetAddressOf( ) ); loaderPtr->LoadShader( L"PressureJacobiCs2.cso", m_pressureJacobiCs.GetAddressOf( ) ); loaderPtr->LoadShader( L"ProjectionCs1.cso", m_fluidProjectionCs.GetAddressOf( ) ); loaderPtr->LoadShader( L"DivergenceCs0.cso", m_fluidDivergenceCs.GetAddressOf( ) ); loaderPtr->LoadShader( L"AdvectionCs1.cso", m_fluidAdvectionCs.GetAddressOf( ) ); loaderPtr->LoadShader( L"GaussianSplatCs0.cso", m_gaussianSplatCs.GetAddressOf( ) ); loaderPtr->LoadShader( L"ZeroTextureCs0.cso", m_zeroCs.GetAddressOf( ) ); loaderPtr->LoadShader( L"CopyTextureCs0.cso", m_copyCs.GetAddressOf( ) ); } { // Create constant buffers loaderPtr->CreateConstantBuffer( m_problemParams.GetAddressOf( ), &m_problemParamsData ); loaderPtr->CreateConstantBuffer( m_forcePerFrame.GetAddressOf( ), &m_forcePerFrameData ); m_cbuffers[ 0 ] = m_problemParams.Get( ); m_cbuffers[ 1 ] = m_forcePerFrame.Get( ); } { // Create textures Rendering::Texture2Description problemTextureDesc; ZeroValue( &problemTextureDesc ); problemTextureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS; problemTextureDesc.Height = _To_uint GetProblemParameters( )->ProblemFactors.y; problemTextureDesc.Width = _To_uint GetProblemParameters( )->ProblemFactors.x; problemTextureDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; problemTextureDesc.Usage = D3D11_USAGE_DEFAULT; problemTextureDesc.SampleDesc.Quality = 0; problemTextureDesc.SampleDesc.Count = 1; problemTextureDesc.MipLevels = 1; problemTextureDesc.ArraySize = 1; m_d3dDevice->CreateTexture2D( &problemTextureDesc, nullptr, m_velocityPingPong0.GetAddressOf( ) ); m_d3dDevice->CreateTexture2D( &problemTextureDesc, nullptr, m_velocityPingPong1.GetAddressOf( ) ); m_d3dDevice->CreateTexture2D( &problemTextureDesc, nullptr, m_pressurePingPong0.GetAddressOf( ) ); m_d3dDevice->CreateTexture2D( &problemTextureDesc, nullptr, m_pressurePingPong1.GetAddressOf( ) ); m_d3dDevice->CreateTexture2D( &problemTextureDesc, nullptr, m_divergence.GetAddressOf( ) ); Rendering::ShaderResourceViewDescription problemTextureSrvDesc; ZeroValue( &problemTextureSrvDesc ); problemTextureSrvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; problemTextureSrvDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; problemTextureSrvDesc.Texture2D.MostDetailedMip = 0; problemTextureSrvDesc.Texture2D.MipLevels = 1; m_d3dDevice->CreateShaderResourceView( m_velocityPingPong0.Get( ), &problemTextureSrvDesc, m_velocityPingPong0Srv.GetAddressOf( ) ); m_d3dDevice->CreateShaderResourceView( m_velocityPingPong1.Get( ), &problemTextureSrvDesc, m_velocityPingPong1Srv.GetAddressOf( ) ); m_d3dDevice->CreateShaderResourceView( m_pressurePingPong0.Get( ), &problemTextureSrvDesc, m_pressurePingPong0Srv.GetAddressOf( ) ); m_d3dDevice->CreateShaderResourceView( m_pressurePingPong1.Get( ), &problemTextureSrvDesc, m_pressurePingPong1Srv.GetAddressOf( ) ); m_d3dDevice->CreateShaderResourceView( m_divergence.Get( ), &problemTextureSrvDesc, m_divergenceSrv.GetAddressOf( ) ); Rendering::UnorderedAccessViewDescription problemTextureUavDesc; ZeroValue( &problemTextureUavDesc ); problemTextureUavDesc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D; problemTextureUavDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; problemTextureUavDesc.Texture2D.MipSlice = 0; m_d3dDevice->CreateUnorderedAccessView( m_velocityPingPong0.Get( ), &problemTextureUavDesc, m_velocityPingPong0Uav.GetAddressOf( ) ); m_d3dDevice->CreateUnorderedAccessView( m_velocityPingPong1.Get( ), &problemTextureUavDesc, m_velocityPingPong1Uav.GetAddressOf( ) ); m_d3dDevice->CreateUnorderedAccessView( m_pressurePingPong0.Get( ), &problemTextureUavDesc, m_pressurePingPong0Uav.GetAddressOf( ) ); m_d3dDevice->CreateUnorderedAccessView( m_pressurePingPong1.Get( ), &problemTextureUavDesc, m_pressurePingPong1Uav.GetAddressOf( ) ); m_d3dDevice->CreateUnorderedAccessView( m_divergence.Get( ), &problemTextureUavDesc, m_divergenceUav.GetAddressOf( ) ); m_d3dContext->CSSetShader( m_zeroCs.Get( ), nullptr, 0u ); m_d3dContext->CSSetUnorderedAccessViews( 0, 1, m_velocityPingPong0Uav.GetAddressOf( ), m_zeroUavInitCounts ); m_d3dContext->Dispatch( problemTextureDesc.Width, problemTextureDesc.Height, 1 ); m_d3dContext->CSSetUnorderedAccessViews( 0, 1, m_velocityPingPong1Uav.GetAddressOf( ), m_zeroUavInitCounts ); m_d3dContext->Dispatch( problemTextureDesc.Width, problemTextureDesc.Height, 1 ); m_d3dContext->CSSetUnorderedAccessViews( 0, 1, m_pressurePingPong0Uav.GetAddressOf( ), m_zeroUavInitCounts ); m_d3dContext->Dispatch( problemTextureDesc.Width, problemTextureDesc.Height, 1 ); m_d3dContext->CSSetUnorderedAccessViews( 0, 1, m_pressurePingPong1Uav.GetAddressOf( ), m_zeroUavInitCounts ); m_d3dContext->Dispatch( problemTextureDesc.Width, problemTextureDesc.Height, 1 ); m_d3dContext->CSSetUnorderedAccessViews( 0, 1, m_divergenceUav.GetAddressOf( ), m_zeroUavInitCounts ); m_d3dContext->Dispatch( problemTextureDesc.Width, problemTextureDesc.Height, 1 ); m_d3dContext->CSSetUnorderedAccessViews( 0, 1, m_nullUavs, m_zeroUavInitCounts ); m_d3dContext->CSSetShader( nullptr, nullptr, 0u ); } { // Create sampler states D3D11_SAMPLER_DESC samplerDesc; ZeroValue( &samplerDesc ); // Create a texture sampler state description. samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; samplerDesc.MaxLOD = D3D11_FLOAT32_MAX; samplerDesc.MaxAnisotropy = 1; m_d3dDevice->CreateSamplerState( &samplerDesc, m_linearSampler.GetAddressOf( ) ); } }
bool CEffectVertexShader::Load() { CreateShaderMacro(); ID3DBlob *l_VSBlob = NULL; bool l_Loaded = LoadShader(m_Filename, m_EntryPoint, m_ShaderModel, &l_VSBlob); DEBUG_ASSERT(l_Loaded); if (!l_Loaded) { return false; } CContextManager &l_context = *CEngine::GetSingleton().getContextManager(); ID3D11Device *l_Device = l_context.GetDevice(); HRESULT l_HR = l_Device->CreateVertexShader(l_VSBlob->GetBufferPointer(), l_VSBlob->GetBufferSize(), NULL, &m_VertexShader); DEBUG_ASSERT(!FAILED(l_HR)); if (FAILED(l_HR)) { l_VSBlob->Release(); return false; } if (m_VertexType == "MV_POSITION_TEXTURE_VERTEX") { l_Loaded = MV_POSITION_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "MV_POSITION_NORMAL_TEXTURE_VERTEX") { l_Loaded = MV_POSITION_NORMAL_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "MV_POSITION4_COLOR_TEXTURE_VERTEX") { l_Loaded = MV_POSITION4_COLOR_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "MV_POSITION_NORMAL_TEXTURE_TEXTURE2_VERTEX") { l_Loaded = MV_POSITION_NORMAL_TEXTURE_TEXTURE2_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_VERTEX") { l_Loaded = MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_TEXTURE2_VERTEX") { l_Loaded = MV_POSITION_NORMAL_TEXTURE_TEXTURE2_TANGENT_BINORMAL_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "MV_POSITION_NORMAL_TEXTURE_WEIGHT_INDICES_VERTEX") { l_Loaded = MV_POSITION_WEIGHT_INDICES_NORMAL_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_WEIGHT_INDICES_VERTEX") { l_Loaded = MV_POSITION_WEIGHT_INDICES_NORMAL_TANGENT_BINORMAL_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_TEXTURE2_WEIGHT_INDICES_VERTEX") { l_Loaded = MV_POSITION_WEIGHT_INDICES_NORMAL_TANGENT_BINORMAL_TEXTURE_TEXTURE2_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "MV_POSITION_NORMAL_TEXTURE_TEXTURE2_TANGENT_BINORMAL_VERTEX") { l_Loaded = MV_POSITION_NORMAL_TEXTURE_TEXTURE2_TANGENT_BINORMAL_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "MV_POSITION_COLOR_VERTEX") { l_Loaded = MV_POSITION_COLOR_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_WEIGHT_INDICES_VERTEX") { l_Loaded = MV_POSITION_WEIGHT_INDICES_NORMAL_TANGENT_BINORMAL_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_TEXTURE2_WEIGHT_INDICES_VERTEX") { l_Loaded = MV_POSITION_WEIGHT_INDICES_NORMAL_TANGENT_BINORMAL_TEXTURE_TEXTURE2_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "PARTICLE_VERTEX") { l_Loaded = PARTICLE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "GUI_VERTEX") { l_Loaded = GUI_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else if (m_VertexType == "GUI_TEXT_VERTEX") { l_Loaded = GUI_TEXT_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout); } else { DEBUG_ASSERT(!"Vertex type '%s' not recognized on CEffectVertexShader::Load"); } l_VSBlob->Release(); DEBUG_ASSERT(l_Loaded); if (!l_Loaded) return false; return CreateConstantBuffer(); }
// -------------------------------------------------------------------------------------------------------------------- bool DynamicStreamingD3D11UpdateSubresource::Init(size_t _maxVertexCount) { D3D11_INPUT_ELEMENT_DESC elements[] = { { "ATTR", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, }; if (!CompileProgram(L"streaming_vb_d3d11_vs.hlsl", &mVertexShader, L"streaming_vb_d3d11_ps.hlsl", &mPixelShader, ArraySize(elements), elements, &mInputLayout)) { return false; } // Constant Buffer HRESULT hr = CreateConstantBuffer(sizeof(Constants), nullptr, &mConstantBuffer); if (FAILED(hr)) { return false; } // Render States { D3D11_RASTERIZER_DESC desc; desc.FillMode = D3D11_FILL_SOLID; desc.CullMode = D3D11_CULL_NONE; desc.FrontCounterClockwise = FALSE; desc.DepthBias = 0; desc.SlopeScaledDepthBias = 0.0f; desc.DepthBiasClamp = 0.0f; desc.DepthClipEnable = FALSE; desc.ScissorEnable = FALSE; desc.MultisampleEnable = FALSE; desc.AntialiasedLineEnable = FALSE; hr = g_d3d_device->CreateRasterizerState(&desc, &mRasterizerState); if (FAILED(hr)) { return false; } } { D3D11_BLEND_DESC desc; desc.AlphaToCoverageEnable = FALSE; desc.IndependentBlendEnable = FALSE; D3D11_RENDER_TARGET_BLEND_DESC& rtDesc = desc.RenderTarget[0]; rtDesc.BlendEnable = TRUE; rtDesc.SrcBlend = D3D11_BLEND_SRC_ALPHA; rtDesc.DestBlend = D3D11_BLEND_INV_SRC_ALPHA; rtDesc.BlendOp = D3D11_BLEND_OP_ADD; rtDesc.SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA; rtDesc.DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA; rtDesc.BlendOpAlpha = D3D11_BLEND_OP_ADD; rtDesc.RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL; hr = g_d3d_device->CreateBlendState(&desc, &mBlendState); if (FAILED(hr)) { return false; } } { D3D11_DEPTH_STENCIL_DESC desc; desc.DepthEnable = FALSE; desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO; desc.DepthFunc = D3D11_COMPARISON_LESS; desc.StencilEnable = FALSE; desc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK; desc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK; desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP; desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS; desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP; desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; desc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS; hr = g_d3d_device->CreateDepthStencilState(&desc, &mDepthStencilState); if (FAILED(hr)) { return false; } } { D3D11_SAMPLER_DESC desc; desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; desc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; desc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; desc.MipLODBias = 0.0f; desc.MaxAnisotropy = 0; desc.ComparisonFunc = D3D11_COMPARISON_NEVER; desc.BorderColor[0] = 0.0f; desc.BorderColor[1] = 0.0f; desc.BorderColor[2] = 0.0f; desc.BorderColor[3] = 0.0f; desc.MinLOD = 0; desc.MaxLOD = D3D11_FLOAT32_MAX; hr = g_d3d_device->CreateSamplerState(&desc, &mSamplerState); if (FAILED(hr)) { return false; } } // Dynamic vertex buffer mParticleBufferSize = kTripleBuffer * sizeof(Vec2) * _maxVertexCount; hr = CreateDynamicVertexBuffer(mParticleBufferSize, nullptr, D3D11_USAGE_DEFAULT, 0, &mDynamicVertexBuffer); if (FAILED(hr)) { return false; } return true; }
void D3D::Create() { // CAMERA XMStoreFloat4x4(view, XMMatrixTranspose(XMMatrixLookAtLH(XMVectorSet(0.0f, 2.0f, -2.0f, 1.0f), XMVectorSet(0.0f, -1.0f, -1.0f, 0.0f), XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f)))); XMStoreFloat4x4(projection, XMMatrixTranspose(XMMatrixPerspectiveFovLH(XM_PI * 0.45f, 640.0f / 480.0f, 1.0f, 1000.0f))); projection->_11 = projection->_22 / (windowWidth / windowHeight); viewMatrix = CreateConstantBuffer(sizeof(XMFLOAT4X4), view); projectionMatrix = CreateConstantBuffer(sizeof(XMFLOAT4X4), projection); // Load bin file std::ifstream infile; infile.open("C:/New folder/pCube1.bin", std::ifstream::binary); if (infile.is_open() == true) { // Main header MainHeader mainHeader; infile.read((char*)&mainHeader, sizeof(MainHeader)); // Mesh header vector<SubMesh> submesh; infile.read((char*)&mesh.header, sizeof(MeshHeader)); // Mesh data mesh.geometry.points.resize(mesh.header.numberPoints); mesh.geometry.normals.resize(mesh.header.numberNormals); mesh.geometry.texCoords.resize(mesh.header.numberCoords); infile.read((char*)mesh.Name.data(), mesh.header.nameLength); infile.read((char*)mesh.geometry.points.data(), mesh.header.numberPoints * sizeof(Point)); infile.read((char*)mesh.geometry.normals.data(), mesh.header.numberNormals * sizeof(Normal)); infile.read((char*)mesh.geometry.texCoords.data(), mesh.header.numberCoords * sizeof(TexCoord)); submesh.resize(mainHeader.meshCount); mesh.geometry.faces.resize(mesh.header.numberFaces); for (size_t i = 0; i < mesh.header.numberFaces; i++) { for (size_t j = 0; j < 3; j++) { infile.read((char*)&mesh.geometry.faces[i].verts[j].pointID, 4); infile.read((char*)&mesh.geometry.faces[i].verts[j].normalID, 4); infile.read((char*)&mesh.geometry.faces[i].verts[j].texCoordID, 4); } } for (size_t i = 0; i < mainHeader.meshCount; i++) { // Mesh header infile.read((char*)&submesh[i].header, sizeof(MeshHeader)); // Mesh data mesh.subMeshes[i].geometry.points.resize(submesh[i].header.numberPoints); mesh.subMeshes[i].geometry.normals.resize(submesh[i].header.numberNormals); mesh.subMeshes[i].geometry.texCoords.resize(submesh[i].header.numberCoords); infile.read((char*)mesh.subMeshes[i].Name.data(), submesh[i].header.nameLength); infile.read((char*)mesh.subMeshes[i].geometry.points.data(), submesh[i].header.numberPoints * sizeof(Point)); infile.read((char*)mesh.subMeshes[i].geometry.normals.data(), submesh[i].header.numberNormals * sizeof(Normal)); infile.read((char*)mesh.subMeshes[i].geometry.texCoords.data(), submesh[i].header.numberCoords * sizeof(TexCoord)); mesh.geometry.faces.resize(submesh[i].header.numberFaces); for (size_t j = 0; j < submesh[i].header.numberFaces; j++) { for (size_t k = 0; k < 3; k++) { infile.read((char*)&submesh[i].geometry.faces[j].verts[k].pointID, 4); infile.read((char*)&submesh[i].geometry.faces[j].verts[k].normalID, 4); infile.read((char*)&submesh[i].geometry.faces[j].verts[k].texCoordID, 4); } } } MatHeader matHeader; infile.read((char*)&matHeader, sizeof(MatHeader)); infile.read((char*)&mesh.material.diffColor, 16); infile.read((char*)mesh.material.diffuseTexture.data(), matHeader.diffuseNameLength); // Crash here on reading of string. infile.read((char*)&mesh.material.specColor, 16); infile.read((char*)mesh.material.specularTexture.data(), matHeader.specularNameLength); // TEST TO PUT THE OBJERCT TOGHETER meshes.push_back(MeshData()); meshes.back().pos.resize(mesh.header.numberFaces * 3); meshes.back().normal.resize(mesh.header.numberFaces * 3); meshes.back().uv.resize(mesh.header.numberFaces * 3); size_t index = 0; for (size_t i = 0; i < mesh.header.numberFaces; i++) { for (size_t j = 0; j < 3; j++) { meshes.back().pos[index].x = mesh.geometry.points[mesh.geometry.faces[i].verts[j].pointID].x; meshes.back().pos[index].y = mesh.geometry.points[mesh.geometry.faces[i].verts[j].pointID].y; meshes.back().pos[index].z = mesh.geometry.points[mesh.geometry.faces[i].verts[j].pointID].z; meshes.back().normal[index] = mesh.geometry.normals[mesh.geometry.faces[i].verts[j].normalID]; meshes.back().uv[index] = mesh.geometry.texCoords[mesh.geometry.faces[i].verts[j].texCoordID]; index++; } } // Vertices meshes.back().meshesBuffer[0] = CreateMesh(sizeof(XMFLOAT3) * meshes.back().pos.size(), meshes.back().pos.data(), meshes.back().pos.size()); meshes.back().meshesBuffer[1] = CreateMesh(sizeof(XMFLOAT3) * meshes.back().normal.size(), meshes.back().normal.data(), meshes.back().normal.size()); meshes.back().meshesBuffer[2] = CreateMesh(sizeof(XMFLOAT2) * meshes.back().uv.size(), meshes.back().uv.data(), meshes.back().uv.size()); // Transform DirectX::XMStoreFloat4x4(&meshes.back().transform, XMMatrixIdentity()); meshes.back().transformBuffer = CreateConstantBuffer(sizeof(XMFLOAT4X4), &meshes.back().transform); // Texture CreateTexture(0); } infile.close(); }
//-------------------------------------------------------------------------------------- // Create any D3D11 resources that aren't dependant on the back buffer //-------------------------------------------------------------------------------------- HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) { DXUT_SetDebugName( pd3dDevice, "Main Device" ); HRESULT hr; ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext(); V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) ); V_RETURN( g_SettingsDlg.OnD3D11CreateDevice( pd3dDevice ) ); g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 ); IDXGIDevice* pDXGIDevice; hr = pd3dDevice->QueryInterface( __uuidof(IDXGIDevice), (VOID**)&pDXGIDevice ); if( SUCCEEDED(hr) ) { IDXGIAdapter* pAdapter; hr = pDXGIDevice->GetAdapter( &pAdapter ); if( SUCCEEDED(hr) ) { DXGI_ADAPTER_DESC AdapterDesc; pAdapter->GetDesc( &AdapterDesc ); SetAdapterInfoForShaderCompilation( AdapterDesc.Description ); SAFE_RELEASE( pAdapter ); } SAFE_RELEASE( pDXGIDevice ); } ID3D10Blob* pVSBlob = NULL; g_pVSTransform = CompileVertexShader( pd3dDevice, L"SceneRender.hlsl", "VSTransform", &pVSBlob ); g_pPSSceneRender = CompilePixelShader( pd3dDevice, L"SceneRender.hlsl", "PSSceneRender" ); g_pPSSceneRenderArray = CompilePixelShader( pd3dDevice, L"SceneRender.hlsl", "PSSceneRenderArray" ); g_pPSSceneRenderQuilt = CompilePixelShader( pd3dDevice, L"SceneRender.hlsl", "PSSceneRenderQuilt" ); // Create a layout for the object data const D3D11_INPUT_ELEMENT_DESC layout[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }, }; V_RETURN( pd3dDevice->CreateInputLayout( layout, ARRAYSIZE( layout ), pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), &g_pDefaultInputLayout ) ); // No longer need the shader blobs SAFE_RELEASE( pVSBlob ); // Create state objects D3D11_SAMPLER_DESC samDesc; ZeroMemory( &samDesc, sizeof(samDesc) ); samDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; samDesc.AddressU = samDesc.AddressV = samDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; samDesc.MaxAnisotropy = 1; samDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS; samDesc.MaxLOD = D3D11_FLOAT32_MAX; V_RETURN( pd3dDevice->CreateSamplerState( &samDesc, &g_pSamLinear ) ); DXUT_SetDebugName( g_pSamLinear, "Linear" ); D3D11_BLEND_DESC BlendDesc; ZeroMemory( &BlendDesc, sizeof( D3D11_BLEND_DESC ) ); BlendDesc.RenderTarget[0].BlendEnable = FALSE; BlendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA; BlendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA; BlendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD; BlendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA; BlendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO; BlendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD; BlendDesc.RenderTarget[0].RenderTargetWriteMask = D3D10_COLOR_WRITE_ENABLE_ALL; hr = pd3dDevice->CreateBlendState( &BlendDesc, &g_pBlendState ); ASSERT( SUCCEEDED(hr) ); D3D11_DEPTH_STENCIL_DESC DSDesc; ZeroMemory( &DSDesc, sizeof(D3D11_DEPTH_STENCIL_DESC) ); DSDesc.DepthEnable = FALSE; DSDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; DSDesc.DepthFunc = D3D11_COMPARISON_LESS; DSDesc.StencilEnable = FALSE; DSDesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK; DSDesc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK; hr = pd3dDevice->CreateDepthStencilState( &DSDesc, &g_pDepthStencilState ); ASSERT( SUCCEEDED(hr) ); D3D11_RASTERIZER_DESC RSDesc; ZeroMemory( &RSDesc, sizeof(RSDesc) ); RSDesc.AntialiasedLineEnable = FALSE; RSDesc.CullMode = D3D11_CULL_BACK; RSDesc.DepthBias = 0; RSDesc.DepthBiasClamp = 0.0f; RSDesc.DepthClipEnable = TRUE; RSDesc.FillMode = D3D11_FILL_SOLID; RSDesc.FrontCounterClockwise = FALSE; RSDesc.MultisampleEnable = TRUE; RSDesc.ScissorEnable = FALSE; RSDesc.SlopeScaledDepthBias = 0.0f; hr = pd3dDevice->CreateRasterizerState( &RSDesc, &g_pRasterizerState ); ASSERT( SUCCEEDED(hr) ); g_pcbVSPerObject11 = CreateConstantBuffer( pd3dDevice, sizeof(CB_VS_PER_OBJECT) ); DXUT_SetDebugName( g_pcbVSPerObject11, "CB_VS_PER_OBJECT" ); // Create other render resources here D3D11_TILED_EMULATION_PARAMETERS EmulationParams; EmulationParams.DefaultPhysicalTileFormat = DXGI_FORMAT_R8G8B8A8_UNORM; EmulationParams.MaxPhysicalTileCount = 1000; D3D11CreateTiledResourceDevice( pd3dDevice, pd3dImmediateContext, &EmulationParams, &g_pd3dDeviceEx ); g_pd3dDeviceEx->CreateTilePool( &g_pTilePool ); g_pTitleResidencyManager = new TitleResidencyManager( pd3dDevice, pd3dImmediateContext, 1, EmulationParams.MaxPhysicalTileCount, g_pTilePool ); ResidencySampleRender::Initialize( pd3dDevice ); g_PageDebugRender.Initialize( pd3dDevice ); CreateSceneGeometry( pd3dDevice ); // Setup the camera's view parameters XMMATRIX matProjection = XMMatrixPerspectiveFovLH( XM_PIDIV4, (FLOAT)pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height, 0.001f, 100.0f ); XMStoreFloat4x4A( &g_matProjection, matProjection ); UpdateViewMatrix(); g_pTitleResidencyManager->StartThreads(); return S_OK; }