mirror of
https://github.com/hajimehoshi/ebiten.git
synced 2024-12-26 03:38:55 +01:00
126 lines
3.6 KiB
Go
126 lines
3.6 KiB
Go
// Copyright 2022 The Ebitengine Authors
|
|
//
|
|
// 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 ebiten
|
|
|
|
import (
|
|
"fmt"
|
|
"image/color"
|
|
)
|
|
|
|
// ColorScale represents a scale of RGBA color.
|
|
// ColorScale is intended to be applied to a premultiplied-alpha color value.
|
|
//
|
|
// The initial (zero) value of ColorScale is an identity scale (1, 1, 1, 1).
|
|
type ColorScale struct {
|
|
// These values are adjusted by -1 from the actual values.
|
|
// It's because the initial value should be 1 instead of 0.
|
|
r_1, g_1, b_1, a_1 float32
|
|
}
|
|
|
|
// String returns a string representing the color scale.
|
|
func (c *ColorScale) String() string {
|
|
return fmt.Sprintf("(%f,%f,%f,%f)", c.r_1+1, c.g_1+1, c.b_1+1, c.a_1+1)
|
|
}
|
|
|
|
// Reset resets the ColorScale as identity.
|
|
func (c *ColorScale) Reset() {
|
|
c.r_1 = 0
|
|
c.g_1 = 0
|
|
c.b_1 = 0
|
|
c.a_1 = 0
|
|
}
|
|
|
|
// R returns the red scale.
|
|
func (c *ColorScale) R() float32 {
|
|
return c.r_1 + 1
|
|
}
|
|
|
|
// G returns the green scale.
|
|
func (c *ColorScale) G() float32 {
|
|
return c.g_1 + 1
|
|
}
|
|
|
|
// B returns the blue scale.
|
|
func (c *ColorScale) B() float32 {
|
|
return c.b_1 + 1
|
|
}
|
|
|
|
// A returns the alpha scale.
|
|
func (c *ColorScale) A() float32 {
|
|
return c.a_1 + 1
|
|
}
|
|
|
|
func (c *ColorScale) elements() (float32, float32, float32, float32) {
|
|
return c.r_1 + 1, c.g_1 + 1, c.b_1 + 1, c.a_1 + 1
|
|
}
|
|
|
|
// SetR overwrites the current red value with r.
|
|
func (c *ColorScale) SetR(r float32) {
|
|
c.r_1 = r - 1
|
|
}
|
|
|
|
// SetG overwrites the current green value with g.
|
|
func (c *ColorScale) SetG(g float32) {
|
|
c.g_1 = g - 1
|
|
}
|
|
|
|
// SetB overwrites the current blue value with b.
|
|
func (c *ColorScale) SetB(b float32) {
|
|
c.b_1 = b - 1
|
|
}
|
|
|
|
// SetA overwrites the current alpha value with a.
|
|
func (c *ColorScale) SetA(a float32) {
|
|
c.a_1 = a - 1
|
|
}
|
|
|
|
// Scale multiplies the given values to the current scale.
|
|
//
|
|
// Scale is slightly different from colorm.ColorM's Scale in terms of alphas.
|
|
// ColorScale is applied to premultiplied-alpha colors, while colorm.ColorM is applied to straight-alpha colors.
|
|
// Thus, ColorM.Scale(r, g, b, a) equals to ColorScale.Scale(r*a, g*a, b*a, a).
|
|
func (c *ColorScale) Scale(r, g, b, a float32) {
|
|
c.r_1 = (c.r_1+1)*r - 1
|
|
c.g_1 = (c.g_1+1)*g - 1
|
|
c.b_1 = (c.b_1+1)*b - 1
|
|
c.a_1 = (c.a_1+1)*a - 1
|
|
}
|
|
|
|
// ScaleAlpha multiplies the given alpha value to the current scale.
|
|
func (c *ColorScale) ScaleAlpha(a float32) {
|
|
c.r_1 = (c.r_1+1)*a - 1
|
|
c.g_1 = (c.g_1+1)*a - 1
|
|
c.b_1 = (c.b_1+1)*a - 1
|
|
c.a_1 = (c.a_1+1)*a - 1
|
|
}
|
|
|
|
// ScaleWithColor multiplies the given color values to the current scale.
|
|
func (c *ColorScale) ScaleWithColor(clr color.Color) {
|
|
cr, cg, cb, ca := clr.RGBA()
|
|
c.Scale(float32(cr)/0xffff, float32(cg)/0xffff, float32(cb)/0xffff, float32(ca)/0xffff)
|
|
}
|
|
|
|
// ScaleWithColorScale multiplies the given color scale values to the current scale.
|
|
func (c *ColorScale) ScaleWithColorScale(colorScale ColorScale) {
|
|
c.r_1 = (c.r_1+1)*(colorScale.r_1+1) - 1
|
|
c.g_1 = (c.g_1+1)*(colorScale.g_1+1) - 1
|
|
c.b_1 = (c.b_1+1)*(colorScale.b_1+1) - 1
|
|
c.a_1 = (c.a_1+1)*(colorScale.a_1+1) - 1
|
|
}
|
|
|
|
func (c *ColorScale) apply(r, g, b, a float32) (float32, float32, float32, float32) {
|
|
return (c.r_1 + 1) * r, (c.g_1 + 1) * g, (c.b_1 + 1) * b, (c.a_1 + 1) * a
|
|
}
|