ebiten/internal/graphicscommand/command.go

610 lines
17 KiB
Go
Raw Normal View History

2016-06-02 19:34:34 +02:00
// Copyright 2016 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.
2018-10-28 12:10:05 +01:00
package graphicscommand
2016-06-02 19:34:34 +02:00
import (
"fmt"
"math"
2016-06-02 19:34:34 +02:00
"github.com/hajimehoshi/ebiten/internal/affine"
"github.com/hajimehoshi/ebiten/internal/driver"
"github.com/hajimehoshi/ebiten/internal/graphics"
2016-06-02 19:34:34 +02:00
)
var theGraphicsDriver driver.Graphics
func SetGraphicsDriver(driver driver.Graphics) {
theGraphicsDriver = driver
}
2019-05-26 12:08:46 +02:00
func NeedsRestoring() bool {
if theGraphicsDriver == nil {
// This happens on initialization.
// Return true for fail-safe
return true
}
2019-05-26 12:08:46 +02:00
return theGraphicsDriver.NeedsRestoring()
}
2017-09-11 20:12:17 +02:00
// command represents a drawing command.
//
// A command for drawing that is created when Image functions are called like DrawTriangles,
2017-09-11 20:12:17 +02:00
// or Fill.
// A command is not immediately executed after created. Instaed, it is queued after created,
// and executed only when necessary.
2016-06-02 19:34:34 +02:00
type command interface {
fmt.Stringer
Exec(indexOffset int) error
NumVertices() int
2018-06-10 10:06:40 +02:00
NumIndices() int
2018-03-18 11:58:32 +01:00
AddNumVertices(n int)
2018-06-10 10:06:40 +02:00
AddNumIndices(n int)
CanMerge(dst, src *Image, color *affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address) bool
2016-06-02 19:34:34 +02:00
}
type size struct {
width float32
height float32
}
2017-09-16 08:49:29 +02:00
// commandQueue is a command queue for drawing commands.
2016-06-02 19:34:34 +02:00
type commandQueue struct {
2017-09-18 18:37:24 +02:00
// commands is a queue of drawing commands.
commands []command
// vertices represents a vertices data in OpenGL's array buffer.
vertices []float32
// nvertices represents the current length of vertices.
// nvertices must <= len(vertices).
2017-09-18 18:37:24 +02:00
// vertices is never shrunk since re-extending a vertices buffer is heavy.
2018-06-10 10:10:11 +02:00
//
// TODO: This is a number of float32 values, not a number of vertices.
// Rename or fix the program.
nvertices int
srcSizes []size
2018-06-10 10:06:40 +02:00
indices []uint16
nindices int
2018-06-10 10:06:40 +02:00
tmpNumIndices int
nextIndex int
err error
2016-06-02 19:34:34 +02:00
}
2017-09-16 08:49:29 +02:00
// theCommandQueue is the command queue for the current process.
var theCommandQueue = &commandQueue{}
2017-09-18 18:37:24 +02:00
// appendVertices appends vertices to the queue.
func (q *commandQueue) appendVertices(vertices []float32, width, height float32) {
if len(q.vertices) < q.nvertices+len(vertices) {
n := q.nvertices + len(vertices) - len(q.vertices)
q.vertices = append(q.vertices, make([]float32, n)...)
q.srcSizes = append(q.srcSizes, make([]size, n/graphics.VertexFloatNum)...)
}
copy(q.vertices[q.nvertices:], vertices)
for i := 0; i < len(vertices)/graphics.VertexFloatNum; i++ {
idx := q.nvertices/graphics.VertexFloatNum + i
q.srcSizes[idx].width = width
q.srcSizes[idx].height = height
}
q.nvertices += len(vertices)
2016-06-02 19:34:34 +02:00
}
2018-06-10 10:06:40 +02:00
func (q *commandQueue) appendIndices(indices []uint16, offset uint16) {
if len(q.indices) < q.nindices+len(indices) {
n := q.nindices + len(indices) - len(q.indices)
q.indices = append(q.indices, make([]uint16, n)...)
}
for i := range indices {
2018-06-10 10:06:40 +02:00
q.indices[q.nindices+i] = indices[i] + offset
}
2018-06-10 10:06:40 +02:00
q.nindices += len(indices)
}
func (q *commandQueue) doEnqueueDrawTrianglesCommand(dst, src *Image, nvertices, nindices int, color *affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address, forceNewCommand bool) {
if nindices > graphics.IndicesNum {
panic(fmt.Sprintf("graphicscommand: nindices must be <= graphics.IndicesNum but not at doEnqueueDrawTrianglesCommand: nindices: %d, graphics.IndicesNum: %d", nindices, graphics.IndicesNum))
}
if !forceNewCommand && 0 < len(q.commands) {
if last := q.commands[len(q.commands)-1]; last.CanMerge(dst, src, color, mode, filter, address) {
last.AddNumVertices(nvertices)
2018-06-10 10:06:40 +02:00
last.AddNumIndices(nindices)
return
}
}
c := &drawTrianglesCommand{
dst: dst,
src: src,
nvertices: nvertices,
2018-06-10 10:06:40 +02:00
nindices: nindices,
color: color,
mode: mode,
filter: filter,
address: address,
}
q.commands = append(q.commands, c)
}
// EnqueueDrawTrianglesCommand enqueues a drawing-image command.
func (q *commandQueue) EnqueueDrawTrianglesCommand(dst, src *Image, vertices []float32, indices []uint16, color *affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address) {
if len(indices) > graphics.IndicesNum {
panic(fmt.Sprintf("graphicscommand: len(indices) must be <= graphics.IndicesNum but not at EnqueueDrawTrianglesCommand: len(indices): %d, graphics.IndicesNum: %d", len(indices), graphics.IndicesNum))
}
split := false
if q.tmpNumIndices+len(indices) > graphics.IndicesNum {
2018-06-10 10:06:40 +02:00
q.tmpNumIndices = 0
q.nextIndex = 0
split = true
}
n := len(vertices) / graphics.VertexFloatNum
q.appendVertices(vertices, float32(graphics.InternalImageSize(src.width)), float32(graphics.InternalImageSize(src.height)))
2018-06-10 10:06:40 +02:00
q.appendIndices(indices, uint16(q.nextIndex))
q.nextIndex += n
2018-06-10 10:06:40 +02:00
q.tmpNumIndices += len(indices)
// TODO: If dst is the screen, reorder the command to be the last.
q.doEnqueueDrawTrianglesCommand(dst, src, len(vertices), len(indices), color, mode, filter, address, split)
}
// Enqueue enqueues a drawing command other than a draw-triangles command.
2017-09-19 18:35:56 +02:00
//
// For a draw-triangles command, use EnqueueDrawTrianglesCommand.
func (q *commandQueue) Enqueue(command command) {
// TODO: If dst is the screen, reorder the command to be the last.
q.commands = append(q.commands, command)
}
func fract(x float32) float32 {
return x - float32(math.Floor(float64(x)))
}
2017-09-19 18:35:56 +02:00
// Flush flushes the command queue.
func (q *commandQueue) Flush() {
if q.err != nil {
return
}
2018-06-10 10:06:40 +02:00
es := q.indices
vs := q.vertices
if recordLog() {
fmt.Println("--")
}
if theGraphicsDriver.HasHighPrecisionFloat() {
const dstAdjustmentFactor = 1.0 / 256.0
const texelAdjustmentFactor = 1.0 / 512.0
for i := 0; i < q.nvertices/graphics.VertexFloatNum; i++ {
s := q.srcSizes[i]
// Convert pixels to texels.
vs[i*graphics.VertexFloatNum+2] /= s.width
vs[i*graphics.VertexFloatNum+3] /= s.height
vs[i*graphics.VertexFloatNum+4] /= s.width
vs[i*graphics.VertexFloatNum+5] /= s.height
vs[i*graphics.VertexFloatNum+6] /= s.width
vs[i*graphics.VertexFloatNum+7] /= s.height
// Adjust the destination position to avoid jaggy (#929).
// This is not a perfect solution since texels on a texture can take a position on borders
// which can cause jaggy. But adjusting only edges should work in most cases.
// The ideal solution is to fix shaders, but this makes the applications slow by adding 'if'
// branches.
switch f := fract(vs[i*graphics.VertexFloatNum+0]); {
case 0.5-dstAdjustmentFactor <= f && f < 0.5:
vs[i*graphics.VertexFloatNum+0] -= f - (0.5 - dstAdjustmentFactor)
case 0.5 <= f && f < 0.5+dstAdjustmentFactor:
vs[i*graphics.VertexFloatNum+0] += (0.5 + dstAdjustmentFactor) - f
}
switch f := fract(vs[i*graphics.VertexFloatNum+1]); {
case 0.5-dstAdjustmentFactor <= f && f < 0.5:
vs[i*graphics.VertexFloatNum+1] -= f - (0.5 - dstAdjustmentFactor)
case 0.5 <= f && f < 0.5+dstAdjustmentFactor:
vs[i*graphics.VertexFloatNum+1] += (0.5 + dstAdjustmentFactor) - f
}
// Adjust regions not to violate neighborhoods (#317, #558, #724).
vs[i*graphics.VertexFloatNum+6] -= 1.0 / s.width * texelAdjustmentFactor
vs[i*graphics.VertexFloatNum+7] -= 1.0 / s.height * texelAdjustmentFactor
}
}
theGraphicsDriver.Begin()
for len(q.commands) > 0 {
nv := 0
ne := 0
nc := 0
for _, c := range q.commands {
if c.NumIndices() > graphics.IndicesNum {
2019-02-07 09:19:24 +01:00
panic(fmt.Sprintf("graphicscommand: c.NumIndices() must be <= graphics.IndicesNum but not at Flush: c.NumIndices(): %d, graphics.IndicesNum: %d", c.NumIndices(), graphics.IndicesNum))
}
if ne+c.NumIndices() > graphics.IndicesNum {
break
}
nv += c.NumVertices()
2018-06-10 10:06:40 +02:00
ne += c.NumIndices()
nc++
}
if 0 < ne {
theGraphicsDriver.SetVertices(vs[:nv], es[:ne])
es = es[ne:]
vs = vs[nv:]
}
indexOffset := 0
for _, c := range q.commands[:nc] {
if err := c.Exec(indexOffset); err != nil {
q.err = err
return
}
if recordLog() {
fmt.Printf("%s\n", c)
}
// TODO: indexOffset should be reset if the command type is different
2018-05-27 17:49:16 +02:00
// from the previous one. This fix is needed when another drawing command is
// introduced than drawTrianglesCommand.
indexOffset += c.NumIndices()
}
if 0 < nc {
// Call glFlush to prevent black flicking (especially on Android (#226) and iOS).
theGraphicsDriver.Flush()
}
q.commands = q.commands[nc:]
2016-06-02 19:34:34 +02:00
}
theGraphicsDriver.End()
q.commands = nil
q.nvertices = 0
2018-06-10 10:06:40 +02:00
q.nindices = 0
q.tmpNumIndices = 0
q.nextIndex = 0
}
// Error returns an OpenGL error for the last command.
func Error() error {
return theCommandQueue.err
2016-06-02 19:34:34 +02:00
}
2017-09-19 18:35:56 +02:00
// FlushCommands flushes the command queue.
func FlushCommands() {
theCommandQueue.Flush()
2016-06-10 22:48:09 +02:00
}
// drawTrianglesCommand represents a drawing command to draw an image on another image.
type drawTrianglesCommand struct {
dst *Image
src *Image
nvertices int
2018-06-10 10:06:40 +02:00
nindices int
color *affine.ColorM
mode driver.CompositeMode
filter driver.Filter
address driver.Address
2016-06-02 19:34:34 +02:00
}
func (c *drawTrianglesCommand) String() string {
mode := ""
switch c.mode {
case driver.CompositeModeSourceOver:
mode = "source-over"
case driver.CompositeModeClear:
mode = "clear"
case driver.CompositeModeCopy:
mode = "copy"
case driver.CompositeModeDestination:
mode = "destination"
case driver.CompositeModeDestinationOver:
mode = "destination-over"
case driver.CompositeModeSourceIn:
mode = "source-in"
case driver.CompositeModeDestinationIn:
mode = "destination-in"
case driver.CompositeModeSourceOut:
mode = "source-out"
case driver.CompositeModeDestinationOut:
mode = "destination-out"
case driver.CompositeModeSourceAtop:
mode = "source-atop"
case driver.CompositeModeDestinationAtop:
mode = "destination-atop"
case driver.CompositeModeXor:
mode = "xor"
case driver.CompositeModeLighter:
mode = "lighter"
default:
panic(fmt.Sprintf("graphicscommand: invalid composite mode: %d", c.mode))
}
filter := ""
switch c.filter {
case driver.FilterNearest:
filter = "nearest"
case driver.FilterLinear:
filter = "linear"
case driver.FilterScreen:
filter = "screen"
default:
panic(fmt.Sprintf("graphicscommand: invalid filter: %d", c.filter))
}
address := ""
switch c.address {
case driver.AddressClampToZero:
address = "clamp_to_zero"
case driver.AddressRepeat:
address = "repeat"
default:
panic(fmt.Sprintf("graphicscommand: invalid address: %d", c.address))
}
dst := fmt.Sprintf("%d", c.dst.id)
if c.dst.screen {
dst += " (screen)"
}
src := fmt.Sprintf("%d", c.src.id)
if c.src.screen {
src += " (screen)"
}
return fmt.Sprintf("draw-triangles: dst: %s <- src: %s, colorm: %v, mode %s, filter: %s, address: %s", dst, src, c.color, mode, filter, address)
}
// Exec executes the drawTrianglesCommand.
func (c *drawTrianglesCommand) Exec(indexOffset int) error {
// TODO: Is it ok not to bind any framebuffer here?
2018-06-10 10:06:40 +02:00
if c.nindices == 0 {
return nil
}
c.dst.image.SetAsDestination()
c.src.image.SetAsSource()
if err := theGraphicsDriver.Draw(c.nindices, indexOffset, c.mode, c.color, c.filter, c.address); err != nil {
return err
}
return nil
2016-06-02 19:34:34 +02:00
}
func (c *drawTrianglesCommand) NumVertices() int {
return c.nvertices
}
func (c *drawTrianglesCommand) NumIndices() int {
2018-06-10 10:06:40 +02:00
return c.nindices
}
func (c *drawTrianglesCommand) AddNumVertices(n int) {
2018-03-18 11:58:32 +01:00
c.nvertices += n
}
func (c *drawTrianglesCommand) AddNumIndices(n int) {
2018-06-10 10:06:40 +02:00
c.nindices += n
}
// CanMerge returns a boolean value indicating whether the other drawTrianglesCommand can be merged
// with the drawTrianglesCommand c.
func (c *drawTrianglesCommand) CanMerge(dst, src *Image, color *affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address) bool {
if c.dst != dst {
return false
}
if c.src != src {
return false
}
if !c.color.Equals(color) {
return false
}
if c.mode != mode {
return false
}
if c.filter != filter {
return false
}
if c.address != address {
return false
}
return true
}
2017-09-19 18:35:56 +02:00
// replacePixelsCommand represents a command to replace pixels of an image.
2016-06-02 19:34:34 +02:00
type replacePixelsCommand struct {
dst *Image
2018-01-28 14:40:36 +01:00
pixels []byte
x int
y int
width int
height int
2016-06-02 19:34:34 +02:00
}
func (c *replacePixelsCommand) String() string {
return fmt.Sprintf("replace-pixels: dst: %d, x: %d, y: %d, width: %d, height: %d", c.dst.id, c.x, c.y, c.width, c.height)
}
2017-09-19 18:35:56 +02:00
// Exec executes the replacePixelsCommand.
func (c *replacePixelsCommand) Exec(indexOffset int) error {
c.dst.image.ReplacePixels(c.pixels, c.x, c.y, c.width, c.height)
2016-06-02 19:34:34 +02:00
return nil
}
2016-06-11 15:52:07 +02:00
func (c *replacePixelsCommand) NumVertices() int {
return 0
}
2018-06-10 10:06:40 +02:00
func (c *replacePixelsCommand) NumIndices() int {
return 0
}
2018-03-18 11:58:32 +01:00
func (c *replacePixelsCommand) AddNumVertices(n int) {
}
2018-06-10 10:06:40 +02:00
func (c *replacePixelsCommand) AddNumIndices(n int) {
}
func (c *replacePixelsCommand) CanMerge(dst, src *Image, color *affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address) bool {
2018-03-18 11:58:32 +01:00
return false
}
type pixelsCommand struct {
result []byte
img *Image
}
// Exec executes a pixelsCommand.
func (c *pixelsCommand) Exec(indexOffset int) error {
p, err := c.img.image.Pixels()
if err != nil {
return err
}
c.result = p
return nil
}
func (c *pixelsCommand) String() string {
return fmt.Sprintf("pixels: image: %d", c.img.id)
}
func (c *pixelsCommand) NumVertices() int {
return 0
}
func (c *pixelsCommand) NumIndices() int {
return 0
}
func (c *pixelsCommand) AddNumVertices(n int) {
}
func (c *pixelsCommand) AddNumIndices(n int) {
}
func (c *pixelsCommand) CanMerge(dst, src *Image, color *affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address) bool {
return false
}
2017-09-19 18:35:56 +02:00
// disposeCommand represents a command to dispose an image.
2016-06-11 15:52:07 +02:00
type disposeCommand struct {
target *Image
2016-06-11 15:52:07 +02:00
}
func (c *disposeCommand) String() string {
return fmt.Sprintf("dispose: target: %d", c.target.id)
}
2017-09-19 18:35:56 +02:00
// Exec executes the disposeCommand.
func (c *disposeCommand) Exec(indexOffset int) error {
c.target.image.Dispose()
2016-06-11 15:52:07 +02:00
return nil
}
func (c *disposeCommand) NumVertices() int {
return 0
}
2018-06-10 10:06:40 +02:00
func (c *disposeCommand) NumIndices() int {
return 0
}
2018-03-18 11:58:32 +01:00
func (c *disposeCommand) AddNumVertices(n int) {
}
2018-06-10 10:06:40 +02:00
func (c *disposeCommand) AddNumIndices(n int) {
}
func (c *disposeCommand) CanMerge(dst, src *Image, color *affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address) bool {
2018-03-18 11:58:32 +01:00
return false
}
2017-09-19 18:35:56 +02:00
// newImageCommand represents a command to create an empty image with given width and height.
type newImageCommand struct {
result *Image
width int
height int
}
func (c *newImageCommand) String() string {
return fmt.Sprintf("new-image: result: %d, width: %d, height: %d", c.result.id, c.width, c.height)
}
2017-09-19 18:35:56 +02:00
// Exec executes a newImageCommand.
func (c *newImageCommand) Exec(indexOffset int) error {
i, err := theGraphicsDriver.NewImage(c.width, c.height)
if err != nil {
return err
}
2018-11-04 11:36:33 +01:00
c.result.image = i
return nil
}
func (c *newImageCommand) NumVertices() int {
return 0
}
2018-06-10 10:06:40 +02:00
func (c *newImageCommand) NumIndices() int {
return 0
}
2018-03-18 11:58:32 +01:00
func (c *newImageCommand) AddNumVertices(n int) {
}
2018-06-10 10:06:40 +02:00
func (c *newImageCommand) AddNumIndices(n int) {
}
func (c *newImageCommand) CanMerge(dst, src *Image, color *affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address) bool {
2018-03-18 11:58:32 +01:00
return false
}
2017-09-19 18:35:56 +02:00
// newScreenFramebufferImageCommand is a command to create a special image for the screen.
type newScreenFramebufferImageCommand struct {
result *Image
width int
height int
}
func (c *newScreenFramebufferImageCommand) String() string {
return fmt.Sprintf("new-screen-framebuffer-image: result: %d, width: %d, height: %d", c.result.id, c.width, c.height)
}
2017-09-19 18:35:56 +02:00
// Exec executes a newScreenFramebufferImageCommand.
func (c *newScreenFramebufferImageCommand) Exec(indexOffset int) error {
2018-11-11 15:57:23 +01:00
var err error
c.result.image, err = theGraphicsDriver.NewScreenFramebufferImage(c.width, c.height)
2018-11-11 15:57:23 +01:00
return err
}
func (c *newScreenFramebufferImageCommand) NumVertices() int {
return 0
}
2018-03-18 11:58:32 +01:00
2018-06-10 10:06:40 +02:00
func (c *newScreenFramebufferImageCommand) NumIndices() int {
return 0
}
2018-03-18 11:58:32 +01:00
func (c *newScreenFramebufferImageCommand) AddNumVertices(n int) {
}
2018-06-10 10:06:40 +02:00
func (c *newScreenFramebufferImageCommand) AddNumIndices(n int) {
}
func (c *newScreenFramebufferImageCommand) CanMerge(dst, src *Image, color *affine.ColorM, mode driver.CompositeMode, filter driver.Filter, address driver.Address) bool {
2018-03-18 11:58:32 +01:00
return false
}
// ResetGraphicsDriverState resets or initializes the current graphics driver state.
func ResetGraphicsDriverState() error {
return theGraphicsDriver.Reset()
}