Fill some geometry. The geometry should be "looping", ie. the last point of the last primitive should be equal to the first point of the first primitive.

The primitive should be connected.

fill $ circle (V2 100 100) 75

This function let you choose how to fill the primitives in case of self intersection. See FillMethod documentation for more information.

Render a mesh patch as an object. Warning, there is no antialiasing on mesh patch objects!

Will stroke geometry with a given stroke width. The elements should be connected

stroke 5 JoinRound (CapRound, CapRound) $ circle (V2 100 100) 75

With stroke geometry with a given stroke width, using a dash pattern.

dashedStroke [5, 10, 5] 3 JoinRound (CapRound, CapStraight 0) $
    line (V2 0 100) (V2 200 100)

With stroke geometry with a given stroke width, using a dash pattern. The offset is there to specify the starting point into the pattern, the value can be negative.

dashedStrokeWithOffset 3 [5, 10, 5] 3 JoinRound (CapRound, CapStraight 0) $
    line (V2 0 100) (V2 200 100)

Draw a string at a given position. Text printing imply loading a font, there is no default font (yet). Below an example of font rendering using a font installed on Microsoft Windows.

import Graphics.Text.TrueType( loadFontFile )
import Codec.Picture( PixelRGBA8( .. ), writePng )
import Graphics.Rasterific
import Graphics.Rasterific.Texture

main :: IO ()
main = do
  fontErr <- loadFontFile "test_fonts/DejaVuSans.ttf"
  case fontErr of
    Left err -> putStrLn err
    Right font ->
      writePng "text_example.png" .
          renderDrawing 300 70 (PixelRGBA8 255 255 255 255)
              . withTexture (uniformTexture $ PixelRGBA8 0 0 0 255) $
                      printTextAt font (PointSize 12) (V2 20 40)
                           "A simple text test!"

You can use any texture, like a gradient while rendering text.

Print complex text, using different texture font and point size for different parts of the text.

let blackTexture =
      Just . uniformTexture $ PixelRGBA8 0 0 0 255
    redTexture =
      Just . uniformTexture $ PixelRGBA8 255 0 0 255
in
printTextRanges (V2 20 40)
  [ TextRange font1 (PointSize 12) "A complex " blackTexture
  , TextRange font2 (PointSize 8) "text test" redTexture]

Define the texture applyied to all the children draw call.

withTexture (uniformTexture $ PixelRGBA8 0 0x86 0xc1 255) $ do
    fill $ circle (V2 50 50) 20
    fill $ circle (V2 100 100) 20
    withTexture (uniformTexture $ PixelRGBA8 0xFF 0x53 0x73 255)
         $ circle (V2 150 150) 20

Draw some geometry using a clipping path.

withClipping (fill $ circle (V2 100 100) 75) $
    mapM_ (stroke 7 JoinRound (CapRound, CapRound))
      [line (V2 0 yf) (V2 200 (yf + 10))
                     | y <- [5 :: Int, 17 .. 200]
                     , let yf = fromIntegral y ]

Will render the whole subaction with a given group opacity, after each element has been rendered. That means that completly opaque overlapping shapes will be rendered transparently, not one after another.

withTexture (uniformTexture $ PixelRGBA8 0xFF 0x53 0x73 255) $
    stroke 3 JoinRound (CapRound, CapRound) $
        line (V2 0 100) (V2 200 100)

withGroupOpacity 128 $ do
   withTexture (uniformTexture $ PixelRGBA8 0 0x86 0xc1 255) .
      fill $ circle (V2 70 100) 60
   withTexture (uniformTexture $ PixelRGBA8 0xff 0xf4 0xc1 255) .
      fill $ circle (V2 120 100) 60

To be compared to the item opacity

withTexture (uniformTexture $ PixelRGBA8 0xFF 0x53 0x73 255) $
    stroke 3 JoinRound (CapRound, CapRound) $
        line (V2 0 100) (V2 200 100)
withTexture (uniformTexture $ PixelRGBA8 0 0x86 0xc1 128) .
   fill $ circle (V2 70 100) 60
withTexture (uniformTexture $ PixelRGBA8 0xff 0xf4 0xc1 128) .
   fill $ circle (V2 120 100) 60

Draw all the sub drawing commands using a transformation.

This command allows you to draw primitives on a given curve, for example, you can draw text on a curve:

let path = Path (V2 100 180) False
                [PathCubicBezierCurveTo (V2 20 20) (V2 170 20) (V2 300 200)] in
stroke 3 JoinRound (CapStraight 0, CapStraight 0) path
withTexture (uniformTexture $ PixelRGBA8 0 0 0 255) $
  withPathOrientation path 0 $
    printTextAt font (PointSize 24) (V2 0 0) "Text on path"

You can note that the position of the baseline match the size of the characters.

You are not limited to text drawing while using this function, you can draw arbitrary geometry like in the following example:

let path = Path (V2 100 180) False
                [PathCubicBezierCurveTo (V2 20 20) (V2 170 20) (V2 300 200)]
withTexture (uniformTexture $ PixelRGBA8 0 0 0 255) $
  stroke 3 JoinRound (CapStraight 0, CapStraight 0) path

withPathOrientation path 0 $ do
  printTextAt font (PointSize 24) (V2 0 0) "TX"
  fill $ rectangle (V2 (-10) (-10)) 30 20
  fill $ rectangle (V2 45 0) 10 20
  fill $ rectangle (V2 60 (-10)) 20 20
  fill $ rectangle (V2 100 (-15)) 20 50

Structure defining how to render a text range

Font size expressed in points. You must convert size expressed in pixels to point using the DPI information. See pixelSizeInPointAtDpi

This constraint ensure that a type is a pixel and we're allowed to modulate it's color components generically.

This constraint tells us that pixel component must also be pixel and be the "bottom" of component, we cannot go further than a PixelBaseComponent level.

Tested pixel types are PixelRGBA8 & Pixel8

Function to call in order to start the image creation. Tested pixels type are PixelRGBA8 and Pixel8, pixel types in other colorspace will probably produce weird results. Default DPI is 96

Function to call in order to start the image creation. Tested pixels type are PixelRGBA8 and Pixel8, pixel types in other colorspace will probably produce weird results.

Transform a path description into a list of renderable primitives.

Reification of texture type

Monad used to record the drawing actions.

Typeclass intented at pixel value modulation. May be throwed out soon.

A 2-dimensional vector

>>> pure 1 :: V2 Int
V2 1 1

>>> V2 1 2 + V2 3 4
V2 4 6

>>> V2 1 2 * V2 3 4
V2 3 8

>>> sum (V2 1 2)
3

Represent a point

Represent a vector

Describe a cubic bezier spline, described using 4 points.

stroke 4 JoinRound (CapRound, CapRound) $
   CubicBezier (V2 0 10) (V2 205 250) (V2 (-10) 250) (V2 160 35)

Describe a simple 2D line between two points.

fill [ Line (V2 10 10) (V2 190 10)
     , Line (V2 190 10) (V2 95 170)
     , Line (V2 95 170) (V2 10 10)]

Describe a quadratic bezier spline, described using 3 points.

fill [Bezier (V2 10 10) (V2 200 50) (V2 200 100)
     ,Bezier (V2 200 100) (V2 150 200) (V2 120 175)
     ,Bezier (V2 120 175) (V2 30 100) (V2 10 10)]

This datatype gather all the renderable primitives, they are kept separated otherwise to allow specialization on some specific algorithms. You can mix the different primitives in a single call :

fill [ toPrim $ CubicBezier (V2 50 20) (V2 90 60)
                            (V2  5 100) (V2 50 140)
     , toPrim $ Line (V2 50 140) (V2 120 80)
     , toPrim $ Line (V2 120 80) (V2 50 20) ]

Describe a path in a way similar to many graphical packages, using a "pen" position in memory and reusing it for the next "move" For example the example from Primitive could be rewritten:

fill $ Path (V2 50 20) True
   [ PathCubicBezierCurveTo (V2 90 60) (V2  5 100) (V2 50 140)
   , PathLineTo (V2 120 80) ]

Actions to create a path

Generalizing constructors of the Primitive type to work generically.

All the rasterization works on lists of primitives, in order to ease the use of the library, the Geometry type class provides conversion facility, which help generalising the geometry definition and avoid applying Primitive constructor.

Also streamline the Path conversion.

This typeclass is there to help transform the geometry, by applying a transformation on every point of a geometric element.

Typeclass helper gathering all the points of a given geometry.

Class used to calculate bounds of various geometrical primitives. The calculated is precise, the bounding should be minimal with respect with drawn curve.

Represent the minimal axis aligned rectangle in which some primitives can be drawn. Should fit to bezier curve and not use directly their control points.

Extract the width of the bounds

Extract the height of the bound

Extract the position of the lower left corner of the bounds.

Return a simple line ready to be stroked.

stroke 17 JoinRound (CapRound, CapRound) $
    line (V2 10 10) (V2 180 170)

Generate a list of primitive representing a rectangle

fill $ rectangle (V2 30 30) 150 100

Generate a list of primitive representing a rectangle with rounded corner.

fill $ roundedRectangle (V2 10 10) 150 150 20 10

Generate a list of primitive representing a circle.

fill $ circle (V2 100 100) 75

Generate a list of primitive representing an ellipse.

fill $ ellipse (V2 100 100) 75 30

Generate a strokable line out of points list. Just an helper around lineFromPath.

stroke 4 JoinRound (CapRound, CapRound) $
   polyline [V2 10 10, V2 100 70, V2 190 190]

Generate a fillable polygon out of points list. Similar to the polyline function, but close the path.

fill $ polygon [V2 30 30, V2 100 70, V2 80 170]

Draw an image with the desired size

drawImageAtSize textureImage 2 (V2 30 30) 128 128

Simply draw an image into the canvas. Take into account any previous transformation performed on the geometry.

drawImage textureImage 0 (V2 30 30)

This function perform an optimisation, it will render a drawing to an image interanlly and create a new order to render this image instead of the geometry, effectively cuting the geometry generation part.

It can save execution time when drawing complex elements multiple times.

Clip the geometry to a rectangle.

Create a list of bezier patch from a list of points,

bezierFromPath [a, b, c, d, e] == [Bezier a b c, Bezier c d e]
bezierFromPath [a, b, c, d, e, f] == [Bezier a b c, Bezier c d e]
bezierFromPath [a, b, c, d, e, f, g] ==
    [Bezier a b c, Bezier c d e, Bezier e f g]

Transform a list a point to a list of lines

lineFromPath [a, b, c, d] = [Line a b, Line b c, Line c d]

Create a list of cubic bezier patch from a list of points.

cubicBezierFromPath [a, b, c, d, e] = [CubicBezier a b c d]
cubicBezierFromPath [a, b, c, d, e, f, g] =
   [CubicBezier a b c d, CubicBezier d e f g]

Gives the orientation vector for the start of the primitive.

Gives the orientation vector at the end of the primitive.

Extract the first point of the primitive.

Return the last point of a given primitive.

Direction of the arc

Translate an arc with a definition similar to the one given in Cairo to a list of bezier path command

Describe how to display the join of broken lines while stroking.

Describe how we will "finish" the stroking that don't loop.

Describe the behaviour of samplers and texturers when they are out of the bounds of image and/or gradient.

Tell how to fill complex shapes when there is self intersections. If the filling mode is not specified, then it's the FillWinding method which is used.

The examples used are produced with the following function:

fillingSample :: FillMethod -> Drawing px ()
fillingSample fillMethod = fillWithMethod fillMethod geometry where
  geometry = transform (applyTransformation $ scale 0.35 0.4
                                           <> translate (V2 (-80) (-180)))
     [ Path (V2 484 499) True
         [ PathCubicBezierCurveTo (V2 681 452) (V2 639 312) (V2 541 314)
         , PathCubicBezierCurveTo (V2 327 337) (V2 224 562) (V2 484 499)
         ]
     , Path (V2 136 377) True
         [ PathCubicBezierCurveTo (V2 244 253) (V2 424 420) (V2 357 489)
         , PathCubicBezierCurveTo (V2 302 582) (V2 47 481) (V2 136 377)
         ]
     , Path (V2 340 265) True
         [ PathCubicBezierCurveTo (V2 64 371) (V2 128 748) (V2 343 536)
         , PathCubicBezierCurveTo (V2 668 216) (V2 17 273) (V2 367 575)
         , PathCubicBezierCurveTo (V2 589 727) (V2 615 159) (V2 340 265)
         ]
     ]

How do we want to perform color/image interpolation within the patch.

Dash pattern to use

Transform a drawing into a serie of low-level drawing orders.

This function will spit out drawing instructions to help debugging.

The outputted code looks like Haskell, but there is no guarantee that it is compilable.