daveh355 / clustered-shading Goto Github PK

private DeferredClusterShader shader;
private DeferredLightAABBCullingShader lightCullingShader;
private DeferredTestShader lightingShader;

private Texture deferredSceneTexture;

private int ssbo;
private int lightSSBO;

private int gridSizeX = 12;
private int gridSizeY = 12;
private int gridSizeZ = 24;
private int numClusters = gridSizeX * gridSizeY * gridSizeZ;

private final int clusterAlignedSize = 448; // (436 + 16 - 1) & ~(16 - 1) = 448 bytes
private final int lightAlignedSize = 48; // (12 + 12 + 4 + 4) = 32 bytes

private int width;
private int height;

private Mesh mesh;
private RenderParameter config;

private boolean isFirstPass = true;

public TestCluster(int width,int height) {
	this.width = width;
	this.height = height;
	this.shader = DeferredClusterShader.getInstance();
	this.lightCullingShader = DeferredLightAABBCullingShader.getInstance();
	this.lightingShader = DeferredTestShader.getInstance();
	
	deferredSceneTexture = new Texture2D(width, height, 
			ImageFormat.RGBA16FLOAT, SamplerFilter.Nearest, TextureWrapMode.ClampToEdge);
	
	createSSBO();
	
}

private void createSSBO() {
	this.ssbo = glGenBuffers();
	glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo);
	

	glBufferData(GL_SHADER_STORAGE_BUFFER, clusterAlignedSize * numClusters, GL_STATIC_COPY);
	
	glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, ssbo);
}

public void cullLightsCompute() {
	shader.bind();
	shader.updateUniforms(width, height, gridSizeX, gridSizeY, gridSizeZ);
	glDispatchCompute(gridSizeX, gridSizeY, gridSizeZ);
	glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
}

public void updateLightSSBO(List<PointLight> pointLights) {
	ByteBuffer lightData = BufferUtils.createByteBuffer(lightAlignedSize * pointLights.size());
	FloatBuffer fv = lightData.asFloatBuffer();
	
	for(PointLight light: pointLights) {
		Vector3f p = light.getPosition();
		Vector3f c = light.getColor();
		float i = light.getIntensity();
		float r = light.getRadius();
		
		fv.put(p.x).put(p.y).put(p.z).put(1.0f)
		.put(c.x).put(c.y).put(c.z).put(1.0f)
		.put(i)
		.put(r)
		.put(0.0f).put(0.0f); // 4 + 4 bytes padding
	}
	
	fv.flip();
	
	if(isFirstPass) {
		this.lightSSBO = glGenBuffers();
		isFirstPass = false;
	}
	
	glBindBuffer(GL_SHADER_STORAGE_BUFFER, lightSSBO);
	glBufferData(GL_SHADER_STORAGE_BUFFER, lightData, GL_DYNAMIC_DRAW); // in LWJGL we can put bytes directly without specifying capacity
	glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, lightSSBO);
	
}

public void lightAABBIntersection() {
	lightCullingShader.bind();
	lightCullingShader.updateUniforms(GLContext.getMainCamera().getViewMatrix());
	glDispatchCompute(27,1,1); // for 12x12x24 work groups of cluster shader we have 3456 threads, same as for 27 work groups
	glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
}

public void render(Texture albedo, Texture position, Texture normal, Texture specularEmissionDiffuseSSAOBloom, Texture depth) {
	lightingShader.bind();
	glBindImageTexture(0, deferredSceneTexture.getId(), 0, false, 0, GL_WRITE_ONLY, GL_RGBA16F);
	glBindImageTexture(2, albedo.getId(), 0, false, 0, GL_READ_ONLY, GL_RGBA16F);
	glBindImageTexture(3, position.getId(), 0, false, 0, GL_READ_ONLY, GL_RGBA32F);
	glBindImageTexture(4, normal.getId(), 0, false, 0, GL_READ_ONLY, GL_RGBA16F);
	glBindImageTexture(5, specularEmissionDiffuseSSAOBloom.getId(), 0, false, 0, GL_READ_ONLY, GL_RGBA16F);
	
	lightingShader.updateUniforms(width, height, gridSizeX, gridSizeY, gridSizeZ);
	
	glDispatchCompute(width/2, height/2,1);
}

public Texture getDeferredSceneTexture() {
	return deferredSceneTexture;
}

`#version 430 core

layout (local_size_x = 2, local_size_y = 2) in;

layout (binding = 0, rgba16f) uniform writeonly image2D defferedSceneImage;

layout (binding = 2, rgba16f) uniform readonly image2DMS albedoSampler;
layout (binding = 3, rgba32f) uniform readonly image2DMS worldPositionSampler;
layout (binding = 4, rgba16f) uniform readonly image2DMS normalSampler;
layout (binding = 5, rgba16f) uniform readonly image2DMS specular_emission_diffuse_ssao_bloom_Sampler;

struct PointLight {
vec4 position;
vec4 color;
float intensity;
float radius;
};

struct Cluster {
vec4 minPoint;
vec4 maxPoint;
uint count;
uint lightIndices[100];
};

layout(std430, binding = 1) restrict buffer clusterSSBO
{
Cluster clusters[];
};

layout(std430, binding = 2) restrict buffer lightSSBO
{
PointLight pointLight[];
};

uniform float zNear;
uniform float zFar;
uniform uvec3 gridSize;
uniform uvec2 screenDimensions;

uniform mat4 viewMatrix;

vec3 diffuse(vec3 albedo, vec3 normal, vec3 toLightDirection, vec3 lightColor,
	float lightIntensity) {
float diffuseFactor = max(dot(normal, toLightDirection), 0.0);
return albedo * lightColor * diffuseFactor * lightIntensity;
}

vec3 specular(vec3 normal, vec3 position, vec3 toLightDir, vec3 lightColor,
	float reflectance, float emission, float lightIntensity) {
vec3 cameraDirection = normalize(-position);
vec3 fromLightDir = -toLightDir;
vec3 reflectedLight = normalize(reflect(fromLightDir, normal));
float specularFactor = max(dot(cameraDirection, reflectedLight), 0.0);
specularFactor = pow(specularFactor, emission);
return lightIntensity * specularFactor * reflectance * lightColor;
}

vec3 calculateLight(vec3 albedo, vec3 position, vec3 normal, PointLight light,
	float reflectance, float emission) {
vec3 lightDirection = light.position.xyz - position;
vec3 toLightDir = normalize(lightDirection);

vec3 diffuse = diffuse(albedo, normal, toLightDir, light.color.rgb,
		light.intensity);
vec3 specular = specular(normal, position, toLightDir, light.color.rgb,
		reflectance, emission, light.intensity);

// Attenuation
float distance = length(light.position.xyz - position);
float attenuation = 1.0 / (1.0 + (distance / light.radius));

diffuse *= attenuation;
specular *= attenuation;

return diffuse + specular;
}

void main(void) {
    // compute coord represents coordinates in screen space
ivec2 computeCoord = ivec2(gl_GlobalInvocationID.x,
		gl_GlobalInvocationID.y);

vec3 finalColor = vec3(0);
vec3 albedo = vec3(0);
vec3 position = vec3(0);
vec4 normal = vec4(0);
vec4 specular_emission_diffuse_ssao_bloom = vec4(0);
vec4 depth = vec4(0);

albedo = imageLoad(albedoSampler, computeCoord, 0).rgb;
normal = imageLoad(normalSampler, computeCoord, 0).rbga;

position = imageLoad(worldPositionSampler, computeCoord, 0).rgb;
specular_emission_diffuse_ssao_bloom = imageLoad(
		specular_emission_diffuse_ssao_bloom_Sampler, computeCoord, 0).rgba;
		
    // we get fragment position from sampled world pos multiplied by view matrix
uint zTile = uint(
		(log(abs(vec3(viewMatrix * vec4(position, 1.0)).z) / zNear)
				* gridSize.z) / log(zFar / zNear));
vec2 tileSize = screenDimensions / gridSize.xy;

uvec3 tile = uvec3(computeCoord.xy / tileSize, zTile);
uint tileIndex = tile.x + (tile.y * gridSize.x)
		+ (tile.z * gridSize.x * gridSize.y);

uint lightCount = clusters[tileIndex].count;

for (int i = 0; i < lightCount; ++i) {
	uint lightIndex = clusters[tileIndex].lightIndices[i];
	PointLight light = pointLight[lightIndex];

	// Lighting
	finalColor += calculateLight(albedo, position, normalize(normal.xyz),
			light, specular_emission_diffuse_ssao_bloom.r,
			specular_emission_diffuse_ssao_bloom.g);

}

imageStore(defferedSceneImage, computeCoord, vec4(finalColor, 1.0));
}`

	viewMatrix.identity();
	
	viewMatrix.rotate((float)Math.toRadians(pitch), new Vector3f(1,0,0));
	viewMatrix.rotate((float)Math.toRadians(yaw), new Vector3f(0,1,0));
	viewMatrix.rotate((float)Math.toRadians(roll), new Vector3f(0,0,1));
	
	Vector3f negativePos = new Vector3f(-position.x, -position.y, -position.z);
	viewMatrix.translate(negativePos);
	
	this.invViewMatirx.set(viewMatrix).invert();
	
	return viewMatrix;
}`