qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-22 08:34:40 -07:00
Code Releases Activity

Add Src and Over draw operators.

Browse Source 
R=r, rsc
CC=golang-dev
https://golang.org/cl/207096
This commit is contained in:
Nigel Tao 2010-02-17 14:34:51 +11:00
parent 77525dc866
commit 3dc04f4a22
3 changed files with 95 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/pkg/exp/4s/xs.go
View File

@ -266,14 +266,14 @@ func setpiece(p *Piece) {
draw.Draw(bb2, r2, draw.White, draw.ZP) draw.Draw(bb2, r2, draw.White, draw.ZP)
draw.Draw(bb2, r.Add(delta), bb, bbr.Min) draw.Draw(bb2, r.Add(delta), bb, bbr.Min)
draw.Draw(bb2mask, r2, draw.Transparent, draw.ZP) draw.Draw(bb2mask, r2, draw.Transparent, draw.ZP)
draw.DrawMask(bb2mask, r, draw.Opaque, bbr.Min, bbmask, draw.ZP, draw.SoverD) draw.DrawMask(bb2mask, r, draw.Opaque, bbr.Min, bbmask, draw.ZP, draw.Over)
draw.DrawMask(bb2mask, r.Add(delta), draw.Opaque, bbr.Min, bbmask, draw.ZP, draw.SoverD) draw.DrawMask(bb2mask, r.Add(delta), draw.Opaque, bbr.Min, bbmask, draw.ZP, draw.Over)
} }
func drawpiece() { func drawpiece() {
draw.DrawMask(screen, br.Add(pos), bb, bbr.Min, bbmask, draw.ZP, draw.SoverD) draw.DrawMask(screen, br.Add(pos), bb, bbr.Min, bbmask, draw.ZP, draw.Over)
if suspended { if suspended {
draw.DrawMask(screen, br.Add(pos), draw.White, draw.ZP, whitemask, draw.ZP, draw.SoverD) draw.DrawMask(screen, br.Add(pos), draw.White, draw.ZP, whitemask, draw.ZP, draw.Over)
} }
} }
@ -282,7 +282,7 @@ func undrawpiece() {
if collider(pos, br.Max) { if collider(pos, br.Max) {
mask = bbmask mask = bbmask
} }
draw.DrawMask(screen, br.Add(pos), draw.White, bbr.Min, mask, bbr.Min, draw.SoverD) draw.DrawMask(screen, br.Add(pos), draw.White, bbr.Min, mask, bbr.Min, draw.Over)
} }
func rest() { func rest() {
@ -349,7 +349,7 @@ func drawboard() {
} }
score(0) score(0)
if suspended { if suspended {
draw.DrawMask(screen, screenr, draw.White, draw.ZP, whitemask, draw.ZP, draw.SoverD) draw.DrawMask(screen, screenr, draw.White, draw.ZP, whitemask, draw.ZP, draw.Over)
} }
} }
@ -375,7 +375,7 @@ func movepiece() bool {
if collider(pos, br2.Max) { if collider(pos, br2.Max) {
mask = bb2mask mask = bb2mask
} }
draw.DrawMask(screen, br2.Add(pos), bb2, bb2r.Min, mask, bb2r.Min, draw.SoverD) draw.DrawMask(screen, br2.Add(pos), bb2, bb2r.Min, mask, bb2r.Min, draw.Over)
pos.Y += DY pos.Y += DY
display.FlushImage() display.FlushImage()
return true return true
@ -444,7 +444,7 @@ func horiz() bool {
for j := 0; j < h; j++ { for j := 0; j < h; j++ {
r.Min.Y = rboard.Min.Y + lev[j]*pcsz r.Min.Y = rboard.Min.Y + lev[j]*pcsz
r.Max.Y = r.Min.Y + pcsz r.Max.Y = r.Min.Y + pcsz
draw.DrawMask(screen, r, draw.White, draw.ZP, whitemask, draw.ZP, draw.SoverD) draw.DrawMask(screen, r, draw.White, draw.ZP, whitemask, draw.ZP, draw.Over)
display.FlushImage() display.FlushImage()
} }
PlaySound(whoosh) PlaySound(whoosh)
@ -457,7 +457,7 @@ func horiz() bool {
for j := 0; j < h; j++ { for j := 0; j < h; j++ {
r.Min.Y = rboard.Min.Y + lev[j]*pcsz r.Min.Y = rboard.Min.Y + lev[j]*pcsz
r.Max.Y = r.Min.Y + pcsz r.Max.Y = r.Min.Y + pcsz
draw.DrawMask(screen, r, draw.White, draw.ZP, whitemask, draw.ZP, draw.SoverD) draw.DrawMask(screen, r, draw.White, draw.ZP, whitemask, draw.ZP, draw.Over)
} }
display.FlushImage() display.FlushImage()
} }

100
src/pkg/exp/draw/draw.go
View File

@ -15,7 +15,14 @@ import "image"
// A Porter-Duff compositing operator. // A Porter-Duff compositing operator.
type Op int type Op int
const SoverD Op = 0 const (
// Over specifies ``(src in mask) over dst''.
Over Op = iota
// Src specifies ``src in mask''.
Src
)
var zeroColor image.Color = image.AlphaColor{0}
// A draw.Image is an image.Image with a Set method to change a single pixel. // A draw.Image is an image.Image with a Set method to change a single pixel.
type Image interface { type Image interface {
@ -23,14 +30,13 @@ type Image interface {
Set(x, y int, c image.Color) Set(x, y int, c image.Color)
} }
// Draw calls DrawMask with a nil mask and an SoverD op. // Draw calls DrawMask with a nil mask and an Over op.
func Draw(dst Image, r Rectangle, src image.Image, sp Point) { func Draw(dst Image, r Rectangle, src image.Image, sp Point) {
DrawMask(dst, r, src, sp, nil, ZP, SoverD) DrawMask(dst, r, src, sp, nil, ZP, Over)
} }
// DrawMask aligns r.Min in dst with sp in src and mp in mask and then replaces the rectangle r // DrawMask aligns r.Min in dst with sp in src and mp in mask and then replaces the rectangle r
// in dst with the result of a Porter-Duff composition. For the SoverD operator, the result // in dst with the result of a Porter-Duff composition. A nil mask is treated as opaque.
// is ``(src in mask) over dst''. If mask is nil, this simplifies to ``src over dst''.
// The implementation is simple and slow. // The implementation is simple and slow.
// TODO(nigeltao): Optimize this. // TODO(nigeltao): Optimize this.
func DrawMask(dst Image, r Rectangle, src image.Image, sp Point, mask image.Image, mp Point, op Op) { func DrawMask(dst Image, r Rectangle, src image.Image, sp Point, mask image.Image, mp Point, op Op) {
@ -54,22 +60,25 @@ func DrawMask(dst Image, r Rectangle, src image.Image, sp Point, mask image.Imag
// TODO(nigeltao): Ensure that r is well formed, i.e. r.Max.X >= r.Min.X and likewise for Y. // TODO(nigeltao): Ensure that r is well formed, i.e. r.Max.X >= r.Min.X and likewise for Y.
// Fast paths for special cases. If none of them apply, then we fall back to a general but slow implementation. // Fast paths for special cases. If none of them apply, then we fall back to a general but slow implementation.
if dst0, ok := dst.(*image.RGBA); ok && op == SoverD { if dst0, ok := dst.(*image.RGBA); ok {
if mask == nil { if op == Over {
if src0, ok := src.(image.ColorImage); ok { // TODO(nigeltao): Implement a fast path for font glyphs (i.e. when mask is an image.Alpha).
drawFill(dst0, r, src0) } else {
return if mask == nil {
} if src0, ok := src.(image.ColorImage); ok {
if src0, ok := src.(*image.RGBA); ok { drawFill(dst0, r, src0)
if dst0 == src0 && r.Overlaps(r.Add(sp.Sub(r.Min))) {
// TODO(nigeltao): Implement a fast path for the overlapping case.
} else {
drawCopy(dst0, r, src0, sp)
return return
} }
if src0, ok := src.(*image.RGBA); ok {
if dst0 == src0 && r.Overlaps(r.Add(sp.Sub(r.Min))) {
// TODO(nigeltao): Implement a fast path for the overlapping case.
} else {
drawCopy(dst0, r, src0, sp)
return
}
}
} }
} }
// TODO(nigeltao): Implement a fast path for font glyphs (i.e. when mask is an image.Alpha).
} }
x0, x1, dx := r.Min.X, r.Max.X, 1 x0, x1, dx := r.Min.X, r.Max.X, 1
@ -89,42 +98,49 @@ func DrawMask(dst Image, r Rectangle, src image.Image, sp Point, mask image.Imag
sx := sp.X + x0 - r.Min.X sx := sp.X + x0 - r.Min.X
mx := mp.X + x0 - r.Min.X mx := mp.X + x0 - r.Min.X
for x := x0; x != x1; x, sx, mx = x+dx, sx+dx, mx+dx { for x := x0; x != x1; x, sx, mx = x+dx, sx+dx, mx+dx {
// TODO(nigeltao): Check that op == SoverD. // A nil mask is equivalent to a fully opaque, infinitely large mask.
if mask == nil { // We work in 16-bit color, so that multiplying two values does not overflow a uint32.
dst.Set(x, y, src.At(sx, sy)) const M = 1<<16 - 1
continue ma := uint32(M)
if mask != nil {
_, _, _, ma = mask.At(mx, my).RGBA()
ma >>= 16
} }
_, _, _, ma := mask.At(mx, my).RGBA() switch {
switch ma { case ma == 0:
case 0: if op == Over {
continue // No-op.
case 0xFFFFFFFF: } else {
dst.Set(x, y, zeroColor)
}
case ma == M && op == Src:
dst.Set(x, y, src.At(sx, sy)) dst.Set(x, y, src.At(sx, sy))
default: default:
dr, dg, db, da := dst.At(x, y).RGBA()
dr >>= 16
dg >>= 16
db >>= 16
da >>= 16
sr, sg, sb, sa := src.At(sx, sy).RGBA() sr, sg, sb, sa := src.At(sx, sy).RGBA()
sr >>= 16 sr >>= 16
sg >>= 16 sg >>= 16
sb >>= 16 sb >>= 16
sa >>= 16 sa >>= 16
ma >>= 16
const M = 1<<16 - 1
a := sa * ma / M
dr = (dr*(M-a) + sr*ma) / M
dg = (dg*(M-a) + sg*ma) / M
db = (db*(M-a) + sb*ma) / M
da = (da*(M-a) + sa*ma) / M
if out == nil { if out == nil {
out = new(image.RGBA64Color) out = new(image.RGBA64Color)
} }
out.R = uint16(dr) if op == Over {
out.G = uint16(dg) dr, dg, db, da := dst.At(x, y).RGBA()
out.B = uint16(db) dr >>= 16
out.A = uint16(da) dg >>= 16
db >>= 16
da >>= 16
a := M - (sa * ma / M)
out.R = uint16((dr*a + sr*ma) / M)
out.G = uint16((dg*a + sg*ma) / M)
out.B = uint16((db*a + sb*ma) / M)
out.A = uint16((da*a + sa*ma) / M)
} else {
out.R = uint16(sr * ma / M)
out.G = uint16(sg * ma / M)
out.B = uint16(sb * ma / M)
out.A = uint16(sa * ma / M)
}
dst.Set(x, y, out) dst.Set(x, y, out)
} }
} }

40
src/pkg/exp/draw/draw_test.go
View File

@ -57,31 +57,47 @@ type drawTest struct {
desc string desc string
src image.Image src image.Image
mask image.Image mask image.Image
op Op
expected image.Color expected image.Color
} }
var drawTests = []drawTest{ var drawTests = []drawTest{
// Uniform mask (0% opaque) mask. // Uniform mask (0% opaque).
drawTest{"nop", vgradGreen(255), fillAlpha(0), image.RGBAColor{136, 0, 0, 255}}, drawTest{"nop", vgradGreen(255), fillAlpha(0), Over, image.RGBAColor{136, 0, 0, 255}},
// Uniform mask (100%, 75%, nil) and vertical-gradient source. drawTest{"clear", vgradGreen(255), fillAlpha(0), Src, image.RGBAColor{0, 0, 0, 0}},
drawTest{"copy", vgradGreen(90), fillAlpha(255), image.RGBAColor{0, 48, 0, 90}},
drawTest{"copyAlpha", vgradGreen(90), fillAlpha(192), image.RGBAColor{100, 36, 0, 255}},
drawTest{"copyNil", vgradGreen(90), nil, image.RGBAColor{0, 48, 0, 90}},
// Uniform mask (100%, 75%, nil) and uniform source. // Uniform mask (100%, 75%, nil) and uniform source.
drawTest{"fill", fillBlue(90), fillAlpha(255), image.RGBAColor{0, 0, 90, 90}}, // At (x, y) == (8, 8):
drawTest{"fillAlpha", fillBlue(90), fillAlpha(192), image.RGBAColor{100, 0, 68, 255}}, // The destination pixel is {136, 0, 0, 255}.
drawTest{"fillNil", fillBlue(90), nil, image.RGBAColor{0, 0, 90, 90}}, // The source pixel is {0, 0, 90, 90}.
// Variable mask. In detail, at (x, y) == (8, 8): drawTest{"fill", fillBlue(90), fillAlpha(255), Over, image.RGBAColor{88, 0, 90, 255}},
drawTest{"fillSrc", fillBlue(90), fillAlpha(255), Src, image.RGBAColor{0, 0, 90, 90}},
drawTest{"fillAlpha", fillBlue(90), fillAlpha(192), Over, image.RGBAColor{100, 0, 68, 255}},
drawTest{"fillAlphaSrc", fillBlue(90), fillAlpha(192), Src, image.RGBAColor{0, 0, 68, 68}},
drawTest{"fillNil", fillBlue(90), nil, Over, image.RGBAColor{88, 0, 90, 255}},
drawTest{"fillNilSrc", fillBlue(90), nil, Src, image.RGBAColor{0, 0, 90, 90}},
// Uniform mask (100%, 75%, nil) and variable source.
// At (x, y) == (8, 8):
// The destination pixel is {136, 0, 0, 255}.
// The source pixel is {0, 48, 0, 90}.
drawTest{"copy", vgradGreen(90), fillAlpha(255), Over, image.RGBAColor{88, 48, 0, 255}},
drawTest{"copySrc", vgradGreen(90), fillAlpha(255), Src, image.RGBAColor{0, 48, 0, 90}},
drawTest{"copyAlpha", vgradGreen(90), fillAlpha(192), Over, image.RGBAColor{100, 36, 0, 255}},
drawTest{"copyAlphaSrc", vgradGreen(90), fillAlpha(192), Src, image.RGBAColor{0, 36, 0, 68}},
drawTest{"copyNil", vgradGreen(90), nil, Over, image.RGBAColor{88, 48, 0, 255}},
drawTest{"copyNilSrc", vgradGreen(90), nil, Src, image.RGBAColor{0, 48, 0, 90}},
// Variable mask and variable source.
// At (x, y) == (8, 8):
// The destination pixel is {136, 0, 0, 255}. // The destination pixel is {136, 0, 0, 255}.
// The source pixel is {0, 0, 255, 255}. // The source pixel is {0, 0, 255, 255}.
// The mask pixel's alpha is 102, or 40%. // The mask pixel's alpha is 102, or 40%.
drawTest{"generic", fillBlue(255), vgradAlpha(192), image.RGBAColor{81, 0, 102, 255}}, drawTest{"generic", fillBlue(255), vgradAlpha(192), Over, image.RGBAColor{81, 0, 102, 255}},
drawTest{"genericSrc", fillBlue(255), vgradAlpha(192), Src, image.RGBAColor{0, 0, 102, 102}},
} }
func TestDraw(t *testing.T) { func TestDraw(t *testing.T) {
for _, test := range drawTests { for _, test := range drawTests {
dst := hgradRed(255) dst := hgradRed(255)
DrawMask(dst, Rect(0, 0, 16, 16), test.src, ZP, test.mask, ZP, SoverD) DrawMask(dst, Rect(0, 0, 16, 16), test.src, ZP, test.mask, ZP, test.op)
if !eq(dst.At(8, 8), test.expected) { if !eq(dst.At(8, 8), test.expected) {
t.Errorf("draw %s: %v versus %v", test.desc, dst.At(8, 8), test.expected) t.Errorf("draw %s: %v versus %v", test.desc, dst.At(8, 8), test.expected)
} }