bool HookGui::HGWidgetShader::Initialize(VulkanWrapper::Context* _graphicContext) { // Get the model manager VulkanWrapper::ModelManager* modelManager = _graphicContext->GetModelManager(); // Request our widget model object modelManager->RequestObject(&m_WidgetModel, "square"); // Create the instance buffer CreateInstanceBuffer(_graphicContext); // Create the uniform buffer CreateUniformBuffer(_graphicContext); // Create the descriptor set CreateDescriptorSet(_graphicContext); // Create our render pass CreateRenderPass(_graphicContext); // Create the graphic pipeline CreateGraphicsPipeline(_graphicContext); // Create the frame buffers CreateFramebuffers(_graphicContext->GetGraphicInstance(), _graphicContext->GetSwapChain(), m_Framebuffers, m_RenderPass); // Create the command buffer m_CommandBuffer = VWShaderBase::CreateCommandBuffer(_graphicContext, VK_COMMAND_BUFFER_LEVEL_PRIMARY, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT); return true; }
bool D3DPostProcessor::Initialize() { D3D12_DESCRIPTOR_HEAP_DESC sampler_descriptor_heap_desc = {}; sampler_descriptor_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE; sampler_descriptor_heap_desc.NumDescriptors = 8; sampler_descriptor_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER; HRESULT hr = D3D::device->CreateDescriptorHeap(&sampler_descriptor_heap_desc, IID_PPV_ARGS(m_texture_samplers_descriptor_heap.ReleaseAndGetAddressOf())); if (FAILED(hr)) { return false; } texture_sampler_cpu_handle = m_texture_samplers_descriptor_heap->GetCPUDescriptorHandleForHeapStart(); // Lookup tables for samplers static const D3D12_FILTER d3d_sampler_filters[] = { D3D12_FILTER_MIN_MAG_MIP_POINT, D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT }; static const D3D12_TEXTURE_ADDRESS_MODE d3d_address_modes[] = { D3D12_TEXTURE_ADDRESS_MODE_CLAMP, D3D12_TEXTURE_ADDRESS_MODE_WRAP, D3D12_TEXTURE_ADDRESS_MODE_BORDER }; // Create sampler objects to match posible configuration values D3D12_SAMPLER_DESC sampler_desc = { d3d_sampler_filters[0], d3d_address_modes[0], d3d_address_modes[0], D3D12_TEXTURE_ADDRESS_MODE_CLAMP, 0.0f, 1, D3D12_COMPARISON_FUNC_ALWAYS, { 0.0f, 0.0f, 0.0f, 0.0f }, 0.0f, 0.0f }; for (size_t i = 0; i < 2; i++) { for (size_t j = 0; j < 3; j++) { sampler_desc.Filter = d3d_sampler_filters[i]; sampler_desc.AddressU = d3d_address_modes[j]; sampler_desc.AddressV = d3d_address_modes[j]; D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle{ texture_sampler_cpu_handle.ptr + (i * 3 + j) * D3D::sampler_descriptor_size }; D3D::device->CreateSampler(&sampler_desc, cpu_handle); } } // Create VS/GS if (!CreateCommonShaders()) return false; // Uniform buffer if (!CreateUniformBuffer()) return false; // Load the currently-configured shader (this may fail, and that's okay) ReloadShaders(); return true; }
EasyDrawer::EasyDrawer() : m_va(nullptr) , m_vbo(nullptr) , m_ibo(nullptr) , m_ubo(nullptr) , m_shaders(nullptr) { Device *dev = GetDevice(); istSafeAddRef(dev); m_ubo = CreateUniformBuffer(dev, 256, I3D_USAGE_DYNAMIC); m_va = dev->createVertexArray(); m_shaders = EasyShaders::getInstance(); }
bool VKRenderPass::VBuildCommandList() { if (!allocateCommandBuffer()) return false; if (m_instanceBlock.buffer != VK_NULL_HANDLE) DeleteUniformBuffer(m_device, m_instanceBlock); //Create block of data for instance variables if (m_instanceDataSize > 0) { if (!CreateUniformBuffer(m_device, m_instanceDataSize, m_instanceData, &m_instanceBlock)) return false; } //Setup the order of the commands we will issue in the command list BuildRenderRequestHeirarchy(); VkResult err; VKRenderer* renderer = VKRenderer::RendererInstance; VkCommandBufferInheritanceInfo inheritanceInfo = {}; inheritanceInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; inheritanceInfo.pNext = nullptr; inheritanceInfo.renderPass = VK_NULL_HANDLE; inheritanceInfo.subpass = 0; inheritanceInfo.framebuffer = VK_NULL_HANDLE; inheritanceInfo.occlusionQueryEnable = VK_FALSE; inheritanceInfo.queryFlags = 0; inheritanceInfo.pipelineStatistics = 0; VkCommandBufferBeginInfo beginInfo = {}; beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; beginInfo.pNext = nullptr; beginInfo.flags = 0; beginInfo.pInheritanceInfo = &inheritanceInfo; //Get the current clear color from the renderer VkClearValue clearColor = renderer->GetClearColor(); std::vector<VkClearValue> clearValues; for (size_t i = 0; i < m_outputRenderTargets.size(); i++) { VKRenderTargetHandle vkTarget= m_outputRenderTargets[i].DynamicCastHandle<VKRenderTarget>(); const VkClearValue* targetClearColor = vkTarget->GetClearColor(); //If a clear color is provided by the render target, lets use that if (targetClearColor == nullptr) clearValues.push_back(clearColor); else clearValues.push_back(*targetClearColor); } clearValues.push_back({1.0f, 0.0f}); VkRenderPassBeginInfo renderPassBeginInfo = {}; renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; renderPassBeginInfo.pNext = nullptr; renderPassBeginInfo.renderPass = m_renderPass; renderPassBeginInfo.framebuffer = m_framebuffer; renderPassBeginInfo.renderArea.offset.x = 0; renderPassBeginInfo.renderArea.offset.y = 0; renderPassBeginInfo.renderArea.extent.width = m_width; renderPassBeginInfo.renderArea.extent.height = m_height; renderPassBeginInfo.clearValueCount = static_cast<uint32_t>(clearValues.size()); renderPassBeginInfo.pClearValues = clearValues.data(); VkViewport viewport = {}; viewport.width = static_cast<float>(m_width); viewport.height = static_cast<float>(m_height); viewport.minDepth = 0.0f; viewport.maxDepth = 1.0f; VkRect2D scissor = {}; scissor.extent.width = m_width; scissor.extent.height = m_height; scissor.offset.x = 0; scissor.offset.y = 0; err = vkBeginCommandBuffer(m_commandBuffer, &beginInfo); assert(!err); if (err != VK_SUCCESS) { HT_DEBUG_PRINTF("VKRenderPass::VBuildCommandList(): Failed to build command buffer.\n"); return false; } /* BEGIN BUFFER COMMANDS */ vkCmdBeginRenderPass(m_commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); vkCmdSetViewport(m_commandBuffer, 0, 1, &viewport); vkCmdSetScissor(m_commandBuffer, 0, 1, &scissor); std::map<IPipelineHandle, std::vector<RenderableInstances>>::iterator iterator; for (iterator = m_pipelineList.begin(); iterator != m_pipelineList.end(); iterator++) { VKPipelineHandle pipeline = iterator->first.DynamicCastHandle<VKPipeline>(); //Calculate inverse view proj Math::Matrix4 invViewProj = Math::MMMatrixTranspose(Math::MMMatrixInverse(m_view)); m_view = Math::MMMatrixTranspose(m_view); m_proj = Math::MMMatrixTranspose(m_proj); pipeline->VSetMatrix4("pass.0proj", m_proj); pipeline->VSetMatrix4("pass.1view", m_view); pipeline->VSetMatrix4("pass.2invViewProj", invViewProj); pipeline->VSetInt("pass.3width", m_width); pipeline->VSetInt("pass.4height", m_height); pipeline->VUpdate(); VkPipeline vkPipeline = pipeline->GetVKPipeline(); VkPipelineLayout vkPipelineLayout = renderer->GetVKRootLayoutHandle()->VKGetPipelineLayout(); vkCmdBindPipeline(m_commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vkPipeline); pipeline->SendPushConstants(m_commandBuffer, vkPipelineLayout); //Bind input textures if(m_inputTargetDescriptorSets.size() > 0) vkCmdBindDescriptorSets(m_commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vkPipelineLayout, m_firstInputTargetSetIndex, static_cast<uint32_t>(m_inputTargetDescriptorSets.size()), m_inputTargetDescriptorSets.data(), 0, nullptr); std::vector<RenderableInstances> renderables = iterator->second; VkDeviceSize offsets[] = { 0 }; for (uint32_t i = 0; i < renderables.size(); i++) { Renderable renderable = renderables[i].renderable; uint32_t count = renderables[i].count; VKMaterialHandle material = renderable.material.DynamicCastHandle<VKMaterial>(); VKMeshHandle mesh = renderable.mesh.DynamicCastHandle<VKMesh>(); std::vector<VkDescriptorSet> descriptorSets = material->GetVKDescriptorSets(); //Bind material descriptor sets vkCmdBindDescriptorSets(m_commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vkPipelineLayout, 0, static_cast<uint32_t>(descriptorSets.size()), descriptorSets.data(), 0, nullptr); //Bind instance buffer if(m_instanceDataSize > 0) vkCmdBindVertexBuffers(m_commandBuffer, 1, 1, &m_instanceBlock.buffer, offsets); UniformBlock_vk vertBlock = mesh->GetVertexBlock(); UniformBlock_vk indexBlock = mesh->GetIndexBlock(); uint32_t indexCount = mesh->GetIndexCount(); vkCmdBindVertexBuffers(m_commandBuffer, 0, 1, &vertBlock.buffer, offsets); vkCmdBindIndexBuffer(m_commandBuffer, indexBlock.buffer, 0, VK_INDEX_TYPE_UINT32); vkCmdDrawIndexed(m_commandBuffer, indexCount, count, 0, 0, 0); } } vkCmdEndRenderPass(m_commandBuffer); /* END BUFFER COMMANDS */ //Blit to render targets for (size_t i = 0; i < m_outputRenderTargets.size(); i++) { VKRenderTargetHandle renderTarget = m_outputRenderTargets[i].DynamicCastHandle<VKRenderTarget>(); if (!renderTarget->Blit(m_commandBuffer, m_colorImages[i])) return false; } err = vkEndCommandBuffer(m_commandBuffer); assert(!err); if (err != VK_SUCCESS) { HT_DEBUG_PRINTF("VKRenderPass::VBuildCommandList(): Failed to end command buffer.\n"); return false; } //Delete instance data delete[] m_instanceData; m_instanceData = nullptr; m_instanceDataSize = 0; return true; }
void AtmosphereSample::Initialize(IRenderDevice *pDevice, IDeviceContext **ppContexts, Uint32 NumDeferredCtx, ISwapChain *pSwapChain) { const auto& deviceCaps = pDevice->GetDeviceCaps(); if(!deviceCaps.bComputeShadersSupported) { throw std::runtime_error("Compute shaders are required to run this sample"); } SampleBase::Initialize(pDevice, ppContexts, NumDeferredCtx, pSwapChain); m_bIsDXDevice = deviceCaps.DevType == DeviceType::D3D11 || deviceCaps.DevType == DeviceType::D3D12; if( pDevice->GetDeviceCaps().DevType == DeviceType::OpenGLES ) { m_uiShadowMapResolution = 512; m_PPAttribs.m_iFirstCascade = 2; m_PPAttribs.m_uiSingleScatteringMode = SINGLE_SCTR_MODE_LUT; m_TerrainRenderParams.m_iNumShadowCascades = 4; m_TerrainRenderParams.m_iNumRings = 10; m_TerrainRenderParams.m_TexturingMode = RenderingParams::TM_MATERIAL_MASK; } m_f4CustomRlghBeta = m_PPAttribs.m_f4CustomRlghBeta; m_f4CustomMieBeta = m_PPAttribs.m_f4CustomMieBeta; m_strRawDEMDataFile = "Terrain\\HeightMap.tif"; m_strMtrlMaskFile = "Terrain\\Mask.png"; m_strTileTexPaths[0] = "Terrain\\Tiles\\gravel_DM.dds"; m_strTileTexPaths[1] = "Terrain\\Tiles\\grass_DM.dds"; m_strTileTexPaths[2] = "Terrain\\Tiles\\cliff_DM.dds"; m_strTileTexPaths[3] = "Terrain\\Tiles\\snow_DM.dds"; m_strTileTexPaths[4] = "Terrain\\Tiles\\grassDark_DM.dds"; m_strNormalMapTexPaths[0] = "Terrain\\Tiles\\gravel_NM.dds"; m_strNormalMapTexPaths[1] = "Terrain\\Tiles\\grass_NM.dds"; m_strNormalMapTexPaths[2] = "Terrain\\Tiles\\cliff_NM.dds"; m_strNormalMapTexPaths[3] = "Terrain\\Tiles\\Snow_NM.jpg"; m_strNormalMapTexPaths[4] = "Terrain\\Tiles\\grass_NM.dds"; // Create data source try { m_pElevDataSource.reset( new ElevationDataSource(m_strRawDEMDataFile.c_str()) ); m_pElevDataSource->SetOffsets(m_TerrainRenderParams.m_iColOffset, m_TerrainRenderParams.m_iRowOffset); m_fMinElevation = m_pElevDataSource->GetGlobalMinElevation() * m_TerrainRenderParams.m_TerrainAttribs.m_fElevationScale; m_fMaxElevation = m_pElevDataSource->GetGlobalMaxElevation() * m_TerrainRenderParams.m_TerrainAttribs.m_fElevationScale; } catch(const std::exception &) { LOG_ERROR("Failed to create elevation data source"); return; } const Char *strTileTexPaths[EarthHemsiphere::NUM_TILE_TEXTURES], *strNormalMapPaths[EarthHemsiphere::NUM_TILE_TEXTURES]; for(int iTile=0; iTile < _countof(strTileTexPaths); ++iTile ) { strTileTexPaths[iTile] = m_strTileTexPaths[iTile].c_str(); strNormalMapPaths[iTile] = m_strNormalMapTexPaths[iTile].c_str(); } CreateUniformBuffer( pDevice, sizeof( CameraAttribs ), "Camera Attribs CB", &m_pcbCameraAttribs ); CreateUniformBuffer( pDevice, sizeof( LightAttribs ), "Light Attribs CB", &m_pcbLightAttribs ); const auto &SCDesc = pSwapChain->GetDesc(); m_pLightSctrPP.reset( new LightSctrPostProcess(m_pDevice, m_pImmediateContext, SCDesc.ColorBufferFormat, SCDesc.DepthBufferFormat, TEX_FORMAT_R11G11B10_FLOAT) ); auto *pcMediaScatteringParams = m_pLightSctrPP->GetMediaAttribsCB(); m_EarthHemisphere.Create(m_pElevDataSource.get(), m_TerrainRenderParams, m_pDevice, m_pImmediateContext, m_strMtrlMaskFile.c_str(), strTileTexPaths, strNormalMapPaths, m_pcbCameraAttribs, m_pcbLightAttribs, pcMediaScatteringParams ); CreateShadowMap(); // Create a tweak bar TwBar *bar = TwNewBar("Settings"); TwDefine(" GLOBAL fontsize=3 "); int barSize[2] = {300, 900}; #ifdef ANDROID barSize[0] = 800; barSize[1] = 1000; #endif TwSetParam(bar, NULL, "size", TW_PARAM_INT32, 2, barSize); // Add variables to the tweak bar #if 0 float3 axis(-1, 1, 0); m_SpongeRotation = RotationFromAxisAngle(axis, FLOAT_PI/4); TwAddVarRW(bar, "Rotation", TW_TYPE_QUAT4F, &m_SpongeRotation, "opened=true axisz=-z group=Sponge"); #endif TwAddVarRW(bar, "FPS", TW_TYPE_FLOAT, &m_fFPS, "readonly=true"); TwAddVarRW(bar, "Light direction", TW_TYPE_DIR3F, &m_f3LightDir, "opened=true axisz=-z showval=false"); TwAddVarRW(bar, "Camera direction", TW_TYPE_DIR3F, &m_f3CameraDir, "opened=true axisz=-z showval=false"); TwAddVarRW( bar, "Camera altitude", TW_TYPE_FLOAT, &m_f3CameraPos.y, "min=2000 max=100000 step=100 keyincr=PGUP keydecr=PGDOWN" ); // Shadows { // Define a new enum type for the tweak bar TwEnumVal ShadowMapRes[] = // array used to describe the shadow map resolution { { 512, "512" }, { 1024, "1024" }, { 2048, "2048" }, { 4096, "4096" } }; TwType modeType = TwDefineEnum( "Shadow Map Resolution", ShadowMapRes, _countof( ShadowMapRes ) ); // create a new TwType associated to the enum defined by the ShadowMapRes array TwAddVarCB( bar, "Shadow map resolution", modeType, SetShadowMapResCB, GetShadowMapResCB, this, "group=Shadows" ); TwAddVarRW( bar, "Show cascades", TW_TYPE_BOOLCPP, &m_bVisualizeCascades, "group=Shadows" ); TwAddVarRW( bar, "Partitioning factor", TW_TYPE_FLOAT, &m_fCascadePartitioningFactor, "min=0 max=1 step=0.01 group=Shadows" ); TwAddVarRW( bar, "Find best cascade", TW_TYPE_BOOLCPP, &m_TerrainRenderParams.m_bBestCascadeSearch, "group=Shadows" ); TwAddVarRW( bar, "Smooth shadows", TW_TYPE_BOOLCPP, &m_TerrainRenderParams.m_bSmoothShadows, "group=Shadows" ); TwAddVarCB( bar, "Num cascades", TW_TYPE_INT32, SetNumCascadesCB, GetNumCascadesCB, this, "min=1 max=8 group=Shadows" ); } TwAddVarRW( bar, "Enable Light Scattering", TW_TYPE_BOOLCPP, &m_bEnableLightScattering, "" ); // Light scattering GUI controls { TwAddVarRW( bar, "Enable light shafts", TW_TYPE_BOOLCPP, &m_PPAttribs.m_bEnableLightShafts, "group=Scattering" ); // Define a new enum type for the tweak bar TwEnumVal LightSctrTech[] = // array used to describe the shadow map resolution { { LIGHT_SCTR_TECHNIQUE_EPIPOLAR_SAMPLING, "Epipolar" }, { LIGHT_SCTR_TECHNIQUE_BRUTE_FORCE, "Brute force" } }; TwType LightSctrTechType = TwDefineEnum( "Light scattering tech", LightSctrTech, _countof( LightSctrTech ) ); TwAddVarRW( bar, "Light scattering tech", LightSctrTechType, &m_PPAttribs.m_uiLightSctrTechnique, "group=Scattering" ); TwEnumVal Pow2Values[] = { { 1, "1" }, { 2, "2" }, { 4, "4" }, { 8, "8" }, { 16, "16" }, { 32, "32" }, { 64, "64" }, { 128, "128" }, { 256, "256" }, { 512, "512" }, { 1024, "1024" }, { 2048, "2048" } }; TwType BigPow2Enum = TwDefineEnum( "Large powers of two", Pow2Values + 7, 5 ); TwAddVarRW( bar, "NumSlices", BigPow2Enum, &m_PPAttribs.m_uiNumEpipolarSlices, "group=Scattering label=\'Num slices\'" ); TwAddVarRW( bar, "MaxSamples", BigPow2Enum, &m_PPAttribs.m_uiMaxSamplesInSlice, "group=Scattering label=\'Max samples\'" ); TwType SmallPow2Enum = TwDefineEnum( "Small powers of two", Pow2Values+2, 5 ); TwAddVarRW( bar, "IntialStep", SmallPow2Enum, &m_PPAttribs.m_uiInitialSampleStepInSlice, "group=Scattering label=\'Initial step\'" ); TwAddVarRW( bar, "ShowSampling", TW_TYPE_BOOLCPP, &m_PPAttribs.m_bShowSampling, "group=Scattering label=\'Show Sampling\'" ); TwAddVarRW( bar, "RefinementThreshold", TW_TYPE_FLOAT, &m_PPAttribs.m_fRefinementThreshold, "group=Scattering label=\'Refinement Threshold\' min=0.01 max=0.5 step=0.01" ); TwAddVarRW( bar, "1DMinMaxOptimization", TW_TYPE_BOOLCPP, &m_PPAttribs.m_bUse1DMinMaxTree, "group=Scattering label=\'Use 1D min/max trees\'" ); TwAddVarRW( bar, "OptimizeSampleLocations", TW_TYPE_BOOLCPP, &m_PPAttribs.m_bOptimizeSampleLocations, "group=Scattering label=\'Optimize Sample Locations\'" ); TwAddVarRW( bar, "CorrectScattering", TW_TYPE_BOOLCPP, &m_PPAttribs.m_bCorrectScatteringAtDepthBreaks, "group=Scattering label=\'Correct Scattering At Depth Breaks\'" ); TwAddVarRW( bar, "ShowDepthBreaks", TW_TYPE_BOOLCPP, &m_PPAttribs.m_bShowDepthBreaks, "group=Scattering label=\'Show Depth Breaks\'" ); TwAddVarRW( bar, "LightingOnly", TW_TYPE_BOOLCPP, &m_PPAttribs.m_bShowLightingOnly, "group=Scattering label=\'Lighting Only\'" ); //TwAddVarRW( bar, "ScatteringScale", TW_TYPE_FLOAT, &m_fScatteringScale, "group=Scattering label=\'Scattering scale\' min=0 max=2 step=0.1" ); TwAddVarRW( bar, "NumIntegrationSteps", TW_TYPE_UINT32, &m_PPAttribs.m_uiInstrIntegralSteps, "min=5 max=100 step=5 group=Advanced label=\'Num Integrtion Steps\'" ); TwDefine( "Settings/Advanced group=Scattering" ); { TwType EpipoleSamplingDensityEnum = TwDefineEnum( "Epipole sampling density enum", Pow2Values, 4 ); TwAddVarRW( bar, "EpipoleSamplingDensity", EpipoleSamplingDensityEnum, &m_PPAttribs.m_uiEpipoleSamplingDensityFactor, "group=Advanced label=\'Epipole sampling density\'" ); } { TwEnumVal SinglSctrMode[] = { { SINGLE_SCTR_MODE_NONE, "None" }, { SINGLE_SCTR_MODE_INTEGRATION, "Integration" }, { SINGLE_SCTR_MODE_LUT, "Look-up table" } }; TwType SinglSctrModeEnum = TwDefineEnum( "Single scattering mode enum", SinglSctrMode, _countof(SinglSctrMode) ); TwAddVarRW( bar, "SingleSctrMode", SinglSctrModeEnum, &m_PPAttribs.m_uiSingleScatteringMode, "group=Advanced label=\'Single scattering\'" ); } { TwEnumVal MultSctrMode[] = { { MULTIPLE_SCTR_MODE_NONE, "None" }, { MULTIPLE_SCTR_MODE_UNOCCLUDED, "Unoccluded" }, { MULTIPLE_SCTR_MODE_OCCLUDED, "Occluded" } }; TwType MultSctrModeEnum = TwDefineEnum( "Higher-order scattering mode enum", MultSctrMode, _countof( MultSctrMode ) ); TwAddVarRW( bar, "MultipleSctrMode", MultSctrModeEnum, &m_PPAttribs.m_uiMultipleScatteringMode, "group=Advanced label=\'Higher-order scattering\'" ); } { TwEnumVal CascadeProcessingMode[] = { { CASCADE_PROCESSING_MODE_SINGLE_PASS, "Single pass" }, { CASCADE_PROCESSING_MODE_MULTI_PASS, "Multi-pass" }, { CASCADE_PROCESSING_MODE_MULTI_PASS_INST, "Multi-pass inst" } }; TwType CascadeProcessingModeEnum = TwDefineEnum( "Cascade processing mode enum", CascadeProcessingMode, _countof( CascadeProcessingMode ) ); TwAddVarRW( bar, "CascadeProcessingMode", CascadeProcessingModeEnum, &m_PPAttribs.m_uiCascadeProcessingMode, "group=Advanced label=\'Cascade processing mode\'" ); } TwAddVarRW( bar, "FirstCascadeToRayMarch", TW_TYPE_INT32, &m_PPAttribs.m_iFirstCascade, "min=0 max=8 step=1 group=Advanced label=\'Start cascade\'" ); TwAddVarRW( bar, "Is32BitMinMaxShadowMap", TW_TYPE_BOOLCPP, &m_PPAttribs.m_bIs32BitMinMaxMipMap, "group=Advanced label=\'Use 32-bit float min/max SM\'" ); { TwEnumVal RefinementCriterion[] = { { REFINEMENT_CRITERION_DEPTH_DIFF, "Depth difference" }, { REFINEMENT_CRITERION_INSCTR_DIFF, "Scattering difference" } }; TwType CascadeProcessingModeEnum = TwDefineEnum( "Refinement criterion enum", RefinementCriterion, _countof( RefinementCriterion ) ); TwAddVarRW( bar, "RefinementCriterion", CascadeProcessingModeEnum, &m_PPAttribs.m_uiRefinementCriterion, "group=Advanced label=\'Refinement criterion\'" ); } { TwEnumVal ExtinctionEvalMode[] = { { EXTINCTION_EVAL_MODE_PER_PIXEL, "Per pixel" }, { EXTINCTION_EVAL_MODE_EPIPOLAR, "Epipolar" } }; TwType ExtinctionEvalModeEnum = TwDefineEnum( "Extinction eval mode enum", ExtinctionEvalMode, _countof( ExtinctionEvalMode ) ); TwAddVarRW( bar, "ExtinctionEval", ExtinctionEvalModeEnum, &m_PPAttribs.m_uiExtinctionEvalMode, "group=Advanced label=\'Extinction eval mode\'" ); } TwAddVarRW( bar, "AerosolDensity", TW_TYPE_FLOAT, &m_PPAttribs.m_fAerosolDensityScale, "group=Advanced label=\'Aerosol density\' min=0.1 max=5.0 step=0.1" ); TwAddVarRW( bar, "AerosolAbsorption", TW_TYPE_FLOAT, &m_PPAttribs.m_fAerosolAbsorbtionScale, "group=Advanced label=\'Aerosol absorption\' min=0.0 max=5.0 step=0.1" ); TwAddVarRW( bar, "UseCustomSctrCoeffs", TW_TYPE_BOOLCPP, &m_PPAttribs.m_bUseCustomSctrCoeffs, "group=Advanced label=\'Use custom scattering coeffs\'" ); #define RLGH_COLOR_SCALE 5e-5f #define MIE_COLOR_SCALE 5e-5f TwAddVarCB(bar, "RayleighColor", TW_TYPE_COLOR4F, []( const void *value, void * clientData ) { AtmosphereSample *pTheSample = reinterpret_cast<AtmosphereSample*>( clientData ); pTheSample->m_f4CustomRlghBeta = *reinterpret_cast<const float4 *>(value) * RLGH_COLOR_SCALE; if( (float3&)pTheSample->m_f4CustomRlghBeta == float3( 0, 0, 0 ) ) { pTheSample->m_f4CustomRlghBeta = float4( 1, 1, 1, 1 ) * RLGH_COLOR_SCALE / 255.f; } }, [](void *value, void * clientData) { AtmosphereSample *pTheSample = reinterpret_cast<AtmosphereSample*>( clientData ); float4 RlghColor = pTheSample->m_f4CustomRlghBeta / RLGH_COLOR_SCALE; RlghColor.w = 1; *reinterpret_cast<float4*>(value) = RlghColor; }, this, "group=Advanced label=\'Rayleigh color\' colormode=rgb"); TwAddVarCB(bar, "MieColor", TW_TYPE_COLOR4F, []( const void *value, void * clientData ) { AtmosphereSample *pTheSample = reinterpret_cast<AtmosphereSample*>( clientData ); pTheSample->m_f4CustomMieBeta = *reinterpret_cast<const float4 *>(value) * MIE_COLOR_SCALE; if( (float3&)pTheSample->m_f4CustomMieBeta == float3( 0, 0, 0 ) ) { pTheSample->m_f4CustomMieBeta = float4( 1, 1, 1, 1 ) * MIE_COLOR_SCALE / 255.f; } }, [](void *value, void * clientData) { AtmosphereSample *pTheSample = reinterpret_cast<AtmosphereSample*>( clientData ); float4 MieColor = pTheSample->m_f4CustomMieBeta / MIE_COLOR_SCALE; MieColor.w = 1; *reinterpret_cast<float4*>(value) = MieColor; }, this, "group=Advanced label=\'Mie color\' colormode=rgb"); #undef RLGH_COLOR_SCALE #undef MIE_COLOR_SCALE TwAddButton(bar, "UpdateCoeffsBtn", [](void *clientData) { AtmosphereSample *pTheSample = reinterpret_cast<AtmosphereSample*>( clientData ); pTheSample->m_PPAttribs.m_f4CustomRlghBeta = pTheSample->m_f4CustomRlghBeta; pTheSample->m_PPAttribs.m_f4CustomMieBeta = pTheSample->m_f4CustomMieBeta; }, this, "group=Advanced label=\'Update coefficients\'"); } // Tone mapping GUI controls { { TwEnumVal ToneMappingMode[] = { {TONE_MAPPING_MODE_EXP, "Exp"}, {TONE_MAPPING_MODE_REINHARD, "Reinhard"}, {TONE_MAPPING_MODE_REINHARD_MOD, "Reinhard Mod"}, {TONE_MAPPING_MODE_UNCHARTED2, "Uncharted 2"}, {TONE_MAPPING_FILMIC_ALU, "Filmic ALU"}, {TONE_MAPPING_LOGARITHMIC, "Logarithmic"}, {TONE_MAPPING_ADAPTIVE_LOG, "Adaptive log"} }; TwType ToneMappingModeEnum = TwDefineEnum( "Tone mapping mode enum", ToneMappingMode, _countof( ToneMappingMode ) ); TwAddVarRW( bar, "ToneMappingMode", ToneMappingModeEnum, &m_PPAttribs.m_uiToneMappingMode, "group=ToneMapping label=\'Mode\'" ); } TwAddVarRW( bar, "WhitePoint", TW_TYPE_FLOAT, &m_PPAttribs.m_fWhitePoint, "group=ToneMapping label=\'White point\' min=0.01 max=10.0 step=0.1" ); TwAddVarRW( bar, "LumSaturation", TW_TYPE_FLOAT, &m_PPAttribs.m_fLuminanceSaturation, "group=ToneMapping label=\'Luminance saturation\' min=0.01 max=2.0 step=0.1" ); TwAddVarRW( bar, "MiddleGray", TW_TYPE_FLOAT, &m_PPAttribs.m_fMiddleGray, "group=ToneMapping label=\'Middle Gray\' min=0.01 max=1.0 step=0.01" ); TwAddVarRW( bar, "AutoExposure", TW_TYPE_BOOLCPP, &m_PPAttribs.m_bAutoExposure, "group=ToneMapping label=\'Auto exposure\'" ); TwAddVarRW( bar, "LightAdaptation", TW_TYPE_BOOLCPP, &m_PPAttribs.m_bLightAdaptation, "group=ToneMapping label=\'Light adaptation\'" ); } const auto& RG16UAttribs = pDevice->GetTextureFormatInfoExt( TEX_FORMAT_RG16_UNORM ); const auto& RG32FAttribs = pDevice->GetTextureFormatInfoExt( TEX_FORMAT_RG32_FLOAT ); bool RG16USupported = RG16UAttribs.Supported && RG16UAttribs.ColorRenderable; bool RG32FSupported = RG32FAttribs.Supported && RG32FAttribs.ColorRenderable; if( !RG16USupported && !RG32FSupported ) { int32_t IsVisible = 0; TwSetParam( bar, "1DMinMaxOptimization", "visible", TW_PARAM_INT32, 1, &IsVisible ); m_PPAttribs.m_bUse1DMinMaxTree = FALSE; } if( !RG16USupported || !RG32FSupported ) { int32_t IsVisible = 0; TwSetParam( bar, "Is32BitMinMaxShadowMap", "visible", TW_PARAM_INT32, 1, &IsVisible ); if( RG16USupported && !RG32FSupported ) m_PPAttribs.m_bIs32BitMinMaxMipMap = FALSE; if( !RG16USupported && RG32FSupported ) m_PPAttribs.m_bIs32BitMinMaxMipMap = TRUE; } }
bool GraphicResourceManager::initialize() { m_font = nullptr; m_title_font = nullptr; stl::fill_n(m_blend_states, _countof(m_blend_states), (BlendState*)nullptr); stl::fill_n(m_depth_states, _countof(m_depth_states), (DepthStencilState*)nullptr); stl::fill_n(m_sampler, _countof(m_sampler), (Sampler*)nullptr); stl::fill_n(m_tex1d, _countof(m_tex1d), (Texture1D*)nullptr); stl::fill_n(m_tex2d, _countof(m_tex2d), (Texture2D*)nullptr); stl::fill_n(m_va, _countof(m_va), (VertexArray*)nullptr); stl::fill_n(m_vbo, _countof(m_vbo), (Buffer*)nullptr); stl::fill_n(m_ibo, _countof(m_ibo), (Buffer*)nullptr); stl::fill_n(m_ubo, _countof(m_ubo), (Buffer*)nullptr); stl::fill_n(m_rt, _countof(m_rt), (RenderTarget*)nullptr); stl::fill_n(m_shader, _countof(m_shader), (AtomicShader*)nullptr); //// どうも 2 の n 乗サイズのフレームバッファの方が若干描画早いっぽい。 uvec2 rt_size = atmGetWindowSize(); //uvec2 rt_size = CalcFrameBufferSize(); // initialize opengl resources i3d::Device *dev = atmGetGLDevice(); i3d::DeviceContext *dc = atmGetGLDeviceContext(); { m_font = CreateSpriteFont("Resources/font.sff", "Resources/font.png", atmGetEasyDrawer()); m_title_font = CreateSpriteFont("Resources/ascii.sff", "Resources/ascii.png", atmGetEasyDrawer()); } for(uint32 i=0; i<_countof(m_va); ++i) { m_va[i] = dev->createVertexArray(); } { BlendStateDesc desc; m_blend_states[BS_NO_BLEND] = dev->createBlendState(desc); desc.enable_blend = true; desc.func_src_rgb = desc.func_src_a = I3D_BLEND_SRC_ALPHA; desc.func_dst_rgb = desc.func_dst_a = I3D_BLEND_INV_SRC_ALPHA; m_blend_states[BS_BLEND_ALPHA] = dev->createBlendState(desc); desc.func_src_rgb = desc.func_src_a = I3D_BLEND_SRC_ALPHA; desc.func_dst_rgb = desc.func_dst_a = I3D_BLEND_ONE; m_blend_states[BS_BLEND_ADD] = dev->createBlendState(desc); desc.func_src_rgb = desc.func_src_a = I3D_BLEND_ONE; desc.func_dst_rgb = desc.func_dst_a = I3D_BLEND_INV_SRC_COLOR; m_blend_states[BS_BLEND_SCREEN] = dev->createBlendState(desc); } { DepthStencilStateDesc desc; m_depth_states[DS_NO_DEPTH_NO_STENCIL] = dev->createDepthStencilState(desc); desc.depth_enable = true; desc.depth_write = true; desc.depth_func = I3D_DEPTH_LESS; m_depth_states[DS_DEPTH_ENABLED] = dev->createDepthStencilState(desc); desc.stencil_enable = true; desc.stencil_op_onpass = I3D_STENCIL_REPLACE; desc.stencil_ref = STENCIL_FLUID; m_depth_states[DS_GBUFFER_FLUID] = dev->createDepthStencilState(desc); desc.stencil_ref = STENCIL_RIGID; m_depth_states[DS_GBUFFER_RIGID] = dev->createDepthStencilState(desc); desc.depth_enable = true; desc.depth_write = false; desc.stencil_ref = 0; desc.stencil_func = I3D_STENCIL_EQUAL; m_depth_states[DS_GBUFFER_BG] = dev->createDepthStencilState(desc); desc.depth_enable = true; desc.depth_func = I3D_DEPTH_ALWAYS; m_depth_states[DS_GBUFFER_UPSAMPLING] = dev->createDepthStencilState(desc); desc.depth_enable = false; desc.depth_write = false; desc.depth_func = I3D_DEPTH_LESS; desc.stencil_enable = false; desc.stencil_func = I3D_STENCIL_ALWAYS; m_depth_states[DS_LIGHTING_FRONT] = dev->createDepthStencilState(desc); m_depth_states[DS_LIGHTING_BACK] = dev->createDepthStencilState(desc); } const uvec2 unitsphere_div(32,16); { CreateFloorQuad(m_va[VA_FLOOR_QUAD], m_vbo[VBO_FLOOR_QUAD], vec4(-PSYM_GRID_SIZE*0.5f, -PSYM_GRID_SIZE*0.5f, -0.15f, 0.0f), vec4(PSYM_GRID_SIZE, PSYM_GRID_SIZE, 0.0f, 0.0f)); CreateScreenQuad(m_va[VA_SCREEN_QUAD], m_vbo[VBO_SCREEN_QUAD]); CreateBloomLuminanceQuads(m_va[VA_BLOOM_LUMINANCE_QUADS], m_vbo[VBO_BLOOM_LUMINANCE_QUADS]); CreateBloomBlurQuads(m_va[VA_BLOOM_BLUR_QUADS], m_vbo[VBO_BLOOM_BLUR_QUADS]); CreateBloomCompositeQuad(m_va[VA_BLOOM_COMPOSITE_QUAD], m_vbo[VBO_BLOOM_COMPOSITE_QUAD]); CreateCube(m_va[VA_UNIT_CUBE], m_vbo[VBO_UNIT_CUBE], 0.5f); CreateCube(m_va[VA_FLUID_CUBE], m_vbo[VBO_FLUID_CUBE], 0.015f); CreateSphere(m_va[VA_UNIT_SPHERE], m_vbo[VBO_UNIT_SPHERE], m_ibo[IBO_UNITSPHERE], 1.00f, unitsphere_div.x,unitsphere_div.y); CreateSphere(m_va[VA_BLOOSTAIN_SPHERE], m_vbo[VBO_BLOODSTAIN_SPHERE], m_ibo[IBO_BLOODSTAIN_SPHERE], 0.075f, 8,8); CreateFieldGridLines(m_va[VA_FIELD_GRID], m_vbo[VBO_FIELD_GRID]); CreateDistanceFieldQuads(m_va[VA_DISTANCE_FIELD], m_vbo[VBO_DISTANCE_FIELD_QUAD], m_vbo[VBO_DISTANCE_FIELD_POS], m_vbo[VBO_DISTANCE_FIELD_DIST]); m_vbo[VBO_GB_FLUID] = CreateVertexBuffer(dev, sizeof(psym::Particle)*PSYM_MAX_PARTICLE_NUM, I3D_USAGE_DYNAMIC); m_vbo[VBO_GB_RIGID_SPHERICAL] = CreateVertexBuffer(dev, sizeof(PSetParticle)*MAX_RIGID_PARTICLES, I3D_USAGE_DYNAMIC); m_vbo[VBO_GB_RIGID_SOLID] = CreateVertexBuffer(dev, sizeof(PSetParticle)*MAX_RIGID_PARTICLES, I3D_USAGE_DYNAMIC); m_vbo[VBO_FW_RIGID_BARRIER] = CreateVertexBuffer(dev, sizeof(PSetParticle)*MAX_RIGID_PARTICLES, I3D_USAGE_DYNAMIC); m_vbo[VBO_PARTICLES] = CreateVertexBuffer(dev, sizeof(SingleParticle)*MAX_EFFECT_PARTICLES, I3D_USAGE_DYNAMIC); m_vbo[VBO_DIRLIGHT_INSTANCES] = CreateVertexBuffer(dev, sizeof(DirectionalLight)*ATOMIC_MAX_DIRECTIONAL_LIGHTS, I3D_USAGE_DYNAMIC); m_vbo[VBO_POINTLIGHT_INSTANCES] = CreateVertexBuffer(dev, sizeof(PointLight)*ATOMIC_MAX_POINT_LIGHTS, I3D_USAGE_DYNAMIC); m_vbo[VBO_BLOODSTAIN_PARTICLES] = CreateVertexBuffer(dev, sizeof(BloodstainParticle)*MAX_BLOODSTAIN_PARTICLES, I3D_USAGE_DYNAMIC); m_vbo[VBO_GENERIC_PARAMS1] = CreateVertexBuffer(dev, 512*1024, I3D_USAGE_DYNAMIC); m_vbo[VBO_GENERIC_PARAMS2] = CreateVertexBuffer(dev, 512*1024, I3D_USAGE_DYNAMIC); } { m_ubo[UBO_RENDERSTATES_3D] = CreateUniformBuffer(dev, sizeof(RenderStates), I3D_USAGE_DYNAMIC); m_ubo[UBO_RENDERSTATES_BG] = CreateUniformBuffer(dev, sizeof(RenderStates), I3D_USAGE_DYNAMIC); m_ubo[UBO_RENDERSTATES_2D] = CreateUniformBuffer(dev, sizeof(RenderStates), I3D_USAGE_DYNAMIC); m_ubo[UBO_FXAA_PARAMS] = CreateUniformBuffer(dev, sizeof(FXAAParams), I3D_USAGE_DYNAMIC); m_ubo[UBO_FADE_PARAMS] = CreateUniformBuffer(dev, sizeof(FadeParams), I3D_USAGE_DYNAMIC); m_ubo[UBO_FILL_PARAMS] = CreateUniformBuffer(dev, sizeof(FillParams), I3D_USAGE_DYNAMIC); m_ubo[UBO_MULTIRESOLUTION_PARAMS] = CreateUniformBuffer(dev, sizeof(MultiresolutionParams), I3D_USAGE_DYNAMIC); m_ubo[UBO_DEBUG_SHOW_BUFFER_PARAMS] = CreateUniformBuffer(dev, sizeof(DebugShowBufferParams), I3D_USAGE_DYNAMIC); } { // create shaders m_shader[SH_GBUFFER_FLOOR] = CreateAtomicShader("GBuffer_Floor"); //m_shader[SH_GBUFFER_FLUID] = CreateAtomicShader("GBuffer_Fluid"); //m_shader[SH_GBUFFER_RIGID] = CreateAtomicShader("GBuffer_Rigid"); m_shader[SH_GBUFFER_FLUID_SPHERICAL]= CreateAtomicShader("GBuffer_FluidBlood"); m_shader[SH_GBUFFER_FLUID_SOLID] = CreateAtomicShader("GBuffer_FluidSolid"); m_shader[SH_GBUFFER_RIGID_SPHERICAL]= CreateAtomicShader("GBuffer_RigidSpherical"); m_shader[SH_GBUFFER_RIGID_SOLID] = CreateAtomicShader("GBuffer_RigidSolid"); m_shader[SH_GBUFFER_PARTICLES] = CreateAtomicShader("GBuffer_ParticleSpherical"); m_shader[SH_GBUFFER_UPSAMPLING] = CreateAtomicShader("GBuffer_Upsampling"); m_shader[SH_BLOODSTAIN] = CreateAtomicShader("Deferred_Bloodstain"); m_shader[SH_UPSAMPLING] = CreateAtomicShader("Deferred_Upsampling"); m_shader[SH_POINTLIGHT] = CreateAtomicShader("Deferred_PointLight"); m_shader[SH_DIRECTIONALLIGHT] = CreateAtomicShader("Deferred_DirectionalLight"); m_shader[SH_MICROSCOPIC] = CreateAtomicShader("Postprocess_Microscopic"); m_shader[SH_FXAA_LUMA] = CreateAtomicShader("FXAA_luma"); m_shader[SH_FXAA] = CreateAtomicShader("FXAA"); m_shader[SH_BLOOM_LUMINANCE] = CreateAtomicShader("Bloom_Luminance"); m_shader[SH_BLOOM_HBLUR] = CreateAtomicShader("Bloom_HBlur"); m_shader[SH_BLOOM_VBLUR] = CreateAtomicShader("Bloom_VBlur"); m_shader[SH_BLOOM_COMPOSITE] = CreateAtomicShader("Bloom_Composite"); m_shader[SH_FADE] = CreateAtomicShader("Fade"); m_shader[SH_FILL] = CreateAtomicShader("Fill"); m_shader[SH_FILL3D] = CreateAtomicShader("Fill3D"); m_shader[SH_OUTPUT] = CreateAtomicShader("Out"); m_shader[SH_DEBUG_SHOW_RGB] = CreateAtomicShader("Debug_ShowRGB"); m_shader[SH_DEBUG_SHOW_AAA] = CreateAtomicShader("Debug_ShowAAA"); m_shader[SH_BARRIER] = CreateAtomicShader("Forward_Barrier"); m_shader[SH_BARRIER_PARTICLES] = CreateAtomicShader("Forward_BarrierRigidParticles"); m_shader[SH_FEEDBACK_BLUR] = CreateAtomicShader("FeedbackBlur"); m_shader[SH_BG1] = CreateAtomicShader("BG1"); m_shader[SH_BG2] = CreateAtomicShader("BG2"); m_shader[SH_BG3] = CreateAtomicShader("BG3"); m_shader[SH_BG4] = CreateAtomicShader("BG4"); m_shader[SH_BG5] = CreateAtomicShader("BG5"); m_shader[SH_BG6] = CreateAtomicShader("BG6"); m_shader[SH_BG7] = CreateAtomicShader("BG7"); m_shader[SH_BG8] = CreateAtomicShader("BG8"); m_shader[SH_BG9] = CreateAtomicShader("BG9"); } { // samplers m_sampler[SAMPLER_GBUFFER] = dev->createSampler(SamplerDesc(I3D_REPEAT, I3D_REPEAT, I3D_REPEAT, I3D_NEAREST, I3D_NEAREST)); m_sampler[SAMPLER_TEXTURE_DEFAULT] = dev->createSampler(SamplerDesc(I3D_REPEAT, I3D_REPEAT, I3D_REPEAT, I3D_LINEAR, I3D_LINEAR)); } { // create textures m_tex2d[TEX2D_RANDOM] = GenerateRandomTexture(dev, uvec2(64, 64), I3D_RGB8); m_tex2d[TEX2D_PSET_PARAMS_GB_SP] = dev->createTexture2D(Texture2DDesc(I3D_RGBA32F, uvec2(12, 4096))); m_tex2d[TEX2D_PSET_PARAMS_GB_SO] = dev->createTexture2D(Texture2DDesc(I3D_RGBA32F, uvec2(12, 4096))); m_tex2d[TEX2D_PSET_PARAMS_FW_SO] = dev->createTexture2D(Texture2DDesc(I3D_RGBA32F, uvec2(12, 4096))); m_tex2d[TEX2D_PSET_PARAMS_FW_BARRIER] = dev->createTexture2D(Texture2DDesc(I3D_RGBA32F, uvec2(12, 4096))); } { // create render targets m_rt[RT_GBUFFER] = i3d::CreateRenderTarget(dev, 4, rt_size, I3D_RGBA16F, I3D_DEPTH24_STENCIL8, 3, 3); m_rt[RT_GAUSS0] = i3d::CreateRenderTarget(dev, 1, uvec2(512, 256), I3D_RGBA16F); m_rt[RT_GAUSS1] = i3d::CreateRenderTarget(dev, 1, uvec2(512, 256), I3D_RGBA16F); m_rt[RT_OUTPUT0] = i3d::CreateRenderTarget(dev, 1, rt_size, I3D_RGBA16F); m_rt[RT_OUTPUT1] = i3d::CreateRenderTarget(dev, 1, rt_size, I3D_RGBA16F); m_rt[RT_OUTPUT2] = i3d::CreateRenderTarget(dev, 1, rt_size, I3D_RGBA16F); m_rt[RT_PREV_FRAME] = i3d::CreateRenderTarget(dev, 1, rt_size, I3D_RGBA16F); m_rt[RT_OUTPUT_HALF] = i3d::CreateRenderTarget(dev, 1, rt_size/uvec2(2,2), I3D_RGBA16F); m_rt[RT_OUTPUT_QUARTER] = i3d::CreateRenderTarget(dev, 1, rt_size/uvec2(4,4), I3D_RGBA16F); m_rt[RT_GENERIC] = i3d::CreateRenderTarget(dev, 0, rt_size, I3D_RGBA16F); } { CreateCubeParticleSet(m_pset[PSET_UNIT_CUBE], m_rinfo[PSET_UNIT_CUBE], 0.5f, 10000.0f); CreateSphereParticleSet(m_pset[PSET_UNIT_SPHERE], m_rinfo[PSET_UNIT_SPHERE], 0.5f, 10000.0f); CreateHollowCubeParticleSet(m_pset[PSET_HOLLOW_CUBE], m_rinfo[PSET_HOLLOW_CUBE], 0.5f, 10000.0f ); CreateCubeParticleSet(m_pset[PSET_CUBE_SMALL], m_rinfo[PSET_CUBE_SMALL], 0.1f); CreateCubeParticleSet(m_pset[PSET_CUBE_MEDIUM], m_rinfo[PSET_CUBE_MEDIUM], 0.2f); CreateCubeParticleSet(m_pset[PSET_CUBE_LARGE], m_rinfo[PSET_CUBE_LARGE], 0.4f); CreateSphereParticleSet(m_pset[PSET_SPHERE_SMALL], m_rinfo[PSET_SPHERE_SMALL], 0.125f); CreateSphereParticleSet(m_pset[PSET_SPHERE_MEDIUM], m_rinfo[PSET_SPHERE_MEDIUM], 0.25f); CreateSphereParticleSet(m_pset[PSET_SPHERE_LARGE], m_rinfo[PSET_SPHERE_LARGE], 0.5f); CreateBulletParticleSet(m_pset[PSET_SPHERE_BULLET], m_rinfo[PSET_SPHERE_BULLET]); } { m_models[MODEL_UNITQUAD] = ModelInfo(I3D_QUADS, VA_SCREEN_QUAD, IBO_NULL, 4); m_models[MODEL_UNITCUBE] = ModelInfo(I3D_QUADS, VA_UNIT_CUBE, IBO_NULL, 24); m_models[MODEL_UNITSPHERE] = ModelInfo(I3D_QUADS, VA_UNIT_SPHERE, IBO_UNITSPHERE, (unitsphere_div.y-1)*(unitsphere_div.x)*4); } return true; }