This is a program which demonstrates the amazing graphics capabilities of QB64, using simple coding techniques and without resorting to the complexities of Open_GL.  Impressive 3D effects can be obtained using the QB64 _MAPTRIANGLE statement: the 3D _MAPTRIANGLE method gives a convincing 3D display along with perspective.

The program features a number of animations (some 2D and some 3D) enhanced with accompanying audio.  In order to run this program you will need to download the zip file from the URL.  Extract the folder "pi in the sky" and place that folder in your QB64 folder – be careful not to create and extra folder layer.  Load the "pi in the sky" bas file and run (QB64v2 or higher).  You will need to have the Run Option "Output EXE to Source Folder" checked.  The program uses quite a bit of processor power (up to nearly 2 CPU's-worth at times on my Core i5 machine) and a lot of memory, so you'll need a modern machine.  At program start there is a delay while the disk files are read and loaded into memory (and there are image manipulations being carried out).

The display shows a landscape within which a variety of animations will occur.  It takes approximately 10 mins to run through all of the animation sequences.  There are earthly animations and celestial animations.  During the celestial animations, there are ghostly appearances in the terrestrial graveyard and related sounds.

In the blue text I give details of the program coding methods, descriptions of the animations and background information.  You do not need to read the blue text to run and enjoy (well, maybe!) the program.

Download:
https://www.dropbox.com/s/goekmtjtmt0n7m1/pi%20in%20the%20sky.zip?dl=1

I started this project purely because the phrase "pi in the sky" popped into my head, and so started coding to produce a pi symbol randomly rotating about three axes in 3D.  The obvious QB64 method is _MAPTRIANGLE(3D).  All you have to do is plug in the mathematics of rotations of a rectangle about the three Cartesian co-ordinates and place the resulting corner positions into _MAPTRIANGLE(3D).  The surface of the image is everywhere flat, but its corners move freely in the 3D space of _MAPTRIANGLE(3D), and as (vanishing point) perspective is coded into the _MAPTRIANGLE(3D) method, a very good-looking 3D display is produced.  I must emphasise that this QB64 method is so well produced that it can be used by novice and low-skill coders.  In the Skill Range Venn Diagram, I sit in the low-skill sector, and I cannot do the real-3D (SUB _GL) stuff of our competent members.

To do this project I have had to go back to school-level calculus, geometry & algebra; oh, happy days!  Having got the pi animation working, I then set about adding other features to demonstrate what can done with QB64 graphics.  The final project uses both software and hardware imaging, and for the hardware images both _MAPTRIANGLE(2D) and _MAPTRIANGLE(3D).  The program is designed to show how such images will interact.  The program also uses a load of _MEM object processing in order to manipulate images, both at initiation and on-the-fly in real time.

Background Image
The graphical animations take place in front of a background image.  This background (a landscape with added features) is software (,32 type image) and has a single _PUTIMAGE directly after creating the 32-bit screen.  This image stays displayed despite the running loop executing a _DISPLAY at each cycle (30 fps).  All other images are hardware (,33 type) and are placed in front of the background (naturally!).

pi Animation
In order to change colour as the pi moves around, real-time editing of the image file is required.  This is achieved by _MEM object manipulation at each display cycle.  _MEM processing can only be achieved with software images, whereas the pi image is hardware.  So, firstly a software image is created at initiation and a _MEM object of the software image is taken.  Then at each cycle that object is manipulated and the software image is copied to hardware and that image is displayed.  The hardware image is freed each cycle at the earliest opportunity.  This method is repeated for all other real-time image manipulations.

Earthly and Celestial Animations
There are both earth-bound and celestial animations.  The earth-bound animations (along with clouds and some rain) are continuous, whereas the celestial animations cycle in a random manner.

Earthly Animations

Beehive
Bees emerge and swarm from a suspended beehive in the foreground.  The bees fly in the 3D space of _MAPTRIANGLE(3D) and both the hive and the bee images (QB64 bee logo) are hardware (3D: ,33 image type).  After emerging in an outward direction the bees turn and fly in the opposite direction away from the viewer "into" the screen.  Bees in front of the hive occlude it, and behind the hive they are occluded by it.  As the hive image is a flat object, a bee moving from directly in front of to directly behind the hive travels right through it.  The bees all appear to move to the right as they move away, but this is just the perspective.  All the bees return to the hive after their flight out.  In order to achieve such paths, the bees are flying in parabolic curves in the 3D space.  There is the sound of humming bees, the more bees that are out the louder they sound.

Fountain
A fountain squirts droplets of water into the pond.  There are 500 droplets of water each moving under gravity in the _MAPTRIANGLE(3D) space.  Although as many droplets are sent behind the fountain as in the front, it looks as if they only fall at the front.  This is just an artefact of the perspective.

Windmill
The moving windmill sails clearly show the 3D and perspective effects  of _MAPTRIANGLE(3D).  The sails appear to move in and out as they rotate and are smaller the further away they are.  As the bees, fountain droplets and windmill sails are _MAPTRIANGLE(3D) images, they occlude each other dependent upon which is further away.  The windmill itself is not a 3D object but part of the software background.  The industrious Miller Heitor looks out from the windmill.

Clouds and Rain
Clouds pass above.  They are slightly transparent so that objects behind can still be seen.  One of the clouds is rain-bearing and a shower of 500 raindrops passes along.  The clouds and raindrops are not 3D, and occlusions occur based upon order in which the _PUTIMAGE functions occur.

Flower Growth
As the rain passes, flowers can spring up in the earth.  Flower images are 2D.

Rainbow
When the rain is in just the right place, a rainbow appears.  The rainbow is a _MAPTRIANGLE(3D) image and occlusions with other such objects are dependent upon distance into the screen.

Graveyard
Ghostly images appear in the graveyard when certain celestial events take place.  The gravestones themselves are part of the background 2D image.

Celestial Animations
At times, celestial animations occur.  When a celestial animation takes place, there are accompanying ghostly images in the graveyard.  There is accompanying related audio.

Concorde
Fly-past of a supersonic passenger aircraft.  The Concorde image is 2D.  The aircraft creates a sonic boom.  A ghostly image of Douglas Bader appears in the graveyard.  Eventually the graveyard image gradually disappears into thin air.  This graphic effect is achieved, again, by _MEM object real-time processing (in this case changing alpha sequentially).  Images here are 2D.

ET
A silhouette from a well-known science fiction film travels across the sky.  The image is 2D.  A ghostly film director appears in the graveyard.

Star Trek
The spacecraft from a well-known science-fiction television series moves through the _MAPTRIANGLE(3D) space coming from the far distance.  Members of the crew appear in the graveyard.  Because the graveyard images are small and transparent, it is rather difficult to recognise who they are.  From left to right they are McCoy, Uhura, Kirk, Sulu and Spock.

ISS
The 2D International Space Station passes overhead.  The sound is that of Sputnik 1.  Cosmonaut Yuri Gagarin appears in the graveyard.

Meteors
A 3D meteor shower occurs while Galileo looks on from the grave.

Transit
A transit of Venus occurs.  This is a very rare event, the last occurring in 2012 and the next due in 2117, so we are very privileged.  The goddess appears in the graveyard.  She is The Bringer of Peace and has her appropriate accompanying music.

Thunderbirds
A bomb falls onto the windmill.  Call for action from a well-known science-fiction television series.  Help arrives and the bomb is safely removed.  All images are 2D.  The graveyard crew are Alan, Scott, Virgil, Gordon and John.

Zodiac
The signs of the Zodiac circle in the heavens.  The image is the surface of an open-ended cylinder.  This is the only non-flat 3D image in this program, and the real-3D effect requires multiple _MAPTRIANGLE(3D) processes.  The Zodiac sign at the front is brightened, and this effect is, again, produced by real-time _MEM processing.  Zodiac symbols of the prominent sign appear in the graveyard.  The music is appropriately mystical.
For you I see a romantic liaison with a coach party of ageing workers from the shoe-making industry.  Astrology – what a load of old cobblers!

UFO
An alien spacecraft arrives and settles for a moment, and after probing the environment it lifts off and flies away.  The image is _MAPTRIANGLE(3D) and occlusions with the windmill sails are correct.  In order to make the landing, the spacecraft follows a helical path (circular x-, z- path and linear y- path).  The arrival of this alien craft arouses the interest of two FBI special agents.  As the craft probes the ground, the little green man appears in the graveyard.

Spotlight
A spotlight illuminates the sky and reveals a pertinent message.  The spotlight image is only 2D, and would have been better as 3D but is done this way to show the limitations.  Again, _MEM processing is required to make the message image respond to the spotlight.  The graveyard shows how this program was produced.


Discussion
This has been a tinkering project.  As ideas came, I'd change to new areas of coding and then return to unfinished parts.  This is a bad method to do projects.  Returning to old parts, you don't quite remember exactly what you previously did and end up making mistakes and taking a great deal of time.  The project could still benefit from further improvements/changes and the tinkering could go on for ever (certainly some of the animations are rather naff, if not great fun for the coder).  But I leave it as is so  as to demonstrate where 2D imaging is not good enough to show completely correct perspective/occlusion.


 

Is there an equivalent of POINT(x,y) of the graphics screen for an undisplayed image?

I want to extract _RGB32 values for all x,y positions of an image which is loaded to memory (either by _NEWIMAGE or _LOADIMAGE) and which is the current _DEST but which is not yet displayed.

If this is possible, I expect that Steve has already told me (a number of times!!), but my one brain cell left hasn't retained that bit of data.  I've gone through all the Wiki statements and cannot find anything that returns such a value.

If this is not possible, I'd have to temporarily load the image, do POINT and make an array to keep the _RGB32 information and then clear the screen: that would be slightly messier.

[banned user] (or maybe it was bplus who is everywhere on this site), I believe that you directed me to this efficient shuffle method, used in my Clock Patience program (in the InForm Programs section).

Is it possible to have an array of _MEM objects (This is not an array sent to a _MEM block)?

I have an index which can vary from 4 to 10 and for each index I want to address a particular and distinct _MEM object.  Is it possible to do this without doing a SELECT CASE on the index and pointing to the appropriate _MEM object?

I've tried the following code and it works OK, so unless informed otherwise, I'll cary on along these lines.

I assume that a DIM SHARED array is shared into a FUNCTION in exactly the same way that it is shared into a SUB.  The Wiki states that the sharing is with "sub-procedures" which again I assume includes FUNCTION: I tried a sample routine without passing the array as an argument to demonstrate it to myself (it worked as if shared).  You might have supposed that an old-stager such as I really ought to know this, but I thought that I had better just check.

This program creates a crossword grid and fills it with words.  The filling routine is quite simple and a number of tries are required before a completed grid is produced.

The program creates a standard 15x15 grid with the following rules:

• Words can be only between 4 and 10 letters long
• The grid is 2-fold symmetric (if you rotate it through 180 degrees, it'll be the same)
• There must be perfect contiguousness

The routine for checking contiguousness is fairly simple, but I believe that it will trap faulty grids: if you discover a noncontiguous grid, please let me know.  The routine for placing the blanks is also fairly simple and some grids do not have the standard crossword look (although all are acceptable).

The method for filling the grid with words is a simple blundering process: a random word of the correct length is tried: if all its squares are blank then this word is added: if some of its squares are already filled and the word does not fit, another word is tried.  If (as is likely) the grid cannot be successfully filled, then another grid is generated and the process begins again.

This blundering process takes some time to achieve a completely filled grid, and some efforts have been made to improve the chance of success.  The dictionary used was created from two readily available on the web: quite a large number of words are thus contained in the dictionary.  You may find (as I do) that a completed grid uses some seemingly improbable words, but somebody has judged them acceptable.  The dictionary also includes some phrases.

When selecting words from the dictionary, the program makes some judgement of how likely the word is to cross successfully.  A word which would produce a cross word ending with unlikely letters like Q or Z is avoided.  And a word which would be less likely to cross with another in the middle (letters like J and X) are also avoided.

So you will notice that a completed grid has words which favour the common letters like E in the crossing positions.  The Qs, J's, K's et cetera will only appear at the start of words or in non-crossing positions.

The longest words are placed first, as fitting the shorter words to existing ones has a better chance.

The program is multilingual, and you can choose which language to use.  The alternatives are:

• British English
• US English
• German
• Spanish
• French
• Italian
• Dutch

Running the program

Extract the folder "Crossword Generator" from the .zip file and place the folder in your QB64 folder (be careful not to create an extra folder layer).  Open the "Multilingual Crossword Generator.bas" in the IDE (with "Output EXE to Source Folder" checked).  [The source folder contains another .bas file which is an older version (English only) of the program].

You will be presented with a Menu List to choose your language.  Although I have constructed this Options Menu to look like an InForm program (Windows native look), there is no mouse function available.  Press the Spacebar to change the language and Return to select your language.


The program will generate a grid and slowly fill with words.  When a word can no longer be found to fit, asterisks are filled in that place - it is unlikely that the grid will be successfully filled - and the program waits for keyboard input.  If you press the Spacebar, another grid will be generated and again words will be added.  If you press "f" when the filling stops, the program will quickly generate new grids and try to fill and the process will continue until a filled grid is obtained. Then the program will again wait for keyboard input.  Spacebar will create another grid, "f" will revert to the step-by-step method.  Esc will quit.

It takes a number of attempts to produce a completely filled grid, and on my Core i5 PC this takes some seconds (dependent upon the language, and if you've a slower machine you may have to wait for longer).

The process to fill the grid clearly has no intelligence to find words that will allow crossing words to be found in a small number of attempts.  An actual human compiler will be careful to think in advance.  Also, there may be some cases where the program, as is, is rejecting acceptable words.  So if you're sufficiently interested, you may like to create a rather cleverer program.

You may well suggest that a naive bystanding youngster would say of this program "But it doesn't do anything!".  This innocent would be correct: the emperor is entirely unclothed.

Multilingual Program now included (Updated 13/09/19)

In Steve's Posting about the Wiki being incorrect for FUNCTION

https://www.qb64.org/forum/index.php?topic=1531.0

I pointed out that arguments passed to a FUNCTION are passed By Reference by default and not by By Value.  That is to say, the argument gets modified in the FUNCTION and that modified value gets passed back to the calling argument.  This was a surprise to me, not to say rather a shock.

Incidentally, I never can remember which is By Reference and which is By Value (always have to look them up) – I'd rather they were called CHANGED and UNCHANGED respectively.

So, I discovered that if you don't want a FUNCTION to change your calling argument, you must pass the argument By Value, and this is done (QB64 methodology) by placing the argument within brackets, viz. if a FUNCTION F%() is called using a calling argument a% then

b% = F%(a%) - By Reference: a% will be modified

b% = F%((a%)) - By Value: a% will remain unchanged


So, I thought that I'd got that understood until I tried passing a String to a FUNCTION.  In this case, the String is always passed By Reference (and gets modified), no matter whether it is inside brackets or not.  Then I found that exactly the same thing happens with a SUB – a String is always modified by a SUB whether or not it is inside brackets.  I hope that you're still with me on this!


In the given code, there is a FUNCTION Ch%() which takes an Integer argument and a FUNCTION Spaced$() which takes a String argument, and there is a SUB Cg() which takes an Integer argument and a SUB Spacef() which takes a String argument.  The main block calls the FUNCTIONs and SUBs By Value and By Reference.

The code demonstrates what I have declared here:  a Numeric may be passed to a SUB or to a FUNCTION either By Reference (default) or By Value, but a String is always passed to a SUB or to a FUNCTION  By Reference.

Is this supposed to happen, and if so should a String behave differently to a Numeric?


From a queasy Qwerkey.