OpenGL persistently mapped SSBO example (not working)

import org.lwjgl.glfw.Callbacks.glfwFreeCallbacks
import org.lwjgl.glfw.GLFW._
import org.lwjgl.glfw.GLFWErrorCallback
import org.lwjgl.opengl.GL
import org.lwjgl.opengl.GL11._
import org.lwjgl.opengl.GL20._
import org.lwjgl.opengl.GL30._
import org.lwjgl.opengl.GL32._
import org.lwjgl.opengl.GL43._
import org.lwjgl.opengl.GL44._
import org.lwjgl.opengl.GL45._
import org.lwjgl.system.MemoryUtil.{NULL, memUTF8}

object StandaloneExample extends App {
  GLFWErrorCallback.createPrint(System.err).set()

  if (!glfwInit())
    throw new IllegalStateException("Unable to initialize GLFW")

  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4)
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5)
  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE)
  glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE)
  glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE)
  glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE)

  val window = glfwCreateWindow(800, 800, "Test", NULL, NULL)
  if (window == NULL)
    throw new RuntimeException("Failed to create the GLFW window")

  glfwSetKeyCallback(window, (window, key, _, action, _) => {
    if ( key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE )
      glfwSetWindowShouldClose(window, true)
  })

  glfwMakeContextCurrent(window)
  glfwSwapInterval(1)
  glfwShowWindow(window)

  GL.createCapabilities()

  glDebugMessageCallback(printDebugMessage, 0l)

  glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, Array.empty[Int], true)

  {
    val w = Array.ofDim[Int](1)
    val h = Array.ofDim[Int](1)
    glfwGetFramebufferSize(window, w, h)
    glViewport(0, 0, w(0), h(0))
  }

  glClearColor(0.5f, 0.0f, 0.5f, 1.0f)

  val progId = {
    val shaderSrc = """#version 450 core
                      |layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
                      |layout (std430, binding = 0) buffer particles {
                      |    float Particle[];
                      |};
                      |
                      |void main() {
                      |    for (int i = 0; i < 24; ++i) {
                      |        Particle[i] = i + 1;
                      |    }
                      |}""".stripMargin

    val pId = glCreateProgram
    val shaderId = glCreateShader(GL_COMPUTE_SHADER)
    glShaderSource(shaderId, shaderSrc)
    glCompileShader(shaderId)

    if(glGetShaderi(shaderId, GL_COMPILE_STATUS) == GL_FALSE) {
      println("Shader compilation failed.")
      println(glGetShaderInfoLog(shaderId))
      sys.exit(1)
    }

    glAttachShader(pId, shaderId)

    def checkProgStatus(pId: Int, statusType: Int, desc: String) {
      if(glGetProgrami(pId, statusType) == GL_FALSE) {
        println(s"$desc error:\n${glGetProgramInfoLog(pId)}")
        sys.exit(1)
      }
    }

    glLinkProgram(pId)
    checkProgStatus(pId, GL_LINK_STATUS, "Program link")

    glValidateProgram(pId)
    checkProgStatus(pId, GL_VALIDATE_STATUS, "Program validation")

    glDetachShader(pId, shaderId)
    glDeleteShader(shaderId)

    pId
  }

  val bufferFlags = GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT
  val bufferSize = 24 * 4
  val bufferId = glCreateBuffers()

  glNamedBufferStorage(bufferId, bufferSize, bufferFlags)

  val mappedBuffer = glMapNamedBufferRange(bufferId, 0, bufferSize, bufferFlags)

  mappedBuffer.rewind()
  val mappedFloatBuffer = mappedBuffer.asFloatBuffer()

  mappedFloatBuffer.rewind()

  val ssboIndex = glGetProgramResourceIndex(progId, GL_SHADER_STORAGE_BLOCK, "particles")

  val props = Array(GL_BUFFER_BINDING)
  val params = Array(-1)
  glGetProgramResourceiv(progId, GL_SHADER_STORAGE_BLOCK, ssboIndex, props, null, params)

  glBindBufferBase(GL_SHADER_STORAGE_BUFFER, params(0), bufferId)

  glUseProgram(progId)

  val sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0)
  glDispatchCompute(1, 1, 1)

  glClientWaitSync(sync, 0, 1000000000) match {
    case GL_TIMEOUT_EXPIRED =>
      println("Timeout expired")

    case GL_WAIT_FAILED =>
      println("Wait failed. " + glGetError())

    case _ =>
      println("Result:")

      while(mappedFloatBuffer.hasRemaining) {
        println(mappedFloatBuffer.get())
      }
  }

  println("Done.")

  glfwFreeCallbacks(window)
  glfwDestroyWindow(window)

  glfwTerminate()
  glfwSetErrorCallback(null).free()



  def printDebugMessage(src: Int, typ: Int, id: Int, severity: Int, length: Int, msg: Long, uparam: Long) {
    val srcs = src match {
      case GL_DEBUG_SOURCE_API => "API"
      case GL_DEBUG_SOURCE_APPLICATION => "APP"
      case GL_DEBUG_SOURCE_OTHER => "Other"
      case GL_DEBUG_SOURCE_SHADER_COMPILER => "Shader compiler"
      case GL_DEBUG_SOURCE_THIRD_PARTY => "3rd party"
      case GL_DEBUG_SOURCE_WINDOW_SYSTEM => "Window sys"
      case i => i.toString
    }

    val typs = typ match {
      case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR => "Deprecated"
      case GL_DEBUG_TYPE_ERROR => "Error"
      case GL_DEBUG_TYPE_MARKER => "Marker"
      case GL_DEBUG_TYPE_OTHER => "Other"
      case GL_DEBUG_TYPE_PERFORMANCE => "Performance"
      case GL_DEBUG_TYPE_POP_GROUP => "Pop group"
      case GL_DEBUG_TYPE_PORTABILITY => "Portability"
      case GL_DEBUG_TYPE_PUSH_GROUP => "Push group"
      case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR => "Undefined behaviour"
      case i => i.toString
    }

    val severities = severity match {
      case GL_DEBUG_SEVERITY_NOTIFICATION => "Notification"
      case GL_DEBUG_SEVERITY_LOW => "Low"
      case GL_DEBUG_SEVERITY_MEDIUM => "Medium"
      case GL_DEBUG_SEVERITY_HIGH => "High"
      case i => i.toString
    }

    println(s"[$severities][$typs][$srcs][$id]: ${memUTF8(msg)}")
  }
}