1. Introduction

The MinimumDraw Library (MDL) is a lightweight, powerful graphics library originally created by UDI (http://udimac.web.fc2.com) and adapted by Michael Roberts for use in LiveCode projects. Version 0.92 includes bug fixes, optimizations, and enhanced debugging capabilities compared to the original 0.91 version.

MDL provides direct pixel-level control for drawing operations, making it ideal for custom graphics that would be difficult to achieve with LiveCode's standard drawing tools. The library is compact, efficient, and includes a wide range of functions for buffer management, drawing primitives, color handling, pixel manipulation, text rendering, and visual effects.

Key Features

• Buffer-based drawing system for efficient graphics operations
• Variety of drawing primitives (lines, rectangles, ovals, diamonds, stars)
• Pixel-level manipulation capabilities
• Built-in vector font rendering for text and numbers
• Color management with alpha channel support
• Visual transitions and effects
• Memory-efficient buffer operations
• Enhanced debugging capabilities

2. Getting Started

Installation

There are two primary methods to incorporate the MDL into your LiveCode project:

Method 1: Include in Stack Script

1. Copy the entire MDL script
2. Paste it into your stack script
3. Create an image object in your stack to use as a drawing canvas

Method 2: Use as a Library Stack

1. Save the MDL script as a standalone stack file (e.g., "lib_MDL_0.92.livecode")
2. In your project, use the following command to load the library:

start using stack "lib_MDL_0.92.livecode"

Basic Setup

Follow these steps to set up a basic drawing environment with MDL:

Step 1: Create an Image Object

Create an image object in your LiveCode stack to serve as your drawing canvas:

create image "myCanvas"
set the width of image "myCanvas" to 400
set the height of image "myCanvas" to 300

Step 2: Initialize the Drawing Buffer

Initialize the MDL buffer using your image:

MdMakeBuffer "myCanvas"

Step 3: Set Colors

Set the pen and background colors:

MdSetPenColor "255,0,0" -- Red
MdSetBgColor "255,255,255" -- White

Step 4: Draw Something

Draw a simple shape:

MdDrawRect "50,50,150,150", true -- Draw a filled rectangle

Step 5: Update the Display

Update the image with your drawing:

MdUpdate "myCanvas"

Complete Basic Example

Here's a complete example that puts everything together:

-- Create a canvas image if it doesn't exist
if there is not an image "myCanvas" then
   create image "myCanvas"
   set the width of image "myCanvas" to 400
   set the height of image "myCanvas" to 300
   set the loc of image "myCanvas" to the loc of this card
end if

-- Initialize MDL buffer
MdMakeBuffer "myCanvas"

-- Clear the canvas
MdSetBgColor "255,255,255" -- White
MdEraseScreen

-- Draw a red rectangle
MdSetPenColor "255,0,0" -- Red
MdDrawRect "50,50,150,150", true

-- Draw a blue circle
MdSetPenColor "0,0,255" -- Blue
MdDrawOval "200,50,300,150", true

-- Draw some text
MdSetPenColor "0,0,0" -- Black
MdDrawText "Hello, MDL!", "50,200", 15, "bold"

-- Update the display
MdUpdate "myCanvas"

3. Core Concepts

The Buffer System

MDL uses a buffer-based drawing system where operations are performed on a virtual canvas in memory before being applied to the visible image. This approach improves performance and enables more complex operations.

Key Buffer Concepts

• Primary Buffer: The main drawing area where operations are performed
• Buffer Stack: A temporary storage system for saving and restoring buffer states
• Dirty Rect Tracking: Optimization that tracks which areas of the buffer have changed

Coordinate System

MDL uses a pixel-based coordinate system with the following characteristics:

• Origin (0,0) is at the top-left corner
• X-coordinates increase from left to right
• Y-coordinates increase from top to bottom
• Coordinates are specified as integers

Rectangle Specification

Rectangles in MDL are specified as a string of four comma-separated integers representing the coordinates of the top-left and bottom-right corners:

"left,top,right,bottom"

Example: "50,50,150,150" defines a 100x100 pixel rectangle with its top-left corner at (50,50).

Color Specification

MDL supports multiple formats for specifying colors:

Pixel Array (Pix) Format

MDL uses a special format called "pix" for storing and manipulating image data. A pix consists of:

1. Width (in pixels)
2. Height (in pixels)
3. Image data (binary format)

These elements are stored as a comma-separated list with the binary image data following the dimensions.

4. Buffer Management

Buffer management functions handle the creation, manipulation, and updating of drawing buffers.

MdMakeBuffer "myCanvas"

MdNewBuffer 800, 600

MdUpdate "myCanvas"
MdUpdate "myCanvas", "pushLeft", "fast"

MdPushBuffer

MdPopBuffer

put MdGetBufferWidth() into tWidth

put MdGetBufferHeight() into tHeight

put MdGetBufferRect() into tBufferRect

MdSetPenColor "255,0,0" -- Red
MdFillScreen

MdSetBgColor "255,255,255" -- White
MdEraseScreen

MdScroll 10, 0 -- Scroll right 10 pixels
MdScroll 0, -20 -- Scroll up 20 pixels

Buffer Management Example

The following example demonstrates typical buffer management operations:

-- Initialize the main buffer
MdMakeBuffer "myCanvas"
MdSetBgColor "255,255,255" -- White
MdEraseScreen

-- Save the empty buffer state
MdPushBuffer

-- Draw something
MdSetPenColor "255,0,0" -- Red
MdDrawRect "50,50,150,150", true
MdUpdate "myCanvas"

-- Wait briefly to show the red rectangle
wait 1 second

-- Restore empty buffer state
MdPopBuffer
MdUpdate "myCanvas", "dissolve", "fast"

-- Draw something else
MdSetPenColor "0,0,255" -- Blue
MdDrawOval "50,50,150,150", true
MdUpdate "myCanvas"

5. Drawing Tools

MDL provides a variety of drawing tools for creating shapes and lines.

Line Drawing

MdDrawLine "10,10,100,100" -- Diagonal line

MdEraseLine "10,10,100,100" -- Erase a diagonal line

Rectangle Drawing

MdDrawRect "50,50,150,150", true -- Filled rectangle
MdDrawRect "200,50,300,150", false -- Outline only

MdEraseRect "50,50,150,150", true -- Erase a filled area

Oval Drawing

MdDrawOval "50,50,150,150", true -- Filled circle
MdDrawOval "200,50,300,100", false -- Outline oval

MdEraseOval "50,50,150,150", true -- Erase a circular area

Diamond Drawing

MdDrawDia "50,50,150,150", true -- Filled diamond

MdEraseDia "50,50,150,150", true -- Erase a diamond-shaped area

Star Drawing

MdDrawStar "50,50,150,150", true -- Filled star

MdEraseStar "50,50,150,150", true -- Erase a star-shaped area

Drawing Example

Here's an example that demonstrates various drawing tools:

-- Initialize the buffer
MdMakeBuffer "myCanvas"
MdSetBgColor "255,255,255" -- White
MdEraseScreen

-- Draw a red outline rectangle
MdSetPenColor "255,0,0" -- Red
MdDrawRect "20,20,120,80", false

-- Draw a blue filled oval
MdSetPenColor "0,0,255" -- Blue
MdDrawOval "150,20,250,80", true

-- Draw a green filled diamond
MdSetPenColor "0,255,0" -- Green
MdDrawDia "20,100,120,160", true

-- Draw a purple star outline
MdSetPenColor "128,0,128" -- Purple
MdDrawStar "150,100,250,160", false

-- Draw some connecting lines
MdSetPenColor "0,0,0" -- Black
MdDrawLine "120,50,150,50" -- Horizontal line connecting rectangle and oval
MdDrawLine "70,80,70,100" -- Vertical line connecting rectangle and diamond
MdDrawLine "200,80,200,100" -- Vertical line connecting oval and star

-- Update the display
MdUpdate "myCanvas"

6. Color Management

MDL provides several functions for managing colors and transparency.

MdSetPenColor "255,0,0" -- Red in RGB format
MdSetPenColor "#00FF00" -- Green in hex format
MdSetPenColor "128" -- Medium gray in grayscale format
MdSetPenColor "128,255,0,0" -- Semi-transparent red

put MdGetPenColor() into tCurrentColor

MdSetBgColor "255,255,255" -- White in RGB format
MdSetBgColor "#000000" -- Black in hex format
MdSetBgColor "200" -- Light gray in grayscale format

put MdGetBgColor() into tCurrentBgColor

-- Get a 50/50 blend of red and blue (purple)
put MdGetBlendColor("255,255,0,0", "255,0,0,255", 5) into tPurple

-- Get a 70/30 blend of red and blue
put MdGetBlendColor("255,255,0,0", "255,0,0,255", 3) into tRedPurple

Alpha Channel Operations

-- Create a pix and set half transparency
put MdBufferToPix() into tPix
MdSetPixAlpha tPix, 128
MdDrawPix tPix, "50,50"

-- Make the entire buffer semi-transparent
MdSetBufferAlpha 128

-- Make just a specific area semi-transparent
MdSetBufferAlpha 128, "50,50,150,150"

Color Management Example

Here's an example that demonstrates various color management techniques:

-- Initialize the buffer
MdMakeBuffer "myCanvas"
MdSetBgColor "255,255,255" -- White
MdEraseScreen

-- Draw overlapping shapes with different colors
MdSetPenColor "255,0,0" -- Red
MdDrawRect "50,50,150,150", true

-- Create a blend of red and blue (purple)
put MdGetBlendColor("255,255,0,0", "255,0,0,255", 5) into tPurple
MdSetPenColor tPurple
MdDrawRect "100,100,200,200", true

-- Create a semi-transparent green overlay
MdSetPenColor "128,0,255,0" -- Semi-transparent green
MdDrawOval "75,75,175,175", true

-- Update the display
MdUpdate "myCanvas"

7. Pixel Manipulation

MDL provides functions for manipulating individual pixels and pixel arrays.

Individual Pixel Operations

MdSetPixel "100,100" -- Set pixel at (100,100) to pen color

MdErasePixel "100,100" -- Set pixel at (100,100) to background color

put MdGetPixel("100,100") into tPixelColor

Pixel Array Operations

put MdNewPix(100, 100) into tEmptyPix

-- Convert entire image
put MdImageToPix("sourceImage") into tFullPix

-- Convert just a portion of the image
put MdImageToPix("sourceImage", "10,10,110,110") into tPartialPix

-- Convert entire buffer
put MdBufferToPix() into tBufferPix

-- Convert just a portion of the buffer
put MdBufferToPix("10,10,110,110") into tPartialPix

-- Copy entire pix
put MdCopyPix(tSourcePix) into tCopyPix

-- Copy just a portion
put MdCopyPix(tSourcePix, "10,10,60,60") into tPartialCopy

MdDrawPix tSpritePix, "100,100" -- Draw sprite at position 100,100

-- Create a small pattern
MdNewBuffer 10, 10
MdSetPenColor "0,0,0"
MdDrawRect "0,0,4,4", true
MdDrawRect "5,5,9,9", true
put MdBufferToPix() into tPatternPix

-- Restore original buffer and draw pattern as a fill
MdNewBuffer 400, 300
MdDrawPixPat tPatternPix, "50,50,350,250" -- Fill area with checkerboard pattern

Pixel Manipulation Example

Here's an example that demonstrates various pixel manipulation techniques:

-- Initialize the buffer
MdMakeBuffer "myCanvas"
MdSetBgColor "255,255,255" -- White
MdEraseScreen

-- Create a small 10x10 pixel pattern
MdNewBuffer 10, 10
MdSetPenColor "255,0,0" -- Red
MdDrawRect "0,0,4,4", true
MdSetPenColor "0,0,255" -- Blue
MdDrawRect "5,5,9,9", true
put MdBufferToPix() into tPattern

-- Restore main buffer
MdNewBuffer 400, 300
MdEraseScreen

-- Draw the pattern as a repeating tile in a rectangle
MdDrawPixPat tPattern, "50,50,350,150"

-- Create a sprite by drawing a simple shape
MdNewBuffer 20, 20
MdSetPenColor "0,255,0" -- Green
MdDrawOval "0,0,19,19", true
MdSetPenColor "0,0,0" -- Black
MdDrawOval "4,4,15,15", false
put MdBufferToPix() into tSprite

-- Make the sprite semi-transparent
MdSetPixAlpha tSprite, 128

-- Restore main buffer and draw the sprite at three locations
MdNewBuffer 400, 300
MdDrawPix tSprite, "100,200"
MdDrawPix tSprite, "200,200"
MdDrawPix tSprite, "300,200"

-- Draw individual pixels to create a dotted line
MdSetPenColor "0,0,0" -- Black
repeat with x = 50 to 350 step 10
    MdSetPixel x & ",180"
end repeat

-- Update the display
MdUpdate "myCanvas"

8. Text and Number Rendering

MDL includes functions for rendering text and numbers using built-in vector fonts.

Vector Text Drawing

-- Basic text drawing
MdDrawText "Hello World", "20,20"

-- Styled text
MdDrawText "BOLD TEXT", "20,50", 10, "bold"
MdDrawText "CENTERED", "200,80", 10, "center"
MdDrawText "LARGE", "20,110", 5, "X:2 Y:2"

-- Multi-line text
MdDrawText "Line 1" & return & "Line 2", "20,150"

-- Draw a simple arrow shape
MdDrawVec "254525", "50,50" -- Triangle

Number Display

-- Basic number display
MdDrawNumber 12345, "20,20"

-- Right-aligned with padding
MdDrawNumber 42, "100,50", 5, 0, "right" -- Shows "   42"

-- Thicker segments
MdDrawNumber 789, "20,80", 3, 2

-- Segment numbering:
--  1
-- 2 3
--  4
-- 5 6
--  7

-- Draw a custom pattern
MdDrawSegment "1234567", "20,20" -- All segments (8)
MdDrawSegment "3567", "40,20" -- Letter "C"
MdDrawSegment "134567", "60,20" -- Letter "E"

Text and Number Example

Here's an example that demonstrates text and number rendering:

-- Initialize the buffer
MdMakeBuffer "myCanvas"
MdSetBgColor "255,255,255" -- White
MdEraseScreen

-- Draw a title
MdSetPenColor "0,0,0" -- Black
MdDrawText "MDL TEXT DEMO", "50,30", 20, "bold center"

-- Draw standard text
MdSetPenColor "0,0,255" -- Blue
MdDrawText "Standard Text", "50,70"

-- Draw formatted text
MdSetPenColor "255,0,0" -- Red
MdDrawText "BOLD", "50,100", 4, "bold"
MdDrawText "WIDE", "120,100", 4, "X:1.5"
MdDrawText "TALL", "200,100", 4, "Y:1.5"
MdDrawText "BIG", "270,100", 3, "X:2 Y:2"

-- Draw multi-line text
MdSetPenColor "0,128,0" -- Green
MdDrawText "Line 1" & return & "Line 2" & return & "Line 3", "50,150"

-- Draw 7-segment numbers
MdSetPenColor "0,0,0" -- Black
MdDrawText "7-Segment Numbers:", "50,220"

-- Draw numbers with different weights
repeat with i = 0 to 3
    MdDrawNumber 8, (50 + i * 40) & ",250", 1, i
end repeat

-- Draw a digital clock display
MdSetPenColor "0,0,255" -- Blue
MdDrawNumber 12, "200,250", 2, 1
MdDrawText ":", "230,250", 1, "bold"
MdDrawNumber 34, "245,250", 2, 1

-- Custom segments to spell "HELLO"
MdSetPenColor "255,0,0" -- Red
MdDrawSegment "23567", "50,300" -- H
MdDrawSegment "13467", "80,300" -- E
MdDrawSegment "167", "110,300" -- L
MdDrawSegment "167", "140,300" -- L
MdDrawSegment "23567", "170,300" -- O

-- Update the display
MdUpdate "myCanvas"

9. Visual Effects

MDL provides a variety of visual effects and transitions that can be applied when updating the display.

put MdGetEffectList() into tEffects

Applying Effects

Visual effects are applied using the MdUpdate function with additional parameters:

MdUpdate "myCanvas", pEffect, pSpeed

Effect Speed Options

• "slow" - Slower transition
• "fast" - Faster transition
• omit - Normal speed (default)

Available Effects

Push Effects

Pushes the new content onto the screen from a direction, moving the old content out.

• "pushUp" - New content pushes up from bottom
• "pushDown" - New content pushes down from top
• "pushLeft" - New content pushes in from right
• "pushRight" - New content pushes in from left

Scroll Effects

Scrolls the content in a specific direction.

• "scrollUp" - Content scrolls upward
• "scrollDown" - Content scrolls downward
• "scrollLeft" - Content scrolls to the left
• "scrollRight" - Content scrolls to the right

Wipe Effects

Wipes the new content onto the screen in a specific direction.

• "wipeUp" - Wipes upward from bottom
• "wipeDown" - Wipes downward from top
• "wipeLeft" - Wipes from right to left
• "wipeRight" - Wipes from left to right
• "wipeOpen" - Wipes from center outward
• "wipeClose" - Wipes from edges inward

Reveal Effects

Reveals the new content gradually in a specific direction.

• "revealUp" - Reveals upward
• "revealDown" - Reveals downward
• "revealLeft" - Reveals from right to left
• "revealRight" - Reveals from left to right

Square Effects

Square-based transitions.

• "squareOpen" - Square expands from center
• "squareClose" - Square contracts to center

Clam Effects

Clam-shell style transitions.

• "clamOpen" - Opens like a clam shell
• "clamClose" - Closes like a clam shell

Dissolve Effects

Dissolve-based transitions.

• "dissolve" - Standard dissolve effect
• "dissolveNight" - Dissolve to black then to new content
• "dissolveDay" - Dissolve to white then to new content

Visual Effects Example

Here's an example that demonstrates several visual effects:

-- Initialize the buffer
MdMakeBuffer "myCanvas"

-- Function to draw a test screen
on drawTestScreen pScreenNum
   MdEraseScreen
   MdSetPenColor "0,0,0" -- Black
   MdDrawText "Screen " & pScreenNum, "20,20", 10, "bold"
   
   -- Draw different shapes based on screen number
   if pScreenNum = 1 then
      MdSetPenColor "255,0,0" -- Red
      MdDrawRect "50,50,150,150", true
   else if pScreenNum = 2 then
      MdSetPenColor "0,0,255" -- Blue
      MdDrawOval "50,50,150,150", true
   else if pScreenNum = 3 then
      MdSetPenColor "0,255,0" -- Green
      MdDrawStar "50,50,150,150", true
   else
      MdSetPenColor "128,0,128" -- Purple
      MdDrawDia "50,50,150,150", true
   end if
end drawTestScreen

-- Draw the first screen
drawTestScreen 1
MdUpdate "myCanvas"

-- Wait briefly
wait 1 second

-- Test various effects
drawTestScreen 2
MdUpdate "myCanvas", "pushLeft", "fast"
wait 1 second

drawTestScreen 3
MdUpdate "myCanvas", "dissolve", "normal"
wait 1 second

drawTestScreen 4
MdUpdate "myCanvas", "wipeOpen", "slow"
wait 1 second

-- Return to first screen with a different effect
drawTestScreen 1
MdUpdate "myCanvas", "squareClose", "fast"

10. Utility Functions

MDL provides a variety of utility functions for rectangle manipulation, data handling, and other common operations.

Rectangle Utilities

put MdPackRect(10, 20, 110, 120) into tRect -- "10,20,110,120"

MdUnpackRect "10,20,110,120", tLeft, tTop, tRight, tBottom

put "10,20,110,120" into tRect
MdOffsetRect tRect, 20, 30
-- tRect is now "30,50,130,150"

put "10,20,110,120" into tRect
MdInsetRect tRect, 10, 10
-- tRect is now "20,30,100,110" (smaller)

put "10,20,110,120" into tRect
MdInsetRect tRect, -10, -10
-- tRect is now "0,10,120,130" (larger)

if MdPtInRect("50,60", "10,20,110,120") then
   -- Point is inside the rectangle
end if

put "10,20,110,120" into tRect
MdZoomRect tRect, 2, 1.5
-- tRect is now "10,20,210,170" (wider and taller)

Location Utilities

put "50,60" into tLoc
MdOffsetLoc tLoc, 10, 20
-- tLoc is now "60,80"

Data Utilities

put MdPackData(100, "ABCD") into tRepeatedData
-- Results in "ABCDABCDABCD..." repeated to 100 bytes

put 10 into tValue1
put 20 into tValue2
MdSwap tValue1, tValue2
-- tValue1 is now 20, tValue2 is now 10

put "1,2,3,4,5" into tList
MdShuffleItems tList
-- tList might now be something like "4,1,5,2,3"

put MdGetShuffeItems(10) into tShuffledList
-- tShuffledList might be something like "7,3,1,10,6,2,8,5,9,4"

put MdGetHelp() into tHelpText

Utility Functions Example

Here's an example that demonstrates various utility functions:

-- Initialize the buffer
MdMakeBuffer "myCanvas"
MdSetBgColor "255,255,255" -- White
MdEraseScreen

-- Create a rectangle and manipulate it
put "50,50,150,150" into tRect
MdSetPenColor "255,0,0" -- Red
MdDrawRect tRect, false

-- Offset the rectangle and draw it
MdOffsetRect tRect, 20, 20
MdSetPenColor "0,255,0" -- Green
MdDrawRect tRect, false

-- Inset the rectangle and draw it
MdInsetRect tRect, 10, 10
MdSetPenColor "0,0,255" -- Blue
MdDrawRect tRect, false

-- Create a shuffled list of positions
put MdGetShuffeItems(10) into tShuffledList

-- Draw dots at shuffled positions
MdSetPenColor "0,0,0" -- Black
repeat for each item i in tShuffledList
    put 200 + (i * 15) into tX
    put 100 into tY
    MdDrawOval (tX - 5) & "," & (tY - 5) & "," & (tX + 5) & "," & (tY + 5), true
end repeat

-- Use point-in-rectangle testing
put "50,200,250,300" into tTestRect
MdDrawRect tTestRect, false

-- Draw text explaining the test
MdDrawText "Click inside or outside the rectangle:", "50,180"

-- Update the display
MdUpdate "myCanvas"

-- In a mouseDown handler, you could do this:
on mouseDown
    if MdPtInRect(the mouseH & "," & the mouseV, tTestRect) then
        answer "You clicked inside the rectangle!"
    else
        answer "You clicked outside the rectangle!"
    end if
end mouseDown

11. Debugging and Optimization

MDL version 0.92 includes enhanced debugging capabilities to help you identify and resolve issues in your code.

Debugging

The primary debugging tool in MDL 0.92 is the debugLog function:

-- Create a debug output field if it doesn't exist
if there is not a field "DebugOutput" then
   create field "DebugOutput"
   set the rect of field "DebugOutput" to "10,400,500,600"
   set the vScrollbar of field "DebugOutput" to true
end if

-- Log debug messages
debugLog "Starting MDL operations..."
MdMakeBuffer "myCanvas"
debugLog "Buffer created with dimensions: " & MdGetBufferWidth() & "x" & MdGetBufferHeight()
MdDrawRect "50,50,150,150", true
debugLog "Rectangle drawn at 50,50,150,150"

Performance Optimization Tips

To get the best performance from MDL, consider these optimization strategies:

Buffer Management

• Minimize buffer creation: Create new buffers only when necessary, as this is a memory-intensive operation.
• Use appropriate buffer sizes: Larger buffers consume more memory and are slower to process.
• Limit push/pop operations: The stack can only store one buffer state, so excessive push/pop operations can be inefficient.

Drawing Operations

• Batch similar operations: Group similar drawing operations to reduce overhead.
• Use filled shapes when appropriate: Filled shapes can be faster to draw than complex patterns of lines.
• Consider using pixel patterns: For repeating patterns, MdDrawPixPat can be more efficient than drawing multiple individual shapes.

Memory Management

• Release unused resources: Clear large variables when no longer needed.
• Monitor memory usage: Use the debugLog function to track memory-intensive operations.
• Be cautious with large pixels arrays: Creating and manipulating large pixel arrays can consume significant memory.

Debugging Example

Here's an example that demonstrates debugging techniques:

-- Create a debug output field if it doesn't exist
if there is not a field "DebugOutput" then
   create field "DebugOutput"
   set the rect of field "DebugOutput" to "10,400,500,600"
   set the vScrollbar of field "DebugOutput" to true
   set the lockText of field "DebugOutput" to false
end if

-- Initialize MDL with debugging
debugLog "Starting MDL initialization"
MdMakeBuffer "myCanvas"
debugLog "Buffer initialized: " & MdGetBufferWidth() & "x" & MdGetBufferHeight()

-- Track memory usage and performance
put the milliseconds into tStartTime
MdSetBgColor "255,255,255"
MdEraseScreen
debugLog "Screen erased in " & (the milliseconds - tStartTime) & "ms"

-- Test drawing performance
put the milliseconds into tStartTime
MdSetPenColor "255,0,0"
repeat with i = 1 to 10
   MdDrawRect (i * 20) & "," & (i * 20) & "," & (i * 20 + 100) & "," & (i * 20 + 100), true
   debugLog "Drew rectangle " & i & " at " & (i * 20) & "," & (i * 20)
end repeat
debugLog "Drew 10 rectangles in " & (the milliseconds - tStartTime) & "ms"

-- Check pixel operations
put the milliseconds into tStartTime
put MdGetPixel("50,50") into tPixelColor
debugLog "Pixel at 50,50 is " & tPixelColor & " (retrieved in " & (the milliseconds - tStartTime) & "ms)"

-- Update with timing
put the milliseconds into tStartTime
MdUpdate "myCanvas"
debugLog "Updated display in " & (the milliseconds - tStartTime) & "ms"

-- Final summary
debugLog "All operations completed"

12. Known Limitations

While MDL is a powerful library, it has some limitations that you should be aware of:

Buffer Stack Limitations

• The buffer stack can only store one level of buffer state (one push/pop operation).
• Attempting multiple push operations without corresponding pop operations may lead to memory issues.

Performance Considerations

• Large buffer sizes (above 1000x1000 pixels) may cause performance degradation.
• Complex operations with alpha blending can be significantly slower than operations without transparency.
• Drawing many small shapes is generally slower than drawing fewer larger shapes.

Text and Font Limitations

• The built-in vector font supports only a limited character set (uppercase letters, numbers, and basic punctuation).
• Text rendering does not support advanced typography features like kerning or variable width fonts.
• Non-English characters are generally not supported in the built-in font.

Visual Effects Limitations

• Visual effects may not perform well on very large buffers.
• Some effects may appear choppy on slower systems.

Memory Management

• MDL does not provide automatic garbage collection for pixel arrays and other resources.
• Care must be taken to manage memory manually in complex applications.

13. Version History

Version 0.92

Released: September 2024

• Added enhanced debugging capabilities with the debugLog function
• Fixed bugs in MdDrawLine, MdDrawDia, and MdDrawStar functions
• Optimized memory usage in buffer operations
• Improved error handling in buffer manipulation functions
• Enhanced documentation and comments

Version 0.91

Released: April 2024

• Added MdDrawOval, MdDrawDia functions
• Removed MdDrawCircle (replaced by MdDrawOval)
• Changed MdDrawStar implementation
• Bug fixes and performance improvements

Version 0.9

Released: Unknown date (original version by UDI)

• Initial public release
• Basic drawing functionality
• Buffer management
• Color handling
• Text rendering