func MakeTextureFromImageFile(filePath string) gl.Uint { var file, err = os.Open(filePath) var img image.Image var tex gl.Uint if err != nil { panic(err) } defer file.Close() img, _, err = image.Decode(file) if err != nil { panic(err) } w, h := img.Bounds().Dx(), img.Bounds().Dy() sw, sh := gl.Sizei(w), gl.Sizei(h) rgba := image.NewRGBA(image.Rect(0, 0, w, h)) for x := 0; x < w; x++ { for y := 0; y < h; y++ { rgba.Set(x, y, img.At(x, h-1-y)) } } gl.GenTextures(1, &tex) gl.BindTexture(gl.TEXTURE_2D, tex) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT) gl.TexStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, sw, sh) gl.TexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, sw, sh, gl.RGBA, gl.UNSIGNED_BYTE, gl.Pointer(&rgba.Pix[0])) gl.BindTexture(gl.TEXTURE_2D, 0) PanicIfErrors("MakeTextureFromImageFile(%v)", filePath) return tex }
func reinitScreen(width, height int) { winWidth, winHeight = gl.Sizei(width), gl.Sizei(height) if sdlScreen != nil { sdlScreen.Free() } sdlScreen = sdl.SetVideoMode(width, height, 24, sdl.OPENGL|sdl.RESIZABLE) if sdlScreen == nil { panic("SDL video init error") } }
func resize(w, h int) { // TODO: Fix the near and far limits persMat := gls.Perspective(45, float32(w)/float32(h), 1, 1000) //persMat := gls.Identity() gl.UseProgram(theProgram) gls.UniformMatrix4fv(ctcm_unif, 1, false, persMat) //log.Println("Resizing ", persMat) gl.Viewport(0, 0, gl.Sizei(w), gl.Sizei(h)) }
func ShaderSource(name string, shader gl.Uint, source string, defines map[string]interface{}, logPrint bool) { var src []*gl.Char var i, l = 1, len(defines) var lines = make([]string, (l*5)+3) var joined string lines[0] = "#version 420 core\n" for dk, dv := range defines { lines[i+0] = "#define " lines[i+1] = dk lines[i+2] = " " lines[i+3] = fmt.Sprintf("%v", dv) lines[i+4] = "\n" i = i + 5 } lines[i] = "#line 1\n" lines[i+1] = source joined = strings.Join(lines, "") src = gl.GLStringArray(lines...) defer gl.GLStringArrayFree(src) gl.ShaderSource(shader, gl.Sizei(len(src)), &src[0], nil) PanicIfErrors("ShaderSource(name=%v source=%v)", name, joined) if logPrint { log.Printf("\n\n------------------------------\n%s\n\n", joined) } }
func glFillTextureFromImageFile(filePath string) { var file, err = os.Open(filePath) var img image.Image if err != nil { panic(err) } defer file.Close() if img, _, err = image.Decode(file); err != nil { panic(err) } w, h := img.Bounds().Dx(), img.Bounds().Dy() rgba := image.NewRGBA(image.Rect(0, 0, w, h)) for x := 0; x < w; x++ { for y := 0; y < h; y++ { rgba.Set(x, y, img.At(x, y)) } } gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.Sizei(w), gl.Sizei(h), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Pointer(&rgba.Pix[0])) }
func CreateProgram(shaders []g.Uint) g.Uint { p := g.CreateProgram() for _, v := range shaders { g.AttachShader(p, v) } g.LinkProgram(p) var status g.Int g.GetProgramiv(p, g.LINK_STATUS, &status) if status == g.FALSE { var length g.Int g.GetProgramiv(p, g.INFO_LOG_LENGTH, &length) log.Println(length) logStr := g.GLStringAlloc(g.Sizei(length + 1)) g.GetProgramInfoLog(p, g.Sizei(length), nil, logStr) log.Println(g.GoString(logStr)) } return p }
func glGetInfoLog(shaderOrProgram gl.Uint, isShader bool) string { var l = gl.Sizei(256) var s = gl.GLStringAlloc(l) defer gl.GLStringFree(s) if isShader { gl.GetShaderInfoLog(shaderOrProgram, l, nil, s) } else { gl.GetProgramInfoLog(shaderOrProgram, l, nil, s) } return gl.GoString(s) }
func MakeTextureFromImageFloatsFile(filePath string, w, h int) gl.Uint { var file, err = os.Open(filePath) var tex gl.Uint var pix = make([]gl.Float, w*h*3) var fVal float32 var raw []uint8 var buf *bytes.Buffer var i int if err != nil { panic(err) } defer file.Close() raw, err = ioutil.ReadAll(file) if err != nil { panic(err) } buf = bytes.NewBuffer(raw) for i = 0; (err == nil) && (i < len(pix)); i++ { if err = binary.Read(buf, binary.LittleEndian, &fVal); err == io.EOF { err = nil break } else if err == nil { pix[i] = gl.Float(fVal) } } if err != nil { panic(err) } sw, sh := gl.Sizei(w), gl.Sizei(h) gl.GenTextures(1, &tex) gl.BindTexture(gl.TEXTURE_2D, tex) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT) gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT) gl.TexStorage2D(gl.TEXTURE_2D, 1, gl.RGB16F, sw, sh) gl.TexSubImage2D(gl.TEXTURE_2D, 0, 0, 0, sw, sh, gl.RGB, gl.FLOAT, gl.Pointer(&pix[0])) gl.BindTexture(gl.TEXTURE_2D, 0) PanicIfErrors("MakeTextureFromImageFloatsFile(%v)", filePath) return tex }
func ShaderInfoLog(shaderOrProgram gl.Uint, isShader bool) string { var l = gl.Sizei(256) var s = gl.GLStringAlloc(l) defer gl.GLStringFree(s) if isShader { gl.GetShaderInfoLog(shaderOrProgram, l, nil, s) } else { gl.GetProgramInfoLog(shaderOrProgram, l, nil, s) } PanicIfErrors("ShaderInfoLog(s=%v)", isShader) return gl.GoString(s) }
// Loads a shader from a string func LoadShader(typ g.Enum, s string) g.Uint { shader := g.CreateShader(typ) cst := g.GLString(s) defer g.GLStringFree(cst) g.ShaderSource(shader, 1, &cst, nil) g.CompileShader(shader) var status g.Int g.GetShaderiv(shader, g.COMPILE_STATUS, &status) if status == g.FALSE { var length g.Int g.GetShaderiv(shader, g.INFO_LOG_LENGTH, &length) log.Println(int(length)) logStr := g.GLStringAlloc(g.Sizei(length + 1)) // TODO: defer g.GetShaderInfoLog(shader, g.Sizei(length), nil, logStr) log.Println(g.GoString(logStr)) } return shader }
func handleResize(w, h int) { gl.Viewport(0, 0, gl.Sizei(w), gl.Sizei(h)) }
func ReadAtomicCounterValues(ac gl.Uint, vals []gl.Uint) { var ptr *gl.Uint gl.BindBuffer(gl.ATOMIC_COUNTER_BUFFER, ac) for i := 0; i < len(vals); i++ { ptr = (*gl.Uint)(gl.MapBufferRange(gl.ATOMIC_COUNTER_BUFFER, gltypes.OffsetIntPtr(nil, gl.Sizei(i*4)), gltypes.SizeOfGlUint, gl.MAP_READ_BIT)) vals[i] = *ptr gl.UnmapBuffer(gl.ATOMIC_COUNTER_BUFFER) } gl.BindBuffer(gl.ATOMIC_COUNTER_BUFFER, 0) PanicIfErrors("ReadAtomicCounter(%v)", ac) }
func display() { gl.ClearColor(0.19, 0.19, 0.21, 0) gl.ClearDepth(1) gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) gl.UseProgram(theProgram) // Temporarily set the cam t clip id := gls.Identity() trans := getLookAtMatrix() // log.Println(trans) gls.UniformMatrix4fv(wtcm_unif, 1, false, trans) gls.UniformMatrix4fv(mtwm_unif, 1, false, id) // And here we do the actual rendering // Generate a name for vufferobj and store it gl.GenBuffers(1, &positionBufferObject) // Bind it to a target gl.BindBuffer(gl.ARRAY_BUFFER, positionBufferObject) // Conver all nodes to a long array of vertexes! i := 0 // TODO: Fix this, based on 4 per eleemnts vpos := make([]float32, len(elements)*4*4) elms := make(map[uint32]mS, len(elements)) // Note that the order here is undefined! ii := 0 for k, v := range elements { elms[k] = mS{ii, len(v.Nodes())} for _, vv := range v.Nodes() { ii++ vpos[i] = float32(nodes[vv][0]) i++ vpos[i] = float32(nodes[vv][1]) i++ vpos[i] = float32(nodes[vv][2]) i++ vpos[i] = 1.0 i++ } } /* for _, v := range nodes { vpos[i] = float32(v[0]) i++ vpos[i] = float32(v[1]) i++ vpos[i] = float32(v[2]) i++ } */ gl.BufferData(gl.ARRAY_BUFFER, gl.Sizeiptr(32/8*len(vpos)), (gl.Pointer)(&vpos[0]), gl.STATIC_DRAW) gl.BindBuffer(gl.ARRAY_BUFFER, 0) gl.BindBuffer(gl.ARRAY_BUFFER, positionBufferObject) gl.EnableVertexAttribArray(0) gl.VertexAttribPointer(0, 4, gl.FLOAT, gl.FALSE, 0, (gl.Pointer)(nil)) /* for _,v := range elms { } */ for _, v := range elms { gl.DrawArrays(gl.LINE_LOOP, gl.Int(v.Start), gl.Sizei(v.Length)) } // Draw Coordinate acis /*for i := 9; i < 9+2*5; i += 2 { gl.DrawArrays(gl.LINE_STRIP, gl.Int(i), 2) }*/ }
func (v *Vec2) Sizei() (sizeof gl.Sizei) { sizeof = gl.Sizei(unsafe.Sizeof(*v)) return sizeof }
func glSetShaderSource(shader gl.Uint, source string) { var src = gl.GLStringArray(source) defer gl.GLStringArrayFree(src) gl.ShaderSource(shader, gl.Sizei(len(src)), &src[0], nil) }
func (mf *Mat4f) Sizei() (sizeof gl.Sizei) { sizeof = gl.Sizei(unsafe.Sizeof(*mf)) return sizeof }
func (vf *Vec2f) Sizei() (sizeof gl.Sizei) { sizeof = gl.Sizei(unsafe.Sizeof(*vf)) return sizeof }
func (m *Mat4) Sizei() (sizeof gl.Sizei) { sizeof = gl.Sizei(unsafe.Sizeof(*m)) return sizeof }