golang游戏开发学习笔记-用golang画一个随时间变化颜色的正方形

其他 2019-07-10 08:03:06 阅读次数: 0

虽然工作中基本只用到java和javascript但一直对golang比较感兴趣，最近闲来无事，想写个游戏（也是博主一直以来的梦想）但如果直接上游戏引擎就起不到学习的作用了，于是从零开始学习opengl,golang下的opengl文档比较少，应用似乎也不广泛，只能照着C++的文档照猫画虎了
主要参考了这两个网站的教程
learnOpenGl 的中文翻译，使用C++实现的。
OpenGL 与 Go 教程 能找到的唯一在golang下使用opengl的教程，非常初级。

1.相关概念

  1. opengl

一个由Khronos组织制定并维护的规范(Specification)。该规范严格规定了每个函数该如何执行，以及它们的输出值。至于内部具体每个函数是如何实现(Implement)的，将由OpenGL库的开发者自行决定（译注：这里开发者是指编写OpenGL库的人）。因为OpenGL规范并没有规定实现的细节，具体的OpenGL库允许使用不同的实现，只要其功能和结果与规范相匹配（亦即，作为用户不会感受到功能上的差异）。

  1. glfw

用于创建窗口、上下文和界面，接收输入和事件的api。

  1. shader(着色器)

运行在GPU上的小程序。这些小程序为图形渲染管线的某个特定部分而运行,使用一种叫GLSL的类C语言写成，有顶点着色器和片段着色器两种，具体干啥的我理解的也不是很透彻，目前只把他门当作渲染一个图像的不同阶段的工具？

  1. program

多个着色器合并之后并最终链接完成的版本。

  1. Vertex Buffer Object (顶点缓冲区对象，简称vbo）

保存多个顶点的对象，一次性的发送一大批数据到显卡上，这个很容易理解，如果没有缓冲区，要把一个图像的每个顶点分别发送到GPU上，与编程语言的缓冲是同样的思想。

  1. Vertex Array Object(顶点数组对象，简称vao)

保存一个或多个vbo和对应的顶点属性，仅仅有vbo是不能直接渲染图像的，还需要绑定各种属性，比如法线，颜色信息，索引等等，有了vao之后每次绘制同构的vbo时不用在重新绑定

  1. Element Buffer Object(索引缓冲对象，简称ebo)

这个概念在这里讲解的很清晰明了了，这里不做赘述

2.依赖

golang在国内似乎被qiang了，好在opengl和glfw的依赖都发布在github上，配置好gopath系统变量后直接使用go get命令下载依赖即可。要注意，安装opengl的依赖需要gcc，如果没有，需要安装mingw或TDM-GCC，依赖安装命令如下

go get -u github.com/go-gl/gl/v4.6-core/gl
go get github.com/go-gl/glfw/v3.2/glfw

3.初始化窗口

import(
    "github.com/go-gl/glfw/v3.2/glfw"
)

引入依赖

 if err := glfw.Init(); err != nil {
            panic(err)
    }
    glfw.WindowHint(glfw.Resizable, glfw.False)
    window, err := glfw.CreateWindow(width, height, "Conway's Game of Life", nil, nil)
    if err != nil {
            panic(err)
    }

    window.MakeContextCurrent()

初始化窗口并设置属性，这里设置窗口不可改变大小，要注意的是GLFW需要在其被初始化之后的线程里被调用

4.编写着色器和着色程序

前面提到着色器要用GLSL语言编写，学过责任链设计模式的同学可以将着色器理解为责任链中的不同部分，前一个程序的输出是后一个程序的输入，我们分别编写一个顶点着色器和片段着色器并编写一个使用opengl编译函数

import(
	"github.com/go-gl/gl/v4.1-core/gl"
	"strings"
	"fmt"
)
const(
	VertexShaderSource = `
		#version 410
		in vec3 vp;
		void main(){
			gl_Position = vec4(vp,1.0);
		}
	` + "\x00"
	FragmentShaderSource = `
		#version 410
		out vec4 frag_colour;
		uniform vec4 FragColor;
		void main() {
			frag_colour = FragColor;
		}
	` + "\x00"
)
func CompileShader(source string, shaderType uint32) (uint32, error) {
    shader := gl.CreateShader(shaderType)
    csources, free := gl.Strs(source)
    gl.ShaderSource(shader, 1, csources, nil)
    free()
    gl.CompileShader(shader)
    var status int32
    gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status)
    if status == gl.FALSE {
        var logLength int32
        gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength)
        log := strings.Repeat("\x00", int(logLength+1))
        gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log))
        return 0, fmt.Errorf("failed to compile %v: %v", source, log)
    }
    return shader, nil
}

然后我们初始化着色程序并加入着色器

if err := gl.Init(); err != nil {
            panic(err)
    }
    version := gl.GoStr(gl.GetString(gl.VERSION))
    log.Println("OpenGL version", version)
    vertexShader, err := shader.CompileShader(shader.VertexShaderSource, gl.VERTEX_SHADER)
    if err != nil {
        panic(err)
    }
    fragmentShader, err := shader.CompileShader(shader.FragmentShaderSource, gl.FRAGMENT_SHADER)
    if err != nil {
        panic(err)
    }
    prog := gl.CreateProgram()
    gl.AttachShader(prog, vertexShader)
    gl.AttachShader(prog, fragmentShader)    
    gl.Viewport(0,0,width,height)
    gl.LinkProgram(prog)

5.构建图像以及缓冲

先定义两个切片

var (
    vertices = []float32{
        -0.5, -0.5, 0.0,
        -0.5, 0.5, 0.0,
        0.5, 0.5, 0.0,
        0.5, -0.5, 0.0,
    }
    indices = []uint32{
        0, 1, 2,
        2, 3, 0,
    }
)

前一个切片内保存的是构成两个三角形所需要的所有顶点，由于我们会用到ebo，所以两个重复的顶点直接省略，而第二个切片的每一行分别代表前一个切面中顶点的索引，分别构成对应的三角形。
生成并绑定vao

var vbo uint32
gl.GenBuffers(1, &vbo)
gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
gl.BufferData(gl.ARRAY_BUFFER, 4*len(points), gl.Ptr(points), gl.STATIC_DRAW)

var vao uint32
gl.GenVertexArrays(1, &vao)
gl.BindVertexArray(vao)
gl.EnableVertexAttribArray(0)
gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 0, gl.Ptr(nil))

var ebo uint32
gl.GenBuffers(2,&ebo)
gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER,ebo)
gl.BufferData(gl.ELEMENT_ARRAY_BUFFER,4*len(indices),gl.Ptr(indices),gl.STATIC_DRAW)

最后在main函数中绘制

for !window.ShouldClose() {
    gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
    timeValue := glfw.GetTime()
    greenValue := float32(math.Sin(timeValue) / 2.0 + 0.5)
    vertexColorLocation := gl.GetUniformLocation(prog,gl.Str("FragColor\x00"))
    gl.UseProgram(prog)
    glBindVertexArray(vao);
    gl.Uniform4f(vertexColorLocation,0,greenValue,0,1)
    gl.DrawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, gl.PtrOffset(0))
    glfw.PollEvents()
    window.SwapBuffers()
}

最终运行结果
在这里插入图片描述
完整代码如下

package main

import(
    "github.com/go-gl/glfw/v3.2/glfw"
    "github.com/go-gl/gl/v4.1-core/gl"
    "log"
    "legend/shader"
    "runtime"
    "math"
    "strings"
	"fmt"
)
const (
    width  = 500
    height = 500
    VertexShaderSource = `
		#version 410
		in vec3 vp;
		void main(){
			gl_Position = vec4(vp,1.0);
		}
	` + "\x00"
	FragmentShaderSource = `
		#version 410
		out vec4 frag_colour;
		uniform vec4 FragColor;
		void main() {
			frag_colour = FragColor;
		}
	` + "\x00"
)

var (
    vertices = []float32{
        -0.5, -0.5, 0.0,
        -0.5, 0.5, 0.0,
        0.5, 0.5, 0.0,
        0.5, -0.5, 0.0,
    }
    indices = []uint32{
        0, 1, 2,
        2, 3, 0,
    }
)
func main() {
    runtime.LockOSThread()
    window := initGlfw()
    defer glfw.Terminate()
    program := initOpenGL()
    vao := makeVao(vertices,indices)
    for !window.ShouldClose() {
        draw(vao, window, program)
    }
    glfw.Terminate()
}
func initGlfw() *glfw.Window {
    if err := glfw.Init(); err != nil {
            panic(err)
    }
    glfw.WindowHint(glfw.Resizable, glfw.False)
    window, err := glfw.CreateWindow(width, height, "Conway's Game of Life", nil, nil)
    if err != nil {
            panic(err)
    }

    window.MakeContextCurrent()
    return window
}

func initOpenGL() uint32 {
    if err := gl.Init(); err != nil {
            panic(err)
    }
    version := gl.GoStr(gl.GetString(gl.VERSION))
    log.Println("OpenGL version", version)
    vertexShader, err := shader.CompileShader(shader.VertexShaderSource, gl.VERTEX_SHADER)
    if err != nil {
        panic(err)
    }
    fragmentShader, err := shader.CompileShader(shader.FragmentShaderSource, gl.FRAGMENT_SHADER)
    if err != nil {
        panic(err)
    }
    prog := gl.CreateProgram()
    gl.AttachShader(prog, vertexShader)
    gl.AttachShader(prog, fragmentShader)    
    gl.Viewport(0,0,width,height)
    gl.LinkProgram(prog)
    return prog
}


func makeVao(points []float32,indices []uint32) uint32 {
    var vbo uint32
    gl.GenBuffers(1, &vbo)
    gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
    gl.BufferData(gl.ARRAY_BUFFER, 4*len(points), gl.Ptr(points), gl.STATIC_DRAW)

    var vao uint32
    gl.GenVertexArrays(1, &vao)
    gl.BindVertexArray(vao)
    gl.EnableVertexAttribArray(0)
    gl.VertexAttribPointer(0, 3, gl.FLOAT, false, 0, gl.Ptr(nil))

    if(indices != nil){
        var ebo uint32
        gl.GenBuffers(2,&ebo)
        gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER,ebo)
        gl.BufferData(gl.ELEMENT_ARRAY_BUFFER,4*len(indices),gl.Ptr(indices),gl.STATIC_DRAW)

    }
    return vao
}

func draw(vao uint32, window *glfw.Window, program uint32) {
    gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
    timeValue := glfw.GetTime()
    greenValue := float32(math.Sin(timeValue) / 2.0 + 0.5)
    vertexColorLocation := gl.GetUniformLocation(program,gl.Str("FragColor\x00"))
    gl.UseProgram(program)
    gl.BindVertexArray(vao)
    gl.Uniform4f(vertexColorLocation,0,greenValue,0,1)

    //gl.DrawArrays(gl.TRIANGLES, 0, 4)
    gl.DrawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, gl.PtrOffset(0))
    glfw.PollEvents()
    window.SwapBuffers()
}
func CompileShader(source string, shaderType uint32) (uint32, error) {
    shader := gl.CreateShader(shaderType)
    csources, free := gl.Strs(source)
    gl.ShaderSource(shader, 1, csources, nil)
    free()
    gl.CompileShader(shader)
    var status int32
    gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status)
    if status == gl.FALSE {
        var logLength int32
        gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength)
        log := strings.Repeat("\x00", int(logLength+1))
        gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log))
        return 0, fmt.Errorf("failed to compile %v: %v", source, log)
    }
    return shader, nil
}

猜你喜欢

转载自blog.csdn.net/qq_35488769/article/details/94209069
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
curl的POST请求，封装方法
8.1.1. Integer Types
Java基础 Day05(个人复习整理)
Python - Django - 中间件 process_exception
小L的试卷
【Shell编程】 （函数）判断用户是否存在
python(css样式)
spring ant path 匹配原则 - 【笔记】
《JavaScript与JScript从入门到精通》(美)James.Jaworski.中译本.扫描版.pdf
Eclipse运行带参数的java程序
每日归档
更多
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022