DXR-Volumebaker.raytrace

#include "UnityShaderVariables.cginc"
#include "UnityRaytracingMeshUtils.cginc"
#include "HLSLSupport.cginc"

#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Macros.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Packing.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Sampling/Sampling.hlsl"

//#include "Noise.cginc"
#pragma only_renderers d3d12

#pragma max_recursion_depth 1

#define M_PI 3.1415926535897932384626433832795


// Input
RaytracingAccelerationStructure g_SceneAccelStruct;

//Global inputs 
uint	PointLightCount;
uint	ConeLightCount;
uint	DirLightCount;
uint	AreaLightCount;
uint	AreaLightSamples;
uint	EnvLightSamples;

struct PointLightData{
float3	PointLightsWS;
float4	PointLightsColor;
};

struct ConeLightData{
float3	ConeLightsWS;
float4	ConeLightsColor	;
float3	ConeLightsDir	;
float2	ConeLightsPram	; //Outter , inner
};

struct DirLightData{
float3	DirLightsDir;
float4	DirLightsColor;
};

struct AreaLightData{
float4x4	AreaLightsMatrix;
float4x4	AreaLightsMatrixInv;
float3	AreaLightsWS;
float4	AreaLightsColor;
float3	AreaLightsSize;
};

StructuredBuffer<PointLightData> PLD;
StructuredBuffer<ConeLightData> CLD;
StructuredBuffer<DirLightData> DLD;
StructuredBuffer<AreaLightData> ALD;

float3	WPosition;
float3	Size = float3(1,1,1);

// Output
RWTexture3D<float4> g_Output;

struct RayPayload
{
    float4 color;
};

struct EnvRayPayload
{
    float4 color;
    float3 dir;
};

struct Material
{
    float3 emissive;    
};

struct AttributeData
{
    float2 barycentrics; 
};

struct Vertex
{
    float2 texcoord;
};

TextureCube  _SkyTexture;
SamplerState  sampler_SkyTexture;


//Miss for raycasting from voxel to light. Miss means that the ray is unobscured from the source light 
[shader("miss")]
void MainMissShader(inout RayPayload payload : SV_RayPayload)
{
    payload.color = float4(1, 1, 1, 1);
}

//
[shader("miss")]
void zEnvMissShader(inout EnvRayPayload payload : SV_RayPayload)
{
    //Enviormental    
    payload.color = _SkyTexture.SampleLevel(sampler_SkyTexture, payload.dir, 5);
}

float InverseSquare(float distance){
	return	1 / (4 * M_PI * distance * distance);
}

//Dumb coarse randomizers
float rand(float2 Pixel)
{
    float _Seed = Pixel.x + Pixel.y ;

	float result = frac(sin(_Seed / 100.0f * dot(Pixel, float2(12.9898f, 78.233f) ) ) * 43758.5453f);
//	_Seed = _Seed + 1.0f;
	return result;
}

float rand(float3 Pixel)
{
    float _Seed = Pixel.x + Pixel.y + Pixel.z ;

	float result = frac(sin(_Seed / 100.0f * dot(Pixel, float3(12.9898f, 49.1165f, 29.1165f))) * 43758.5453f);
//	_Seed += 1.0f;
	return result;
}

///
///Point light
///
float4 PointLightCast(float3 VoxelWS, uint Num){

	float LightRadius = distance(VoxelWS, PLD[Num].PointLightsWS ); 
    float3 rayDirection =  -normalize(VoxelWS - PLD[Num].PointLightsWS)  ;

    RayDesc ray;
    ray.Origin    = VoxelWS;
    ray.Direction = rayDirection;
    ray.TMin      = 0.0f;
    ray.TMax      = LightRadius;

    RayPayload payload;
    payload.color = float4(0, 0, 0, 0);

    uint missShaderIndex = 0;
    TraceRay(g_SceneAccelStruct, 0, 0xFF, 0, 1, missShaderIndex, ray, payload); //Add an anyhit shader to support transparencies 

	return payload.color * InverseSquare(LightRadius) * PLD[Num].PointLightsColor;
}

///
/// Cone light
///

float4 ConeLightCast(float3 VoxelWS, uint Num){


    float3 rayDirection =  -normalize(VoxelWS - CLD[Num].ConeLightsWS)  ;

	//Currently taking a point light and adding attenuation
	float attenuation = (dot(CLD[Num].ConeLightsDir, -rayDirection));

    if (attenuation <= 0) return float4(0, 0, 0, 0); //early out

    float LightRadius = (distance(VoxelWS, CLD[Num].ConeLightsWS )); 

	/////
	float flOuterConeCos = CLD[Num].ConeLightsPram.x;
	float flTemp = dot(CLD[Num].ConeLightsDir, -rayDirection) - flOuterConeCos;
	float vSpotAtten = saturate(flTemp * CLD[Num].ConeLightsPram.y);
	///

    RayDesc ray;
    ray.Origin    = VoxelWS;
    ray.Direction = rayDirection;
    ray.TMin      = 0.0f;
    ray.TMax      = LightRadius;

    RayPayload payload;
    payload.color = float4(0, 0, 0, 0);

    uint missShaderIndex = 0;
    TraceRay(g_SceneAccelStruct, 0, 0xFF, 0, 1, missShaderIndex, ray, payload); //Add an anyhit shader to support transparencies 

	return  InverseSquare(LightRadius) * vSpotAtten * payload.color * CLD[Num].ConeLightsColor;
}

//
//Directional Light
//

float4 DirLightCast(float3 VoxelWS, uint Num){

    float3 rayDirection = -DLD[Num].DirLightsDir;

    RayDesc ray;
    ray.Origin    = VoxelWS;
    ray.Direction = rayDirection;
    ray.TMin      = 0.0f;
    ray.TMax      =  1000.0f;

    RayPayload payload;
    payload.color = float4(0, 0, 0, 0);

    uint missShaderIndex = 0;
    TraceRay(g_SceneAccelStruct, 0, 0xFF, 0, 1, missShaderIndex, ray, payload); //Add an anyhit shader to support transparencies 

	return  payload.color * DLD[Num].DirLightsColor;
}

//
//Area Light
//

float4 AreaLightCast(float3 VoxelWS, uint Num){
  //  
    float3 lsPos = float3(ALD[Num].AreaLightsMatrix[0][3], ALD[Num].AreaLightsMatrix[1][3],ALD[Num].AreaLightsMatrix[2][3]);
    float3 VoxelLS =  mul( float4(VoxelWS.xyz,1)-lsPos, ALD[Num].AreaLightsMatrix);
    float4 areaLightAccumulation = float4(0,0,0,0);
    if (VoxelLS.z <= 0) return areaLightAccumulation; //Early out
    uint3 id =  DispatchRaysIndex().xyz; //redundent, oh well

  for (int j = 0; j < AreaLightSamples; j++) 
  {
    //int loop64 = fmod(j + AreaLightSamples + id.x+id.y+id.z,64);
    float3 LocalPos = mul(ALD[Num].AreaLightsWS.xyz -lsPos , ALD[Num].AreaLightsMatrix).xyz ;
    float3 LightPosSample = LocalPos + float3( (rand(id.xyz + j)-0.5) *  ALD[Num].AreaLightsSize.x , (rand(id.xyz+j+20)-0.5) * ALD[Num].AreaLightsSize.y,0);
    //float3 LightPosSample = LocalPos + float3( BlueNoiseInDisk[loop64].x *  AreaLightsSize[Num].x * 0.5  , BlueNoiseInDisk[loop64].y * AreaLightsSize[Num].y *0.5, 0   );

    float LightRadius = distance(VoxelLS, LightPosSample ); 

	float3 rayDirection = -normalize(VoxelLS - LightPosSample);

	float attenuation = saturate(dot(float3(0,0,1), -rayDirection));

    RayDesc ray;
    ray.Origin    = VoxelWS;
    ray.Direction = mul(rayDirection, ALD[Num].AreaLightsMatrixInv);
    ray.TMin      = 0.0f;
    ray.TMax      = LightRadius;

    RayPayload payload;
    payload.color = float4(0, 0, 0, 0);

    uint missShaderIndex = 0;
    TraceRay(g_SceneAccelStruct, 0, 0xFF, 0, 1, missShaderIndex, ray, payload); //Add an anyhit shader to support transparencies 

    areaLightAccumulation += saturate(InverseSquare(LightRadius) * payload.color * ALD[Num].AreaLightsColor * attenuation) / AreaLightSamples;
   }
	return  areaLightAccumulation;
}

//
//Disk light
//

float4 DiscLightCast(float3 VoxelWS, uint Num){
  //  
    float3 lsPos = float3(ALD[Num].AreaLightsMatrix[0][3], ALD[Num].AreaLightsMatrix[1][3],ALD[Num].AreaLightsMatrix[2][3]);
    float3 VoxelLS =  mul( float4(VoxelWS.xyz,1)-lsPos, ALD[Num].AreaLightsMatrix);
    float3 IntialDirection =  -normalize(VoxelWS - ALD[Num].AreaLightsWS)  ;
    uint3 id =  DispatchRaysIndex().xyz;
    float4 areaLightAccumulation = float4(0,0,0,0);
    if (VoxelLS.z <= 0) return areaLightAccumulation;

  for (int j = 0; j < AreaLightSamples; j++) 
  {
    float3 LocalPos = mul(ALD[Num].AreaLightsWS.xyz -lsPos , ALD[Num].AreaLightsMatrix).xyz ;
    //https://stackoverflow.com/questions/5837572/generate-a-random-point-within-a-circle-uniformly
    float t = 2 * M_PI * rand(id.xyz + j + 30);
    float u = rand(id.xyz + j) + rand(id.xyz + j + 20);
    float r;
    if (u > 1) r = (2 - u);
    else  r = u;
    //	[r * cos(t), r * sin(t)]

    float3 LightPosSample = LocalPos +  
        float3( ( r * cos(t)) * ALD[Num].AreaLightsSize.x,
                ( r * sin(t)) * ALD[Num].AreaLightsSize.x,
                0);


    float LightRadius = distance(VoxelLS, LightPosSample ); 

	float3 rayDirection = -normalize(VoxelLS - LightPosSample);

	float attenuation = saturate(dot(float3(0,0,1), -rayDirection));

    RayDesc ray;
    ray.Origin    = VoxelWS;
    ray.Direction = mul(rayDirection, ALD[Num].AreaLightsMatrixInv);
    ray.TMin      = 0.0f;
    ray.TMax      = LightRadius;

    RayPayload payload;
    payload.color = float4(0, 0, 0, 0);

    uint missShaderIndex = 0;
    TraceRay(g_SceneAccelStruct, 0, 0xFF, 0, 1, missShaderIndex, ray, payload); //Add an anyhit shader to support transparencies 

    areaLightAccumulation += saturate(InverseSquare(LightRadius) * payload.color * ALD[Num].AreaLightsColor * attenuation) / AreaLightSamples;
   }
	return  areaLightAccumulation;
}

//Cast Ray from vox to env
float4 EnvCast(float3 VoxelWS){

    float4 Accumulation = float4(0,0,0,0);

   for (int j = 0; j < EnvLightSamples; j++) 
    {

        int _RaytracingFrameIndex = 100; //temp cast

        int globalSampleIndex = _RaytracingFrameIndex * EnvLightSamples + j;

        float2 theSample;
      //  theSample.x = GetBNDSequenceSample(VoxelWS, globalSampleIndex, 0);
     //   theSample.y = GetBNDSequenceSample(VoxelWS, globalSampleIndex, 1);
        uint3 id =  DispatchRaysIndex().xyz; //redundent, oh well

        theSample.x = rand(id.xyz + j * 5);
        theSample.y = rand(id.xyz + j + 23);

        float3 rayDirection = SampleSphereUniform(theSample.x, theSample.y);

        RayDesc ray;
        ray.Origin    = VoxelWS;
        ray.Direction = rayDirection;
        ray.TMin      = 0.0f;
        ray.TMax      = 100000;

        RayPayload payload;
        payload.color = float4(0, 0, 0, 0);

        uint missShaderIndex = 1;
        TraceRay(g_SceneAccelStruct, 0, 0xFF, 0, 1, missShaderIndex, ray, payload);
        
        Accumulation += payload.color / EnvLightSamples ;
    }
    return Accumulation;
}



//
// Main shader
//

[shader("raygeneration")]
void MainRayGenShader()
{
    float3 launchIndex = DispatchRaysIndex().xyz + float3(.5,.5,.5); //id
    float3 launchDim = DispatchRaysDimensions().xyz; //whd
    float3 VoxelWorldPosition = WPosition + ( ( launchIndex/launchDim ) / Size );

	float4 LightAccumulation = float4(0,0,0,0);

	for (int i=0; i< PointLightCount; i++)  LightAccumulation += PointLightCast(VoxelWorldPosition, i) ; 
	for (int i=0; i< ConeLightCount; i++)	LightAccumulation += ConeLightCast(VoxelWorldPosition, i) ; 
	for (int i=0; i< DirLightCount; i++)	LightAccumulation += DirLightCast(VoxelWorldPosition, i) ; 
	for (int i=0; i< AreaLightCount; i++){	
      if (ALD[i].AreaLightsSize.z == 0)  LightAccumulation += AreaLightCast(VoxelWorldPosition, i) ; 
      else  LightAccumulation += DiscLightCast(VoxelWorldPosition, i) ;
    }
    LightAccumulation += EnvCast(VoxelWorldPosition);

    g_Output[launchIndex] = LightAccumulation;
}