func (r *EffectsRenderer) initFramebuffer(w, h int) (fb uint32, tex uint32, err error) {
gl.GenFramebuffers(1, &fb)
gl.BindFramebuffer(gl.FRAMEBUFFER, fb)
gl.GenTextures(1, &tex)
gl.BindTexture(gl.TEXTURE_2D, tex)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(w), int32(h), 0, gl.RGBA, gl.UNSIGNED_BYTE, nil)
gl.FramebufferTexture2D(gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0)
if err = r.GetError(); err != nil {
return
}
buffers := []uint32{gl.COLOR_ATTACHMENT0}
gl.DrawBuffers(1, &buffers[0])
var rb uint32
gl.GenRenderbuffers(1, &rb)
gl.BindRenderbuffer(gl.RENDERBUFFER, rb)
gl.RenderbufferStorage(gl.RENDERBUFFER, gl.STENCIL_INDEX8, int32(w), int32(h))
gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.STENCIL_ATTACHMENT, gl.RENDERBUFFER, rb)
gl.BindTexture(gl.TEXTURE_2D, 0)
gl.BindFramebuffer(gl.FRAMEBUFFER, 0)
gl.BindRenderbuffer(gl.RENDERBUFFER, 0)
return
}
func getGLTexture(img image.Image, smoothing TextureSmoothing) (t uint32, err error) {
var (
data *bytes.Buffer
bounds image.Rectangle
width int
height int
)
if data, err = imageBytes(img); err != nil {
return
}
bounds = img.Bounds()
width = bounds.Max.X - bounds.Min.X
height = bounds.Max.Y - bounds.Min.Y
gl.GenTextures(1, &t)
gl.BindTexture(gl.TEXTURE_2D, t)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, int32(smoothing))
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, int32(smoothing))
gl.TexImage2D(
gl.TEXTURE_2D,
0,
gl.RGBA,
int32(width),
int32(height),
0,
gl.RGBA,
gl.UNSIGNED_INT_8_8_8_8,
gl.Ptr(data.Bytes()),
)
gl.GenerateMipmap(gl.TEXTURE_2D)
gl.BindTexture(gl.TEXTURE_2D, 0)
return
}
func newTexture(file string, texNum uint32) (uint32, error) {
imgFile, err := os.Open(file)
if err != nil {
return 0, err
}
img, _, err := image.Decode(imgFile)
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.ZP, draw.Src)
var texture uint32
gl.GenTextures(1, &texture)
gl.ActiveTexture(texNum)
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.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
}
func createTexture(textureUnit uint32, rgba *image.RGBA) (uint32, error) {
var texture uint32
gl.GenTextures(1, &texture)
gl.ActiveTexture(textureUnit)
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
}
// Attempting to load a Texture from a given location on the disk.
func LoadTexture(path string) (Texture, error) {
// Loading the image data.
imgFile, err := os.Open(path)
if err != nil {
return 0, 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, errors.New("Unsupported stride.")
}
draw.Draw(rgba, rgba.Bounds(), img, image.Point{0, 0}, draw.Src)
// Generating and populating the texture.
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(texture), nil
}
func GetGLTexture(img image.Image, smoothing TextureSmoothing) (t uint32, err error) {
var (
data *bytes.Buffer
bounds image.Rectangle
width int
height int
)
if data, err = imageBytes(img); err != nil {
return
}
bounds = img.Bounds()
width = bounds.Max.X - bounds.Min.X
height = bounds.Max.Y - bounds.Min.Y
gl.GenTextures(1, &t)
if e := gl.GetError(); e != 0 {
fmt.Printf("ggt1 ERROR: %s\n", e)
}
gl.BindTexture(gl.TEXTURE_2D, t)
if e := gl.GetError(); e != 0 {
fmt.Printf("ggt2 ERROR: %s\n", e)
}
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, int32(smoothing))
if e := gl.GetError(); e != 0 {
fmt.Printf("ggt3 ERROR: %s\n", e)
}
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, int32(smoothing))
if e := gl.GetError(); e != 0 {
fmt.Printf("ggt4 ERROR: %s\n", e)
}
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, int32(width), int32(height), 0, gl.RGBA, gl.UNSIGNED_INT_8_8_8_8, gl.Ptr(data.Bytes()))
if e := gl.GetError(); e != 0 {
fmt.Printf("ggt5 ERROR: %s\n", e)
}
gl.GenerateMipmap(gl.TEXTURE_2D)
if e := gl.GetError(); e != 0 {
fmt.Printf("ggt6 ERROR: %s\n", e)
}
gl.BindTexture(gl.TEXTURE_2D, 0)
if e := gl.GetError(); e != 0 {
fmt.Printf("ggt7 ERROR: %s\n", e)
}
return
}
func LoadImageToTexture(filePath string) (glTex uint32, e error) {
gl.GenTextures(1, &glTex)
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, glTex)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR_MIPMAP_LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT)
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT)
rgba_flipped, err := loadFile(filePath)
if err != nil {
return glTex, err
}
imageSize := int32(rgba_flipped.Bounds().Max.X)
gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, imageSize, imageSize, 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(rgba_flipped.Pix))
gl.GenerateMipmap(gl.TEXTURE_2D)
return glTex, nil
}
func CreateTexture(file string) (Texture, error) {
imgFile, err := os.Open(file)
if err != nil {
return Texture{}, err
}
img, _, err := image.Decode(imgFile)
if err != nil {
return Texture{}, err
}
rgba := image.NewRGBA(img.Bounds())
if rgba.Stride != rgba.Rect.Size().X*4 {
return Texture{}, fmt.Errorf("unsupported stride")
}
draw.Draw(rgba, rgba.Bounds(), img, image.Point{0, 0}, draw.Src)
width, height := int32(rgba.Rect.Size().X), int32(rgba.Rect.Size().Y)
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,
width,
height,
0,
gl.RGBA,
gl.UNSIGNED_BYTE,
gl.Ptr(rgba.Pix))
return Texture{Id: texture, Width: width, Height: height}, nil
}
func bindAggregateImage(img image.Image, idx int) uint32 {
newIdx := idx
if rgba, ok := img.(*image.RGBA); ok {
gl.GenTextures(1, &textures[newIdx])
gl.ActiveTexture(gl.TEXTURE0 + uint32(newIdx))
gl.BindTexture(gl.TEXTURE_2D, textures[newIdx])
gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_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.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_R, 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))
gl.GenerateMipmap(gl.TEXTURE_2D)
idxS := strconv.Itoa(newIdx)
fmt.Println("idx: ", int32(newIdx), "myTextureSampler["+idxS+"]\x00")
gl.Uniform1i(gl.GetUniformLocation(program, gl.Str("myTextureSampler["+idxS+"]\x00")), int32(newIdx))
if ok := gl.GetError(); ok != gl.NO_ERROR {
fmt.Println("1- Cannot load Image in location: ./: ", ok)
os.Exit(-1)
}
return textures[newIdx]
} else {
fmt.Println("Image not RGBA at location: ./")
os.Exit(-1)
}
return 0
}
// LoadDictionary reads a gobbed Dictionary object from r, registers its atlas texture with opengl,
// and returns a Dictionary that is ready to render text.
func LoadDictionary(r io.Reader) (*Dictionary, error) {
errChan := make(chan error)
initOnce.Do(func() {
render.Queue(func() {
// errChan <- render.RegisterShader("glop.font", []byte(font_vertex_shader), []byte(font_fragment_shader))
errChan <- render.RegisterShader("glop.font", []byte(font_vshader), []byte(font_fshader))
})
})
err := <-errChan
if err != nil {
return nil, err
}
var dict Dictionary
dec := gob.NewDecoder(r)
err = dec.Decode(&dict)
if err != nil {
return nil, err
}
render.Queue(func() {
// Create the gl texture for the atlas
gl.GenTextures(1, &dict.atlas.texture)
glerr := gl.GetError()
if glerr != 0 {
errChan <- fmt.Errorf("Gl Error on gl.GenTextures: %v", glerr)
return
}
// Send the atlas to opengl
gl.BindTexture(gl.TEXTURE_2D, dict.atlas.texture)
gl.PixelStorei(gl.UNPACK_ALIGNMENT, 1)
gl.TexImage2D(
gl.TEXTURE_2D,
0,
gl.RED,
dict.Dx,
dict.Dy,
0,
gl.RED,
gl.UNSIGNED_BYTE,
gl.Ptr(&dict.Pix[0]))
glerr = gl.GetError()
if glerr != 0 {
errChan <- fmt.Errorf("Gl Error on creating texture: %v", glerr)
return
}
// Create the atlas sampler and set the parameters we want for it
gl.GenSamplers(1, &dict.atlas.sampler)
gl.SamplerParameteri(dict.atlas.sampler, gl.TEXTURE_MIN_FILTER, gl.LINEAR)
gl.SamplerParameteri(dict.atlas.sampler, gl.TEXTURE_MAG_FILTER, gl.LINEAR)
gl.SamplerParameteri(dict.atlas.sampler, gl.TEXTURE_WRAP_S, gl.REPEAT)
gl.SamplerParameteri(dict.atlas.sampler, gl.TEXTURE_WRAP_T, gl.REPEAT)
glerr = gl.GetError()
if glerr != 0 {
errChan <- fmt.Errorf("Gl Error on creating sampler: %v", glerr)
return
}
errChan <- nil
})
err = <-errChan
if err != nil {
return nil, err
}
return &dict, nil
}
func loadFont(img *image.RGBA, config *FontConfig) (f *Font, err error) {
f = new(Font)
f.config = config
// Resize image to next power-of-two.
img = Pow2Image(img).(*image.RGBA)
ib := img.Bounds()
f.textureWidth = float32(ib.Dx())
f.textureHeight = float32(ib.Dy())
for _, glyph := range config.Glyphs {
if glyph.Width > f.maxGlyphWidth {
f.maxGlyphWidth = glyph.Width
}
if glyph.Height > f.maxGlyphHeight {
f.maxGlyphHeight = glyph.Height
}
}
// save to disk for testing
if f.IsDebug {
file, err := os.Create("out.png")
if err != nil {
panic(err)
}
defer file.Close()
b := bufio.NewWriter(file)
err = png.Encode(b, img)
if err != nil {
panic(err)
}
err = b.Flush()
if err != nil {
panic(err)
}
}
// generate texture
gl.GenTextures(1, &f.textureID)
gl.BindTexture(gl.TEXTURE_2D, f.textureID)
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(ib.Dx()),
int32(ib.Dy()),
0,
gl.RGBA,
gl.UNSIGNED_BYTE,
gl.Ptr(img.Pix),
)
gl.BindTexture(gl.TEXTURE_2D, 0)
// create shader program and define attributes and uniforms
f.program, err = NewProgram(fontVertexShaderSource, fontFragmentShaderSource)
if err != nil {
return f, err
}
// attributes
f.centeredPosition = uint32(gl.GetAttribLocation(f.program, gl.Str("centered_position\x00")))
f.uv = uint32(gl.GetAttribLocation(f.program, gl.Str("uv\x00")))
// uniforms
f.finalPositionUniform = gl.GetUniformLocation(f.program, gl.Str("final_position\x00"))
f.orthographicMatrixUniform = gl.GetUniformLocation(f.program, gl.Str("orthographic_matrix\x00"))
f.scaleMatrixUniform = gl.GetUniformLocation(f.program, gl.Str("scale_matrix\x00"))
f.fragmentTextureUniform = gl.GetUniformLocation(f.program, gl.Str("fragment_texture\x00"))
f.colorUniform = gl.GetUniformLocation(f.program, gl.Str("fragment_color_adjustment\x00"))
return f, nil
}
func NewTexture() Texture {
var texture uint32
gl.GenTextures(1, &texture)
Check()
return Texture(texture)
}