opengl textures

Author: jackmott

gogl/gogl.go

@@ -4,22 +4,84 @@ import (
 	"errors"
 	"fmt"
 	"github.com/go-gl/gl/v3.3-core/gl"
+	"github.com/go-gl/mathgl/mgl32"
+	"image/png"
 	"io/ioutil"
+	"os"
 	"strings"
 )
 
 type ShaderID uint32
 type ProgramID uint32
 type BufferID uint32
+type TextureID uint32
+
+func MglTest() {
+	x := mgl32.NewVecN(2)
+	fmt.Println(x)
+}
 
 func GetVersion() string {
 	return gl.GoStr(gl.GetString(gl.VERSION))
 }
 
+// Todo:  SDL2_image  stb_image Sean Barret
+func LoadTextureAlpha(filename string) TextureID {
+	infile, err := os.Open(filename)
+	if err != nil {
+		panic(err)
+	}
+	defer infile.Close()
+
+	img, err := png.Decode(infile)
+	if err != nil {
+		panic(err)
+	}
+
+	w := img.Bounds().Max.X
+	h := img.Bounds().Max.Y
+
+	pixels := make([]byte, w*h*4)
+	bIndex := 0
+	for y := 0; y < h; y++ {
+		for x := 0; x < w; x++ {
+			r, g, b, a := img.At(x, y).RGBA()
+			pixels[bIndex] = byte(r / 256)
+			bIndex++
+			pixels[bIndex] = byte(g / 256)
+			bIndex++
+			pixels[bIndex] = byte(b / 256)
+			bIndex++
+			pixels[bIndex] = byte(a / 256)
+			bIndex++
+		}
+	}
+
+	texture := GenBindTexture()
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
+	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
+	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(w), int32(h), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(pixels))
+	gl.GenerateMipmap(gl.TEXTURE_2D)
+	return texture
+}
+
+func GenBindTexture() TextureID {
+	var texId uint32
+	gl.GenTextures(1, &texId)
+	gl.BindTexture(gl.TEXTURE_2D, texId)
+	return TextureID(texId)
+}
+
+func BindTexture(id TextureID) {
+	gl.BindTexture(gl.TEXTURE_2D, uint32(id))
+}
+
 func LoadShader(path string, shaderType uint32) (ShaderID, error) {
 	shaderFile, err := ioutil.ReadFile(path)
 	if err != nil {
-		panic(err)
+		return 0, err
 	}
 	shaderFileStr := string(shaderFile)
 	shaderId, err := CreateShader(shaderFileStr, shaderType)

gogl/shader.go

@@ -20,7 +20,15 @@ func NewShader(vertexPath string, fragmentPath string) (*Shader, error) {
 	if err != nil {
 		return nil, err
 	}
-	result := &Shader{id, vertexPath, fragmentPath, getModifiedTime(vertexPath), getModifiedTime(fragmentPath)}
+	vertexModTime, err := getModifiedTime(vertexPath)
+	if err != nil {
+		return nil, err
+	}
+	fragmentModTime, err := getModifiedTime(fragmentPath)
+	if err != nil {
+		return nil, err
+	}
+	result := &Shader{id, vertexPath, fragmentPath, vertexModTime, fragmentModTime}
 	return result, nil
 }
 
@@ -34,18 +42,25 @@ func (shader *Shader) SetFloat(name string, f float32) {
 	gl.Uniform1f(location, f)
 }
 
-func getModifiedTime(filePath string) time.Time {
+func getModifiedTime(filePath string) (time.Time, error) {
+
 	file, err := os.Stat(filePath)
 	if err != nil {
-		panic(err)
+		return time.Time{}, err
 	}
-	return file.ModTime()
+	return file.ModTime(), nil
 }
 
-func (shader *Shader) CheckShaderForChanges() {
+func (shader *Shader) CheckShaderForChanges() error {
 
-	vertexModTime := getModifiedTime(shader.vertexPath)
-	fragmentModTime := getModifiedTime(shader.fragmentPath)
+	vertexModTime, err := getModifiedTime(shader.vertexPath)
+	if err != nil {
+		return err
+	}
+	fragmentModTime, err := getModifiedTime(shader.fragmentPath)
+	if err != nil {
+		return err
+	}
 	// check if greater than?
 	if !vertexModTime.Equal(shader.vertexModified) ||
 		!fragmentModTime.Equal(shader.fragmentModified) {
@@ -57,5 +72,6 @@ func (shader *Shader) CheckShaderForChanges() {
 			shader.id = id
 		}
 	}
+	return nil
 
 }

hellotriangle/assets/tex.png

@@ -1,3 +1,7 @@
+// Make shader hotloading fail gracefully and retry
+// Make an attribpointer helper function
+// Make a texture
+
 package main
 
 import (
@@ -29,14 +33,17 @@ func main() {
 	defer window.Destroy()
 
 	gl.Init()
+	gogl.MglTest()
 
 	fmt.Println("OpenGL Version", gogl.GetVersion())
 
-	shaderProgram, err := gogl.NewShader("shaders/hello.vert", "shaders/hello.frag")
+	shaderProgram, err := gogl.NewShader("shaders/hello.vert", "shaders/quadtexture.frag")
 	if err != nil {
 		panic(err)
 	}
 
+	texture := gogl.LoadTextureAlpha("assets/tex.png")
+
 	vertices := []float32{
 		0.5, 0.5, 0.0, 1.0, 1.0,
 		0.5, -0.5, 0.0, 1.0, 0.0,
@@ -74,6 +81,7 @@ func main() {
 		shaderProgram.Use()
 		shaderProgram.SetFloat("x", x)
 		shaderProgram.SetFloat("y", 0.0)
+		gogl.BindTexture(texture)
 		gogl.BindVertexArray(VAO)
 		gl.DrawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, gl.PtrOffset(0))
 		window.GLSwap()

hellotriangle/hellotriangle.go

@@ -0,0 +1,9 @@
+#version 330 core
+out vec4 FragColor;
+in vec2 TexCoord;
+
+uniform sampler2D texture1;
+
+void main() {
+    FragColor = texture(texture1,TexCoord);    
+}

hellotriangle/shaders/quadtexture.frag

@@ -155,8 +155,8 @@ void main()
     vec2 star2pos = coord  + pos *.05;
     vec2 star3pos = coord + pos *.1; 
 
-    vec3 nebulaColor1 = hsv2rgb(vec3(.4+.005*sin(nebula1pos.x * 100.0 + nebula1pos.y), 0.5, .25));
-	vec3 nebulaColor2 = hsv2rgb(vec3(.9+.001*sin(nebula2pos.x * 60.0 + nebula2pos.y), 1., .25));
+    vec3 nebulaColor1 = hsv2rgb(vec3(.9+.005*sin(nebula1pos.x * 100.0 + nebula1pos.y), 0.5, .25));
+	vec3 nebulaColor2 = hsv2rgb(vec3(.1+.001*sin(nebula2pos.x * 60.0 + nebula2pos.y), 1., .25));
 
     result += fractalNebula(nebula1pos, nebulaColor1, 1.);
     result += fractalNebula(nebula2pos + vec2(5., 7.2), nebulaColor2, .5);