Golang游戏引擎日记（09.纹理贴图）

运行效果：

shader.vert：

#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aColor;
layout (location = 2) in vec2 aTexCoord;

out vec3 ourColor;
out vec2 TexCoord;

void main()
{
    gl_Position = vec4(aPos, 1.0);
    ourColor = aColor;
    TexCoord = aTexCoord;
}

shader.frag：

#version 330 core
out vec4 FragColor;

in vec3 ourColor;
in vec2 TexCoord;

uniform sampler2D ourTexture;

void main()
{
    FragColor = texture(ourTexture, TexCoord);
}

game.go：

package engine

import (
	_ "embed"
	"fmt"
	"image"
	"image/draw"
	_ "image/png"
	"os"
	"unsafe"

	"github.com/go-gl/gl/v3.3-core/gl"
	"github.com/go-gl/glfw/v3.3/glfw"
)

var mIsRunning = false
var mWidth = 1024
var mHeight = 768

var VAO uint32
var VBO uint32
var EBO uint32
var shaderProgram uint32
var texture uint32

var vertices = [...]float32{
	//位置         颜色            纹理坐标 -
	0.5, 0.5, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, // 右上
	0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, // 右下
	-0.5, -0.5, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, // 左下
	-0.5, 0.5, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, // 左上
}

var indices = [...]int32{
	0, 1, 3,
	1, 2, 3,
}

//go:embed shader.vert
var vertexShaderSource string

//go:embed shader.frag
var fragmentShaderSource string

type Game struct {
	MWindow *glfw.Window
}

//初始化引擎
func (g *Game) Initialize() bool {
	//获取glfw版本
	fmt.Println(glfw.GetVersionString())
	//初始化glfw
	var err error
	if err = glfw.Init(); err != nil {
		fmt.Printf("Unable to initialize glfw: %v", err)
		return false
	}

	glfw.WindowHint(glfw.RedBits, 8)
	glfw.WindowHint(glfw.GreenBits, 8)
	glfw.WindowHint(glfw.BlueBits, 8)
	glfw.WindowHint(glfw.AlphaBits, 8)
	glfw.WindowHint(glfw.DepthBits, 24)
	glfw.WindowHint(glfw.DoubleBuffer, 1)
	//glfw.WindowHint(glfw.Resizable, 0) //禁止调整窗口大小
	//设置版本
	glfw.WindowHint(glfw.ContextVersionMajor, 3)
	glfw.WindowHint(glfw.ContextVersionMinor, 3)
	glfw.WindowHint(glfw.OpenGLProfile, glfw.OpenGLCoreProfile)
	glfw.WindowHint(glfw.OpenGLForwardCompatible, glfw.True)
	//窗口模式
	if g.MWindow, err = glfw.CreateWindow(mWidth, mHeight, "纹理贴图", nil, nil); err != nil {
		fmt.Printf("Failed to create window: %v", err)
		return false
	}
	//回调函数
	g.MWindow.SetCloseCallback(CloseCallback) //关闭回调
	g.MWindow.SetSizeCallback(SizeCallback)   //调整回调
	g.MWindow.SetKeyCallback(KeyCallback)     //按键回调
	//上下文
	g.MWindow.MakeContextCurrent()

	//初始化opengl
	if err = gl.Init(); err != nil {
		fmt.Printf("Unable to initialize gl: %v", err)
		return false
	}
	gl.Viewport(0, 0, int32(mWidth), int32(mHeight))
	//gl.Enable(gl.CULL_FACE) //开启剔除
	//gl.CullFace(gl.FRONT)    //剔除背面

	version := gl.GoStr(gl.GetString(gl.VERSION))
	fmt.Println(version)

	//顶点着色器
	vertexShader := gl.CreateShader(gl.VERTEX_SHADER)
	vertexString, _ := gl.Strs(vertexShaderSource)
	gl.ShaderSource(vertexShader, 1, vertexString, nil)
	gl.CompileShader(vertexShader)
	var success int32
	var infoLog [512]uint8
	gl.GetShaderiv(vertexShader, gl.COMPILE_STATUS, &success)
	if success != 1 {
		gl.GetShaderInfoLog(vertexShader, 512, nil, &infoLog[0])
		fmt.Printf("顶点着色器错误:%s\n", infoLog)
	}
	//片段着色器
	fragmentShader := gl.CreateShader(gl.FRAGMENT_SHADER)
	fragmentString, _ := gl.Strs(fragmentShaderSource)
	gl.ShaderSource(fragmentShader, 1, fragmentString, nil)
	gl.CompileShader(fragmentShader)
	gl.GetShaderiv(fragmentShader, gl.COMPILE_STATUS, &success)
	if success != 1 {
		gl.GetShaderInfoLog(fragmentShader, 512, nil, &infoLog[0])
		fmt.Printf("片段着色器错误:%s\n", infoLog)
	}
	//着色器程序
	shaderProgram = gl.CreateProgram()
	gl.AttachShader(shaderProgram, vertexShader)
	gl.AttachShader(shaderProgram, fragmentShader)
	gl.LinkProgram(shaderProgram)
	gl.GetProgramiv(shaderProgram, gl.LINK_STATUS, &success)
	if success != 1 {
		gl.GetProgramInfoLog(shaderProgram, 512, nil, &infoLog[0])
		fmt.Printf("着色器程序错误:%s\n", infoLog)
	}
	//删除着色器
	gl.DeleteShader(vertexShader)
	gl.DeleteShader(fragmentShader)

	gl.GenVertexArrays(1, &VAO)
	gl.GenBuffers(1, &VBO)
	gl.GenBuffers(1, &EBO)

	gl.BindVertexArray(VAO)

	gl.BindBuffer(gl.ARRAY_BUFFER, VBO)
	gl.BufferData(gl.ARRAY_BUFFER, int(unsafe.Sizeof(vertices)), unsafe.Pointer(&vertices), gl.STATIC_DRAW)

	gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, EBO)
	gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, int(unsafe.Sizeof(indices)), unsafe.Pointer(&indices), gl.STATIC_DRAW)

	// 位置属性
	gl.VertexAttribPointerWithOffset(0, 3, gl.FLOAT, false, 8*int32(unsafe.Sizeof(float32(0))), 0)
	gl.EnableVertexAttribArray(0)
	// 颜色属性
	gl.VertexAttribPointerWithOffset(1, 3, gl.FLOAT, false, 8*int32(unsafe.Sizeof(float32(0))), uintptr(3*int32(unsafe.Sizeof(float32(0)))))
	gl.EnableVertexAttribArray(1)
	//纹理属性
	gl.VertexAttribPointerWithOffset(2, 2, gl.FLOAT, false, 8*int32(unsafe.Sizeof(float32(0))), uintptr(6*int32(unsafe.Sizeof(float32(0)))))
	gl.EnableVertexAttribArray(2)

	texture, _ = newTexture("./container.png")

	//保持运行
	mIsRunning = true
	return true
}

//引擎循环
func (g *Game) RunLoop() {
	for mIsRunning {
		//清屏
		gl.ClearColor(0.2, 0.3, 0.3, 1.0)
		gl.Clear(gl.COLOR_BUFFER_BIT)
		//....
		g.ProcessInput()
		g.UpdateGame()
		g.GenerateOutput()
		//交换缓存
		g.MWindow.SwapBuffers()
		glfw.PollEvents()
	}
}

//引擎销毁
func (g *Game) Shutdown() {
	gl.DeleteVertexArrays(1, &VAO)
	gl.DeleteBuffers(1, &VBO)
	gl.DeleteBuffers(1, &EBO)
	gl.DeleteProgram(shaderProgram)

	g.MWindow.Destroy()
	glfw.Terminate()
}

func (g *Game) ProcessInput() {

}

func (g *Game) UpdateGame() {

}

func (g *Game) GenerateOutput() {
	gl.BindTexture(gl.TEXTURE_2D, texture)
	gl.UseProgram(shaderProgram)
	gl.BindVertexArray(VAO)
	gl.DrawElementsWithOffset(gl.TRIANGLES, 6, gl.UNSIGNED_INT, 0)
}

func CloseCallback(w *glfw.Window) {
	mIsRunning = false
}

func SizeCallback(w *glfw.Window, width int, height int) {
	gl.Viewport(0, 0, int32(width), int32(height))
}

func KeyCallback(w *glfw.Window, key glfw.Key, scancode int, action glfw.Action, mods glfw.ModifierKey) {
	switch key {
	case glfw.KeyEscape:
		if action == glfw.Press {
			CloseCallback(w)
		}
	}
}

func newTexture(file string) (uint32, error) {
	imgFile, err := os.Open(file)
	if err != nil {
		return 0, fmt.Errorf("texture %q not found on disk: %v", file, err)
	}
	img, _, err := image.Decode(imgFile)
	if err != nil {
		return 0, err
	}

	rgba := image.NewRGBA(img.Bounds())
	if rgba.Stride != rgba.Rect.Size().X*4 {
		return 0, fmt.Errorf("unsupported stride")
	}
	draw.Draw(rgba, rgba.Bounds(), img, image.Point{0, 0}, draw.Src)

	var texture uint32
	gl.GenTextures(1, &texture)
	gl.ActiveTexture(gl.TEXTURE0)
	gl.BindTexture(gl.TEXTURE_2D, texture)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)
	gl.TexImage2D(
		gl.TEXTURE_2D,
		0,
		gl.RGBA,
		int32(rgba.Rect.Size().X),
		int32(rgba.Rect.Size().Y),
		0,
		gl.RGBA,
		gl.UNSIGNED_BYTE,
		gl.Ptr(rgba.Pix))

	return texture, nil
}