Here is the news summary for September 2012, top new items are initial FreePascal support and introduction of lambdas syntax.
Part 1 left us with a large cryptic looking string (a recursively applied grammar applied to an axiom, for the purists).
In part 2 we’ll go from that big string to a visual representation, by making use of that string as a set of commands for a turtle language.
For more details, read the turtle graphics article in wikipedia, it’s (at the moment) short and to the point.
The class of grammar-based fractals known as Lindenmayer system allows generating an interesting variety of geometrical and botanical visuals.
To the right is a representation of a “Fractal Plant”, which is generated from just two simple (if cryptic-looking) rules applied recursively.
In simple terms, L-System starts from a string (called an axiom), to which rules are applied recursively. Rules are a set of substitution strings for characters in the original string.
With SmartMS v1.0.1 out you can now use WebGL!
Download HelloWebGL.zip (51 kB), it contains the first demo (in .opp form and pre-compiled), as well as the initial WebGLScene units which you’ll have to copy to your “Libraries” folder (the WebGL import units should have been delivered in v1.0.1).
- GLS.Vectors: contains vector manipulations types as well as a collection of helpers to operate on them.
- GLS.Base: contains Pascal classes to simplify basic OpenGL tasks revolving around buffers and shaders.
Recent additions to DWScript… as well as for next Smart MS version 😉
Here is a small class to facilitate working with off-screen dynamic images in Smart MS: w3BufferedImage.zip (1kb)
It’ll be in the next Smart update, but you can already use it, it was introduced as part of WarTrail, as a way to optimize graphic elements that are complex and don’t change over several frames (text, tiled background, etc.).
You can use it to bundle graphic layer element, for instance in WarTrail the top & bottom areas (with scores & buttons) are in two distinct buffered images, and when you bring up the “menu” for a tower upgrade, that’s another buffered image.
To use it, you simply create it, and specify its size, f.i. a 200×50 buffer is created with
buffer := TBufferedImage.Create(200, 50);
then you need to setup its OnRedraw event, which is a procedure that passes the buffered image itself. This is here that you’ll have to (re)draw whatever your buffered image is meant to contain
buffer.OnRedraw := procedure (Sender : TBufferedImage) begin Sender.Canvas... your code here ... end;
Inplace of the anonymous methods, you can also use a standalone procedure or a regular method (and it might be preferable if what you draw isn’t trivial), as they’re all compatible, the compiler takes care of everything that would differentiate a “procedure” from a “procedure of object” or a “reference to procedure” in Delphi.
When you need to draw the buffered image, you can use one of its Draw() or DrawScaled() methods, basically telling it to redraw itself on another canvas. The available methods are currently:
// top-left anchor procedure Draw(dest : TW3Canvas; x, y : Float); overload; procedure Draw(dest : TW3Canvas; x, y : Float; const sourceRect : TRect); overload; // center anchor procedure DrawScaled(dest : TW3Canvas; x, y, scale : Float);
The first two are top-left anchored, ie. the x & y are the top-left of where the image will be drawn, and you can optionally specify a sourceRect, so that only part of your buffered image will be drawn (note that for tiled images, the w3SpriteSheet class is preferable, it offers more features like rotations and automatic sourceRect computations)
For DrawScaled, the x & y are the center of where the image will be drawn.
When you need the image invalidated, you just call it’s Invalidate method, then the next Draw call will first invoke OnRedraw. You can also use the Prepare method to have OnRedraw be invoked at a time of your choosing instead.
Last thing, if you need to draw with alpha-transparency (f.i. to fade-in or out), just use the GlobalAlpha property of the target canvas, f.i.:
myCanvas.GlobalAlpha:=0.5; // 50% opacity bufferedImage.Draw(myCanvas, 50, 50); // drawn at top, left = 50,50 myCanvas.GlobalAlpha:=1; // restore 100% opacity
That’s about it! Now you can efficiently make use of custom dynamic elements, such as multi-layered text with shadow, that would otherwise be too complex to redraw from scratch at each frame!
Amongst the samples included with Delphi, you can find a “Meteors” clone. With SmartMobileStudio approaching the next beta milestone, I gave it a run at compiling old Delphi code, VCL, TCanvas-based, that was never intended to run Web-side… but now does! Click here or the image below to test it!
A virtual method that is never called, in its base class nor any of its subclasses, will now be eliminated.
In the small game Nickel Iron which was used as illustration, that further reduces the generated output by almost 10% to just 92 kB “raw”, or 23 kB compressed. The gains come from not just the unused implementations being removed, but also a reduction in the size of the various VMTs.
25 kB 23 kB.
- faster download: faster application installation or startup.
- faster parsing for the browser: faster startup.
And smaller also means you can have far more complex applications for a given size budget.