How to Read Data from a Compute Shader using a UBO?

[mattbick2003]

I am trying to read a ton of floats from a compute shader into a buffer. I simply have no idea how to do this, and I have searched and tried to follow things such as tutorials and other forums. Sadly, I just don't understand how to read my data from my Compute Shader into a FloatBuffer.

Compute Shader:

#version 430

uniform vec3 startPos;
uniform int xSize;
uniform int ySize;
uniform int zSize;


layout(std430, binding = 1) buffer Vals 
{
	float vals[];

};


uniform Vals {
	uniform float vals[];
};

layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;

vec3 random3(vec3 c) {
	float j = 4096.0*sin(dot(c,vec3(17.0, 59.4, 15.0)));
	vec3 r;
	r.z = fract(512.0*j);
	j *= .125;
	r.x = fract(512.0*j);
	j *= .125;
	r.y = fract(512.0*j);
	return r-0.5;
}

/* skew constants for 3d simplex functions */
const float F3 =  0.3333333;
const float G3 =  0.1666667;

/* 3d simplex noise */
float simplex3d(vec3 p) {
	 /* 1. find current tetrahedron T and it's four vertices */
	 /* s, s+i1, s+i2, s+1.0 - absolute skewed (integer) coordinates of T vertices */
	 /* x, x1, x2, x3 - unskewed coordinates of p relative to each of T vertices*/
	 
	 /* calculate s and x */
	 vec3 s = floor(p + dot(p, vec3(F3)));
	 vec3 x = p - s + dot(s, vec3(G3));
	 
	 /* calculate i1 and i2 */
	 vec3 e = step(vec3(0.0), x - x.yzx);
	 vec3 i1 = e*(1.0 - e.zxy);
	 vec3 i2 = 1.0 - e.zxy*(1.0 - e);
	 	
	 /* x1, x2, x3 */
	 vec3 x1 = x - i1 + G3;
	 vec3 x2 = x - i2 + 2.0*G3;
	 vec3 x3 = x - 1.0 + 3.0*G3;
	 
	 /* 2. find four surflets and store them in d */
	 vec4 w, d;
	 
	 /* calculate surflet weights */
	 w.x = dot(x, x);
	 w.y = dot(x1, x1);
	 w.z = dot(x2, x2);
	 w.w = dot(x3, x3);
	 
	 /* w fades from 0.6 at the center of the surflet to 0.0 at the margin */
	 w = max(0.6 - w, 0.0);
	 
	 /* calculate surflet components */
	 d.x = dot(random3(s), x);
	 d.y = dot(random3(s + i1), x1);
	 d.z = dot(random3(s + i2), x2);
	 d.w = dot(random3(s + 1.0), x3);
	 
	 /* multiply d by w^4 */
	 w *= w;
	 w *= w;
	 d *= w;
	 
	 /* 3. return the sum of the four surflets */
	 return dot(d, vec4(52.0));
}


void main() {
	
	vals[gl_GlobalInvocationID.x + gl_GlobalInvocationID.y * xSize + gl_GlobalInvocationID.z * xSize * ySize] = simplex3d(gl_GlobalInvocationID);


}

The Java Code:

package shaders;

import java.nio.ByteBuffer;
import java.nio.FloatBuffer;

import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.GL15;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.GL30;
import org.lwjgl.opengl.GL31;
import org.lwjgl.opengl.GL33;
import org.lwjgl.opengl.GL42;
import org.lwjgl.opengl.GL43;





import math.Vector3f;

public class SimplexNoiseComputeShader extends ComputeShaderProgram {

	private static final String shaderFile = "src/shaders/SimplexNoiseComputeShader.txt";
	
	private int location_startPos;
	private int location_xSize;
	private int location_ySize;
	private int location_zSize;

	
	private boolean isDone = false;
	
	public FloatBuffer vals;
	
	private int xSize;
	private int ySize;
	private int zSize;

	
	private int totalSize;
	
	private int ubo;
	
	public SimplexNoiseComputeShader(Vector3f startPos, int xSize, int ySize, int zSize) {
		super(shaderFile);
		
		this.xSize = xSize;
		this.ySize = ySize;
		this.zSize = zSize;

		totalSize = xSize * ySize * zSize;
		
		
		// TODO Auto-generated constructor stub
		//Load the start position for our compute shader
		location_startPos = super.getUniformLocation("startPos");
		
		location_xSize = super.getUniformLocation("xSize");
		location_ySize = super.getUniformLocation("ySize");
		location_zSize = super.getUniformLocation("zSize");

		
		super.loadVector3f(location_startPos, startPos);
		super.loadInt(location_xSize, xSize);
		super.loadInt(location_ySize, ySize);
		super.loadInt(location_zSize, zSize);

		
		
		
		//start the compute shader!
		start();
		run();
		
		
		
		//ByteBuffer bb = GL30.glMapBufferRange(ssbo, 0, totalSize, GL15.GL_READ_ONLY);
		//vals = bb.asFloatBuffer();
		
		
		//clean up the compute shader
		CleanUp();
		isDone = true;

		
	}
	
	private void run() {
		GL43.glDispatchCompute(xSize, ySize, zSize);
	}

	
	
	
	
}