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