Java 图像不可见

我一直在尝试使用显示图像

这是一个稍加修改的版本，我尝试在其中显示图像：

import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL20.*;
import static org.lwjgl.opengl.GL30.*;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;

import javax.imageio.ImageIO;

import org.lwjgl.BufferUtils;
import org.lwjgl.LWJGLException;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.*;

public class DistortionCorrection {

    public enum Eye {
        Left, Right
    };

    protected int shader=0;
    protected int vertShader=0;
    protected int fragShader=0;

    protected int colorTextureID;
    protected int framebufferID;
    protected int depthRenderBufferID;

    private int LensCenterLocation;
    private int ScreenCenterLocation;
    private int ScaleLocation;
    private int ScaleInLocation;
    private int HmdWarpParamLocation;

    // renderDistortedEye
    public static float K0 = 1.0f;
    public static float K1 = 0.22f;
    public static float K2 = 0.24f;
    public static float K3 = 0.0f;

    // Added
    BufferedImage panda;
    private static final int BYTES_PER_PIXEL = 4;
    int pandaID;

    private final static String VERTEX_SHADER_SOURCE =
            "void main() {\n" +
                    "   gl_TexCoord[0] = gl_MultiTexCoord0;\n" +
                    "   gl_Position = gl_Vertex;\n" +
                    "}";

    private final static String FRAGMENT_SHADER_SOURCE =
            "uniform sampler2D tex;\n" +
                    "uniform vec2 LensCenter;\n" +
                    "uniform vec2 ScreenCenter;\n" +
                    "uniform vec2 Scale;\n" +
                    "uniform vec2 ScaleIn;\n" +
                    "uniform vec4 HmdWarpParam;\n" +
                    "\n" +
                    "vec2 HmdWarp(vec2 texIn)\n" +
                    "{\n" +
                    "   vec2 theta = (texIn - LensCenter) * ScaleIn;\n" +
                    "   float  rSq= theta.x * theta.x + theta.y * theta.y;\n" +
                    "   vec2 theta1 = theta * (HmdWarpParam.x + HmdWarpParam.y * rSq + " +
                    "           HmdWarpParam.z * rSq * rSq + HmdWarpParam.w * rSq * rSq * rSq);\n" +
                    "   return LensCenter + Scale * theta1;\n" +
                    "}\n" +
                    "\n" +
                    "\n" +
                    "\n" +
                    "void main()\n" +
                    "{\n" +
                    "   vec2 tc = HmdWarp(gl_TexCoord[0].xy);\n" +
                    "   if (any(notEqual(clamp(tc, ScreenCenter-vec2(0.25,0.5), ScreenCenter+vec2(0.25, 0.5)) - tc, vec2(0.0, 0.0))))\n" +
                    "       gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);\n" +
                    "   else\n" +
                    "       gl_FragColor = texture2D(tex, tc);\n" +
                    "}";

    public DistortionCorrection(int screenWidth, int screenHeight) {
        initShaders(VERTEX_SHADER_SOURCE, FRAGMENT_SHADER_SOURCE);
        initFBO(screenWidth, screenHeight);

        // Added
        glOrtho(0, Display.getWidth(), Display.getHeight(), 0, -1, 1);
        try {
            panda = ImageIO.read(new File("/Users/webstorms/Desktop/panda.jpg"));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        glEnable(GL_TEXTURE_2D);
        pandaID = loadTexture(panda);
        glBindTexture(GL_TEXTURE_2D, pandaID);
        // Added end

        Util.checkGLError();

        LensCenterLocation = glGetUniformLocation(shader, "LensCenter");
        ScreenCenterLocation = glGetUniformLocation(shader, "ScreenCenter");
        ScaleLocation = glGetUniformLocation(shader, "Scale");
        ScaleInLocation = glGetUniformLocation(shader, "ScaleIn");
        HmdWarpParamLocation = glGetUniformLocation(shader, "HmdWarpParam");
        System.out.println(FRAGMENT_SHADER_SOURCE);
        Util.checkGLError();
    }

    private void initFBO(int screenWidth, int screenHeight) {
        framebufferID = glGenFramebuffers();                                                                               
        colorTextureID = glGenTextures();                                                                                               
        depthRenderBufferID = glGenRenderbuffers();                                                                 

        glBindFramebuffer(GL_FRAMEBUFFER, framebufferID);                                               

        // initialize color texture
        glBindTexture(GL_TEXTURE_2D, colorTextureID);                                                                 
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);                               
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, screenWidth, screenHeight, 0,GL_RGBA, GL_INT, (java.nio.ByteBuffer) null);
        //glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
        //glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,GL_TEXTURE_2D, colorTextureID, 0);

        // initialize depth renderbuffer
        glBindRenderbuffer(GL_RENDERBUFFER, depthRenderBufferID);                               
        glRenderbufferStorage(GL_RENDERBUFFER, GL14.GL_DEPTH_COMPONENT24, screenWidth, screenHeight);
        glFramebufferRenderbuffer(GL_FRAMEBUFFER,GL_DEPTH_ATTACHMENT,GL_RENDERBUFFER, depthRenderBufferID);

        glBindFramebuffer(GL_FRAMEBUFFER, 0);                                                                   
    }

    public void beginOffScreenRenderPass() {

        glBindTexture(GL_TEXTURE_2D, 0);         
        Util.checkGLError();
        glBindFramebuffer(GL_FRAMEBUFFER, framebufferID);
        Util.checkGLError();
    }

    public void endOffScreenRenderPass() {

    }

    public void renderToScreen() {
        Util.checkGLError();
        glUseProgram(shader);
        Util.checkGLError();


        glEnable(GL_TEXTURE_2D);   
        glDisable(GL_DEPTH_TEST);
        glBindFramebuffer(GL_FRAMEBUFFER, 0);                                   

        glClearColor (1.0f, 0.0f, 0.0f, 0.5f);
        glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glBindTexture(GL_TEXTURE_2D, colorTextureID);   

        renderDistortedEye(Eye.Left, 0.0f, 0.0f, 0.5f, 1.0f);
        renderDistortedEye(Eye.Right, 0.5f, 0.0f, 0.5f, 1.0f);

        glUseProgram(0);
        glEnable(GL_DEPTH_TEST);

    }

    public void renderDistortedEye(Eye eye, float x, float y, float w, float h) {
        float as = w/h;

        float scaleFactor = 1.0f;
        Util.checkGLError();

        float DistortionXCenterOffset;
        if (eye == Eye.Left) {
            DistortionXCenterOffset = 0.25f;
        }
        else {
            DistortionXCenterOffset = -0.25f;
        }

        glUniform2f(LensCenterLocation, x + (w + DistortionXCenterOffset * 0.5f)*0.5f, y + h*0.5f);
        glUniform2f(ScreenCenterLocation, x + w*0.5f, y + h*0.5f);
        glUniform2f(ScaleLocation, (w/2.0f) * scaleFactor, (h/2.0f) * scaleFactor * as);;
        glUniform2f(ScaleInLocation, (2.0f/w), (2.0f/h) / as);

        glUniform4f(HmdWarpParamLocation, K0, K1, K2, K3);

        if (eye == Eye.Left) {
            glBegin(GL_TRIANGLE_STRIP);
            glTexCoord2f(0.0f, 0.0f);   glVertex2f(-1.0f, -1.0f);
            glTexCoord2f(0.5f, 0.0f);   glVertex2f(0.0f, -1.0f);
            glTexCoord2f(0.0f, 1.0f);   glVertex2f(-1.0f, 1.0f);
            glTexCoord2f(0.5f, 1.0f);   glVertex2f(0.0f, 1.0f);
            glEnd();
        }
        else {
            glBegin(GL_TRIANGLE_STRIP);
            glTexCoord2f(0.5f, 0.0f);   glVertex2f(0.0f, -1.0f);
            glTexCoord2f(1.0f, 0.0f);   glVertex2f(1.0f, -1.0f);
            glTexCoord2f(0.5f, 1.0f);   glVertex2f(0.0f, 1.0f);
            glTexCoord2f(1.0f, 1.0f);   glVertex2f(1.0f, 1.0f);
            glEnd();           
        }
    }

    protected void initShaders(String vertexShader, String fragmentShader) {
        shader=glCreateProgram();

        vertShader=createVertShader(vertexShader);
        fragShader=createFragShader(fragmentShader);

        glAttachShader(shader, vertShader);
        glAttachShader(shader, fragShader);

        glLinkProgram(shader);
        glValidateProgram(shader);
    }

    private int createVertShader(String vertexCode){
        vertShader=glCreateShader(GL_VERTEX_SHADER);

        if (vertShader==0) {
            return 0;
        }

        glShaderSource(vertShader, vertexCode);
        glCompileShader(vertShader);

        return vertShader;
    }

    private int createFragShader(String fragCode){

        fragShader = glCreateShader(GL_FRAGMENT_SHADER);
        if (fragShader==0) {
            return 0;
        }
        glShaderSource(fragShader, fragCode);
        glCompileShader(fragShader);

        return fragShader;
    }

    public static void main(String[] args) {

        try {
            DisplayMode displayMode = Display.getDesktopDisplayMode();
            Display.setDisplayMode(displayMode);
            Display.setTitle("Barrel Distorion Shader");
            Display.setFullscreen(true);
            PixelFormat pixelFormat = new PixelFormat(8, 8, 8);
            Display.create(pixelFormat);
        } catch (LWJGLException e) {
            e.printStackTrace();
        }

        DistortionCorrection shader = new DistortionCorrection(640, 400);

        while (!Display.isCloseRequested()) {
            if (Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {
                System.exit(0);
            }
            shader.beginOffScreenRenderPass();

            glDisable(GL_DEPTH_TEST);
            glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
            glClear(GL_COLOR_BUFFER_BIT);

            glMatrixMode(GL_PROJECTION);
            glLoadIdentity();
        //  glMatrixMode(GL_MODELVIEW);
            glLoadIdentity();

            // Content

            // Added
            //   glPushMatrix();
            //    glTranslatef(100, 100, 0);
            glBegin(GL_QUADS);
            {
                glTexCoord2f(0, 0);
                glVertex2f(0, 0);

                glTexCoord2f(1, 0);
                glVertex2f(Display.getWidth(), 0);

                glTexCoord2f(1, 1);
                glVertex2f(Display.getWidth(), Display.getHeight());

                glTexCoord2f(0, 1);
                glVertex2f(0, Display.getHeight());
            }
            glEnd();
           //  glPopMatrix();
             // Added end

            /*
            glBegin(GL_LINES);
            glColor3f(1.0f, 1.0f, 0.0f);
            for (int i=0; i<20; i++) {
                glVertex2f(-1.0f, -1.0f + 0.1f * i);
                glVertex2f(1.0f, -1.0f + 0.1f * i);
            }
            for (int i=0; i<20; i++) {
                glVertex2f(-1.0f + 0.1f * i, -1.0f);
                glVertex2f(-1.0f + 0.1f * i, 1.0f);
            }
            glEnd(); */

            shader.endOffScreenRenderPass();
            shader.renderToScreen();

            Display.sync(60);
            Display.update();
        }
    }
     public static int loadTexture(BufferedImage image){

          int[] pixels = new int[image.getWidth() * image.getHeight()];
            image.getRGB(0, 0, image.getWidth(), image.getHeight(), pixels, 0, image.getWidth());

            ByteBuffer buffer = BufferUtils.createByteBuffer(image.getWidth() * image.getHeight() * BYTES_PER_PIXEL); //4 for RGBA, 3 for RGB

            for(int y = 0; y < image.getHeight(); y++){
                for(int x = 0; x < image.getWidth(); x++){
                    int pixel = pixels[y * image.getWidth() + x];
                    buffer.put((byte) ((pixel >> 16) & 0xFF));     // Red component
                    buffer.put((byte) ((pixel >> 8) & 0xFF));      // Green component
                    buffer.put((byte) (pixel & 0xFF));               // Blue component
                    buffer.put((byte) ((pixel >> 24) & 0xFF));    // Alpha component. Only for RGBA
                }
            }

            buffer.flip(); //FOR THE LOVE OF GOD DO NOT FORGET THIS

            // You now have a ByteBuffer filled with the color data of each pixel.
            // Now just create a texture ID and bind it. Then you can load it using 
            // whatever OpenGL method you want, for example:

          int textureID = glGenTextures(); //Generate texture ID
            glBindTexture(GL_TEXTURE_2D, textureID); //Bind texture ID

            //Setup wrap mode
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE);

            //Setup texture scaling filtering
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

            //Send texel data to OpenGL
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, image.getWidth(), image.getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);

            //Return the texture ID so we can bind it later again
          return textureID;
       }

}

import static org.lwjgl.opengl.GL11.*；
导入静态org.lwjgl.opengl.GL20.*；
导入静态org.lwjgl.opengl.GL30.*；
导入java.awt.image.buffereImage；
导入java.io.File；
导入java.io.IOException；
导入java.nio.ByteBuffer；
导入javax.imageio.imageio；
导入org.lwjgl.BufferUtils；
导入org.lwjgl.LWJGLException；
导入org.lwjgl.input.Keyboard；
导入org.lwjgl.opengl.*；
公共类扭曲更正{
公众眼{
左，右
};
受保护的int着色器=0；
受保护的int-vertShader=0；
受保护的整数fragShader=0；
受保护的int-colorTextureID；
受保护的int-framebufferID；
受保护的int depthRenderBufferID；
私密的内景定位；
私人中心位置；
私人内部规模定位；
私有内部规模位置；
私人内部HMP位置；
//渲染失真眼
公共静态浮子K0=1.0f；
公共静态浮子K1=0.22f；
公共静态浮子K2=0.24f；
公共静态浮子K3=0.0f；
//增加
大熊猫；
私有静态最终整数字节每像素=4；
国际潘代德；
私有最终静态字符串顶点着色器源=
“void main（）{\n”+
“gl_TexCoord[0]=gl_MultiTexCoord0；\n”+
“gl\u位置=gl\u顶点；\n”+
"}";
私有最终静态字符串片段\u着色器\u源=
“均匀采样2D tex；\n”+
“统一vec2透镜探测器；\n”+
“统一vec2屏幕中心；\n”+
“统一vec2比例；\n”+
“统一vec2 ScaleIn；\n”+
“统一的vec4 HMP内存；\n”+
“\n”+
“vec2-HmdWarp（vec2-texIn）\n”+
“{\n”+
“vec2θ=（texIn-LensCenter）*标度；\n”+
“float rSq=theta.x*theta.x+theta.y*theta.y；\n”+
“vec2θ1=θ*（HmdWarpParam.x+HmdWarpParam.y*rSq+”+
“HmdWarpParam.z*rSq*rSq+HmdWarpParam.w*rSq*rSq*rSq）；\n”+
“返回LensCenter+比例*θ1；\n”+
“}\n”+
“\n”+
“\n”+
“\n”+
“void main（）\n”+
“{\n”+
“vec2 tc=HmdWarp（gl_TexCoord[0].xy）；\n”+
“如果（任何）（notEqual（夹具（tc，屏幕中心-vec2（0.25,0.5），屏幕中心+vec2（0.25,0.5））-tc，vec2（0.0,0.0）））\n”+
“gl_FragColor=vec4（0.0,0.0,0.0,1.0）；\n”+
“其他\n”+
gl_FragColor=texture2D（tex，tc）；\n+
"}";
公共扭曲更正（int屏幕宽度，int屏幕高度）{
初始化着色器（顶点着色器源、片段着色器源）；
initFBO（屏幕宽度、屏幕高度）；
//增加
glOrtho（0，Display.getWidth（），Display.getHeight（），0，-1，1）；
试一试{
panda=ImageIO.read（新文件（“/Users/webstors/Desktop/panda.jpg”）；
}捕获（IOE异常）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
glEnable（GL_纹理_2D）；
pandaID=加载纹理（熊猫）；
glBindTexture（GL_纹理_2D，pandaID）；
//附加端
Util.checklerror（）；
LensCenterLocation=glGetUniformLocation（着色器，“LensCenter”）；
ScreenCenterLocation=glGetUniformLocation（着色器，“ScreenCenter”）；
ScaleLocation=glGetUniformLocation（着色器，“缩放”）；
ScaleInLocation=glGetUniformLocation（着色器，“ScaleIn”）；
HmdWarpParamLocation=glGetUniformLocation（着色器，“HmdWarpParam”）；
System.out.println（片段着色器源）；
Util.checklerror（）；
}
私有void initFBO（整数屏幕宽度，整数屏幕高度）{
framebufferID=glGenFramebuffers（）；
colorTextureID=glGenTextures（）；
depthRenderBufferID=glGenRenderbuffers（）；
glBindFramebuffer（GL_FRAMEBUFFER，framebufferID）；
//初始化颜色纹理
glBindTexture（GL_TEXTURE_2D，colorTextureID）；
glTexParameterf（GL_纹理2D、GL_纹理最小过滤器、GL_线性）；
glTexImage2D（GL_TEXTURE_2D，0，GL_RGBA8，屏幕宽度，屏幕高度，0，GL_RGBA，GL_INT，（java.nio.ByteBuffer）null）；
//glTexParameterf（GL_纹理2D、GL_纹理包裹、GL_夹具）；
//glTexParameterf（GL_纹理、GL_纹理、GL_包裹、GL_夹紧）；
glFramebufferTexture2D（GL_帧缓冲区，GL_颜色_附件0，GL_纹理_2D，colorTextureID，0）；
//初始化深度渲染缓冲区
glBindRenderbuffer（GL_RENDERBUFFER，depthRenderBufferID）；
glRenderbufferStorage（GL_RENDERBUFFER，GL14.GL_DEPTH_component 24，屏幕宽度，屏幕高度）；
glFramebufferRenderbuffer（GL_帧缓冲区、GL_深度附件、GL_渲染缓冲区、深度渲染缓冲区ID）；
glBindFramebuffer（GL_帧缓冲区，0）；
}
public void beginOffScreenRenderPass（）{
glBindTexture（GL_TEXTURE_2D，0）；
Util.checklerror（）；
glBindFramebuffer（GL_FRAMEBUFFER，framebufferID）；
Util.checklerror（）；
}
public void endOffScreenRenderPass（）{
}
公共void renderToScreen（）{
//
// This polygon is wound Clockwise instead of Counter-Clockwise; when you start
//   using projection matrices and face culling this is a concept you will need
//     to understand. 
//
// Counter-Clockwise is the preferred winding order in OpenGL, by the way - I
//   just wanted to show this to you for future reference.
//
glBegin (GL_QUADS);
{
  glTexCoord2f ( 0.0f,  0.0f);
  glVertex2f   (-1.0f, -1.0f); // Bottom-left

  glTexCoord2f ( 0.0f,  1.0f);
  glVertex2f   (-1.0f,  1.0f); // Top-Left

  glTexCoord2f ( 1.0f,  1.0f);
  glVertex2f   ( 1.0f,  1.0f); // Top-Right

  glTexCoord2f ( 1.0f,  0.0f);
  glVertex2f   ( 1.0f, -1.0f); // Bottom-Right
}
glEnd ();