ebiten/internal/opengl/program.go

357 lines
10 KiB
Go
Raw Normal View History

// Copyright 2014 Hajime Hoshi
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
2014-12-09 15:16:04 +01:00
package opengl
2013-10-26 18:56:58 +02:00
import (
"fmt"
"github.com/hajimehoshi/ebiten/internal/affine"
"github.com/hajimehoshi/ebiten/internal/graphics"
emath "github.com/hajimehoshi/ebiten/internal/math"
"github.com/hajimehoshi/ebiten/internal/web"
2015-01-17 04:45:19 +01:00
)
2017-09-24 15:56:50 +02:00
// arrayBufferLayoutPart is a part of an array buffer layout.
type arrayBufferLayoutPart struct {
2016-10-22 09:57:09 +02:00
// TODO: This struct should belong to a program and know it.
name string
dataType DataType
num int
}
2017-09-24 15:56:50 +02:00
// arrayBufferLayout is an array buffer layout.
//
// An array buffer in OpenGL is a buffer representing vertices and
// is passed to a vertex shader.
type arrayBufferLayout struct {
parts []arrayBufferLayoutPart
2016-10-28 18:07:19 +02:00
total int
}
2017-09-24 15:56:50 +02:00
// totalBytes returns the size in bytes for one element of the array buffer.
2016-10-28 18:07:19 +02:00
func (a *arrayBufferLayout) totalBytes() int {
if a.total != 0 {
return a.total
}
t := 0
for _, p := range a.parts {
t += p.dataType.SizeInBytes() * p.num
}
2016-10-28 18:07:19 +02:00
a.total = t
return a.total
}
2017-09-24 15:56:50 +02:00
// newArrayBuffer creates OpenGL's buffer object for the array buffer.
2018-10-29 17:52:59 +01:00
func (a *arrayBufferLayout) newArrayBuffer() buffer {
2018-10-29 17:31:09 +01:00
return GetContext().newArrayBuffer(a.totalBytes() * IndicesNum)
}
2017-09-24 15:56:50 +02:00
// enable binds the array buffer the given program to use the array buffer.
2018-10-29 17:52:59 +01:00
func (a *arrayBufferLayout) enable(program program) {
for _, p := range a.parts {
2018-10-29 17:31:09 +01:00
GetContext().enableVertexAttribArray(program, p.name)
}
2016-10-28 18:07:19 +02:00
total := a.totalBytes()
offset := 0
for _, p := range a.parts {
2018-10-29 17:31:09 +01:00
GetContext().vertexAttribPointer(program, p.name, p.num, p.dataType, total, offset)
offset += p.dataType.SizeInBytes() * p.num
}
}
2017-09-24 15:56:50 +02:00
// disable stops using the array buffer.
2018-10-29 17:52:59 +01:00
func (a *arrayBufferLayout) disable(program program) {
// TODO: Disabling should be done in reversed order?
for _, p := range a.parts {
2018-10-29 17:31:09 +01:00
GetContext().disableVertexAttribArray(program, p.name)
}
}
// theArrayBufferLayout is the array buffer layout for Ebiten.
var theArrayBufferLayout arrayBufferLayout
func initializeArrayBuferLayout() {
theArrayBufferLayout = arrayBufferLayout{
// Note that GL_MAX_VERTEX_ATTRIBS is at least 16.
parts: []arrayBufferLayoutPart{
{
name: "vertex",
dataType: Float,
num: 2,
},
{
name: "tex_coord",
dataType: Float,
num: 4,
},
{
name: "color_scale",
dataType: Float,
num: 4,
},
},
}
}
func ArrayBufferLayoutTotalBytes() int {
return theArrayBufferLayout.totalBytes()
}
2018-10-29 17:31:09 +01:00
// openGLState is a state for
type openGLState struct {
2017-09-24 15:56:50 +02:00
// arrayBuffer is OpenGL's array buffer (vertices data).
2018-10-29 17:52:59 +01:00
arrayBuffer buffer
2017-09-24 15:56:50 +02:00
// elementArrayBuffer is OpenGL's element array buffer (indices data).
2018-10-29 17:52:59 +01:00
elementArrayBuffer buffer
2017-09-24 15:56:50 +02:00
// programNearest is OpenGL's program for rendering a texture with nearest filter.
2018-10-29 17:52:59 +01:00
programNearest program
// programLinear is OpenGL's program for rendering a texture with linear filter.
2018-10-29 17:52:59 +01:00
programLinear program
2016-05-16 04:34:41 +02:00
2018-10-29 17:52:59 +01:00
programScreen program
2018-10-29 17:52:59 +01:00
lastProgram program
lastProjectionMatrix []float32
lastColorMatrix []float32
lastColorMatrixTranslation []float32
lastSourceWidth int
lastSourceHeight int
}
2013-10-26 18:56:58 +02:00
var (
2017-09-24 15:56:50 +02:00
// theOpenGLState is the OpenGL state in the current process.
theOpenGLState openGLState
2018-10-29 17:52:59 +01:00
zeroBuffer buffer
zeroProgram program
)
2013-10-26 18:56:58 +02:00
const (
IndicesNum = (1 << 16) / 3 * 3 // Adjust num for triangles.
maxTriangles = IndicesNum / 3
2018-06-02 18:43:10 +02:00
maxQuads = maxTriangles / 2
)
2015-01-13 15:03:37 +01:00
// Reset resets or initializes the current OpenGL state.
func Reset() error {
return theOpenGLState.reset()
}
2017-09-24 15:56:50 +02:00
// reset resets or initializes the OpenGL state.
func (s *openGLState) reset() error {
2018-10-29 18:18:10 +01:00
if err := GetContext().reset(); err != nil {
2016-08-01 19:23:23 +02:00
return err
}
s.lastProgram = zeroProgram
s.lastProjectionMatrix = nil
s.lastColorMatrix = nil
s.lastColorMatrixTranslation = nil
s.lastSourceWidth = 0
s.lastSourceHeight = 0
// When context lost happens, deleting programs or buffers is not necessary.
// However, it is not assumed that reset is called only when context lost happens.
// Let's delete them explicitly.
if s.programNearest != zeroProgram {
2018-10-29 17:31:09 +01:00
GetContext().deleteProgram(s.programNearest)
}
if s.programLinear != zeroProgram {
2018-10-29 17:31:09 +01:00
GetContext().deleteProgram(s.programLinear)
}
if s.programScreen != zeroProgram {
2018-10-29 17:31:09 +01:00
GetContext().deleteProgram(s.programScreen)
}
// On browsers (at least Chrome), buffers are already detached from the context
// and must not be deleted by DeleteBuffer.
if !web.IsBrowser() {
if s.arrayBuffer != zeroBuffer {
2018-10-29 17:31:09 +01:00
GetContext().deleteBuffer(s.arrayBuffer)
}
if s.elementArrayBuffer != zeroBuffer {
2018-10-29 17:31:09 +01:00
GetContext().deleteBuffer(s.elementArrayBuffer)
}
}
2018-10-30 14:41:05 +01:00
shaderVertexModelviewNative, err := GetContext().newShader(vertexShader, shaderStr(shaderVertexModelview))
2014-12-31 08:12:13 +01:00
if err != nil {
panic(fmt.Sprintf("graphics: shader compiling error:\n%s", err))
2013-10-26 18:56:58 +02:00
}
2018-10-29 17:31:09 +01:00
defer GetContext().deleteShader(shaderVertexModelviewNative)
2014-12-31 08:12:13 +01:00
2018-10-30 14:41:05 +01:00
shaderFragmentNearestNative, err := GetContext().newShader(fragmentShader, shaderStr(shaderFragmentNearest))
2014-12-31 08:12:13 +01:00
if err != nil {
panic(fmt.Sprintf("graphics: shader compiling error:\n%s", err))
2014-12-31 08:12:13 +01:00
}
2018-10-29 17:31:09 +01:00
defer GetContext().deleteShader(shaderFragmentNearestNative)
2013-10-26 18:56:58 +02:00
2018-10-30 14:41:05 +01:00
shaderFragmentLinearNative, err := GetContext().newShader(fragmentShader, shaderStr(shaderFragmentLinear))
if err != nil {
panic(fmt.Sprintf("graphics: shader compiling error:\n%s", err))
}
2018-10-29 17:31:09 +01:00
defer GetContext().deleteShader(shaderFragmentLinearNative)
2018-10-30 14:41:05 +01:00
shaderFragmentScreenNative, err := GetContext().newShader(fragmentShader, shaderStr(shaderFragmentScreen))
if err != nil {
panic(fmt.Sprintf("graphics: shader compiling error:\n%s", err))
}
2018-10-29 17:31:09 +01:00
defer GetContext().deleteShader(shaderFragmentScreenNative)
2018-10-29 17:52:59 +01:00
s.programNearest, err = GetContext().newProgram([]shader{
shaderVertexModelviewNative,
shaderFragmentNearestNative,
})
if err != nil {
return err
}
2018-10-29 17:52:59 +01:00
s.programLinear, err = GetContext().newProgram([]shader{
shaderVertexModelviewNative,
shaderFragmentLinearNative,
2015-01-12 12:47:49 +01:00
})
if err != nil {
return err
2014-12-31 08:48:25 +01:00
}
2015-01-12 12:47:49 +01:00
2018-10-29 17:52:59 +01:00
s.programScreen, err = GetContext().newProgram([]shader{
shaderVertexModelviewNative,
shaderFragmentScreenNative,
})
if err != nil {
return err
}
s.arrayBuffer = theArrayBufferLayout.newArrayBuffer()
2014-12-31 09:45:23 +01:00
// Note that the indices passed to NewElementArrayBuffer is not under GC management
// in opengl package due to unsafe-way.
// See NewElementArrayBuffer in context_mobile.go.
2018-10-29 17:31:09 +01:00
s.elementArrayBuffer = GetContext().newElementArrayBuffer(IndicesNum * 2)
2014-12-31 09:45:23 +01:00
return nil
2013-10-26 18:56:58 +02:00
}
2017-09-24 17:06:45 +02:00
// areSameFloat32Array returns a boolean indicating if a and b are deeply equal.
func areSameFloat32Array(a, b []float32) bool {
if len(a) != len(b) {
return false
}
for i := 0; i < len(a); i++ {
if a[i] != b[i] {
return false
}
}
return true
}
func BufferSubData(vertices []float32, indices []uint16) {
c := GetContext()
c.arrayBufferSubData(vertices)
c.elementArrayBufferSubData(indices)
}
func UseProgram(proj []float32, texture Texture, dstW, dstH, srcW, srcH int, colorM *affine.ColorM, filter graphics.Filter) {
theOpenGLState.useProgram(proj, texture, dstW, dstH, srcW, srcH, colorM, filter)
}
2017-09-24 17:06:45 +02:00
// useProgram uses the program (programTexture).
func (s *openGLState) useProgram(proj []float32, texture Texture, dstW, dstH, srcW, srcH int, colorM *affine.ColorM, filter graphics.Filter) {
c := GetContext()
2018-10-29 17:52:59 +01:00
var program program
switch filter {
case graphics.FilterNearest:
program = s.programNearest
case graphics.FilterLinear:
program = s.programLinear
case graphics.FilterScreen:
program = s.programScreen
default:
panic("not reached")
}
2017-09-24 17:06:45 +02:00
if s.lastProgram != program {
2018-10-29 17:31:09 +01:00
c.useProgram(program)
2017-09-24 17:06:45 +02:00
if s.lastProgram != zeroProgram {
theArrayBufferLayout.disable(s.lastProgram)
2016-05-29 16:04:20 +02:00
}
2017-09-24 17:06:45 +02:00
theArrayBufferLayout.enable(program)
if s.lastProgram == zeroProgram {
2018-10-30 15:57:40 +01:00
c.bindBuffer(arrayBuffer, s.arrayBuffer)
c.bindBuffer(elementArrayBuffer, s.elementArrayBuffer)
2018-10-29 17:31:09 +01:00
c.uniformInt(program, "texture", 0)
}
s.lastProgram = program
2017-09-24 17:06:45 +02:00
s.lastProjectionMatrix = nil
s.lastColorMatrix = nil
s.lastColorMatrixTranslation = nil
s.lastSourceWidth = 0
s.lastSourceHeight = 0
}
2015-01-17 04:45:19 +01:00
2017-09-24 17:06:45 +02:00
if !areSameFloat32Array(s.lastProjectionMatrix, proj) {
2018-10-29 17:31:09 +01:00
c.uniformFloats(program, "projection_matrix", proj)
2017-09-24 17:06:45 +02:00
if s.lastProjectionMatrix == nil {
s.lastProjectionMatrix = make([]float32, 16)
}
// (*framebuffer).projectionMatrix is always same for the same framebuffer.
// It's OK to hold the reference without copying.
s.lastProjectionMatrix = proj
}
2013-10-26 18:56:58 +02:00
esBody, esTranslate := colorM.UnsafeElements()
if !areSameFloat32Array(s.lastColorMatrix, esBody) {
2018-10-29 17:31:09 +01:00
c.uniformFloats(program, "color_matrix_body", esBody)
if s.lastColorMatrix == nil {
s.lastColorMatrix = make([]float32, 16)
}
// ColorM's elements are immutable. It's OK to hold the reference without copying.
s.lastColorMatrix = esBody
}
if !areSameFloat32Array(s.lastColorMatrixTranslation, esTranslate) {
2018-10-29 17:31:09 +01:00
c.uniformFloats(program, "color_matrix_translation", esTranslate)
if s.lastColorMatrixTranslation == nil {
s.lastColorMatrixTranslation = make([]float32, 4)
}
// ColorM's elements are immutable. It's OK to hold the reference without copying.
s.lastColorMatrixTranslation = esTranslate
}
sw := emath.NextPowerOf2Int(srcW)
sh := emath.NextPowerOf2Int(srcH)
if s.lastSourceWidth != sw || s.lastSourceHeight != sh {
2018-10-29 17:31:09 +01:00
c.uniformFloats(program, "source_size", []float32{float32(sw), float32(sh)})
s.lastSourceWidth = sw
s.lastSourceHeight = sh
}
if program == s.programScreen {
scale := float32(dstW) / float32(srcW)
2018-10-29 17:31:09 +01:00
c.uniformFloat(program, "scale", scale)
}
// We don't have to call gl.ActiveTexture here: GL_TEXTURE0 is the default active texture
// See also: https://www.opengl.org/sdk/docs/man2/xhtml/glActiveTexture.xml
c.BindTexture(texture)
2016-02-06 21:13:54 +01:00
}