Below you'll find a list of all new features in the next Gamestudio beta version. Click onto the links to get the manual page of the new features.
For becoming a beta tester and receiving the latest cool features many months in advance, you should have experience with Gamestudio, be able to speak English, and own either the current Gamestudio/A7 Pro Edition or a valid support ticket. You can also get beta tester status when you've published a commercial quality project, programmed a popular tool or plugin, made substantial contributions to the Gamestudio Wiki, or have written a popular tutorial or book about Gamestudio. You can stay beta tester as long as you test beta versions and participate actively on the beta forum. For applying to beta tester status, please email Gamestudio Support (support [at] 3dgamestudio.net), and give your forum member name and your Gamestudio/A7 Pro user ID or support ticket number.
The beta list is no assurance of upcoming features. All beta features below are subject to change or even removal. Do not rely upon them to be implemented into an official release. Some of the beta features will only be available for certain editions. Features marked with X are experimental, unfinished features for testing purposes - they are implemented in beta versions, but not in an official release.
A8 The shader compiler now checks if a precompiled effect (*.fxo) exists and is newer than the effect file (*.fx) from the material definition. In that case, the precompiled effect will be loaded, rather than the effect file. This will speed up material loading. It also makes it unnecessary to include the shader compiler (d3dcompiler_42.dll) in the published version when precompiled effects are included instead.
A startup.h template was added. This customizable template starts the game with a splash screen, music, title, and sets some engine parameters like antialiasing and startup resolution.
A8 The Project Manager now supports the new lite-C template set, beginning with George's car and camera templates.
A8 WED now renders objects in two layers, so that only the active object is actually rendered. This increases the WED framerate especially in large levels.
A8 More improvements to the collision and trigger detection. Sprites now load noticeably faster and consume less memory.
CENTER_Y now also works with TrueType fonts.
The bmap_save function now clips the image to the size given in the BMAP definition.
The automatic adaption of the z buffer to the render target size can be prevented through the compatibility variable.
A8 The bmap_create function now also supports the 2x16 and 2x32 bit floating point formats.
A8 All WED/MED file open dialogs now use a standard Windows dialog with file history.
A model lightmap is now recognized by the engine and by shaders on any skin number (not only the second skin).
If an entity has a size above 100 units, its LOD distance is reduced by its radius. This gives better LOD results for large models.
The Game Design tutorial now contains the new MED and WED workshops by Quadraxas and David.
The view_check function can now determine if a box is fully or partially inside the view frustum.
A8 P Shaders can now be precompiled with the -fxo command line option for faster level loading and material creation.
A8 Some more fixes to the physics engine. EVENT_FRICTION is now correctly set, and pXent_movechar now moves and rotates correctly.
A8 ODE physics, A6 map collision detection and AABB collision was now removed from the A8 engine. This has the following consequences:
All string functions now support Unicode.
The pan_setstring function can place an ASCII or Unicode string on a panel.
A8 The effect_layer function can be used to create 2D particles that are rendered in panels or follow the mouse pointer.
A8 P The region_set function now supports clipping objects by their center.
The keys.c include file contains often used, simple functions related to keyboard and joystick input.
The following functions now also work with Unicode strings: str_width, str_cpy, str_cat, str_cmp, str_cmpi, str_cmpni, str_getchr, str_setchr, str_clip, str_trunc, str_chr.
The c_ignore function can be used to ignore certain entity groups on the following collision function call. It replaces the IGNORE_FLAG2 method.
The view_check function determines if a bounding box intersects a view frustum.
The WED/MED FBX importer was rewritten, using the 2010 FBX library. Many problems, especially with unsupported bones animation keys, are now gone. The new FBX importers are supposed to replace the old FBX 2005 / 2006 importers. Besides FBX files, they also import 3DS and some versions of Collada files.
A8 WEDB now got a tool for defining portal regions. Select the objects you want to be contained in the region, then click Add Region. A region frame is drawn around the selected objects. The region can be assigned a name under Properties. Portal regions can be used for clipping branches of the ABT resp. BSP tree (Pro only), or for other purposes such as triggers.
A8 P The region_set function disables or enables the branches of the ABT resp. BSP tree in a certain region.
A8 The region_create function creates a portal region in the level.
A8 region_check checks if an object lies within a certain region.
A8 region_find finds a region at a certain position.
A camera.c library was added to the snippets, allowing to set up an automatic player-following camera with 6 different modes. It replaces the old t_camera.c library from the car templates.
A8 Ventilator's 100-lines contest entry (Knights on Wheels) was modified for using car.c. It's now 25 lines, instead of 100...
Users often have strange problems to correctly display a level loading splash screen. In most games, even in the templates, it's displayed after and not while level loading, and mostly with a wrong duration. To solve this once and for all, a function level_loadsplash was added to the level.c library.
A8 The car template was adapted to PhysX, and underwent a major cleanup on that occasion. A new car.c library with often-used vehicle function was added, and replaces the old tcar.c library from the templates.
A8 Many small fixes to the PhysX implementation. PhysX functions won't crash anymore when called with wrong parameters.
Declaring global struct pointers (f.i. VECTOR* v = {x=1;y=2;z=3;} ) inside functions will now issue an error message.
Array initialization now also supports multidimensional arrays.
This beta version contains the A8 engine kernel. A8 is 100% code compatible to A7, so all A7 projects should normally still run under A8 without any change. It even still supports A6 C-Script. The two exceptions are physics - see below - and external plugins that use a fixed D3DVERTEX size. The D3DVERTEX size of A8 is different and requires that plugins use the ent_status function for determining the vertex size.
A8 C The DirectPlay network library was replaced by the Enet library. This doesn't affect the network functions or traffic, so A7 network projects still work without any change. The main advantage is that Enet is less resource hungry and supports other platforms, which allows a possible future development of a Linux based network server.
A8 C The functions session_open, session_connect, client_drop, and session_close are now also available in the A8 Commercial Edition.
A8 P If a matrix array with the name matBones appears in a shader, the engine calculates the bones animation on the GPU, rather than on the CPU. This has of course several disadvantages - vertex manipulation, mouse picking, decals, and polygonal collision detection won't work with those entities. But they are rendered up to 3 times faster especially when they have many bones or use bones weights. With only a few bones and no weights, the difference is less noticable. An example level crowd.c is included for comparing the rendering speed (A8 Pro without bones shader: 14 fps; with bones shader: 40 fps).
A8 Due to an improved ABT algorithm, all A8 editions render levels with many entities noticably faster than A7. The difference can be up to 25%. A8 supports up to 200,000 entities per level (A7: 100,000; A6: 15,000).
A8 P The d3d_instancing variable activates instancing for sprites. The terrain demo is rendered about 30% faster with A8 Pro this way, although it has twice the vegetation density.
A8 For vegetation, new sprite types with 4 or 6 sides are supported.
A8 DDS sprites can now also be multi-sided and multi-framed.
A8 C Accelerated stencil shadows are now also available in the A8 Commercial Edition, and are now always used for stencil shadows. They are rendered up to three times faster than software based stencil shadows. The old software based mode is still implemented in the Free and Extra Editions.
A8 The hardware accelerated PhysX engine replaced the old ODE physics engine. In the beta version, both engines are supported; the PhysX binding was developed by Chris3D and is contained in the ackphysX.dll plugin. Here's a very basic physics program:
#include <default.c>
#include <ackphysx.h>
function main() { physX_open(); level_load(""); // load an empty level vec_set(camera.x,vector(-100,0,30)); pXent_settype (NULL,PH_STATIC,PH_PLANE); // create a static plane at groundlevel zero ENTITY* ball = ent_create(SPHERE_MDL,vector(0,0,100),NULL); pXent_settype (ball,PH_RIGID,PH_SPHERE ); // create a ball pXent_setelasticity(ball,50); pXent_addvelcentral(ball,vector(0,-10,0)); // make it jump and roll sidewards while(1){ pX_pick(); // pick and move the ball with the cursor wait(1); } }
The syntax of the old physics commands is mostly maintained, so it's easy to move old physics applications, like the car demo and car template, to A8. In almost all cases this will result in a better frame rate and greater stability of the physics simulation. With an nVIDIA graphics card, the physics subsystem can now handle thousands of simultaneously touching physics objects (samples\physXtest.c):
Please note that for testing the beta version you'll need to install the recent PhysX driver from the nVidia website; this won't be necessary with the release version.
A8 ent_create can create several entities at once by loading a WMB entity that contains sub-entities.
A8 A published A8 acknex.dll now works with all executables generated with the same development system. This way, a single DLL can be used for many EXEs (A7 and before required a separate DLL for any EXE). This also overcomes the problems with some commercial wrapper systems. (Please note that beta versions can't be published).
A8 Through the video_border function, an overlay channel in the window outside of the DirectX area is now supported. This way, arbitrary shaped windows are possible. An example can be found in the samples\digital.c demo:
A8 C The bmap_process function can be used for procedural texture generation and general parallel processing.
Some A8 features, such as portal regions, shadow mapping, HDR shader, OpenAL, etc. are not yet available in this beta version. They will become available for beta testing in the next time.
A shadowmapping demo - shadowmapping.c - was added to the samples folder.
If a view target is bigger than the frame buffer, the z buffer size is now automatically adapted, so calling bmap_zbuffer is not necessary anymore in that case.
str_len, str_cat, str_cmp, str_cmpi, and str_cmpni now also support Unicode strings.
The new car template system is now included.The DirectX version was changed from October 2006 to August 2009. The 2006 version had several bugs that became increasingly difficult to work around (including a bug with Unicode font rendering). The engine now uses the d3dx9_42.dll instead of the d3dx9_30.dll.
C The engine now supports Unicode text for displaying right-to-left writing like Hebrew or Arabic, as well as logographic or syllabic alphabets such as Chinese Han or Japanese Kana.
bmap_create can now also create cutouts from images.
str_setchr and str_getchr can manipulate single characters in a string.
The dtimer() function can measure time in a double variable, overcoming the var range limitation.
This version contains the new template system, beginning with the car ai template.
A new GED version with various small fixes was included.
Individual colors of panel elements (digits etc) can now be set through pan_setcolor, and changed at runtime.
ent_blendframe replaces the ent_blend function.
Levels with lightmaps and a second UV coordinate set can now be imported in WED from FBX files. A lightmap can be applied to the selected block through Textures/Apply Lightmap. The 3D view can be switched between texture and lightmap mode through the View menu.
d3d_automaterial can be used to automatically assign a standard material to all blocks with a certain texture.
str_parse, str_parse_tail, str_parse_head can be used to parse words out of a string.
sys_exit can now generate an exit code for the application, thus allowing it to control batch files.
The sys_marker function can be used to indicate memory areas that were overwritten due to a script bug. This can help fixing hard-to-locate bugs that result in random crashes.
C Bone weights are now also supported by all bones manipulation functions such as ent_bonerotate.
A new map compiler was included. Among several detail improvements, the BSP mode that confused newbies is now not default anymore.
According to a recent study, the choice reaction time is a major indicator of a person's life span. A small lite-C program reactiontest.c for measuring a person's choice reaction time was added to the samples.
The video_mode variable now only supports widescreen resolutions that are also supported by the video card in fullscreen mode. This way the engine won't start in a widescreen resolution that can't be switched to fullscreen mode. Switching to an unsupported fullscreen resolution now won't displace the engine window anymore.
P A set of ftp functions can be used to upload, download, or update files from a server.
P A set of http functions can be used for communicating with PHP scripts on a server, or for accessing an online database. The ftp and http functions were originally developed by Peter Soxberger for the MMOG Utopia.
For demonstrating how to use lite-C for simple calculations (without engine window), a program pi.c for calculating the first 1000 digits of Pi was added to the samples.
The compatibility variable can be used to restrict the bounding box size to the first frame, as required for a bug workaround in the A6 templates.
The MED Merge function now attempts to merge the bones also. This is not always possible, but should work in most cases.
The WED Block Properties panel now got an Apply button for easier numerical manipulation.
The WED Add Object dialogs were updated and are more clear now. The Load Entity function caused confusion for beginners and was thus removed. Entities can now only be placed from the folder path.
A C++ var class was added to the engine SDK. The examples were updated.
SED debugging sessions can now be repeated indefinitely - at least as long as the script doesn't crash - without increasing the allocated memory.
snd_add now returns the end of the sample in the target sound buffer.
file_exists tells if a file exists in the path.
When video_screen is set to 0, printf() prints into the text area of the startup window. This can be used for text-only programs.
P socket_connect, socket_send, and socket_receive can be used to communicate with a TCP or UDP socket.
str_chr finds the position of a character in a string.
str_cut cuts out a string from another string.
A tutorial about walking, third person camera, and collision events was added to the workshops.
On very small and very large models, FAT and NARROW are now both automatically set.
The LIGHT flag now also works for TEXT objects.
The PROC_NOFREEZE parameter exempts functions from freeze_mode.
The ent_nextlight function now stores light info in the hit struct, and can also detect WED-placed lights.
A new map compiler was included, with improvements of the lighting algorithms.
Through d3d_flags the renderer can be switched between pixel and vertex fog.
iLights gives the number of lights in range of the current object.
str_for_id now returns NULL when the client was disconnected.
The particles.c library contains often used, small particle related functions, such as emulating a particle effect with sprites. Suggestions or contributions of further functions are welcome.
The engine_status function can be called from a DLL for determining when engine variables are available.
The snd_add function writes a sound sample into the buffer of a playing sound, and can be used to compose sounds in real time.
The snd_playing function now returns the current play position.
The snd_create function can now create sine wave sounds of any duration without a sound file.
The material.lod variable can speed up rendering by suppressing shaders above a certain distance.
The UNTOUCHABLE flag makes panels transparent to mouse clicks.
The ent_status function can now be used for determining the size of a D3DVERTEX. Because the vertex size can change between engine versions and even between entities, this method is preferable over using the sizeof macro.
A new GED version with several small fixes is included.
The str_printf function copies formatted text and variables into a target string.
The file_date function can be used to compare the modification dates of two files.
The ent_animatefrom function can animate an entity with a scene from another entity.
The map compiler got two new options for setting the minimum smooth angle and switching tesselation off.
WED and MED underwent many small improvements and bugfixes.
The exec function can now be used for directly opening documents and Internet URLs.
WED and MED FBX importers were further revamped with many small improvements for texture import.
Reading engine object definitions by the lite-C compiler was improved; panel elements can now also access other predefined engine object parameters.
The new map compiler version improves shadow mapping, and avoids some problems with seams and imprecise texture coordinates of the previous versions.
The ent_bonehandle function returns the handle or name of a bone with a given number or name.
The draw_obj function draws a text, panel, or view entity for one frame on the screen.
With the bmap_for_texture function, textures can be replaced on level geometry, or videos can be played on them.
send_skill can now also send entity strings between clients and server. This allows f.i. updating player names to the clients.
P dplay_encrypt now uses a harder-to-crack algorithm. When encryption is active, clients are now dropped when their script does not match the server script. This effectively prevents any tampering with a client.
P By setting preload_mode to 16 or above, files in a resource can't be replaced externally. This improves the security of online games.
Error messages now indicate the erroneous function itself, rather than the function last called before the error. This makes it easy to find the problem by single stepping through the given function.
EVENT_DISCONNECT is now executed immediately when a client closes, without waiting for a timeout.
WED can now import from the 3DS and OBJ format, and select scale and origin at import.
Individual render targets for a view can be set through the target1...target3 parameters.
engine_gettaskinfo can be used to list all currently running functions.
The vmask parameter can be used to make parts of a model mesh invisible.
The hit struct now contains the number of the mesh subset, which can be used to determine which part of the model was hit.
ent_getdecal returns the decals attached to a certain entity or block.
The effect_lod variable can be used to disable all shaders above a certain distance.
LOD techniques now also work with level blocks. Previously they only worked with models.
Panel colors can now also be used for coloring bitmap fonts.
The client_id parameter can now be used to assign a sky entity to a certain view.
The engine window can now be maximized, minimized, or resized. An event is triggered f.i. for automatically adapting the video resolution.
Internal LOD meshes ( P ) are now rendered even when a decal is attached to the model.
engine_getscriptinfo delivers the name of a script function.
sys_nxalloc allocates memory from the level cache.
The application icon (displayed in the taskbar) is now set from the acknex.exe icon, and can be changed to any custom icon with an icon editor.
The strio.c library contains often used, small functions related to strings and file input/output.
The ent_buffers function can be used to retrieve and manipulate the shape of model, terrain, or level meshes.
For users who want to contribute to the upcoming A7 templates, a Template Writing Guide was added (WIP).
file_str_readto and file_str_writeto can now also read from and write to buffers.
vec_mul calculates the matrix product of two vectors.
With the sys_winversion variable the OS version can be determined.
The sys_message function can be used to 'remote control' external programs with lite-C.
The sys_active function can be used to wait until a program started with exec becomes active.
The preload_mode variable can now be set up to preload also the entities' environment light.
The exec function now accepts shortcuts for the program folder and engine folder.
The group parameter can be used to define individual collision groups for entities.
WED can now compile a level trough command line as well as with the WED SDK.
The new Export/Import Lights feature allows compiling a level with several different sets of lights, or splitting a level into several wmb entities that share the same lights.
Trough a d3d_entsort setting, intransparent entities can now also be sorted more precisely than with the ABT tree.
The level.c library contains often used, small level related functions, such as terrain tiling, placing entities on terrain, and generating an endless terrain level. Similar include files with simple, small, but useful functions will be added in the future for actors, weapons etc., and will be used by the templates. It is highly recommended that you use the functions from the include files for your own project when possible - they will be permanently maintained and improved. Suggestions or contributions of further functions are welcome.
The ang_diff function calculates the angle difference between two Euler angles.
The sys_malloc and sys_free functions can be used to create arrays of dynamic size at runtime; allocated memory is automatically released at exit.
A starfield screensaver example (a7_screensaver.c) was added to the samples folder.
The OVERLAY flag can now be used to enforce the solid rendering pass and z-buffer writing.
The SKY and NOSKY flags can be used to combine several views for generating an endless level effect.
A terrain / vegetation example (infinite_terrain.c) was added to the samples folder. This example uses 9 simultaneous views for a terrain level of virtually unlimited size, and can handle 60,000 entities per frame at a decent frame rate.
The CLIP flags give entities individual clip ranges.
The wind animation shader was adapted to sprites, and moved from experimental to release state.
The CULL_CW flag was changed from bit 17 to bit 27.
diag_mode can be used to print level statistics.
Shaders can be temporarily disabled by setting d3d_shaderversion to 0.
The ang_for_axis function rotates entities about an arbitrary axis.
The ang_to_matrix and ang_for_matrix functions can be used to rotate entities by rotation matrices calculated by external software packages, such as physics engines.
MED Model Properties can now also display the properties of terrain models.
The NOSEND_Z flag reduces the network traffic caused by entity position updates from 9 bytes to 6 bytes per entity.
WED and MED now support the Vista Aero theme when using the GXL2BASDX9B.DLL (moved from experimental to production state).
dplay_localfunction can now be used to suppress all entity level actions.
The on_exit event is also triggered when the Cancel button was hit on an engine error message.
Light positions are now updated immediately before rendering, preventing a one.frame lag that could be visible on fast moving lights.
X A new experimental GXL library (GXL2BASDX9B.DLL) was added that supports the Vista Aero theme. This is an experimental feature and works only with the beta WED (WEDB.EXE) that is included in the beta version.
When proc_mode is set to PROC_GLOBAL, the current entity function is not terminated when its my entity is removed by ent_remove or by a level change. Removing an entity sets all my and you pointers to that entitiy in all functions to NULL.
C The LightMap shader variable allows accessing the lightmap of a terrain entity. The terraintex material now contains a _lm technique that supports terrain lightmaps.
C The map compiler can now also create lightmaps for terrains. Shadows on the terrain surface are cast by the level geometry and by the terrain itself. Restriction: The PRV lighting doesn't use terrain lightmaps yet.
For terrains, ent_create now runs the terrain action (if any) before the terrain is placed in the level. This allows the action to set the scale of chunked terrains, which can otherwise not be changed afterwards.
For using the engine in an external application, a parent window can be set through hWndParent.
For multitexture terrains, the number of texture tiles per terrain row can now be given through detail_size.
Shaders can now access all global variables in the script through adding "_var" or "_flt" to the variable name.
The view_to_matrix function returns the transformation and projection matrix of a certain view.
P The session_close function switches back to single player mode.
SED has now two different buttons and keys for starting either the current script, or the script set up in preferences.
Some useful macros were added to acknex.h: DEBUG_VAR() and DEBUG_BMAP() can be used for quick debugging variables and view render targets. Some often used colors (COLOR_BLACK etc. ) are predefined. The functions D3DXVec3Set and D3DXVec4Set were added to the d3d9.h file for easier converting DirectX source code to lite-C.
View borders can be set for rendering isometric offcenter views.
The lite-C compiler now converts numeric types also for overloaded functions, which makes using them a little more relaxed.
If a sky is defined in the script, it is now always rendered in the background of the level when the level does not contain a sky box. If the level contains a sky box, the sky is only rendered when the sky box is visible.
X An experimental texture processing/procedural texture function was implemented in the beta version (bmap_process).
The mouse sensitivity can now be adjusted in WED Preferences.
A section about preventing light artifacts was added to the WED shader guide.
The view.lod parameter can be used to increase LOD steps in a certain view.
If a file name in the script starts with "_", but the file is not found, the engine now trys to open the same file name without the leading "_". This way files can be excluded from publishing without renaming them.
The Smooth flag on block surfaces now also causes Gouraud shading when the block is exposed to dynamic lights. Without that flag, the block gets flat shading with hard edges.
A description of the WMB format for A7.70 and above can be found on the formats page.
tex_cycles can be used to switch off the default animation, and determine its speed.
c_rotate now accepts the IGNORE_FLAG2 option and does not displace the entity origin anymore when GLIDE is not set.
Whe the engine runs as an entity viewer, include\viewer.c is automatically executed.
joy_raw and joy_rot now return values with decimals for higher precision.
ent_for_file returns a pointer to the first level entity with the given file name.
Mirror clip planes can now be used in shaders through vecPortal.
Panels, views and texts now got two general purpose variables skill_x, skill_y for storing pointers or whatever else.
The -eq command line option terminates the engine on encountering a syntax error, and prints the error message into a file.
ent_reload reloads a modified entity file from hard disk.
MED now contains the same slice tool as WED.
The snd_buffer function can be used for playing own sound samples through the engine's sound player.
Chunked Terrains can now be placed multiple times in the level, just like nonchunked terrain.
SED can now save its current state as a project without creating a new project before. The project data now also includes the main script name.
The SED code jumper now also lists global pointers to variables and engine objects. The code templates got some often-used code snippets for a file header, panel, action, main function, and particle function.
Two new samples - clock.c and particle_trail.c - were added to the samples folder.
pan_setneedle sets or modifies a needle element on a panel.
pan_setdigits sets or modifies a digits element on a panel.
pan_setwindow sets or modifies a window element on a panel.
C The video_alpha variable sets the transparency of the engine window and can be used to fade the window in and out.
window_pos gives the current engine window position on the desktop.
A new particle system was implemented. Particles are now round instead of square. C The BEAM effect is now a lot faster and consists of straight or curved lines instead of single particles. P The Pro Edition now uses instancing that allows ten times more particles without frame rate penalties.
C The bumpmapping shaders were improved and don't reflect lights from the back side anymore.
C The mtl_lightcount material can be temporarily assigned to an object for displaying the number of dynamic lights in range.
video_aspect can now be re-defined for starting with the selected screen aspect under C-Script.
C The AUTORELOAD, TRANSLUCENT, and PASS_SOLID material flags can now also be set by defining a bool variable within the .fx file.
C Panel digits elements now also support the SHADOW and OUTLINE flags.
str_for_id retrieves the player name of a certain player entity in a multiplayer game.
pan_setslider sets or modifies a slider. Sliders can now alternatively be defined with a scale image.
pan_setbutton sets or modifies a button on a panel.
txt_addstring adds a new string to a TEXT object.
32 bit TGA textures can now also be used for level geometry, thus allowing specular maps and height maps on the alpha channels of the texture and normal map.
MED now also got tools for cutting objects with a wire or a plane.
The predefined shaders now use the ambient, diffuse, specular, and emissive settings from the material.
path_scanpath scans only the path the entity is already attached to.
LC The parallax and occlusion shaders were rewritten. They now support two lights and lightmaps, and are much faster than their predecessors.
ent_setskin now also sets skins of sprites and chunked terrain.
The bumpmapping shaders now support 3 lights; the cartoon shader supports 8 lights and lightmaps.
New shaders were added to the shader library: glass, glassBump, chrome, chromeBump, turbulence, and wireframe.
The shader viewer was improved and now supports model autorotation and material adjusting.
Shaders are now only compiled when they are visible. This reduces the engine startup time when the shader library is included, but causes a brief delay when the shader becomes visible on an entity the first time. For preventing this, shaders can be precompiled with ent_preload or preload_mode.
BMAPs can now be defined from rectangular sections of images.
The WED FBX importer was improved. Model textures can now be internal or external, and are not converted to 32 bit anymore.
Compressed images (.dds) can now also be used for sprite frames and sky cubes.
The on_client event is now also triggered when the client was accepted for the session, and when it was disconnected.
dplay_port sets a port number for the session_connect function.dplay_id contains the unique identification number of a client in a multiplayer game.
dplay_status can be used to determine the status of a client.
A 25th workshop Creating a Serious Online Game was added to the lite-C Tutorial. Please note that this workshop requires the upcoming beta 7.67 as it uses some features only available in this version.
The SPOTLIGHT flag was moved from flags2 to flags in order to be updated over the network (flags2 aren't updated).
dplay_localfunction can now also be used to automatically run actions of created entities on all connected machines.
The sizeof() macro is now C/C++ compatible.
A predefined primitive cube, sphere, and sprite entity can now be created with ent_create.
mouse_pos3d gives the level coordinates of the mouse pointer.
file_ commands now also accept "%SAVE_DIR%" and "%EXE_DIR%" path constants. If no path is given, the file is opened in the work folder. The old behavior (opening the file in the save_dir folder) can be achieved by setting the compatibility variable at 8 or below.
The wiimote interface was improved and contains now a function for retrieving a pointer position from the infrared camera.
New error message: E1516 "Invalid pointer freed".
The d3d_lines variable can be used for making the effect of normalmapping shaders more visible, for testing purposes. Pressing [F11] twice when default.c is included will set this variable.
The code\st_stencilblur.fx effect blurs stencil shadows with a Poisson filter.
 |
 |
 |
| General decal shadow | Individual decal shadow | Stencil self-shadow |
 |
 |
 |
| Stencil without self-shadow | Poisson blurred stencil shadow | Box blurred self-shadow |
P Setting shadow_stencil to 3 or 4 activates accelerated shadows that render about 3x faster than normal stencil shadows.
Mouse picking now also works in orthogonal views (ISOMETRIC).
The view_to_light function now copies the light color and other light data into the hit struct.
Due to optimizations in the mesh creation code, decal shadows are now generated twice as fast than before.
The WED slice tools were now moved from experimental to release state.
The shadow pointer can be used for individual shadow models and decal shadows.
Users tend to confuse the VISIBLE and INVISIBLE flags, which causes render errors and can not be detected by the compiler. We've now renamed the VISIBLE flag to SHOW.
The default albedo value of materials was increased from 50 to 100, due to several newbie complains about too-dim lighting in their levels.
SED now also scans .h and .fx files with the Find in Files function. When the directory field is empty, the current directory is selected. The [F5] and [Ctrl-F5] keys were swapped because Test Run is used more often than Debug Run.
Send_skill_to and send_skill_id can send an entity parameter to another client.
Ent_nextvertex finds the closest vertex to a certain terrain position, and can be used to deform chunked terrain in real time.
Arbitrary initial window sizes can now be set up through the screen_size vector.
View.aspect is now relative to the real monitor format.
video_aspect gives the format of the primary monitor.
Video_mode and video_switch now automatically switch to widescreen formats.
C Decal Shadows now replace the old z buffer shadows when shadow_stencil is set to 0. They are no 'real' shadows, but a diffuse darkness underneath the shadow throwing object, regardless of any light sources. They are faster than stencil shadows, and can in some cases look better.
Decals on terrain are now not cut off on chunks anymore. This allows unrestricted decal shadows on terrain.
X WEDB got two new tools for slicing and cutting blocks. Move the Slice Wire over any selected block or group, and press [Enter] to cut. The Slice Plane cuts the whole group along a plane. There are no icon images for the tools yet, so disable toolbar icons for activating them.
MDL models can now share textures between mesh groups. This might make sense when you have several groups with the same texture, but different materials.
The options in WED Preferences are now available in a new menu order.
The ent_setmesh function now updates the collision shape from the new mesh.
The ent_getvertex/ent_setvertex functions replace all vertex functions like vec_for_mesh, vec_to_mesh etc. They also support mesh deformation on chunked terrain.
The ent_status function returns information about the entity mesh, and replaces the ent_vertices, ent_skins, and ent_frames functions.
Shared textures are now supported for models.
The WiiMote plugin was improved and now contains smoothing functions for angles.
The num_sounds variable indicates the number of playing sound channels - also displayed in the Statistics Panel.
The smooth function lets a parameter - such as an angle - softly approach a target value, or smoothes jittery input values.
The WiiMote plugin by Firoball was now officially integrated in the engine. Up to 4 WiiMotes and other Bluetooth input devices are automatically detected at engine start.
D3DXVECTOR3 and D3DXVECTOR4 inline functions were added to include\d3d9.h.
In postprocessing shaders, the vecLightPos... arrays are now automatically set to the 8 closest lights that overlap the frustum of the postprocessing view. If the view has a genius, the vecLightPos... arrays are set to the lights in range of the genius entity instead.
Dynamic lights placed in WED now automatically get the CAST flag, i.e. they can throw shadows.
Shaders can now use an arbitrary number of textures by accessing BMAP objects.
The angle limit of decals can be set by the decal_clip variable.
The view volume size in ISOMETRIC mode can now be controlled by the view.arc parameter. ISOMETRIC mode can be used for orthogonal projection, or for clipping objects in a rectangular view volume f.i. for PSSM shaders (moved from experimental to release state).
The mouse_panel pointer can be used for determining which panel the mouse is over (if any).
The lightmapping algorithms of the map compiler were improved. Lighting 2.0 is now always activated (lighting 1.0 was removed). The Supersampling option resamples the lightmaps for removing 'staircase' artifacts.
Single faces of a block can now be individually selected in WED by clicking on them in the 2D or 3D views.
The ambient_color variable can be used to adjust the brightness of level entities that receive no light from the PRV. It is automatically loaded from lit levels. This prevents levels without ground plane from going fullbright.
"_repeat" effect passes can now use up to 4 repeated textures.
MED got new menu items for swapping and removing the second UV coordinate set. The coordinate sets are now also indicated under Model Properties.
The shader viewer now also displays shaders on map entities (if the shader supports lightmaps). A test entity "sphere.wmb" was added to the folder.
The mip_levels variable can be set for using more than 4 mipmaps per texture.
If mip_sprites is set above 0, mipmaps are now also created for all models that don't have own mipmaps.
A new material mtl_terraintex was added to the shader library, and can be used for rendering terrain with an arbitrary number of 32-bit masked textures.
The PASS_SOLID flag enforces entities to be rendered in the solid pass.
An effect pool is now allocated for all effects, supporting shared effect parameters.
If an effect pass name contains the character sequence "_repeat", the pass is repeated for every skin of the model. This special method can be used to render an arbitrary number of skins, for instance for multitexture terrain. The number of the current pass repetition can be evaluated through the iRepeat shader variable.
The run_mode variable can be used to distiguish between development and production mode, and determine the way the engine was started.
Later decals are now placed on top of earlier decals on the same object.
Models with both transparent and intransparent parts can now also be used for view entities.
The concave flag can now also be set for block groups in WED. This flag is required for all blocks that have lost their convexity due to vertex manipulations. Imported blocks have this flag set automatically.
A short guide about how to Apply Shaders to Level Blocks was added to the manual.
Als long as the PLUGINDIR was not changed, engine plugins are now automatically loaded from both the work folder and the acknex_plugins folder.
The inchar() function can be used to read a single character from the keyboard.
Truetype texts can be horizontally limited to the size_x area.
str_width returns the width of a string in pixels.
The WWRAP flag activates word wrap for a truetype text.
The ARIGHT flag aligns text right.
P dplay_encrypt activates encryption and compression of data packets sent over the network.
On OBB collision detection, the IGNORE_PASSABLE flag still detected passable map entities unless IGNORE_PASSENTS was also set. This was inconsistent to AABB collision detection where IGNORE_PASSABLE ignores anything passable. Both OBB and AABB collision detection now ignore anything passable on IGNORE_PASSABLE. For getting the old behavior back, set the compatibility variable to 5.
The maximum number of physics contacts can now be set through the ph_max_contacts variable.
The diag_status function prints the current status of all running functions into the diag file. This function is triggered by hitting [Alt-F11] when default.c is incuded.
The draw_box3d function can be used for drawing bounding boxes.
Panel events can now also be triggered by right mouse clicks.
str_for_int and str_for_float generate strings with more digits or higher precision.
Models with wrong texture sizes now issue warning 1309.
file_str_readto now accepts NULL for the string pointer for just skipping parts of the file.
PRAGMA_BIND and PRAGMA_LEVEL now support file names with spaces; still, it is absolutely not recommended to have file names with spaces or foreign characters in your game.
str_to_int and str_to_float allow to read numbers from strings with higher precision.
WED FBX level import now creates models with mipmaps.
The WED SDK now allows a better control of menu entries, by determining the menu position and placing separators.
P The -mon command line option can be used to select a monitor for fullscreen display in a multi monitor system.
For avoiding a string content "#nnn" to be interpreted as an empty string of length nnn, two '#' characters at the beginning of a string (such as "##123") are interpreted as a single '#'.
Bad entity file names (such as names that contain '/' or '\' characters) are now indicated by warning message W1305 .
Faulty bones animation in FBX files (scale inheritance) is now indicated with an error message during import.
The main script file can now be directly given in the WED SDK.
Panels can now be horizontally and vertically flipped through negative scale factors.
C P The original content of a panel/text target map is now preserved before rendering into it.
MED can now directly import lightmapped models from FBX files. The lightmap is mapped to the second UV coordinate set.
C P The direction of sun or spot lights can now be determined in shaders through the vecLightDir array.
If the name of an EXE file is given in the command line, the engine automatically starts the EXE file if its exists, and compiles it from a C script with the same name otherwise. This can be used to speed up the startup process by skipping the script compiling when the script is not changed. Enter scriptname.exe in the WED or SED command line options window for starting faster. Debugging and crash handling only works in the code, not in an compiled executable.
The text_outline variable can be used to adjust text shadow and outline border transparency.
The on_message pointer can be used for calling the engine message loop from another application. This now allows completely replacing the engine window (hWnd) by another application window.
ent_nextlight finds the closest dynamic lightsources to an entity.
The amount of virtual memory allocated by the engine can be determined through the sys_memory variable.
C P The Lambert, Phong, and Blinn bumpmapping shaders now support multiple lights and can also be assigned to level blocks. A general bumpmapping vertex shader that can be combined with various pixel lighting effects was implemented in the default.fx library.
C P The vecLightPos array is now sorted from close to far lights. This also avoids wrong lighting in cases when more than 8 dynamic lights are close to an entity or level block.
C P Predefined shader actions (such as fx_bump) can now be directly assigned to entities; the shader parameters are taken from skill1...skill4 in that case. If the skills are zero, default values are used.
X C P The ISOMETRIC flag activates an orthogonal view projection.
Crashes in lite-C now always give the name of the crashed function.
Texture coordinates at the c_trace hit position can be retrieved through hit.u1,v1/u2,v2.
Several mode flags were added to limit the entities detected by c_scan.
The UNTOUCHABLE flag now also works for panels.
The exec_wait function waits for the termination of an externally called program.
Due to an internal optimization, A7.10 now consumes about 30% less nexus memory per level than prior versions.
C P A decal material can now be set through PARTICLE.material. If no material is set, the decal renders with the same material and shader as the object it's attached to.
WED now moves directly into a group scope by selecting an object of the group in the level tree.
The scale restriction through [Ctrl] now also works with the WED Edit Box tool.
hit.texname is set to the name of the hit model, sprite or block texture that was hit.
For FBX level imports, import rules can now be defined in the .imfl file.
A vec_cross function was added.
On common demand, a few lines were added to the c_move example for falling with gravity and reducing the speed on slopes.
C P The number of currently connected clients can be evaluated through the num_clients variable and is displayed in the [F11] panel.
A rotating triangle sample (triangle.c) was added to the lite-C samples to show how to use DirectX functions for drawing at runtime.
A brief description of the predefined shaders and using them was added to the manual.
The FBX Level Importer now automatically detects model instances.
The map compiler now also supports the Smooth flag for lighting 2.0.
The time consumed for 2D draw_ functions is now visible in the [F11] panel through the time_draw variable.
The number of mipmaps read from external DDS files is now limited to 4 for avoiding too-extreme mipmapping on DDS textures. The d3d_mipmapping variable can now be used to activate anisotropic mipmap filtering.
Despite all player movement examples in AUM, the c_move function still invites all sorts of beginner's mistakes when writing code for player walking. A simple walking example was thus added to the manual page.
The ent_type function determines the type of the level or entity.
For compatibility to imported lightmapped models, block meshes now also use the second UV coordinate set for lightmaps.
Through the HIT_TARGET macro hits on entities or level surfaces can be determined.
The second UV skinning data from the MDL7 format is now imported in the engine and used for the D3DVERTEX u2,v2 coordinates. If a model has a second UV set, it is automatically treated as if its second skin were a lightmap (if it has no shader or FFP effect).
The add_new function initializes the folder and resource path and removes all file buffers.
Some new vector helper functions were implemented:
vec_for_ent can be used to convert between world and entity coordinates.
vec_fill sets a vector to a constant.
vec_rotateback performs an inverse rotation.
vec_rotateaxis performs a quaternion rotation of a vector about a rotation axis.
vec_bounce calculates a reflection vector.
The random_seed function can be used to start the random sequence with always the same numbers.
C P The first version of the A7 decal manager was implemented. The ent_decal function attaches a decal to any entity, floor or wall.
The merging operator ## is now supported in macros.
The mouse_pointer variable now supports all available Windows mouse pointers.
The mouse cursor is now visible on frame and menu bar of the engine window when a mouse bitmap is active inside the client area.
The impact range of dynamic lights on meshes can now be adjusted with the d3d_lightres variable, preventing cases when lights are not visible on coarse tesselated surfaces.
X MEDB now supports a second UV set on skins, for special purposes such as shadow mapping. The second UV set is also stored in the MDL7 file, but not yet used by the engine.
The CHILD flag now prevents the view from culling and sorting entities again, and uses the culling and sorting process from the previous view. This increases the rendering speed on CHILD views.
The acknex.exe created by the Publish process now contains a manifest as required by the Microsoft Games for Windows standard.
The ent_pvs function retrieves all potentially visible entities from the ABT or BSP tree.
A7 now supports multiple render targets through bmap_rendertarget.
The OVERRIDE material flag gives the material priority over view materials.
A new MED / WED SDK was uploaded to http://server.conitec.net/down/wedmedsdk7.zip. It contains some fixes and new VC++ 2005 projects for the WED plugin samples.
The fx_floor_mirror action in mtlFX.c can be assigned to a floor entity in the level, and generates a horizontal mirror effect. The reflection factor can be adjusted through the entities' ambient value.
The 2-sided and 6-sided mapping dialogs in MED are now non-modal.
The proc_kill function can now terminate all instances of a given function pointer.
The on_frame event is executed every frame, and can be used to implement functionality similar to wait() in an external language.
The NOLOD flag allows a view to use the LOD states of a previous view, which is useful for shadow mapping views that render from a light source position.
8 general purpose matrices can now be defined for shaders.
The Add Light panel now allows to select the light color through the Windows Color Dialog.
The new Transform Model Global dialog now rotates the model about all axes, instead of exchanging the coordinates. The modifications are visible in real time. This makes model import from editors with a different coordinate system much easier.
Resource files in the work folder are now automatically opened without needing a PRAGMA_RESOURCE statement.
The ANIMATE flag can be used for switching model auto animation on and off.
Through the level_ent pointer the size of the current level can be determined.
The depth parameter of a view allows to preset the z buffer to a certain value.
New shader variables: fLayer, fAlpha, fPower
Buffers allocated through file_load can be freed through file_load(NULL,buffer,NULL).
The draw_quad function can be used to draw images or colored areas without needing a panel.
The preliminary version of the long-awaited Template7 system together with the T7 game engine will now be officially included in this version. A brief tutorial can be found on the Wiki. As long as the entity behavior editor is not yet finished, entity behavior can provisionally be edited by opening the XML files with a text editor as described on the Wiki.
The FBX level importer now supports object hierarchy import and an improved dialogue. The object position problems of the last beta version are also supposed to be fixed.
bmap_zbuffer can be used to render into bitmaps bigger than the screen, and to use render targets even when d3d_antialiasing was enabled.
The lite-C compiler kernel was modified. Previously, scripts containing lots of predefined engine structs and numeric constants compiled quite slow. They now compile much faster.
Attempts to use the video or DirectX device in the first frame before it's initialized are now indicated with an error message "video not yet initialized ".
bmap_to_alpha can now also create a one-bit alpha channel for overlay transparency when the percentage value is set at 0.
PRAGMA_POINTER can be used to switch off the lite-C pointer autodetection, and treat code as in C/C++.
ent_boneparent returns the parent of a bone and can be used to walk the skeleton of an entity and determine its structure.
The bone functions can now also use bone handles instead of bone names. Finding a bone by its handle is faster than using its name, and overcomes problems when two bones have the same name.
Another new engine demo can be downloaded from http://server.conitec.net/down/demo_venice.rar.
fps_max now uses a CPU loop for small idle times, which reduces the 'stuttering motion' problem on levels with high frame rate.
A new engine demo can be downloaded from http://server.conitec.net/down/demo_lightshadows.zip.
The pVars pointer can be used for getting a handle to any lite-C struct that is not an engine object. This can be useful for identifying structs in a multiplayer enviroment.
P Through the ENGINE option in options.scr the name of the executable for WEDS can be given, e.g. ENGINE = "wrun.exe".
Pointers can now also be used as boolean expressions in lite-C.
The PRAGMA_PLUGIN definition replaces the abandoned dll_open function that did not work under lite-C anyway. Calling dll_open will now generate an error message.
P The engine window can now display user defined icons in the task bar. If an icon named "32.ico" or "16.ico" is found in the work folder, it is automatically loaded and used for the task bar icon in stead of the default A7 icon.
WED can now import whole levels that are created in MAX or MAYA, and convert them into a WMP level plus MDL entities. For this, use the Import Level from FBX function. For any object in the Import dialog you can select whether to import it as a mesh, or import it to a MDL7 model in the work folder. Camera positions and lights can now also be imported from FBX levels.
The LPD3DXEFFECT interface was added to d3d9.h.
When an engine window is not opened (video_screen = 0), all diag() and printf() output is now printed into the text area of the startup window.
Shaders can now use different techniques dependent on whether they are rendering model or block meshes. This way the same shader can be used for models and for level blocks.
Expressions containing '&&' or '||' now evaluate to 1 or 0, instead of nonzero or 0. This allows for better compatibility to ANSI C in boolean expressions.
Collisions with a bounding box or ellipsoid are now restricted to planes facing the movement direction. This prevents objects from getting stuck when sliding along complicated geometry, but could have side effects - please check carefully.
The pPaths array can be used by external development tools to read the engine paths.
The engine can be prevented from opening a video device by setting video_screen at 0 before the first wait() or level_load() call. This is useful for programs that don't need an engine window.
Panels and Texts can now render into target bitmaps.
Material and shaders can now be directly assigned to geometry blocks in WED (without using the d3d_automaterial feature) when the level is compiled in mesh mode.
proc_mode is now automatically set to 0 at the first wait call.
The shader viewer was greatly improved. It now supports more than 40 different surface and postprocessing shaders that can be used in projects.
Lite-C now allows PRAGMA_PATH, PRAGMA_LEVEL, PRAGMA_BIND and PRAGMA_RESOURCE statements in a .c file, making an additional WDL file superflous (except for startup window definitions). Paths added by PRAGMA_PATH are also used by the WED Publish function.
WED and MED can now display DDS images in the texture view, and can import textures from most image formats. An external library (exio.dll) is used for the image conversion. It uses the devil.dll image conversion library by Denton Woods. The exio.dll source code is available in the external folder.
The projects paths used by the WED publish process are now indicated in the Resource View under 'Path'.
More shader workshops about postprocessing, shadow mapping, and soft shadows, were added to the Shader Tutorial (http://server.conitec.net/down/shader_workshops.zip).
Shaders can now detemine the fog color through vecFogColor.
If no #include statement is found in the main script, default.c is automatically included.
Bitmap names or formats can now be directly given for the bmap element in a VIEW definition.
The ENABLE_VIEW event is now used for rendering view material events, instead of ENABLE_RENDER, for better distinction between view and entity materials.
The predefined light_view determines the view used to clip dynamic lights.
Color depth values 12 and 14 in a BMAP definition now create a floating point bitmap in F16 and F32 format.
proc_kill was improved and can now terminate all instances of the current function that were called by the current entity.
Views can now directly render into cubic environment maps by using a bitmap as a render target that was converted with bmap_to_cubemap before.
Functions that end with "_event" are now automatically assigned to the corresponding event.
Four more entity skills can be passed to shaders through vecSkill45.
A new WED/MED SDK for A7 was uploaded, with more examples and new features.
The index high byte of STRING objects (HBYTE_STRING in atypes.h) was changed from 10 to 2 for internal technical reasons.
Taco Cohen's Shader Workshops were adapted to A7.07 / lite-C and can be downloaded at http://server.conitec.net/down/shader_workshops.zip.
ent_mtlset and ent_setskin can now create new entity skins and skin materials.
The realloc() function is now supported by lite-C.
The level_load function is now executed directly and undelayed, thus a wait() after level loading is not required anymore.
The CHILD flag lets a view inherit its parameters from the previous stage.
The entity viewer script in default.c was modified so that entities are now centered in the view and rotated with the cursor keys.
The -nv command line option prevents the engine from rendering and opening the DirectX device.
The AUTORELOAD material flag can be used for editing shaders and observing the result immediately in the engine window.
The Light Manager now clips active dynamic lights against the view frustum when only one view is active. This can noticeably increase the frame rate on levels with lots of dynamic lights.
The %EXE_DIR% in PATH statements is now also used by the WED Publish process.
The SHADOW flag restricts a view to shadow throwing objects, for shadow mapping purposes.
The view_to_light function sets a view to a dynamic light position.
The ptr_remove function replaces all individual remove functions.
Lite-C now also supports the conversion between char and short variables by typecasting.
A new bmap_blitpart function was implemented for blitting from only a part of a source bitmap.
The ACTIVATE_SHOOT flag for c_move prevents collision events and lets c_move behave similar to c_trace.
The render behavior of a view stage can now be determined with the PROCESS_SCREEN and PROCESS_TARGET flags.
Views can now be assigned a material that replaces all entity materials and can be used for special effects or postprocessing.
The render_stencil bitmap pointer allows rendering the stencil buffer content into an offscreen bitmap for further processing, such as blurring stencil shadows.
Through the view stage parameter a rendering chain of views can be created for complex pre- and postprocessing effects, such as shadow mapping.
A texture transformation matrix is now used for shifting textures through u,v entity parameters.
Panels now also accept the CENTER_X / CENTER_Y flags for their digits elements.
on_scanmessage can be used to set a user defined message handler.
engine_getvarinfo returns the type and name of a lite-C variable of the current script, and the name and offset if the variable is an element of a struct.
The Frame Manager in MED is now non-modal and allows inserting frames while editing them. Clicking on a field in the scene column selects all frames from the scene. The current frame is indicated in the frame column. Double clicking on a frame lets MED change to that frame.
A small modification to include file handling: #include files given in double quotes "..." are now also searched in the code subfolder. #include files given in angular brackets <...> are only searched in the include subfolder.
The engine vertex struct (D3DVERTEX) was moved from the d3d9.h file to atypes.h, for using it in external C++ projects that don't want to include d3d9.h.
PRAGMA_PATH can be used to define paths for include files.
The IGNORE_WORLD flag in c_move, c_trace, and c_rotate ignores all level blocks and terrains.
The SED Code Jumper now detects all C standard variable types, functions and #defines. Local variables are not listed anymore in the Code Jumper.
MED can now automatically assign vertices to bones (moved from experimental to production state).
WED can now edit terrains that are placed in the level. For this, select the terrain to edit, and click [Scope Down]. A terrain editor panel will open that gives access to a magnet tool for shaping hills and valleys (moved from experimental to production state).
The pixel_.. functions and the send_..._id functions were changed in afuncs.h so that they now accept a var for the pixel and the client_id, rather than a long. This prevents conversion problems when the pixel or client_id variable was defined as a var rather than a long. Please note that if you used a long in your code you need to change it to a var.
All manual pages now got a [latest version online] button that loads the latest version of the page from the online manual.
ent_clone and ent_cloneskin can be used for individually modifying meshes, skins, and skin materials of an entity.
The continue statement now also works in for loops.
PRAGMA_PRINT can be used to display compiler messages.
The display of LOD levels in the WED 3D view can now be adjusted in Preferences.
Block surface flags can now be set for all faces together in Block Properties.
If a sound file with the name beep.wav is found in the path, it is used for the beep sound.
A7 now supports the 3Dconnexion SpaceNavigator family of 3D navigation devices. If such a device is detected, the engine gives the startup message "3D navigation device found" and binds it automatically in as a first or second joystick device.
WED can now search standard paths for publishing by using the PATH statement in options.scr, e.g. PATH = "%EXE_DIR%\code".
The mouse pointer is now automatically moved when mouse_mode is set at 4.
Two new samples were added to the work folder: pong.c is the classical Pong game and pong_multiplayer.c is its multiplayer version for playing Pong over a network ( P or C ).
X The terrain_lod variable controls caching and LOD for chunked terrain.
A new code folder was added to the Gamestudio directory and is automatically searched by the #include directive. The code folder contains common C and shader code, such as mtlFX.c, and the standard .fx shaders.
The _chr function converts STRING* pointers and char arrays to char* pointers (useful for passing text strings to a DLL).
The sun_color vector can now be set to the sun color from the map properties of the level.
New flags IGNORE_FLAG2 and ACTIVATE_PUSH are added to the c_trace and c_move parameters for ignoring certain groups of entities on collision detection.
The digits element can now also be used for displaying strings.
A wrong number of parameters to a function now throws an error message.
A new VERTEX object was added to the engine objects. It is used for receiving information about c_trace targets and will be used in the future for setting/retrieving positions and uv coordinates by vertex functions.
engine_getvar is now documented and works also in lite-C.
effect_load(MATERIAL*,""); reloads the current effect and makes it convenient to edit effects at runtime.
The handedness of the binormal is now stored in the 4th tangent coordinate of every vertex. This avoids shader problems with mirrored coordinates.
The new WED option Mesh Size can be used to greatly increase the rendering speed in complex levels.
SED can now open files by clicking on them even if a SED instance already had files open from a different folder.
ent_remove now also removes view and sky entities.
The PATH statement now accepts the keyword %EXE_DIR% for the Gamestudio folder.
The WED Find function can now find objects by their name or file name.
When c_trace() hits a model entity in OBB mode, the tex_color vector is now set to the color of the texture pixel at the hit point. For this the texture must be a TGA image in 24 bit RGB or in 32 bit ARGB format.
When c_trace() hits a level block or a model entity in OBB mode, the predefined hit.skin1 pointer is set to the hit BMAP (the lightmap or the first entity skin), and hit.u1,hit.v1 are set to the u,v coordinates of the hit point on the texture. This can be used to paint on the texture, add or remove shadows, or punch holes in targets with a gun.
When a client connects, the on_server event now receives the client number. All send functions also accept the client number to send data to a certain client.
send_data_to transmits arbitrary data between clients and server in a network environment.
send_var now also works in lite-C and can be used to update arbitrary variables and structs between client and server.
A Duplicate Skin function was added to the MED skin manager. New skins are now always added behind the selected skin.
A shader test project (shadertest.c) was added to the projects folder. You can use it to select between several shaders and activate light sources for testing the effects. The project was created by our future team member, André Weiß, who will join the Gamestudio team by the end of the year after finishing university.
The vecLightPos array now also contains the sun. This way the same shaders can be used for indoor and outdoor lighting.
The floatv, floatd, and floatr functions are taken over to lite-C for more convenient conversion of shader scripts.
The mtlFX template was converted to C, and the normalmapping and specular bumpmapping shaders posted to the "Ask Conitec" forum were added to the template.
When changing the window size of WED and MED, the views are now proportionally scaled.
X The lightmap resolution can now be adjusted in mesh mode with the slider Lightmap Scale. Please note that this mode is still experimental. It doesn't work yet together with Merge Across Leafs and causes artifacts when the resolution is too low. Set it at 2.0 or above to achieve good results.
pan_setvar and pan_setevent can be used to change functions and variables of panel elements, or to set them in panels created in external languages like C++ or Delphi.
Crashes in lite-C functions don't lead to an engine crash anymore, but issue an error message (just as in C-Script). The function name is indicated in the message, making it easy to determine the crash reason.
C The d3d_antialias variable can be used to activate full scene antialiasing before the video device is opened.
Panels, texts and view entities with a negative layer value are now drawn below VIEW objects, and can be used to draw into the background of a view when the sky is switched off.
MED can now import FBX files with an arbitrary number of bones per vertex. Multiple bones animation can be imported, but not edited in MED. The number of bones per vertex is visible under Model Properties. The engine animates up to 4 bones per vertex. The number of bones per vertex can be restricted by setting the max_bones variable (moved from experimental to production state).
X WEDB can now edit terrains. For this, select the terrain to edit, and click Scope Down. A terrain editor panel will open that gives access to a magnet tool for shaping hills and valleys.
The atan2 function is supported for higher precision in trigonometric calculations.
P The session_open function can be used to open a session as a server at runtime.
Pointers can now also be compared with >, <, >=, and <=.
Functions can now also return short and char variables.
d3d_skydepth can be used to store sky images in compressed format.
The preload_mode variable can be used to prevent the little 'jerk' when an entity becomes visible the first time.
The mtl_remove function can be used to remove temporarily created materials.
File names - for instance in external model skins - may now also contain relative or absolute paths. If the file is not found in the given path, it's searched in the current folder or in the folders given by the PATH statement.
MEDB can now automatically assign vertices to bones. For this, click Apply Vertices with a selected bone, but no selected vertices or groups. MED will automatically find the closest vertices that surround the selected bone and assign them.
MED can now globally scale, mirror, and transform models with all their bones and animations, and allows to separate bones animation matrices into their rotation, translation, and scaling components.
When using the engine as a model viewer, bones animated models now also play through their aimations.
WED now displays the next-higher group in the edit windows when Draw Top Group is activated in WED Preferences.
The LOD flags can be used to determine with which LOD step the entity was displayed in the last frame.
In TEXT and DIGITS definitions, fonts can now be directly defined, rather than using predefined fonts.
The Single Mesh option causes a WED block group to be rendered as a single mesh. This increases the frame rate in levels that consist of complex block geometry, like cities. Most 3D cards achieve the best performance when rendering meshes of about 1000 polygons.
The record_mode variable can be used to check the status or terminate a record / replay operation.
MED FBX import now also supports bones animation. Because the FBX format is not downwards compatible to itself, two FBX importers are now implemented. The normal importer is for FBX files saved with the 2006 FBX version, the 2005 importer is for FBX files saved with the 2005 FBX version.
ent_setmesh can be used to change the mesh of an entity, f.i. for adding lightmapping data.
WED / MED now refreshes its 2D and 3D Windows by right click and selecting GXL / Refresh. Useful if the DirectX device got lost due to task switching or running another DirectX program in the foreground.
<windows.h> is now not included anymore by default in lite-C Pure Mode, thus saving a couple seconds compile time. When using the Windows API in Pure Mode, include it manually.
Missing include files in lite-C now issue a warning.
move_friction now also works for the OBB collision detection.
bmap_to_alpha creates an alpha channel for an intransparent bitmap.
The stdio.h header file was added to lite-C. It contains all file and directory functions from the C libraries io.h, stdio.h, and direct.h.
Entities with OVERLAY flag are now rendered in the solid pass even if they have alpha channel textures.
d3d_alpharef can be used for removing 'black seams' of overlay textures.
For easier adding external functions to lite-C, a PRAGMA_API definition can be used.
The Publish dialog can now be called through a WED command line option. SED / Publish now opens the Publish dialog and can thus now also create executables and resources.
MED's Apply Vertices Mode was improved so that vertices and mesh groups can now easier be attached to or removed from bones.