ebiten/internal/affine/colorm.go

298 lines
7.0 KiB
Go
Raw Normal View History

2016-10-31 16:13:19 +01:00
// 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.
package affine
import (
2017-10-14 16:58:09 +02:00
"image/color"
2016-10-31 16:13:19 +01:00
"math"
)
// ColorMDim is a dimension of a ColorM.
const ColorMDim = 5
2017-01-19 16:37:51 +01:00
var (
2018-02-19 16:33:56 +01:00
colorMIdentityBody = []float32{
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1,
}
2018-02-19 16:33:56 +01:00
colorMIdentityTranslate = []float32{
0, 0, 0, 0,
2017-01-17 18:23:52 +01:00
}
2017-01-19 16:37:51 +01:00
)
2017-01-17 18:23:52 +01:00
2016-10-31 16:13:19 +01:00
// A ColorM represents a matrix to transform coloring when rendering an image.
//
// A ColorM is applied to the source alpha color
// while an Image's pixels' format is alpha premultiplied.
// Before applying a matrix, a color is un-multiplied, and after applying the matrix,
// the color is multiplied again.
//
// The initial value is identity.
type ColorM struct {
2017-01-19 16:37:51 +01:00
// When elements is nil, this matrix is identity.
// elements are immutable and a new array must be created when updating.
body []float32
2018-02-19 16:33:56 +01:00
translate []float32
2016-10-31 16:13:19 +01:00
}
2017-05-25 15:50:47 +02:00
func (c *ColorM) Reset() {
c.body = nil
c.translate = nil
2017-05-25 15:50:47 +02:00
}
2018-02-19 16:33:56 +01:00
func clamp(x float32) float32 {
2017-10-14 16:58:09 +02:00
if x > 1 {
return 1
}
if x < 0 {
return 0
}
return x
}
func (c *ColorM) Apply(clr color.Color) color.Color {
if c.body == nil {
2017-10-14 16:58:09 +02:00
return clr
}
r, g, b, a := clr.RGBA()
if a == 0 {
return color.Transparent
}
// Unmultiply alpha
2018-02-19 16:33:56 +01:00
rf := float32(r) / float32(a)
gf := float32(g) / float32(a)
bf := float32(b) / float32(a)
af := float32(a) / 0xffff
eb := c.body
et := c.translate
rf2 := eb[0]*rf + eb[4]*gf + eb[8]*bf + eb[12]*af + et[0]
gf2 := eb[1]*rf + eb[5]*gf + eb[9]*bf + eb[13]*af + et[1]
bf2 := eb[2]*rf + eb[6]*gf + eb[10]*bf + eb[14]*af + et[2]
af2 := eb[3]*rf + eb[7]*gf + eb[11]*bf + eb[15]*af + et[3]
2017-10-14 16:58:09 +02:00
rf2 = clamp(rf2)
gf2 = clamp(gf2)
bf2 = clamp(bf2)
af2 = clamp(af2)
return color.NRGBA64{
R: uint16(rf2 * 0xffff),
G: uint16(gf2 * 0xffff),
B: uint16(bf2 * 0xffff),
A: uint16(af2 * 0xffff),
}
}
2018-02-19 16:33:56 +01:00
func (c *ColorM) UnsafeElements() ([]float32, []float32) {
if c.body == nil {
c.body = colorMIdentityBody
c.translate = colorMIdentityTranslate
2017-01-19 16:37:51 +01:00
}
return c.body, c.translate
2017-01-19 04:07:31 +01:00
}
2017-01-18 18:29:49 +01:00
// SetElement sets an element at (i, j).
2018-02-19 16:33:56 +01:00
func (c *ColorM) SetElement(i, j int, element float32) {
if c.body == nil {
c.body = colorMIdentityBody
c.translate = colorMIdentityTranslate
}
if j < (ColorMDim - 1) {
2018-02-19 16:33:56 +01:00
es := make([]float32, len(c.body))
copy(es, c.body)
es[i+j*(ColorMDim-1)] = element
c.body = es
} else {
2018-02-19 16:33:56 +01:00
es := make([]float32, len(c.translate))
copy(es, c.translate)
es[i] = element
c.translate = es
2017-01-19 16:37:51 +01:00
}
2017-01-18 18:29:49 +01:00
}
2016-10-31 16:28:07 +01:00
func (c *ColorM) Equals(other *ColorM) bool {
if c.body == nil {
if other.body == nil {
2017-01-19 16:37:51 +01:00
return true
}
c.body = colorMIdentityBody
c.translate = colorMIdentityTranslate
}
if other.body == nil {
other.body = colorMIdentityBody
other.translate = colorMIdentityTranslate
2017-01-19 16:37:51 +01:00
}
for i := range c.body {
if c.body[i] != other.body[i] {
return false
}
2016-10-31 16:28:07 +01:00
}
for i := range c.translate {
if c.translate[i] != other.translate[i] {
2017-01-19 16:37:51 +01:00
return false
}
2016-10-31 16:28:07 +01:00
}
2017-01-19 16:37:51 +01:00
return true
2016-10-31 16:28:07 +01:00
}
2016-10-31 16:13:19 +01:00
// Concat multiplies a color matrix with the other color matrix.
// This is same as muptiplying the matrix other and the matrix c in this order.
2017-05-23 04:30:54 +02:00
func (c *ColorM) Concat(other *ColorM) {
if c.body == nil {
c.body = colorMIdentityBody
c.translate = colorMIdentityTranslate
}
if other.body == nil {
other.body = colorMIdentityBody
other.translate = colorMIdentityTranslate
2017-01-19 16:46:25 +01:00
}
// TODO: This is a temporary hack to calculate multiply of transposed matrices.
// Fix mulSquare implmentation and swap the arguments.
c.body = mulSquare(c.body, other.body, ColorMDim-1)
lhsb := other.body
lhst := other.translate
rhst := c.translate
2018-02-19 16:33:56 +01:00
c.translate = []float32{
lhsb[0]*rhst[0] + lhsb[4]*rhst[1] + lhsb[8]*rhst[2] + lhsb[12]*rhst[3] + lhst[0],
lhsb[1]*rhst[0] + lhsb[5]*rhst[1] + lhsb[9]*rhst[2] + lhsb[13]*rhst[3] + lhst[1],
lhsb[2]*rhst[0] + lhsb[6]*rhst[1] + lhsb[10]*rhst[2] + lhsb[14]*rhst[3] + lhst[2],
lhsb[3]*rhst[0] + lhsb[7]*rhst[1] + lhsb[11]*rhst[2] + lhsb[15]*rhst[3] + lhst[3],
2017-01-19 16:46:25 +01:00
}
2016-10-31 16:13:19 +01:00
}
2017-01-18 18:29:49 +01:00
// Add is deprecated.
2016-10-31 16:13:19 +01:00
func (c *ColorM) Add(other ColorM) {
// Implementation is just for backward compatibility.
if c.body == nil {
c.body = colorMIdentityBody
c.translate = colorMIdentityTranslate
}
if other.body == nil {
other.body = colorMIdentityBody
other.translate = colorMIdentityTranslate
}
2018-02-19 16:33:56 +01:00
body := make([]float32, len(c.body))
for i := range c.body {
body[i] = c.body[i] + other.body[i]
}
2018-02-19 16:33:56 +01:00
translate := make([]float32, len(c.translate))
for i := range c.translate {
translate[i] = c.translate[i] + other.translate[i]
}
c.body = body
c.translate = translate
2016-10-31 16:13:19 +01:00
}
// Scale scales the matrix by (r, g, b, a).
2018-02-19 16:33:56 +01:00
func (c *ColorM) Scale(r, g, b, a float32) {
if c.body == nil {
2018-02-19 16:33:56 +01:00
c.body = []float32{
r, 0, 0, 0,
0, g, 0, 0,
0, 0, b, 0,
0, 0, 0, a,
2017-01-19 16:59:33 +01:00
}
c.translate = colorMIdentityTranslate
2017-01-19 16:59:33 +01:00
return
2017-01-19 16:37:51 +01:00
}
2018-02-19 16:33:56 +01:00
es := make([]float32, len(c.body))
copy(es, c.body)
for i := 0; i < ColorMDim-1; i++ {
es[i*(ColorMDim-1)] *= r
es[i*(ColorMDim-1)+1] *= g
es[i*(ColorMDim-1)+2] *= b
es[i*(ColorMDim-1)+3] *= a
}
c.body = es
2018-02-19 16:33:56 +01:00
c.translate = []float32{
c.translate[0] * r,
c.translate[1] * g,
c.translate[2] * b,
c.translate[3] * a,
2016-10-31 16:13:19 +01:00
}
}
// Translate translates the matrix by (r, g, b, a).
2018-02-19 16:33:56 +01:00
func (c *ColorM) Translate(r, g, b, a float32) {
if c.body == nil {
c.body = colorMIdentityBody
2018-02-19 16:33:56 +01:00
c.translate = []float32{r, g, b, a}
2017-01-19 16:59:33 +01:00
return
2017-01-19 16:37:51 +01:00
}
2018-02-19 16:33:56 +01:00
es := make([]float32, len(c.translate))
copy(es, c.translate)
es[0] += r
es[1] += g
es[2] += b
es[3] += a
c.translate = es
2016-10-31 16:13:19 +01:00
}
var (
// The YCbCr value ranges are:
// Y: [ 0 - 1 ]
// Cb: [-0.5 - 0.5]
// Cr: [-0.5 - 0.5]
rgbToYCbCr = ColorM{
2018-02-19 16:33:56 +01:00
body: []float32{
0.2990, -0.1687, 0.5000, 0,
0.5870, -0.3313, -0.4187, 0,
0.1140, 0.5000, -0.0813, 0,
0, 0, 0, 1,
2017-01-19 16:37:51 +01:00
},
2018-02-19 16:33:56 +01:00
translate: []float32{0, 0, 0, 0},
2016-10-31 16:13:19 +01:00
}
yCbCrToRgb = ColorM{
2018-02-19 16:33:56 +01:00
body: []float32{
1, 1, 1, 0,
0, -0.34414, 1.77200, 0,
1.40200, -0.71414, 0, 0,
0, 0, 0, 1,
2017-01-19 16:37:51 +01:00
},
2018-02-19 16:33:56 +01:00
translate: []float32{0, 0, 0, 0},
2016-10-31 16:13:19 +01:00
}
)
2017-01-19 16:37:51 +01:00
// ChangeHSV changes HSV (Hue-Saturation-Value) elements.
2016-10-31 16:13:19 +01:00
// hueTheta is a radian value to ratate hue.
// saturationScale is a value to scale saturation.
// valueScale is a value to scale value (a.k.a. brightness).
//
// This conversion uses RGB to/from YCrCb conversion.
2018-02-19 16:33:56 +01:00
func (c *ColorM) ChangeHSV(hueTheta float64, saturationScale float32, valueScale float32) {
2016-10-31 16:13:19 +01:00
sin, cos := math.Sincos(hueTheta)
2018-02-19 16:33:56 +01:00
s32, c32 := float32(sin), float32(cos)
2017-05-23 04:30:54 +02:00
c.Concat(&rgbToYCbCr)
c.Concat(&ColorM{
2018-02-19 16:33:56 +01:00
body: []float32{
1, 0, 0, 0,
0, c32, s32, 0,
0, -s32, c32, 0,
0, 0, 0, 1,
2017-01-19 16:37:51 +01:00
},
2018-02-19 16:33:56 +01:00
translate: []float32{0, 0, 0, 0},
2016-10-31 16:13:19 +01:00
})
s := saturationScale
v := valueScale
c.Scale(v, s*v, s*v, 1)
2017-05-23 04:30:54 +02:00
c.Concat(&yCbCrToRgb)
2016-10-31 16:13:19 +01:00
}