import com.jogamp.opengl.GL4; //导入依赖的package包/类
/**
 * Tests if this is a single-precision floating-point type (includes vectors and matrices).
 *
 * @return {@code true} if this is a single-precision floating-point type.
 */
public boolean isSinglePrecisionFloat() {
    switch (typeId) {
    case GL4.GL_FLOAT:        return true;
    case GL4.GL_FLOAT_VEC2:   return true;
    case GL4.GL_FLOAT_VEC3:   return true;
    case GL4.GL_FLOAT_VEC4:   return true;
    case GL4.GL_FLOAT_MAT2:   return true;
    case GL4.GL_FLOAT_MAT3:   return true;
    case GL4.GL_FLOAT_MAT4:   return true;
    case GL4.GL_FLOAT_MAT2x3: return true;
    case GL4.GL_FLOAT_MAT2x4: return true;
    case GL4.GL_FLOAT_MAT3x2: return true;
    case GL4.GL_FLOAT_MAT3x4: return true;
    case GL4.GL_FLOAT_MAT4x2: return true;
    case GL4.GL_FLOAT_MAT4x3: return true;

    default:                  return false;
    }
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
/**
 * Tests if this is a double-precision floating-point type (includes vectors and matrices).
 *
 * @return {@code true} if this is a double-precision floating-point type.
 */
public boolean isDoublePrecisionFloat() {
    switch (typeId) {
    case GL4.GL_DOUBLE:        return true;
    case GL4.GL_DOUBLE_VEC2:   return true;
    case GL4.GL_DOUBLE_VEC3:   return true;
    case GL4.GL_DOUBLE_VEC4:   return true;
    case GL4.GL_DOUBLE_MAT2:   return true;
    case GL4.GL_DOUBLE_MAT3:   return true;
    case GL4.GL_DOUBLE_MAT4:   return true;
    case GL4.GL_DOUBLE_MAT2x3: return true;
    case GL4.GL_DOUBLE_MAT2x4: return true;
    case GL4.GL_DOUBLE_MAT3x2: return true;
    case GL4.GL_DOUBLE_MAT3x4: return true;
    case GL4.GL_DOUBLE_MAT4x2: return true;
    case GL4.GL_DOUBLE_MAT4x3: return true;

    default:                   return false;
    }
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
/**
 * Tests if this is a floating-point sampler type.
 *
 * @return {@code true} if this is a floating-point sampler type.
 */
public boolean isFloatSampler() {
    switch (typeId) {
    case GL4.GL_SAMPLER_1D:                   return true;
    case GL4.GL_SAMPLER_2D:                   return true;
    case GL4.GL_SAMPLER_3D:                   return true;
    case GL4.GL_SAMPLER_CUBE:                 return true;
    case GL4.GL_SAMPLER_CUBE_SHADOW:          return true;
    case GL4.GL_SAMPLER_1D_SHADOW:            return true;
    case GL4.GL_SAMPLER_2D_SHADOW:            return true;
    case GL4.GL_SAMPLER_1D_ARRAY:             return true;
    case GL4.GL_SAMPLER_2D_ARRAY:             return true;
    case GL4.GL_SAMPLER_1D_ARRAY_SHADOW:      return true;
    case GL4.GL_SAMPLER_2D_ARRAY_SHADOW:      return true;
    case GL4.GL_SAMPLER_2D_MULTISAMPLE:       return true;
    case GL4.GL_SAMPLER_2D_MULTISAMPLE_ARRAY: return true;
    case GL4.GL_SAMPLER_BUFFER:               return true;
    case GL4.GL_SAMPLER_2D_RECT:              return true;
    case GL4.GL_SAMPLER_2D_RECT_SHADOW:       return true;

    default:                                  return false;
    }
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
/**
 * Tests if this is a signed integer sampler type.
 *
 * @return {@code true} if this is a signed integer sampler type.
 */
public boolean isSignedIntegerSampler() {
    switch (typeId) {
    case GL4.GL_INT_SAMPLER_1D:                   return true;
    case GL4.GL_INT_SAMPLER_2D:                   return true;
    case GL4.GL_INT_SAMPLER_3D:                   return true;
    case GL4.GL_INT_SAMPLER_CUBE:                 return true;
    case GL4.GL_INT_SAMPLER_1D_ARRAY:             return true;
    case GL4.GL_INT_SAMPLER_2D_ARRAY:             return true;
    case GL4.GL_INT_SAMPLER_2D_MULTISAMPLE:       return true;
    case GL4.GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: return true;
    case GL4.GL_INT_SAMPLER_BUFFER:               return true;
    case GL4.GL_INT_SAMPLER_2D_RECT:              return true;

    default:                                      return false;
    }
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
/**
 * Tests if this is a unsigned integer sampler type.
 *
 * @return {@code true} if this is a unsigned integer sampler type.
 */
public boolean isUnsignedIntegerSampler() {
    switch (typeId) {
    case GL4.GL_UNSIGNED_INT_SAMPLER_1D:                   return true;
    case GL4.GL_UNSIGNED_INT_SAMPLER_2D:                   return true;
    case GL4.GL_UNSIGNED_INT_SAMPLER_3D:                   return true;
    case GL4.GL_UNSIGNED_INT_SAMPLER_CUBE:                 return true;
    case GL4.GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:             return true;
    case GL4.GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:             return true;
    case GL4.GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:       return true;
    case GL4.GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY: return true;
    case GL4.GL_UNSIGNED_INT_SAMPLER_BUFFER:               return true;
    case GL4.GL_UNSIGNED_INT_SAMPLER_2D_RECT:              return true;

    default:                                               return false;
    }
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
/**
 * Tests if this is a (single-precision) floating-point image type.
 *
 * @return {@code true} if this is a (single-precision) floating-point image type.
 */
public boolean isFloatImage() {
    switch (typeId) {
    case GL4.GL_IMAGE_1D:                   return true;
    case GL4.GL_IMAGE_2D:                   return true;
    case GL4.GL_IMAGE_3D:                   return true;
    case GL4.GL_IMAGE_2D_RECT:              return true;
    case GL4.GL_IMAGE_CUBE:                 return true;
    case GL4.GL_IMAGE_BUFFER:               return true;
    case GL4.GL_IMAGE_1D_ARRAY:             return true;
    case GL4.GL_IMAGE_2D_ARRAY:             return true;
    case GL4.GL_IMAGE_2D_MULTISAMPLE:       return true;
    case GL4.GL_IMAGE_2D_MULTISAMPLE_ARRAY: return true;

    default:                                return false;
    }
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
/**
 * Tests if this is a signed integer image type.
 *
 * @return {@code true} if this is a signed integer image type.
 */
public boolean isSignedIntegerImage() {
    switch (typeId) {
    case GL4.GL_INT_IMAGE_1D:                   return true;
    case GL4.GL_INT_IMAGE_2D:                   return true;
    case GL4.GL_INT_IMAGE_3D:                   return true;
    case GL4.GL_INT_IMAGE_2D_RECT:              return true;
    case GL4.GL_INT_IMAGE_CUBE:                 return true;
    case GL4.GL_INT_IMAGE_BUFFER:               return true;
    case GL4.GL_INT_IMAGE_1D_ARRAY:             return true;
    case GL4.GL_INT_IMAGE_2D_ARRAY:             return true;
    case GL4.GL_INT_IMAGE_2D_MULTISAMPLE:       return true;
    case GL4.GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY: return true;

    default: return false;
    }
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
/**
 * Tests if this is a unsigned integer image type.
 *
 * @return {@code true} if this is a unsigned integer image type.
 */
public boolean isUnsignedIntegerImage() {
    switch (typeId) {
    case GL4.GL_UNSIGNED_INT_IMAGE_1D:                   return true;
    case GL4.GL_UNSIGNED_INT_IMAGE_2D:                   return true;
    case GL4.GL_UNSIGNED_INT_IMAGE_3D:                   return true;
    case GL4.GL_UNSIGNED_INT_IMAGE_2D_RECT:              return true;
    case GL4.GL_UNSIGNED_INT_IMAGE_CUBE:                 return true;
    case GL4.GL_UNSIGNED_INT_IMAGE_BUFFER:               return true;
    case GL4.GL_UNSIGNED_INT_IMAGE_1D_ARRAY:             return true;
    case GL4.GL_UNSIGNED_INT_IMAGE_2D_ARRAY:             return true;
    case GL4.GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE:       return true;
    case GL4.GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY: return true;

    default:                                             return false;
    }
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
public void render(GL4 gl4, Application app) {

        gl4.glDisable(GL_DEPTH_TEST);
        gl4.glViewport(0, 0, app.windowSize.x, app.windowSize.y);

        gl4.glBindVertexArray(vertexArrayName.get(0));
        gl4.glUseProgram(program.name);

        for (int eye = 0; eye < VR.EVREye.Max; eye++) {

            gl4.glBindTexture(GL_TEXTURE_2D, app.eyeDesc[eye].textureName.get(FramebufferDesc.Target.RESOLVE));
            gl4.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
            gl4.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
            gl4.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            gl4.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
            // left lens (first half of index array ), right lens (second half of index array )
            gl4.glDrawElements(GL_TRIANGLES, indexSize / 2, GL_UNSIGNED_SHORT,
                    eye == VR.EVREye.EYE_Left ? 0 : indexSize); // indexSize / 2 * Short.Bytes = indexSize
        }
        gl4.glBindVertexArray(0);
        gl4.glUseProgram(0);
    }
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
private void initVertexArray(GL4 gl4) {

        // create and bind a VAO to hold state for this model
        gl4.glGenVertexArrays(1, vertexArrayName);
        gl4.glBindVertexArray(vertexArrayName.get(0));

        gl4.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.VERTEX));

        // Identify the components in the vertex buffer
        gl4.glEnableVertexAttribArray(Semantic.Attr.POSITION);
        gl4.glVertexAttribPointer(Semantic.Attr.POSITION, 3, GL_FLOAT, false, RenderModel_Vertex_t.SIZE,
                RenderModel_Vertex_t.OFFSET_POSITION);
        gl4.glEnableVertexAttribArray(Semantic.Attr.NORMAL);
        gl4.glVertexAttribPointer(Semantic.Attr.NORMAL, 3, GL_FLOAT, false, RenderModel_Vertex_t.SIZE,
                RenderModel_Vertex_t.OFFSET_NORMAL);
        gl4.glEnableVertexAttribArray(Semantic.Attr.TEXT_COORD);
        gl4.glVertexAttribPointer(Semantic.Attr.TEXT_COORD, 2, GL_FLOAT, false, RenderModel_Vertex_t.SIZE,
                RenderModel_Vertex_t.OFFSET_TEXT_COORD);

        gl4.glBindBuffer(GL_ARRAY_BUFFER, 0);

        gl4.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferName.get(Buffer.ELEMENT));

        gl4.glBindVertexArray(0);
    }
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
private void initVertexArray(GL4 gl4) {

        gl4.glGenVertexArrays(1, vertexArrayName);
        gl4.glBindVertexArray(vertexArrayName.get(0));

        gl4.glBindBuffer(GL_ARRAY_BUFFER, vertexBufferName.get(0));

        int stride = 2 * 3 * Float.BYTES;
        int offset = 0;

        gl4.glEnableVertexAttribArray(Semantic.Attr.POSITION);
        gl4.glVertexAttribPointer(Semantic.Attr.POSITION, 3, GL_FLOAT, false, stride, offset);

        offset += Vec3.SIZE;
        gl4.glEnableVertexAttribArray(Semantic.Attr.COLOR);
        gl4.glVertexAttribPointer(Semantic.Attr.COLOR, 3, GL_FLOAT, false, stride, offset);

        gl4.glBindBuffer(GL_ARRAY_BUFFER, 0);
        gl4.glBindVertexArray(0);
    }
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
private boolean setupStereoRenderTargets(GL4 gl4) {
    if (hmd == null) {
        return false;
    }
    IntBuffer width = GLBuffers.newDirectIntBuffer(1), height = GLBuffers.newDirectIntBuffer(1);

    hmd.GetRecommendedRenderTargetSize.apply(width, height);
    renderSize.set(width.get(0), height.get(0));

    IntStreamEx.range(VR.EVREye.Max).forEach(eye -> eyeDesc[eye] = new FramebufferDesc(gl4, renderSize));

    BufferUtils.destroyDirectBuffer(width);
    BufferUtils.destroyDirectBuffer(height);

    return true;
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
@Override
public void dispose(GLAutoDrawable drawable) {

    if (hmd != null) {
        VR.VR_Shutdown();
        hmd = null;
    }

    GL4 gl4 = drawable.getGL().getGL4();

    modelsRender.dispose(gl4);
    scene.dispose(gl4);
    axisLineControllers.dispose(gl4);
    distortion.dispose(gl4);

    IntStreamEx.range(VR.EVREye.Max).forEach(eye -> eyeDesc[eye].dispose(gl4));

    BufferUtils.destroyDirectBuffer(clearColor);
    BufferUtils.destroyDirectBuffer(clearDepth);
    BufferUtils.destroyDirectBuffer(errorBuffer);
    BufferUtils.destroyDirectBuffer(matBuffer);

    System.exit(0);
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
void processVREvent(GL4 gl4, VREvent_t event) {

        switch (event.eventType) {

            case VR.EVREventType.VREvent_TrackedDeviceActivated:
                //TODO | ask giuseppe for gl
                modelsRender.setupRenderModelForTrackedDevice(gl4, event.trackedDeviceIndex, hmd);
                System.out.println("Device %u attached. Setting up render model.\n" + event.trackedDeviceIndex);
                break;

            case VR.EVREventType.VREvent_TrackedDeviceDeactivated:
                System.out.println("Device %u detached.\n" + event.trackedDeviceIndex);
                break;

            case VR.EVREventType.VREvent_TrackedDeviceUpdated:
                System.out.println("Device %u updated.\n" + event.trackedDeviceIndex);
                break;
        }
    }
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
/**
 * Create/destroy GL Render Models.
 *
 * @param gl4
 * @param hmd
 */
public void setupRenderModels(GL4 gl4, IVRSystem hmd) {

    IntStreamEx.range(trackedDeviceToRenderModel.length).forEach(i -> trackedDeviceToRenderModel[i] = null);

    if (hmd == null) {
        return;
    }

    for (int trackedDevice = VR.k_unTrackedDeviceIndex_Hmd + 1; trackedDevice < VR.k_unMaxTrackedDeviceCount;
            trackedDevice++) {

        if (hmd.IsTrackedDeviceConnected.apply(trackedDevice) == 0) {
            continue;
        }
        setupRenderModelForTrackedDevice(gl4, trackedDevice, hmd);
    }
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
/**
 * Create/destroy GL a Render Model for a single tracked device.
 *
 * @param gl4
 * @param trackedDeviceIndex
 * @param hmd
 */
public void setupRenderModelForTrackedDevice(GL4 gl4, int trackedDeviceIndex, IVRSystem hmd) {

    if (trackedDeviceIndex >= VR.k_unMaxTrackedDeviceCount) {
        return;
    }
    // try to find a model we've already set up
    String renderModelName = getTrackedDeviceString(hmd, trackedDeviceIndex,
            VR.ETrackedDeviceProperty.Prop_RenderModelName_String);

    Model model = findOrLoad(gl4, renderModelName);

    if (model == null) {
        String trackingSystemName = getTrackedDeviceString(hmd, trackedDeviceIndex,
                VR.ETrackedDeviceProperty.Prop_TrackingSystemName_String);
        System.err.println("Unable to load render model for tracked device " + trackedDeviceIndex + "("
                + trackingSystemName + "." + renderModelName + ")");
    } else {
        trackedDeviceToRenderModel[trackedDeviceIndex] = model;
        showTrackedDevice[trackedDeviceIndex] = true;
    }
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
private boolean initVertexArray(GL4 gl4) {

        gl4.glGenVertexArrays(1, vertexArrayName);
        gl4.glBindVertexArray(vertexArrayName.get(0));
        {
            gl4.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.VERTEX));
            gl4.glVertexAttribPointer(Semantic.Attr.POSITION, 2, GL_FLOAT, false, 0, 0);
            gl4.glEnableVertexAttribArray(Semantic.Attr.POSITION);

            gl4.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.INSTANCE));
            gl4.glVertexAttribIPointer(Semantic.Attr.DRAW_ID, 1, GL_INT, 0, 0);
            gl4.glVertexAttribDivisor(Semantic.Attr.DRAW_ID, 1);
            gl4.glEnableVertexAttribArray(Semantic.Attr.DRAW_ID);

            gl4.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferName.get(Buffer.ELEMENT));
        }
        gl4.glBindVertexArray(0);

        return true;
    }
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
private void renderFBO(GL4 gl4, int framebuffer) {

        gl4.glEnable(GL_DEPTH_TEST);

        gl4.glBindProgramPipeline(pipelineName.get(Program.THROUGH));
        gl4.glBindBufferRange(GL_UNIFORM_BUFFER, Semantic.Uniform.TRANSFORM0, bufferName.get(Buffer.TRANSFORM), 0,
                uniformBlockSize);

        gl4.glViewport(0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y);

        gl4.glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
        float[] depth = {1.0f};
        gl4.glClearBufferfv(GL_DEPTH, 0, depth, 0);
        gl4.glClearBufferfv(GL_COLOR, 0, new float[]{1.0f, 0.5f, 0.0f, 1.0f}, 0);

        textureName.position(Texture.DIFFUSE);
        gl4.glBindTextures(0, 1, textureName);
        textureName.rewind();
        gl4.glBindVertexArray(vertexArrayName.get(0));

        gl4.glDrawArraysInstanced(GL_TRIANGLES, 0, vertexCount, 5);

        gl4.glDisable(GL_DEPTH_TEST);
    }
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
@Override
protected boolean end(GL gl) {

    GL4 gl4 = (GL4) gl;

    gl4.glDeleteVertexArrays(VertexArray.MAX, vertexArrayName);
    gl4.glDeleteBuffers(Buffer.MAX, bufferName);
    gl4.glDeleteProgram(transformProgramName);
    gl4.glDeleteProgram(feedbackProgramName);
    gl4.glDeleteTransformFeedbacks(1, feedbackName);

    BufferUtils.destroyDirectBuffer(vertexArrayName);
    BufferUtils.destroyDirectBuffer(bufferName);
    BufferUtils.destroyDirectBuffer(feedbackName);

    return checkError(gl4, "end");
}
 

import com.jogamp.opengl.GL4; //导入依赖的package包/类
private boolean initVertexArray(GL4 gl4) {

        boolean validated = true;

        gl4.glGenVertexArrays(1, vertexArrayName);
        gl4.glBindVertexArray(vertexArrayName.get(0));
        {
            gl4.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.POSITION));
            gl4.glVertexAttribPointer(Semantic.Attr.POSITION, 2, GL_FLOAT, false, 0, 0);
            gl4.glVertexAttribDivisor(Semantic.Attr.POSITION, 0);
            gl4.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.COLOR));
            gl4.glVertexAttribPointer(Semantic.Attr.COLOR, 4, GL_FLOAT, false, 0, 0);
            gl4.glVertexAttribDivisor(Semantic.Attr.COLOR, 1);

            gl4.glEnableVertexAttribArray(Semantic.Attr.POSITION);
            gl4.glEnableVertexAttribArray(Semantic.Attr.COLOR);
        }
        gl4.glBindVertexArray(0);

        return validated;
    }