AquaEngine is an engine is a game-engine for osx developed with xcode in C,C# and C++
** FOR EACH SUB-ENGINE (LIGHTNING-ENGINE, ANIMATION-ENGINEÉ) THERE IS A FILE SPECIFIC FOR THAT ENGINE
The 1st strategy is to make an hyper-modern engine and then find methods to slink down the processing by 6 main ways:
1) re-using data:
sounds logic but it isn't done so much in regularity engines, for example in place of rendering a
whole new frame first the engine is going to render vertexes to a metabuffer that also stores
information like the texture center and lights. by way of that the engine calculates what data
can be re-used and what data needs to be recalculated.
2) using pre-calculated data:
for example: if you have a light in the center of a room with some non moving objects and a light
in the center then you can apply the shadows as a texture map. pre-calculated data will always be
checked before it will be used (for example: if the light moves or so it isn't valid anymore).
3) 2-way approach:
the shading as example now: phong-shading as first approach and as fallback approach gouraud-shading
for near and flat-shading far.
4) optimized mipmapping:
textures are most times mipmapped this way: 1x1, 2x2, 4x4 or 1x1, 1x2, 1x4, 2x1, 2x2, 2x4, 4x1, 4x2,
4x4. optimized mipmaps aren't they use more advanced algorithms for that. for more info read the
"advanced_mipmapping.pdf" file.
PS: this isn't about linear-optimized mipmapping.
5) caching:
no engine of this age that hasn't one, our one's working with priorities, links, basic tricks:
SOFTLINK; a link to another file that's always used together with it.
HARD LINK; a link to another file that's sometimes used together with it.
PRIORITIES; the engine gives each indexed file a priority number based on the
metadata of that file (the metadata is stored in the index).
BASIC; if a script is reaching a link to a file the engine already load's
that file, there are also other methods explained in the
"caching-engine.pdf" file
6) Hardware acceleration:
speeding up the engine by way of hardware acceleration is already done by most modern engines
but is still required if you want to make your engine run at an acceptable framerate.
The 2nd strategy is about the memory, by 2 main ways:
1) primitive compression:
to reduce data, for example you have to mesh files loaded and one is a low quality version and
the other one is high quality. 1/2 of the vertexes are the same and the engine has stored them
at the beginning of the file and that ones that are different at the end, then is the
compression-engine going to set an alias in the 2nd loaded file to that part that is identical
to a part the 1st loaded file.
there are also some primitive logic an mathematical operations used by the engine:
XOR; a part of the file isn't saved in the memory, the 1st part xor to the 2nd part of the
file is = the 3rd part of the file (the unsaved part).
ALIAS; pointer to another identical part of the inside another file.
REPEAT; the engine checks on 1-bit level and on 8-bit level(byte) for x-times the same character.
then it saves the times the character appears and what character it's going about.
INVERSION; pointer to another inverted identical part of a file inside another file.
STENCIL; only used for textures etc, a stencil buffer for the unused part of the file.
*THE ENGINE CHACKS THE SIZE BEFORE AND AFTER EACH OPERATION TO MAKE SURE DATA DOEN'T GROW!
*THIS KIND OF COMPRESSION IS DONE BEFORE WHILE COMPILING IT OR DONE ON THE FLY (WITH GENERATED DATA),
BUT IT IS A BACKGROUND PROCESS TO MAKE SURE IT DOESN'T SLOW DOWN TEH SYSTEM TO MUCH.
2) advanced compression:
to reduce data, the compression is done before and isn't applied on the fly but is always done before
(while compiling). it uses many operations.
LOGIC; AND, OR, NOT, NAND, NOR, XOR, XNOR: all logic operations have 1 or 2 input
sources set (both with the same length) and always 1 output source the sources
are always done with pointers to multiple bits.
MATH; X; :, -, +, ^, _, are the supported mathematical operations. they are stored in
the as formulas inside a file on the place where the output needs to be.
ALIAS; pointer to another identical part of the inside another file.
REPEAT; the engine checks for bit patterns repeating for x-times.
then it saves the times the character appears and what character it's going about.
STENCIL; only used for textures etc, a stencil buffer for the unused part of the file.
*THIS COMPRESSION ISN'T APPLIED ON THE FLY, IT'S DONE WHILE COMPILED
*IT'S UNCOMPRESSED WHEN IT'S POSSIBLY NEEDED, THE CACHING-ENGINE IS USED TO DECIDE WICH
FILES ARE POSSIBLY NEEDED IN THE FUTURE.
* some other info: a) sub-engines: -rendering engine (without lightning)
* -lightning engine
* -animation engine
* -ai-scripting engine
* -scripting engine
* -physics engine (without vehicle-physics)
* -vehicle-physics engine
* -input manager
* b) other projects we use i our project: -BulletPhysics (for all physics except vehicle-physics)
* -ODE (Open Dynamics Engine, for vehicle physics and as fall back.)
* -OGRE (for all the rendering, lightningÉ)
* c) we use OpenGL for things we can't do with OGRE or for things that are significantly faster with
* OpenGL then with OGRE.
* d) for the audio effects we use OpenAL and for playing audio without effects we use QuickTime.
* e) we use QuickTime for cutscenes to.
* The Team.
