const UINT iInnerRingDim,

const UINT iRingExtension,

const UINT iNumLayers,

CProc Proc)

{

UINT iRingDimension = iInnerRingDim + 2*iRingExtension;

assert( (iInnerRingDim % 4) == 0 );

for(int iRing = iNumRings-1; iRing >= 0; --iRing)

{

for(UINT iRow = 0; iRow < iRingDimension; ++iRow)

{

UINT iFirstQuart = iRingExtension + iInnerRingDim*1/4;

UINT iThirdQuart = iRingExtension + iInnerRingDim*3/4;

UINT iStartCol[2] = {0, iThirdQuart };

UINT iEndCol[2] = {iFirstQuart, iRingDimension};

if( !(iRing > 0 && iRow >= iFirstQuart && iRow < iThirdQuart) )

iStartCol[1] = iEndCol[0];

for(int i=0; i < _countof(iStartCol); ++i)

for(UINT iCol = iStartCol[i]; iCol < iEndCol[i]; ++iCol)

for(UINT iLayer = 0; iLayer < iNumLayers; ++iLayer)

Proc(iCol, iRow, iRing, iLayer);

}

}

m_strEffectPath(L"fx\\Clouds.fx"),

m_strPreprocessingEffectPath(L"fx\\Preprocessing.fx"),

m_uiCloudDensityTexWidth(1024),

m_uiCloudDensityTexHeight(1024),

m_bPSOrderingAvailable(false),

m_f3PrevLightDir(0,0,0)

{

CRenderTechnique &State,

int iWidth = 0, int iHeight = 0,

int iTopLeftX = 0, int iTopLeftY = 0,

UINT uiWidth, UINT uiHeight)

{

m_uiBackBufferWidth = uiWidth;

m_uiBackBufferHeight = uiHeight;

UINT uiDownscaledWidth = m_uiBackBufferWidth /m_CloudAttribs.uiDownscaleFactor;

UINT uiDownscaledHeight = m_uiBackBufferHeight/m_CloudAttribs.uiDownscaleFactor;

m_CloudAttribs.uiBackBufferWidth = m_uiBackBufferWidth;

m_CloudAttribs.uiBackBufferHeight = m_uiBackBufferHeight;

m_CloudAttribs.uiDownscaledBackBufferWidth = uiDownscaledWidth;

m_CloudAttribs.uiDownscaledBackBufferHeight = uiDownscaledHeight;

m_CloudAttribs.fBackBufferWidth = (float)m_uiBackBufferWidth;

m_CloudAttribs.fBackBufferHeight = (float)m_uiBackBufferHeight;

m_CloudAttribs.fDownscaledBackBufferWidth = (float)uiDownscaledWidth;

m_CloudAttribs.fDownscaledBackBufferHeight = (float)uiDownscaledHeight;

// Release existing resources

m_ptex2DScreenCloudColorSRV.Release();

m_ptex2DScreenCloudColorRTV.Release();

m_ptex2DScrSpaceCloudTransparencySRV.Release();

m_ptex2DScrSpaceCloudTransparencyRTV.Release();

m_ptex2DScrSpaceDistToCloudSRV.Release();

m_ptex2DScrSpaceDistToCloudRTV.Release();

m_ptex2DDownscaledScrCloudColorSRV.Release();

m_ptex2DDownscaledScrCloudColorRTV.Release();

m_ptex2DDownscaledScrCloudTransparencySRV.Release();

m_ptex2DDownscaledScrCloudTransparencyRTV.Release();

m_ptex2DDownscaledScrDistToCloudSRV.Release();

m_ptex2DDownscaledScrDistToCloudRTV.Release();

m_pbufParticleLayersSRV.Release();

m_pbufParticleLayersUAV.Release();

m_pbufClearParticleLayers.Release();

// Create screen space cloud color buffer

D3D11_TEXTURE2D_DESC ScreenCloudColorTexDesc =

{

m_uiBackBufferWidth, //UINT Width;

m_uiBackBufferHeight, //UINT Height;

1, //UINT MipLevels;

1, //UINT ArraySize;

DXGI_FORMAT_R11G11B10_FLOAT, //DXGI_FORMAT Format;

{1,0}, //DXGI_SAMPLE_DESC SampleDesc;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE, //UINT BindFlags;

0, //UINT CPUAccessFlags;

0, //UINT MiscFlags;

};

HRESULT hr;

CComPtr<ID3D11Texture2D> ptex2DScreenCloudColor;

V( pDevice->CreateTexture2D(&ScreenCloudColorTexDesc, nullptr, &ptex2DScreenCloudColor) );

V( pDevice->CreateShaderResourceView(ptex2DScreenCloudColor, nullptr, &m_ptex2DScreenCloudColorSRV) );

V( pDevice->CreateRenderTargetView(ptex2DScreenCloudColor, nullptr, &m_ptex2DScreenCloudColorRTV) );

if( m_CloudAttribs.uiDownscaleFactor > 1 )

{

// Create downscaled screen space cloud color buffer

D3D11_TEXTURE2D_DESC DownscaledScreenCloudColorTexDesc = ScreenCloudColorTexDesc;

DownscaledScreenCloudColorTexDesc.Width /= m_CloudAttribs.uiDownscaleFactor;

DownscaledScreenCloudColorTexDesc.Height /= m_CloudAttribs.uiDownscaleFactor;

CComPtr<ID3D11Texture2D> ptex2DDownscaledScrCloudColor;

V( pDevice->CreateTexture2D(&DownscaledScreenCloudColorTexDesc, nullptr, &ptex2DDownscaledScrCloudColor) );

V( pDevice->CreateShaderResourceView(ptex2DDownscaledScrCloudColor, nullptr, &m_ptex2DDownscaledScrCloudColorSRV) );

V( pDevice->CreateRenderTargetView(ptex2DDownscaledScrCloudColor, nullptr, &m_ptex2DDownscaledScrCloudColorRTV) );

}

{

// Create screen space cloud transparency buffer

D3D11_TEXTURE2D_DESC ScreenTransparencyTexDesc = ScreenCloudColorTexDesc;

ScreenTransparencyTexDesc.Format = DXGI_FORMAT_R8_UNORM;

CComPtr<ID3D11Texture2D> ptex2DScreenTransparency;

V( pDevice->CreateTexture2D(&ScreenTransparencyTexDesc, nullptr, &ptex2DScreenTransparency) );

V( pDevice->CreateShaderResourceView(ptex2DScreenTransparency, nullptr, &m_ptex2DScrSpaceCloudTransparencySRV) );

V( pDevice->CreateRenderTargetView(ptex2DScreenTransparency, nullptr, &m_ptex2DScrSpaceCloudTransparencyRTV) );

if( m_CloudAttribs.uiDownscaleFactor > 1 )

{

// Create downscaled screen space cloud transparency buffer

ScreenTransparencyTexDesc.Width /= m_CloudAttribs.uiDownscaleFactor;

ScreenTransparencyTexDesc.Height /= m_CloudAttribs.uiDownscaleFactor;

CComPtr<ID3D11Texture2D> ptex2DDownscaledScrTransparency;

V( pDevice->CreateTexture2D(&ScreenTransparencyTexDesc, nullptr, &ptex2DDownscaledScrTransparency) );

V( pDevice->CreateShaderResourceView(ptex2DDownscaledScrTransparency, nullptr, &m_ptex2DDownscaledScrCloudTransparencySRV) );

V( pDevice->CreateRenderTargetView(ptex2DDownscaledScrTransparency, nullptr, &m_ptex2DDownscaledScrCloudTransparencyRTV) );

}

}

{

// Create screen space distance to cloud buffer

D3D11_TEXTURE2D_DESC ScreenDistToCloudTexDesc = ScreenCloudColorTexDesc;

ScreenDistToCloudTexDesc.Format = DXGI_FORMAT_R32_FLOAT; // We need only the closest distance to camera

CComPtr<ID3D11Texture2D> ptex2DScrSpaceDistToCloud;

V( pDevice->CreateTexture2D(&ScreenDistToCloudTexDesc, nullptr, &ptex2DScrSpaceDistToCloud) );

V( pDevice->CreateShaderResourceView(ptex2DScrSpaceDistToCloud, nullptr, &m_ptex2DScrSpaceDistToCloudSRV) );

V( pDevice->CreateRenderTargetView(ptex2DScrSpaceDistToCloud, nullptr, &m_ptex2DScrSpaceDistToCloudRTV) );

if( m_CloudAttribs.uiDownscaleFactor > 1 )

{

// Create downscaled screen space distance to cloud buffer

ScreenDistToCloudTexDesc.Width /= m_CloudAttribs.uiDownscaleFactor;

ScreenDistToCloudTexDesc.Height /= m_CloudAttribs.uiDownscaleFactor;

CComPtr<ID3D11Texture2D> ptex2DDownscaledScrDistToCloud;

V( pDevice->CreateTexture2D(&ScreenDistToCloudTexDesc, nullptr, &ptex2DDownscaledScrDistToCloud) );

V( pDevice->CreateShaderResourceView(ptex2DDownscaledScrDistToCloud, nullptr, &m_ptex2DDownscaledScrDistToCloudSRV) );

V( pDevice->CreateRenderTargetView(ptex2DDownscaledScrDistToCloud, nullptr, &m_ptex2DDownscaledScrDistToCloudRTV) );

}

}

if( m_bPSOrderingAvailable )

{

int iNumElements = (m_uiBackBufferWidth / m_CloudAttribs.uiDownscaleFactor) *

(m_uiBackBufferHeight / m_CloudAttribs.uiDownscaleFactor) *

m_CloudAttribs.uiNumParticleLayers;

D3D11_BUFFER_DESC ParticleLayersBufDesc =

{

iNumElements * sizeof(SParticleLayer), //UINT ByteWidth;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS, //UINT BindFlags;

0, //UINT CPUAccessFlags;

D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, //UINT MiscFlags;

sizeof(SParticleLayer) //UINT StructureByteStride;

};

CComPtr<ID3D11Buffer> pbufParticleLayers;

V(pDevice->CreateBuffer( &ParticleLayersBufDesc, nullptr, &pbufParticleLayers));

D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;

ZeroMemory(&SRVDesc, sizeof(SRVDesc));

SRVDesc.Format = DXGI_FORMAT_UNKNOWN;

SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;

SRVDesc.Buffer.FirstElement = 0;

SRVDesc.Buffer.NumElements = iNumElements;

V(pDevice->CreateShaderResourceView( pbufParticleLayers, &SRVDesc, &m_pbufParticleLayersSRV));

D3D11_UNORDERED_ACCESS_VIEW_DESC UAVDesc;

UAVDesc.Format = DXGI_FORMAT_UNKNOWN;

UAVDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;

UAVDesc.Buffer.FirstElement = 0;

UAVDesc.Buffer.NumElements = iNumElements;

UAVDesc.Buffer.Flags = 0;

V(pDevice->CreateUnorderedAccessView( pbufParticleLayers, &UAVDesc, &m_pbufParticleLayersUAV));

std::vector<SParticleLayer> ClearLayers(iNumElements);

ParticleLayersBufDesc.Usage = D3D11_USAGE_IMMUTABLE;

ParticleLayersBufDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;

D3D11_SUBRESOURCE_DATA InitData = {&ClearLayers[0],0,0};

V(pDevice->CreateBuffer( &ParticleLayersBufDesc, &InitData, &m_pbufClearParticleLayers));

}

// Create buffer storing index of the first particle for each tile in screen space

m_uiTileTexWidth = (uiDownscaledWidth + sm_iTileSize-1)/sm_iTileSize;

m_uiTileTexHeight = (uiDownscaledHeight + sm_iTileSize-1)/sm_iTileSize;

D3D11_TEXTURE2D_DESC FirstListIndTexDesc =

{

m_uiTileTexWidth, //UINT Width;

m_uiTileTexHeight, //UINT Height;

1, //UINT MipLevels;

1, //UINT ArraySize;

DXGI_FORMAT_R32_SINT, //DXGI_FORMAT Format;

{1,0}, //DXGI_SAMPLE_DESC SampleDesc;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE, //UINT BindFlags;

0, //UINT CPUAccessFlags;

0, //UINT MiscFlags;

};

m_ptex2DScrFirstListIndSRV.Release();

m_ptex2DScrFirstListIndUAV.Release();

CComPtr<ID3D11Texture2D> ptex2DFirstListInd;

V( pDevice->CreateTexture2D(&FirstListIndTexDesc, nullptr, &ptex2DFirstListInd) );

V( pDevice->CreateShaderResourceView(ptex2DFirstListInd, nullptr, &m_ptex2DScrFirstListIndSRV) );

V( pDevice->CreateUnorderedAccessView(ptex2DFirstListInd, nullptr, &m_ptex2DScrFirstListIndUAV) );

m_pbufParticleListsBuffSRV.Release();

m_pbufParticleListsBuffUAV.Release();

// Create buffer used to store lists of particles after tiling

int iNumElements = FirstListIndTexDesc.Width * FirstListIndTexDesc.Height * 1000;

D3D11_BUFFER_DESC ParticleListsBufDesc =

{

iNumElements * sizeof(SParticleListKnot), //UINT ByteWidth;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS, //UINT BindFlags;

0, //UINT CPUAccessFlags;

D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, //UINT MiscFlags;

sizeof(SParticleListKnot) //UINT StructureByteStride;

};

CComPtr<ID3D11Buffer> pbufParticleListsBuffDesc;

V(pDevice->CreateBuffer( &ParticleListsBufDesc, nullptr, &pbufParticleListsBuffDesc));

D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;

ZeroMemory(&SRVDesc, sizeof(SRVDesc));

SRVDesc.Format = DXGI_FORMAT_UNKNOWN;

SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;

SRVDesc.Buffer.FirstElement = 0;

SRVDesc.Buffer.NumElements = iNumElements;

V(pDevice->CreateShaderResourceView( pbufParticleListsBuffDesc, &SRVDesc, &m_pbufParticleListsBuffSRV));

D3D11_UNORDERED_ACCESS_VIEW_DESC UAVDesc;

UAVDesc.Format = DXGI_FORMAT_UNKNOWN;

UAVDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;

UAVDesc.Buffer.FirstElement = 0;

UAVDesc.Buffer.NumElements = iNumElements;

UAVDesc.Buffer.Flags = D3D11_BUFFER_UAV_FLAG_COUNTER;

V(pDevice->CreateUnorderedAccessView( pbufParticleListsBuffDesc, &UAVDesc, &m_pbufParticleListsBuffUAV));

ID3D11DeviceContext *pDeviceContext,

ID3D11Texture2D *ptex2DMaxDensityMipMap,

ID3D11Texture2D *ptex2DTmpMaxDensityMipMap,

const D3D11_TEXTURE2D_DESC &MaxCloudDensityMipDesc )

{

HRESULT hr;

CD3DShaderMacroHelper Macros;

DefineMacros(Macros);

Macros.Finalize();

// Create techniques

CRenderTechnique RenderMaxDensityLevel0Tech;

RenderMaxDensityLevel0Tech.SetDeviceAndContext(pDevice, pDeviceContext);

RenderMaxDensityLevel0Tech.CreateVGPShadersFromFile(m_strEffectPath, "ScreenSizeQuadVS", nullptr, "RenderMaxMipLevel0PS", Macros);

RenderMaxDensityLevel0Tech.SetDS( m_pdsDisableDepth );

RenderMaxDensityLevel0Tech.SetRS( m_prsSolidFillNoCull );

RenderMaxDensityLevel0Tech.SetBS( m_pbsDefault );

CRenderTechnique RenderCoarseMaxMipLevelTech;

RenderCoarseMaxMipLevelTech.SetDeviceAndContext(pDevice, pDeviceContext);

RenderCoarseMaxMipLevelTech.CreateVGPShadersFromFile(m_strEffectPath, "ScreenSizeQuadVS", nullptr, "RenderCoarseMaxMipLevelPS", Macros);

RenderCoarseMaxMipLevelTech.SetDS( m_pdsDisableDepth );

RenderCoarseMaxMipLevelTech.SetRS( m_prsSolidFillNoCull );

RenderCoarseMaxMipLevelTech.SetBS( m_pbsDefault );

CComPtr<ID3D11RenderTargetView> pOrigRTV;

CComPtr<ID3D11DepthStencilView> pOrigDSV;

pDeviceContext->OMGetRenderTargets(1, &pOrigRTV, &pOrigDSV);

D3D11_VIEWPORT OrigViewPort;

UINT iNumOldViewports = 1;

pDeviceContext->RSGetViewports(&iNumOldViewports, &OrigViewPort);

UINT uiCurrMipWidth = MaxCloudDensityMipDesc.Width;

UINT uiCurrMipHeight = MaxCloudDensityMipDesc.Height;

for(UINT uiMip = 0; uiMip < MaxCloudDensityMipDesc.MipLevels; ++uiMip)

{

D3D11_RENDER_TARGET_VIEW_DESC RTVDesc;

RTVDesc.Format = MaxCloudDensityMipDesc.Format;

RTVDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;

RTVDesc.Texture2D.MipSlice = uiMip;

CComPtr<ID3D11RenderTargetView> ptex2DTmpMaxDensityMipMapRTV;

V(pDevice->CreateRenderTargetView(ptex2DTmpMaxDensityMipMap, &RTVDesc, &ptex2DTmpMaxDensityMipMapRTV));

pDeviceContext->OMSetRenderTargets(1, &ptex2DTmpMaxDensityMipMapRTV.p, nullptr);

ID3D11SamplerState *pSamplers[] = {m_psamPointWrap};

pDeviceContext->PSSetSamplers(2, _countof(pSamplers), pSamplers);

m_CloudAttribs.f4Parameter.x = (float)uiMip;

UpdateConstantBuffer(pDeviceContext, m_pcbGlobalCloudAttribs, &m_CloudAttribs, sizeof(m_CloudAttribs));

ID3D11Buffer *pCBs[] = {m_pcbGlobalCloudAttribs};

pDeviceContext->PSSetConstantBuffers(0, _countof(pCBs), pCBs);

if(uiMip == 0)

{

ID3D11ShaderResourceView *pSRVs[] = {m_ptex2DCloudDensitySRV};

pDeviceContext->PSSetShaderResources(1, _countof(pSRVs), pSRVs);

}

else

{

ID3D11ShaderResourceView *pSRVs[] = {m_ptex2DMaxDensityMipMapSRV};

pDeviceContext->PSSetShaderResources(3, _countof(pSRVs), pSRVs);

}

RenderQuad(pDeviceContext, uiMip == 0 ? RenderMaxDensityLevel0Tech : RenderCoarseMaxMipLevelTech, uiCurrMipWidth, uiCurrMipHeight);

pDeviceContext->CopySubresourceRegion(ptex2DMaxDensityMipMap, uiMip, 0,0,0, ptex2DTmpMaxDensityMipMap, uiMip, nullptr);

uiCurrMipWidth /= 2;

uiCurrMipHeight /= 2;

}

assert( uiCurrMipWidth == 0 && uiCurrMipHeight == 0 );

pDeviceContext->OMSetRenderTargets(1, &pOrigRTV.p, pOrigDSV);

pDeviceContext->RSSetViewports(iNumOldViewports, &OrigViewPort);

{

m_ptex2DLiSpFirstListIndUAV.Release();

m_ptex2DLiSpFirstListIndSRV.Release();

D3D11_TEXTURE2D_DESC LiSpFirstListIndTexDesc =

{

m_CloudAttribs.uiLiSpFirstListIndTexDim, //UINT Width;

m_CloudAttribs.uiLiSpFirstListIndTexDim, //UINT Height;

1, //UINT MipLevels;

1, //UINT ArraySize;

DXGI_FORMAT_R32_SINT, //DXGI_FORMAT Format;

{1,0}, //DXGI_SAMPLE_DESC SampleDesc;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE, //UINT BindFlags;

0, //UINT CPUAccessFlags;

0, //UINT MiscFlags;

};

HRESULT hr;

CComPtr<ID3D11Texture2D> ptex2DFirstListInd;

V( pDevice->CreateTexture2D(&LiSpFirstListIndTexDesc, nullptr, &ptex2DFirstListInd) );

V( pDevice->CreateShaderResourceView(ptex2DFirstListInd, nullptr, &m_ptex2DLiSpFirstListIndSRV) );

V( pDevice->CreateUnorderedAccessView(ptex2DFirstListInd, nullptr, &m_ptex2DLiSpFirstListIndUAV) );

const D3D11_BUFFER_DESC &BuffDesc,

D3D11_SUBRESOURCE_DATA *pInitData,

ID3D11Buffer**ppBuffer,

ID3D11ShaderResourceView **ppSRV,

ID3D11UnorderedAccessView **ppUAV,

UINT UAVFlags /*= 0*/)

{

HRESULT hr;

CComPtr< ID3D11Buffer > ptmpBuffer;

if( ppBuffer == nullptr )

ppBuffer = &ptmpBuffer;

V_RETURN(pDevice->CreateBuffer( &BuffDesc, pInitData, ppBuffer));

if( ppSRV )

{

assert( BuffDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED );

D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;

ZeroMemory(&SRVDesc, sizeof(SRVDesc));

SRVDesc.Format = DXGI_FORMAT_UNKNOWN;

SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;

SRVDesc.Buffer.FirstElement = 0;

SRVDesc.Buffer.NumElements = BuffDesc.ByteWidth / BuffDesc.StructureByteStride;

V_RETURN(pDevice->CreateShaderResourceView( *ppBuffer, &SRVDesc, ppSRV));

}

if( ppUAV )

{

assert( BuffDesc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED );

D3D11_UNORDERED_ACCESS_VIEW_DESC UAVDesc;

UAVDesc.Format = DXGI_FORMAT_UNKNOWN;

UAVDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;

UAVDesc.Buffer.FirstElement = 0;

UAVDesc.Buffer.NumElements = BuffDesc.ByteWidth / BuffDesc.StructureByteStride;

UAVDesc.Buffer.Flags = UAVFlags;

V_RETURN(pDevice->CreateUnorderedAccessView( *ppBuffer, &UAVDesc, ppUAV));

}

return S_OK;

{

m_CloudAttribs.uiRingDimension = m_CloudAttribs.uiInnerRingDim + m_CloudAttribs.uiRingExtension*2;

// Populate cell locations array

m_PackedCellLocations.clear();

m_PackedCellLocations.reserve(m_CloudAttribs.uiRingDimension * m_CloudAttribs.uiRingDimension * m_CloudAttribs.uiNumRings);

TraverseCloudLattice(m_CloudAttribs.uiNumRings, m_CloudAttribs.uiInnerRingDim, m_CloudAttribs.uiRingExtension, 1,

[&](UINT i, UINT j, UINT ring, UINT layer)

{

m_PackedCellLocations.push_back( PackParticleIJRing(i,j,ring, layer) );

}

);

m_CloudAttribs.uiNumCells = (UINT)m_PackedCellLocations.size();

// Populate particle locations array

m_PackedParticleLocations.clear();

m_PackedParticleLocations.reserve(m_CloudAttribs.uiNumCells * m_CloudAttribs.uiMaxLayers);

TraverseCloudLattice(m_CloudAttribs.uiNumRings, m_CloudAttribs.uiInnerRingDim, m_CloudAttribs.uiRingExtension, m_CloudAttribs.uiMaxLayers,

[&](UINT i, UINT j, UINT ring, UINT layer)

{

m_PackedParticleLocations.push_back( PackParticleIJRing(i,j,ring, layer) );

}

);

m_CloudAttribs.uiMaxParticles = (UINT)m_PackedParticleLocations.size();

// Reserve space for other aux arrays

m_CamSpaceOrder.reserve( m_PackedParticleLocations.size() );

m_LightSpaceOrder.reserve( m_PackedParticleLocations.size() );

m_ParticleDistToCam.resize( m_PackedParticleLocations.size() );

m_ParticleLightSpaceZ.resize( m_PackedParticleLocations.size() );

// Populate camera space and light space particle lists

m_CamSpaceOrder.clear();

m_LightSpaceOrder.clear();

for(UINT ind=0; ind < m_PackedParticleLocations.size(); ++ind)

{

UINT i,j,ring,layer;

UnPackParticleIJRing( m_PackedParticleLocations[ind], i,j,ring,layer );

if( layer < GetNumActiveLayers(m_CloudAttribs.uiMaxLayers, ring) )

{

m_CamSpaceOrder.push_back(ind);

m_LightSpaceOrder.push_back(ind);

}

}

m_RingGridAttribs.resize(m_CloudAttribs.uiNumRings);

HRESULT hr;

// Create cloud cell attributes buffer

{

D3D11_BUFFER_DESC CloudGridBuffDesc =

{

m_CloudAttribs.uiNumCells * sizeof(SCloudCellAttribs), //UINT ByteWidth;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS, //UINT BindFlags;

0, //UINT CPUAccessFlags;

D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, //UINT MiscFlags;

sizeof(SCloudCellAttribs) //UINT StructureByteStride;

};

m_pbufCloudGridSRV.Release();

m_pbufCloudGridUAV.Release();

V( CreateBufferAndViews( pDevice, CloudGridBuffDesc, nullptr, nullptr, &m_pbufCloudGridSRV, &m_pbufCloudGridUAV ) );

}

// Create particle attributes buffer

{

D3D11_BUFFER_DESC ParticleBuffDesc =

{

m_CloudAttribs.uiMaxParticles * sizeof(SParticleAttribs), //UINT ByteWidth;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS, //UINT BindFlags;

0, //UINT CPUAccessFlags;

D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, //UINT MiscFlags;

sizeof(SParticleAttribs) //UINT StructureByteStride;

};

m_pbufCloudParticlesSRV.Release();

m_pbufCloudParticlesUAV.Release();

V( CreateBufferAndViews( pDevice, ParticleBuffDesc, nullptr, nullptr, &m_pbufCloudParticlesSRV, &m_pbufCloudParticlesUAV ) );

}

// Create buffer for storing particle visibility flags

{

D3D11_BUFFER_DESC VisibleParticlesFlagsBuffDesc =

{

(m_CloudAttribs.uiMaxParticles + 31)/32 * sizeof(UINT), //UINT ByteWidth;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS, //UINT BindFlags;

0, //UINT CPUAccessFlags;

D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, //UINT MiscFlags;

sizeof(UINT) //UINT StructureByteStride;

};

m_pbufVisibleParticlesFlagsSRV.Release();

m_pbufVisibleParticlesFlagsUAV.Release();

V( CreateBufferAndViews( pDevice, VisibleParticlesFlagsBuffDesc, nullptr, nullptr, &m_pbufVisibleParticlesFlagsSRV, &m_pbufVisibleParticlesFlagsUAV) );

}

// Create buffer for storing particle lighting info

{

D3D11_BUFFER_DESC LightingBuffDesc =

{

m_CloudAttribs.uiMaxParticles * sizeof(SCloudParticleLighting), //UINT ByteWidth;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS, //UINT BindFlags;

0, //UINT CPUAccessFlags;

D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, //UINT MiscFlags;

sizeof(SCloudParticleLighting) //UINT StructureByteStride;

};

m_pbufParticlesLightingSRV.Release();

m_pbufParticlesLightingUAV.Release();

V( CreateBufferAndViews( pDevice, LightingBuffDesc, nullptr, nullptr, &m_pbufParticlesLightingSRV, &m_pbufParticlesLightingUAV) );

}

// Create buffer for storing attenuated sun light. Note that this buffer has different addressing scheme to allow direct

// access by the particle coordinates

{

D3D11_BUFFER_DESC AttenuatedSunLightBuffDesc =

{

m_CloudAttribs.uiNumRings * m_CloudAttribs.uiRingDimension * m_CloudAttribs.uiRingDimension * m_CloudAttribs.uiMaxLayers * sizeof(D3DXVECTOR4), //UINT ByteWidth;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS, //UINT BindFlags;

0, //UINT CPUAccessFlags;

D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, //UINT MiscFlags;

sizeof(D3DXVECTOR4) //UINT StructureByteStride;

};

m_pbufAttenuatedSunLightSRV.Release();

m_pbufAttenuatedSunLightUAV.Release();

V( CreateBufferAndViews( pDevice, AttenuatedSunLightBuffDesc, nullptr, nullptr, &m_pbufAttenuatedSunLightSRV, &m_pbufAttenuatedSunLightUAV) );

AttenuatedSunLightBuffDesc.Usage = D3D11_USAGE_IMMUTABLE;

AttenuatedSunLightBuffDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;

std::vector<float> MinusOne(AttenuatedSunLightBuffDesc.ByteWidth / sizeof(float), -1);

D3D11_SUBRESOURCE_DATA InitData = {&MinusOne[0], 0,0};

m_pbufDefaultAttenuatedSunLight.Release();

V( CreateBufferAndViews( pDevice, AttenuatedSunLightBuffDesc, &InitData, &m_pbufDefaultAttenuatedSunLight, nullptr, nullptr) );

}

// Create buffer for storing cell locations

{

D3D11_BUFFER_DESC PackedCellLocationsBuffDesc =

{

m_CloudAttribs.uiNumCells * sizeof(UINT), //UINT ByteWidth;

D3D11_USAGE_IMMUTABLE, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE, //UINT BindFlags;

0, //UINT CPUAccessFlags;

D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, //UINT MiscFlags;

sizeof(UINT) //UINT StructureByteStride;

};

m_pbufPackedCellLocationsSRV.Release();

D3D11_SUBRESOURCE_DATA InitData = {&m_PackedCellLocations[0], 0, 0};

CreateBufferAndViews( pDevice, PackedCellLocationsBuffDesc, &InitData, nullptr, &m_pbufPackedCellLocationsSRV, nullptr);

}

// Create buffer for storing unordered list of valid cell

{

D3D11_BUFFER_DESC ValidCellsBuffDesc =

{

m_CloudAttribs.uiNumCells * sizeof(UINT),//UINT ByteWidth;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS, //UINT BindFlags;

0, //UINT CPUAccessFlags;

D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, //UINT MiscFlags;

sizeof(UINT) //UINT StructureByteStride;

};

m_pbufValidCellsUnorderedList.Release();

m_pbufValidCellsUnorderedListSRV.Release();

m_pbufValidCellsUnorderedListUAV.Release();

V( CreateBufferAndViews( pDevice, ValidCellsBuffDesc, nullptr, &m_pbufValidCellsUnorderedList, &m_pbufValidCellsUnorderedListSRV, &m_pbufValidCellsUnorderedListUAV, D3D11_BUFFER_UAV_FLAG_APPEND) );

}

// Create buffer for storing unordered list of valid particles

{

D3D11_BUFFER_DESC ValidParticlesBuffDesc =

{

m_CloudAttribs.uiMaxParticles * sizeof(UINT), //UINT ByteWidth;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS, //UINT BindFlags;

0, //UINT CPUAccessFlags;

D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, //UINT MiscFlags;

sizeof(UINT) //UINT StructureByteStride;

};

m_pbufValidParticlesUnorderedList.Release();

m_pbufValidParticlesUnorderedListSRV.Release();

m_pbufValidParticlesUnorderedListUAV.Release();

V( CreateBufferAndViews( pDevice, ValidParticlesBuffDesc, nullptr, &m_pbufValidParticlesUnorderedList, &m_pbufValidParticlesUnorderedListSRV, &m_pbufValidParticlesUnorderedListUAV, D3D11_BUFFER_UAV_FLAG_APPEND) );

}

// Create buffer for storing sorted index of all particles

{

D3D11_BUFFER_DESC SortedParticlesBuffDesc =

{

m_CloudAttribs.uiMaxParticles * sizeof(UINT), //UINT ByteWidth;

D3D11_USAGE_DYNAMIC, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE, //UINT BindFlags;

D3D11_CPU_ACCESS_WRITE, //UINT CPUAccessFlags;

D3D11_RESOURCE_MISC_BUFFER_STRUCTURED, //UINT MiscFlags;

sizeof(UINT) //UINT StructureByteStride;

};

m_pbufSortedParticlesOrder.Release();

m_pbufSortedParticlesOrderSRV.Release();

V( CreateBufferAndViews( pDevice, SortedParticlesBuffDesc, nullptr, &m_pbufSortedParticlesOrder, &m_pbufSortedParticlesOrderSRV) );

}

// Create buffer for storing streamed out list of visible particles

{

D3D11_BUFFER_DESC SerializedParticlesBuffDesc =

{

m_CloudAttribs.uiMaxParticles * sizeof(UINT), //UINT ByteWidth;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_STREAM_OUTPUT|D3D11_BIND_VERTEX_BUFFER|D3D11_BIND_SHADER_RESOURCE, //UINT BindFlags;

0, //UINT CPUAccessFlags;

0, //UINT MiscFlags;

0 //UINT StructureByteStride;

};

m_pbufSerializedVisibleParticles.Release();

V(pDevice->CreateBuffer( &SerializedParticlesBuffDesc, nullptr, &m_pbufSerializedVisibleParticles));

D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;

ZeroMemory(&SRVDesc, sizeof(SRVDesc));

SRVDesc.Format = DXGI_FORMAT_R32_UINT;

SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;

SRVDesc.Buffer.ElementOffset = 0;

SRVDesc.Buffer.ElementWidth = sizeof(UINT);

m_pbufSerializedVisibleParticlesSRV.Release();

V(pDevice->CreateShaderResourceView( m_pbufSerializedVisibleParticles, &SRVDesc, &m_pbufSerializedVisibleParticlesSRV));

}

return S_OK;

{

HRESULT hr;

int iNumStartPosZenithAngles = m_PrecomputedOpticalDepthTexDim.iNumStartPosZenithAngles;

int iNumStartPosAzimuthAngles = m_PrecomputedOpticalDepthTexDim.iNumStartPosAzimuthAngles;

int iNumDirectionZenithAngles = m_PrecomputedOpticalDepthTexDim.iNumDirectionZenithAngles;

int iNumDirectionAzimuthAngles= m_PrecomputedOpticalDepthTexDim.iNumDirectionAzimuthAngles;

D3D11_TEXTURE3D_DESC PrecomputedOpticalDepthTexDesc =

{

iNumStartPosZenithAngles, //UINT Width;

iNumStartPosAzimuthAngles, //UINT Height;

iNumDirectionZenithAngles * iNumDirectionAzimuthAngles, //UINT Depth;

5, //UINT MipLevels;

DXGI_FORMAT_R8G8_UNORM,//DXGI_FORMAT Format;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET,//UINT BindFlags;

0,//UINT CPUAccessFlags;

D3D11_RESOURCE_MISC_GENERATE_MIPS //UINT MiscFlags;

};

CComPtr<ID3D11Texture3D> ptex3DPrecomputedParticleDensity;

V_RETURN( pDevice->CreateTexture3D(&PrecomputedOpticalDepthTexDesc, nullptr, &ptex3DPrecomputedParticleDensity));

m_ptex3DPrecomputedParticleDensitySRV.Release();

V_RETURN(pDevice->CreateShaderResourceView( ptex3DPrecomputedParticleDensity, nullptr, &m_ptex3DPrecomputedParticleDensitySRV));

if( !m_ComputeOpticalDepthTech.IsValid() )

{

CD3DShaderMacroHelper Macros;

DefineMacros(Macros);

Macros.AddShaderMacro("DENSITY_GENERATION_METHOD", m_CloudAttribs.uiDensityGenerationMethod);

Macros.Finalize();

m_ComputeOpticalDepthTech.SetDeviceAndContext(pDevice, pDeviceContext);

m_ComputeOpticalDepthTech.CreateVGPShadersFromFile(m_strPreprocessingEffectPath, "ScreenSizeQuadVS", nullptr, "PrecomputeOpticalDepthPS", Macros);

m_ComputeOpticalDepthTech.SetDS( m_pdsDisableDepth );

m_ComputeOpticalDepthTech.SetRS( m_prsSolidFillNoCull );

m_ComputeOpticalDepthTech.SetBS( m_pbsDefault );

}

CComPtr<ID3D11RenderTargetView> pOrigRTV;

CComPtr<ID3D11DepthStencilView> pOrigDSV;

pDeviceContext->OMGetRenderTargets(1, &pOrigRTV, &pOrigDSV);

D3D11_VIEWPORT OrigViewPort;

UINT iNumOldViewports = 1;

pDeviceContext->RSGetViewports(&iNumOldViewports, &OrigViewPort);

ID3D11Buffer *pCBs[] = {m_pcbGlobalCloudAttribs/*, RenderAttribs.pcMediaScatteringParams*/};

pDeviceContext->PSSetConstantBuffers(0, _countof(pCBs), pCBs);

ID3D11SamplerState *pSamplers[] = {m_psamLinearClamp, m_psamLinearWrap, m_psamPointWrap};

pDeviceContext->VSSetSamplers(0, _countof(pSamplers), pSamplers);

pDeviceContext->PSSetSamplers(0, _countof(pSamplers), pSamplers);

ID3D11ShaderResourceView *pSRVs[] =

{

m_ptex3DNoiseSRV,

};

for(UINT Slice = 0; Slice < PrecomputedOpticalDepthTexDesc.Depth; ++Slice)

{

D3D11_RENDER_TARGET_VIEW_DESC RTVDesc;

RTVDesc.Format = PrecomputedOpticalDepthTexDesc.Format;

RTVDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D;

RTVDesc.Texture3D.MipSlice = 0;

RTVDesc.Texture3D.FirstWSlice = Slice;

RTVDesc.Texture3D.WSize = 1;

CComPtr<ID3D11RenderTargetView> pSliceRTV;

V_RETURN(pDevice->CreateRenderTargetView( ptex3DPrecomputedParticleDensity, &RTVDesc, &pSliceRTV));

UINT uiDirectionZenith = Slice % iNumDirectionZenithAngles;

UINT uiDirectionAzimuth= Slice / iNumDirectionZenithAngles;

m_CloudAttribs.f4Parameter.x = ((float)uiDirectionZenith + 0.5f) / (float)iNumDirectionZenithAngles;

m_CloudAttribs.f4Parameter.y = ((float)uiDirectionAzimuth + 0.5f) / (float)iNumDirectionAzimuthAngles;

assert(0 < m_CloudAttribs.f4Parameter.x && m_CloudAttribs.f4Parameter.x < 1);

assert(0 < m_CloudAttribs.f4Parameter.y && m_CloudAttribs.f4Parameter.y < 1);

UpdateConstantBuffer(pDeviceContext, m_pcbGlobalCloudAttribs, &m_CloudAttribs, sizeof(m_CloudAttribs));

pDeviceContext->OMSetRenderTargets(1, &pSliceRTV.p, nullptr);

pDeviceContext->PSSetShaderResources(0, _countof(pSRVs), pSRVs);

RenderQuad(pDeviceContext, m_ComputeOpticalDepthTech, PrecomputedOpticalDepthTexDesc.Width, PrecomputedOpticalDepthTexDesc.Height);

}

pDeviceContext->GenerateMips( m_ptex3DPrecomputedParticleDensitySRV);

pDeviceContext->OMSetRenderTargets(1, &pOrigRTV.p, pOrigDSV);

pDeviceContext->RSSetViewports(iNumOldViewports, &OrigViewPort);

return S_OK;

{

HRESULT hr;

LPCTSTR SingleSctrTexPath = L"media\\SingleSctr.dds";

LPCTSTR MultipleSctrTexPath = L"media\\MultipleSctr.dds";

HRESULT hr1 = D3DX11CreateShaderResourceViewFromFile(pDevice, SingleSctrTexPath, nullptr, nullptr, &m_ptex3DSingleSctrInParticleLUT_SRV, nullptr);

HRESULT hr2 = D3DX11CreateShaderResourceViewFromFile(pDevice, MultipleSctrTexPath, nullptr, nullptr, &m_ptex3DMultipleSctrInParticleLUT_SRV, nullptr);

if( SUCCEEDED(hr1) && SUCCEEDED(hr2) )

return S_OK;

D3D11_TEXTURE3D_DESC PrecomputedScatteringTexDesc =

{

m_PrecomputedSctrInParticleLUTDim.iNumStartPosZenithAngles, //UINT Width;

m_PrecomputedSctrInParticleLUTDim.iNumViewDirAzimuthAngles, //UINT Height;

// We are only interested in rays going into the sphere, which is half of the total number of diections

m_PrecomputedSctrInParticleLUTDim.iNumViewDirZenithAngles/2 * m_PrecomputedSctrInParticleLUTDim.iNumDensityLevels, //UINT Depth;

1, //UINT MipLevels;

DXGI_FORMAT_R16_FLOAT,//DXGI_FORMAT Format;

D3D11_USAGE_DEFAULT, //D3D11_USAGE Usage;

D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET,//UINT BindFlags;

0,//UINT CPUAccessFlags;

0 //UINT MiscFlags;

};

CComPtr<ID3D11Texture3D> ptex3DSingleScatteringInParticleLUT, ptex3DMultipleScatteringInParticleLUT;

V_RETURN( pDevice->CreateTexture3D(&PrecomputedScatteringTexDesc, nullptr, &ptex3DSingleScatteringInParticleLUT));

V_RETURN( pDevice->CreateTexture3D(&PrecomputedScatteringTexDesc, nullptr, &ptex3DMultipleScatteringInParticleLUT));

m_ptex3DSingleSctrInParticleLUT_SRV.Release();

m_ptex3DMultipleSctrInParticleLUT_SRV.Release();

V_RETURN(pDevice->CreateShaderResourceView( ptex3DSingleScatteringInParticleLUT, nullptr, &m_ptex3DSingleSctrInParticleLUT_SRV));

V_RETURN(pDevice->CreateShaderResourceView( ptex3DMultipleScatteringInParticleLUT, nullptr, &m_ptex3DMultipleSctrInParticleLUT_SRV));

D3D11_TEXTURE3D_DESC TmpScatteringTexDesc = PrecomputedScatteringTexDesc;

TmpScatteringTexDesc.Format = DXGI_FORMAT_R32_FLOAT;

TmpScatteringTexDesc.Depth = m_PrecomputedSctrInParticleLUTDim.iNumViewDirZenithAngles * m_PrecomputedSctrInParticleLUTDim.iNumDistancesFromCenter;

CComPtr<ID3D11Texture3D> ptex3DSingleSctr, ptex3DGatheredScatteringN, ptex3DSctrOrderN, ptex3DMultipeScattering;

V_RETURN( pDevice->CreateTexture3D(&TmpScatteringTexDesc, nullptr, &ptex3DSingleSctr));

V_RETURN( pDevice->CreateTexture3D(&TmpScatteringTexDesc, nullptr, &ptex3DGatheredScatteringN));

V_RETURN( pDevice->CreateTexture3D(&TmpScatteringTexDesc, nullptr, &ptex3DSctrOrderN));

V_RETURN( pDevice->CreateTexture3D(&TmpScatteringTexDesc, nullptr, &ptex3DMultipeScattering));

std::vector< CComPtr<ID3D11RenderTargetView> > ptex3DSingleSctrRTVs(TmpScatteringTexDesc.Depth);

std::vector< CComPtr<ID3D11RenderTargetView> > ptex3DGatheredScatteringN_RTVs(TmpScatteringTexDesc.Depth);

std::vector< CComPtr<ID3D11RenderTargetView> > ptex3DSctrOrderN_RTVs(TmpScatteringTexDesc.Depth);

std::vector< CComPtr<ID3D11RenderTargetView> > ptex3DMultipeScatteringRTVs(TmpScatteringTexDesc.Depth);

CComPtr<ID3D11ShaderResourceView> ptex3DSingleSctrSRV;

CComPtr<ID3D11ShaderResourceView> ptex3DGatheredScatteringN_SRV;

CComPtr<ID3D11ShaderResourceView> ptex3DSctrOrderN_SRV;

CComPtr<ID3D11ShaderResourceView> ptex3DMultipeScatteringSRV;

V_RETURN(pDevice->CreateShaderResourceView( ptex3DSingleSctr, nullptr, &ptex3DSingleSctrSRV));

V_RETURN(pDevice->CreateShaderResourceView( ptex3DGatheredScatteringN, nullptr, &ptex3DGatheredScatteringN_SRV));

V_RETURN(pDevice->CreateShaderResourceView( ptex3DSctrOrderN, nullptr, &ptex3DSctrOrderN_SRV));

V_RETURN(pDevice->CreateShaderResourceView( ptex3DMultipeScattering, nullptr, &ptex3DMultipeScatteringSRV));

for(UINT Slice = 0; Slice < TmpScatteringTexDesc.Depth; ++Slice)

{

D3D11_RENDER_TARGET_VIEW_DESC RTVDesc;

RTVDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D;

RTVDesc.Texture3D.MipSlice = 0;

RTVDesc.Texture3D.FirstWSlice = Slice;

RTVDesc.Texture3D.WSize = 1;

RTVDesc.Format = TmpScatteringTexDesc.Format;

V_RETURN(pDevice->CreateRenderTargetView( ptex3DSingleSctr, &RTVDesc, &ptex3DSingleSctrRTVs[Slice]) );

V_RETURN(pDevice->CreateRenderTargetView( ptex3DGatheredScatteringN, &RTVDesc, &ptex3DGatheredScatteringN_RTVs[Slice]));

V_RETURN(pDevice->CreateRenderTargetView( ptex3DSctrOrderN, &RTVDesc, &ptex3DSctrOrderN_RTVs[Slice]) );

V_RETURN(pDevice->CreateRenderTargetView( ptex3DMultipeScattering, &RTVDesc, &ptex3DMultipeScatteringRTVs[Slice]) );

}

if( !m_ComputeSingleSctrInParticleTech.IsValid() )

{

CD3DShaderMacroHelper Macros;

DefineMacros(Macros);

Macros.Finalize();

m_ComputeSingleSctrInParticleTech.SetDeviceAndContext(pDevice, pDeviceContext);

m_ComputeSingleSctrInParticleTech.CreateVGPShadersFromFile(m_strPreprocessingEffectPath, "ScreenSizeQuadVS", nullptr, "PrecomputeSingleSctrPS", Macros);

m_ComputeSingleSctrInParticleTech.SetDS( m_pdsDisableDepth );

m_ComputeSingleSctrInParticleTech.SetRS( m_prsSolidFillNoCull );

m_ComputeSingleSctrInParticleTech.SetBS( m_pbsDefault );

}

if( !m_RenderScatteringLUTSliceTech.IsValid() )

{

CD3DShaderMacroHelper Macros;

DefineMacros(Macros);

Macros.Finalize();

m_RenderScatteringLUTSliceTech.SetDeviceAndContext(pDevice, pDeviceContext);

m_RenderScatteringLUTSliceTech.CreateVGPShadersFromFile(m_strPreprocessingEffectPath, "ScreenSizeQuadVS", nullptr, "RenderScatteringLUTSlicePS", Macros);

m_RenderScatteringLUTSliceTech.SetDS( m_pdsDisableDepth );

m_RenderScatteringLUTSliceTech.SetRS( m_prsSolidFillNoCull );

m_RenderScatteringLUTSliceTech.SetBS( m_pbsDefault );

}

if( !m_GatherPrevSctrOrderTech.IsValid() )

{

CD3DShaderMacroHelper Macros;

DefineMacros(Macros);

Macros.Finalize();

m_GatherPrevSctrOrderTech.SetDeviceAndContext(pDevice, pDeviceContext);

m_GatherPrevSctrOrderTech.CreateVGPShadersFromFile(m_strPreprocessingEffectPath, "ScreenSizeQuadVS", nullptr, "GatherScatteringPS", Macros);

m_GatherPrevSctrOrderTech.SetDS( m_pdsDisableDepth );

m_GatherPrevSctrOrderTech.SetRS( m_prsSolidFillNoCull );

m_GatherPrevSctrOrderTech.SetBS( m_pbsDefault );

}

if( !m_ComputeScatteringOrderTech.IsValid() )

{

CD3DShaderMacroHelper Macros;

DefineMacros(Macros);

Macros.Finalize();

m_ComputeScatteringOrderTech.SetDeviceAndContext(pDevice, pDeviceContext);

m_ComputeScatteringOrderTech.CreateVGPShadersFromFile(m_strPreprocessingEffectPath, "ScreenSizeQuadVS", nullptr, "ComputeScatteringOrderPS", Macros);

m_ComputeScatteringOrderTech.SetDS( m_pdsDisableDepth );

m_ComputeScatteringOrderTech.SetRS( m_prsSolidFillNoCull );

m_ComputeScatteringOrderTech.SetBS( m_pbsDefault );

}

if( !m_AccumulateInscatteringTech.IsValid() )

{

CD3DShaderMacroHelper Macros;

DefineMacros(Macros);

Macros.Finalize();

m_AccumulateInscatteringTech.SetDeviceAndContext(pDevice, pDeviceContext);

m_AccumulateInscatteringTech.CreateVGPShadersFromFile(m_strPreprocessingEffectPath, "ScreenSizeQuadVS", nullptr, "AccumulateMultipleScattering", Macros);

m_AccumulateInscatteringTech.SetDS( m_pdsDisableDepth );

m_AccumulateInscatteringTech.SetRS( m_prsSolidFillNoCull );

D3D11_BLEND_DESC AdditiveBlendStateDesc;

ZeroMemory(&AdditiveBlendStateDesc, sizeof(AdditiveBlendStateDesc));

AdditiveBlendStateDesc.IndependentBlendEnable = FALSE;

for(int i=0; i< _countof(AdditiveBlendStateDesc.RenderTarget); i++)

AdditiveBlendStateDesc.RenderTarget[i].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;

AdditiveBlendStateDesc.RenderTarget[0].BlendEnable = TRUE;

AdditiveBlendStateDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;

AdditiveBlendStateDesc.RenderTarget[0].BlendOpAlpha= D3D11_BLEND_OP_ADD;

AdditiveBlendStateDesc.RenderTarget[0].DestBlend = D3D11_BLEND_ONE;

AdditiveBlendStateDesc.RenderTarget[0].DestBlendAlpha= D3D11_BLEND_ONE;

AdditiveBlendStateDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_ONE;

AdditiveBlendStateDesc.RenderTarget[0].SrcBlendAlpha= D3D11_BLEND_ONE;

CComPtr<ID3D11BlendState> pAdditiveBlendBS;

V_RETURN( pDevice->CreateBlendState( &AdditiveBlendStateDesc, &pAdditiveBlendBS) );

m_AccumulateInscatteringTech.SetBS( pAdditiveBlendBS );

}

CComPtr<ID3D11RenderTargetView> pOrigRTV;

CComPtr<ID3D11DepthStencilView> pOrigDSV;

pDeviceContext->OMGetRenderTargets(1, &pOrigRTV, &pOrigDSV);

D3D11_VIEWPORT OrigViewPort;

UINT iNumOldViewports = 1;

pDeviceContext->RSGetViewports(&iNumOldViewports, &OrigViewPort);

ID3D11Buffer *pCBs[] = {m_pcbGlobalCloudAttribs/*, RenderAttribs.pcMediaScatteringParams*/};

pDeviceContext->PSSetConstantBuffers(0, _countof(pCBs), pCBs);

ID3D11SamplerState *pSamplers[] = {m_psamLinearClamp, m_psamLinearWrap, m_psamPointWrap};

pDeviceContext->VSSetSamplers(0, _countof(pSamplers), pSamplers);

pDeviceContext->PSSetSamplers(0, _countof(pSamplers), pSamplers);

for(int iDensityLevel = 0; iDensityLevel < m_PrecomputedSctrInParticleLUTDim.iNumDensityLevels; ++iDensityLevel)

{

for(UINT Slice = 0; Slice < TmpScatteringTexDesc.Depth; ++Slice)

{

float Zero[4]={0,0,0,0};

pDeviceContext->ClearRenderTargetView(ptex3DMultipeScatteringRTVs[Slice], Zero);

}

// Precompute single scattering

for(UINT Slice = 0; Slice < TmpScatteringTexDesc.Depth; ++Slice)

{

UINT uiViewDirZenith = Slice % m_PrecomputedSctrInParticleLUTDim.iNumViewDirZenithAngles;

UINT uiDistFromCenter = Slice / m_PrecomputedSctrInParticleLUTDim.iNumViewDirZenithAngles;

m_CloudAttribs.f4Parameter.x = ((float)uiViewDirZenith + 0.5f) / (float)m_PrecomputedSctrInParticleLUTDim.iNumViewDirZenithAngles;

m_CloudAttribs.f4Parameter.y = ((float)uiDistFromCenter + 0.5f) / (float)m_PrecomputedSctrInParticleLUTDim.iNumDistancesFromCenter;

m_CloudAttribs.f4Parameter.z = ((float)iDensityLevel + 0.5f) / (float)m_PrecomputedSctrInParticleLUTDim.iNumDensityLevels;

assert(0 < m_CloudAttribs.f4Parameter.x && m_CloudAttribs.f4Parameter.x < 1);

assert(0 < m_CloudAttribs.f4Parameter.y && m_CloudAttribs.f4Parameter.y < 1);

assert(0 < m_CloudAttribs.f4Parameter.z && m_CloudAttribs.f4Parameter.z < 1);

UpdateConstantBuffer(pDeviceContext, m_pcbGlobalCloudAttribs, &m_CloudAttribs, sizeof(m_CloudAttribs));

ID3D11RenderTargetView *pSliceRTV = ptex3DSingleSctrRTVs[Slice];

pDeviceContext->OMSetRenderTargets(1, &pSliceRTV, nullptr);

ID3D11ShaderResourceView *pSRVs[] =

{

m_ptex3DNoiseSRV,

};

pDeviceContext->PSSetShaderResources(0, _countof(pSRVs), pSRVs);

RenderQuad(pDeviceContext, m_ComputeSingleSctrInParticleTech, TmpScatteringTexDesc.Width, TmpScatteringTexDesc.Height);

}

// Number of scattering orders is chosen so as to obtain reasonable exitance through the particle surface

const int iMaxScatteringOrder = 18;

for(int iSctrOrder = 1; iSctrOrder < iMaxScatteringOrder; ++iSctrOrder)

{

for(int iPass = 0; iPass < 3; ++iPass)

{

// Gather scattering of previous order

for(UINT Slice = 0; Slice < TmpScatteringTexDesc.Depth; ++Slice)

{

if( iPass < 2 )

{

UINT uiViewDirZenith = Slice % m_PrecomputedSctrInParticleLUTDim.iNumViewDirZenithAngles;

UINT uiDistFromCenter = Slice / m_PrecomputedSctrInParticleLUTDim.iNumViewDirZenithAngles;

m_CloudAttribs.f4Parameter.x = ((float)uiViewDirZenith + 0.5f) / (float)m_PrecomputedSctrInParticleLUTDim.iNumViewDirZenithAngles;

m_CloudAttribs.f4Parameter.y = ((float)uiDistFromCenter + 0.5f) / (float)m_PrecomputedSctrInParticleLUTDim.iNumDistancesFromCenter;

m_CloudAttribs.f4Parameter.z = ((float)iDensityLevel + 0.5f) / (float)m_PrecomputedSctrInParticleLUTDim.iNumDensityLevels;

assert(0 < m_CloudAttribs.f4Parameter.x && m_CloudAttribs.f4Parameter.x < 1);

assert(0 < m_CloudAttribs.f4Parameter.y && m_CloudAttribs.f4Parameter.y < 1);

assert(0 < m_CloudAttribs.f4Parameter.z && m_CloudAttribs.f4Parameter.z < 1);

m_CloudAttribs.f4Parameter.w = (float)iSctrOrder;

}

else

{

m_CloudAttribs.f4Parameter.x = ((float)Slice + 0.5f) / (float)TmpScatteringTexDesc.Depth;

assert(0 < m_CloudAttribs.f4Parameter.x && m_CloudAttribs.f4Parameter.x < 1);

}

UpdateConstantBuffer(pDeviceContext, m_pcbGlobalCloudAttribs, &m_CloudAttribs, sizeof(m_CloudAttribs));

ID3D11RenderTargetView *pSliceRTV = nullptr;

CRenderTechnique *pTechnique = nullptr;

ID3D11ShaderResourceView *pSRVs[1] = {nullptr};

switch(iPass)

{

// Gather scattering of previous order

case 0:

pSRVs[0] = iSctrOrder > 1 ? ptex3DSctrOrderN_SRV : ptex3DSingleSctrSRV;

pSliceRTV = ptex3DGatheredScatteringN_RTVs[Slice];