ebiten/internal/opengl/context_js.go
2018-06-22 01:45:25 +09:00

465 lines
13 KiB
Go

// 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.
// +build js
package opengl
import (
"errors"
"fmt"
"github.com/hajimehoshi/gopherwasm/js"
"github.com/hajimehoshi/ebiten/internal/web"
)
type (
Texture js.Value
Framebuffer js.Value
Shader js.Value
Buffer js.Value
uniformLocation js.Value
attribLocation int
programID int
Program struct {
value js.Value
id programID
}
)
var InvalidTexture = Texture(js.Null)
func getProgramID(p Program) programID {
return p.id
}
var (
blend js.Value
clampToEdge js.Value
colorAttachment0 js.Value
compileStatus js.Value
framebuffer js.Value
framebufferBinding js.Value
framebufferComplete js.Value
linkStatus js.Value
maxTextureSize js.Value
nearest js.Value
noError js.Value
texture2d js.Value
textureMagFilter js.Value
textureMinFilter js.Value
textureWrapS js.Value
textureWrapT js.Value
rgba js.Value
unpackAlignment js.Value
unsignedByte js.Value
unsignedShort js.Value
)
func init() {
// Accessing the prototype is rquired on Safari.
c := js.Global.Get("WebGLRenderingContext").Get("prototype")
VertexShader = ShaderType(c.Get("VERTEX_SHADER").Int())
FragmentShader = ShaderType(c.Get("FRAGMENT_SHADER").Int())
ArrayBuffer = BufferType(c.Get("ARRAY_BUFFER").Int())
ElementArrayBuffer = BufferType(c.Get("ELEMENT_ARRAY_BUFFER").Int())
DynamicDraw = BufferUsage(c.Get("DYNAMIC_DRAW").Int())
Triangles = Mode(c.Get("TRIANGLES").Int())
Lines = Mode(c.Get("LINES").Int())
Short = DataType(c.Get("SHORT").Int())
Float = DataType(c.Get("FLOAT").Int())
zero = operation(c.Get("ZERO").Int())
one = operation(c.Get("ONE").Int())
srcAlpha = operation(c.Get("SRC_ALPHA").Int())
dstAlpha = operation(c.Get("DST_ALPHA").Int())
oneMinusSrcAlpha = operation(c.Get("ONE_MINUS_SRC_ALPHA").Int())
oneMinusDstAlpha = operation(c.Get("ONE_MINUS_DST_ALPHA").Int())
blend = c.Get("BLEND")
clampToEdge = c.Get("CLAMP_TO_EDGE")
compileStatus = c.Get("COMPILE_STATUS")
colorAttachment0 = c.Get("COLOR_ATTACHMENT0")
framebuffer = c.Get("FRAMEBUFFER")
framebufferBinding = c.Get("FRAMEBUFFER_BINDING")
framebufferComplete = c.Get("FRAMEBUFFER_COMPLETE")
linkStatus = c.Get("LINK_STATUS")
maxTextureSize = c.Get("MAX_TEXTURE_SIZE")
nearest = c.Get("NEAREST")
noError = c.Get("NO_ERROR")
rgba = c.Get("RGBA")
texture2d = c.Get("TEXTURE_2D")
textureMagFilter = c.Get("TEXTURE_MAG_FILTER")
textureMinFilter = c.Get("TEXTURE_MIN_FILTER")
textureWrapS = c.Get("TEXTURE_WRAP_S")
textureWrapT = c.Get("TEXTURE_WRAP_T")
unpackAlignment = c.Get("UNPACK_ALIGNMENT")
unsignedByte = c.Get("UNSIGNED_BYTE")
unsignedShort = c.Get("UNSIGNED_SHORT")
}
type context struct {
gl js.Value
loseContext js.Value
lastProgramID programID
}
func Init() error {
if web.IsNodeJS() {
return fmt.Errorf("opengl: Node.js is not supported")
}
if js.Global.Get("WebGLRenderingContext") == js.Undefined {
return fmt.Errorf("opengl: WebGL is not supported")
}
// TODO: Define id?
canvas := js.Global.Get("document").Call("querySelector", "canvas")
attr := js.Global.Get("Object").New()
attr.Set("alpha", true)
attr.Set("premultipliedAlpha", true)
gl := canvas.Call("getContext", "webgl", attr)
if gl == js.Null {
gl = canvas.Call("getContext", "experimental-webgl", attr)
if gl == js.Null {
return fmt.Errorf("opengl: getContext failed")
}
}
c := &Context{}
c.gl = gl
// Getting an extension might fail after the context is lost, so
// it is required to get the extension here.
c.loseContext = gl.Call("getExtension", "WEBGL_lose_context")
if c.loseContext != js.Null {
// This testing function name is temporary.
js.Global.Set("_ebiten_loseContextForTesting", js.NewCallback(func([]js.Value) {
c.loseContext.Call("loseContext")
}))
}
theContext = c
return nil
}
func (c *Context) Reset() error {
c.locationCache = newLocationCache()
c.lastTexture = Texture(js.Null)
c.lastFramebuffer = Framebuffer(js.Null)
c.lastViewportWidth = 0
c.lastViewportHeight = 0
c.lastCompositeMode = CompositeModeUnknown
gl := c.gl
gl.Call("enable", blend)
c.BlendFunc(CompositeModeSourceOver)
f := gl.Call("getParameter", framebufferBinding)
c.screenFramebuffer = Framebuffer(f)
return nil
}
func (c *Context) BlendFunc(mode CompositeMode) {
if c.lastCompositeMode == mode {
return
}
c.lastCompositeMode = mode
s, d := operations(mode)
gl := c.gl
gl.Call("blendFunc", int(s), int(d))
}
func (c *Context) NewTexture(width, height int) (Texture, error) {
gl := c.gl
t := gl.Call("createTexture")
if t == js.Null {
return Texture(js.Null), errors.New("opengl: glGenTexture failed")
}
gl.Call("pixelStorei", unpackAlignment, 4)
c.BindTexture(Texture(t))
gl.Call("texParameteri", texture2d, textureMagFilter, nearest)
gl.Call("texParameteri", texture2d, textureMinFilter, nearest)
gl.Call("texParameteri", texture2d, textureWrapS, clampToEdge)
gl.Call("texParameteri", texture2d, textureWrapT, clampToEdge)
// void texImage2D(GLenum target, GLint level, GLenum internalformat,
// GLsizei width, GLsizei height, GLint border, GLenum format,
// GLenum type, ArrayBufferView? pixels);
gl.Call("texImage2D", texture2d, 0, rgba, width, height, 0, rgba, unsignedByte, nil)
return Texture(t), nil
}
func (c *Context) bindFramebufferImpl(f Framebuffer) {
gl := c.gl
gl.Call("bindFramebuffer", framebuffer, js.Value(f))
}
func (c *Context) FramebufferPixels(f Framebuffer, width, height int) ([]byte, error) {
gl := c.gl
c.bindFramebuffer(f)
pixels := make([]byte, 4*width*height)
gl.Call("readPixels", 0, 0, width, height, rgba, unsignedByte, pixels)
if e := gl.Call("getError"); e.Int() != noError.Int() {
return nil, errors.New(fmt.Sprintf("opengl: error: %d", e))
}
return pixels, nil
}
func (c *Context) bindTextureImpl(t Texture) {
gl := c.gl
gl.Call("bindTexture", texture2d, js.Value(t))
}
func (c *Context) DeleteTexture(t Texture) {
gl := c.gl
if !gl.Call("isTexture", js.Value(t)).Bool() {
return
}
if c.lastTexture == t {
c.lastTexture = Texture(js.Null)
}
gl.Call("deleteTexture", js.Value(t))
}
func (c *Context) IsTexture(t Texture) bool {
gl := c.gl
return gl.Call("isTexture", js.Value(t)).Bool()
}
func (c *Context) TexSubImage2D(p []byte, x, y, width, height int) {
gl := c.gl
// void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
// GLsizei width, GLsizei height,
// GLenum format, GLenum type, ArrayBufferView? pixels);
gl.Call("texSubImage2D", texture2d, 0, x, y, width, height, rgba, unsignedByte, p)
}
func (c *Context) NewFramebuffer(t Texture) (Framebuffer, error) {
gl := c.gl
f := gl.Call("createFramebuffer")
c.bindFramebuffer(Framebuffer(f))
gl.Call("framebufferTexture2D", framebuffer, colorAttachment0, texture2d, js.Value(t), 0)
if s := gl.Call("checkFramebufferStatus", framebuffer); s.Int() != framebufferComplete.Int() {
return Framebuffer(js.Null), errors.New(fmt.Sprintf("opengl: creating framebuffer failed: %d", s.Int()))
}
return Framebuffer(f), nil
}
func (c *Context) setViewportImpl(width, height int) {
gl := c.gl
gl.Call("viewport", 0, 0, width, height)
}
func (c *Context) DeleteFramebuffer(f Framebuffer) {
gl := c.gl
if !gl.Call("isFramebuffer", js.Value(f)).Bool() {
return
}
// If a framebuffer to be deleted is bound, a newly bound framebuffer
// will be a default framebuffer.
// https://www.khronos.org/opengles/sdk/docs/man/xhtml/glDeleteFramebuffers.xml
if c.lastFramebuffer == f {
c.lastFramebuffer = Framebuffer(js.Null)
c.lastViewportWidth = 0
c.lastViewportHeight = 0
}
gl.Call("deleteFramebuffer", js.Value(f))
}
func (c *Context) NewShader(shaderType ShaderType, source string) (Shader, error) {
gl := c.gl
s := gl.Call("createShader", int(shaderType))
if s == js.Null {
return Shader(js.Null), fmt.Errorf("opengl: glCreateShader failed: shader type: %d", shaderType)
}
gl.Call("shaderSource", js.Value(s), source)
gl.Call("compileShader", js.Value(s))
if !gl.Call("getShaderParameter", js.Value(s), compileStatus).Bool() {
log := gl.Call("getShaderInfoLog", js.Value(s))
return Shader(js.Null), fmt.Errorf("opengl: shader compile failed: %s", log)
}
return Shader(s), nil
}
func (c *Context) DeleteShader(s Shader) {
gl := c.gl
gl.Call("deleteShader", js.Value(s))
}
func (c *Context) NewProgram(shaders []Shader) (Program, error) {
gl := c.gl
v := gl.Call("createProgram")
if v == js.Null {
return Program{}, errors.New("opengl: glCreateProgram failed")
}
for _, shader := range shaders {
gl.Call("attachShader", v, js.Value(shader))
}
gl.Call("linkProgram", v)
if !gl.Call("getProgramParameter", v, linkStatus).Bool() {
return Program{}, errors.New("opengl: program error")
}
id := c.lastProgramID
c.lastProgramID++
return Program{
value: v,
id: id,
}, nil
}
func (c *Context) UseProgram(p Program) {
gl := c.gl
gl.Call("useProgram", p.value)
}
func (c *Context) DeleteProgram(p Program) {
gl := c.gl
if !gl.Call("isProgram", p).Bool() {
return
}
gl.Call("deleteProgram", p)
}
func (c *Context) getUniformLocationImpl(p Program, location string) uniformLocation {
gl := c.gl
return uniformLocation(gl.Call("getUniformLocation", p.value, location))
}
func (c *Context) UniformInt(p Program, location string, v int) {
gl := c.gl
l := c.locationCache.GetUniformLocation(c, p, location)
gl.Call("uniform1i", js.Value(l), v)
}
func (c *Context) UniformFloat(p Program, location string, v float32) {
gl := c.gl
l := c.locationCache.GetUniformLocation(c, p, location)
gl.Call("uniform1f", js.Value(l), v)
}
var (
float32Array = js.Global.Get("Float32Array")
)
func (c *Context) UniformFloats(p Program, location string, v []float32) {
gl := c.gl
l := c.locationCache.GetUniformLocation(c, p, location)
switch len(v) {
case 2:
gl.Call("uniform2f", js.Value(l), v[0], v[1])
case 4:
gl.Call("uniform4f", js.Value(l), v[0], v[1], v[2], v[3])
case 16:
u8 := js.ValueOf(v)
m := float32Array.New(u8.Get("buffer"), u8.Get("byteOffset").Int(), 16)
gl.Call("uniformMatrix4fv", js.Value(l), false, m)
default:
panic("not reached")
}
}
func (c *Context) getAttribLocationImpl(p Program, location string) attribLocation {
gl := c.gl
return attribLocation(gl.Call("getAttribLocation", p.value, location).Int())
}
func (c *Context) VertexAttribPointer(p Program, location string, size int, dataType DataType, stride int, offset int) {
gl := c.gl
l := c.locationCache.GetAttribLocation(c, p, location)
gl.Call("vertexAttribPointer", int(l), size, int(dataType), false, stride, offset)
}
func (c *Context) EnableVertexAttribArray(p Program, location string) {
gl := c.gl
l := c.locationCache.GetAttribLocation(c, p, location)
gl.Call("enableVertexAttribArray", int(l))
}
func (c *Context) DisableVertexAttribArray(p Program, location string) {
gl := c.gl
l := c.locationCache.GetAttribLocation(c, p, location)
gl.Call("disableVertexAttribArray", int(l))
}
func (c *Context) NewArrayBuffer(size int) Buffer {
gl := c.gl
b := gl.Call("createBuffer")
gl.Call("bindBuffer", int(ArrayBuffer), js.Value(b))
gl.Call("bufferData", int(ArrayBuffer), size, int(DynamicDraw))
return Buffer(b)
}
func (c *Context) NewElementArrayBuffer(size int) Buffer {
gl := c.gl
b := gl.Call("createBuffer")
gl.Call("bindBuffer", int(ElementArrayBuffer), js.Value(b))
gl.Call("bufferData", int(ElementArrayBuffer), size, int(DynamicDraw))
return Buffer(b)
}
func (c *Context) BindBuffer(bufferType BufferType, b Buffer) {
gl := c.gl
gl.Call("bindBuffer", int(bufferType), js.Value(b))
}
func (c *Context) ArrayBufferSubData(data []float32) {
gl := c.gl
gl.Call("bufferSubData", int(ArrayBuffer), 0, js.ValueOf(data))
}
func (c *Context) ElementArrayBufferSubData(data []uint16) {
gl := c.gl
gl.Call("bufferSubData", int(ElementArrayBuffer), 0, js.ValueOf(data))
}
func (c *Context) DeleteBuffer(b Buffer) {
gl := c.gl
gl.Call("deleteBuffer", js.Value(b))
}
func (c *Context) DrawElements(mode Mode, len int, offsetInBytes int) {
gl := c.gl
gl.Call("drawElements", int(mode), len, unsignedShort, offsetInBytes)
}
func (c *Context) maxTextureSizeImpl() int {
gl := c.gl
return gl.Call("getParameter", maxTextureSize).Int()
}
func (c *Context) Flush() {
gl := c.gl
gl.Call("flush")
}
func (c *Context) IsContextLost() bool {
gl := c.gl
return gl.Call("isContextLost").Bool()
}
func (c *Context) RestoreContext() {
if c.loseContext != js.Null {
c.loseContext.Call("restoreContext")
}
}