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

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

4. program

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

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

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

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

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

7. 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

}