//============================================================================================================================== bool OBJMeshShader::Initialize() { ConstantBuffer<ZShadeSandboxLighting::cbMaterialShadingBuffer> objShadingCB(m_pD3DSystem); objShadingCB.Initialize(PAD16(sizeof(ZShadeSandboxLighting::cbMaterialShadingBuffer))); m_pShadingCB = objShadingCB.Buffer(); ConstantBuffer<cbMatrixBuffer> matrixBufferCB(m_pD3DSystem); matrixBufferCB.Initialize(PAD16(sizeof(cbMatrixBuffer))); m_pMatrixCB = matrixBufferCB.Buffer(); ConstantBuffer<ZShadeSandboxLighting::cbLightBuffer> lightCB(m_pD3DSystem); lightCB.Initialize(PAD16(sizeof(ZShadeSandboxLighting::cbLightBuffer))); m_pLightCB = lightCB.Buffer(); ConstantBuffer<ZShadeSandboxLighting::cbSunLightBuffer> sunCB(m_pD3DSystem); sunCB.Initialize(PAD16(sizeof(ZShadeSandboxLighting::cbSunLightBuffer))); m_pSunCB = sunCB.Buffer(); ClearInputLayout(); SetInputLayoutDesc("OBJMeshShader", ZShadeSandboxMesh::VertexLayout::mesh_layout_pos_normal_tex, 3); LoadVertexShader("OBJMeshVS"); LoadPixelShader("OBJMeshPS"); LoadPixelShader("OBJMeshWireframePS"); AssignVertexShaderLayout("OBJMeshShader"); return true; }
//============================================================================================================================== bool DeferredShader::Initialize() { ConstantBuffer<cbPackBuffer> packCB(m_pD3DSystem); packCB.Initialize(PAD16(sizeof(cbPackBuffer))); m_pPackCB = packCB.Buffer(); ConstantBuffer<cbMatrixBuffer> matrixCB(m_pD3DSystem); matrixCB.Initialize(PAD16(sizeof(cbMatrixBuffer))); m_pMatrixCB = matrixCB.Buffer(); ConstantBuffer<cbMatrixBuffer2> matrix2CB(m_pD3DSystem); matrix2CB.Initialize(PAD16(sizeof(cbMatrixBuffer2))); m_pMatrix2CB = matrix2CB.Buffer(); ClearInputLayout(); SetInputLayoutDesc("DeferredShader", ZShadeSandboxMesh::VertexLayout::mesh_layout_pos_normal_tex, 3); LoadVertexShader("DeferredShaderVS"); LoadPixelShader("DeferredShaderPS"); LoadPixelShader("DeferredShaderWireframePS"); AssignVertexShaderLayout("DeferredShader"); return true; }
//============================================================================================================================== bool TerrainTessellationQuadShadowShader::Initialize() { ConstantBuffer<cTessellationBuffer> tessellationCB(m_pD3DSystem); tessellationCB.Initialize(PAD16(sizeof(cTessellationBuffer))); m_pTessellationCB = tessellationCB.Buffer(); ConstantBuffer<cDomainConstBuffer> domainCB(m_pD3DSystem); domainCB.Initialize(PAD16(sizeof(cDomainConstBuffer))); m_pDomainCB = domainCB.Buffer(); ConstantBuffer<cMatrixBuffer> matrixBufferCB(m_pD3DSystem); matrixBufferCB.Initialize(PAD16(sizeof(cMatrixBuffer))); m_pMatrixBufferCB = matrixBufferCB.Buffer(); ClearInputLayout(); SetInputLayoutDesc("TerrainTessellationQuadShadowShader", ZShadeSandboxMesh::VertexLayout::mesh_layout_pos_tex, 2); LoadVertexShader("TerrainTessellationQuadVS"); LoadHullShader("TerrainTessellationQuadShadowHS"); LoadDomainShader("TerrainTessellationQuadDS"); LoadPixelShader("TerrainTessellationShadowPS"); AssignVertexShaderLayout("TerrainTessellationQuadShadowShader"); return true; }
//================================================================================================================================== HDR::HDR(D3D* d3d) : PostProcess(d3d) //, hdrTarget(0) , luminance(0) , bright(0) , summed(0) , blurredH(0) , blurredHV(0) , m_pBloomConstants(0) , m_pCSConstants(0) { mType = EPostProcessTypes::Type::eHDR; ConstantBuffer<cbBloomConstants> bloomCB(mD3DSystem); bloomCB.Initialize(PAD16(sizeof(cbBloomConstants))); m_pBloomConstants = bloomCB.Buffer(); ConstantBuffer<cbConstants> constCB(mD3DSystem); constCB.Initialize(PAD16(sizeof(cbConstants))); m_pCSConstants = constCB.Buffer(); int backbufferWidth = mD3DSystem->GetEngineOptions()->m_screenWidth; int backbufferHeight = mD3DSystem->GetEngineOptions()->m_screenHeight; // Float format will change the bandwidth needed. //#define FLOAT_FORMAT DXGI_FORMAT_R32G32B32A32_FLOAT //#define FLOAT_FORMAT DXGI_FORMAT_R16G16B16A16_FLOAT #define FLOAT_FORMAT DXGI_FORMAT_R11G11B10_FLOAT UINT bindflags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET; //target = PostProcessManager::CreateRenderTarget(backbufferWidth, backbufferHeight, FLOAT_FORMAT, bindflags, 2); bindflags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS; luminance = PostProcessManager::CreateRenderTarget(backbufferWidth / 2, backbufferHeight / 2, DXGI_FORMAT_R32_FLOAT, bindflags, 1); summed = PostProcessManager::CreateRenderTarget(backbufferWidth / 2, backbufferHeight / 2, FLOAT_FORMAT, bindflags, BLUR_LEVELS); blurredH = PostProcessManager::CreateRenderTarget(backbufferWidth / 2, backbufferHeight / 2, FLOAT_FORMAT, bindflags, BLUR_LEVELS); blurredHV = PostProcessManager::CreateRenderTarget(backbufferWidth / 2, backbufferHeight / 2, FLOAT_FORMAT, bindflags, BLUR_LEVELS); bright = PostProcessManager::CreateRenderTarget(backbufferWidth / 2, backbufferHeight / 2, FLOAT_FORMAT, bindflags, BLUR_LEVELS); fMiddleGreyValue = 5.0f; fBloomThreshold = 1.8f; fBloomMultiplier = 2.0f; PostProcessManager::mShader->LoadComputeShader("GetAvgLum"); PostProcessManager::mShader->LoadComputeShader("BlurHorizontal"); PostProcessManager::mShader->LoadComputeShader("BlurVertical"); PostProcessManager::mShader->LoadComputeShader("Add"); PostProcessManager::mShader->LoadComputeShader("ComputeLuminanceAndBright"); PostProcessManager::mShader->LoadPixelShader("ToneMapWithBloom"); }
//============================================================================================================================== bool AmbientLightDeferredShader::Initialize() { ConstantBuffer<cbDeferredLightBuffer> lightCB(m_pD3DSystem); lightCB.Initialize(PAD16(sizeof(cbDeferredLightBuffer))); m_pLightCB = lightCB.Buffer(); LoadVertexShader("AmbientLightDeferredVS"); LoadPixelShader("AmbientLightDeferredPS"); LoadPixelShader("AmbientLightDeferredWireframePS"); return true; }
//============================================================================================================================== bool OBJMeshShader::Initialize() { ConstantBuffer<cbOBJShadingConst> objShadingCB(m_pD3DSystem); objShadingCB.Initialize(PAD16(sizeof(cbOBJShadingConst))); m_pOBJShadingCB = objShadingCB.Buffer(); ConstantBuffer<cbMatrixBuffer> matrixBufferCB(m_pD3DSystem); matrixBufferCB.Initialize(PAD16(sizeof(cbMatrixBuffer))); m_pMatrixBufferCB = matrixBufferCB.Buffer(); ClearInputLayout(); SetInputLayoutDesc("OBJMeshShader", ZShadeSandboxMesh::VertexLayout::mesh_layout_pos_normal_tex, 3); LoadVertexShader("OBJMeshVS"); LoadPixelShader("OBJMeshPS"); LoadPixelShader("OBJMeshWireframePS"); AssignVertexShaderLayout("OBJMeshShader"); return true; }
//============================================================================================================================== bool DebugGBufferDeferredShader::Initialize() { ConstantBuffer<cbInvMatrixBuffer> matrixCB(m_pD3DSystem); matrixCB.Initialize(PAD16(sizeof(cbInvMatrixBuffer))); m_pMatrixCB = matrixCB.Buffer(); LoadVertexShader("DebugGBufferDeferredVS"); LoadPixelShader("DebugGBufferDeferredPS"); LoadPixelShader("DebugGBufferDepthDeferredPS"); LoadPixelShader("DebugGBufferDeferredWireframePS"); return true; }
//============================================================================================================================== bool TriMaterialTessellationShader::Initialize() { ConstantBuffer<cTessellationBuffer> tessellationCB(m_pD3DSystem); tessellationCB.Initialize(PAD16(sizeof(cTessellationBuffer))); m_pTessellationCB = tessellationCB.Buffer(); ConstantBuffer<Const_Per_Frame> perFrameCB(m_pD3DSystem); perFrameCB.Initialize(PAD16(sizeof(Const_Per_Frame))); m_pPerFrameCB = perFrameCB.Buffer(); ConstantBuffer<Const_Per_Object> perObjectCB(m_pD3DSystem); perObjectCB.Initialize(PAD16(sizeof(Const_Per_Object))); m_pPerObjectCB = perObjectCB.Buffer(); ConstantBuffer<ZShadeSandboxLighting::cbLightBuffer> lightCB(m_pD3DSystem); lightCB.Initialize(PAD16(sizeof(ZShadeSandboxLighting::cbLightBuffer))); m_pLightCB = lightCB.Buffer(); ConstantBuffer<ZShadeSandboxLighting::cbSunLightBuffer> sunCB(m_pD3DSystem); sunCB.Initialize(PAD16(sizeof(ZShadeSandboxLighting::cbSunLightBuffer))); m_pSunCB = sunCB.Buffer(); ClearInputLayout(); SetInputLayoutDesc("TriMaterialTessellationShader", ZShadeSandboxMesh::VertexLayout::mesh_layout_pos_normal_tex, 3); LoadVertexShader("MaterialTessellationShaderVS"); LoadHullShader("TriMaterialTessellationShaderHS"); LoadDomainShader("TriMaterialTessellationShaderDS"); LoadPixelShader("MaterialTessellationShaderPS"); LoadPixelShader("MaterialTessellationShaderWireframePS"); AssignVertexShaderLayout("TriMaterialTessellationShader"); bFlipHorizontally = false; bFlipVertically = false; return true; }
//============================================================================================================================== bool ShadowMapBuildShader::Initialize() { ConstantBuffer<cbShadowMapConst> shadowMapCB(m_pD3DSystem); shadowMapCB.Initialize(PAD16(sizeof(cbShadowMapConst))); m_pShadowMapCB = shadowMapCB.Buffer(); ClearInputLayout(); //SetInputLayoutDesc("ShadowMapBuildShader", ZShadeSandboxMesh::VertexLayout::mesh_layout_pos, 1); SetInputLayoutDesc("ShadowMapBuildShader", ZShadeSandboxMesh::VertexLayout::mesh_layout_pos_normal_tex, 3); LoadVertexShader("ShadowMapBuilderVS"); LoadPixelShader("ShadowMapBuilderPS"); AssignVertexShaderLayout("ShadowMapBuildShader"); return true; }
//============================================================================================================================== bool TerrainTessellationQuadSSAOShader::Initialize() { ConstantBuffer<cTessellationBuffer> tessellationCB(m_pD3DSystem); tessellationCB.Initialize(PAD16(sizeof(cTessellationBuffer))); m_pTessellationCB = tessellationCB.Buffer(); ConstantBuffer<cDomainConstBuffer> domainCB(m_pD3DSystem); domainCB.Initialize(PAD16(sizeof(cDomainConstBuffer))); m_pDomainCB = domainCB.Buffer(); ConstantBuffer<cMatrixBuffer> matrixBufferCB(m_pD3DSystem); matrixBufferCB.Initialize(PAD16(sizeof(cMatrixBuffer))); m_pMatrixBufferCB = matrixBufferCB.Buffer(); ConstantBuffer<cShadingConstBuffer> shadingCB(m_pD3DSystem); shadingCB.Initialize(PAD16(sizeof(cShadingConstBuffer))); m_pShadingCB = shadingCB.Buffer(); ConstantBuffer<ZShadeSandboxLighting::cbLightBuffer> lightCB(m_pD3DSystem); lightCB.Initialize(PAD16(sizeof(ZShadeSandboxLighting::cbLightBuffer))); m_pLightCB = lightCB.Buffer(); ConstantBuffer<ZShadeSandboxLighting::cbSunLightBuffer> sunCB(m_pD3DSystem); sunCB.Initialize(PAD16(sizeof(ZShadeSandboxLighting::cbSunLightBuffer))); m_pSunCB = sunCB.Buffer(); ClearInputLayout(); SetInputLayoutDesc("TerrainTessellationQuadSSAOShader", ZShadeSandboxMesh::VertexLayout::mesh_layout_pos_tex, 2); LoadVertexShader("TerrainTessellationQuadVS"); LoadHullShader("TerrainTessellationQuadShadowHS"); LoadDomainShader("TerrainTessellationQuadDS"); LoadPixelShader("TerrainTessellationNormalDepthPS"); AssignVertexShaderLayout("TerrainTessellationQuadSSAOShader"); return true; }
//============================================================================================================================== bool MaterialTessellationShader::Initialize() { ConstantBuffer<ZShadeSandboxLighting::cbMaterialTessellationBuffer> tessellationCB(m_pD3DSystem); tessellationCB.Initialize(PAD16(sizeof(ZShadeSandboxLighting::cbMaterialTessellationBuffer))); m_pTessellationCB = tessellationCB.Buffer(); ConstantBuffer<ZShadeSandboxLighting::cbMaterialDomainBuffer> domainCB(m_pD3DSystem); domainCB.Initialize(PAD16(sizeof(ZShadeSandboxLighting::cbMaterialDomainBuffer))); m_pDomainCB = domainCB.Buffer(); ConstantBuffer<ZShadeSandboxLighting::cbMaterialShadingBuffer> shadingCB(m_pD3DSystem); shadingCB.Initialize(PAD16(sizeof(ZShadeSandboxLighting::cbMaterialShadingBuffer))); m_pShadingCB = shadingCB.Buffer(); ConstantBuffer<ZShadeSandboxLighting::cbLightBuffer> lightCB(m_pD3DSystem); lightCB.Initialize(PAD16(sizeof(ZShadeSandboxLighting::cbLightBuffer))); m_pLightCB = lightCB.Buffer(); ConstantBuffer<ZShadeSandboxLighting::cbSunLightBuffer> sunCB(m_pD3DSystem); sunCB.Initialize(PAD16(sizeof(ZShadeSandboxLighting::cbSunLightBuffer))); m_pSunCB = sunCB.Buffer(); ClearInputLayout(); SetInputLayoutDesc("MaterialTessellationShader", ZShadeSandboxMesh::VertexLayout::mesh_layout_pos_normal_tex, 3); switch (mType) { case ZShadeSandboxLighting::EMaterialTessellationType::Type::eQuad: { LoadVertexShader("QuadMaterialTessellationVS"); LoadHullShader("QuadMaterialTessellationHS"); LoadDomainShader("QuadMaterialTessellationDS"); LoadPixelShader("QuadMaterialTessellationPS"); LoadPixelShader("QuadMaterialTessellationWireframePS"); } break; case ZShadeSandboxLighting::EMaterialTessellationType::Type::eTri: { LoadVertexShader("TriMaterialTessellationVS"); LoadHullShader("TriMaterialTessellationHS"); LoadDomainShader("TriMaterialTessellationDS"); LoadPixelShader("TriMaterialTessellationPS"); LoadPixelShader("TriMaterialTessellationWireframePS"); } break; } AssignVertexShaderLayout("MaterialTessellationShader"); // Instancing SetInputLayoutDesc("MaterialTessellationShaderInstance", ZShadeSandboxMesh::VertexLayout::mesh_layout_pos_normal_tex_instance, 4); switch (mType) { case ZShadeSandboxLighting::EMaterialTessellationType::Type::eQuad: { LoadVertexShader("QuadMaterialTessellationInstanceVS"); } break; case ZShadeSandboxLighting::EMaterialTessellationType::Type::eTri: { LoadVertexShader("TriMaterialTessellationInstanceVS"); } break; } AssignVertexShaderLayout("MaterialTessellationShaderInstance"); return true; }
OceanSimulator::OceanSimulator(OceanParameter& params, ID3D11Device* pd3dDevice) { HRESULT hr; // If the device becomes invalid at some point, delete current instance and generate a new one. m_pd3dDevice = pd3dDevice; m_pd3dDevice->GetImmediateContext(&m_pd3dImmediateContext); // Height map H(0) int height_map_size = (params.dmap_dim + 4) * (params.dmap_dim + 1); D3DXVECTOR2* h0_data = new D3DXVECTOR2[height_map_size * sizeof(D3DXVECTOR2)]; float* omega_data = new float[height_map_size * sizeof(float)]; initHeightMap(params, h0_data, omega_data); m_param = params; int hmap_dim = params.dmap_dim; int input_full_size = (hmap_dim + 4) * (hmap_dim + 1); // This value should be (hmap_dim / 2 + 1) * hmap_dim, but we use full sized buffer here for simplicity. int input_half_size = hmap_dim * hmap_dim; int output_size = hmap_dim * hmap_dim; // For filling the buffer with zeroes. char* zero_data = new char[3 * output_size * sizeof(float) * 2]; memset(zero_data, 0, 3 * output_size * sizeof(float) * 2); // RW buffer allocations // H0 UINT float2_stride = 2 * sizeof(float); createBufferAndUAV(m_pd3dDevice, h0_data, input_full_size * float2_stride, float2_stride, &m_pBuffer_Float2_H0, &m_pUAV_H0, &m_pSRV_H0); // Notice: The following 3 buffers should be half sized buffer because of conjugate symmetric input. But // we use full sized buffers due to the CS4.0 restriction. // Put H(t), Dx(t) and Dy(t) into one buffer because CS4.0 allows only 1 UAV at a time createBufferAndUAV(m_pd3dDevice, zero_data, 3 * input_half_size * float2_stride, float2_stride, &m_pBuffer_Float2_Ht, &m_pUAV_Ht, &m_pSRV_Ht); // omega createBufferAndUAV(m_pd3dDevice, omega_data, input_full_size * sizeof(float), sizeof(float), &m_pBuffer_Float_Omega, &m_pUAV_Omega, &m_pSRV_Omega); // Notice: The following 3 should be real number data. But here we use the complex numbers and C2C FFT // due to the CS4.0 restriction. // Put Dz, Dx and Dy into one buffer because CS4.0 allows only 1 UAV at a time createBufferAndUAV(m_pd3dDevice, zero_data, 3 * output_size * float2_stride, float2_stride, &m_pBuffer_Float_Dxyz, &m_pUAV_Dxyz, &m_pSRV_Dxyz); SAFE_DELETE_ARRAY(zero_data); SAFE_DELETE_ARRAY(h0_data); SAFE_DELETE_ARRAY(omega_data); // D3D11 Textures createTextureAndViews(m_pd3dDevice, hmap_dim, hmap_dim, DXGI_FORMAT_R32G32B32A32_FLOAT, &m_pDisplacementMap, &m_pDisplacementSRV, &m_pDisplacementRTV); createTextureAndViews(m_pd3dDevice, hmap_dim, hmap_dim, DXGI_FORMAT_R16G16B16A16_FLOAT, &m_pGradientMap, &m_pGradientSRV, &m_pGradientRTV); // Samplers D3D11_SAMPLER_DESC sam_desc; sam_desc.Filter = D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT; sam_desc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; sam_desc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; sam_desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP; sam_desc.MipLODBias = 0; sam_desc.MaxAnisotropy = 1; sam_desc.ComparisonFunc = D3D11_COMPARISON_NEVER; sam_desc.BorderColor[0] = 1.0f; sam_desc.BorderColor[1] = 1.0f; sam_desc.BorderColor[2] = 1.0f; sam_desc.BorderColor[3] = 1.0f; sam_desc.MinLOD = -FLT_MAX; sam_desc.MaxLOD = FLT_MAX; m_pd3dDevice->CreateSamplerState(&sam_desc, &m_pPointSamplerState); // Compute shaders ID3DBlob* pBlobUpdateSpectrumCS = NULL; FUtil::CompileShaderFromFile("FFT//ocean_simulator_cs.hlsl", "UpdateSpectrumCS", "cs_4_0", &pBlobUpdateSpectrumCS); m_pd3dDevice->CreateComputeShader(pBlobUpdateSpectrumCS->GetBufferPointer(), pBlobUpdateSpectrumCS->GetBufferSize(), NULL, &m_pUpdateSpectrumCS); SAFE_RELEASE(pBlobUpdateSpectrumCS); // Vertex & pixel shaders ID3DBlob* pBlobQuadVS = NULL; ID3DBlob* pBlobUpdateDisplacementPS = NULL; ID3DBlob* pBlobGenGradientFoldingPS = NULL; FUtil::CompileShaderFromFile("FFT//ocean_simulator_vs_ps.hlsl", "QuadVS", "vs_4_0", &pBlobQuadVS); FUtil::CompileShaderFromFile("FFT//ocean_simulator_vs_ps.hlsl", "UpdateDisplacementPS", "ps_4_0", &pBlobUpdateDisplacementPS); FUtil::CompileShaderFromFile("FFT//ocean_simulator_vs_ps.hlsl", "GenGradientFoldingPS", "ps_4_0", &pBlobGenGradientFoldingPS); m_pd3dDevice->CreateVertexShader(pBlobQuadVS->GetBufferPointer(), pBlobQuadVS->GetBufferSize(), NULL, &m_pQuadVS); m_pd3dDevice->CreatePixelShader(pBlobUpdateDisplacementPS->GetBufferPointer(), pBlobUpdateDisplacementPS->GetBufferSize(), NULL, &m_pUpdateDisplacementPS); m_pd3dDevice->CreatePixelShader(pBlobGenGradientFoldingPS->GetBufferPointer(), pBlobGenGradientFoldingPS->GetBufferSize(), NULL, &m_pGenGradientFoldingPS); SAFE_RELEASE(pBlobUpdateDisplacementPS); SAFE_RELEASE(pBlobGenGradientFoldingPS); // Input layout D3D11_INPUT_ELEMENT_DESC quad_layout_desc[] = { {"POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, }; m_pd3dDevice->CreateInputLayout(quad_layout_desc, 1, pBlobQuadVS->GetBufferPointer(), pBlobQuadVS->GetBufferSize(), &m_pQuadLayout); SAFE_RELEASE(pBlobQuadVS); // Quad vertex buffer D3D11_BUFFER_DESC vb_desc; vb_desc.ByteWidth = 4 * sizeof(D3DXVECTOR4); vb_desc.Usage = D3D11_USAGE_IMMUTABLE; vb_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; vb_desc.CPUAccessFlags = 0; vb_desc.MiscFlags = 0; float quad_verts[] = { -1, -1, 0, 1, -1, 1, 0, 1, 1, -1, 0, 1, 1, 1, 0, 1, }; D3D11_SUBRESOURCE_DATA init_data; init_data.pSysMem = &quad_verts[0]; init_data.SysMemPitch = 0; init_data.SysMemSlicePitch = 0; m_pd3dDevice->CreateBuffer(&vb_desc, &init_data, &m_pQuadVB); // Constant buffers UINT actual_dim = m_param.dmap_dim; UINT input_width = actual_dim + 4; // We use full sized data here. The value "output_width" should be actual_dim/2+1 though. UINT output_width = actual_dim; UINT output_height = actual_dim; UINT dtx_offset = actual_dim * actual_dim; UINT dty_offset = actual_dim * actual_dim * 2; UINT immutable_consts[] = {actual_dim, input_width, output_width, output_height, dtx_offset, dty_offset}; D3D11_SUBRESOURCE_DATA init_cb0 = {&immutable_consts[0], 0, 0}; D3D11_BUFFER_DESC cb_desc; cb_desc.Usage = D3D11_USAGE_IMMUTABLE; cb_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; cb_desc.CPUAccessFlags = 0; cb_desc.MiscFlags = 0; cb_desc.ByteWidth = PAD16(sizeof(immutable_consts)); m_pd3dDevice->CreateBuffer(&cb_desc, &init_cb0, &m_pImmutableCB); ID3D11Buffer* cbs[1] = {m_pImmutableCB}; m_pd3dImmediateContext->CSSetConstantBuffers(0, 1, cbs); m_pd3dImmediateContext->PSSetConstantBuffers(0, 1, cbs); cb_desc.Usage = D3D11_USAGE_DEFAULT; cb_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; cb_desc.CPUAccessFlags = 0; cb_desc.MiscFlags = 0; cb_desc.ByteWidth = PAD16(sizeof(float) * 3); hr = m_pd3dDevice->CreateBuffer(&cb_desc, NULL, &m_pPerFrameCB); // FFT fft512x512_create_plan(&m_fft_plan, m_pd3dDevice, 3); #ifdef CS_DEBUG_BUFFER D3D11_BUFFER_DESC buf_desc; buf_desc.ByteWidth = 3 * input_half_size * float2_stride; buf_desc.Usage = D3D11_USAGE_STAGING; buf_desc.BindFlags = 0; buf_desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; buf_desc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED; buf_desc.StructureByteStride = float2_stride; m_pd3dDevice->CreateBuffer(&buf_desc, NULL, &m_pDebugBuffer); assert(m_pDebugBuffer); #endif }
/*---------------------------------------------------------------------*/ void fill_entry_descriptors( char *image_file, char *img, int img_size, entry_t ** res_entries, int *res_nb_entries ) { int elf_offset; int max_size = 0; int max_name = 0; int i; // Check file integrity if ( ( img_size < ( 16 * 3 ) ) || img[0] != 'R' || img[1] != 'E' || img[2] != 'S' || img[3] != 'E' || img[4] != 'T' ) fatal( "%s is not a valid Playstation 2 ROM image\n", image_file ); // Get number of ROMDIR entries romdir_t *romdir = ( romdir_t * ) img; int offset = 0; entry_t *entries; int nb_entries = 0; while ( romdir[nb_entries].name[0] ) { nb_entries++; offset += 16; if ( offset > img_size ) fatal( "%s is not a valid Playstation 2 ROM image: " "ROMDIR section ended prematuraly\n", image_file ); } // Alloc the resulting entries entries = malloc( sizeof( entry_t ) * nb_entries ); // fill the resulting entries w.r.t the EXTINFO and ROMDIR sections unsigned char *extinfo = img + ( ( nb_entries + 1 ) * sizeof( romdir_t ) ); for ( i = 0; i < nb_entries; i++ ) { //print("%p [%p]\n",extinfo,img); if ( extinfo >= ( unsigned char * ) ( img + img_size ) ) fatal( "%s is not a valid Playstation 2 ROM image: " "EXTINFO section ended prematuraly\n", image_file ); // fill entry infos strcpy( entries[i].name, romdir[i].name ); if ( max_name < strlen( entries[i].name ) ) max_name = strlen( entries[i].name ); entries[i].flags = 0; int size = romdir[i].extinfo_size; while ( size ) { if ( extinfo >= ( unsigned char * ) ( img + img_size ) ) fatal( "%s is not a valid Playstation 2 ROM image: " "EXTINFO section ended prematuraly\n", image_file ); extinfo_t *ei = ( extinfo_t * ) extinfo; switch ( ei->id ) { case EXTINFO_ID_DATE: entries[i].date = *( unsigned int * ) ( ei + 1 ); entries[i].flags |= ENTRY_FLAG_DATE; break; case EXTINFO_ID_VERSION: entries[i].version = ei->value; entries[i].flags |= ENTRY_FLAG_VERSION; break; case EXTINFO_ID_DESCR: strcpy( entries[i].descr, ( char * ) ( ei + 1 ) ); entries[i].flags |= ENTRY_FLAG_DESCR; break; case EXTINFO_ID_NULL: strcpy( entries[i].descr, ( char * ) ( ei + 1 ) ); entries[i].flags |= ENTRY_FLAG_NULL; break; default: fatal( "%s is not a valid Playstation 2 archive: " "invalid EXTINFO id for IRX %s\n", image_file, entries[i].name ); } size -= ( sizeof( extinfo_t ) + ei->size ); extinfo += ( sizeof( extinfo_t ) + ei->size ); } } // The IRX files are located right after sizeof(ROMDIR) + sizeof(EXTINFO) elf_offset = PAD16( romdir[1].size + romdir[2].size ); entries[0].irx_size = romdir[0].size; entries[1].irx_size = romdir[1].size; entries[2].irx_size = romdir[2].size; for ( i = 3; i < nb_entries; i++ ) { entries[i].irx_binary = ( char * ) ( elf_offset + ( int ) img ); entries[i].irx_size = romdir[i].size; elf_offset += PAD16( romdir[i].size ); if ( max_size < romdir[i].size ) max_size = romdir[i].size; } verbose_set_length_of_size_column( digits_in_number( max_size ) ); verbose_set_length_of_name_column( max_name ); *res_entries = entries; *res_nb_entries = nb_entries; }
/*---------------------------------------------------------------------*/ void delete_entries_from_image( char *image_name, char *irx_args[], int num_irx ) { // Read the entire file char *img; int size, i, j; read_file( image_name, &img, &size ); // Fill our entry descriptors entry_t *entry; int nb_entries; fill_entry_descriptors( image_name, img, size, &entry, &nb_entries ); romdir_t *romdir_entry = ( romdir_t * ) img; int romdir_original = 0; int romdir_updated = 0; int extinfo_original = 0; int extinfo_updated = 0; int irx_original = 0; int irx_updated = 0; int new_romdir_size = 0; int new_extinfo_size = 0; int new_irx_size = 0; char *romdir_section = img; char *extinfo_section = romdir_section + romdir_entry[1].size; char *irx_section = extinfo_section + PAD16( romdir_entry[2].size ); if ( verbose ) { int max_name = 0; // find out the size of the name column for ( j = 0; j < num_irx; j++ ) { for ( i = 0; i < nb_entries; i++ ) { if ( strcmp( entry[i].name, irx_args[j] ) == 0 ) { if ( max_name < strlen( entry[i].name ) ) max_name = strlen( entry[i].name ); break; } } } verbose_set_length_of_name_column( max_name ); } // mark irx entries to delete for ( j = 0; j < num_irx; j++ ) { for ( i = 0; i < nb_entries; i++ ) { if ( strcmp( entry[i].name, irx_args[j] ) == 0 ) { if ( verbose ) verbose_print_delete_message( entry[i].name, entry[i].irx_size ); entry[i].name[0] = -1; break; } } if ( i == nb_entries ) fatal( "Entry %s not found in ROM image %s", irx_args[j], image_name ); } // Update all section at once for ( i = 0; i < nb_entries; i++ ) { // pad the previous section with zeros, if any memset( irx_section + irx_updated, 0, PAD16( irx_updated ) - irx_updated ); irx_original = PAD16( irx_original ); irx_updated = PAD16( irx_updated ); new_irx_size = PAD16( new_irx_size ); if ( entry[i].name[0] == -1 ) { // this entry must be deleted if ( i > 2 ) irx_original += romdir_entry[i].size; extinfo_original += romdir_entry[i].extinfo_size; romdir_original += sizeof( romdir_t ); } else { // this entry is kept back if ( i > 2 ) { memmove( irx_section + irx_updated, irx_section + irx_original, romdir_entry[i].size ); irx_original += romdir_entry[i].size; irx_updated += romdir_entry[i].size; new_irx_size += romdir_entry[i].size; } memmove( extinfo_section + extinfo_updated, extinfo_section + extinfo_original, romdir_entry[i].extinfo_size ); extinfo_original += romdir_entry[i].extinfo_size; extinfo_updated += romdir_entry[i].extinfo_size; new_extinfo_size += romdir_entry[i].extinfo_size; memmove( romdir_section + romdir_updated, romdir_section + romdir_original, sizeof( romdir_t ) ); romdir_original += sizeof( romdir_t ); romdir_updated += sizeof( romdir_t ); new_romdir_size += sizeof( romdir_t ); } } // copy the last romdir entry (dummy) memset( romdir_section + romdir_updated, 0, sizeof( romdir_t ) ); romdir_original += sizeof( romdir_t ); romdir_updated += sizeof( romdir_t ); new_romdir_size += sizeof( romdir_t ); // Update the overall size of the previous sections romdir_entry[1].size = new_romdir_size; romdir_entry[2].size = new_extinfo_size; // pad the extinfo section memset( extinfo_section + new_extinfo_size, 0, PAD16( new_extinfo_size ) - new_extinfo_size ); new_extinfo_size = PAD16( new_extinfo_size ); // decal the EXTINFO and IRX sections to their new position memmove( img + new_romdir_size, extinfo_section, new_extinfo_size ); memmove( img + new_romdir_size + new_extinfo_size, irx_section, new_irx_size ); // done ! save the result to disk write_file( image_name, img, new_romdir_size + new_extinfo_size + new_irx_size ); }