Java 如何在JOGL中编辑顶点着色器

因此，我正在开发一个Java/Jogl应用程序，它基本上只是转换三角形的顶点。到目前为止，我能够使三角形从左向右移动，但我不知道如何编辑顶点着色器，以便在单击按钮时，三角形开始上下移动，而不是左右移动

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.nio.*;
import javax.swing.*;
import static com.jogamp.opengl.GL4.*;

import com.jogamp.common.nio.Buffers;
import com.jogamp.opengl.*;
import com.jogamp.opengl.awt.GLCanvas;
import com.jogamp.opengl.util.FPSAnimator;
import graphicslib3D.GLSLUtils;

import java.io.File;
import java.io.IOException;
import java.util.Scanner;
import java.util.Vector;

public class a1 extends JFrame implements GLEventListener
{   
    private GLCanvas myCanvas;
    private int rendering_program;
    private int vao[] = new int[1];
    private GLSLUtils util = new GLSLUtils();
    private Button button1, button2;

    private float x = 0.0f;
    private float y = 0.0f;
    private float inc = 0.01f;
    private float incy = 0.01f;
    private int click = 1;

public a1()
{   setTitle("Chapter2 - program2");
    setSize(600, 400);
    myCanvas = new GLCanvas();
    myCanvas.addGLEventListener(this);
    getContentPane().setLayout(new BorderLayout());
    getContentPane().add(myCanvas, BorderLayout.CENTER);

    JPanel sidePanel = new JPanel();
    sidePanel.setLayout(new BoxLayout(sidePanel, BoxLayout.Y_AXIS));
    button1 = new Button("button");
    button2 = new Button("button2");
    sidePanel.add(button1);
    sidePanel.add(button2);
    getContentPane().add(sidePanel, BorderLayout.WEST);

    button2.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            click = 1;

        }
    });

    setVisible(true);
    FPSAnimator animator = new FPSAnimator(myCanvas, 30);
    animator.start();
}

public void display(GLAutoDrawable drawable)
{   GL4 gl = (GL4) GLContext.getCurrentGL();
    gl.glUseProgram(rendering_program);
    gl.glPointSize(50.0f);

    float bkg[] = {0.0f, 0.0f, 0.0f, 1.0f};
    FloatBuffer bkgBuffer = Buffers.newDirectFloatBuffer(bkg);
    gl.glClearBufferfv(GL_COLOR, 0, bkgBuffer);

    x+=inc;
    y+=incy;
    if(x > 1.0f) inc = -0.01f;
    if(x < -1.0f) inc = 0.01f;

    if(y > 1.0f) incy = -0.01f;
    if(y< -1.0f) incy = 0.01f;


    int offset_loc = gl.glGetUniformLocation(rendering_program, "inc");
    int offset_y = gl.glGetUniformLocation(rendering_program, "incy");
    int flag = gl.glGetUniformLocation(rendering_program, "flag");

    gl.glProgramUniform1f(rendering_program, offset_loc, x);
    gl.glProgramUniform1f(rendering_program, offset_y, y);
    gl.glProgramUniform1f(rendering_program, flag, click);
    gl.glDrawArrays(GL_TRIANGLES,0,3);
}


public void init(GLAutoDrawable drawable)
{   GL4 gl = (GL4) GLContext.getCurrentGL();
    rendering_program = createShaderProgram();
    gl.glGenVertexArrays(vao.length, vao, 0);
    gl.glBindVertexArray(vao[0]);
}

private int createShaderProgram()
{
    GL4 gl = (GL4) GLContext.getCurrentGL();
    int[] vertCompiled = new int[1];
    int[] fragCompiled = new int[1];
    int[] linked = new int[1];

    String vshaderSource[] = readShaderSource("src/vert.shader");
    String fshaderSource[] = readShaderSource("src/frag.shader");

    int vShader = gl.glCreateShader(GL_VERTEX_SHADER);
    gl.glShaderSource(vShader, vshaderSource.length, vshaderSource, null, 0);
    gl.glCompileShader(vShader);

    util.checkOpenGLError();
    gl.glGetShaderiv(vShader, GL_COMPILE_STATUS, vertCompiled, 0);
    if(vertCompiled[0] == 1)
    {
        System.out.println("vertex compilation success");
    }else{
        System.out.println("vertex compilation failed");
        util.printShaderLog(vShader);
    }
    int fShader = gl.glCreateShader(GL_FRAGMENT_SHADER);
    gl.glShaderSource(fShader, fshaderSource.length, fshaderSource, null, 0);
    gl.glCompileShader(fShader);

    util.checkOpenGLError();
    gl.glGetShaderiv(fShader, GL_COMPILE_STATUS, fragCompiled, 0);
    if(fragCompiled[0] == 1)
    {
        System.out.println("fragment compilation success");
    }else{
        System.out.println("fragment compilation failed");
        util.printShaderLog(fShader);
    }

    int vfprogram = gl.glCreateProgram();
    gl.glAttachShader(vfprogram, vShader);
    gl.glAttachShader(vfprogram, fShader);
    gl.glLinkProgram(vfprogram);

    util.checkOpenGLError();
    gl.glGetProgramiv(vfprogram, GL_LINK_STATUS, linked, 0);
    if(linked[0] == 1)
    {
        System.out.println("linking succeeded");
    }else{
        System.out.println("linking failed");
        util.printProgramLog(vfprogram);
    }
    //gl.glDeleteShader(vShader);
    //gl.glDeleteShader(fShader);
    return vfprogram;
}

public static void main(String[] args) { new a1(); }
public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {}
public void dispose(GLAutoDrawable drawable) {}

private String[] readShaderSource(String filename)
{
    Vector<String> lines = new Vector<String>();
    Scanner sc;
    try
    {
        sc = new Scanner(new File(filename));
    }catch (IOException e)
    {
        System.err.println("IOException reading file: " + e);
        return null;
    }
    while(sc.hasNext())
    {
        lines.addElement(sc.nextLine());
    }
    String[] program = new String[lines.size()];
    for(int i=0; i<lines.size(); i++)
    {
        program[i] = (String) lines.elementAt(i)+ "\n";
    }
    return program;
}
}

#version 430
uniform float inc;
void main(void)
{

  if(gl_VertexID == 0) gl_Position = vec4(0.25, -0.25+inc, 0.0, 1.0);
  else if(gl_VertexID == 1) gl_Position = vec4(-0.25, -0.25+inc, 0.0, 1.0);
  else gl_Position = vec4(0.25, 0.25+inc, 0.0, 1.0);

}

import java.awt.*；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.nio.*；
导入javax.swing.*；
导入静态com.jogamp.opengl.GL4.*；
导入com.jogamp.common.nio.Buffers；
导入com.jogamp.opengl。*；
导入com.jogamp.opengl.awt.GLCanvas；
导入com.jogamp.opengl.util.FPSAnimator；
导入graphicslib3D.GLSLUtils；
导入java.io.File；
导入java.io.IOException；
导入java.util.Scanner；
导入java.util.Vector；
公共类a1扩展了JFrame实现了GLEventListener
{   
私人画布；
私有int-u程序；
私有整数vao[]=新整数[1]；
私有GLSLUtils util=新GLSLUtils（）；
私人按钮按钮1，按钮2；
私人浮动x=0.0f；
私人浮动y=0.0f；
私人浮动公司=0.01f；
专用浮点数incy=0.01f；
私有int click=1；
公众a1（）
{setTitle（“第2章-程序2”）；
设置大小（600400）；
myCanvas=newglcanvas（）；
myCanvas.addGLEventListener（这个）；
getContentPane（）.setLayout（新的BorderLayout（））；
getContentPane（）.add（myCanvas，BorderLayout.CENTER）；
JPanel侧面板=新的JPanel（）；
侧面板.setLayout（新的BoxLayout（侧面板，BoxLayout.Y_轴））；
button1=新按钮（“按钮”）；
按钮2=新按钮（“按钮2”）；
侧面板。添加（按钮1）；
侧面板。添加（按钮2）；
getContentPane（）.add（侧面板，BorderLayout.WEST）；
button2.addActionListener（新建ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
单击=1；
}
});
setVisible（真）；
FPSAnimator animator=新的FPSAnimator（myCanvas，30）；
animator.start（）；
}
公共空白显示（GLAutoDrawable）
{GL4 gl=（GL4）GLContext.getCurrentGL（）；
gl.glUseProgram（渲染程序）；
gl.glPointSize（50.0f）；
浮动bkg[]={0.0f，0.0f，0.0f，1.0f}；
FloatBuffer bkgBuffer=Buffers.newDirectFloatBuffer（bkg）；
gl.glClearBufferfv（gl_颜色，0，bkgBuffer）；
x+=公司；
y+=incy；
如果（x>1.0f）inc=-0.01f；
如果（x<-1.0f）inc=0.01f；
如果（y>1.0f）incy=-0.01f；
如果（y<-1.0f）incy=0.01f；
int offset_loc=gl.glGetUniformLocation（渲染程序，“inc”）；
int offset_y=gl.glGetUniformLocation（渲染程序，“incy”）；
int flag=gl.glGetUniformLocation（渲染程序，“标志”）；
gl.glProgramUniform1f（渲染程序，偏移量，x）；
gl.glProgramUniform1f（渲染程序，偏移量y，y）；
gl.glprogrammuniform1f（渲染程序、标志、单击）；
gl.gldrawArray（gl_三角形，0,3）；
}
公共void init（GLAutoDrawable）
{GL4 gl=（GL4）GLContext.getCurrentGL（）；
rendering_program=createShaderProgram（）；
gl.glgenvertexarray（vao.length，vao，0）；
gl.glBindVertexArray（vao[0]）；
}
private int createShaderProgram（）
{
GL4 gl=（GL4）GLContext.getCurrentGL（）；
int[]=新的int[1]；
int[]fragCompiled=新int[1]；
int[]链接=新的int[1]；
字符串vshaderSource[]=readShaderSource（“src/vert.shader”）；
字符串fshaderSource[]=readShaderSource（“src/frag.shader”）；
int vShader=gl.glCreateShader（gl_顶点_着色器）；
gl.glShaderSource（vShader，vshaderSource.length，vshaderSource，null，0）；
gl.glCompileShader（vShader）；
util.checkOpenGLError（）；
glGetShaderiv（vShader，gl_COMPILE_STATUS，vertcomiled，0）；
如果（0）==1）
{
System.out.println（“顶点编译成功”）；
}否则{
System.out.println（“顶点编译失败”）；
util.printShaderLog（vShader）；
}
int fShader=gl.glCreateShader（gl_片段_着色器）；
gl.glShaderSource（fShader，fshaderSource.length，fshaderSource，null，0）；
gl.glCompileShader（fShader）；
util.checkOpenGLError（）；
glGetShaderiv（fShader，gl_COMPILE_STATUS，fragCompiled，0）；
if（fragCompiled[0]==1）
{
System.out.println（“片段编译成功”）；
}否则{
System.out.println（“片段编译失败”）；
util.printShaderLog（fShader）；
}
int vfprogram=gl.glCreateProgram（）；
glAttachShader（vfprogram，vShader）；
glAttachShader（vfprogram，fShader）；
gl.glLinkProgram（vfprogram）；
util.checkOpenGLError（）；
gl.glGetProgramiv（vfprogram，gl_LINK_STATUS，linked，0）；
如果（链接[0]==1）
{
System.out.println（“链接成功”）；
}否则{
System.out.println（“链接失败”）；
util.printProgramLog（vfprogram）；
}
//gl.glDeleteShader（vShader）；
//gl.glDeleteShader（fShader）；
返回VFP程序；
}
公共静态void main（字符串[]args）{new a1（）；}
公共空间重塑（GLAutoDrawable drawable、int x、int y、int WITH、int height）{}
public void dispose（glautodravable dravable）{}
私有字符串[]readShaderSource（字符串文件名）
{
向量线=新向量（）；
扫描仪sc；
尝试
{
sc=新扫描仪（新文件（文件名））；
}捕获（IOE异常）
{
System.err.println（“IOException读取文件：”+e）；
返回null；
}
while（sc.hasNext（））
{
lines.addElement（sc.nextLine（））；
}
String[]program=新字符串[lines.size（）]；
对于（inti=0；i1），不要这样做更新

2） 不要对OpenGL资源（vao）使用
int
数组，更喜欢直接整数缓冲区，例如，可以对vao使用
GLBuffers.newDirectIntBuffer（1）；

3） 不要使用
FPSAnimator
，而是使用
Animator

4） 不要每次在
display（）
方法（
bkgBuffer
）中初始化新的直接缓冲区，只在变量声明中初始化一次，或者
button2.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        update = 1;
    }
});

public void display(GLAutoDrawable drawable) {   

    GL4 gl = (GL4) GLContext.getCurrentGL();

    if(update) {
        update = false;
        ...
    }
}

    gl3.glBindBuffer(GL_ARRAY_BUFFER, bufferName.get(Buffer.VERTEX));
    gl3.glBufferSubData(GL_ARRAY_BUFFER, 0, vertexBuffer.capacity(), vertexBuffer);
    gl3.glBindBuffer(GL_ARRAY_BUFFER, 0);

#version 430    
layout (location = POSITION) in vec2 position;
void main(void)
{    
    gl_Position = vec4(position, 0, 1);
}

gl3.glBindBuffer(GL_UNIFORM_BUFFER, bufferName.get(Buffer.TRANSFORM));
gl3.glBufferSubData(GL_UNIFORM_BUFFER, 0, Mat4.SIZE, matBuffer);
gl3.glBindBuffer(GL_UNIFORM_BUFFER, 0);

#version 430    
layout (location = POSITION) in vec2 position;

layout (binding = TRANSFORM) uniform Transform
{
    mat4 mat;
};

void main(void)
{    
    gl_Position = mat * vec4(position, 0, 1);
}