fool is Fool Object Oriented Library, because cannot be concidered as a language, and is not so fast.
at the origin, FOOL is a librairy made for graphic and hierachical programming, in assembler, it needs fasm to compile the sources.
it is my vision of item based programming. instead of using code with calls, use a tree data structure to describe the application.
sources can run from boot, dos and every system with a DOS or PC emulator.
in fact, it is not really limited to any system, just it is coded for what i still have
everything is an item, then, it can be qualified object oriented librairy.
the calling convention of FOOL is new, there is no parameters passed by registers or stack, everything is taken from objects.
for example, to draw a red 320*200 pixels rectangle,like this:
just create a data structure like this:
and call it with
fool is a library i code alone. then, it is very slow to maturate, but the idea is there,
a tree structured programming model very close to the hardware.
the main advantage to code it alone is that there is no unknown line of code, and the code is coherent
the main disadvantage is that it is very slow to develop, so slow that the coherency is broken due to evolution of the coder (me) skills
there are a lot of various little tests codes in this librairy, under the application forlder
mainly to test the librairy, implement new items. even the poorest applet in this folder is tested when a major modification occurs
the design of the API is general to every functions in this lib.
there are many way to call and compose a function using fool and assembler.
the ASM item is just a pointer to a code location.
the NODE and GNODE items are containers that can list up to 2^30 items. one item is a dword, 32-2.
all items inside a node are called one by one, the last in the list is called first
this is cool for graphics programming,
the last item is behind the first, then the first in list should be drawn the last
all the tree is executed, many times per second, depends on the frame rate, and if there is a frame rate control.
some console mode code that do not need cool graphics can have frame rates very high, like several millions of loop execution per second.
the frame rate control is cool for graphics, but to have a real time graphics, you just need to use a timer
here, the timer is close to 1000Hz, means you have a millisecond between two clocks. the use of the timer is as simple as a mov
after, you just have to use the DT value inyour formulae, to have a real time application
here real time means relative to time, everything related to time will be 4D.
before to dive into the 4D world, just rest here, in the 2D and 3D one, it is enough for the moment
but just for the moment
if a loop should be made on many items, it can be better to implement it is assembly first, using the ASM item,
and link the new method in function list when the function works correctlly
the function list is a list of pointers to the functions coded in assembler, but to use with fool API.
there are many level of calls in fool, for experiments, code from scratch, it can be good to ignore the function list,
and just use direct labels to the functions, the function list is there for the future, where fool will be residant, like a sytem
the applications will then just have to use an equate file to give the correct function id.
and a function list will be used, this function list would be local, global, or whatever, like a single list, where each field identify a function
this step would be tricky and need a very good model to implement, then, i really focus on the model to use for the fool kernel
then, i let the site as is, and return to design and code