Better
This commit is contained in:
parent
b28583c1ff
commit
9cc7ebab3c
|
@ -1,77 +0,0 @@
|
||||||
# SPDX-FileCopyrightText: ☭ Emery Hemingway
|
|
||||||
# SPDX-License-Identifier: Unlicense
|
|
||||||
|
|
||||||
import std/[deques]
|
|
||||||
import pixie
|
|
||||||
|
|
||||||
type
|
|
||||||
Pane* = ref object
|
|
||||||
image: pixie.Image
|
|
||||||
spans: seq[Span]
|
|
||||||
arrangement: Arrangement
|
|
||||||
|
|
||||||
Well* = ref object
|
|
||||||
panes: Deque[Pane]
|
|
||||||
|
|
||||||
proc newFrame(width, height: int): Frame =
|
|
||||||
let (w, h) = (width div 2, height div 2)
|
|
||||||
new result
|
|
||||||
result.panes[0] = Pane(image: newImage(w, h))
|
|
||||||
result.panes[1] = Pane(image: newImage(w, h))
|
|
||||||
result.panes[2] = Pane(image: newImage(w, h))
|
|
||||||
|
|
||||||
proc paneVec2(frame: Frame): Vec2 =
|
|
||||||
vec2(frame.panes[0].image.width.float32, frame.panes[0].image.height.float32)
|
|
||||||
|
|
||||||
proc allocChild(frame: Frame) =
|
|
||||||
assert frame.child.isNil
|
|
||||||
let (w, h) = (frame.panes[0].image.width div 2, frame.panes[0].image.height div 2)
|
|
||||||
doAssert w > 2 and h > 2, $w & "x" & $h
|
|
||||||
frame.child = newFrame(w, h)
|
|
||||||
|
|
||||||
proc setDepth(frame: Frame; n: Natural) =
|
|
||||||
var
|
|
||||||
frame = frame
|
|
||||||
i = n
|
|
||||||
while i > 0:
|
|
||||||
dec(i)
|
|
||||||
if frame.child.isNil:
|
|
||||||
allocChild(frame)
|
|
||||||
frame = frame.child
|
|
||||||
|
|
||||||
proc `[]`*(frame: Frame; i: Natural): Pane =
|
|
||||||
var
|
|
||||||
frame = frame
|
|
||||||
i = i
|
|
||||||
while true:
|
|
||||||
if i < 4:
|
|
||||||
return frame.panes[i]
|
|
||||||
if frame.child.isNil:
|
|
||||||
allocChild(frame)
|
|
||||||
frame = frame.child
|
|
||||||
dec(i, 4)
|
|
||||||
|
|
||||||
iterator walkPanes(frame: Frame): tuple[coord: Vec2, pane: Pane] =
|
|
||||||
var frame = frame
|
|
||||||
while not frame.isNil and
|
|
||||||
frame.panes[0].image.width > 2 and
|
|
||||||
frame.panes[1].image.height > 2:
|
|
||||||
let coord = frame.paneVec2
|
|
||||||
yield(coord, frame.panes[0])
|
|
||||||
yield(coord - vec2(coord.x, 0), frame.panes[1])
|
|
||||||
yield(coord - vec2(0, coord.y), frame.panes[2])
|
|
||||||
frame = frame.child
|
|
||||||
|
|
||||||
proc append*(frame: Fram; text: string; font: Font) =
|
|
||||||
let span = newSpan(text, font)
|
|
||||||
|
|
||||||
proc append*(frame: Fram; stream: Stream; font: Font) =
|
|
||||||
var line: string
|
|
||||||
while readLine(stream, line):
|
|
||||||
append(frame, font, line)
|
|
||||||
|
|
||||||
when isMainModule:
|
|
||||||
let frame = newFrame(800, 600)
|
|
||||||
frame.setDepth(3)
|
|
||||||
for (coord, pane) in walkPanes(frame):
|
|
||||||
echo coord, " - ", pane.image.width, "x", pane.image.height
|
|
|
@ -1,26 +0,0 @@
|
||||||
import pixie
|
|
||||||
|
|
||||||
let image = newImage(200, 200)
|
|
||||||
image.fill(rgba(255, 255, 255, 255))
|
|
||||||
|
|
||||||
const typefacePath =
|
|
||||||
"/nix/store/ay5vhxszmibk0nrhx1vid4nhgvgdniq8-corefonts-1/share/fonts/truetype/Trebuchet_MS.ttf"
|
|
||||||
|
|
||||||
let typeface = readTypeface(typefacePath)
|
|
||||||
|
|
||||||
proc newFont(typeface: Typeface, size: float32, color: Color): Font =
|
|
||||||
result = newFont(typeface)
|
|
||||||
result.size = size
|
|
||||||
result.paint.color = color
|
|
||||||
|
|
||||||
let spans = @[
|
|
||||||
newSpan("verb [with object] ",
|
|
||||||
newFont(typeface, 12, color(0.78125, 0.78125, 0.78125, 1))),
|
|
||||||
newSpan("strallow\n", newFont(typeface, 36, color(0, 0, 0, 1))),
|
|
||||||
newSpan("\nstral·low\n", newFont(typeface, 13, color(0, 0.5, 0.953125, 1))),
|
|
||||||
newSpan("\n1. free (something) from restrictive restrictions \"the regulations are intended to strallow changes in public policy\" ",
|
|
||||||
newFont(typeface, 14, color(0.3125, 0.3125, 0.3125, 1)))
|
|
||||||
]
|
|
||||||
|
|
||||||
image.fillText(typeset(spans, vec2(180, 180)), translate(vec2(10, 10)))
|
|
||||||
image.writeFile("text_spans.png")
|
|
|
@ -1,62 +0,0 @@
|
||||||
# SPDX-FileCopyrightText: ☭ Emery Hemingway
|
|
||||||
# SPDX-License-Identifier: Unlicense
|
|
||||||
|
|
||||||
import std/[sequtils]
|
|
||||||
import pixie
|
|
||||||
|
|
||||||
proc newFont*(typeface: Typeface, size: float32): Font =
|
|
||||||
result = newFont(typeface)
|
|
||||||
result.size = size
|
|
||||||
|
|
||||||
func height(arr: Arrangement): float =
|
|
||||||
if arr.positions.len > 0: result = arr.positions[arr.positions.high].y
|
|
||||||
|
|
||||||
proc add(result: var Arrangement; other: sink Arrangement) =
|
|
||||||
if result.lines.len == 0:
|
|
||||||
result = other
|
|
||||||
else:
|
|
||||||
let runeOff = result.runes.len
|
|
||||||
add(result.lines, map(other.lines,
|
|
||||||
proc (x: (int, int)): (int, int) = (x[0]+runeOff, x[1]+runeOff)))
|
|
||||||
add(result.spans, map(other.spans,
|
|
||||||
proc (x: (int, int)): (int, int) = (x[0]+runeOff, x[1]+runeOff)))
|
|
||||||
add(result.fonts, other.fonts)
|
|
||||||
add(result.runes, other.runes)
|
|
||||||
let yOff = result.positions[result.positions.high].y
|
|
||||||
add(result.positions,
|
|
||||||
map(other.positions,
|
|
||||||
proc(pos: Vec2): Vec2 = vec2(pos.x, pos.y + yOff)))
|
|
||||||
add(result.selectionRects,
|
|
||||||
map(other.selectionRects,
|
|
||||||
proc(rect: Rect): Rect = rect(rect.x, rect.y + yOff, rect.w, rect.h)))
|
|
||||||
|
|
||||||
proc render*(font: Font; text: string): Image =
|
|
||||||
# TODO: render by font size, not by wh
|
|
||||||
var wh = layoutBounds(font, "X")
|
|
||||||
echo "bounds of X are ", wh
|
|
||||||
wh.x = wh.x * 80
|
|
||||||
wh.y = wh.y * 50
|
|
||||||
let margin = wh / 9.0
|
|
||||||
var
|
|
||||||
printSpace = wh * (7.0 / 9.0)
|
|
||||||
pages = @[Arrangement()]
|
|
||||||
|
|
||||||
proc pageEnd(): float =
|
|
||||||
let
|
|
||||||
pi = pages.high
|
|
||||||
li = pages[pi].lines.high
|
|
||||||
ci = pages[pi].lines[li][1]
|
|
||||||
pages[pi].positions[ci].y
|
|
||||||
|
|
||||||
proc append(span: Span) =
|
|
||||||
var arr = typeset(@[span], printSpace)
|
|
||||||
if pages[pages.high].height + arr.height < printSpace.y:
|
|
||||||
pages[pages.high].add arr
|
|
||||||
else:
|
|
||||||
discard
|
|
||||||
|
|
||||||
append(newSpan(text, font))
|
|
||||||
|
|
||||||
result = newImage(int wh.x, int wh.y)
|
|
||||||
fill(result, rgba(255, 255, 255, 255))
|
|
||||||
fillText(result, pages[0], translate(margin))
|
|
|
@ -46,7 +46,6 @@ type
|
||||||
screen: Image
|
screen: Image
|
||||||
window: WindowPtr
|
window: WindowPtr
|
||||||
renderer: RendererPtr
|
renderer: RendererPtr
|
||||||
texture: TexturePtr
|
|
||||||
rect: bumpy.Rect
|
rect: bumpy.Rect
|
||||||
viewPoint: Vec2
|
viewPoint: Vec2
|
||||||
well: Well
|
well: Well
|
||||||
|
@ -56,59 +55,50 @@ func rect(img: Image): bumpy.Rect =
|
||||||
result.w = float img.width
|
result.w = float img.width
|
||||||
result.h = float img.height
|
result.h = float img.height
|
||||||
|
|
||||||
proc newApp(length: cint): App =
|
proc newApp(): App =
|
||||||
## Create a new square plane of `length` pixels.
|
## Create a new square plane of `length` pixels.
|
||||||
result = App(
|
result = App(zoomFactor: 1.0)
|
||||||
well: newWell(length, length),
|
result.window = createWindow(
|
||||||
zoomFactor: 1.0,
|
"well of text",
|
||||||
|
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
|
||||||
|
600, 800,
|
||||||
|
SDL_WINDOW_RESIZABLE,
|
||||||
)
|
)
|
||||||
discard createWindowAndRenderer(
|
result.renderer = createRenderer(result.window, -1, 0)
|
||||||
length, length,
|
var
|
||||||
SDL_WINDOW_RESIZABLE,
|
info: RendererInfo
|
||||||
result.window, result.renderer)
|
# mode: DisplayMode
|
||||||
var info: RendererInfo
|
|
||||||
check getRendererInfo(result.renderer, addr info)
|
check getRendererInfo(result.renderer, addr info)
|
||||||
echo "SDL Renderer: ", info.name
|
echo "SDL Renderer: ", info.name
|
||||||
|
echo "SDL maximum texture size: ", info.max_texture_width, "x", info.max_texture_height
|
||||||
|
#check getDisplayMode(result.window, mode)
|
||||||
|
let (w, h) = result.window.getSize
|
||||||
|
result.well = newWell(w, h)
|
||||||
|
|
||||||
func toSdl(rect: bumpy.Rect): sdl2.Rect =
|
func toSdl(rect: bumpy.Rect): sdl2.Rect =
|
||||||
(result.x, result.y, result.w, result.h) =
|
(result.x, result.y, result.w, result.h) =
|
||||||
(cint rect.x, cint rect.y, cint rect.w, cint rect.h)
|
(cint rect.x, cint rect.y, cint rect.w, cint rect.h)
|
||||||
|
|
||||||
proc viewPort(app: App; wh: Vec2): bumpy.Rect =
|
|
||||||
result.wh = wh / app.zoomFactor
|
|
||||||
result.xy = app.viewPoint - (result.wh * 0.5)
|
|
||||||
|
|
||||||
proc redraw(app: App) =
|
proc redraw(app: App) =
|
||||||
assert app.zoomFactor != 0.0
|
assert app.zoomFactor != 0.0
|
||||||
|
app.renderer.setDrawColor(0xf8, 0xf8, 0xf8)
|
||||||
|
app.renderer.clear()
|
||||||
var
|
var
|
||||||
(w, h) = app.window.getSize
|
(w, h) = app.window.getSize
|
||||||
sdlViewPort = rect(-float(w shr 1), -float(h shr 1), float w, float h)
|
wh = vec2(float w, float h)
|
||||||
viewPort = app.viewPort(sdlViewPort.wh)
|
viewPort = rect(app.viewPoint, wh / app.zoomFactor)
|
||||||
app.renderer.setDrawColor(0x80, 0x80, 0x80)
|
for intersect in app.well.intersectingPanes(viewPort):
|
||||||
app.renderer.clear()
|
let texture = app.well.texture(intersect.index, app.renderer)
|
||||||
|
if texture.isNil:
|
||||||
|
break
|
||||||
|
var
|
||||||
|
sdlSrc = intersect.src.toSdl
|
||||||
|
dst = rect(intersect.dst.xy - viewPort.xy, intersect.dst.wh)
|
||||||
|
if app.zoomFactor != 1.0:
|
||||||
|
dst = dst * app.zoomFactor
|
||||||
|
var sdlDst = dst.toSdl
|
||||||
|
app.renderer.copy(texture, addr sdlSrc, addr sdlDst)
|
||||||
|
|
||||||
let wellRect = app.well.rect
|
|
||||||
if viewPort.overlaps wellRect:
|
|
||||||
for (index, rect) in app.well.intersectingPanes(viewPort):
|
|
||||||
let texture = app.well.texture(index, app.renderer, rect.wh * app.zoomFactor)
|
|
||||||
if texture.isNil: break
|
|
||||||
let
|
|
||||||
overlap = viewPort and rect
|
|
||||||
src = rect(overlap.xy - rect.xy, overlap.wh)
|
|
||||||
var dst: bumpy.Rect
|
|
||||||
dst.x = (overlap.x - viewPort.x) * (sdlViewPort.w / viewPort.w)
|
|
||||||
dst.y = (overlap.y - viewPort.y) * (sdlViewPort.h / viewPort.h)
|
|
||||||
dst.wh =
|
|
||||||
if app.zoomFactor == 1.0:
|
|
||||||
overlap.wh # correct
|
|
||||||
elif app.zoomFactor > 1.0:
|
|
||||||
sdlViewPort.wh - dst.xy # correct?
|
|
||||||
else:
|
|
||||||
overlap.wh * app.zoomFactor
|
|
||||||
var (sdlSrc, sdlDst) = (src.toSdl, dst.toSdl)
|
|
||||||
app.renderer.copy(texture, addr sdlSrc, addr sdlDst)
|
|
||||||
else:
|
|
||||||
echo "no overlap of ", viewPort, " and ", wellRect
|
|
||||||
app.renderer.present()
|
app.renderer.present()
|
||||||
|
|
||||||
proc resize(app: App) =
|
proc resize(app: App) =
|
||||||
|
@ -124,21 +114,22 @@ proc pan(app: App; xy: Vec2) =
|
||||||
app.redraw()
|
app.redraw()
|
||||||
|
|
||||||
proc recenter(app: App) =
|
proc recenter(app: App) =
|
||||||
reset app.viewPoint
|
let (w, h) = app.window.getSize
|
||||||
|
app.viewPoint = vec2(0, 0)
|
||||||
app.zoomFactor = 1.0
|
app.zoomFactor = 1.0
|
||||||
app.redraw()
|
app.redraw()
|
||||||
|
|
||||||
proc main() =
|
proc main() =
|
||||||
|
|
||||||
discard sdl2.init(INIT_TIMER or INIT_VIDEO or INIT_EVENTS)
|
discard sdl2.init(INIT_TIMER or INIT_VIDEO or INIT_EVENTS)
|
||||||
let app = newApp(512)
|
let app = newApp()
|
||||||
|
app.redraw()
|
||||||
|
|
||||||
let
|
let
|
||||||
typeface = readTypeface(typefacePath)
|
typeface = readTypeface(typefacePath)
|
||||||
font = newFont(typeface)
|
font = newFont(typeface)
|
||||||
# TODO
|
# TODO
|
||||||
|
|
||||||
app.redraw()
|
|
||||||
|
|
||||||
#[
|
#[
|
||||||
let
|
let
|
||||||
|
@ -157,16 +148,16 @@ proc main() =
|
||||||
|
|
||||||
let stream = newFileStream(stdin)
|
let stream = newFileStream(stdin)
|
||||||
# TODO
|
# TODO
|
||||||
|
var line: string
|
||||||
|
while readLine(stream, line):
|
||||||
|
# TODO
|
||||||
|
app.well.append(line, font)
|
||||||
|
app.redraw()
|
||||||
|
|
||||||
var
|
var
|
||||||
evt = sdl2.defaultEvent
|
evt = sdl2.defaultEvent
|
||||||
mousePanning: bool
|
mousePanning: bool
|
||||||
line: string
|
|
||||||
while true:
|
while true:
|
||||||
if readLine(stream, line):
|
|
||||||
# TODO
|
|
||||||
app.well.append(line, font)
|
|
||||||
app.redraw()
|
|
||||||
# asyncdispatch.poll(0)
|
# asyncdispatch.poll(0)
|
||||||
if waitEventTimeout(evt, sdlTimeout):
|
if waitEventTimeout(evt, sdlTimeout):
|
||||||
case evt.kind
|
case evt.kind
|
||||||
|
|
|
@ -1 +0,0 @@
|
||||||
debugger:native
|
|
129
src/wells.nim
129
src/wells.nim
|
@ -8,38 +8,48 @@ type
|
||||||
Rect = bumpy.Rect
|
Rect = bumpy.Rect
|
||||||
|
|
||||||
Pane* = ref object
|
Pane* = ref object
|
||||||
image: pixie.Image
|
|
||||||
spans: seq[Span]
|
spans: seq[Span]
|
||||||
arrangement: Arrangement
|
arrangement: Arrangement
|
||||||
|
image: Image
|
||||||
|
texture: TexturePtr
|
||||||
|
|
||||||
Well* = ref object
|
Well* = ref object
|
||||||
panes: Deque[Pane]
|
panes: Deque[Pane]
|
||||||
dimensions: Vec2
|
width, height: int
|
||||||
|
|
||||||
using
|
using
|
||||||
pane: Pane
|
pane: Pane
|
||||||
well: Well
|
well: Well
|
||||||
|
|
||||||
proc newWell*(width, height: int): Well =
|
proc newWell*(width, height: int): Well =
|
||||||
result = Well(dimensions: vec2(float width, float height))
|
result = Well(width: width, height: height)
|
||||||
result.panes.addFirst Pane()
|
result.panes.addFirst Pane()
|
||||||
|
|
||||||
proc margins*(well): Vec2 = well.dimensions / 9.0
|
proc dimensions(well): Vec2 = vec2(float well.width, float well.height)
|
||||||
|
|
||||||
proc bounds*(well): Vec2 = well.margins * 7.0
|
proc margins*(well): (int, int) = (well.width div 9, well.height div 9)
|
||||||
|
|
||||||
proc rect*(well): Rect =
|
proc rect*(well): Rect =
|
||||||
result.wh = well.dimensions
|
result.wh = well.dimensions
|
||||||
|
|
||||||
proc rectAt(well; offset: int): Rect =
|
proc rectAt(well; i: int): Rect =
|
||||||
if offset < well.panes.len:
|
if i < well.panes.len:
|
||||||
let n = succ offset
|
let
|
||||||
result.w = well.dimensions.x / float(2 * n)
|
(quo, rem) = divmod(i, 3)
|
||||||
result.h = well.dimensions.y / float(2 * n)
|
shiftOff = quo.succ
|
||||||
case offset and 3
|
scaleDiv = 1 shl quo.succ
|
||||||
of 0: (result.x, result.y) = (result.w, result.h)
|
fullWh = well.dimensions
|
||||||
of 1: result.y = result.h
|
result.w = float(well.width shr shiftOff)
|
||||||
of 2: result.x = result.w
|
result.h = float(well.height shr shiftOff)
|
||||||
|
case rem
|
||||||
|
of 0:
|
||||||
|
result.xy = fullWh - (result.wh * 2.0)
|
||||||
|
of 1:
|
||||||
|
result.x = fullWh.x - result.w
|
||||||
|
result.y = fullWh.y - (result.h * 2.0)
|
||||||
|
of 2:
|
||||||
|
result.x = fullWh.x - (result.w * 2.0)
|
||||||
|
result.y = fullWh.y - result.h
|
||||||
else: discard
|
else: discard
|
||||||
|
|
||||||
proc place*(well; offset, width, height: int): (Pane, Rect) =
|
proc place*(well; offset, width, height: int): (Pane, Rect) =
|
||||||
|
@ -52,20 +62,20 @@ proc place*(well; offset, width, height: int): (Pane, Rect) =
|
||||||
|
|
||||||
proc append*(well; text: string; font: Font) =
|
proc append*(well; text: string; font: Font) =
|
||||||
assert well.panes.len > 0
|
assert well.panes.len > 0
|
||||||
let span = newSpan(text, font)
|
let span = newSpan(text & "\n", font)
|
||||||
while true:
|
while true:
|
||||||
let pane = well.panes[0]
|
let pane = well.panes.peekLast()
|
||||||
pane.spans.add(span)
|
pane.spans.add(span)
|
||||||
var
|
var
|
||||||
arrangement = typeset(pane.spans, well.bounds)
|
arrangement = typeset(pane.spans, well.dimensions)
|
||||||
bounds = layoutBounds arrangement
|
bounds = layoutBounds arrangement
|
||||||
# assert bounds.x <= well.bounds.x
|
if bounds.y <= well.dimensions.y:
|
||||||
if bounds.y <= well.bounds.y:
|
doAssert pane.spans.len > 0, "text does not find on a single pane - " & $bounds & $well.dimensions
|
||||||
doAssert pane.spans.len > 0, "text does not find on a single pane - " & $bounds & $well.bounds
|
|
||||||
pane.arrangement = arrangement
|
pane.arrangement = arrangement
|
||||||
break
|
break
|
||||||
else:
|
else:
|
||||||
well.panes.addFirst Pane()
|
discard pane.spans.pop()
|
||||||
|
well.panes.addLast Pane()
|
||||||
|
|
||||||
proc append*(well; stream: Stream; font: Font) =
|
proc append*(well; stream: Stream; font: Font) =
|
||||||
var line: string
|
var line: string
|
||||||
|
@ -79,21 +89,12 @@ proc render*(well; index: Natural; scale: float): Image =
|
||||||
if dimensions.x > 8 and dimensions.y > 8:
|
if dimensions.x > 8 and dimensions.y > 8:
|
||||||
result = newImage(int dimensions.x, int dimensions.y)
|
result = newImage(int dimensions.x, int dimensions.y)
|
||||||
fill(result, rgba(255, 255, 255, 255))
|
fill(result, rgba(255, 255, 255, 255))
|
||||||
fillText(well.panes[index].arrangment, translate(well.margin))
|
fillText(well.panes[index].arrangment, translate(well.margins))
|
||||||
]#
|
]#
|
||||||
|
|
||||||
iterator intersectingPanes*(well; rect: Rect): (int, Rect) =
|
type Intersection = tuple
|
||||||
var i = 0
|
src, dst: Rect
|
||||||
while i < well.panes.len:
|
index: int
|
||||||
let bounds = well.rectAt(i)
|
|
||||||
if (i and 3) == 3:
|
|
||||||
let quad = rect(vec2(0,0), bounds.wh * 2.0)
|
|
||||||
if not rect.overlaps quad:
|
|
||||||
# all further panes are non-intersecting
|
|
||||||
break
|
|
||||||
if rect.overlaps bounds:
|
|
||||||
yield (i, bounds)
|
|
||||||
inc(i)
|
|
||||||
|
|
||||||
const
|
const
|
||||||
amask = uint32 0xff000000
|
amask = uint32 0xff000000
|
||||||
|
@ -101,20 +102,48 @@ const
|
||||||
gmask = uint32 0x0000ff00
|
gmask = uint32 0x0000ff00
|
||||||
bmask = uint32 0x00ff0000
|
bmask = uint32 0x00ff0000
|
||||||
|
|
||||||
proc texture*(well; index: int; renderer: RendererPtr; wh: Vec2): TexturePtr =
|
proc texture*(well; index: int; renderer: RendererPtr): TexturePtr =
|
||||||
# TODO:caching
|
if index < well.panes.len:
|
||||||
if index >= well.panes.len or wh.x < 4 or wh.y < 4: return nil
|
let pane = well.panes[index]
|
||||||
let pane = well.panes[index]
|
if pane.texture.isNil and not pane.arrangement.isNil:
|
||||||
let
|
assert pane.image.isNil
|
||||||
image = newImage(wh.x.int, wh.y.int)
|
let
|
||||||
zoom = wh / well.dimensions
|
w = (well.width div 9) * 7
|
||||||
margin = wh / 9.0
|
h = (well.height div 9) * 7
|
||||||
if not pane.arrangement.isNil:
|
pane.image = newImage(w, h)
|
||||||
image.fillText(pane.arrangement, scale(zoom) * translate(margin))
|
pane.image.fill(rgba(255, 255, 255, 255))
|
||||||
var surface = createRGBSurfaceFrom(
|
pane.image.fillText(pane.arrangement)
|
||||||
image.data[0].addr, wh.x.cint, wh.y.cint, cint 32, 4 * wh.x.cint,
|
var surface = createRGBSurfaceFrom(
|
||||||
rmask, gmask, bmask, amask,
|
pane.image.data[0].addr,
|
||||||
)
|
pane.image.width.cint,
|
||||||
result = createTextureFromSurface(renderer, surface)
|
pane.image.height.cint,
|
||||||
destroy(surface)
|
cint 32,
|
||||||
|
pane.image.width.cint shl 2,
|
||||||
|
rmask, gmask, bmask, amask,
|
||||||
|
)
|
||||||
|
assert(not surface.isNil, $getError())
|
||||||
|
pane.texture = createTextureFromSurface(renderer, surface)
|
||||||
|
destroy(surface)
|
||||||
|
assert(not pane.texture.isNil, $getError())
|
||||||
|
result = pane.texture
|
||||||
|
|
||||||
|
iterator intersectingPanes*(well; view: Rect): Intersection =
|
||||||
|
var
|
||||||
|
intersect: Intersection
|
||||||
|
zoom = 1.0
|
||||||
|
while intersect.index < well.panes.len:
|
||||||
|
var paneRect = well.rectAt(intersect.index)
|
||||||
|
if (intersect.index mod 3) == 0:
|
||||||
|
let quad = rect(paneRect.xy, paneRect.wh * 2.0)
|
||||||
|
if not view.overlaps quad:
|
||||||
|
# all further panes are non-intersecting
|
||||||
|
break
|
||||||
|
zoom = zoom * 2.0
|
||||||
|
let margin = paneRect.wh / 9.0
|
||||||
|
paneRect.xy = paneRect.xy + margin
|
||||||
|
paneRect.wh = paneRect.wh - (margin * 2.0)
|
||||||
|
if view.overlaps paneRect:
|
||||||
|
intersect.dst = view and paneRect
|
||||||
|
intersect.src = rect(intersect.dst.xy - paneRect.xy, intersect.dst.wh) * zoom
|
||||||
|
yield(intersect)
|
||||||
|
inc(intersect.index)
|
||||||
|
|
Loading…
Reference in New Issue