// Requires visual inspection of stdout
func TestMakeFragments(t *testing.T) {
const (
w = 20
h = 30
a = 12
b = 14
)
src := MakeAnimation(5, false, 1)
dst := nimble.MakePixMap(w, h, make([]nimble.Pixel, w*h), w)
background := nimble.RGB(0.5, 0.25, 1)
foreground := nimble.RGB(0.25, 1, 0.25)
dst.Fill(background)
Draw(dst, a, b, src[0], foreground)
// Result should be a filled circle
for y := int32(0); y < dst.Height(); y++ {
for x := int32(0); x < dst.Width(); x++ {
r2 := (x-a)*(x-a) + (y-b)*(y-b)
var e nimble.Pixel
if r2 <= 25 {
e = foreground
} else {
e = background
}
if e != dst.Pixel(x, y) {
t.Fail()
panic(fmt.Sprintf("x=%v y=%v e=%v\n", x, y, e))
}
}
}
}
// CopyCLUT returns a PixMap copy the color lookup table.
// It is intended only for debugging.
func CopyCLUT() (pm nimble.PixMap) {
pm = nimble.MakePixMap(clutSize, clutSize, make([]nimble.Pixel, clutSize*clutSize), clutSize)
for y := int32(0); y < clutSize; y++ {
copy(pm.Row(y), clut[y][:])
}
return
}
// Init prepares state used by Draw.
func Init(width, height int32) {
if width < 3 || height < 3 {
panic(fmt.Sprintf("score.Init: width=%v height=%v\n", width, height))
}
lightWidth = width / 6
lightHeight = height
lightStorage = make([]nimble.Pixel, nLight*2*lightHeight*lightWidth)
xScale := 2.0 / float32(lightWidth-2)
yScale := 2.0 / float32(lightHeight-2)
xOffset := -.5 * xScale * float32(lightWidth)
yOffset := -.5 * yScale * float32(lightHeight)
for k, color := range lightColor {
for s := state(0); s < state(2); s++ {
pm := nimble.MakePixMap(lightWidth, lightHeight, getLight(k, s), lightWidth)
for i := int32(0); i < lightHeight; i++ {
for j := int32(0); j < lightWidth; j++ {
x := float32(j)*xScale + xOffset
y := float32(i)*yScale + yOffset
factor := 1 - x*x - y*y
if factor < 0 {
factor = 0
}
if s == 0 {
// The light is off, so dim the image
factor *= .25
}
pm.SetPixel(j, i, nimble.RGB(color.r*factor, color.g*factor, color.b*factor))
}
}
}
}
}
// Draw draws the score (as binary lights) on the given PixMap.
func Draw(pm nimble.PixMap, scoreValue int) {
if pm.Height() != lightHeight {
panic(fmt.Sprintf("score.Draw: pm.Height()=%v lightHeight=%v\n", pm.Height(), lightHeight))
}
for k := range lightColor {
s := state(scoreValue >> uint(nLight-k-1) & 1)
src := nimble.MakePixMap(lightWidth, lightHeight, getLight(k, s), lightWidth)
pm.Copy(lightWidth*int32(k), 0, &src)
}
}
// PastelPalette returns a palette of pastel colors.
// The pallette is returned as a PixMap with one row for each hue,
// which fades to black with increasing column indices.
func PastelPalette(nHue, nShade int32) (pm nimble.PixMap) {
pm = nimble.MakePixMap(nShade, nHue, make([]nimble.Pixel, nHue*nShade), nShade)
for h := int32(0); h < nHue; h++ {
r, g, b := rgbOfHue(h, nHue)
scale := 1 / float32(nShade)
row := pm.Row(h)
for j := int32(0); j < nShade; j++ {
f := float32(nShade-j) * scale
row[j] = nimble.RGB(r*f, g*f, b*f)
}
}
return
}
func Draw(pm nimble.PixMap, cm colorMap, running bool) {
setColoring(cm)
width, height := pm.Size()
if width != xSize || height != ySize {
panic(fmt.Sprintf("radar.Draw: (width,height)=(%v,%v) (xSize,ySize)=(%v,%v)\n",
width, height, xSize, ySize))
}
src := nimble.MakePixMap(width, height, getFrame(frameCounter), width)
pm.Copy(0, 0, &src)
if running {
frameCounter = (frameCounter + 1) % (int32(len(frameStorage)) / frameSize)
}
}
foreground := nimble.RGB(0.25, 1, 0.25)
dst.Fill(background)
Draw(dst, a, b, src[0], foreground)
// Result should be a filled circle
for y := int32(0); y < dst.Height(); y++ {
for x := int32(0); x < dst.Width(); x++ {
r2 := (x-a)*(x-a) + (y-b)*(y-b)
var e nimble.Pixel
if r2 <= 25 {
e = foreground
} else {
e = background
}
if e != dst.Pixel(x, y) {
t.Fail()
panic(fmt.Sprintf("x=%v y=%v e=%v\n", x, y, e))
}
}
}
}
var src = MakeAnimation(10, false, 1)
var dst = nimble.MakePixMap(500, 500, make([]nimble.Pixel, 500*500), 500)
func BenchmarkDraw(b *testing.B) {
for n := 0; n < b.N; n++ {
Draw(dst, 250, 250, src[0], nimble.Gray(1))
}
}
// Init initializes state used by Draw. Init should be called once with width and
// height values matching the size of the PixMap passed to future calls to Draw.
func Init(width, height int32) {
background = nimble.MakePixMap(width, height, make([]nimble.Pixel, height*width), width)
background.Fill(nimble.Black)
}