JAVA LWJGL配置OpenGL显示图片

最新推荐文章于 2023-12-27 21:13:02 发布
最新推荐文章于 2023-12-27 21:13:02 发布
阅读量1.1k 收藏
点赞数
分类专栏： java opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010302327/article/details/109851359
版权

继续搞Java的OpenGL

需要导入的jar包

将官方Demo里的LWJGLCanvas进行简单的修改

LWJGLCanvas.java

import org.lwjgl.PointerBuffer;
import org.lwjgl.opengl.GL;
import org.lwjgl.opengl.GLCapabilities;
import org.lwjgl.system.MemoryStack;
import org.lwjgl.system.Platform;
import org.lwjgl.system.jawt.JAWT;
import org.lwjgl.system.jawt.*;
import org.lwjgl.system.linux.XVisualInfo;

import java.awt.*;
import java.awt.event.*;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

import static org.lwjgl.glfw.GLFW.*;
import static org.lwjgl.glfw.GLFWNativeWin32.glfwAttachWin32Window;
import static org.lwjgl.opengl.GLX13.*;
import static org.lwjgl.system.MemoryStack.stackPush;
import static org.lwjgl.system.MemoryUtil.NULL;
import static org.lwjgl.system.jawt.JAWTFunctions.*;

public class LWJGLCanvas extends Canvas {

    private final JAWT awt;

    private JAWTDrawingSurface ds;

    private final List<Renderer> renderers = new ArrayList<>();

    private long context;

    private GLCapabilities caps;

    public LWJGLCanvas() {
        awt = JAWT.calloc();
        awt.version(JAWT_VERSION_1_4);
        if (!JAWT_GetAWT(awt)) {
            throw new IllegalStateException("GetAWT failed");
        }

        // AWT event listeners are invoked in the EDT

        addComponentListener(new ComponentAdapter() {
            @Override public void componentResized(ComponentEvent e) {
                System.out.println(e);
                if (context != NULL) {
                    paint();
                }
            }
            @Override public void componentMoved(ComponentEvent e) {
                System.out.println(e);
            }
            @Override public void componentShown(ComponentEvent e) {
                System.out.println(e);
            }
            @Override public void componentHidden(ComponentEvent e) {
                System.out.println(e);
            }
        });
//        addFocusListener(new FocusListener() {
//            @Override public void focusGained(FocusEvent e) {
//                System.out.println(e);
//            }
//            @Override public void focusLost(FocusEvent e) {
//                System.out.println(e);
//            }
//        });
//        addKeyListener(new KeyAdapter() {
//            @Override public void keyPressed(KeyEvent e) {
//                System.out.println(e);
//            }
//            @Override public void keyTyped(KeyEvent e) {
//                System.out.println(e);
//            }
//            @Override public void keyReleased(KeyEvent e) {
//                System.out.println(e);
//            }
//        });
//        addMouseListener(new MouseAdapter() {
//            @Override public void mouseClicked(MouseEvent e) {
//                System.out.println(e);
//            }
//            @Override public void mousePressed(MouseEvent e) {
//                System.out.println(e);
//            }
//            @Override public void mouseReleased(MouseEvent e) {
//                System.out.println(e);
//            }
//            @Override public void mouseEntered(MouseEvent e) {
//                System.out.println(e);
//            }
//            @Override public void mouseExited(MouseEvent e) {
//                System.out.println(e);
//            }
//            @Override public void mouseWheelMoved(MouseWheelEvent e) {
//                System.out.println(e);
//            }
//            @Override public void mouseDragged(MouseEvent e) {
//                System.out.println(e);
//            }
//            @Override public void mouseMoved(MouseEvent e) {
//                System.out.println(e);
//            }
//        });
//        addMouseMotionListener(new MouseMotionListener() {
//            @Override public void mouseDragged(MouseEvent e) {
//                System.out.println(e);
//            }
//            @Override public void mouseMoved(MouseEvent e) {
//                System.out.println(e);
//            }
//        });
//        addMouseWheelListener(System.out::println);
    }

    @Override
    public void update(Graphics g) {
        paint(g);
    }

    @Override
    public void paint(Graphics g) {
        paint();
        repaint();
    }

    public void addRenderer(Renderer renderer){
        if(renderer == null){
            return;
        }
        renderers.add(renderer);
    }
    public void removeRenderer(Renderer renderer){
        if(renderer == null){
            return;
        }
        renderers.remove(renderer);
    }

    private void paint() {
        if (ds == null) {
            // Get the drawing surface
            ds = JAWT_GetDrawingSurface(this, awt.GetDrawingSurface());
            if (ds == null) {
                throw new IllegalStateException("awt->GetDrawingSurface() failed");
            }
        }

        // Lock the drawing surface
        int lock = JAWT_DrawingSurface_Lock(ds, ds.Lock());
        if ((lock & JAWT_LOCK_ERROR) != 0) {
            throw new IllegalStateException("ds->Lock() failed");
        }

        try {
            // Get the drawing surface info
            JAWTDrawingSurfaceInfo dsi = JAWT_DrawingSurface_GetDrawingSurfaceInfo(ds, ds.GetDrawingSurfaceInfo());
            if (dsi == null) {
                throw new IllegalStateException("ds->GetDrawingSurfaceInfo() failed");
            }

            try {
                switch (Platform.get()) {
                    case LINUX:
                        // Get the platform-specific drawing info
                        JAWTX11DrawingSurfaceInfo dsi_x11 = JAWTX11DrawingSurfaceInfo.create(dsi.platformInfo());

                        long drawable = dsi_x11.drawable();
                        if (drawable == NULL) {
                            break;
                        }

                        if (context == NULL) {
                            createContextGLX(dsi_x11);
                            for (Renderer r: renderers) {
                                r.onCreated();
                            }
                        } else {
                            if (!glXMakeCurrent(dsi_x11.display(), drawable, context)) {
                                throw new IllegalStateException("glXMakeCurrent() failed");
                            }
                            GL.setCapabilities(caps);
                        }

                        render(getWidth(), getHeight());
                        glXSwapBuffers(dsi_x11.display(), drawable);

                        glXMakeCurrent(dsi_x11.display(), NULL, NULL);
                        GL.setCapabilities(null);
                        break;
                    case WINDOWS:
                        // Get the platform-specific drawing info
                        JAWTWin32DrawingSurfaceInfo dsi_win = JAWTWin32DrawingSurfaceInfo.create(dsi.platformInfo());

                        long hdc = dsi_win.hdc();
                        if (hdc == NULL) {
                            break;
                        }

                        // The render method is invoked in the EDT
                        if (context == NULL) {
                            createContextGLFW(dsi_win);
                            for (Renderer r: renderers) {
                                r.onCreated();
                            }
                        } else {
                            glfwMakeContextCurrent(context);
                            GL.setCapabilities(caps);
                        }

                        try (MemoryStack stack = stackPush()) {
                            IntBuffer pw = stack.mallocInt(1);
                            IntBuffer ph = stack.mallocInt(1);

                            glfwGetFramebufferSize(context, pw, ph);

                            render(pw.get(0), ph.get(0));
                        }
                        glfwSwapBuffers(context);

                        glfwMakeContextCurrent(NULL);
                        GL.setCapabilities(null);
                        break;
                }
            } finally {
                // Free the drawing surface info
                JAWT_DrawingSurface_FreeDrawingSurfaceInfo(dsi, ds.FreeDrawingSurfaceInfo());
            }
        } finally {
            // Unlock the drawing surface
            JAWT_DrawingSurface_Unlock(ds, ds.Unlock());
        }
    }
    private int viewWidth = -1;
    private int viewHeight = -1;
    private void render(int width, int height) {
        if(viewWidth != width || viewHeight != height){
            viewWidth = width;
            viewHeight = height;
            for (Renderer r: renderers) {
                r.onChanged(width,height);
            }
        }
        for (Renderer r: renderers) {
            r.onDrawFrame();
        }
    }

    private void createContextGLFW(JAWTWin32DrawingSurfaceInfo dsi_win) {
        // glfwWindowHint can be used here to configure the GL context
        context = glfwAttachWin32Window(dsi_win.hwnd(), NULL);
        if (context == NULL) {
            throw new IllegalStateException("Failed to attach win32 window.");
        }

        // Any callbacks registered here will work. But care must be taken because
        // the callbacks are NOT invoked in the EDT, but in an AWT thread that
        // does the event polling. Many GLFW functions that require main thread
        // invocation, should only be called in that thread.

        // Because of how input focus is implemented in AWT, it is recommended that AWT
        // KeyListeners are always used for keyboard input.

        glfwMakeContextCurrent(context);
        caps = GL.createCapabilities();
    }

    // Simplest possible context creation.
    private void createContextGLX(JAWTX11DrawingSurfaceInfo dsi_x11) {
        long display  = dsi_x11.display();
        long drawable = dsi_x11.drawable();

        PointerBuffer configs = Objects.requireNonNull(glXChooseFBConfig(display, 0, (IntBuffer)null));

        long config = NULL;
        for (int i = 0; i < configs.remaining(); i++) {
            XVisualInfo vi = Objects.requireNonNull(glXGetVisualFromFBConfig(display, configs.get(i)));
            if (vi.visualid() == dsi_x11.visualID()) {
                config = configs.get(i);
                break;
            }
        }

        context = glXCreateNewContext(display, config, GLX_RGBA_TYPE, NULL, true);
        if (context == NULL) {
            throw new IllegalStateException("glXCreateContext() failed");
        }

        if (!glXMakeCurrent(display, drawable, context)) {
            throw new IllegalStateException("glXMakeCurrent() failed");
        }

        caps = GL.createCapabilities();
    }

    public void destroy() {
        // Free the drawing surface
        JAWT_FreeDrawingSurface(ds, awt.FreeDrawingSurface());

        awt.free();

        if (context != NULL) {
            glfwDestroyWindow(context);
        }
    }

    public interface Renderer {
        void onCreated();
        void onChanged(int width, int height);
        void onDrawFrame();
    }
}

主要加入了Renderer，用于渲染用，模仿Android的GLSurfaceView的Renderer
创建Shader加载类ShaderUtils.java

import org.lwjgl.opengl.GL;
import org.lwjgl.opengl.GLCapabilities;
import org.lwjgl.system.MemoryStack;

import java.nio.ByteBuffer;

import static org.lwjgl.opengl.GL30C.*;
import static org.lwjgl.system.MemoryStack.stackPush;

public class ShaderUtils {
    public static int createProgram(ByteBuffer vs, ByteBuffer fs) {
        GLCapabilities caps = GL.getCapabilities();
        if (!caps.OpenGL20) {
            throw new IllegalStateException("This demo requires OpenGL 2.0 or higher.");
        }
        int version;
        if (caps.OpenGL33) {
            version = 330;
        } else if (caps.OpenGL21) {
            version = 120;
        } else {
            version = 110;
        }
        
        int v = glCreateShader(GL_VERTEX_SHADER);
        int f = glCreateShader(GL_FRAGMENT_SHADER);



        compileShader(version, v, vs);
        compileShader(version, f, fs);

        int p = glCreateProgram();
        glAttachShader(p, v);
        glAttachShader(p, f);
        glLinkProgram(p);
        printProgramInfoLog(p);

        if (glGetProgrami(p, GL_LINK_STATUS) != GL_TRUE) {
            throw new IllegalStateException("Failed to link program.");
        }

        glUseProgram(p);
        return p;
    }


    private static void compileShader(int version, int shader, ByteBuffer code) {
        try (MemoryStack stack = stackPush()) {
            ByteBuffer header = stack.ASCII("#version " + version + "\n#line 0\n", false);

            glShaderSource(
                    shader,
                    stack.pointers(header, code),
                    stack.ints(header.remaining(), code.remaining())
            );

            glCompileShader(shader);
            printShaderInfoLog(shader);

            if (glGetShaderi(shader, GL_COMPILE_STATUS) != GL_TRUE) {
                throw new IllegalStateException("Failed to compile shader.");
            }
        }
    }
    private static void printShaderInfoLog(int obj) {
        int infologLength = glGetShaderi(obj, GL_INFO_LOG_LENGTH);
        if (infologLength > 0) {
            glGetShaderInfoLog(obj);
            System.out.format("%s\n", glGetShaderInfoLog(obj));
        }
    }
    private static void printProgramInfoLog(int obj) {
        int infologLength = glGetProgrami(obj, GL_INFO_LOG_LENGTH);
        if (infologLength > 0) {
            glGetProgramInfoLog(obj);
            System.out.format("%s\n", glGetProgramInfoLog(obj));
        }
    }
}

创建渲染类GLRenderer.java

import org.lwjgl.BufferUtils;

import java.awt.image.BufferedImage;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

import static com.hyq.hm.test.gl.IOUtil.ioResourceToByteBuffer;
import static org.lwjgl.opengl.GL30C.*;
public class GLRenderer implements LWJGLCanvas.Renderer {
    private final int[] textures = new int[1];

    private final int[] bos = new int[2];

    private int programId = -1;
    private int aPositionHandle;
    private int aTextureCoordHandle;
    private int uTextureSamplerHandle;


    private int imageWidth,imageHeight;
    private ByteBuffer imageBuffer;
    public void setImage(BufferedImage image){
        imageWidth = image.getWidth();
        imageHeight = image.getHeight();
        imageBuffer = imageToBuffer(image);
    }


    @Override
    public void onCreated() {
        try {
            ByteBuffer vs = ioResourceToByteBuffer("X:\\test\\image.vert", 4096);
            ByteBuffer fs = ioResourceToByteBuffer("X:\\test\\image.frag", 4096);
            programId = ShaderUtils.createProgram(vs, fs);
        } catch (IOException e) {
            e.printStackTrace();
        }
        if(programId == -1){
            return;
        }
        aPositionHandle = glGetAttribLocation(programId, "aPosition");
        aTextureCoordHandle = glGetAttribLocation(programId, "aTexCoord");
        uTextureSamplerHandle = glGetUniformLocation(programId, "sTexture");


        final float[] vertexData = {
                1f, -1f, 0f,
                -1f, -1f, 0f,
                1f, 1f, 0f,
                -1f, 1f, 0f
        };


        final float[] textureVertexData = {
                1f, 0f,
                0f, 0f,
                1f, 1f,
                0f, 1f
        };
        FloatBuffer vertexBuffer = ByteBuffer.allocateDirect(vertexData.length * 4)
                .order(ByteOrder.nativeOrder())
                .asFloatBuffer()
                .put(vertexData);
        vertexBuffer.position(0);

        FloatBuffer textureVertexBuffer = ByteBuffer.allocateDirect(textureVertexData.length * 4)
                .order(ByteOrder.nativeOrder())
                .asFloatBuffer()
                .put(textureVertexData);
        textureVertexBuffer.position(0);

        glGenBuffers(bos);
        glBindBuffer(GL_ARRAY_BUFFER, bos[0]);
        glBufferData(GL_ARRAY_BUFFER, vertexBuffer, GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, bos[1]);
        glBufferData(GL_ARRAY_BUFFER,  textureVertexBuffer, GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, 0);


        glGenTextures(textures);
        glBindTexture(GL_TEXTURE_2D, textures[0]);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight,0, GL_RGBA, GL_UNSIGNED_BYTE, imageBuffer);
        glBindTexture(GL_TEXTURE_2D, 0);
    }
    @Override
    public void onChanged(int width, int height) {
        if(programId == -1){
            return;
        }
        viewportSize(width,height,imageWidth,imageHeight);
    }

    @Override
    public void onDrawFrame() {
        if(programId == -1){
            return;
        }
        glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
        glClearColor(1.0f,1.0f,1.0f,1.0f);

        glUseProgram(programId);

        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, textures[0]);
        glUniform1i(uTextureSamplerHandle, 0);

        glBindBuffer(GL_ARRAY_BUFFER, bos[0]);
        glEnableVertexAttribArray(aPositionHandle);
        glVertexAttribPointer(aPositionHandle, 3, GL_FLOAT, false,
                0, 0);
        glBindBuffer(GL_ARRAY_BUFFER, bos[1]);
        glEnableVertexAttribArray(aTextureCoordHandle);
        glVertexAttribPointer(aTextureCoordHandle, 2, GL_FLOAT, false, 0, 0);


        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindTexture(GL_TEXTURE_2D, 0);
        glUseProgram(0);
    }
    private void viewportSize(int screenWidth,int screenHeight,int width,int height) {
        int left, top, viewWidth, viewHeight;
        float sh = screenWidth * 1.0f / screenHeight;
        float vh = width * 1.0f / height;
        if (sh < vh) {
            left = 0;
            viewWidth = screenWidth;
            viewHeight = (int) (height * 1.0f / width * viewWidth);
            top = (screenHeight - viewHeight) / 2;
        } else {
            top = 0;
            viewHeight = screenHeight;
            viewWidth = (int) (width * 1.0f / height * viewHeight);
            left = (screenWidth - viewWidth) / 2;
        }
        glViewport(left, top, viewWidth, viewHeight);
    }

    public static ByteBuffer imageToBuffer(BufferedImage image) {
        int width = image.getWidth();
        int height = image.getHeight();
        int[] pixels = new int[width * height];
        image.getRGB(0, 0, width, height, pixels, 0, width);
        ByteBuffer buffer = BufferUtils.createByteBuffer(width * height * 4);
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                int pixel = pixels[y * width + x];
                buffer.put((byte) ((pixel >> 16) & 0xFF));
                buffer.put((byte) ((pixel >> 8) & 0xFF));
                buffer.put((byte) (pixel & 0xFF));
                buffer.put((byte) ((pixel >> 24) & 0xFF));
            }
        }
        buffer.flip();
        return buffer;
    }
}

代码和我上一篇的差不多，区别在Shader的加载是文件转成ByteBuffer，而不是直接使用String

加载Shader需要用到官方Demo里的IOUtil.java，直接复制过来就好了

image.frag

uniform sampler2D sTexture;

#if __VERSION__ < 130
    varying vec2 vTexCoord;

    #define out_Color gl_FragColor
#else
    in vec2 vTexCoord;

    #if __VERSION__ < 330
        out vec4 out_Color;
    #else
        layout(location = 0) out vec4 out_Color;
    #endif
#endif

void main() {
    out_Color = texture(sTexture ,  vec2(vTexCoord.x , 1.0 - vTexCoord.y));
}

image.vert

#if __VERSION__ < 130
    attribute vec4 aPosition;
    attribute vec2 aTexCoord;
    varying vec2 vTexCoord;
#else
    #if __VERSION__ < 330
        in vec4 aPosition;
        in vec2 aTexCoord;
    #else
        layout(location = 0) in vec4 aPosition;
        layout(location = 1) in vec2 aTexCoord;
    #endif
                 
    out vec2 vTexCoord;
#endif
                 
void main() {
    vTexCoord = aTexCoord;
    gl_Position = aPosition;
}

最后是Main函数

public static void main(String[] args) {
	// write your code here
        if (Platform.get() == Platform.MACOSX) {
            throw new UnsupportedOperationException("This demo cannot run on macOS.");
        }

        GLFWErrorCallback.createPrint().set();
        if (!glfwInit()) {
            throw new IllegalStateException("Unable to initialize glfw");
        }
        LWJGLCanvas canvas = new LWJGLCanvas();
        canvas.setSize(640, 480);

        BufferedImage image = null;
        try {
            image = ImageIO.read(new File("X:\\test\\ic_car.jpg"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        if(image != null){
            GLRenderer renderer = new GLRenderer();
            renderer.setImage(image);
            canvas.addRenderer(renderer);
        }
        JFrame frame = new JFrame("JAWT Demo");

        frame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosed(WindowEvent e) {
                canvas.destroy();
                frame.dispose();
                glfwTerminate();
                Objects.requireNonNull(glfwSetErrorCallback(null)).free();
            }
        });

        KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(e -> {
            if (e.getKeyCode() == KeyEvent.VK_ESCAPE && e.getID() == KeyEvent.KEY_PRESSED) {
                canvas.destroy();
                frame.dispose();
                glfwTerminate();
                Objects.requireNonNull(glfwSetErrorCallback(null)).free();
                return true;
            }

            return false;
        });

        frame.setLayout(new BorderLayout());
        frame.add(canvas, BorderLayout.CENTER);
        frame.add(new JTextField(), BorderLayout.SOUTH);
        frame.pack();
        frame.setVisible(true);
    }

效果

 

红色与青色
关注
专栏目录
Java与游戏开发：Lwjgl与OpenGL的高级图形编程奇幻旅程
java专栏
08-06 779
Lwjgl就像是一位灵巧的向导，帮助Java在原生库的森林中穿梭无阻。OpenGL则是一位强大的画家，在游戏的画布上绘制出绚丽多彩的图形。首先，确保你安装了Java Development Kit (JDK) 和一个合适的IDE，如IntelliJ IDEA或Eclipse。
lwjgl java_LWJGL - 轻量级的Java游戏库
weixin_31108095的博客
03-02 607
LWJGL - Lightweight Java Game Library 3LWJGL (https://www.lwjgl.org) is a Java library that enables cross-platform access to popular native APIs useful in the development of graphics (OpenGL/V...
debug:调试LWJGL3 OpenGL应用程序
05-07
什么 Java代理，用于调试LWJGL3程序以防止JVM崩溃并解决OpenGL错误。 为什么 由于用户程序中的某些错误可能导致JVM崩溃而没有有意义的错误消息，因此LWJGL 3已针对极端速度进行了调整，但以健壮性为代价。 如何 从下载lwjglx-debug-1.0.0.jar文件，或按照下面“构建”部分中的说明构建此Maven项目。 将lwjglx-debug-1.0.0.jar到任何目录（此后称为<cwd> ） 使用-javaagent:<cwd>/lwjglx-debug-1.0.0.jar启动LWJGL3应用程序 使用命令行时，它应类似于： java -javaagent:<cwd>/lwjglx-debug-1.0.0.jar -cp all/the/jars your.main.Class 使用Eclipse时，用main()方法右键单击您的类，转到“运行方式>运行配置
java opengl 图片文字_如何通过opengl显示相机预览
weixin_35655990的博客
03-04 123
有两种方法可以使用opengl来显示这个像素数据在JAVA中使用Opengl在c或c中使用opengl(JNI)实际上，无论哪种方式，如果你知道什么是opengl管道就会很容易我总是因为可重用性而使用opengl和c，只需按照以下三个步骤操作即可使用android API的预览缓冲区制作纹理图像(像素是指向相机帧缓冲区的指针)glTexImage2D(GL_TEXTURE_2D, 0, GL_RG...
使用JavaCV提供的支持， 使用OpenGL实时处理+显示摄像头采集的图像， 并使用FFMPEG实时录制音视频_Java
07-12
安卓下实现的 实时相机滤镜显示 + 拍照 + 处理结果视频音频录制 demo (需要 javacv, 已配置好) 更多详情、使用方法，请下载后阅读README.md文件
如何简单使用Java开发OpenGL
weixin_44598449的博客
03-09 7859
首先，OpenGL最好还是推荐使用C++开发，效率比较高，而且若是想要在编程方面长远的走下去，C是必须要了解的，借助这个机会学一下C并没有什么坏处，不过，可能有些同学，对编程不感兴趣，没有时间学，或实在不想用C写，在此介绍一下一个用Java开发OpenGL的好工具，同时也是为喜欢Java绘图的推荐一个好工具。 processing是一个基于Java发展的专门为绘图存在的编程语言，主要用户是画家，艺术家，美工等人。 [官方网站](https://processing.org/) [下载页](https.
lwjgl3：LWJGL是一个Java库，可跨平台访问流行的本机API，这些API在开发图形（OpenGL，Vulkan），音频（OpenAL），并行计算（OpenCL，CUDA）和XR（OpenVR，LibOVR）应用程序中有用
02-03
LWJGL（ ）是一个Java库，可以跨平台访问流行的本机API，这些API在图形（OpenGL / Vulkan），音频（OpenAL）和并行计算（OpenCL）应用程序的开发中很有用。 这种访问是直接的，高性能的，而且还包装在适用于Java...
lwjgl配置文件
10-08
在"lwjgl配置文件"中，我们主要关注的是如何在Eclipse这样的集成开发环境中（IDE）正确配置和使用这些资源。首先，你需要下载LWJGL的库文件，其中包括必要的jar包。这些jar包通常包含了LWJGL的核心API，如opengl、...
java lwjgl 2d 游戏引擎.zip
09-08
Java语言在游戏开发领域也有广泛的应用，特别是对于2D游戏来说，Lightweight Java Game Library（LWJGL）是一个非常受欢迎的开源库。这个压缩包"java lwjgl 2d 游戏引擎.zip"显然包含了一个使用LWJGL构建的2D小游戏...
lwjgl3-swt:LWJGL 3中对SWT的完全OpenGL支持
05-25
它是什么？ 修订了SWT的GLCanvas的嵌入式实现。 它对我有什么帮助？ 支持： 创建OpenGL 3.0和3.2核心/... 在您现有的SWT应用程序中，只需将所有org.eclipse.swt.opengl.*导入替换为org.lwjgl.opengl.swt.* 。 新的
Planets:在OpenGL中渲染的太阳能系统（lwjgl Java包装器）
05-19
要在Eclipse中运行项目，应在运行配置中将-Djava.library.path = build / natives / windows（或... / linux，对于linux）添加到JVM参数中 建造 克隆此仓库 运行'gradlew buildDistr' 您将在build \ distributions...
基于opengl es 的显示gif的例子
08-29
基于opengl es 的显示gif的例子
SimpleLWJGL3Triangle:LWJGL 使用 OpenGL 4.1 的简​​单三角形渲染
07-07
SimpleLWJGL3Triangle 这是一个使用 LWJGL3 的简单程序，它使用现代 OpenGL 4.1 语法渲染一个三角形。 我在网上找不到用新的 LWJGL 第 3 版 API 演示这一点的好地方，所以希望这对其他人有所帮助。
Java OpenGL（JOGL）学习笔记，含代码
03-08
在我学习JOGL的时候，只找到了英文版的pdf资料，看不懂。。然后我找了C语言版的OpenGL学习教程，对照着将JOGL学完了，并写了一个word作为笔记
【LWJGL2 WIKI】【现代OpenGL篇】用投影、视图、模型矩阵画方形
杂碎的杂乱的杂物间
01-19 2008
原文：http://wiki.lwjgl.org/wiki/The_Quad_with_Projection,_View_and_Model_matricesIntroduction 介绍在OpenGL里，位移、旋转、缩放摄像机和模型用的矩阵必须我们自己计算。传统的OpenGL里有一堆帮忙计算矩阵的函数，但是OpenGL作为一个图形类库职责是画东西而不是算东西，所以现在这些工作最好是由我们自己来完成
java游戏开发包_LWJGL
weixin_36431157的博客
02-25 2330
软件简介LWJGL(Lightweight Java GameLibrary)它可以帮助Java程序员开发有着商业性质的游戏.LWJGL为开发者提供简单易用的API来访问OpenGL (Open GraphicsLibrary)与OpenAL (Open Audio Library) 同也提供操作控制器(Gamepads, Steeringwheel和操纵杆)的API.示例代码：importor...
【JAVA】使用OPENGL
最新发布
12-27 1364
【代码】【JAVA】使用OPENGL。
从零开始Java游戏引擎[LWJGL](3)-使用VAO和VBO绘制图形
KingW
07-27 2873
本节介绍如何使用VAO和VBO进行图形绘制。 先看效果： 本系列文章关注的重点是游戏引擎的开发，关于OpenGL的基础知识，这里就不再详细讲了，否则篇幅篇幅就太长了。这里的相关概念我只简单讲下我自己的理解，如果各位不了解话，请查阅相关的OpenGL书籍。 VBO：顶点缓存对象，其中存储着顶点的相关信息（包括：顶点坐标、顶点颜色、顶点法线、纹理坐标等，这些也就是常说的顶点属性）。每个VBO...
关于Lwjgl及其相关配置
jakeway的专栏
05-09 3143
   LWJGL（Light Weight Java Game Library），是在Java3D之后非官方出现的一种针对Java游戏的一种解决方案。它包括了游戏图形（OpenGL）、音效（OpenAL）及控制输入（JInput），在于成为Java界的DirectX。它的应用函数与C语言版的OpenGL基本完全一致，所以如果你习惯应用OpenGL，那么你使用Lwjgl将得心应手。    当然，
java lwjgl
09-25
java lwjgl是指使用Java编写的轻量级Java游戏库(Lightweight Java Game Library)。它提供了一系列用于游戏开发的功能和工具，包括图形渲染、窗口管理、输入处理、音频处理等。LWJGL基于OpenGL和OpenAL，使开发者能够利用Java语言进行快速、高效的游戏开发。 LWJGL的主要特点包括： - 跨平台：LWJGL可以在多个操作系统上运行，包括Windows、MacOS和Linux等。 - 高性能：LWJGL基于底层的OpenGL和OpenAL库，提供了直接访问硬件的能力，使游戏能够获得更高的性能。 - 简单易用：LWJGL的API设计简单明了，易于学习和使用。 - 社区活跃：LWJGL拥有一个积极的社区，提供了丰富的文档和示例代码，方便开发者学习和解决问题。 LWJGL被广泛应用于游戏开发领域，特别是Java游戏开发。许多著名的游戏如《我的世界》(Minecraft)就是使用LWJGL进行开发的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值