ParaEngine Change History

/** @page ParaEngine_change ParaEngine Change History @author LiXizhi


  • paraworld solution is ported from vs 2005 to vs 2008.
  • TODO: Only the f-in-box dll is not vs 2008 compatible.
  • Compiled FCollada in vs2008. i commented the lines: in libxml/config.h and libxml/win32config.h otherwise i was having a lot of errors regarding vsnprintf and snprintf). and added #define snprintf _snprintf


  • TextSprite is added to IDE. script/ide/TextSprite.lua. It can be used to render large numbers.



  • readjust the product direction to bring kids virtual world to top priority

2008.11.8 - 2008.11.15

  • a one week visit to hangzhou and shanghai, meet lots of people


  • hello chat user and room registration page layout created.
  • domain name can now be changed when logging in. rulemapping.replaceables_replace implemented. webservice_constants now uses the new replaceables. paraworld.ChangeDomain method is added.


  • HelloChat now supports loading world from external command.
  • pe:canvas3d now supports objectbinding attribute. see AssetInfoViewer.html for example. model asset viewer layout (AssetInfoViewer.html) is implemented in HelloChat app.
  • HelloChat Animation Skill command is added for demo purposes. "Profile.HelloChat.DoSkill"
  • Load Movie Immediately from external command
  • TODO: World registration is enabled.
  • TODO: a task dialog created for demo purposes.
  • TODO: The chat window displays.


  • pe:bag drag and drop operation implemented.
  • pe:bag supports inner node command. The HelloChat demos the use of pe:bag for all its asset types. It can add selection to bag, and it can drag an asset to outside to delete it.
  • the movie app demo is done by leio. pretty cool.


  • pe:bag mcml page is implemented.
  • bAutoSize params added to "File.MCMLWindowFrame" command


  • BCS asset creation order bug fixed.


  • HelloChat layout is improved with world editing functions.


  • windowframe directPosition supported with drag operations. We can now create window frame by different alignment type, such as bottom right alignment.
  • BUG: sometimes, tiny xml parse function will fail or crash when parsing xml files. This happens very rarely and is not repeatable.
  • TIXML_USE_STL is moved from tinyxml.h to preprocessor macros.
  • pe:asset is implemented. we can now easily embed model assets in mcml pages.
  • window frame default style can be replaced via external application. see HelloChat demo for more information.


  • "Creation.UpdatePanels" command added to creator app. Call this function when selection changed.
  • os.window.IsVisible implemented
  • *.bat batch scripts are created to load paraengine applications in different mode.
  • CurrentSpeed, WalkSpeed, ForceStop, ForceMove attributes are added to biped object.


  • TODO: needs to replace the C# downloader with C++ downloader. Since, the latter will be much faster.
  • Fixed: we will automatically switch left and right button according to windows settings. The left mouse button in paraengine is always the primary mouse button.
  • ParaUIObject now support GetAttributeObject() method. editbox can use this to change CaretColor and SelectedBackColor attribute
  • attribute FieldType_DWORD is implemented, which can be used for 32bits color
  • note: if multiple inheritance is used, make sure IAttributeFields is the first one.
  • "showboundingbox" property is added for all ParaObject. OBJ_SelectObject now support several selection effect in addion to firing missile to selected object.


  • pe:ribbonbar and pe:command implemented. see pe_ribbon.lua
  • PageCtrl not support GetUsedSize() which can retrieve the actual space taken to render the inner mcml control
  • RibbonControl implemented. See RibbonControl.lua. RibbonControl will automatically resize itself to best contain the current selected mcml ribbon tab page.


  • LoadUI is made fully customizable.
  • LoginPage now support cmdredirect. And we now support custom login module.


  • Logo page is refactored to be more general. Prese P key will pause/resume the logo
  • contains the sample down page test.
  • HelloChat redist files created: see packages/redist/art_hellochat-1.0.txt, main_hellochat-1.0.txt and BuildParaWorld.lua
  • HelloChat basic UI outline is created.
  • an example world "worlds/MyWorlds/KongFuChat" is created.
  • BUG: printf_s is not working as expected. I have to switch back to the old _snprintf instead.
  • unfound texture of CCS is reported to log file.


  • script/ide/IDE.lua is added for IDE central include. script/kids/ParaWorldCore.lua is added to ParaWorldCore include.
  • HelloChat app is a standalone app created on top of ParaWorld App architecture. See script/apps/HelloChat.
  • HelloWorld app is created.
  • TODO: FBX file format may be supported along with Collada.


  • ParaEngine plugins\PEDetectActiveX\PEDetectActiveX.dll is implemented and registered with ParaWorldViewer.
  • BUG: if config/config.txt contains an unsupported type, such as multisample type 2. the engine will not start. We should fallback to safe settings.



  • we now support namespace (ns) attribute to variables, so that a table can reside in a nested namespace. such as <variable name="Class1" type="Class1" ns="MyCompany.MyProject.Class1"/> more information please see AddTableDeclaration();


  • system event type is added to EventsCenter. we can now listen to system event.
  • Sys_Event.SYS_COMMANDLINE is implemented and added to event_mapping.lua
  • commonlib.Lua2XmlString is implemented.
  • script/installer/GenVisualStudioDocProject.lua is implemented to generate a script doc project for SDK users.


  • visual c++ runtime library is distributed as shared assembly. Private assembly is examined but decided not to use.
  • if the ParaEngine.sig file is not found, we will set the working directory as the current executable path using GetModuleFileName();
  • ReadRegStr and ReadRegDWORD implemented to NPL.
  • the paraworldviewer web installer is created, which is a 50KB setup file to download and install the paraworldviewer application. See script/installer/TestDownload.htm for example.


  • paraworldviewer installer nsis script created. I have find no good way to develop direct plugin for all kinds of web browsers. However, by designing url protocal, we can achieve similar result. Current I installs the paraworldviewer:// and paraworld:// protocal when the two clients are installed on disk. I will secretly inject the single parameter to ensure that only one instance of the client is running and that a message is send to the existing exe if it is requested on a different world.
  • fullscreen command line is supported so that we can specify whether to start full screen or not.


  • VsNPL is fully implemented. see script/VisualStudioNPL/readme.txt for extending intellisense via xml files.


  • VsNPL solution is added.
    • download the WowAddonStudio source from SVN from codeplex
    • install visual studio 2008 SDK.
    • Generate a PLK for product name and version, etc. Embed the PLK in resource file. and modify the LuaLanguageServicePackage.cs accordingly.
    • Edit the project property to add debug command in debug mode: /ranu /rootsuffix Exp /novsip
    • Edit the project property to add post build event to generate reg file for deployment "C:\Program Files\Microsoft Visual Studio 2008 SDK\VisualStudioIntegration\Tools\bin\RegPkg.exe" /regfile:DeployVsNPL.reg /codebase "$(TargetDir)LuaLanguageService.dll"
    • change the default registry root to [DefaultRegistryRoot("Software\\Microsoft\\VisualStudio\\9.0")] since we are deploying to isolated shell.
    • Added Documentation/NplDocumetation.xml
    • VSPackages is set to load whenever a solution exists. [ProvideAutoLoad("F1536EF8-92EC-443C-9ED7-FDADF150DA82")] // = ToString()
    • Fixed: we need to regenerate all GUIDs in order for language service to load correctly.
    • Now that debug and release mode are compiled with different GUID.
    • DeployVsNPL.reg is used to create the SetupVsNPL project: needs to replace following key values - [TARGETDIR]LuaLanguageService.dll - [SystemFolder]mscoree.dll
    • SetupVsNPL project is implemented which is based on the tutorial of
    • Note: if *.xml documentation file is not valid, it may render the entire code sense invalid for any lua files.
    • TODO: NPLDocumentation will be added in future.
  • Install VsNPL is easy, run the installer at VsNPL/SetupVsNPL/Release/*.msi


  • API servers are designed to be deployed on clusters.
  • Talked about the finance system in paraworld extensively.


  • Discussed the server architecture with kenny. It appears that ejabberd implementation may be rewritten in future.
    • TODO: Move all game server logics to linux platform, I may still need to use NPL on this server side.
    • the number of available racks may be a bottleneck on server architecture.
    • TODO: decrease the radius of visible characters if there are too many characters on server, but do not exempt transmit load character


  • project DarkStar is studied extensively. project DarkStar is an open source
  • movie platform demo is previewed by leio.


  • randint(lower, upper) bug fixed. it will generate correct upper value.
  • Texture:UnloadAsset() will delete texture info for static texture. this corrects a bug when the dimension of the texture changes when unloaded.


  • mini map is can now be captured and saved, which uses the new CaptureSceneState interface.
  • Portal rendering tutorial is given and fixed some minor bugs with portal editing system.


  • successfully ported ParaEngine from vs 2003 to vs 2005. All statically linked libs need to be rebuild using the new compiler, these include, lua, luabind, pcre, sqlite, and directshow base class.
  • to prevent dll hell, all libs are using multithreaded c run time, instead of multithreaded dll.
  • About building directX show libs. DirectX Show is now part of the windows platform SDK. however, I still build it from the dxsdk_feb2005_extras, the steps are below
    • download and install to Root/dxsdk_feb2005_extras/DirectShow/Include, add to additional project include path
    • go to and build dxsdk_feb2005_extras\DirectShow\Samples\C++\DirectShow\BaseClasses and copy debug and release output to Root\lib_release\lib\strmbasd.lib and STRMBASE.lib.
    • (During build, needs to correct several bugs to the source code and change to multithreaded mode,since they are not compatible with the new compiler) Note: the above project and files are stored in vss as well. One can grab all files from vss.
  • TODO: FCollada is added to solution. I intend to support collada file format for static models.


  • seems that we need to run a devenv /setup to fix the problem.
  • CaptureSceneState and RestoreSceneState implemented in ParaEngineExtension.lua.
  • jmonkeyengine studied.
  • Fixed: luabind updated to 7.1. I have tried to port ParaEngine from vs 2003 to vs 2005. But stuck at the place where LuaBind does not support out_value or pure_out_value for luabind object type. Anything except object is OK.



  • objects on miniscene graph are always shown in the main scene regardless of which zone they belongs.
  • main scene rebuild processing logics changed from queue traversing to recursive functions.
  • BaseCamera now inherits from the BaseObject interface, which has the homezone property.
  • BUG: after right clicking on the object property to edit its position, the creation panel's click to drag create function failed to function.
  • TODO: when adding new objects to the scene via user interface, we should automatically add the mesh object to the zone where the camera eye position resides.


  • transparent shader's zwrite enable is reenabled after finished with the effect.
  • Render logic change: OBJ_VOLUMN_CONTAINER is obsoleted, use portal system instead. Child objects of scene graph are invisible by default, unless it is miniscenegraph.
  • objects with home zone are removed from shadow caster list.
  • shadow rendering logics are slightly changed.
  • Microsoft made a WOW addin for visual studio 2008 to demo its extensibility. It contains a lua language service which may be of use in future.


  • zonepage can not pick, select, list, highlight portals that belong to the current zone.
  • zone object picking, selection, deletion is implemented in zone page.
  • ParaObject:SetHomeZone() method is implemented. Mesh objects are serialized with it.
  • rough CBaseObject collistion test method is refactored to use accurate sphere testing against frustum.
  • Portal and Zone object camera frustum testing is made different from normal object, because it must shift the near plane to the eye position. Also portalFrustum's camera frustum should be zero near plane distance.
  • BUG: sometimes, first camera persion view's vEye's Y axis can be invalid.


  • when right click to edit an object position, the creation panel's left click does not work anymore.
  • personalworldpage are now sorted by write date.
  • Portal, Zone auto generation functions are fully implemented. PortalDemo world is created for demostrating the portal rendering system.


  • installed visual assist X again.
  • syntax coloring for lua is implemented using visual studio usertype.dat. see "script/ide/visualstudio_highlight/readme.txt"


  • NOTE: vs 2005 suddenly failed to restart. after uninstalling some components, and have a disk check on c and e drive and restart, the vs 2005 magically start again. however, on the next day, on a clean reboot, the vs 2005 will not start again I uninstalled, started and killed process many times, and it wonnot work. After installing a asus AI software and have the E drive disk checked (actually skipped on reboot), the vs 2005 can restart again. but the message The Windows Forms Designer Hosting Package ({68939055-38E0-4D17-92CB-8909710D8178}) did not load because of previous errors. For assistance, contact the package vendor. To attempt to load this package again, type 'devenv /resetskippkgs' at the command prompt. appears on each subsequent reboot. and it asks me to run "devenv.exe" /resetskippkgs next times. There are some google results of failed loading packages on vs. however, I also suspect that it is the disk problem.
  • for highlighting lua source code, there are two ways without using additional software, like lualangpak. One is provided by VS itself. the other is by visual assist X, because VB code looks a lot like lua, except the comment.



  • width, height, depth, facing attributes added for BaseObject. they are used for databinding for zone/portal's bounding box. see PortalPage for example.


  • PortalPage, ZonePage, PortalSystemPage implemented.
  • MousePick now support filter function which allows picking of any object type combinations.
  • Map3DSystem.msg.OBJ_PickObject is implemented which allows picking via a callback function and a filter. It is used with portal and zone picking.


  • pe:numericupdown tag is implemented in MCML for NumericUpDown control
  • the character may have alternative standing animations. A character must have the standing animation ANIM_STAND(0), it may also have up to 4 custom standing animations, in the id range ANIM_CUSTOM0-ANIM_CUSTOM3 we will play the custom animations, if any, randomly after the default standing animation is played after some set time(such as 10 seconds).


  • NumericUpDown control is fully implemented in IDE, with spin buttons, mouse wheel and mouse drag.
  • databinding also support NumericUpDown via IDE_numeric type.


  • TODO: world upload service should use patching on the server side. and the server need to apply patch via a seperate process that runs at idle time or at night.
  • Asynchronous web request on the server side is studied.


  • sky shader now renders with z test enabled, and with depth value set to 1.0. so it is now rendered after the terrain to make the z-buffer work better. Currently both the shader version and fixed function will allow this function of optimization.


  • BUG: when running debug build, I once have the message g:\scm\release\PhysX_2.8.1\novodex\SDKs\Core\Common\src\SceneRaycast.cpp (470) :invalid parameter : NxRay direction not valid: must be unit vector. I wonder this caused the infinit plane problem.
  • TODO: View/fog Distance should be saved in machine config, not in the world db. When saving effect level, make sure shadow, etc are changed accordingly.


  • portal rendering algrithm itself is fully implemented. there are some limitations to the current portal system
    • only the outer world zone can contain other zones
    • the camera can see into a room via at most one portal. in other words, there can not be two doors in to the same room with positive dot product. if there have two such doors, one of the door contents are ignored which renders the result undefined.
    • mobile characters will be automatically added to appropriate zones. However, it is advised to use simple zone shapes with just a few planes
    • static mesh objects are manually added to zones at scene saving time or model exporting time
    • objects inside a zone will not be shadow casters.
    • zones consists of planes, which are expressed as normal from the origin(0,0,0), hence the zone must be convex and contain the origin 0,0,0 point in its inner space. if the zone node contains a exact point (0,0,0) it will automatically become the ground plane.
  • portal system will automatically disable sky, ocean, shadow, and terrain when camera is in a zone disconnected with the outer world.
  • BUG: the mainmenu in script will black out once when first show up.
  • TODO: export zones from 3dsmax or create directly in the game.


  • data binding class now support MCML_node type. See pe:fileuploader for an example.
  • pe:container now support relation and visible attributes.
  • Project template: InstallApps is refactored.
  • PageCtrl:CloseWindow() is added which allow a page to close its container standard mcml browser.
  • log method will not throw exceptions for some strings with percentage letter %.
  • TemplateProcessor.lua is created for creating components via mcml page in DeveloperApp.


  • pe:fileuploader now supports "*." as dir attribute
  • DeveloperWnd in DeveloperApp is refactored. Project template: NPL_File is refactored.
  • IM account import is studied.


  • all render targets (miniscenegraph) are created with preset alpha to 0.f.
  • CCS UI is optimized for lazy loading. A number of other UI themes are made consistent.
  • new installer is made with the new UI system.


  • portal rendering is improved with camera support.
  • new black UI theme are done. the content client area is now non-transparent white, with a black border.
  • debugwnd, testconsole UI layout improved.
  • text property of all ParaUIObject will not affect its color.
  • bug: "warning: sCode exceed the length limit of 4096" occurs on JGSL server when the creation string is too long.


  • the best full screen resolution will always be smaller or equal to the current adapter resolution.
  • nsis updated to 2.39. installer slightly refined.
  • JGSL servermode will now automatically reconnect every 10 minutes if disconnected.
  • vista UAC installer problem solved. the new installer will run by requesting admin level permission.




  • portal rendering system is partially implemented. PortalFrustum is implemented. More information, please see CPortalNode.cpp file for my design.
  • google chrome source code studied and webkit rendering core studied. TODO: maybe we can update the internal browser to webkit.


  • paraworld installer now supports vista. dx and physx installs as non silent mode during vista operating system.
  • occlusion query for ocean is improved to use the query result from previous frames if available.
  • occlusion query banks are now created on demand.
  • TODO: use portal and anti-portal for rendering small meshes, instead of using hardware occlusion query, since the query result may not be available until next frame, otherwise it will stall the CPU.


  • portal and antipoatal rendering studied as occlusion technique in the public world. For public world, we must do LOD and portal based occlusion.


  • attended CSDN hero 2008 at shanghai and give a lecture on paraworld
  • listened the "smart" development lecture by ivory jaconbsin.


  • ArtToolsPage.html and ProToolsPage.html are added to developersapp. They maintain a list of micellanous tools for artists and developers.
  • character, ocean, small meshes now all use hardware occlusion testing.
  • ingame statistic descriptions are added to developerapp wiki topic.
  • front page is slightly refactored.


  • MapPosLogPage are implemented in minimapapp. It can be used to store important positions within a given world.
  • performance statistics are implemented for all directX draw calls in paraengine.
  • Ocean occlussion testing is fully implemented. we will only render when occlussion test is passed. It will greatly improve ocean rendering speed.
  • occlussion testing is by default enabled for small smeshes, when their count is above a given threshold, such as 25.


  • pe:name now uses fixed height. <a> mcml tag now support fixed height.
  • left click now takes no effect no current player.
  • preload.lua and onload.lua script are added to paraworld world loading procedure. the preload script can be used to download and load art resource files. wow models and worlds are ported to engine for art references.


  • custom game fonts are supported at "fonts/*.ttf". See AddFontName(). One can also add mapping via "GUI_font_mapping" property in config.lua. see script/config.lua for example. A lite font is used and added to installer.
  • most mcml and npl files are localized using TranslateFilePage with autotranslation.



  • the installer now supports multiple languages via MUI2. If the user selects a installer language, the product will automatically assume that language via its config file.
  • bug submit page is implemented.


  • config/config.txt will automatically remove the read-only file attribute when overwriting the file.
  • EncodingConvert("utf-8", "", s) now supports utf-8 to/from ansci conversions.
  • translator now output mcml translations correctly.
  • CopyTextToClipboard is now functional with ansci string.
  • TranslateFilePage.html is implemented and added in developersapp.


  • mcml page translation is implemented. for any div style tags, including the pe:mcml page, we can use the trans attribute to specify how the child nodes are translated.
  • ParaworldMCML translation table are implemented. The Build process now include the generation of translation tables.


  • SetSegment and GetBase64String are added. They are used to send files via web services by blocks
  • is implemented which will break large files to pieces before sending. see for details.


  • whether we treat png file as DXT3 by default. if the texture filename ends with "_32bits.png", we will load with D3DFMT_A8R8G8B8 instead of DXT3. If one wants to ensure high resolution texture, use TGA format instead.


  • bug fixed: when xref objects are animated twice when rending ocean reflection.


  • mipmapping is used for dds. png and jpg are by default using DXT3 and DXT1 without mipmapping, which may lose some colors. To use ARGB8 format, one can use tga file format.
  • cartoon face and ccs body compositive textures are saved as compressed dds format with full mipmapping, instead of ARGB8 format.
  • Texture LOD can now be set at run time.
  • CommonSettingPage.html page are implemented in settingsapp. Texture LOD and anti-aliasing are added to it.


  • MovieApp are fully designed.
  • New main task bar UI is available


  • MovieApp architecture code are implemented.


  • ccs component can now have xref objects.


  • personalworldpage.html is implmented with multiple view mode.
  • pe:if tag condition will be evaluated each time page is refreshed, instead of just once.
  • SearchFile now support getting all file info, such as file size, file attribute, file times. etc. see. GetItemData


  • starviewpage is partially implemented.
  • in pe:gridview one can also apply css style to PageSettings.


  • new attachment points for CCS is defined. ear, facial addon, back, waist, boots, etc are defined.
  • artists want high heel boot models. BootHeight property (attribute) is added for character. boot height, default to 0.f meters. It only affects rendering. In case, the character is wearing a high heel boot, we may set this to 0.1-0.2 meters. e.g. obj:GetAttributeObj():setfield("BootHeight", 0.1);
  • Post processing pipeline are fully implemented and tested with a motionblur shader sample. a dozen of new api is available for doing post processing in NPL.


  • Post processing pipeline is implemented in ParaEngine. see the script/ide/PostProcessor.lua for example usage.
  • post processing shaders are added in script/shaders/*.fx


  • An application called NTWrapper is used to host ParaEngine JGSL public server instances as windows service. See the wiki site for operation details.


  • jgsl grid server is tested with multiple users and multiple worlds. Max history reset number is implemented.
  • jgsl client and server agent timeout logics are corrected.
  • cheer for Beijing Olympic 2008


  • grid server is fully implemented. is registered. AutoLobby is configured to join public server before trying for private servers. wiki documentation for operation is added. see JGSLPublicGameServers
  • JGSL server bandwidth limit is removed for official public servers.
  • JGSL client logics are slightly changed to recover from temporary packet lost.


  • grid server is implemented. please see JGSL_grid and JGSL_servermode.


  • installer now will not delete screen shot and world/MyWorlds during uninstallation.
  • NPL jabber client will now output error messages in msg.error={code, condition, msg} field, such as offline messages.
  • JGSL will now handle offline user responses.


  • PageCtrl backward page now support inner iframes. The inner visible page, if any, first goes backward, and then the parent page ctrl.


  • unhandled mouse up event is allowed to be sent to 3d scene event when there is a 2D window who has focus.
  • texture info are not deleted when device is deleted. However, it is deleted when texture are refreshed. This fix a bug when remote http texture reloads.


  • cursor file is loaded from memory (managed asset) to increase speed when cursor images changes frequently.
  • we can generate pkg file while the pkg file is still in use.
  • ParaIDE project is moved from AB to VSS
  • A bug when changing source control provider in vs2005 is corrected: First UNBIND old solution from old source control provider and save and exit vs. Now delete *.suo file, this is very important. Finally, change the *.sln binding to the new source control provider and get latest version.
  • ejabberd is made as a boot service in ubuntu linux server. See the ejabberd solution for details.
  • All VMs are auto started with the host server machines
  • the ubuntu linux service can now share folders with windows development server via smb service.


  • script solution is moved from AB to vss 2005. Integrated windows account now seperates two different users types artist and programmer. BuildInHouseSDK() is implemented to build a main.pkg at the root dir for in-house development. It contains the latest script and xml files, but is different from the release version main package.
  • AB buckets are created with each 2GB, with a total of 17GB data. Buckets are moved offline and backed up to persistent disks. AB consistency checked are scheduled monthly, old consistency are corrected.
  • left button move logics changes slightly: if user double clicks or does not select any object we will get the picking object and move the current character to that location.


  • mcml browser window can now toggle display nav address bar
  • BUG fixed: multiline editbox press enter key on the first line will not break text.
  • translation locale will generate warning instead of error for unfound translations.
  • KidsUI translation is removed. ParaWorld translation is added.


  • Camera position, character facing, and time of day are now perserved when saving to db.
  • default LoginWorld changed to an ordinary game world. LoadWorld now support loading a world without resetting UI. This allows us to silently switch main scene while UI is unchanged.
  • ParaUIObject.cursor is added. we allow any UI object to specify a 32*32 image cursor file when mouse over it.


  • Game Cursor is changed automatically according to current selection.
  • ParaWorldStart page now uses real scene instead of miniscenegraph for login scene.


  • if render target conflicts with a static texture, it will replace the static texture in the texture manager.
  • CloseWindow added in It also fixes a bug when editing replaceable textures in the scene, cancel editing now triggers the end editing event correctly.
  • css:max-width and align property added to div mcml tag.
  • MCML browserWnd now support navigation bar to be separate.


  • glow effect parameters are saved with the game world.


  • when character is mounted, any moving state is removed from state manager.
  • SettingsPage for EnvApp is implemented.
  • AutoPatcher design and intial implemented is done. see autopatcherpage.html.
  • UI is once again refactored by designers


  • GetCursorFile is implemented. We can now change the cursor regularly according to our logic
  • all paraworld services are now on vmserver 2.0


  • TODO: auto patching should be implemented. using vpatch3.2 and nsis
  • TODO: JGSL game server should be implemented as a system service for public world.
  • TODO: we should change cursor for different action hint on the mouse.


  • persistent earth world view is get rid of. the ParaWorld world view is the only view in the platform. The star world view is reserved for future consideration.
  • container will now leak all unhandled mouse messages to 3d scenes.
  • disablemousewheel is added to treeview. QuickChatPage now uses the new feature to display interactive chat content with two states.
  • movie script is designed, which is a wiki style text scripts that can be used to direct speech and actions in a scene. Character speech and camera(actors) may also be extracted completely from the scene.
  • vmserver and vmconverter are downloaded and used for the server.


  • ParaCamera CameraMode is implemented. Conflicts of WASD key when in free camera mode is resolved.
  • When left button is down, camera lock behind is disabled. when right click, camera is locked behind character. When camera is not locked. left click will move the current character to a given location. See mouse handler for more information.
  • backward key will remove the current biped's waypoint.
  • TODO: JGSL is too easy to have a broken line. we should reconnect to old server once gain after a broken line. If reconnection failed, we will try to host our own server.
  • TODO: VIP: model update and sharing: if a model is not found, it will search in the global object category and download if found. We also allow people to upload objects to our category. global object category is the AssetApp application service. It is for artists to share models with the community. A user can constantly download models to their local server and use offline models with ease.
  • TODO: People can only corporate on a published read-only world. If they wants to save their improvisional creations, they can package them into blueprints and use them in their homeworld. In future release, we will support saving as a different file from a readonly cooperative world. This will allow people to work on terrain and landscaping together.
  • TODO: VIP: a Beeper with XRef that could play MP3 music, etc.
  • TODO: Think about business model and coporation models who wants to run serious virtual worlds on it.
  • TODO: Saving animations to world or improving the movie shooting functions.
  • TODO: Dumping non-existing models and characters in the world.
  • TODO: toggle jabber server address automatically.
  • TODO: occasionally, the same character has two same avatars on server.
  • TODO: adding jabber friends between lxz1 and lxz2 is one directional.


  • linux system services and boot order is studied and configed the ejabberd.
  • TreeView scrolling is fixed. Now that we can disable clipping for fixed height tree view items. However, the scroll step, scroll page size, and the tree view height must all be integer times of treeview item height. Example usage can be seen in Lobby BBS channel page.
  • button mouse over will now only take effect when all its parents and itself are enabled.
  • Lobby BBS channel page refactored to use new treeview and mouse over feature.
  • bug fix: ParaUIObject:LostFocus() can now loses focus to 3D scene completely. It used to loses focus to its parent container only.



  • action feed can now be cleared by group.
  • TextureEntity now support hit count property and MakeInvalid method.
  • miniscenegraph active rendering will now only render when there is an visible object in 3D or UI that calls the GetTexture() method. Internally, it used the hit count property of TextureEntity to decide whether there are hits in the last frame.
  • particles can now be rendered properly in miniscenegraph and main scene. The scenestate caches global particle for different scene.
  • User confirmation email can now be resent when unactivated user signed in.


  • TeleportPage is refined and support none-remote-world. profile page and a few other places now supports teleport shortcut.
  • aabb bounding box can now be exported from the reference model for characters.


  • TeleportPage is fully implemented. it now allows people to easy teleport to another user.


  • username can not be empty when register profile.
  • downloaded world will be saved as
  • bug fixed: address bar visibility is now persistent.
  • bug fixed: retry_cancel is now properly displayed by MessageBox. When logging in, the user can retry or cancel login process via the new message box buttons.


  • right click OPC to see its mcml profile is supported. JGSL query profile is implemented with local server support. Right click an jabber client character, we can retrieve its profile from context menu.
  • Bug fixed: JID of server used to contain upper case letters. After the fix,all JID are converted to lower case using string.lower(), see GetJID()
  • Map3DSystem.JGSL.query.GetWorldInfo is implemented. see JGSL_query
  • paraworld.users.getInfo is implemented with local server.


  • inner world listing is sorted by date on the client
  • switch character right is granted to friend role.
  • bug fix: user can refresh a previously uploaded world.
  • art and model asset are moved to the packages/startup. Main core packages is reduced to include only script and UI texture, which makes granular update easier later on.
  • it takes me hours to find a random occurs bug: when compiling and loading empty script file, it may sometimes generate runtime error. Avoid loading empty script file.
  • bug fixed: we can publish a world twice.


  • bug fixed: mcml text width sometimes miscalculated. pe_text is fixed. however, multiple lines of scaled font may still appear wrong, but will not affect parent layout.


  • BCS Xref dependencies solved. now it uses the app framework.
  • Headon text uses physics height. Headon text display bug corrected: it used to render invisible UI attached to 3D objects like headon text.
  • pe:if and pe:if-not are added to mcml tags.
  • disabled creating two objects at the same place


  • bug fix: remote texture whose file name is same as texture sequence does not show up.


  • full screen size is auto picked which is nearest to the window size.
  • bug fix: full screen mouse is not displayed on some computer



  • ParaWorld automated build pipeline is established. See script/installer/BuildParaWorld
  • numerical key 1, 2-9, 0 can be used to face camera and play various predefined animations.
  • autotips is fully implemented. camera, fly mode, pause game all added to autotips.
  • GeneratePkgFile() is implemented.
  • Basic security fix on BBS chat and action feed with XMLEncodeString();
  • assetmap is disabled in release build. watermark is disabled in release build.
  • Ebook is supported in new ParaWorld app. EBook tutorials worlds are refactored using new world format.


  • biped character picking bounding box is read from ParaX asset file and is different from physics boundingbox. This makes mouse picking of character object more easier. This also makes headon speech dialog display more accurate.
  • TODO: mouse picking: if ray intersects with more characters, we can loop among the touched characters, instead of using the closest candidates.
  • biped that floats on water surface animation (like boat) will now use land running animation instead of falling down animation.


  • ParaWorld installer script is completely refactored to use nsis script. It has dependecy check and auto install for windows installer 3.1, .Net 2.0, vc8 sp1, DirectX 9, DX Update, Nvidia PhysX where only vc8 sp1, DX Update, Nvidia PhysX are contained in the install package, all other dependencies are downloaded from the web if not present. More information, please see paraworld_installer_v1.nsi, and script/installer.nsi, installer assets are Texture\3DMapSystem\brand folder.
  • random walk will retain its initial center position when the behavior is assigned.


  • Nvidia PhysX upgraded to 2.8.1. experimental NX_SUPPORT_MESH_SCALE is disabled.
  • Nvidia PhysX upgraded to 2.8.1. Please note that the experimental NX_SUPPORT_MESH_SCALE is still not supported in this latest version.
  • pw_sandbox_file is added which included mcml in sandbox mode. sandbox mode is applied to all zip file.
  • Tutorial world is made via a minimap.


  • shift character access right is added.
  • middle key to fast move the character at administrator right.
  • mini-map background is supported. minimap.png(or jpg) file under world root directory is used as the default minimap of the world.
  • UploadWorldPage is fully implemented which upload the current world to user's logical path "worlds/[worldname].zip" on the remote server


  • PublishWorldPage is implemented with local saving and saving as. World Preview image can be generated from save page. Full scene saving (renaming) is supported.


  • quick chat and BBS channel is implemented with better mcml based UI and some basic formatting to chat text is implemented.
  • JGSL client/server is improved with broken line recovery. And performance is boosted by using local namespace.
  • JGSL query class is implemented for query information about a given client.
  • mcml checkbox and radiobox now supports onclick events.
  • linux and win server security is studied for paraworld api and jabber. TODO: more needs to be explored.
  • all paraworld server


  • character rflections supported.
  • JGSL broadcasting logic is changed. It will only broadcast content after connection, instead of from world loading. Bug fix: The first history message is not resent.


  • ChatDomainIP is supported in JGSL, although at release time we need to remove it. see webservice_constants.lua.
  • headon_speech.lua is improved with full mcml text support, such as <a href="#">link text</a>. Pure text support auto-sized background. If mouse is over text, it will not disappear with life count down.


  • A serious bug in os.hook is corrected. All hook messages are called twice in the old days, now it is working as expected.
  • AutoLobbyPage is implemented with auto login feature. More information, please see Map3DSystem.App.worlds.AutoLobbyPage.AutoJoinRoom() method.
  • session key logics (JGSL_msg.CS_PING and JGSL_msg.SC_PING_REPLY) are built into JGSL client and server. currently we allow a PC to be either a client or a server, but not both. Each time the world path changes, session key will change, thus all servers and clients are disconnected. because we have session keys, offline or other irrelavent messages can be wisely filtered by server or client. and it sures that it only serves the recently connected client or server.


  • following official worlds are added:
    used as basic tutorial for both online and offline version
    used as advanced tutorial for both online and offline version
    used as developer tutorial for both online and offline version
    used as default homeworld of a user who has not submitted any homeworld before. This makes it possible for other users to join its world even it has never been created before.


  • OpenInBrowserDlgPage.html is implemented to replace the old dialog box.
  • WelcomePage.html are created for all important official applications.
  • DestroyOnClose property supported for File.MCMLBrowser and MCMLWindowFrame
  • LogoPage.lua now support use anykey to continue.
  • AutoLobbyPage is implemented and added to statusbar via application interface.
  • when moving or copying or selecting using context menu, characters will always face the selected object.
  • MiniMapPage.html is implemented and added to status bar.


  • CharSavePage is improved with saving functions
  • LoginStatus is shown immediately, when clicking the login button.
  • input button in mcml now support Get/SetUIValue method.
  • VisitWorldPage is implmented with user tile, world info retrieval.


  • mount animation is deprecated in ParaEngine, instead use the scripting interface to specify which animation to play.
  • witching off a character(vehicle), the character will be stoped to prevent it runs to infinity without a controller.
  • character head turning angle is set to 0 when mounted.
  • MQL is upgraded. FriendsFinder.html support strict email and partial name match.


  • DynamicVertexBufferEntity now can fail gracefully if it can not get enough video memory on restore.
  • LogoPage is refactored and used in ParaWorld for the logopage when application starts.
  • ContextMenu and PopupEditor now always stays in their safe screen area.
  • S_Mount action is deprecated. One needs to use ParaCharacter:MountOn(obj) instead. Recording of mount action is no longer supported.
  • "IgnoreWindowSizeChange" attribute is added to ParaEngine attribute, one can now specialy whether window resizing to affect backbuffer.
  • windows cursor now works correctly when IgnoreWindowSizeChange is true and window is resized. mouse position is updated completely via windows ::GetCursorPosition(), instead of d3d cursor.
  • pe:editor and pe:container now support aligment="_fi" and width="100%".


  • autotip is refactored to application desktop and uses mcml and work with paraworld application.
  • pe:label and font mcml tag support text-shadhow property.
  • tooltip of UI buttons are improved with milliseconds accurate popup delay time setting.
  • Application Help Page implemented by SettingsApp. File.Help command can be used to trigger it. Each application can register a help page with app:SetHelpPage() like they did with app settings page. F1 key will trigger only the help page of the given application.





  • pe:script now support "refresh" property. This allows inline script to be evaluated only once. it is useful for query parameter tab page selection. pe:script documentation is improved.
  • MyDesktop app now handles fly (F key) and run (R key) toggling.
  • localserver will now save empty mcml profile. It can be used to delete invalid mcml profile when detected for the current user.
  • popup object modifcation window is refactored in CreatorApp. The UI is on mcml page PopupObjModPage.html
  • BlueprintApp, ProfileApp, VideoRecorderApp, now works on the new application framework.
  • TODO: pe:world, publish world wizard.


  • developer app switch desktop added. Online user page and recent registered user page is implemented in loggedinuserpage.html.
  • pe_gridview paging rendering is now correct with page refresh. TODO: Design a method to refresh only smallest part of the page. Because gridview node are rebuilt during refresh. fetching property of pe:name does not take effect.
  • AnimationPage is fully implemented by the CCS interface. However it requires that animation files not in zip package for the from file tab to work properly
  • os.hook post call back are called correctly
  • text-align:center now works properly in mcml.
  • all alignment type UI controls can now be draggable. In the old days, only "_lt" can be correctly dragged.
  • objmodpage is improved with advanced and simple SRT tranformation.


  • Entire paraworld namespace refactored to remove unused files and tables. TableDef.lua is mostly useless. Each system file will define their own local table space.
    • ccs.lua is refactored to use local table for improved executation performance. ccs.lua is considered a ccs data file and used in ide/objecteditor. TODO: move ccs.lua to ide/objecteditor.
  • AppDesktop is implemented to provide public application desktop functions for application developers. The most important one is desktop mode. it also wraps the desktop main menu and app task bar.
    • desktop mode is implemented. one can search for DesktopMode in source code to find where they are used.
  • ParaUIObject.Destroy() now support id. Destory method in ParaUI is refactored to use id and a bug with PostDestory is corrected.
  • ParaUIObject.lifetime property is refactored. It corrects a bug of error deletion.
  • Bug fix: the first created character will not be used as the default character. This may errounously make a mini scene graph character a main scene player.


  • ParaUIObject slider now support background and button property. And the background now support 9 element bg.
  • colorpicker control now uses colored slider buttons and centered text.
  • kids_db is reimplemented as world_db and user_db. the paraworld now completely break dependency from kidsmovie code base. headonspeach display dialog correctly with Reposition called. EBookApp break dependency from kidsmovie code.
  • ParaUIObject.lifetime property is fixed. The old implementation may lead to crash with UI deletion time?
  • dropdownlistbox control now uses id instead of global name.


  • Advanced create world page is implemented.
  • APP_WORLD_CLOSING is sent to each application before a world switching occurs. This gives an application a chance to display some user interface before the current world is closed. For example, see worldsApp.
  • one can now hook the onsize window of input application. The msg contains current screen width and height. More information see OnScreenSize()
  • Terrain MainTexture can now be null or invalid. TODO: better use unchopped main texture, otherwise too many textures are wasted. 8*8=64 main textures per terrain is a waste of space.


  • NewWorldPage in worldsAPP is implemented with category template, world info page at worlds/Templates/*.*.
  • new worlds are created at worlds/MyWorlds by default.
  • Empty world templates are created at worlds/Templates/Empty/*.*


  • pe:custom tag is fully implemented for embedded NPL UI objects inside mcml page.
  • a tag support page scoping onclick function with type property set to button.
  • AvatarRegPage is refactored with gridview and uses the new a tag with page scoping.
  • ScreenshotApp will take UI screen shot without the screen shot window itself. It will now upload image to web via paraworld.actionfeed.SubmitArticle and paraworld.actionfeed.UploadScreenshot is added for kidsmovie in paraworld.
  • pe:avatar now support inner nodes and support TakeSnapshot function. AvatarRegPage.html now uses it to display a take snap button.
  • TODO: New World wizard, pe:world, publish world.
  • TODO: delete invalid mcml profile when detected for the current user?


  • ocean, sky, terrain page is fully refactored in mcml. All old functions are functional, the UI is in mcml page file. See OceanPage.html, TerrainPage.html, SkyPage.html.
  • application switching is now enabled for AppTaskBar.
  • ide/AutoHide is fully implemented. It gives auto hide capability to any container one specifies. desktop mainmenu is now autohide by default using this technique.
  • png and dds static textures are created with dxt3 and dxt1 respectively in ParaEngine.


  • pe:sliderbar is fully implemented, which embed the ide/sliderbar. sliderbar onchange event is fixed to avoid duplicate value calls.
  • ide/colorpicker is added and implemented. pe:colorpicker is fully implemented, which embed the ide/colorpicker. colorpicker onchange event is fixed to avoid duplicate value calls. more information, please see script/kids/3DMapSystemApp/mcml/test/test_pe_design.html.
  • MCMLWindowFrame commands is added to create mcml based window frame via app command. SkyPage is refactored to use mcml page window frame.
  • LoginPage is fully implemented by the LoginApp.
  • pe:gridview now support ItemsPerLine property which allows multiple items to be displayed on a single line.


  • Logged in front page is completely done with story, request and message feed. ActionFeedApp now implements data source functions for mcml pages.

2008/6/4 -simple mcml style like div support width, height property with percentage like width="70%"

  • Support multiple feedtype and feed template: what kinds of feed is sent, nil,"story", "action", "request", "message". Defaults to "message", where "story" and "action" requires that the receiver is a friend of the current user.
  • Page object is exposed via embedded code script. It is the same object as the document:GetPageCtrl().


  • rulemapping now support multiple strings in a table as value field. the auto character animation will now use this feature to play different animation when mounted according to the user input such as pressing forward key or down key.
  • adding and becoming friends are published to action feeds
  • fixed: invalid objects are not attached to miniscenegraph now.
  • NPLParser class now support auto indexed table items {"string1", "string2\r\n", 213, nil,["A"]="B", true, false, {"another table", "field1"}}. So IsPureData() for the above items will be returning true. and NPLWebServiceClientLib also support this.
  • IDE/contentmenu now will indent correctly. TreeNode can indent correctly.
  • a_class, a_style is added to pe:name mcml tag.
  • "_mcmlblank" can be specified as target property in a tag. ProfilePage.html is added to show the profile of the given user.


  • PublishFeedPage is fully implemented with url, content. Feed is displayed on front page.
  • IsPureData now support limited lua 5.1 syntax. I actually implemented over the old 5.0 syntax, to make it recognize \r in additional to \n in string. Full 5.1 syntax is not ported. It is still basically 5.0 syntax.
  • os.lua is now fully integrated with ide/windowsframe. McmlBrowserWnd now uses the new ide/WindowFrame interface.


  • Profile.Actionfeed.Add command is added. Actionfeed is now displayed on logged in user's home page.
  • zorder is added to windowsframe. AppTaskBar integration is partially done.


  • AppStartPage theme art is fully implemented with or without animation.
  • PateCtrl:Redirect() method is implemented, which allows page script to redirect to a different page. This is used in startpage to display different content based on logged in status. Although we can use iframe for the same function, the backward, forward navigation button will not be usable. So use Redirect and specify a time delay.
  • XPath is now moved to commonlib.XPath. The old one conflict with the mcml XPath function.


  • fixed: ide's multiline editbox can now hold pure chinese character. and it uses global unique id for selected line, instead of global name.


  • zorder is added to ParaUIObject, default value is 0, the larger the more top level. usually set to 1. Internally stable sort (bubble sort) is applied to children at AddChild and BringToFront and BringToBack() function. for real top level windows, the z-order is secretly increased by 1000 to make them stay above all zorder.
  • AppTaskBar's StartAppPage is implemented with datasource. AppTaskBar is a z-order 1 window.
  • Universal bone includes hand extension bones: finger0, finger1, finger2, ... .
  • Fixed: pivot point of the root bone is not exported in v1/boy. In order for pivot point to be exported, we need to assign weight to each bone. It is common to forget to do so to Root bone. A trick to fix this is to bound all bones to a invisible mesh triangle and assign some weights for each bone. This shall ensure all bones' pivot points are exported.
  • InviteFriends.html is fully implemented with paraworld.users.Invite api call.


  • iframe tag in mcml support relative path. pe:if-is-user supports loggedinuser as uid property. The StartPage.html in loginapp uses this features to display different pages for logged in and not logged in user
  • Online mode buttons are displayed via app command interface.
  • if the command line contains "startpage", it will be used as startup page of loginapp. e.g. C:\InstallDir\ParaWorld.exe startpage="script/kids/3DMapSystemApp/Login/NewUserRegPage.html"
  • pe:script inline code block with document:write() will handle Chinese character correctly.
  • wordbreak is supported in mcml label tag.


  • buf fix: dymaic vertex buffer size overflow: if the requested buffer is larger than the total dynamic buffer size, we will break the input.
  • pe:progressbar is added to MCML tags. It is used in PackageMaker. pe:if-is-user is added to MCML tags.
  • FriendsPage is fully implemented, with adding, removing, showing friends, etc. see FriendsPage.html.


  • mcml a tag supports onclick events and parameters. LoggedInPage is refined.


  • pe:mqldatasource is fully implemented. see mcml/pe_datasource.lua
  • FriendsFinder now uses mqldatasource and gridview. TODO: if a page contains multiple web service calls to the same paraworldAPI only one is called. This is not the desired behavior.


  • company mail server is fully configured with pop3 and smtp support using smartermail and dynamic DNS.


  • pe:download now supports refreshing, download status text, such as the total number of bytes currently downloaded. More information, please see "script/kids/3DMapSystemApp/mcml/pe_component.lua" and "script/kids/3DMapSystemApp/mcml/test/test_pe_components.html"
  • localserver resourcestore now supports individual file progress report callback.
  • Maximum numberof Mount attachment points of a character is increased from 10 to 20. One can bind bones to Path in 3dsmax.


  • mcml tag pe:download is fully implemented. mcml tag div support background and onclick event.
  • Microcosmos Query Language is implemented. see. NPL.load("(gl)script/kids/3DMapSystemApp/API/paraworld.MQL.lua");


  • all simple mcml tag like div now support "display" attribute, it is similar to css.display property. except that it only recognize "none" as input
  • <pe:tab-item onclick="funcName()"/> onclick event is added. <a href="open://relative file path "> is supported.
  • rulemapping lib is implemented. see "script/IDE/rulemapping.lua" and "script/ide/test/test_rulemapping.lua". Currenly, this is used in MCML url mapping rules, and mount.rules.lua file for the auto character mount animation.
  • "mount.rules.lua" is added and used in event_handlers_keyboard. We can now map any model to their default mount animation using either strict mapping or regular expression mapping.


  • Animated Xref object inside static mesh may contain mount points. This is fit for models like swing, where most of the model is static,only part of the model is animated, and the character can sit on the animated part if it contains mount point.
  • Multiple mount point is supported, it will mount to the closest mount point.
  • ParaXExporter: A critical bug in release 2008/4/8 is fixed. static mesh bounding box is not exported correctly as before. now this is fixed. bones whose name ends with Mount, Mount1-9 are supported.
  • New API added ParaObject:HasAttachmentPoint() ParaObject:GetAttachmentPosition() ParaObject:SetAnimation() ParaObject:GetAnimation().
  • In ParaWorld script logic, the left shift key will switch to and mount on characters or static mesh with xrefed mountable objects. When it is the latter, camera remains on the current character and the W and S key can be used to start/stop the default running/standing animation on the mesh object.


  • LoggedInHomePage.html is added in LoginApp. It is the page to display after user logged in.
  • the registration process is refined with already filled app registration page skiped. Profile reg page check for username and photo and automatically display the tab page.
  • Mcml browser and page control can now nagivate back and forward among rcently opened urls.
  • ParaUIObject:SetDefault() is added for default button in a container. DefaultButton property in button MCML is also added. When enter key is pressed in editor box, the default button of its container will be clicked.
  • double precision fixed when transmitting double number over web services.
  • ParaUIObject:Reposition(alignment, x,y,w,h) is added. We can now change the position and alignment even after control is created. ParaUIObject.height and ParaUIObject.width will now work for "_m*" alignment. Their meaning, however, is the distance from right and bottom border of its parent.
  • pe:xmldatasource is fully implemented with internal xml data node or external xml data file. see "script/kids/3DMapSystemApp/mcml/test/test_pe_gridview.html" for example


  • pe:pager is fully implemented and integrate well with pe:gridview control. pe:pager also support custom look. all events are now working in pe:gridview.
  • background2 attribute for button mcml is added which can be used to set vista style buttons.
  • "_ctt", "_ctl", "_ctr", "_ctb" alignment now works properly on child controls and also supported in mcml pe:container tag via its alignment property.


  • pe:gridview is fully implemented, with embedded code block and templated rows. More information, please see mcml/pe_gridview.lua and mcml/test/test_pe_gridview.html pe:gridview uses another important design pattern in mcml called templated iterator.


  • ParaXML can now export all kinds of unknown tags like <%embeded code block%> <! dtd node> <?server side script>. Anything inside is <> is returned in an unkown node like <unknown>%embeded code block%</unknown>
  • MCML supports Embedded Code Blocks in MCML Pages. The syntax is <%embeded code block%>. An embedded code block is server code that executes during the page's render phase. The code in the block can execute programming statements and call functions in the current page class. Embedded code blocks must be written in the page's default language. In general, using embedded code blocks for complex programming logic is not a best practice, because when the code is mixed on the page with markup, it can be difficult to debug and maintain. In addition, because the code is executed only during the page's render phase, you have substantially less flexibility than with code-behind or script-block code in scoping your code to the appropriate stage of page processing.


  • pe:gridview is added. pe:gridview and related tags(pe:pager) are used for displaying a long list of templated data with paging.
  • ide/windowsframe.lua is refactored and works together with ide/os windows. It simplifies window and window frame creation and messaging.
  • universal facial animation bones are defined. ParaXExporter is updated. The current version includes: Bone_forehand, Bone_L_eyelid, Bone_R_eyelid, Bone_L_eye, Bone_R_eye, Bone_B_eyelid, Bone_upper_lip, Bone_L_lip, Bone_R_lip, Bone_B_lip, Bone_chin. in 3dsmax, the bone name must end with "forehand", "left eyelid", "right eyelid", "left eye", "right eye", "bottom eyelid", "upper lip", "left lip", "right lip", "lower lip", "chin" For initial position defined for the universal facial skeleton, please see the art documentation. Currently hair does not have universal skeleton, universal skeleton allows multiple characters to share the same bone animation file.



  • AppTaskBar is implemented which uses the new application centric UI framework


  • ide/OpenFolderDialog is refactored to use the fileexplorerctrl.lua.
  • AssetsApp/PackageMakerPage is fully implemented, and is now compatible with the ide's commonlib.package framework.
  • currently only editbox can have focus(control can not), thus tab key can be used to switch between editboxes. A minor bug is created, when tab key will occasionally jump twice. This is because when clearevent does not clear cached repeated key


  • commonlib.package is fully implemented. It is a package extension system implemented in pure NPL. It support a very simple versioning system.


  • "stdint.h" is added from the web for the bit lib in NPL. I modified lua 5.1.3 core to allow string.format("%x") to work for entire 52 bits, instead of 31 bits in the official release.
  • NPL is now able to display debug information for source file up to 120 characters (used to be 60).


  • is redefined as the global unique id of an GUI object. GetUIObject(id) now accept both id and name of a given UI object. GetUIObject(id) is fast because it uses an internal hash. Since we use an id mapping, unattached ui objects can now be detected and reported. Hence, commonlib.GetUIObjectByGlobalID is obsoleted. use GetUIObject(id) and commonlib.GetGlobalIDFromUIObject is obsoleted. use property
  • ParaUIObject:SetScript(eventName, Func, ...) is implemented in ide/ParaEngineExtension.
  • commonlib.LibStub is implemented which is a simple versioning stub meant for use in Libraries. See test in script/ide/test/test_LibStub.lua
  • bit lib in NPL can be opened via luaopen_bit() which is implemented with native bitwise operations. luaopen_bit() is used in ide/math/bit.lua.
  • ide/math/TEA and ide/math/MD5 is added which is via the libstub interface.


  • Seeing Olympic holy fire within 100 meters from me near our Company in Shenzhen.
  • ide/MessageBox is refactored and can be set to use animations for popup and background fade. ide/styles/*MotionData.xml contains motion data in xaml for the animation effect used within.
  • Some minor bugs is fixed in Motion engine, such as ensuring first frame is played immediately upon play and the last frame is shown when animation ends.


  • binary NPL file is now supported. Currently, loading an NPL file, we will first find if there is an up to date compiled version in the bin directory. if there is, we will load the compiled version, otherwise we will use the text version. use bin version, if source version does not exist; use bin version, if source and bin versions are both on disk (instead of zip) and that bin version is newer than the source version. e.g. we can compile source to bin directory with file extension ".o", e.g. "script/abc.lua" can be compiled to "bin/script/abc.o", The latter will be used if available and up-to-date.
  • NPL.Compile method is implemented. It uses an externel compiler at script/bin/. To compile all simply call CompileFiles("script/*.lua", nil, 10);
  • ParaEngine and ParaAllInOne plug-ins's PostBuild event is configured in visual studio post build event. Currently it simply xcopy target to output dir. More advanced post build script may be performed in future.
  • ParaX character with _t texture (disable z-buffer or translucent pass) can have 4 bone animations instead of 1.


  • motionlib support ParaUIObject name and id binding. motionlib in MCML supports motion binding to img, div(any simple tags), text input, button, inner text
  • FileExplorerCtrl and mcml pe:filebrowser supports new attributes to enable check boxes and several new events, like oncheck and oncreatenode.
  • PackageMakerPage is implemented in AssetsApp. PrintToFile() is added. It can be used to determine which asset files are currently in use by the game engine.


  • Social MCML tag pe:name and pe:profile-photo is refactored. more information, see script/kids/3DMapSystemApp/mcml/test/SocialTagsTest.html. It utilizes an asynchronous page pattern with pageCtrl:Refresh() the code is shorter by using only meta code to produce standard mcml inner control for most social tags.


  • Profile registration page now uses pe:label and pe:fileupload. User photo upload is implemented. GetImageInfo is implemented
  • motion lib MCML tags are implemented. please see mcml/test/MotionTest.html and mcml/pe_motion
  • PageCtrl Refresh method with time delay is implemented. it is used with the pe:name to provide an asynchronous page element pattern.


  • mcml <pe:tabs> now support Set/GetUIValue and Set/GetValue methods which allows switching tab pages with run time page code. Examples, see FriendsPage.html
  • NPL.activate("ParaAllInOne.dll", "exec:OpenFileDialog"); is implemented which opened an external win32 window asking for file path.
  • pe:fileupload control for <pe:fileupload> and <input type="file"> tags is implemented. Examples, see mcml/test/browser.html. if "dir" property is not set, it will open using external browser.


  • bug in ParaGlobal::GetDateFormat is fixed. it now allows user specified date format
  • LoginApp/StartPage.html is rewritten using new <script> tag for dynamic content. TODO: We can also test for motion lib integration with MCML here.
  • VMserver beta 2 and ubuntu 8.04 server edition examined.


  • commonlib.echo and commonlib.dump is added which handles recursive table and function serialization. They are useful for debugging. see ide/serialization.lua. commonlib.echo is now the referred way to output temporary log string.
  • commonlib.log has no limit to string size and with formatting like commonlib.log("hello %s \n", "paraengine").
  • inline script code defined inside <pe:script> or <script> is executed in a page environment. One can define global variable and functions in the inline code block and use them as they are in the page event handler. They will not pollute the real global NPL environment or glia environment. for example code, please see mcml/browser.xml. src property of <script> also support relative path.


  • regular expression is supported in addtion to wild card, in SearchFiles method when searching zip files. e.g. this allows us to locate *.jpg in a zip file, etc.
  • LoadWorldPage in WorldsApp support world image preview. It will display the first found jpg image in the world root folder(same rule applies to zip file world); and image not available is displayed for world without previews. The SnapshotPage in ScreenShotApp can be used to generate world preview image. It will resize the current snapshot and save it to the current world folder as preview.jpg file.
  • FriendsFinder, InviteFriends and FriendsPage are added to ProfilesApp.


  • SnapshotPage is implemented via MCML in screen shot app. Some minor fix in mcml controls. <img> in mcml now handles dynamic sized src texture correctly.
  • pe:lable and html label is implemented in MCML.


  • MCMLBrowserWnd is implemented in WebBrowserApp. "File.MCMLBrowser" command is implemented to allow any other application to open an MCML page by calling this command.
  • Bugs with mcml select tag is fixed when there are less than 3 items in the drop down list. pe:filebrowser tag double click event is fixed.
  • ModelBrowserPage.html(lua) in AssetsApp is fully implemented with code in complete MCML.
  • LoadWorldPage is implemented in MCML in WorldsApp.
  • long string is lua 5.1 is supported in NPL and .Net lib. EncodeStringInQuatation of NPL and .Net will handle \r \000 correctly in long string.


  • ParaEngine goes exhibition at Shenzhen Cartoon Animation Park. ParaWorld movie script is written.


  • OpenFileDialog is rewritten using the new FileExplorerCtrl control.
  • pe:filebrowser in MCML is implemented, which is the ide/FileExplorerCtrl control wrapper.
  • pe:canvas3d in MCML is implemented, which is the ide/Canvas3D control wrapper.


  • FileExplorerCtrl is fully implemented. see ide/FileExplorerCtrl.lua. Cartoon face coordiate is adjusted. ejabberd server is configured behind NAT and is working well.


  • Terrain config file now support tile range like ([0-63],[0-63]) = %WORLD%/flat.txt and (1,2) = %WORLD%/flat.txt
  • Path replaceable is fully supported in terrain related files, NPL db item files, and mesh replaceable files.
  • When a new world is created, the %WORLD%/flat.txt and world config file are cloned.
  • lualib in luabind and NPL is upgraded from 5.0 to latest 5.1.3. A number of places in old NPL code is updated for compatibility issues.
  • mathlib.matrix and mathlib.complex is ported to NPL, see script/ide/math/matrix; Bitwise operation is ported to NPL, see script/ide/math/bit.lua


  • wide screen video recording is suppported in MovieApp.
  • Path replaceable is fully implemented. see test case in ParaIO_PathReplaceable() in script/test/ParaIO_test.lua


  • default window mode resolution is changed to wide screen, somewhere 1024*680. see config/config.txt. In-game UI is adjusted to support this new height.
  • CPathReplaceable and CPathVariable is fully implemented CParaIO. The following new IO function is available via scripting interface: EncodePath, DecodePath, AddPathVariable
  • embedded mozilla player cursor now lives well with d3d hardware cursor in both windowed or full screen mode. SetUseSystemCursor() is added NPL. Mozila browser window in NPL will now automatically set mouse cursor accordingly.


  • Desktop front page is refined with branded PEDN logo added and a few UI tweaks. Login settings page is completely rewritten using the new DOM and MCML code behind pattern. Please see script/kids/3DMapSystemApp/Login/setting.html(lua). It is a very good example of using MCML with NPL.
    • is implemented. MCML <hr> is now based on css style.


  • DOM in MCML is improved to support button onclick script. PageCtrl added SetUIValue() method. This makes it convenient to use the code behind model in MCML and NPL. More information, please see the script/kids/3DMapSystemApp/Login/setting.html(lua) file.
  • Leio has done an NPL motion lib in ide/Motion which supports animation exported from flash in XAML format.



  • onload callback of pe:mcml and other HTML tags are added to MCML. such as <pe:mcml onload="commonlib.echo">, the first input of onload is the including node object. the implementation is actually in pe_simple_styles.create().
  • MCML <option> now support value field and will now automatically add non-existing ones. Databinding and IDE.dropdownlistbox also support value field, in additional to text field.
  • Official Paraworld website framework is done via twiki. Please see paraworld web.


  • ParaXExporter Bounding Box: bounding box is by default automatically computed for both static and animated models. However, one can manually specify a bounding box by creating a box named "aabb". aabb stands for Axis Aligned Bounding Box. Manual bounding box is useful with Xref scenes, where xref objects does not contribute to bounding box in the including scene. - pe:script and script is added to MCML, one can now embed inline or external NPL script in MCML, like javascript in HTML. More information, please see pe_script.lua. - ParaWorld.ico Icon is added. a free icon tool iconFX is used to create different resolutions. Only 16*16 icon uses shadow.


  • MeshObject now accept both static and animated x-reference objects. Please see XRefObject.h for more info. A more advanced way is to group objects in the logic layer (scripting) which will not have the following limitations. Physics of static x-reference objects are considered, unless the file name end with _a, etc. Artists no longer need to manually add physics faces around x-reference objects in the including mesh.
    • 1. Limitations: X-reference nesting is not supported, which means that you can not reference a model which in turn references another model.
    • 2. Limitations: The bounding box of a model containning x-reference objects does not take the x-reference objects in to consideration, one needs to manually specify bounding box perhaps via a transparent dot.
    • 3. Limitations: Batch-Rendering, grass-rendering, and construction rendering effects are disabled for x-referenced static mesh objects.
  • MeshObjects can now contain multiple static Actors in the physics engine;
  • ArtDep is rewritten in PEDN. New UI art requirement written. CoreTeam pedn is added to PEDN


  • Pandion IM is modified to create the ParaChat app. More information, please see ParaChat solution.
  • ParaWorld.exe single="true" command line params "single" is added to ensure that only one instance of paraworld.exe can be running. If multiple is called, the following call will just bring the first instance to foreground.


  • PageCtrl is improved and BrowserWnd becomes a thin wrapper of PageCtrl, instead of a different implementation. Request query result can be retrieved.
  • <a target="_self"> and <form action="url" target="_self"> is supported for page rendered by PageCtrl. Since both BrowserWnd and <iframe> uses page control, they all support open url in target. Sample code, please see script/kids/3DMapSystemApp/mcml/test/test_iframe.html.


  • ParaEngine Co. is added to the Please see the topic ParaEngineWikipedia in PEDN.
  • <iframe name="page1"> is implemented in MCML. <a target="page1"> can be used to open a MCML page link in a given iframe of the same mcml page.


  • Raw view and raw edit of PEDN now supports HTML special unicode Chinese characters. Raw view of any kind will need Change permission. I modified the perl module to get it right. Please see the PEDNOperationGuide for more information.
  • ParaWorld Rest interface is designed. A ParaWorld Python client is designed. The reference code is python client for facebook. The preview edition of google app is studied(also used on python). Technologies found in the above places, such as simplejson, perl, python, CGI, etc are studied.


  • SmarterMail server is fully configured on the PEDN, documentation is written on PWOperations topics. Email confirmation is required on PEDN registration.
  • SiteMap.xml is generated and uploaded for pedn and submitted to google.


  • PEDN is fully deployed to and added to google webmaster tools. The server is on Intranet, I used a free service at which allows dynamic IP hosting. CName of pedn.paraengine is mapped to, whose DNS server is provided by I installed a free client updater on 220 PEDN server to update dynamic IP to DNS server every 15 minutes. PEDN front page translation is done and page writing task assigned to groups. HR portal is done; Download Portal is done; Page translation plugin is done; Forum web is multi-lingual.
  • Access right (InsidePEGroup) is applied to all sub webs of PEDN. Variable based page caching is applied to pages with time consuming search and include variables.



  • Python, Ejabberd, ParaWorldAPI is setup on a linux vm running ubuntu. Ejabberd authentification module is implemented and fully documented in ParaEnginePlugin.
  • JGSLOperationGuide is written on PEDN. Bash shell script, linux, python, ejabberd, VM workstation are studied again.
  • ParaWorld.JGSL.ubuntu.vm virtual machine snapshoted and deployed to development server.
  • PEDN.Downloads web is added.


  • App registration page title bar is implemented. It will display and highlight the current uncomplete registration steps in bullet image list.
  • pe:avatar is fully implemented using data from CCSApp's profile MCML box data alive. ara
  • PEDN wiki translations framework is done, I modified the view.pattern.template to add a language translation bar on top, so that any user can contribute to PEDN translated pages. Currently the default is en, secondary is zh-cn. More information, please see the translation plugin in twiki.
  • ejabberd external authentication is examined, please see ChatApp for a discussion. It is possible to write a command line program to authenticate with paraworld REST server and install the program on ejabberd server.
  • pe:a is designed to support asynchronous download of anything like app plug-in, world templates, asset files, etc.


  • App interface now supports 3 more messages: APP_WORLD_LOAD, APP_WORLD_STARTUP_STEPS, APP_WORLD_SAVE, APP_WORLD_CLOSING, APP_WORLD_CLOSED. For more info, please see script/kids/3DMapSystemApp/BaseApp.lua
  • CCS app now handles APP_WORLD_LOAD to load user appearance from its profile MCML box.
  • OBJ_ModifyObject now supports CCS modification correctly.
  • The linux scheduler crontab and cron is studied. page cache addon of twiki requires this. MailerContrib of twiki also requires it.
  • Ejabberd is deployed on ubuntu 7.1. The virtual host must be a domain or IP address accessable from the network, such as or, etc.


  • Profile definition can now be applied. see and All application profile MCML should use profile definition to keep only relavent information in MCML profile. In case the profile format changes, it will automatically clear unused fields. Please see script/kids/3DMapSystemApp/profiles/app_main.lua for example.


  • Task scheduled for ParaEngine developer network. Localization of PEDN is done using perl localization framework. TFly and webtopbar is refactored to support IE, mozilla and opera web browsers. Most browser issues involves empty lines in HTML, "overflow:visible!important" should be applied to <pre> css.


  • ParaEngine Developer site webtopbar is implemented on PatternSkin of twiki. It has a similar look to MSDN, with localization, web navigation, search and quick action popup menu.More information see ParaEngineCssSkin
  • Perl localization framework is studied. Poedit and translation memory is studied. twiki localization is programmed to add paraengine resources. A very important feature is to be able to get text strings from all existing source code. NPL and paraworld application needs to be able to do it as well. i.e. extracting localization strings from a given set of files, automatically replace, append, delete older strings. Possibliy do an automatic translate according to a base file.




  • I found that the xmlserializer strips away \r\n out during deserialization (and just leave \n). WebService strips out \r\n (an leave \n) even using SetInnerText(). so the msg code sending using InnerText of XML web service call will have \r removed. This leads to errors for scode. A workaround is to replace \r and \n with and respectively in FillDataToXmlElement of NPLParser.cs and SerializeToScode in message converter for string type. In fact, I just replace \r, since \n is not removed unless it is for xml attribute. NOTE: I do not know if there are other hidden rules for ANSI code page by MS web service. but currently, I only find \r is an undocumented exception.
  • SetValue and GetValue is implemented for each mcml control base class. This allows databinding with MCML node at page load time or later with page region update. So far, MCML databinding is bidirectional. Please see script/kids/3DMapSystemApp/profiles/ProfileRegPage.lua for an example of two-way databinding. The above page class uses databinding to display existing user profile as well as collecting user input


  • IsPureData is added. It can check to see if string is serialized from a lua data type, such as table.
  • profiles.GetSetMCML is implemented with local server support. ProfileManager is implemented with local server support.


  • onframemove event of UI button, text and container is implemented. A deltatime global variable contains the time in second elapsed since last onframemove call.see example usage in ide/canvas3d
  • TODO: The old UI animation framemove in NPL no longer needs to use NPL Timer, use onframemove of the parent container instead.
  • MCML's pe:slide is implemented, which can be used to show image or text slide shows in mcml pages.


  • ParaEngine team moved to a new office at B603.
  • pe:container and pe:editor now support refresh method. PageCtrl supports UpdateRegion() method which can be used to reconstruct a sub region of mcml in a page.
  • Relationship in profile is collected. Map reg page is created. CCS reg page is beautified a bit. The latter two uses UpdateRegion() from PageCtrl to build interactive MCML page
  • EncodingConvert now supports "HTML" unicode character to/from NPL default text encoding.
  • All application development docs is automatically generated: They are created as child topics of OfficialApps. see GenerateAppDevWikiPages()


  • A GetViewBox bug is corrected. It will now return the best candidate, instead of the first candidate. The initial epsilon for a candiate is 0.05.
  • Problem fixed: on some machines NPLWebserviceClient.dll can not be loaded because of "LoadLibrary error 14001". This is due to dependencies in manifest file not found on the target computer. In this case, it is usually the Microsoft.VC80.CRT that is missing or with a lower version number. provides three methods to deploy Visual C++ libraries.
      1. Install to Winsxs Directory using MSMs merged into app setup.
      2. Private Assembly install under app directory. (from %PROGDIR%\Microsoft Visual Studio 8\VC\Redist\x86, copy Microsoft.VC80.CRT and Microsoft.VC80.MFC to \AppBin) In our case, Microsoft.VC80.CRT is enough
      3. Install to Winsxs Directory using vcredist*.exe. (%PROGDIR%\Microsoft Visual Studio 8\SDK\v2.0\Bootstrapper\Packages\vcredist_x86\vcredist_x86.exe). note that I found that some msvc8 redistributable on the Internet is old. Use the one on your development machine.
  • A free tool called Dependency Walker can help you locate such problem.
  • <pe:container> and <pe:editor> supports right float and vertical alignment.



  • MCML now supports all font styles. pe:editor and pe:tabs now supports css. Registration page is created.
  • attribute of MCML is now UTF-8 localized. Hold a meeting on MCML and related marketing stuffs.


  • NPLDocGen is fully implemented. Most NPL modules are converted to wiki site.


  • NPL source documentation can be automatically generated from a config file. The output is twiki file and twiki portal file. More information please see "script/ide/NPLDocGen.lua" and "script/NPL_twiki_doc.lua". The output is in "script/doc/"
  • TODO: disable IO for accessing encrpted zip files. function should be changed, so that "script/ide/*.*" can not be accessed via script, unless there is a disk copy in development environment.
  • pe:editor now handles relative positioning well. pe:container is added which is very similar to pe:editor except that it does not handle bindingcontext
  • ParaXML can now set/get condense white space or not.
  • ParaMisc can be used to paste or get text from clip board. GetTextFromClipboard and CopyTextToClipboard
  • MultilineEditbox syntax lighter now handles special XML characters correctly. i.e. &XXX;


  • ParaXML now supports UTF-8 encoding properly. HTML special characters like &#XXXX; will be automatically converted to default NPL code page (ansi code page)
  • ParaEngine::StringHelper is implemented with all sorts of Unicode encoding functions.


  • <form> <font color> added to MCML. style "float:left;" added to MCML.
  • http web page can now be downloaded. Headers, ContentType, StatusCode, StatusLine, ResponseUri is included in the msg returned. More information, please see AsyncDownload
  • ParaUIObject's shadow color is automatically determined by the font color. Either black or white is used.
  • McmlBrowser implemented.
  • mcml supported following new css tag: class, margin-*, padding-*,background, background-color


  • app config functions added. Applications can now write name, value pairs in its own config file locally.
  • getUserInfo local server implementation
  • GetObject(x,y,z,epsilon) added an epsilon.
  • wiki DebugApp added.
  • Designed UI for Login and registrations as well as profiles, etc.


  • multiline editbox fully implemented with treeview, readonly, line number and syntax highlighting
  • NPL build rule is used and LuaLangPack.msi is used instead of VSlua. the build rule file for vs 2005 is at script/bin/*.rule One can right click the script project and add this custom build rule file. Edit the build rule file so that the compiler exe path points to a correct path on your machine.
  • ParaUIObject.shadow is added for text object. a black shadow can be rendered underneath the text.


  • treeView can now bind to NPL table. Editing string field is supported now. See TreeNode:BindNPLTable
  • TestConsoleWnd is fully implemented with user interface. OnSelectTestCase uses TreeNode:BindNPLTable() data binding.
  • Default HTTP texture in ParaEngine now uses local server resource store as well. see GetRemoteTexture(url) in script/ide/ParaEngineExtension.lua
    • because of the delayed loading. GUI's texture dimension is not updated when texture is updated. ParaEngine now deals with http textures by retrieving its size each time they are used. There is some tricky code to set size to (-1,-1) and use whitedot.png when texture is being downloaded.
    • call ClearTextureCache() to clear cached data.
  • OpenArchive("filepath", "rootDir") now supports a root directory. This will allow an HTTP zip package to be used from web cache disk location.


  • Unit test framework is implemented in script/ide/UnitTest/unit_test.lua
  • Advanced log is implemented in script/ide/log.lua



  • web service local server is fully functional.



  • local server webcache db and resource store is fully implemented. The interface and implementation is written as close to google gears as possible.


  • twiki site is fully set up, with apache server, active perl and twiki. Twiki is thoroughly studied.
  • ParaEngine developer site and corporation wiki site are setup with navigations and placeholder pages.
  • Microsoft SyncToy is used for wiki site backup and NPL reference sync with the developer wiki site.
  • TODO: planning to sync doc from NPL code files to wiki dynamically.

Warning: Can't find topic Main.url , , , ... can be used.


  • localserver is partially implemented in app/localserver/*.* script folder.


  • virtualization technology is studied: microsoft server|application virualization, vmware|thininstall. A concept called Dynamic IT is studied.
  • The following open source applications are installed using vmware and evaluated: wiki software: twiki, mediawiki, pmwiki. I like twiki most, its plug-in architecture is strong. os systems: fedora, ubuntu. all linux based os. web content building: joomla with a very large number of community developed add-ons. trac and a few other project management software.


  • vmware is installed and being studied. It is very good for testing our server architecture in development phase.
  • A bug for XML namespace keys in NPL::SerializeToSCode and web service NPL client lib is corrected. Any string can be used as keys when calling NPL web service, such as "pe:profile"


  • is deployed and studied thoroughly. It will be used for our corporation intranet and external development and product wiki site.
  • local server from google gears are studied again. I will implement a similar system in NPL for url, REST and web services. Therefore most web service based ParaWorld API can be called with a modeless local server pattern.


  • mcml controls layout class fully implemented. The mcml control renderer now handles content flow similar to standard HTML renderer. e.g. div, text and image,etc will float to the right and automatically wrap a line. see. mcml/mcml_controls_layout.lua
  • mcml controls: radio box, check box, combobox, listbox and their databindings are implemented.


  • bug fix: shadow map is now turned off correctly.


  • following mcml tag controls are done: pe:treeview pe:treenode HTML tags:<text>, h1, h2,h3, h4, li, p, hr, div, a(href), img(src,height, width, title), anyTag(attr: style="color: #006699; left: -60px; position: relative; top: 30px;width: 100px;height: 100px"), see script/kids/3DMapSystemApp/mcml/test/dlg_tabs.xml for more information.
  • pe:editor databinding is done


  • following mcml controls are implemented: pe:editor pe:editor-buttonset pe:editor-button pe:editor-text pe:editor-divider pe:visible-to-owner pe:tabs pe:tab-item


  • all mcml tag node definition is defined and documented in mcml/mcml. mcml_controls for rendering mcml data is defined in mcml/mcml_controls and mcml/pe_* files.
    • social tags: pe:profile pe:userinfo pe:friends pe:app pe:name pe:profile-action
    • design tags: pe:tabs pe:tab-item pe:treeview pe:treenode pe:image pe:flash
    • component tags:pe:roomhost pe:market pe:comments
    • editor display: pe:editor pe:editor-buttonset pe:editor-button pe:editor-text pe:editor-divider
    • control tags: pe:visible-to-owner
    • worlds tags:pe:world pe:model pe:avatar


  • added profiles, worlds, task app to the platform. layed out the initial app infrastructure.
  • moved following apps to app directory: inventory, bcs, ccs, env, theme, chat, pet.
  • layed out the initial infrastructure for mcml data binding controls. they are mainly used for displaying profile data in a data binding tree view control.
  • ProfileManager and profile interface are designed in code. see profiles/ProfileManager.lua. The TODO web services are marked in API/*.lua.


  • asset manager is refined: Asset Manager is the main window. AssetData contains all data structuring for asset, folder, and package. AssetProvider is responsible for loading and saving packages to file or web services. DlgPackage is for creating and editing packages, asset, etc. AssetViewCtl uses databinding to edit and view asset.
  • asset manager can now take thumbnail image of asset, and edit package properties.
  • designed and scheduled profiles, worlds, task, inventory app
  • thought about AI app, MMORPG app.

2008/2/11 - 2008/2/12

  • the sidebar_main contains three windows: searchWnd, MyMapWnd, searchWnd. MyMapWnd displays maps for the current user, its friends, and featured maps. Each map may contain folders, each folders may contain map markers. folders can be toggled as a group to change child marks visibilities. Folders can be edited and deleted. Marks can be added to folders. DlgFolder and DlgMark are dialogs for editing folders and marks in details. These dialogs uses databinding with the mark treeNode object. the MapUILayer is used for displaying all visible marks on top of the map window. It manages a pool of created-on-demand UI button controls. One can limit the max number of on-screen marks allowed. MapUILayer is automatically bind to the treeview of the MapMapWnd. Map Mark is displayed as a button icon and an optional text on the MapUILayer. Button icon contains a cursor point and supports drag and drop operation; text can be sized, rotated and colored, and is automatically positioned according to rotation and size. Map2DMarkInfo contains all the data structure definitions for mark styles, markInfo, folderInfo and mapInfo. MarkProvider is used to load and save map from/to local disk or web services.
  • TODO: MapUILayer Further supports filtering according to level(z) value.
  • TODO: Support synchronization with remove server. and getting friends and featured map.
  • TODO: searchWnd and searchWnd implementation.


  • map 2D layer is refactored with map editing, button pooling, map saving, mark and folder editing, etc.


  • IDE/canvas3d now supports panning with middle button.
  • onframemove event is added to ParaUIObject. duplicated code in UI binding is removed.
  • functions in ParaIO will now accept NULL input and greecefully return nil instead of throw exceptions.


  • setting common general panel is fully implemented, with screen resolution settings.
    when toggle to an unsupported resolution, the application will fail. m_pMouse in GUIRoot will be 0. and a mem dump is generated.
  • sliderbar supported databinding.
  • Ocean manager exposes reflection properties from its atttribute fields. ParaEngine exposes screen settings from its attribute fields.
  • asset app's preview is implemented for model and character.
  • IDE/canvas3d is implemented for previewing asset and models.


  • all paraobjectattributes has been exposed and translated to settings app




  • Currently all assets are loaded by the asset application.Assets file are now in asset package format. see the asset application for more information.
  • Mainbar Creator is ported to be app compatible. all assets are now converted to the new asset package file format.
  • Xref mouse pick bug is corrected. exact match seems to have some floating point error. we will use the min distance version by searching closest xref.


  • ide/DataBinding further supports radio box and TreeView node.
  • bug corrected. ide/OpenFileDialog can use search ranges properly. It displays an optional title and use a default dialogbox backgroud.
  • application assets/assetmanager is implemented with add package, add asset functionalities.


  • script/ide/DataBinding.lua is implemented, which allows NPL programmers to bind table to ParaUIObject or IDE controls.
  • _guihelper.ShowDialogBox() is implemented which usually works with DataBinding to get simple input from user.
  • ide/radiobox can now uses SelectedIndex to check in a radio box group.


  • browse app can now sort app by a few fields. TreeView supports sorting nodes by a given field name.
  • login.loginwnd application is created and tested. ParaWorldAPI now suports pre and post functions when creating RPC wrapper. Pre function can be used to fill cookie data and validate user input.
  • map 2d part is closed source: with 2d mark editing nearly finished.
  • toplevel window style is supported in NPL window. TODO: enable dragging for top level window.
  • PasswordChar of editbox can be displayed properly even with non-equal width font type.


  • all team members of ParaEngine celebrated and had dinner together
  • login.startuppage is implemented and fully tested. Users can now use any texture, world as startup desktop page. Save and load is also implemented.
  • 15 applications have been ported to new architecture like webbrowser, paraworldintro(pwIntropage, credits, website, etc), login(login, CG, frontpage), ebook, painter, videorecorder, settings, map, minimap, newworld
  • desktop integration point is implemented. All apps now takes advantage of the desktop ip to add icons to desktop.


  • Voxel mesh's texture can be changed via SetReplaceableTexture
  • TODO: voxel mesh file format can now contains meta objects.


  • Voxel mesh is implemented using marching cube algorithm ( Please see ./VoxelMesh/*.*. To create Voxel mesh use CreateVoxelMesh(); The architecture is briefly below: CVoxelMesh is a scene object that contains a MetaWorldFragment. MetaWorldFragment is a collection of metaobjects. MetaWorldFragment can be serialzed to/from a 32*32*32 grid file. instead of using a grid file, we can construct the grid manually using prefined metaobjects, such as metaball and metaheightmap. When MetaWorldFragment is serialized to file, all metaobjects may be collapsed to a single cube 3d grid, very economic in size. Each MetaWorldFragment is associated with one IsoSurface.An IsoSurface is the triangle soap built from a 32*32*32 3d grid using marching cube algorithm. DataGrid is a temporary and shared singleton data class used when building the triangles. IsoSurfaceBuilder is the actual class that performs the marching cube algorithms. IsoSurface is rendered using the IsoSurfaceRenderable object, which in turn uses DynamicRenderable class defined in ParaEngine base class. DynamicRenderable contains everything needed for rendering, so the isosurface is only rebuilt when a voxel mesh is first drawn or modified.
  • Voxel mesh is usually used for overhang or cave terrains with traditional height map based terrain. That is why the high level manager is called VoxelTerrainManager. Voxel mesh can also be used independently with global height map terrain. E.g. Create arbitrary sized and editiable mesh (sculptures) or single terrain mesh in miniscenegraphs, etc.
  • VoxelTerrainManager keeps an instance of IsoSurfaceBuilder and GridData, which are used (shared) by all MetaWorldFragments. IsoSurfaceBuilder and GridData is initialized with 32*32*32*N data, which consumes quite a bit memory, and there are a few parameters that can be specified when creating them, such as grid size, grid scaling, whether use normals, normal method, whether use texture coordinate or vertex colors, etc. Unlike DataGrid, The data chain: CVoxelMesh->MetaWorldFragment(1)->IsoSurface(1), MetaObjects(n), only contains necessary data to store and render the grid, so it is economic in size.
  • TODO: make alignment of voxel mesh with terrain and pick the base texture of the global terrain as the voxel mesh texture. Create holes in the global terrain to create caves in terrain automatically.
  • TODO: UV of voxel mesh is currently set to be the same as the vertex grid position x,z in object space. This will kind of project a texture to the surface of the voxel mesh in the horizonal xz plain. This can be used with the global heightmap terrain to automatically pick the color of terrain for the voxel mesh.
  • TODO: Editing and saving voxel mesh in the game: we can search for existing voxel mesh in a region, if found we will use meta objects to edit the voxel mesh. If not found, a voxel mesh can be created at the current location.
  • Many thanks to Martin Enge who wrote the original marching cube algorithm and posted to the OGRE forum, and I have ported and improved much of its code to ParaEngine.


  • miniscenegraph now supports transparent faces and particles, although using them extensively is still now advised.
  • absolute particles are now rendered with initial position and rotation affected by its parent transform. Before this, only position is affected by parent bones.
  • TODO: add a billboarded bones
  • Bug corrected: D3DXLoadMeshFromXOf can only load a simple mesh from datanode. If the mesh contains frames or second UV sets, the function will not work. So in such cases, I fall back to use the original D3DXLoadMeshFromXInMemory, which can handle frames and second UV sets. Currently, the second UV set is always written in x header file. Old ParaX static files without header will not be rendered properly unless they have frame node around the mesh node.


  • create RPC wrapper in ParaWorld API is implemented using closures. It now offers more control over how RPC is created.
  • ParaWorld Desktop integration point is designed and documented in doc 6.10.


  • never break from iterator returned by db:rows(); otherwise, it will leave the sql statement unclosed, causing the table to be permanently locked and thus no write operation can be performed thereafterwards.
  • Applications can now be installed from a downloaded integration point IP.xml file. Add/Remove/Uninstall program functionality is fully implemented.
  • Debug App is added, which allows developers to execute code and watch NPL variables at runtime.
  • non-wordwrapping is supported in multilineeditbox in NPL.
  • ParaUIObject:SetBGImageAndRect(ParaAssetObject pTextureEntity,int left,int top,int width,int height) is supported in NPL for UI object.


  • ParaWorld API wrapper is created in NPL. please see. NPL.load("(gl)script/kids/3DMapSystemApp/API/ParaworldAPI.lua"); Documentation is updated in doc 6.10
  • BrowerWnd app is implemented in the editapps applications.


  • "input" application is created. Notes: the paraworld platform will create a default "input" application, with windows "mouse_down", "mouse_up","mouse_move", "key_down". other applications can hook to the "input" application to process message. The platform developers needs to manually invoke hook in their event handlers such as in RegisterEvent("_mdown_XXX", ";XXX.OnMouseDown();"); For more information, please see the "screenshot" application
  • "screen shot" application will now hook to "input" application to process the F11 key to take screen shot.
  • TakeScreenShot() will now use defined time format for automatically generated screen shot file name. This corrects a bug when ':' is used in file name


  • 2d and 3d gridview is scheduled to be implemented.
  • modeling software is studied. it comes from Dassault System (parent company of solidworks). Ms virtual earth has a partner with it.
  • bounding box of mesh and parax can now be retrieved from scripting interface. local aabb={};ParaAssetObject:GetBoundingBox(aabb); where aabb is a {min_x, min_y, min_z, max_x, max_y, max_z}
  • annual report is written


  • ParaIO.openimage is implemented to read pixel data from any image file, such as png, bmp, jpg, dds, etc. More information, please see ParaIO_openimageTest() in script/test/ParaIO_test.lua ReadBytes() and WriteBytes() are implemented to perform binary file IO in NPL.
  • all texture based render target, such as those used by miniscenegraph, are all created with A8R8G8B8, instead of X8R8G8B8. But it will default to X8R8G8B8 if the former is not supported.
  • the SetBackGroundColor can now uses alpha. we can now render transparent mini maps. e.g. scene:SetBackGroundColor("0 0 255 128") will be semi-transparent blue.
  • the 3dcanvas now defaults to zero alpha value in the back buffer.
  • 2008 Macworld Expo Keynotes is reviewed. Mac X leopard interface is studied: iChat, time machine, stack, etc are reviewed.


  • inventory application is designed and partially implemented
  • Blueprint app is partially implemented


  • windows hook is implemented in the scripting interface, applications can now hook to other application messages as well as mouse, keyboard messages, etc. More info please see scripting/ide/os.lua


  • SelectObject is implemented, which can select object in a sphere or bounding box into ParaSelection groups.
  • Para3DCanvas is obsoleted, use Miniscenegraph instead. Para3DCanvas will only initialize and draw when there is a 3d canvas GUI rendering with it.


  • Market place and room host service app service's requirement have been written see doc 6.11 and 6.12
  • blueprint app is designed.


  • effect ParameterBlock is tested. see script/test/testMeshLOD.lua. We can change effect file parameter per effect, per asset or per object. value and texture are supported. texture also accept ParaAssetObject as input, which means that you can even use the output of a miniscene graph as input to a shader. TODO: There might be a problem in ATI card, see my 2006/5/12 notes, since I used the effect's set texture call for all textures in parameter block.
  • per asset effect parameter can be loaded from mesh XML meta file. More information, please see TestMeshEffectXMLParams() in testMeshLOD as well as script/test/MeshShaderParamTest.xml
  • [corrected] biped scale and speed scale will now affect biped movement speed in the old way.


  • CParameterBlock is implemented in AssetEntity and CBaseObject. Currentlt the effect parameters can be set via ParaParamBlock interface from the scripting interface. we offer three levels of effect parameters: per effect file, per asset file, per mesh object. Effect parameters are also applied in that order. e.g. per effect file affects all object rendering with the effect file; per asset file affects all objects that use the mesh asset file; per mesh object affects only the mesh object. In most cases, you just set all params at init time, and the program will run. unless you want to change some parameters frame by frame.


  • the static mesh object now supports optional ParaXHeader which can be used to specify bounding box, etc. ParaEngine's static mesh loader will automatically detect the presence of the header. If the header exists, it will use the information directly. If ParaX header is not found, it will try to collapse the mesh and compute bounding box using the old directX way at runtime, which may be a little time consuming.
  • ParaX exporter now exports bounding box information in to the ParaXHeader even for static mesh. The LOD exporter will also utilize this. The last reserved parameter in header denotes model format in static mesh, such as whether has normal, second uv sets, etc.


  • ParaEngine uses regular expression from A c++ wrapper of it called "pcrecpp" is used, which is contributed by Google Inc. To use it, #include "commonframework/regularexpression.h" the header file also contains some doc. I compiled a static lib version of pcre in ../../pcre/, see . I only used a contributed version please see /pcre/contributes/ One should link with pcre/bin/Debug/pcre.lib or pcre/bin/release/pcre.lib respectively to use with multithreaded app such as ParaEngine. One should link with pcre/bin/Debug/lib_pcre.lib or pcre/bin/release/lib_pcre.lib respectively to use with multithreaded dll app such as ParaX Exporter.
  • UV animation is supported for transparent mesh groups, which are translucent face group sorted. This is usually for texture based water pools, etc.
  • LOD mesh or char export supported in ParaX exporter: export lod mesh or character file (XML) in a directory. LOD mesh XML file is just a meta file referencing a collection of x files and specifying which file to use when object is within a given radius. In order to automatically generate mesh LOD file, one needs to first export each LOD mesh or char file to their corresponding x file respectively. then open any of the max file and select export LOD mesh, the LOD XML file will be automatically generated according to the file name of the max file. See below: Put all your LOD mesh's model max files(all resolutions), textures and exported x files in the same directory. Name each file as objectName_LOD10.max or objectName_LOD20(0).max. the number in the trailing "_LODnumber" means within what distance in meters this file shall be used. E.g. in your directory, you have char_LOD5(0).max, char_LOD20(0).max,char_LOD30(0).max,, char_LOD5.x, char_LOD10.x, char_LOD30.x. Open char_LOD5(0).max and export LOD, the final file will be char.xml which contains reference to all other three x files with proper show distance. Suppose filename of the static or character meshis "parentdir/xxx_LOD10(0).max", the exported file will be "xxx.xml", and the LOD setting are retrieved from the filename. e.g. _LOD10 means this LOD is used within 10 meters.It will also search for all xxx*.x files in the current directory for other LOD mesh files.


  • application architecture is fully implemented on the client side. Please see script/kids/3DMapSystemApp/AppManager.lua and files in the same folder.
  • The edit application setting itself is an application under the same addin architecture, please see script/kids/3DMapSystemApp/EditApps/ folder
  • ParaEngine IDE.Net can automatically generate application files with a wizard. Use solution manager->install module->app_simple.xml. The source code of the IDE application template is in script/templates/app_simple.lua and add_simple.lua.IP.xml.
  • For an example of a window based application, please see the EBook application's app_main file.


  • application development guide is written in doc 6.10. The session management is still the most tricky part of the architecture. Web service session and WSE is researched.
  • a wii from nintendo is bought and tested via father's 3d eye glasses.


  • the application commands architecture uses a tree hierachy to store all commands in an application. This architecture is very similar to Visual studio IDE's addin architecture, where each addin has connection and disconnection event, and each command has querystatus and exec event.


  • a facebook alike application addin architecture is designed.
  • NPL cookie is implemented in NPLExtension.lua


  • a mainmenu IDE control is fully implemented, it has a modern office style looking, see IDE/mainmenu.lua.
  • the gooding of the ParaWorld is changed to top/bottom layout, where the top menu contains non-interactive functions, and bottom mainbar contains interactive buttons.


  • construction blueprints UI and game design is finished with details: history bar, BOM bar are introduced into the overall game play and used to aid blueprint construction. blueprint category is defined.
  • integration point for application is thoroughly discussed and almost defined.


  • XNA is examined, a system tray IM beeper is scheduled to be developed by XNA using a pet egg metaphor for IM beeper info. Some open source C# IM is examined like, Shaim,, Soapbox, etc.
  • some open source VoIP IM is also examined, like openwengo, jingle clients, etc.
  • ejabberd is upgraded to version 2 beta.


  • ParaWorld server architecture is defined. Security level for each user and server actions are defined in a tab form. Following security measures are taken in to consideration: plain password, session, SSL(certificate), MD5 digest on shared secret, chapcha, email confirmation, DB log, IP restriction. center server and app server communication sequence diagram is drawn.
  • Pet system rendering draft is drawn. Pet rendering will uses LOD and lots of shader effect and facial animation.


  • Smart pointer template class asset_ptr is implemented, which is a contructible and assignable wrapper of reference counted AssetEntity. It can be used with stl containers like vector, map, etc. When implementing asset_ptr, the copy constructor does not work well with c++ template, I think it is more or less a bug of the MSVC compiler which cost me quite some time to find.
  • All raw pointers to AssetEntity derived class in ParaEngine now uses asset_ptr. I modified almost every asset consumption file in GUI, asset manager and 3d scene. Now that all paraengine asset is fully reference counted.
  • there are some open source conservative garbage collection system for c and c++.
  • By using smart pointers, we have solved the problem of heap access violation. Another useful tool is called global flags, which can be found in debug tools for windows. We can enable full heap page for debugging memory access violation locations in the source code.
  • _CrtSetBreakAlloc(MemAllocationNumber); can be used to break at where the memory leak happens. Search this in ParaEngineApp.cpp


  • For character or mesh LODs, we can now load LOD based character or mesh from a descriptor mesh XML file. The xml file will specify a group of LOD mesh files to be used by camera and/or screen distance. Inner file can be either relative path or absolute path. To generate this mesh XML file, we can manually wrote it or use the ParaXExporter for 3dsmax. For the exporter, we need to export each lod mesh file normally, and then export the xml file by filling a windows form. mesh xml file can be loaded by the Normal x file loading function in NPL. LoadStaticMesh(). for test files, please see script/test/TestMeshLOD.lua.
  • Para mesh XML file is a reference file for properly loading static mesh or parax mesh file. It may contain LOD information, shader information, bounding box info, etc. More info see ParaMeshXMLFile.cpp


  • new investor relationships are developed.


  • some facebook games and viral distribution is studied, like staries, tower boxxy, crazy taxi, worms, pool, are all very addictive games.


  • client side application description file (with integration points) is designed in script/apps/sample/*.xml.


  • The facebook server and developer architecture is thoroughly studied. there are some distributed memory cache open source object used by facebook.
  • ParaWorld architecture is adjusted to be more social network oriented. Everthing from map, chat, GSL, pet, poking, games, etc are merely applications. over 10 integration points of application is defined in doc, with a comparison to facebook application integration points.
  • Meet a former tecent project manager, some key points learnt are (1) how to design the the kill time function and cool experience; (2) how to use a sandbox model to interprete user behaviors. predicting user behavior and letting users try the application have already been an inevitable parts of software development.


  • Para mesh XML file is defined. TinyXPath is used for parsing mesh XML file.


  • facebook and paraworld community comparision is made. See doc 6.6.12
  • TODO: Static Mesh and ParaX mesh LOD is supported.
  • I added LOD for all static, skinned and customizable models. So that even for pet, we may have 2 LOD objects. one for within 2 meters; and one for the rest situations in concise form. There may even be two shaders for two LODs. Basically in shader, we need to consider Multi-Coloring for both LODs, For the detail LOD: consider normal mapping, hair, specular lighting, facial animation, etc?


  • facebook is studied. Facebook is successful because of the following things: (1) it turns everything into user relationships and goals. such as:
    • real world relationships(from strong to weak: friends, network(school,company), group(common interest), network(city, nation))
    • user actions: such as playing games, editing profiles, adding friends, sending gift, and almost each meaningful action.
    • contact import from outlook, MSN and other IM, etc. (2) another thing makes facebook popular is its thousands of third-party applications and open API. apps such as
    • mini-games: global and friend score ranking, score competing with friends, adding friends to get to next level, etc.
    • social applications: wall writing, poking, pet, friend seeking (3) advertising via location. and advertising app via relationships.
  • minor bug corrected for 3dsmax exporter: multiple material tag can be exported correctly.


  • translucent face group sorting is performed for static mesh object and parax mesh object. a face is considered translucent if it has alpha blending, alpha testing disabled and z-write disabled. In the 3dsmax exporter, one needs to manually set a material to be sorted by appending with _s (which means sorting faces)


  • doc 6.6.0 for paraworld is discussed in the team.
  • mini-game is designed. Facebook is popular for its mini-games. It offers 98% open API for developers to extend mini-games with its API. For paraengine, we need to make adding and removing mini-games easy for user. And we should also make creating games for paraworld easy for developers There is a mini-game score races among friends.


  • Minor bug: GetCartoonFaceComponent() sometimes returns unpredictable number for the color component. I think it is a minor bug that 0xffffffff is sometimes converted to 4294967296, instead of 4294967295 randomly. the current workaround is to check if there is value larger than 4294967295, and change it to 4294967295 in NPL.
  • Bug fixed: RefreshModel now works fine with model geosets. In the old days: there is a render problem on the GT6600 computer that some random lines emits from left top corner. This is due to unanimated geosets that should be hidden.
  • ParaCharacter::refreshmodel() is automatically called when body parameter or character slot or cartoon face is changed.
  • Cartoon faces composition is batch-rendered. This solved a bug where some random triangle lines emits from screen during cartoon face customization.


  • JGSL is now working with all kinds of creation and environment manipulations. Environment manipulations are compressed before sent so that only the most recent env is sent in a batch.
  • JGSL now uses relative-to-terrain measure for player height transmission.


  • designed the paraworld community from ground up, making it both interesting and social. Everything is backed up by theories of social, civic, and flow experience, etc
  • Over 50 pages of design doc is written, covering three new function sets: social building game and widgets, social pet system, civic system (including Map BBS).
  • various meetings (internal discussions) are held during the past two weeks for the new function sets and goals of the paraworld community.


  • recruited a game designer and project manager to the team.


  • the goal of paraworld communiy is decided into 5 hierachies vertically.


  • NASA AMES project for space colonization is reviewed thoroughly.
  • UI discussed for the new paraworld community.


  • reviewed the design principle of sims2, spore, rise of roman, gears of war, and several mini-games (time management) on Yahoo Games!, like building-a-lot, etc.

2007.11.19 - 2007.11.25

  • Maintains contacts with previous IDG workshop members, discussing possible collabration and investment relations.

2007.11.15 - 2007.11.18

  • I attended IDG workshop 2007 for three days and demoed paraworld application. There are over 100 CEOs attended it.


  • movie recorder can now record and playback object creation, modification, deletion, terrain paint with relative and absolute playback.
  • TreeView in NPL now supports scrolling to best show a given node.


  • AI movie template is implemented. see script/AI/templates/AIMoviePlayer.lua. Movie character can now be saved and automatically replayed the next time the scene is loaded.
  • All movie functions are now message driven. see script/kids/3DMapSystemUI/MsgProc_movie.lua
  • object creation history is implemented. see Map3DSystem.obj.GetHistory() in script/kids/3DMapSystemUI/MsgProc_obj.lua
  • DoString() will now work with any code length(old is 4096 bytes), provided it does have a length. We may need to improve security in future.
  • PPT for IDG workshop 2007 is written. Lots of screenshots of the paraworld product is taken.


  • time series class in implemented in NPL. see NPL.load("(gl)script/ide/TimeSeries/TimeSeries.lua");
  • movie library: recorder class is implemented. see NPL.load("(gl)script/kids/3DMapSystemUI/Movie/Recorder.lua"); It internally it saves movie actor variables as time series. and uses sequence controller to play back.
  • My map function in paraworld product is designed and partially implemented.


  • the second parameter of GetDynamicField or GetField or attribute object can not be nil in NPL.
  • JGSL server and client is finished with ccs, and multiple user support.
  • bug corrected: when calling UpdateRects to an existing button when mouse is over it, the 9-tile rect rect is wrong. I corrected by setting to artworklayer and normal state before calling UpdateRects().
  • character AI functions ported to the map system
  • Note: sometimes the debugging in vs 2003 will exit if NPLWebServiceClient.dll is loaded. The reason is unknown, perhaps some tricky bug by VS IDE. It is solved by setting F5 just before loading the .Net dll and ensure that ALLInOne debug version is built against the same debug ParaEngine core lib.


  • the log function will seek to end before writing. it can be used for simultaneous write to the same log file.
  • the NPL jabber activation interface has a limitation: The msg table key name can NOT contain number or non-letter characters, except for array index, otherwise the entire message will not be sent.
  • The XML param array elements can now be successfully transmitted back and force between NPL and XML.


  • ParaX exporter for 3dsmax is improved with new material attribute. if the material name ends with "_u", it will be unlit, which means no lighting is applied to surface. "*_b": Disable alpha testing in max material: alpha testing is by default enabled for all exported max material. To disable alpha testing, name the max material as "*_b", such as "mat_b".
  • miniscenegraph picking is fixed


  • Jabber Game Server Lite is now working fine with position normal update. I implemented with time out features and better code reuse for both client and server. We can now add more features to it gradually.
  • mesh construction shader will now work with objects with 0 or negative height.


  • Jabber Game Server Lite base framework is implemented in NPL. See NPL.load("(gl)script/kids/3DMapSystemNetwork/JGSL.lua");
  • The jabber NPL activation call will have msg.from or JID in the receiving neuron file.
  • Chinese version of lecture notes of the ParaWorld is translated.
  • the pricing of Kids Movie English version is changed to 24.99 USD on shareit and
  • ParaEngine formally received IDG's first round investment of USD 50w.


  • Jabber Game Server Lite is designed. The draft of lecture notes of the ParaWorld is written to be presented on IDG workshop.


  • AddDragReceiver logics is implemented by ParaUIObject, which allows dragable objects to specify which UI receiver can receive it.
  • ParaUI object dragging logics is changed significantly. Use AddDragReceiver() in onbegindrag event. Drag cancel or restore now works correctly with all UI object alignment types. The new dragging functions are used in the resizable window control in NPL.
  • Map system in paraworld is refactored in NPL with some documentation.
  • GetChildCount() implemented in ParaUIObject, so that we can tanverse all children in a container. This is currently required for building animations for a group of UI object.


  • Map 2D system is refactored in NPL. The map 2d layer code is quite tricky. I have documented the code slightly.


  • Bug Fixed: since we use EnableAutoDepthStencil, we must SetRenderTarget to the back buffer in the beginning of each render frame in order for EnableAutoDepthStencil work properly for the backbuffer as well. I have commented out all manually depth-stencil set/restore calls in miniscene-graph, movie capture, mirrorsurface, ocean rendering, GUI canvas rendering. The only exception is shadow map which uses a special depth buffer.
  • miniscenegraph will now automatically adjust aspect radio of the camera projection matrix according to the render target size.
  • ParaUIObject.color property is added so that we can set the color of 9 tile UI with a single call.
  • MinisceneManager is implemented in NPL, which allows a miniscenegraph to load an onload script and NPC table the same way as the main scene. More information, please see script/ide/MinisceneManager.lua


  • BUG: HTML browser sometimes crashes when resizing.
  • HTML texture surface will default to white color. local file supported in web browser in NPL. such as "local://readme.txt"


  • webbrowser in NPL is fully implemented using the ParaBrowserManager interface. It uses mozilla internally. More information, see script/kids/3DMapSystemUI/InGame/WebBrowser.lua. Partially fixed see see 2008.4.20: figure out a way to disable either mozilla mouse cursor or paraengine mouse cursor. Currently these two conflicts with each other mozilla will internally set the mouse cursor on mouse move and click events. This conflicts with the use of d3d hardware cursor. However, currently there is no workaround. I have tried to hook all WM_SETCURSOR events, but it does not work. Current key events are sent to mozilla through the HWND and windows message pipeline, which is why I do not need to send key event to it.
  • UI container in NPL now sends key down event to scripting interface. One can specify the handler in onkeydown property.
  • BUG minor: when the texture format is single lined and no clip.i.e. _guihelper.SetUIFontFormat(_this, 36+256); the first draw call and subsequent draw call differs by 1 pixel in the vertical direction.


  • ChangeTimer() is implemented. it allows a timer to be called after a duration. And time interval of a timer can be changed at any time.
  • mini scene graph resize problem fixed. it is an effect manager problem. Active and owner dray miniscene graph instances do not share shader with main scene graph now.
  • "sensor_name" parameter which is passed in all queued scripts are not passed any more, except for IGameObject events and GUI onclick event. They are still there for backward compatibilities.
  • 3d scene sandbox environment bug is correctly. tricky note: since any individual script may delete object, we will put all sCode in one string to execute during AI framemove.
  • ParaHTMLBrowser and ParaBrowserManager is fully implemented for the scripting interface. Over 50 new HTML APIs are added to the NPL, C++ and plugin, respectively. Overall 150 APIs.


  • CHTMLBrowserManager is fully implemented in C++ via the mozHTMLrenderer plug in. when loading the mozHTMLrenderer, the mozilla runtime need to be in the same directory as the plug-in dll and application main executable files. Mozilla runtime files are in ParaEngine plugins\MozHTMLRenderer\runtime folder. we need to deploy these files and folders at release time.
  • TODO: there are still few bugs: (1) a dialog box randomly pops up declaring that a different c runtime lib is used. (2) certain page does not load until it is complete or displays an error page. like (3) the window size returned sometimes is wrong. could be 0 or smaller values. but it will further makes the rendering of HTML page wrong, like the page.


  • mozilla HTML rendered engine now in a dll. I used the open source uBrower project as well. More information, please see the *_license.txt.
  • On the Internet, second life, OGRE, google group and irr engine all talks about the Mozilla HTML renderer.
  • There are compiler errors for the lib from the uBrowser. Someone on the Internet has compiled a VS 2005 multithreaded DLL compatible lib. And I have used it instead of compiling Mozilla source code on our own, which involves many procedures.
  • Mozilla 1.8.X runtime is pretty big ().


  • miniscenegraph is upgraded, with full support for fog, time of day, sun lighting, and skybox. It uses identical IScene interface with the main scene object.
  • Miniscenegraph scripting interface is tested in NPL. see script/test/TestMiniSceneGraph.lua
  • IScene interface is added, so that EffectManager and SkyBox can serve different scene manager types, such as CSceneObject and CMiniScenegraph.


  • "chatdomain" command line parameter is added.
  • NPL activation via jabber/XMPP is implemented and tested. It offers a similar syntax like NPL.activate(). e.g. jc:activate(""..":script/kids/3DMapSystemUI/Chat/ChatWnd.lua", {body="jabber NPL message", sendername="lixizhi"});
  • In order to find a message exchange bug, I just learned quite every aspect of the jabber protocol and server/client implementations to get to the point. It worths it. Improved quite a bit other related code during debugging
  • I have read doc on several times, read and ejabberd community site, and debugged thoroughly from application layer to transport layer, examing and loging every messages sent. And I am finally able to locate a slight difference in the ejabberd database backup record's session data table. The last field in the session record indicates a different presence priority for connected clients.
  • jc:SetPresence(-1, "andy", "chat", 0); where the last parameter need to be positive. otherwise it means no messages allowed. -1 means presence only. and it will not receive message from priority 0 entities. But can receive messages from priority 8.


  • Jabber.Net is upgraded by following procedures. (1) get the latest version using QSVN. To lxzsrc/JabberNet. (2) check out all files under Jabber.Net and wrapper solution from our source control. (3) copy and overwrite everything in lxzsrc\ParaEngine\ParaEngine plugins\JabberNet (4) For Jabber.Net. the debug and release settings shall build with NET20 NO_SRV and disable assembly signing. For wrappers, the release build shall has an input lib like the debug one. (5) we shall also change AssemblyInfo.cs file in Jabber.Net to further disable signing by removing the last few signing lines.
  • NPL Jabber will bind resource to ParaEngine by default.


  • UI theme of the map system application is defined in doc.
  • mathlib is implemented in NPL. see script/ide/mathlib.lua
  • We can now query whether object has physics in NPL.
  • Mesh popup editor is implemented in NPL. When moving a 3d object in NPL, its physics is temporarily disabled
  • save world UI is ported to map system.


  • a slider bar control is implemented in NPL using a button and a container: both vertical and horizontal slider is provided. see script/ide/sliderbar.lua. NPL designer now support trackBar which will convert to SliderBar in NPL.
  • the entire object manipulation, environment modification API is now message driven. See script/kids/3DMapSystemUI/Msg_Def.lua


  • Autocamera frame move and biped state manager is refactored, so that heading turning of a character is independent of camera control. The code logic of Auto camera is greatly simplified. The new camera system is good with in-game editing feature in the new map system UI.
  • FaceTrackingController is improved to support an arbitrary 3D point.


  • main scene head on display bug is corrected. More than one object is not displayed
  • message driven system for object manipulation in NPL is implemented. Object selection, creation, etc are all implemented via scriping interface
  • script/ide/object_editor.lua is refactored. It supports creation from NPL params table.


  • ParaEngine attend China High Tech Fair 2007. 2000 CD of kids movie creator is distributed.


  • mouse wheel for button is reenabled. but mouse wheel will still leak to its container if no such event handler. This is useful for container content scrolling.The container window receives the scrolling event instead of the child button.
  • d3dtransformStack is implemented. Independent Miniscenegraph can now be rendered even the main scene is not enabled.
  • onsize is implemented for container UI object.


  • ParaEngine Chinese company web site is set up.
  • ParaToon English web site is set up.


  • fixed UI mouse move and CCS hand texture



  • context menu implemented for paraworld game
  • IDE.os is implemented. It will emulate operating system message queue and windows behavior
  • all the UI sub systems of the new paraworld game will utilize the new IDE.os for event handling.


  • load world, new world, 3d ebook, settings have been ported to the new 3d map system
  • startup panel: credit, game intro, CG, video page have been implemented.


  • "flv" texture is supported in addtional to "swf". A default swf is used intenally. One can see the source in Texture/FLVPlayer.fla|swf It will automatically extract movie dimension from file name instead of file content. file name should be "filename_width_height.flv". e.g. "paraengine_400_300.flv". If size is not provided. 256*256 is used.
  • To play "flv" file. One can embed it in "swf" file using relative path. And then play the swf file instead. movie dimension can be encoded in swf file.
  • PutFlashVars and CallFlashFunction is added to NPL. it allows NPL to interact with a flash movie instance (swf file). More information, see ParaFlashPlayer;
  • swf file can now be from a remote server.


  • NPL.IDE TreeView pagesize bug corrected.
  • NPL.IDE.HTMLRenderer is refined to support css and href. Example file: script/test/testHTMLrenderer.html It only support formatting to the following tag and their attributes: h1, h2,h3, h4, li, img(attr: src,height, width, title), a(href), anyTag(attr: style="color: #006699; left: -60px; position: relative; top: 30px;width: 100px;height: 100px"),title It also support relative image path as well as HTTP file path. In addition to per tag css, it also support global CSS via a table called css during initialization. All images are displayed on the left block, where all text are displayed in the right block. images is aligned vertically at the its normal text flow position.
    the HTML must use ansi encoding. Unicode or UTF8 encoding will render Chinese text unreadable.
    all HTML tag and attribute must use lower case.
    we can use tag css to position a text or image any where relative to its normal text flow. We can also specify fixed block size.


  • NPL.IDE.HTMLRenderer implemented.


  • Main startup UI of 3d map system is implemented: frame window is done.
  • Bug fix:The font element of editbox will now calculate correct caret positions.
  • spacing is added for button, editbox, and text UI control
  • UpdateRect added for ParaUIObject().


  • Main startup UI of 3d map system is designed.


  • Logic refine TODO: The UI Event function InterpretMessage() is sometimes called multiple times by the current class MsgProc' handler and its base classes. This could cause problems especially when a group of messages have been processed in one place and then reinterpreted and processed in another. For example, if there are multiple handlers to rootUI events in Scene and camera classes. I have deliberately avoided this by not interpreting any messages outside the GUI dispatch. However, InterpretMessage() function needs to be refined and called only once for each control at the its born time.
  • In NPL, mouse click scene handler is rarely used, since it can now be produced via mouse down move and up event handler. However, lazy NPL programmer can still use it if they do not like to write other mouse handlers in NPL.


  • Dynamic attribute fields of mesh objects are automatically saved during scene loading and saving. This is usually used to save mesh URL that is relavent to a certain game, etc.
  • BCS concept art pipeline is defined.
  • Mouse down, mouse move and mouse up event can now be handled in the 3d scene's event handler in NPL. One can call function like this RegisterEvent("_mmove_helloworld_pick", ";helloworld.OnMouseMove();"); It is compatible with old interface where only mouse click event can be handled in the scripting interface.


  • GUI object now support rotation, translation, scaling and a rotation origin relative to the control center. the rotation attribute of ParaUIObject is only useful to do animation or just for the look. @note: it does not change the sensing rect of the UI control. Currently, text, button, editbox, canvas, container supports rotation.
  • bug corrected: visible property of the UI object will now correct update the client rects.
  • ParaObject's attriute object now support dynamic field. In NPL, we can call: local url = GetPlayer():GetAttributeObject():GetDynamicField("URL", "anything"); local value = GetPlayer():GetAttributeObject():SetDynamicField("URL", nil);


  • SetNineElementBG is implemented for container, editbox, button, text, listbox, guicanvas control. it will use 9 textures for arbitary sized containers. Alternatively, there is shortcut via the old ParaUIObject.background property, with special format like "filename:5 5 5 5". Notice the semicolon in the filename.
  • ParaUIObject.background property can be used to set "artwork", or "background" layer, according to the current active layer. This is useful to use 9 texture even for background layer to create interesting effect like the Vista buttons.
  • _guihelper related Vista style button functions have been altered to conform to the above standard.


  • UI container's client rect is now only computed if the container is scrollable. This makes the UI slightly faster at creation or resizing time.
  • All UI object now supports four additional alignment type, center top, center bottom, center left, and center right. More information, please see CreateUIObject()
  • Feature TODO: unattached UI object will cause memory leak. We way need to wrong the developer in future.
  • We can now get the render text length in pixel for text UI control.
  • 3D map system UI is now completely separated from KidsMovie UI code in NPL, except for user and world db.


  • File and directory listing control is implemented in NPL.ide. see script/ide/filedialog.lua
  • UI update rect logic changed: we will update a UI object's rect and children whenever it is attached to a parent. No matter what alignment is used, when a control is attached to a parent, its absolute position can be computed and immediately used. The new logic is very useful, when in NPL, we need absolution position with a auto strench alignment type immedaitely after its creation.
  • bug corrected: In the old days, when setting text property of the editbox before it is attached to a known sized parent, caret position is wrong. this is tricky when setting text when the client area is unknown and text position can not be calculated.


  • Context menu is implemented in NPL.ide. Please see script/test/testcontextmenu.lua
  • IM add and remove user implemented and tested.


  • Bug corrected: when creating UI controls, the container does not show up if their UpdateRects() function is not called on the container upon CreateUIObject().
  • IM roster and chating functions are tested in NPL with a simple UI implemented.


  • tinyXpath is added to ParaEngine.
  • LuaXML is in implemented in NPL.ide, which could convert any XML string to lua table. see script/ide/luaxml.lua
  • ParaXML is implemented in C++. It has a similar function like the above LuaXML.
  • a stack implementation is added to NPL.ide.see script/ide/stack.lua


  • overall design of paraworld game user interface is discussed. The new UI in NPL features auto tool bar, treeview, resizable windows, auto hide panel, etc with a few more UI animation styles.
  • UI for getting roster in jabber IM client is fully tested in NPL. see script/network/IM_main.lua.


  • TreeView and TreeNode control has been implemented in NPL. It will dynamically render only visible client area and reuse controls from the last scroll location. Hence it can render tens of thousands of data inside a TreeView control. Moreover, TreeView also supports Owner draw control, where a user provided draw function can be used to render each treeNode. Such feature is very useful for rendering game chat display window, where there are formatted and interactive multi-line text. It is also suitable for contact list display in an IM. For more information, please see script/test/testtreeview.lua
  • Mouse wheel now works on scrollable container as well as NPL TreeView control for text, button and editbox.
  • ParaIDE.NPLDesigner now supports TreeView control. it will now automatically generate treeview code with nodes, indentation and item height,etc.


  • NPL jabber client is implemented in C++, C# and NPL. Over 60 documented jabber API is added in each programming interface. For more information, please see I have used Jabber-Net for the client code implementation and ejabbered | openfire for server side.


  • concept art pipeline for CCS is established.


  • All 3d object now supports very fast text based head on display during scene graph rendering and mini scene graph rendering. Head on text, color and position offset is now attribute of a 3d object. It can be set and get at any time and automatically rendered via predefined or user defined UI template. This is useful when rendering character name over head during Internet play, as well as 3d map marker in the 3d map system. Please see the script/test/testheadondisplay.lua for more information.
  • Map system web services are implemented partially.


  • ParaIO now supports multiple search paths. if a file is not found in the current directory, it will attempt to load from one of the search paths. this is extremely useful when loading external world that contains local asset files. Upon loading such a world, we will first add the world directory to the search path, and upon exiting, remove the search path.


  • HTTP based texture file is supported. See ParaEngineExtension.lua
    • In 3D, HTTP or FTP texture can be used just like any other texture except that they have a HTTP file path.
    • In 2D, when we are using a remote texture, we need to specify its rect with -1, such as _this.background=";0 0 -1 -1"; This tells the GUI that texture size is dynamically loaded when texture is ready.
    • In NPL, a special function called LoadRemoteTexture is provided to given developer more control over how a remote texture should be rendered when it is still downloading. e.g. local testTex = LoadRemoteTexture("", "Texture/whitedot.png"); where a white texture is used during downloading.
    it is not a good idea to have too many remote textures in a scene, since all download are made concurrent. And currently, I do not limit the total number of thread at this version (it is system bound).
    security is another issue, in case user choose to download illegal files.
    crc32 code can be appended to file name, so that the same file does not need to be downloaded multiple times if local and server version match. such as "".
  • GUI now supports texture bound with dynamic width and height. such as "Texture/;0 0 -1 -1", where -1 is replaced with the dynamic width or height when needed. This is specially useful for specifying width and height of a HTTP remote texture where the dimension is not known immediately.
  • A fix with ParaMisc:GetImageAndRect(), where RECT is returned by value.


  • map system art requirement is written see doc 6.6.4
  • Game server lite(GSL) requirement is proposed, where we will develop a simple game server using The GSL will record all visitors' action sequences and play back using special time origin realigment algorithm. this will give an illusion that many people are visiting a world. The world owner and everyone will see user actions while it is offline.
  • open source or free instant messenging services are explored. Google talk and Microsoft Live ID/contacts are two possible choices. However, I am still pondering whether to get our own IM in the game or just use an existing solution.


  • external animation system is fullly implemented, where hang shang models have been exported in this manner and tested against dozens of animations under the character/Animations/ directory.
  • Note1: Physique is not well supported when exporting a character that support external shared animation. One can use the free autodesk plug-in Phy2Skin to convert a physique to skin when mesh is at initial pose. After conversion, one also needs to manually add the root biped bone to the skin and assign some weight to it. The reason behind this is that Physique does not export the root bone, which contains translational animations required by shared animation.


  • [Shared animation support]: in order to use shared animation, all characters need to have the same da vinci initial position. Since all animations are based on relative bone rotation to this initial character position.
  • for shared animations to take effect,bones must be named properly in 3dsmax (the default biped naming of character studio in 3dsmax 7,8,9 is compatible with us). Here is the list of known bone names (case insensitive, maybe prefixed with any characters like biped01,but not surfixed): Root(any name which is parent of pelvis), Pelvis,Spine, L Thigh,L Calf, L Foot, R Thigh,R Calf, R Foot, L Clavicle, L UpperArm, L Forearm, L Hand, R Clavicle, R UpperArm, R Forearm,R Hand,Head,Neck, L Toe0, R Toe0, R Finger0, L Finger0, Spine1, Spine2, Spine3, The parent of the pelvis bone is always regarded as the root bone (Root). All predefined bones must have pivot points,otherwise external animation will not be applied. only the Bone_Root's translation animation (which is also scaled automatically according to the local model) will be applied to the local model, for all other predefined bones, only rotation is applied. This conforms to the BVH file format, where only the root node has translation and rotation animation, where all other nodes contains only rotation animation. This allows the same animation data to be applied to different models with different bone lengths, but the same topology. for More information, see Bone::calcMatrix


  • Most 3dsmax biped bones are exported with some predefined ID, so that we can share animations among multiple animated character.
  • ParaXModel and ParaXAnimInstance have been modified to support shared external animation data.
  • CBoneAnimProvider is fully implemented, it allows ParaXModel to share animations.


  • Complete rewritten of animation index struct. Fixed some bug when changing model in CCS mode. The new struct called AnimIndex supports local animation index as well as index into a bone animation provider.
  • ParaMovie now supports line interlaced stereo vision output in addition to frame interlaced mode.


  • environment sim logic changes: the current player is always sentient to all other objects and all other objects are sentient to the current player.
  • videoRecorder is implemented in the IDE of the NPL. It now supports stereo output and FPS specification.
  • mini scene graph can now be enabled or disabled. this is useful when taking screen shot when content on the miniscenegraph is not taken.


  • stereo vision is supported for father's eye glasses. It is said that iPod uses a similar output. The even frame is for left eye, the odd frame is for right eye. both ParaMovie namespace can now specify frame rate and stereo vision mode during movie capture. Please note that stereo vision is a separate feature supported in autocamera class. It will work even without movie capture. The stereo vision here is different from hardware stereo vision supported by NVidia. When using NVidia stereo vision, the software stereo vision needs to be disabled.


  • MCML started: XMLSpy is used for code generation
  • 3d map system requirement is finished
  • kids movie: english and chinese version 1.1 is done and released.


  • LoadFile and DoString will now load file or do string only in the calling runtime.
  • sandbox is fully implemented. Most APIs are disabled in the kidsmovie sandbox mode. The SetScriptSandBox() can be used to turn on and off sandbox currently headon_speach and AI functions are modified to work under sandbox environment.


  • sandbox is added, which offers some protection for third-party plug ins. Please refer to script/ide/sandbox.lua and script/kids/km_sandbox_file.lua


  • a bunch of neuron file function is added. This can be used to execute code in a seperate sandbox environment. It can provide some security improvement over third-party game world.


  • Miniscene graph is fully implemented to support a separate camera and render target and rendering pipeline
  • Mouse ray picking is supported in miniscene graph.
  • 3D Map requirement is started. It will use the miniscene graph to create the 3d map for the game.


  • camera third person is enabled; set camera code is written in NPL


  • ParaXModel will now apply the surface material in shader on a per model basis. This correct a bug when the model canvas contains both the ParaXModel and static mesh model.


  • Caution: always remember to reset animation when calling InitBaseModel internal method otherwise the blending animation and frame may not exist on the new base model, and application may crash.
  • client side statistics is supported
  • custom character and Cartoon face are supported in the network layer
  • server can be restarted from client in either pure server mode or listen server mode.
  • CCS textures on the dedicated server will not composed until the render function is called. If render is not called, no texture is composed on server.
  • When zip file has priority, even the database files will be loaded from zip file before the disk file. This is useful when loading a world in zip file which contains db files.
  • CCS get functions are exported from NPL.


  • custom character is support in the network layer.


  • both client and server mode uses Frame rate controller. Hence the timer is more accurate.
  • In server mode, the environment simulator becomes real-time, instead of first-order. It allows more accurate sim on the server side. Since the frame rate of the server is much lower, it needs to be real time in order to be accurate.
  • a bug fixed:when group 2 information of the server is never sent to client.
  • a bug fixed:IsGlobal is moved from group2 to group1, and it now does not contribute to group 1 or 2 changes.


  • All NPL network events have been declared in script/network/KMNetMsg.lua file
  • Slider onchange event will only be called when it is from a user action. calling setValue in script will not cause the onchange event to be raised.
  • when passive rendering is on (such as the server mode), the terrain heightfield update will now function as expected.


  • BUG fixed: if two application instances load the same zip world file, the db, which is extracted to the temp file will fail.
    DoesFileExist will use FindFirstFile to avoid misjudge some existing file which is opened with synchronous IO such as db files.
  • Dropped BUG : VIA/s3g unichrome pro IGP (integrated card) will cause the application to crash when the 3d scene is loaded. It can display, but application crash when camera moves, or new objects created and disappears.
    we will not support it. It is not even DirectX7 card with only 8MB video memory. Kind of TNT2 serie which is so old.
  • BUG: When a user is connected to a game server, it can not reconnect to the same server, but reconnection is only valid on the third time. This is because the reconnect time between two connects are too small.
    a workaround will be display something and delay for a moment between ParaNetwork.Restart() and the next connection call. In other words, we should wait for the server to disconnect, before connecting to it again.
  • BUG: CRC32 sometimes is inconsistent, where files are consistent. It happens on the vista and winXP computer both. But i can not reproduce it very well. This causes an existing world to be downloaded again and again even it is already synchrounized with the server.
  • TODO: we shall allow the game server administrator to join its own world. One work around is to give the host dedicated game server an internal player name, such as admin. The listen game server,however, will retain its original game server name. alternatively, the server can enforce the client player to use a different name, such as gameservername_admin.
  • game server will now remember total user, server start time, etc.
  • Logic change: seting the value property of the slider bar will not cause the onchange event to be raised.


  • ParaIO can now set disk file search priority.This is useful when loading game world from zip file, where the files in archive files need to be examined before disk file.
  • we can now disable d3d when starting the application.
  • Game server can now be started using command line and requires no user interface.
  • when entering a game world, it will first load from the space server, and then try the game server if any. if game server is not valid, it just leaves in offline world by the space server.
  • Bug fixed: when switching networked game world, app will down.
  • Bug fixed: chat display is improved and moved to left bottom corner.


  • ParaMisc::SimpleEncode and ParaMisc::SimpleDecode are added, it uses synmetric key to render text ineligible. User credentials in NPL are encoded by some internal key. However, this method provides very limited protection.


  • app command line can now be retrieved via NPL
  • two internal optional command lines are bootstappper="config/bootstrapper.xml" local="config/local.ini" d3d="0"
  • ParaNetwork center and receptor address can be modified via scripting interface


  • ParaX Exporter will now select the skin with largest number of bones when exporting scenes with multiple skins.
  • Passive Rendering Mode is added, see EnablePassiveRendering()
  • SceneObject::GetLocalObject() can get a mesh object at a given 3D position.
  • NPL timer is now accurate using timeGetTime.
  • bug fixes: when we are entering text in editbox with IME, and then changes to another IMEEditbox, the caret disappears.


  • miniscenegraph is fully implemented.
  • auto instanced mesh is only used when there is no xref mesh.


  • VSLua, a debugger for visual studio is integrated. Please see, I feel that the offline compiler is more useful than the debugger. The debugger is still very cumbersome to use. In order to build an exe with debugger support, enable the macro DEBUG_NPL_GLIA_FILE in the NPLRuntime.cpp. TODO: we may read whether debug by specifying in the config file instead of using a different build.


  • cartoon face is fully implemented. doc is in 6.4.


  • character customization system documentation is refactored and implemented according to the new specifications in doc 6.4
  • 6.4 character customization system documentation is almost done.
  • bug fixes: 3d canvas's render target size will be created correctly after losing device object.


  • fixed function now supports UV animation.


  • ATI shadow mapping bug is corrected. R32 and RGBA shadow map is used by ATI and NVidia card respectively. I used the red component instead of the blue components in all shadowmap shaders, so that the terrain shadow receiver sharder is consistent for both ATI and NVidia card.
  • Kids Movie Community web site is completely rebuilt.


  • character customization documentation is written.
  • We can now add file to zip even if it is opened with asynchronous IO such as database file.
  • Vec2D is removed.
  • fixing a bug of uv order in particle system. where particle.order should be set before the TexCordSet is initialized.


  • transparency shader is used when the camera to player distance is very small.


  • filelogger now supports wild characters. See InstallFiles.txt for an example.
  • world download class is implemented in NPL. Its design pattern can be used for a chunk of dependent web calls.


  • zip file generation will now stuff time data in the extra data field. Hence, we will always assume extra data length is 0. However, the game engine zip implementation will also check the extra data field length if the extra field in the central directory is not 0. However, checking field length in the zip chunk can be IO intensive and slow. We should avoid generating extra field when creating zip files with any other third party tools. To my knowledge, winrar will generate clean data without extra field.
  • Improved: The managed NPL lexer for large base64 string is very ineffient. It will linearly reallocate some 32bytes for the string token. The performance is very bad when the size is larger than say 64KB. hence, I have changed it to double its size when the buffer is over 500 bytes. Hence we can now safely encode serveral MB of file in base64 encoding in the script. And the NPL lexer will be fast to parse it.


  • NPL to sCode table index serialization bug is corrected for index over 10.
  • we can now upload EBook, screen shots to our community website.


  • the 3d scene mouse click is only sent when it is not a mouse drag.
  • we can not query the product key via scripting interface
  • we can now get the content of a file as string via the scripting interface's ParaIOObject::GetText()


  • CreateZip and related function set are implemented. we can now create zip files from any file systems, or we can zip everything inside a directory to a zip file with a single function call.
  • The FileSearch() can now search zip files, in addition to disk file.
  • a possible bug that cause avi recording to quit unexpectedly is prevented.


  • AsyncDownload() is implemented as C# plug-in.
  • ParaIO.CRC32(filename) is implemented.
  • SyncFile(filename) is implemented in NPL, with CRC32 checkings.
  • web service callback will report error message in a variable called msgerror.


  • Bug corrected: The ListBox freezes whenever a toplevel control is pops up and closes. This is due to the CGUIListBox::m_nEvent.m_eState not reset after losing focus. Hence, whenever a control is re-gaining focus, we will reset its key state.
  • TODO: this may be the same problem when some IME input method has double text.


  • static mesh's replaceable texture will now reflect on any animated Xref models in the model file.


  • and GetFileName() is added. the former provides a synchronous calling mechanism for neuron files.
  • XRefScript object is added in MeshObject as well as NPL scripting's ParaObject. For more information, please see ParaObject and MeshObject.
  • ParaX exporter now supports XRefScript object: if the file name of the XRef Scene is filename.lua.max, it is treated as a script object and is exported as filename.lua. In a script scene, the scene itself is not rendered but merely served as a visual clue for artists and designers. The script file plays a role similar to character event file, with even handlers for on_action, on_click, etc. We can use script Xref scene to add interactivity to a static mesh object, such as specifying mount surface, and lots of game elements that is instanced with the mesh.
  • The following Xref Script model has been created in 3dsmax and NPL, please see model/scripts/ folder for all XRef script widgets that will be added.
    • lowchair.lua.max: allowing character to sit on a char surface
    • bed.lua.max: allowing character to sit on a bed surface


  • INTERPOLATION_LINEAR_CROSSFRAME is used for UV translation animation. This allows texture to translate to a different texture UV immediately between two frames, such as the blinking of eyes.


  • Static Mesh Object now support X Reference sections,allowing static mesh to contain any animation mesh object. For more information please see the ParaXModel.templates and StaticMesh and MeshObject class for X reference object.
  • mount point for static mesh object is enabled by animated x ref. I can refer to biped object for how to handle that.


  • Base64 encode and decode is added. Please see commonframework/CyoEncode.cpp.
  • NPL.activate function can now accept ParaFileObject typed message data type. ParaFileObject will be converted to base64 string upon transmission. There are size limit though of 10MB.
  • we can now resize an image when taking a screen shot.


  • esc key logic is imporoved in KidsMovie script


  • basic security improvement to ParaIO namespace which prevent user to use absolute path when moving, copying or creating files.
  • open file dialog implemented in NPL
  • NPL designer panel is implemented in C#'s allinone solution. We can now export anything from visual studio 2005 win form design mode to NPL.
  • loginBox is implemented in NPL, I used some similar structs as in 2's Form authentication model.



  • a multi-line editbox is implemented in NPL, using a collection of single line editboxes. see EBook/Popupeditor.lua. It can deal with english and Chinese character editing, with automatic word breaking, inserting and deletion supported.


  • GUI editbox will now handle OnKeyUp event. Hence we are now possible to build a concise version of multiline editbox using multiple single line editboxes.


  • Kids Movie Creator has following prerequisits: Windows Installer 3.1, .Net 2.0, PhysX.
  • TODO: In Windows Vista, even the administrator account is not able to create or modify files under the game install directory if UAC ( user access control) is turned on.
  • Flash movie is now rendered correctly on older machines that does not support non-power of 2 textures.


  • a single developer license of f-in-box is purchased and installed in ParaEngine.
  • Texture/Flash.ocx will be used if the flash.ocx activeX control version on the target computer is below 9


  • Worlds can now be read-only and in zip format. Worlds in side a zip book is also readyonly.
  • ForceRender() will now render both 2d and 3d.


  • In KidsMovie, EBook is fully implemented with Zip book support. All tutorials are now book based.
  • In mesh and character file runtime remapping is implemented. In case some files are not found (possibly because of moving the directory), the engine can search the disk for possible replaceables using the filename of the missing asset file. the implementation is in ParaWorldAsset::m_bUseAssetSearch. in order to enable this function, one needs to create an empty file at "temp/assetmap.txt". Check the log file for information at runtime. "temp/assetmap.txt" will be read and written at at loading and exiting time.
  • UNKNOWN BUG: some times, the listbox is not selectable in the EBook popup menu. I can not reproduce this error; but it happens twice.
  • we will now automatically take screen shot according to the file extensions.


  • DirectX SDK upgraded to April 2007. PhysX upgraded to 2.7.3. All ParaEngine solutions have been recompiled.
  • All character and model assets have been reorganized.


  • GUI resource has been documented and resource elements now uses string instead of wstring. Some default parameters in original functions have been optimized.
  • Button GUI can now have both the artwork layer and the background layer. This is used in the _guihelper.SetVistaStyleButton() scripting functions.


  • audio engine now supports sound capturing. It is used in the EBook of Kids Movie.
  • UNKNOWN MS BUG: i do not know, this might be a bug of XACT, that sometimes pWave->Destroy() never returns.pWave->Destroy();that m_pEngine->PrepareWave() may return the same wave object that has been formerly destroyed. Hence, I removed all pWave->Destroy(); in the audio engine.


  • EBook implementation is added to the KidsMovie
  • zip archive file can use relative path
  • database file can be in zip archive file and extracted to disk on the fly.
  • wave file can be in zip archive file and extracted to disk on the fly.


  • there can be multiple top level controls in the GUI. the z-order of top level controls is dependent on the time order when the SetTopLevel() method is called.


  • scrollbar alignment type is changed to middle left and middle bottom.
  • I have a wonderful idea of turning the current kids movie product in to a multimedia cartoon book maker, where the book contains editable text, images, videos and 3d scenes.


  • bug corrected : there is a time bug in the network layer (the gettime function) which causes connection to be dropped unexpectedly. To workaround where the timer can sometimes jump forward by hours or days
  • when the current window is not the foreground window, we will use Sleep() function with different time for different server mode.
  • we can now disable rendering on the server by minimizing the game engine window


  • TODO: generate a 2D map for a given terrain tile at a given loaded scene. Make this recursive, to generate all mip levels in a given map (or any arbitrary rectangular region in the world).
  • Most functions in NPL network layer now returns HRESULT, which gives some more information on fail conditions.
  • The emulated environment server will now automatically remove OPC if it is time out or failed on sending a latest packet.


  • NOTE: for Network testing, I have made following temporary changes to the NPL Network layer
    • Namespacebinding and account database will be made writable at loading time. Since they are sometimes under source control.
    • There is a macro in account manager that allows any account to pass authetification mode.
    • AddNamespaceRecord method will now delete existing record and then add the new one.
  • When loading world using the kids UI, the network is disabled.
  • the client will automatically create an empty world if the connecting server world does not exist on the local machine.
  • the server will assume that the local personal world is a world with the same user name under worlds/ directory. If the username is LiXizhi, then the personal world path is "worlds/LiXizhi" when the user try to host its personal world, KidsUI will try to load this world or ask the user to create it if it is not created before; and then it will immediately change the simulation mode to SERVER, so that it will begin receiving incoming clients connections.
  • the script/network/explorer is fully integrated to the KidsUI.
  • The .Net web service based networking is fully integrated to the KidsMovie with explorer UI. A test session is organized on 8 computers, with the server running ASP.NET site as well as game server.
  • TODO: add a special material attribute "_p", so that light can be turned off on a per face group basis
  • TODO: we should render, any mesh faces that have alpha testing disabled last (before character).Otherwise alpha testing disabled mesh will overlay the character due to z-buffer. Or shall we disable Z-buffer for such faces.
  • TODO: when a client connect to the same server twice, (either by connecting within a connected world or connecting twice by canceling the first one)
  • TODO: using XRef in 3dsmax to attach other static mesh objects or animated character objects to the scene. We may use additional data field in the text based X-file format. It generally contains the x file path, the 4*3 transformation, and the animation ID if any.
  • TODO: there is a problem when certain user may not be able to connect the server. It seems that the login packet never get sent in some cases. The network honors priority, but in case of reliable_ordered data, hence it is not necessary to have priority in ordered channels.
  • TODO: we should make it possible to log all network creation activitity to file.
  • TODO IDEA: I have idea to change the original new world function in Kids Movie, to some challenging game. In the game, the world is devided into many steps, each step contains 5-7 blocks to build. The user may spend weeks to complete a rather complex level, but the result is somewhat different from the original design. people just wants to continue, because they want to see the idea of the original world creator and follow the original creator's path and make slight difference. Difficulties may arise in some steps and there are endless creativity to explore (more creatable elements to add in the future, even some RPG element).


  • the UI designer now supported .Net control are form, panel, button, text box, label, list box, tabControl, check box, comboBox, ProgressBar. - OnMouseWheel event can now be fired correctly by UI container and other object types.


  • the UI designer now supports .Net tabControl.
  • ParaUI now supports "_fi" alignment type, which is like the fill alignment type.


  • dropdownlistbox is fully implemented in NPL using editbox, button and a toplevel listbox.
  • a toplevel container will trap any mouse events from now on. Usually mouseup event can be used to test whether it is a click outside the client area of a certin top level control.
  • a internet explorer form is implemented in NPL, which allows opening multiple windows.


  • TODO: I have trouble building a NPLWebServiceClientLib in Visual Studio 2005 (release)and I was getting the following error "sgen.exe" exited with code 1 I found that following the steps below fixed it:Open up the project properties.Open up the build tab.Set "Generate Serialization Assembly" to "Off" on google, people say it is a bug of VS 2005. However, to increase performance of XML serialization, I should remember to set back to auto when it is fixed.
  • ParaIDE: solution view can now be trigger from the ParaIDE's file menu. The new solution function will now create a new main game loop file using the script/templates/helloworld_main.xml template module. The LoadWorld and helloworld_main template modules have been rewritten.
  • UI Designer project in C# is implemented. We are now able to export button, panel, form, textbox, listbox from .Net controls to NPL script. In other worlds, We can use the visual studio IDE to design NPL controls. See WinFormToNPL class in the project for more details.
  • ParaEngineSDK_redist: the redistribution package for ParaEngine SDK is created under the ParaEngine directory.


  • Flash player can now be accessed via the scripting interface, such as GetFlashPlayer(0)
  • In flash player, we can simulate single mouse click, there is no need to simulate key input. mouse click is simulated by sending WM_LBUTTONDOWN and WM_LBUTTONUP messages to the client window Because the game engine app always captures the mouse, the single click function will actually send a pair of Left button down and up message to the flash control. The first click set the mouse focus and the second performs the actual click. Then the flash control will soon lose mouse capture to the game engine.
  • TODO: how to stop a flash movie in UnloadMovie(), including music.


  • flash movie can now be used as textures. See FlashMananger.cpp
  • I manually decoded the header of SWF file(both compressed and uncompressed are supported) to get the default size of the flash movie.
  • DONE -2007/4/26: we need to purchase a $299 license from in order to remove the demo watermark. Do this at release time. We may just replace recompile with the new purchased dll.
  • DONE -2007/4/26: in case the flash ocx version on the client's computer is too low, we may need to include a player in the exe resource of the executable. Detailed guide can be found in the f-in-box's help files.


  • character tracker logic is fully implemented in the current CS network game architecture. All player history send and receive history on server and client are cached for validation and sending frequency. the documentation is in Doc 6.1 Kids Movie Network Architecture
  • Due to the character tracker logic, we can now use different update rates for different attribute groups in a normal update packet. For example, if a character is static on the server, the server will not need to include the position data in the packet very frequently.
  • web service GetIP.asmx is partially implemented for the game application web service.
  • the terrain tile cache size for server mode is set to very large to cover more tiles in memory.see EmuCSParaEditGame.cpp
  • TODO: on Vista Computer, clip planes does not work which renders the water reflection invalid.


  • value tracker is implemented for trackering network histories of object. It is used in COPCObject. all COPCObject object on the server side will track the history of all perceived objects of the OPC.
  • We can now limit the total number of player updates in a single normal update packets. So in case, there are crowed positions, players in vicinity are sent in separate update packets.We can use a rating system which contains the normal part and delay part.
  • the server's normal update rates are not dependdent on client update rate any more. It will send no more than one update packet per frame for a given client. normal update are all unreliable sequenced packets now. If there are two same typed normal update packets for the same object, only the latest one needs to be processed. The same rules should apply for the client side as well.
  • TODO: implement secure NPL connection and Use CloseConnection for all NPL requests of connected but unauthorized callers.
  • TODO: add SetUnreliableTimeout() for both client and server. It is that an unreliable message which is enqueued by send function but not transmitted to network wire in some specified time automatically disappears from send-queue.
  • TODO: test with ApplyNetworkSimulator()
  • BUG: when the server sends with NPL::MEDIUM_PRIORITY, NPL::RELIABLE_SEQUENCED to clients, the performance is great with 20 moving characters in the camera. However, when the server sends with NPL::MEDIUM_PRIORITY, NPL::UNRELIABLE_SEQUENCED, there is 3-5 second lag when there are over 4 moving characters at a time.


  • Raknet is upgraded to version 3 beta.
  • BUG: On Windows Vista, reflection map is not rendered properly. the camera clipping plane does not seem to work. Could it be that DX 10 does not support clipping plane through DX render state?
  • Note: I have researched over NAT pouch through resolutions extensively. The only universal solution is to implement our own lobby or game master servers. ASP.NET alone can only get the IP but not any port of a connecting client, thus HTTP can not be used for the lobby servers. (Our game servers are not on HTTP port!)


  • The Rain/Spray particle systems are now exported. In 3dsmax create pannel, select particle system->spray to create.
    • Particle system can be attached to bones.
    • we can assign a standard material to the spray emitter using the material editor. The material name can be XXX rows cols, such as "MyTexture 2 3", in which case, the texture will be evenly divided in to 2*3 tiles, and that ParaEngine's particle system will randomly pick one to use for each newly born particle.
    • the size parameter of a particle system is not exported in full animation block, but only three keys are exported, hence it only makes sense to animate it using less than 3 keys.
    • the material diffuse color and transparency is used for particle color animation. Like size paramter, only three keys are exported, hence it only makes sense to animate it using less than 3 keys.
    • The particle object name in 3dsmax can be the following format "XXX [sphere [r = float_rotation]] [g = float_gravity] [s = float_slowdown]", such as "spray01 sphere r = 0.5 g = 0 s = 0.01"
    • emitter type is derived from the spray particle object name in 3dsmax.By default it is a plane emitter. - if the node name contains "sphere", then it is a sphere particle emitter - the node name also contains "r = float_value", initial rotation angle is set for the sphere, it is usually in the range [-Pi/2, Pi/2], such as "XXX sphere r = 0.5". - if the node name does not contains "sphere", then it is a plane particle emitter
    • the display type of a particle determines how a particle is rendered. By default it is a 0. - 0 or 2 means normal particle which is centered on the particle origin with a given size. - 1 means that particle is rendered with origin at the particle system center and extends to the particle origin.


  • A simple vegetation shader is implemented. Mesh name ending with "_v" will be rendered by the vegetation shader.
  • Texture UV animation in the material editor (translation, rotation and scaling) is now exported. UV animation is assumed to be looped globally for all animation sequences. It is good to use UV animation for special effect,such as blinking eyes, etc. However, currently only the UV translation animation is rendered in the game engine.
    add for rotation and scaling animation.


  • NPL network layer documentation is written (see doc 3.9).
  • NPL network layer is improved and redocumented. NPLPacket class and NPLEmailAddress are implemented with faster and more secure code.
  • Network architecture doc is updated with game server and space server logics.


  • NPLParser and NPLLex are implemented in both C++ and C#. There are used to validate NPL code when sending and receiving messages.
  • we can now send NPL Activation msg which can be number, string, table(string and interger keys are supported), and nested table. See the example below: local msg = {a=b"\\hi"<a>x</a>, b=21.123, tablein = {x=4, asd="ssd",},c=false, [0]=21.0, ["asd"]=""}; local address = "http://localhost:1979/WebServiceSite/NPLWebServiceProxy.asmx"; RegisterWSCallBack(address, log("WS callback:"..commonlib.serialize(msg).."\r\n");); NPL.activate(address, msg); A sample XML sent in the soap parameter is given below: <msg><a type="string">xxx</a><param index=0 type="double">21</param><b type="boolean">false</b></msg>


  • NPLWebSerivceClient is implemented as a ParaEngine plug-in in C++.Net. We can now call any SOAP web service method with following syntax: XMLElement Activate(XMLElement); Although both synchronous and asynchronous call are supported by the API, only asynchronous call are exposed and can be used via scripting interface. validated sCode messages at receiving and sending time. To the XML-script conversion: see MessageConverter at ws client plugin
    writing the documentation of design and user guide. Three related projects: The NPLRuntime() uses the web service client proxy plugin for calling any web services on the Internet. The web service client proxy plugin is at ParaEnginePlugin/NPLWebServiceClient, which is almost a C++ wrapper for its managed implementation ParaEnginePlugin/NPLWebServiceClientLib ParaEnginePlugin/NPLWebServiceClientLib has a web reference to ParaEnginePlugin/WebServiceSite, which contains the NPLWebServiceProxy.asmx web service method.

  • NOTE: for unknown reasons, only assembly plug-ins developed using C# can be debugged in VS.NET 2005, C++.Net plug-ins can not be debugged. However, if C++.Net calls C# code, the C# code can be debugged whereas C++ source still can not.
  • TODO: write Documentation:
    • implement a world directory file manager for synchronization: which files are synchronized. world/character?script?
    • implement a world directory cascading (which removes dependency on other worlds).
    • changing world directory name: but what happens to file paths ini db files


  • all KidsMovie source control and ParaEngine Product line has been backed up in disks.
  • channel based NPL networking API have been implemented. See ParaNPLScripting.cpp. Documentation is in 6.1 KidsMovie Net..doc Web service implemention interface is written.
    Web service implemention and sCode security check needs to be done.
    the KisMovie network logics should be rewritten using proper channels.
    implement a basic NAT-punch through with web service and the new NPL WS API
  • TODO: RakNet 3.0 beta is available today. It seems to be a major release. its file sychronization and memory replica system may be ported to NPL.


  • glow effect's intensity, blending factor and glowness color can all be adjusted in the scene attributes.


  • Terrain shadow rendering technique is changed from depth based shadow map to color shadow map read from the blue component of color shadow map. This allow us to create blurred shadow on the terrain. We can continue to use the depth shadow map for other scene objects. I used 2 pass guassian blur for the color shadow map I have documented the code and method in EndShadowPass() in ShadowMap.cpp. There is a trick that prevents the terrain to be re-tesselated when rendering the same terrain for both the shadow map and the normal rendering. The draw sequence must be: RENDER_GLOBAL_TERRAIN(reflection), RENDER_GEN_SM_TERRAIN, RENDER_GLOBAL_TERRAIN(normal). See RenderSelection(RENDER_GEN_SM_TERRAIN) for more information.
  • TODO: Since I only used terrain as the shadow receiver that uses color shadow map, we can turn off hardware shadow mapping or F32 shadow mapping.
  • F32 shadow mapp will default to D3DFMT_A8R8G8B8 shadow mapp before it reports real failure.
  • culling mode is now disabled during the shadow map generation pass. This ensure all faces to cast shadows regardless of its normal. It will be a little slow though.


  • Shadow mapping techniques are substantially reviewed and optimized. Orthogonal SM, TSM and LiPSM are modified. LiPSM is now fully documented according to the original paper.
  • To improve shadow quality for LiPSM and PSM, we still need to more acturally specify the bounding boxes of terrains (the shadow receivers). I have used multiple bounding boxes(100-200) to approximate the terrain shadow receiver, instead of one bounding box. However, one bounding box is used in case of TSM and orthogonal SM. With the improved PSM and LiPSM, shadows can be projected on all terrain within the frustum.
    LiPSM works very well when light is above head. However, it works poorly when camera is looking along the light direction where light is slopy.
    In case of PSM related ones, we can draw more shadow casters.
  • I will support two shadow mapping method. LiPSM and Orthogonal SM, basically:
    • Use LiPSM (with multiple bounding boxes for the terrain receiver): I think it is the best One pass general Shadow Mapping technique.
    • Use Orthogonal SM (with only one bounding box for the terrain receiver): It is fast and looks almost the same as TSM. But only a small region of the terrain(shadow receiver) can has shadow. - TODO: Cascaded Shadow Maps with Orthogonal SM is the final solution for more general cases, which I have not implemented yet.
  • The follow camera system will now be disabled when character is still.
  • API behavior change: character onclick events will on longer be fired automatically. The user is required to generate it in the scripting interface.


  • Module Manager and Installation is implemented in the solution view of ParaIDE.Net. One can now make modules containing several template script files and save to XML files One can also install modules from these XML module template file to any disk location using any parameters called replaceables. The most important replaceables are %install_path%, %instance_name%, and %file_path%. Examples are in script/templates/*.xml and *.lua.
  • The following NPL script modules have been made and tested.
    • helloworld_mainloop.xml: a simple hello world application with basic event handling.
    • loadworld.xml: a simple load world dialog and function with basic data base processing.
    • winform.xml: a NPL windows form
    • winform_singleton.xml: same as winform.xml, except that only one instance of the window is allowed.
    • winform_toplevel.xml: a top level NPL windows form
    • winform_toplevel_singleton.xml: same as winform.xml, except that only one instance of the window is allowed.
  • Here is the procedure of creating a module
    • write an instance lua file such as script/templates/winform_singleton.lua
    • test the instance file and make sure it compiles and runs well
    • replace text in the instance lua file with replaceables, such as %instance_name% and %file_path%
    • Open ParaIDE.Net, open solution view, open the module manager page, and click New to create a new module XML usually with the same name such as script/templates/winform_singleton.xml
    • In module manager page, add a new file and copy text in the instance lua file to the source code and save the module
    • In the module install page, open the previously saved module file, such as script/templates/winform_singleton.xml, Select the directory where to install the new module instance, edit replaceable tables properly, especially the %instance_name% field, and click Install. A new instance lua file will be generated at the specified location.
    • Test the generated file and make sure it compiles and runs well.


  • .Net 3.0 service oriented programming model(contract, schema and policy) is reviewed. Some of its ideas are similar to NPL, such as one-way web service call, and its several deployment methods. NPL can be made compatible with .Net 3.0 model, but it will remain to be a more flexible and light-weighted solution for game and other applications. The flexibility of NPL can not be replicated in .Net 3.0 due to the compiled nature of MSIL code.In NPL, data and programs are treated the same. And NPL package schema can be non-fixed and easy to upgrade.
  • the autocamera's camera behind character mode is changed, such that when character is still, the camera is free to go.
  • the scene object by default handles no on_click events. The scripting interface is thus responsible to call on_click event of a character object with first paramter set to 0.


  • The windows menu is cleaned up. Added an about dialog. see ParaEngineApp.cpp. On the onetimesceneinit() method, we set the menu item state according to build configurations.


  • the .Net Managed API is completely ported to visual studio 2005 using the new C++.Net syntax. The source control has been moved from VSS to AB. The good part is that we can debug accross the native and managed code after porting to VS 2005. Below are the migration notes.
    • A solution called AllInOne is created under the ParaEngine Plugin Directory.
    • The current project dependencies in AllInOne solutoin are (ParaEngine.lib)-->ParaEngineManaged-->ParaIDE-->ParaAllInOne
    • VS2003 to VS2005 C++ Porting notes: string* is replaced by string^. new is replaced by gcnew. All const std::string& is replaced by const char*
    • ParaEngineManaged and ParaAllInOne are C++.Net application using multi byte character encoding.
    • ParaAllInOne is the plug-in application. it will output to the same configuration directory of the main game engine
    • ParaAllInOne will run the main application and set the working directory to the ParaEngine root path. Press F5 in ParaAllInOne will allow developers to debug all managed code as well as native code.
  • ParaEngine Plugin deployment notes:
    • To deploy one must now manually copy the ParaAllInOne.dll from the main game engine release directory to the plugin directory under the application root.
    • The ParaEngineManaged.dll and ParaIDE.dll must in the working directory. ie.the root directory.
  • Tiny XML is added to ParaEngine. See ./xml
  • Bootstrapper is implemented in C++, NPL and .Net. See CBootstrapper.cpp. It will load and save via XML file in the config/bootstrapper.xml
  • An Application Solution Manager is implemented in ParaIDE.Net. It can be used to generate and set bootstrapper for ParaEngine.
  • The NPL file syntax now regards (gl)XX.lua and XX.lua as equivalent. However, (gl) is still advised to be added for local glia file.


  • luabind is upgraded to 2006.1 version. I have modified the luabind/luabind/object.hpp and added the operator=(T) function to the luadbind::object class using the replace function.


  • terrain bounding box bug is corrected: when the maximum triangle count is exceeded, the bounding box is now accurately calculated.


  • mesh construction process is implemented at fixed function pipeline as well.


  • GDI texture saving will generate mipmapping texture for all dds textures.
  • ParaIO now supports deletefile and movefile.


  • 2D GDI interface is rewritten and exposed to the NPL scripting interface.
  • a paint brush application is made in NPL, which is used by the kids movie product to edit replaceable textures of models.


  • face tracking is disabled when the biped is in control of the user.


  • highlighting marker are all post rendered instead of rendering with the parent control.


  • particle effect file is added.
  • TODO: when rendering model containing particles in a 3D canvas, particles will not be rendered. This will prevent particles being generated from a canvas's coordinate system. In future, I need to move particle rendering after the draw batch. So that canvas scenes and main scenes can have sparated particle systems rendered.
  • terrain shader texture limit is changed to 12. This limit can be increased at will.


  • effect files can be indexed by its name.
  • during scene picking, character has more priority than transparent meshes.
  • [worldname]/onload.lua will be activated when a game world has been loaded.


  • we can now mouse pick a point in the scene. numerical 4 and 5 keys are used to create and delete at the current mouse position.
  • Card compatibility issue solved: ATI 9800 card will not go white.


  • replaceable texture is implemented for static meshes.
  • I have adjusted the main loop of the application. When the application is not active, nothing takes place in the main loop
    • TODO: however, the CPU is still 100% when inactive. It appears that the network layer thread will consume 100% CPU no matter what.
  • bug is corrected, when the particle instances in scenestate is not properly cleaned up.


  • physics mesh is extracted from the static mesh according to the material attribute. In 3dsmax, one can disable physics for a given material by naming the material with "*_a".
  • Chinese version of Kids Movie is finished.


  • The paper " An Avatar-Based Approach to 3D User Interface Design for Children" is finished with WangTian.
  • Code driven XACT function is added in ParaAudio. We can now play any audio files without prebuild using XACT content builder.
  • a bone animation bug is corrected. The bug results in bumpy animation when the first two frames of an animated bone is the same.


  • The website is finished with both English and Chinese version support.
  • texture sequence FPS can now be specified in the texture file, as, where 10 is the FPS which can also be floating point value.
  • when naming mesh file, one can combine "_a"(no physics), "_b"(billboard), "_t"(transparent), "_d"(dim or no lighting), "_r"(receive shadow) in the file name in any order, such as "xxx_b_t_d.x"
  • Both game engine and mesh exporter supports mesh faces with z buffer write disabled faces. One only needs to specify "_t" in the 3dsmax material name. This is usually used for particle mesh.
  • the reflection map's background color is properly clearly according to the current fog color or the background color.


  • TODO: codec selection should be toggled to windowed mode, otherwise it will pause in full screen mode.
  • TODO: the new world instruction panel should use a slider


  • KidsMovieCreator Setup project instructions:
    • Under the directory ../ParaInstall/KidsMovie/KidsMovieCreator/
    • the VS 2005's setup program can create bootstrapper programs which can selectly run components. But one has to manually edit component XML files under D:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\BootStrapper\Packages\.
    • I have created a Ageia PhysX installer component for bootstrapper. The source file is at .\ParaInstall\KidsMovie\KidsMovieCreator\Bootstrapper * Custom action is used for DXSetup.exe, the DirectX setup folder is at D:\lxzsrc\ParaEngine\ParaInstall\DirectX\, where I only included the recent versions of optional component. For more information, please refer to the technical article of the DirectX SDK.
    • Finally, nullsoft's NSI script file is used for putting the boottrapper, PhysX system driver, the kidsmoviecreator.msi, and the windows installer2.0 into a single exe file. The source file is at .\ParaInstall\KidsMovie\KidsMovieCreator\kidsmoviecreator_nullsoft.nsi. To rebuild the ALL-in-one exe file, install nullsoft, and left click on the file and select compile to generate the final install file.


  • texture sequence is used for fixed function ocean rendering


  • asset can now be unloaded from scripting interface.


  • Fixed function stencil based container is now properly aligned when rendering.
  • when enable lighting in fixed function, object goes red. This is due to emissive color which is used for encoding the reflectivity. The problem now does not occur.
  • audio engine will be properly invalidated when calling any of its API, when there is no sound card installed on the target computer.


  • when creating new world, character position are preserved by copying the world attribute file.
  • the talk behavior of character is enhanced to process command of user text input in the kidsmovie interface.


  • onchange of editbox will output virtual_key from the last key stroke, such as the enter key.
  • the enter key will bring the interface to the text input state.


  • sky fog is now accurately rendered which shows no box distortions. The sky fog range can also be adjusted from the attribute interface.
  • ./config/config.txt settings can now be preserved
  • the title windows text can now be changed via scripting interface.


  • the ocean reflection map now allows users to select which group of items to be rendered. The faster a computer, the more items will be rendered.


  • the left shift key now moves to the closest biped and mount on it if the distance is close enough.
  • CFileLogger is finished. It can be used a automatic build system. more information, please see InstallFiles.txt and CFileLogger.cpp.


  • Kids Movie asset file can now be loaded either from db file or disk file.
  • the common lib can now serialize script table to file or string.
  • player control keys have been moved to the scripting interface.
  • script/ide/action_table.lua is implemented.
  • TODO: alpha 0-50 should be reenabled when alpha testing is not enabled. if a texture ends with "_a", it will be treated with alpha blending but not alpha testing.


  • product is automatically registered using the license code in ./config/license.txt. When a product is activated, the license code will be written to the file as well.
  • tips of day control has been added to GUI.
  • ParaGlobal.random now provides an automatic random number generator with seeds automatically set at application starts.
  • GUI bring to front and back function are added. The GetUIObject(x,y) function is simplified and optimized.
  • TODO: The Mouse focus in/out algorithm needs to be rewritten. Right now, a button between a container will be highlighted, which is undesired logic.


  • GUI helper will now be brought to top with each new message call.
  • GUI set color will not able to set the alpha channel. This can be used to create canvas fading effect with a timer. see script/kids/ui/product_logo.lua


  • serial number generation and verification code are implemented. Some license code are generated in temp/*licenses*.txt call this GenerateActivationCodes("", 1,10000); whenever one wants to generate new keys.
  • script/ide/event_mapping.lua is added. One can now easily look up virtual keys using amenable names.
  • GUI video can be resumed when device changes or lost
  • background color of sceneobject is added, so when scene is not enabled the default scene background color can be set separately.
  • start up logo is implemented for kids movie, see script/kids/ui/product_logo.lua
  • Product activation UI is implemented. see ShowAboutWindow() in script/kids/UI_startup.lua.
  • scroll bar default width and kids UI scroll bar textures have been correctly set, including all four texture states={[1]="highlight", [2] = "pressed", [3] = "disabled", [4] = "normal"};


  • single key down event handler in scripting interface is added.
  • Toggle windowed mode is added to scripting interface
  • Kids Movie design document is written.


  • current two group of localization file is created. One is "IDE" which contains all ParaEngine specific strings. The other is "KidsUI", which is application specific.
  • both the zip and pkg file encrption logics are supported. pkg is a slightly encrypted version of zip file.


  • a script based localization framework is implemented. See script/ide/locale.lua and script/lang/lang.lua
  • a script based commonlib is implemented. It provide debugging functions such as debugstack(), etc. See script/ide/commonlib.lua


  • The English and Chinese version of the China Web3D business plan (both are 16 pages) are reviewed. A number of emails have been sent to interested people when at Beijing.


  • I had a long talk with Ms Zhang, CEO of Nuveen Asia. Her son Jaalin, Cheng may also contribute to the studio.


  • I have written a 32 page PPT based on the latest China Web3D business plan.
  • I have given a presentation at Beijing to a large audience of venture capitals exclusively.
  • Father and I was in Beijing from 2006/11/16-2006/11/22.


  • I have given presentation to Walden Capital International.


  • Ageia Physics Engine is updated to 2.6.2. It now uses a free commercial licence.
    at installation time, it requires to install a phyiscs driver using the redistributable file provided by ageia.
  • in free camera mode, the mouse wheel will control the camera move speed
  • In movie capture mode, the game engine will set the max frame rate of each frame rate controller to the current ideal frame rate. This will prevent faster machines to run too fast during capture mode.
  • Bug corrected: fog density and camera far near plane are preserved in db.
  • Bug corrected: category name is sent in network mode when creating object.
  • Bug corrected: Player can not control other OPC. Client can not delete OPC.
  • Bug corrected: Environment simulator adjacent tile checking duplicate functionality is now working properly. if the tile container is the root tile, no static solid object is added.
  • TODO: The max NPL packet size is increased from 4096 to 64000. Packets larger than this size will be dropped. We should split packet if their size is that big. It seems that there is a performance decrease after increasing the size.
  • TODO: can not delete object.
  • TODO: There is usually a lag of 30 seconds on some machine. It seems that the client should not flush the server with too many data, it needs to predict when it is approaprite to send packets. And that both the client and the server should not process only one packet at a time, but process as many packets as possible.


  • NPLExtension.lua and ParaEngineExtension.lua are added. GetCharacter() is implemented in scripting interface.
  • Server mode menu state is added. In server mode, rendering is disabled; but simulation and GUI event still work.


  • Network function for the follow types are implemented: ocean,sky,time and chat headon_display
  • when crossing boarders, networked players does not play any animations.


  • ParaNetwork now has a collection of maintainance functions. The KidsMovie project now uses some of these functions, such as restart(), which closes all connections.


  • Terrain heightfield can be sent and received via NPL at any resolution.
  • The document 6.1: KidsMovie Network Architecture is started.
  • During login process: the server will send the world path for the client to login.
  • Center server disconnection is supported, OPC can be removed automatically once disconnected.
  • China Web3D business plan are written in both Chinese and English version.


  • TODO: we need to use channels when sending packets.There are three ways to do it.
    • Do it per activate: NPL.activate("", "", channels);
    • Associate channel ID with a certain file name. All activate to it are in a certain channel.
    • Associate channel ID with a certain file name. All activate from it are in a certain channel.
  • TODO: we need to use another channel for pure chat, and a third for auto patcher.
  • TODO: use string table in the network layer, so that we do not have to send the NPL file name repeatly each time. shall we use a more efficient StringTable for known file name strings? stringTable->EncodeString(FullName.sRelativePath.c_str(), 256, &s);
  • TODO: shall we use huffman encoding for all strings in sCode? stringCompressor->EncodeString(FullName.sRelativePath.c_str(), 256, &s);
  • The terrain namespace is changed to ParaTerrain.


  • Hipihi paid visit to our studio, with their CEO and tech chief. and we exchanged some opinions
  • We can get view box of a mesh object. And query the scene using the viewbox. Such we can use the view box to locate the same object on different computers.
  • Rotation and scaling can be set using absolute values. Rotation is represented by quaternions. This is realized through decomposing local transform matrix of the mesh in to standard forms.
  • Mesh modification request is implemented in NPL. creation_client.lua and creation_server.lua.


  • Distributed client/server networking mode is implemented. Network Players can perform walking, running, actions, jumping, resizing, changing base model (appearance), and toggle players.
  • impersonation is also implemented in the distributed CS module, so that a client can use characters with arbitrary names.
  • Fix some PNG file display problem. if PNG is saved with 48bits, it may display wrong in some GPU. Hence, artists should always use 24 or 32bit png texture files.
  • In debug mode of DirectX, full screen will generate wrong images because SetDepthStencilSurface() always set the surface to white, instead of perserving old values on it. Hence when drawing using multiple render targets, such as the canvas, the ocean reflection, objects will not be drawn on latter surfaces because of depth testing failure. Since this has nothing to do with release mode, so I did not fix it. To fix it in debug mode, I need to manually clear DepthStencilSurface to black after setting it using SetDepthStencilSurface().


  • the onchange event of GUI object can only have one instance in the current event pool.
  • the ocean level can be adjusted using a slider bar.
  • NPL connection lost and disconnection are allowed. Reconnection is working by manually reconnect to another world.
  • NPL glia and neuron file packet are sent using bit stream, which saves some memory and bandwidth in the header structure.


  • sky box mesh is now persistent in attribute database per world.
  • a number of camera parameters have been exposed through the attribute interface.
  • mesh file name ending with "_p" or "_d" will disable local and global lighting, such as for fire and other special objects. See e.g. in models/pops/fire
  • the light helper mesh is moved to models/pops/lightball/
  • the NPL ParaObject:SetPosition for sphere light object is matched to SetCenterPosition.
  • Default idle animation can be set. Currently, the on land idle and in water idle animations are automatically set by the biped state manager. By using the swim idle animation in water, we can now play other animations under water.


  • GUI containers with scroll bar now works correctly.
  • InvalidateRect is added for GUI object. So that NPL can manually recaluculate the client area of a container.
  • DoAutoSize() is added for GUI text object. One can now manually update the size. For scrollable text, Use temp:DoAutoSize();temp.parent:InvalidateRect(); See _guihelper.MessageBox(); for details.


  • Client/server chat application is finished in NPL. See script/client/chat_client.lua and script/server/chat_server.lua
  • client/server based NPL.activate() function with string and lua object as input are supported in NPL. Traditional CS architecture is realized by defining a special namespace called @server. Broadcasting is also supported with all@server.


  • GUI improvement: if the destination can not receive drag, restore dragging control to source control
  • GUI drag and drop will cancel when there is a mouse down event during a dragging session.
  • the ocean wind speed and direction can now be adjusted.


  • Three kinds of button animation style is implemented. It can be activated by setting the ParaUIObject.animstyle property.
  • GUIVideo is refactored. The codec thread and game engine thread now works OK. It is also more robust even a video codec fails.
  • The GUIVideo does not use the clone method, and it does not have the m_event object as most other GUI objects. The base interface can deal with NULL m_event.


  • NPL network layer is exposed via scripting interface.


  • terrain base alpha will now automatically adjust according to operation on other terrain layers. See TerrainEditor.lua.
  • network events system implemented.
  • NPL now offers functionalities to serialize lua object(tables) to and from string.
  • TODO: per object net events. sending lua tables over the network.
  • doxygen updated for new NPL functionalities.


  • TODO: The open source project Expression features a very good procedural facial animation system. I may use it in the character animation system.
  • TODO: there might be a outsource project with HiPiHi company in Beijing on the customizable character system. It might be a good chance to refine the character system to what extent I need in the automatic character animation project. My suggestion to their CEO is that a version by Jan 2007, and another version one month later.
  • The terrain base layer alpha use a shared mask d3d texture for white mask texture, in order to save video and system memory. The base layer alpha is only created on demand.


  • a SetSkin bug is corrected. Skin 0 is now correctly displayed for replaceable skin characters.
  • The terrain engine added another alpha layer for the base0. This will correct the visual flaw where the terrain is too bright. The user can also choose to turn off this automatic behavior and manually paint the alpha channel of the layer0 like any other layers.
    As layerN(N>0) is painted, the alpha channel of the base layer0 will automatically decrease, by the inverse of the amount added or substracted in the layerN.
  • when saving the base layer alpha, a simple encoding algorithem is used, so that constant alpha map will only take 9 bytes, instead 256*256 bytes.


  • Biped facing is now correctly recorded. The bug is caused by canvas where the biped is reused for different scene manager.
  • Non-actor is not preserved in the movie file like before, instead they must be made persistent in the local NPC database.
  • Movie clip and actor list UI is fully implemented in the scene manager.
  • KidsMovie for HangShang Version is made. It is only 20MB compressed.
  • Follow controller will use immediate facing. Sequence controller will use immediate facing in command mode only.
  • TODO: Add a collection of UI buttons for smoothly change the camera from one mode to another mode.


  • Movie recording UI is completely rewritten in script/movie/ActorMovieCtrl.lua
  • KidsUI's character property and AI behavior UI controls are significantly improved, with movie actor support, static local character support, and exchanging character type support.
  • object renaming is now seriously implemented.See ParaObject::SetName().
  • A KidsUI timer is added in script/kids/ui/LoadMainGameUI.lua for updating UI.
  • a number of small fixes regarding the editing UI of KidsMovie in NPL scripts.


  • TODO: add several particle effects, such as fire and smoke.
  • Always formally assign a Director when making a film.
  • String table database now support fast query by ID. (Not tested)
  • Movie controller renabled.
  • Partially done.


  • On demand software architecture( or grid computing) should be integrated in the NPL server model. Distributed DNS may be used to realize the On-demand server topology.
  • TODO: movie making in ParaEngine should be reinforced, so that no other game engine are comparable to it: these includes: (1) Easy making of movie controller: only one movie sequence can be associated with a character. One click recording. Enable recording of networked character. A movie sequence can be looped or not. (2) Clips and its playback functionalities. A clip is defined as a collection of actors and their movie controller starting time and location. The director can choose to shoot from any perspective when a clip is playing. A scene can have multiple clips. Only one click can be enabled in a scene at a given time for playback and movie shooting. (3) A complete movie may consist of multiple scenes each contains one or more clips. One movie scene can inherite from another movie scene, both actor and scene may be inherited from the base scene.


  • construction shader now supports shadow map generation technique.
  • shadow render list in the scene manager will not escape any shadow caster which does not contain the shadow generation technique.


  • Basic CS networking is tested and works OK.
  • The ocean will now be as large as the fog distance.
  • Right now, the ocean, fog, camera will all be saved and loaded for each scene.
  • a slight fix for shadows on the ground, sometimes disappears even when close to camera. The new fix ensures that all objects within a certain radius get tested using their swept sphere for shadow casting.
  • Done: proposal of the paper of 3D UI for kids.


  • Network UI is implemented in script/network/NetworkPannel.lua
  • flatten terrain bug corrected. The elevation value is converted to [0,1] range before computation.


  • a standard client/server application is built. Three environment simulators are created for standalone, client and server respectively.


  • Headon speach now does not receive any mouse events.
  • CreateProcess() is added on demand of users.
  • Characters can now be saved in ParaIDE in the selection bar.
  • When reseting AI events in ParaIDE, a default event file will be created automatically.
  • BaseObject's attributes can now be edited through the ParaIDE as well, this makes changing the mesh name possible in the ParaIDE.
  • function lists can now be displayed and hyperlinked in ParaIDE's script editor.


  • Bug corrected: IMEedit box's Chinese input will not leak English characters to the control.
  • TODO: Current bottleneck is character skinning and character rendering. When there are over 10 characters, the game just slows down. mesh LOD and cheating skinning or hardware skinning is the solution.


  • Implement automatic instancing in the render pipeline, so that grass can be created in super large qualities. Automatically use instancing rendering technique when the number of objects are over 10 in the same frame. ID3dxMesh::DrawSubMesh has been rewritten by me. See StaticMesh::DrawSubMeshEx(); The render pipeline will use instancing if vertex shader 3 is discovered. Right now, asset batching is reenabled for all render lists. Asset batching now has higher piority than camera distance in the sorting function, see SceneState.h A template RenderList() function is written to handle all rendering in sceneobject.cpp. All static meshes, big or small, including shadows will use instancing by default.


  • client/server classes of enviroment simulator are added.


  • NPL network layer registeration and account management have been added to ParaIDE and tested on two machines via a local network.
  • Ocean shader ocean_water_high.fx is implemented and used as the default shader. In the new shader the following changes are made: (1) bump mapping is always used. (2) surface normal is now computed per pixel, instead of per vertex. (3) specular light works better at night. (4) specular cliff is disabled. (5) a number of performance optimization is applied. (6) reflection map above and below water shift distance is decreased,since the wave height is decreased. I find that with alpha blending at the shoreline, the above and below camera shift is not quite an issue, it sometimes gives a shoreline effect.
  • A bug of bump map in ocean shader is corrected: we need to use bumpmap.xzy as the world normal,instead of


  • AI script editor in ParaIDE is completely finished. One can now look at the property of a character in ParaIDE. And add and edit its AI events using the property window. To edit the script, open and close the dropdown list. The script file will be opened in the script editor, which is also implemented in ParaIDE. By editing the config/predefinedAiEvents.xml, one can add predefined events to be displayed in the dropdown list of a character' AI event property.


  • Property Grid control in .Net can be fully extended, I have used it create a drop down list for all AI character events(attributes).
  • All ParaEngine related attributes have been moved to ./config/*.* directory. One can use GetCurDirectory() to get this directory.
  • I am considering publishing the book in O'Reilly or Springer. But the proposal reviewing process is kind of strict.


  • NPL Editor is implemented in ParaIDE with a syntax highlighting rich edit box.
  • I run into the problem of text Encoding when reading text script files in to .Net. my current solution is to assume Encoding.Default encoding for all files, and open and write using this encoding. At least it works for all script files written on the same computer.


  • ParaAttributeObject have been ported to managed API interface. For an example of usage, please see ParaAttributesWrapper class in ParaIDE.
  • Most ParaEngine objects which implements the IAttributeObject now has a wrapper class in managed environment. see ParaAttributesWrapper.cs. The class also contains a function to automatically generate C# wrapper code for a given ParaAttributeObject. However, human intervention is still required, such as for field containing special editor(such as file), or special position data, or field whose name contains ' ' letters.
  • TODO: in ParaIDE, there is a potential bug,when binding object to the current object. The bug occurs when user try to edit a deleted object's property from ParaIDE. However, there is no quick patch for it, so it will depend on the user's knowledge on this. see. menuItemProperties_Click() in SelectionTW.cs


  • All terrain textures can be retrieved and replaced dynamically through the scripting interface.
  • ParaIDE now has a terrain attribute form, which can be accessed throught menu:modify->terrain tile... It allow users to edit the terrain at the current player's position.
  • FreeImage DLL and its .net wrapper is used by ParaIDE for loading DDS file in .net environment. The DLLs are put in ParaIDE/DLLs folders. Please see FreeImage.cs in ParaIDE (I have added a function called FromFile() which is used by TerrainAttributeForm.cs). It seems that the FreeImage open source project is so powerful to handle a variety of image files, including PSD files.


  • sky box can now be changed dynamically.
  • terrain shadow will not be enabled when the it is at night.This should be removed when local lighting is enabled on the global terrain.
  • ParaX converter is done in ParaIDE. Any old format model file can now be converted using the specified encoding.
  • three particles and their textures have been ported.
  • TODO: shall we use other bone names for hand and shoulder attachment points.


  • ocean fog and ocean shader reimplemented.
  • loading screen implemented in ParaEnginCore.h as well as the scripting/ide/LoaderUI.lua. LoaderUI functions can not be called during render;
  • Known Issue: there is always a fog color back buffer displayed when rendering reflection map in full screen mode under debug version of directX.
  • When character moves from water to land, it will now change from swimming to running as long as its head emerged.
  • TODO: implement AI in ParaIDE
  • TODO: implement NPL debugging services in ParaIDE.
  • TODO: inplement two sets of simulator from a common base class. The first is for sever simulation; the other is for client simulation.


  • water wave height is changed to 5. The animated ocean surface normal map is added. Nvidia DDS and normal filter tool is used to convert bump(height) maps.
  • TODO: terrain local lighting: add another pass for local lighting using alpha blending.
  • TODO: increase ocean reflection speed by using terrain LOD.
  • TODO: LOD and portal may be loaded in the near future. It seems that an engine with LOD delivers very smooth frame rate, as seen in the game Fable 2005.
  • TODO: implement a new light-weighted ocean surface without shoreline and reflection?


  • prodecural ocean shoreline wave is implemented, but the result is not good. it is not used.
  • Add ripples on the ocean surface. Ripple texture is made, which resembles the one in the game Fable 2005 by MS and lionhead.


  • TODO: infinite number of 3D sound support.
  • TRAINING SESSION 1: Wang Tian (1:10pm-1:50pm) "Sound Editing in ParaEngine using XACT"
  • Read the RADICAL art pipeline: TODO: we need to build a similar one.



  • hardware occlusion query for ocean is implemented.
  • particle system reviewed. billboarding bug is corrected.
  • shoreline is implemented in the ocean engine. 36 terrain tile which has the same size of the ocean tile is cached.
    the shoreline is enabled by default,currently it can not be disabled.
  • shoreline texture and transparent shoreline is implemented.


  • changing skin is supported for ParaX model.
  • The flatten terrain filter will flatten the terrain using the middle point height, instead of the lowest height.
  • C,F camera key is disabled


  • a follow controller bug is corrected, where now CMath::ToStandardAngle now retuns within constant time. The follow controller will face the same direcion as the target character.
  • The simulation bug is corrected, where the adjacent tiles are returned using the exact character position instead of the center of its container tile.This ensures that any two pairs of characters are equalavent, no matter which one sensed the other first.
  • GUI AttachTo3D() is re-implemented. It uses names instead of pointer to 3D objects. At the beginning of each frame, it decides which GUI objects are visible according to whether the attachment point is visible.
    when the camera moves, edge of 3D GUI are clipped. I do not know why. However, when object stops, the display is correct again.
  • global timer is re-enabled. Attached ParaX model are animated using global timer.
  • editing mode is edited in ParaEngineSettings.
  • four AI templates created in ./script/AI/templates/
  • headon_speech is implemented for character speaking and head on model display.


  • TODO: BVH file for exporting animal models is not working as expected. I have tried many means but can not get the chest and hip bone to the right position in 3dsmax's biped system. Yet, most animal models use a similar bone structure like the horse, which differs very much from 3dsmax biped hierachy.
  • character density decides how fast an object will fall down. So we can allow player to dynamically adjust density to change the behavior of flying or swimming object.


  • my book "Design and Implementation of a Distributed Game Engine" is finally finished, including cover designs. A Da Vinci World appendix is added for teaching the game engine.


  • the density, physics radius and scale can now be saved in the character database. The above parameters can also be saved in the item db in the reserved fields when the item type is character.
  • Character(created as global or local) will be automatically renamed to a unique name during creation via script.


  • TODO: Intro scene
  • Mount mode and object switching system "O" key need to be brought explicitly to the UI.
  • mount mode selection toggle is done. Referenced object functions are exposed to NPL. TogglePlayer() is exposed to NPL. Object switching is now intelligent. For example, when on the car , "O" key is only switching between mounted object and mount target.
  • 3dsmax exporter now sorts transparent material.
  • when the speed of the default animation of an animation now works OK.


  • Characters now have a movable region bounding box. All Characters that have not set this are subject to the global bounding box.
    GetMovableRegion(), SetMovableRegion(): currently it sets the global movable region of the character.
  • Video movie recording UI is improved, so that the last codec setting can be preserved in ./screen shot/codec_options.bin
  • cursor is correctly rendered and captured when recording GUI in AVI mode.
  • mouse selection is improved by using the physics engine if available. children can tolerate a certain degree of selection of failure without losing confident.
  • TODO: More detailed performance switching should be added, such as disable reflections of ocean rendering, etc.
  • TODO: the title should be changed to something more sounding. Can use popular words or movie titles.


  • The biped simulation now supports density attribute. Note water density is 1. And air fly density threshold is 0.5.Object density can be set from ParaObject.
  • KidsMovie install shield system is set up.
    • Installshield: File or directories containing chinese characters can only be installed under Chinese language settings.
    • Installshield: every time to release a product, use the release wizard. Specify Chinese language
    • Installshield: shortcuts and dynamic links can not be edited in version 12. This is very strange.
  • TODO: Release Notes: the terrain textures should be redirected. The character DB should be removed in future version. The spell particle systems should be replaced by ParaX file.


  • Sqlite 3.3.7 and luasqlite 4.1 updated.
  • sqlite3_open() can open file with directory containing chinese characters. Sqlite3 uses UTF encoding.
  • exit and return button is now confirmed.
  • when clicking enlarge, character should not change focus. character rotation around the y axis is enabled in editing mode.
  • when enlarging characters, also enlarge its physics radius.
  • Auto save should pop up a dialog asking whether to save or not. -- no need to add.
  • Tooltips is now displayed just below the cursor and always shows within screen. Tooltips is added to item list bar in Kids Movie demo.
  • PasswordChar implemented for Editbox. It can be used to input passwords in GUI.


  • Testing with two 10 year old kids: one girl and one boy both have former gaming experience.
    • children loves underwater world and sky world: anything that is unreal. Children derives most joy from simply letting these unusual things happen according to their will and manipulation.
    • puzzle is OK by children.
    • "girl" suggests that we can design tasks to delete "haixing" on the ocean floor to practice using the system. "girl" suggests a pet system, where each pet has a unique character, such as some can fly, some can swim, some can split and move swiftly. "girl" suggests a white board to write words on. "girl" suggests that a map system is not necessary. Although, she keeps getting lost even in a small place "girl" suggests a home point, to which she can be transfered immediately with the click of a button. "girl" suggests two people driving a car. Character should be wounded when falls down, or it needs special armor when underwater.
    • "girl and boy" does not express interest in modifying terrain.
    • "boy" loves tank, plane, ship. "girl" loves cute fish, cat, etc. "boy" loves enlarge models.
    • children just interprete depects in their mind with something meaning and quite enjoys it, such as body through body, body inside mesh, etc.


  • when GUI object is reference counted, the default container should reference the default scroll bar, so that when the style of default scroll bar is changed, so does the container scroll bar. Right now, we clone the scroll bar. So the only way to change the scroll bar style of a container is to set the default scroll bar style before any container object is created.
  • Cursor texture hotspot can now be changed through script.


  • reference architecture is implemented. The CBaseObject now derives from the IRefObject class. It can handle bi-directional references. when objects are deleted from the scene, the engine ensures that all references are informed. This gives the bi-directional reference a chance to remove a reference to a to-be deleted object.
  • The character mount system now utilizes the reference architecture.
  • whether an object is sentient has nothing to do with whether it is referenced by other objects. However, if an object is sentient, all its referenced objects are at least simulated by the basic path-finding algorithm and automatically updated in the container tile when their location changes.
  • GetNextObject bug is corrected. It will return NULL, if there is only one object left.
  • Default terrain texture of the empty world have changed to and, where the is RGB format. since both main and common texture are multiplied, it does not matter which one is grey scale image or both are color images.


  • canvas screen shot can be taken at any resolution and from the selection bar in the ParaIDE.
  • camera now has an explicit first person sub mode, when the camera is close enough to the object.
  • player asset and ocean infor are now saved in world attributes.
  • when character is deleted, it is also deleted from the database.
  • we can now take control of characters.
  • we can now use filters to select scene objects in kids movie demo, such as light, global objects, mesh objects,etc.


  • Camera is changed a little bit: when camera zoom-in close enough either because of user request or physical request, change to first person camera view. TODO: when camera object distance is very close, we should apply an alpha to the entire object.
  • In ParaX exporter for 3dsmax 8: the initial pose and the mesh pose before the phyique modifer is applied, must be the same. In some models, the artist may accidentally change the mesh pose when binding physique to the mesh. Although this does not show problems in 3dsmax display, the 3DXI can not adopt the correct initial pose.
    1. dxi only uses the mesh pose before the phyique modifer as the initial pose. So any transformation to the mesh after physique modifier is applied is lost during exportation. This explains several mesh animations being wrong after exportation, such as the purchased models from Olways.
  • drag and drop of the asset and selection bar are implemented.
  • we can now toggle GUI on and off.


  • Add global ParaEngine event handlers and expose to both scripting, API interface, and managed API interface. Managed API interface are exposed as multicast delegate in the EventCenter class of ParaEngineManaged class.
  • Two types of event firing is supported:(1) Fire event immediately, similar to SendMessage in Win32 (2) Pose Event, which return immediate without executing the event handlers. similar to PostMessages in Win32 Since event raisers and event handlers may be on the same thread, PoseEvent is there to prevent interlocking of program code.
  • events are categoried by types, see PE_types.h, events_def.h. There are also some predefined events in Predefinedevents.h.
  • SelectionToolWindow in ParaIDE are implemented through the new managed event handeling interface. Whenever the game engine changes selection, the plug-in interface will receive an event and in the event handler, we will update the GUI of selection.


  • Application settings are implemented in ParaIDE. A recent world list is implemented.
  • TODO: It seems that since 3dmax8, transformation of the biped root node is not exported
  • TODO: multiple threaded architecture has been proposed in one of the DirectX technical article.
  • integration of database and ParaIDE.


  • non-addctive terrain layer sharder implemented.But it is still problematic at the tile border.
  • new world, load world have been implemented in ParaIDE.
  • game world can now be created in any directory of the SDK root dir.
  • ParaEngine Event Center is implemented. Event handling of both GUI, editor, and 3D are defined in a single place.


  • sqlite for .Net framework 1.1 is finished and implemented with xceed.grid. See ParaIDE. there are two dll dependencies: and sqlite3.dll, all of which should be put with the main executable file. there is still another open source 2.0 implementation for sqlite. I will move to .net 2.0 when vs2005 is used. Sqlite only support file level concurrency.


  • Selection and property window implemented in ParaIDE.


  • so far, there are three external programming interfaces in ParaEngine: NPL scripting, C++ API interface, and managed API interface. both NPL scripting and C++ API interface are thin wrappers of the ParaEngine CORE API. The managed API interface is, however, a managed wrapper of the C++ API interface.
  • I have build three plugin samples under the ParaEngine Plugin/sample/ directory. They are using standard win32 DLL, MFC DLL, and managed extension C++(.NET), repectively. for mixed dll reasons, only the first two can be debugged using visual studio. visual studio will crash whenever debugging plug-ins written in managed extension or mixed mode C++. I have followed (tried) the standard procedure of writing mixed mode DLL as documented in the microsoft support website: // see;en-us;814472. But the result is just the same. so Instead, I simply compile it as multi-thread dll and link with MSVCRT. However, there is a major flaw with visual studio 2003 and .NET. I will need to wait for the next release of .NET or VC to solve this problem. Also, I have not tried if visual studio 2005 also crashes when attaching to the main process. Moreover, EEFileLoadException first chance exception is thrown whenever debugging C# method from C++. This only occurs in debug build. One can google EEFileLoadException to know it. (I consider it a Microsoft bug.) It appears that I may need to expose C++ API through the COM interface.

  • ParaEngineManaged project is created. it exposes both NPL and IDE interface for pure managed applications. currently, ParaScene, ObjectEditor and a few other classes and helper classes in NPL are exported to this DLL.
  • ParaIDE project is created. It is written in C# referencing ParaEngineManaged. It is much like the world/game editor application.
  • ParaAllInOne project is created. It is written in mixed mode C++. It is a simple ParaEngine plug-in that simply loads the ParaIDE. To activate the plug-in, just click menu->game->function2. See function2.lua for more information.
  • ParaIDE uses xceed controls for ease of developing C# UI controls.
    Remember to register an authorized copy of the xceed componets before releasing ParaIDE in the public domain.
  • ParaEngine SDK installation has been upgraded to use install shield 12. It will now install xceed components in the global assembly cache on the target system. ParaIDE layout XML file is now included in the installation of the SDK.
  • ParaIDE: File based asset management and favourite system have been implemented in ParaIDE.


  • the following API have been exposed: everything in ParaEngine information center, File IO.
  • database interface can now return the last inserted row id.


  • Implemented ParaEngine Plug-in architecture. They can be accessed via NPL.load("*.dll") and NPL.activate("*.dll", ""); It allows developers to extend ParaEngine using dll. Any programming language is supported such as C++ or C#. All script functions have their C++ API counterparts, which enable plug-in developers to access the game engine from their own laugage environment. samples of plug-ins can be found at ../ParaEngine Plugin/samples/Helloworld
    most of the API are not thread-safe. so if the dll uses a separate thread, it must not call anything to the game engine.
  • TODO: A special object called CModifier can be extended through the plug-in interface.
  • DONE yet untested: texture sequence. we can now control the all attributes of the animated texture from the scripting interface. Basically first Load the texture using LoadTexture(), and set the animated texture properties using the ParaAsset object.


  • 3dsmax exporter UI dialog implemented for all supported exporting type.
  • full screen glow effect can now be paremterized in sceneobject's attributes.


  • BVH serializer is implemented for exporting animation to BioVision Hierarchy file. The biped class exposes a function called dump BVH animation. When it is called. currently we support all traditional BVH nodes, as well as those supported by 3dsmax 8, such as Chest2, LeftToe, LeftFinger0, etc. we also allow the position of Hips and Chest node to be arbitrary in mesh bone hirarchy. i.e. the chest bone can be the parent or sibling of the Hips bones. in order to use the exported BVH file. First create a biped in 3dsmax 8 or above, then load the BVH file, save the animation as bip file. open or create your character, load the .bip file to the biped of your character. And it is done, 3dsmax will automatically fit the animation in .bip file with your character bone structure. please see CBVHSerializer::SaveBVH() for more information.

  • TODO: Implement model group. Allowing groups of objects to be exported from 3dsmax and imported to the game engine. Objects can be moved in and out of group. Group can have the following method
    • visibilities
    • position and rotation. Object inside a group can still be moved independently, since all objects still use absolute positions. Once the position of a group is changed, it will recursively update all sub object positions. Rotation is a little bit tricky: sub objects shall all rotate using the center of group as the pivot point. the bounding box of group will automatically change as objects are added or deleted from the group. TODO: how to change BB when object moves or reattached? in the old days, when object changes position, they are reattached to the scene. each object can be assigned a group container.
    • group may contain other groups.
    • group can create instance of itself.
    • there should be a setting for scene picking that select group first/last.
    • group has a property called : IsEditable. so that some portion of the scene is not editable.

  • BUG: sequence controller under low frame rate seems to be wrong
  • TODO: reflective mesh should be at any height of the model.


  • Model exporter: Body attachments are supported through special bone names.
  • Light map intensity is supported.
  • Add model canvas in both 3d and 2d. Supporting the following behavious: rotation, pan, zoom, zoom all. the 2d interface contains a pointer to the 3d interface object.
  • supporting highlighting in both 3D and 2D interface.
    • 3D highlighting use a special effect file as well as an arrow mesh to indicate the selected 3D object
    • 2D highlighting will use a blinking circle border to indicate the selected GUI object.
  • both ParaX and static model can now be attached to the character using AddAttachment method.


  • If a static mesh object name begins with "g_", it can be retrieved by GetObject(); currently, renaming an object after attaching it to the scene is dangrous, because when people use the GetObject(), it may return a renamed and deleted object. The good practice is that never change an object's name when it is attached to the scene.
  • Animated textures with transparency supported: multiple texture files. Please see the max exporter for more information.
  • TODO: how to bind static physics with animated ParaXModel? Currently, we need to create two seperate models.
  • TODO: making a world non-persistent by a boolean attributes
  • TODO: register a timer which will automatically unregsiter itself
  • TODO: provide a fixed function draw method for selected mesh effect.


  • ocean bump map added. but not implemented to full scale
  • tranparent mesh ending with file name ending with _t is rendered after all meshes have been rendered.
  • character mesh ending with file name _s will always be created as local animated mesh.
  • Bug corrected, local mesh names are accidentally attached to root tile, it has been moved to the tile container. However, it seems OK to use a separate hash table for other named local objects.
  • the normal mesh effect has a normal_low version which is for shader 2.0 computer as well as ATI X1300 below cards.
    It is very strange that multi-sampling and looped lighting are not supported on ATI X1300. It just runs very slowly on these cards.
  • In the config.txt file, we can now specify the start up game effect set to use.


  • Selection manager is implemented. Selection Shader is implemented for rendering selected mesh.
  • attribute object doc under ./temp/doc is added to doxygen


  • 3dsmax 8 exporter triangle winding problem is solved from converting from CW to CCW.
  • 3dsmax 8 exporter light map restriction are now removed.


  • scene name can now contain blank spaces.


  • light map supported(see the shader simple_mesh_normal_tex2.fx): it must be specified as bitmap in the reflection map of 3dsmax. The exported texture file has the same file name as the diffuse map plus "LightMap".For example, the diffuse texture is "", then the light map will be ""
  • 3dsmax exporter now supports exporting multiple UV sets, such as for light maps. Using multiple UV sets usually result in more duplicated vertices. So it is not advised to use extensively.


  • TODO: when switching input method in 3dsmax 8, the application crashes. Maybe this is due to the wrong 3dXI patch. Or unicode?
  • implementing attachment points in 3dsmax exporter, both for reconfigurable attachments and static attachments. reconfigurable attachments may use some predefined bone id.
  • "_m?" alignment type now works with "_m?" parent window.


  • four middle positions added for the GUI. Position calculation code is simplified.
  • Container boarder defaults to 0. Object name of GUI can not exceed 255.
  • SetText and GetText method of GUI have been moved to CGUIBase
  • sentient radius can now be modified on a per object basis.
  • In order to set an object to always sentient, it must be made sentient at least once either by event triggering or script attribute.
  • press F3 to inspect the GUI object at current mouse position. GUI object inspector added in NPL.load("(gl)script/ide/GUI_inspector_simple.lua");
  • scene picking code can not pick different kinds of objects using the given filter functions.


  • the shadow shader is reimplemented. mesh file ending with "_r" will be automatically rendered using the shadow shader. the bounding box of shadow mesh is only taken in to consideration when it is near the camera position or has a big viewing angle. To increase shadow mapping quality, it is advised to use several small shadow receiver meshes instead of one large mesh, since the bounding box of all shadow receivers play a major role in shadow mapping quality.
  • design a flag to turn off terrain rendering (shadow on terrain, empty aabb of terrain?)
  • transparent texture file now has threshold at 0.5. however the texture breaks at closer distance.
  • object can now print its attributes to file at temp/doc/*.txt.


  • when fog is disabled, the sky mesh will not blend fog to it, which allows distant objects to be environmentally mapped to the sky box.
  • cubic environment mapping is supported by the 3dsmax exporter and ParaEngine.
  • TODO: the cubic mapping works well except for a small range or camera angles. I do not know why.
  • TODO: we need to separate model with environment mapping or reflection mapping in to a different technique to simplify the mesh shader. Currently a universal shader with boolean switches are used.
  • the scene manager now uses two light switches. One is for sunlight, the other is for local lights. When sunlight is disabled the diffuse color component of object will not be affected by the sun color.Yet the ambient component still changes with the day time.
  • object scaling has been unified for both character and mesh object.
  • object attributes such as billboard and shadow receiver are added to the base class.
  • if the asset file name ends with "_a", it will have no physics, even bApplyPhysics is true. For example. "grass_a.x". Some other special file endings are listed below
    no physics "_b": billboarded and no physics "_r": mesh is shadow receiver.


  • Mesh Billboard is added. any mesh model file ended with "_b" will be treated as billboarded.
  • TODO: how to currect the bounding box of billboarded object. i.e. ViewClippingObject.


  • bug corrected: can not perform character scene picking when the scene is empty.
  • AddHeightField() method is added in the ParaTerrain. We can now apply any height field not larger than 129*129 from a disk file to a terrain location.


  • CMirrorSurface added. We have add any reflection surfaces to the scene
  • Reflection map, environment mapping, normal mapping, are now supported by the effect system. the ParaEngine 3dsmax exporter supports all the above texture maps for the static paraxmodel.
  • For reflection surface: I just assume the reflection surface is centered on the world origin of the current rendered object and texture sampler is on s1 register. if there are multiple surfaces, we choose the one closest and below the camera eye.See EffectFile::EnableReflectionMapping() and CMirrorSurface::SetPosition() currently it only supports horizontal surface.Vertical surface and arbitrary surfaces may be supported in the future


  • three custom attributes for the camera is added: near plane, far plan and field of view. please note, as the camera radius doubles, the area ( both terrain and meshes) quables. so it will slow now exponentially. Make sure to set the fog end range accordingly or use the GreatView modifier on the camera object.


  • local light object is added. Light score is calculated differently. Light objects are persistent during scene saving.
  • the base object now exposes interfaces to transform itself.
  • up to 4 lights per object in shader.
  • CSphereObject is added, which is a special CBaseObject. The CLightObject is derived from it.
  • a number of attribute regarding local lights are added to the scene object.
  • script to add lights are added.
  • TODO: add light mesh helper model to install build
  • character models such as COW and SPIDER's transparent texture now work properly.
  • object selection is optimized: (1) high-light using shader the selected object. (2) light source picking should be optimized
  • add transparent texture support in 3dsmax exporter.
  • TODO: when alpha blending is enabled, alpha testing should use a lower threshold than without blending.
  • TODO: why I am getting warning from output: Direct3D9: (ERROR) :Not that many BOOL constant registers, where there are 16 boolean registers, yet I only used 5.
  • One can enable the core debug objects so that a mirrored object which contains all of the properties of the object can be viewed in the watch window. Simply include the #define D3D_DEBUG_INFO in your code before the D3d9.h file. i.e. the Dxstdafx.h file before line 37.


  • a bug corrected with shadow map generation, when there is no shadow receivers.
  • alpha blending or transparent textures are supported in model shaders.


  • it takes a high resolution screen shot besides a low resolution one when pressing screen shot key the second time at the same location.
  • script control modifier_control and a sample modifier is created in the script/ide folder
  • Mini dump is added to the main loop. Added in ParaDebug.h. GenerateDump().see also 2006/3/8
  • "application crash when changing effect" is caused by invalid terrain normal array and the problem is fixed.


  • The behavior of ":script" property schematics in script property control is this: when we invoke its editor, if the field is empty then the ResetField() will be automatically called, replace the empty string to its default value, and then open with the editor.
  • GetSchematicsType(), GetSchematicsMinMax(), in the scripting interface and CAttributeField class. Now that, we can integer script control can get the min, max from the property schematics
  • Add (transformation|physics, etc) modifier (3D position, snapping, facing, 3D rotation, scaling) and implement IAttributeField that we use modifier object to modify object. this is similar to 3dsMax's modifier stack. In fact, doing modifiers in script is a better idea. some modifiers may have user interfaces and others may not. Such as, - by applying a terrain texture modifier to the terrain object, we can change the terrain theme to some predefined settings. - by applying a effect modifier to the scene, we can change the global scene effects. - by applying an AI modifier to a biped, we can immediately make it an NPC wandering backforth between two points, (with GUI to specify the two relative points.) - by applying an transform modifier to a mesh object, we can change its 3D position, snapping, facing, 3D rotation, scaling (using affine matrix.) Eventually, there may be tons of modifiers to different kinds of game engine objects. And people can use NPL to develop third party modifiers for their own game's needs. Basic Design: (1) a global list of modifiers from which modifiers are instanced.Once a object is selected, the SDK will try to build a subset of applicable modifiers from all registered and active modifiers. _Modifiers= {} _Modifiers.RegisterModifier(name, class) _Modifiers.UnRegisterModifier(name) (2) for each modifier, the following static and member function should be present static bool CanModify(object) , which is used to build a sub set of modifier which can be applied to a selected object. Modifier new(object), instantiate a modifier by supplying a object being modified, if CanModify(object) is false, this function will fail.
    it stores the object which is being modified by the modifier. DoModifier(), apply the current modifier settings to the current object. and save the last settings for restore. UnDoModifier(), try to restore to the last setting

ShowGUI(x,y,parent), this can be nil or a function to display GUI of the modifier. UpdateData(), retrieve settings from the current GUI, and save the last settings for restore. (3) Advanced users can derive any type of Modifier in NPL and register them in NPL. (4) Although we keep a temperary(non-persistent) history of modifiers in a stack, all modifiers are supposed to be applied to the bottom object. hence the order in which modifiers are applied may affect the UNDO operation. We do so just for simplicity, since we do not want to generate a new object whenever a next modifer is applied to the last object.

  • TODO: Do I need to have a pattern for creating new objects in the GUI. In case, we have more kinds of objects to be put to the scene, an automated process may be better. But it is not of top priority for the moment, since I have only a few kind of general objects to be created in the scene.


  • Once a persistent NPC is made unpersistent and saved, it will be deleted from the database.
  • bug corrected for script common controls, when scene is reset.
  • bug corrected for movie render target and depth buffer format unmatched problem: the shadowmap, glow effect, movie surface and GUI now handles the current size of backbuffer and buffer format.
  • bug corrected when reloading scene, visiting bipeds are all cleared.


  • On Load script logic: the onload script is moved from the biped object to the IGameObject. an attribute called m_bIsLoaded is added as a member of the IGameObject. Besides, providing a manual function, there are several different schemes to automatically execute the on load script. (1) execute it whenever the IGameObject is attached to the scene, isGlobal==true and that m_bIsLoaded = false.          (2) execute it whenever either onsentient, onperceive, onclick event is raised and that m_bIsLoaded = false. I think the best way to do is to execute both schemes. and use the m_bIsLoaded field to choose which scheme to use in script. for example, if one does not want to load a script simple set m_bIsLoaded to true, then attach it to the scene, finally set m_bIsLoaded back to false, so that the on load script will still be loaded when onsentient,... event is raised.
  • In order to implement On Load script logic: On_attached and On_dettached callback is added and implemented in IGameObject.
  • implement the schematics and UI for 3D position, color, [TODO:file], script UI.
  • The script control can be reset to default value by enter space " " in the UI.
  • add a way to reload an IGameObject's script event handler. This allows the game engine to change AI behaviors at runtime. solution1(Not implemented): NPL.load() should [by default?] compare the modification date with the last loading time to decide whether a file need to be reloaded. solution2(implemented): this can be realized by using the OnLoadScript and IsLoaded property. Use NPL.load(file,true) in OnLoadScript and set IsLoaded to false. this will cause the script to reload, and then set the OnLoadScript back if necessary.


  • attribute schematics: All simple schematics start with ':', they are mostly used in script.See CAttributeField::GetSimpleSchema();
  • most script GUI windows are made invisible instead of deleted.
  • Attribute fields data provider: it is a group of attribute stored in {name, value} value pair fasion in a single database table. The db table does not define the name, hence a table in the database is very similar to an intance of Iattributefields in ParaEngine. To be extensible, the table record has the following format: {name(prim key), InstanceName(indexed), value, type, description, schematics} in other word, the database table provides a serialization of IAttributeField (all fields are persistent except get/set function address).All instances sharing the same ClassName are usually stored in the same db table. In case of a singleton, we can default InstanceName field to NULL. e.g. game world class may store global information for a game in the database, such as the spawn points, last player position, etc. Besides, serializing IAttributeField class, the data provider should also expose methods to add and remove dynamic fields.
  • the attribute database is used when loading and saving game world, making player position persistent. see script/kids/loadworld and saveworld.lua
  • DoString() added
  • Property control now support color control; attribute field with schema ":rgb" can now be properly displayed and modified in Property control GUI. e.g. see the SkyColor and FogColor attribute in the GUI.
  • in 3dsmax, we can rotate entire biped using a control dialog in the biped IDE; however, bones with IK chain need to be manually rotated.
  • build the two WOW demo worlds TwoWOWdemoWorlds.rar, as well as character position change function; we can modify and build demos on the existing WOW worlds. demo requires four big WOW *.zip resource files.
  • ocean attribute field is implemented. The ocean color can also be changed.
  • TODO: preserve water level in single terrain.


  • TODO: add comments and comment UI to all attribute fields. How to build multi-language solution? Using external help database, such as CHM?
    string data provider: we can set current culture ID of the string data provider once and for all, so that everything that the provider returned subsequently will be in the given culture. record in dbTable(cultureID) may has the format {stringID, content}.
    build a program that automatically search for all chinese strings in script files, and build a mapping or highlighting on existing files, so that duplicated strings only appears once; then replace strings with another language.
  • TODO: add edit mode flag, which enables or disables querying of attribute fields to various sets of game objects.


  • the attribute fields have been applied universally in the game engine to scene object, camera, sky, paraengine settings, global terrain, terrain object, etc.
  • sky color can now be modified only rendering with shader.
  • bug corrected: when press update on the property window of scene object, the scroll bar size is not correct.
  • bug corrected: sometimes a scroll bar in a container just seems to attach to the root scene for no reason.
  • all NPL sCode is now run in protected mode with better error reporting in log file. This corrects runtime errors when error occurs in sCode.


  • TODO: there is a program called LuaEdit at it can be used to debug lua program with break point.
  • shadow on object shader is developed but not used, because the effect is really a crap for global outdoor scene. However, the code can be enabled by defining SHADOW_ON_MESH macro in effectmanager.cpp and staticobject.cpp
  • the reset and InvokeEditor is now implemented in the Iattributefields interface.
  • IGameObject's event can now invoke external editor for editing On_Click,etc events.
  • the config text file can now be used to specified the default script editor when the application starts.
  • Done: on change event should work with IsModified flag of edit control.IsModified is set to true whenever content changes, and set to false whenever on_change returns. Also on_change should never be called when IsModified flag is false.


  • the full screen glow effect now can specify blending factor for both the back buffer and source glow texture. By controlling these two factors we can simulate underwater blur effect, as well as HDR effect by approximating the average brightness by the time of day and whether it is under water.
  • The reflection texture now uses a seperate depth stencil buffer with out multi-sampling. Since the multi-sampling type of render target and depth stencil buffer needs to the same.
  • skybox and sky fog are now implemented completely in the sky.fx shader.
  • DONE: window resizing mouse cursor problem.


  • ParaEngine specification is updated in documentation.
  • config.txt is updated. We can now enable full screen mode and AA when application start it will automatically find the best settings for the graphics card.
  • TODO: when start in full screen mode, the terrain tessellation is wrong at the places intersecting the view frustum. I did not figure out why.
  • In order to support back buffer alpha based full screen glow effect, the back buffer selection process now prefers ARGB format over XRGB format.


  • full screen glow effect is implemented. The glow shader is rather universal, which can be applied to any stage of the rendering pipeline. See Gloweffect.cpp.
  • glowness of objects can be controlled by
    • the alpha value written to the back buffer per pixel
    • a global glowness parameter in shader.
    • the filter size: currently two are implemented. One uses 5*5 filter, another uses 9*9 filter. The default is 5*5.

(1) TODO: glowness of objects in ParaEngine is automatically adjusted in the following way. I just hand tuned these values to make them look good.

    • terrain: 0.5 per pixel glowness in back buffer alpha
    • sky: 0 per pixel glowness in back buffer alpha
    • static mesh: 1.0 per pixel glowness in back buffer alpha
    • character mesh: 1.0 per pixel glowness in back buffer alpha
    • under water quad: 1.0 per pixel glowness in back buffer alpha (2) TODO: use HDR tone mapping to correct overly bright scenes. Currently the fog is too bright when glow effect is turned on.
  • underwater effect now uses blur filters when full screen glow is turned on.


  • a protential stack overflow problem with NPL.load() is documented. Right now, NPL will always store the requested file to the loaded file list, before it is actually being loaded. this will prevent the loading of the same file being recursively called. This rule applies in C++'s #include method as well.
  • TODO: onchange of ParaUIObject should only be called when user finished editing either by losing focus or pressing the enter key.
  • both character and static mesh can now be properly managed by property window (including deletion and global/local toggling, etc). supported attribute field type is boolean, string, int, float, vector3 TODO: other type and schema based field should be supported,
  • property window now uses late evaluation, which only update UI binding when it is visible or not minimized.
  • corrected a bug when toggling global/local attribute of an object.


  • visibility group is implemented. see script/common/visibilitygroup.lua
  • property window is partially implemented by script. see script/common/property_control.lua
  • TODO: ParaUIObject:removeALL() should recalculate scrollable size


  • attribute text file can now be parsed by CParaFile. See FileManager.h. template modification sometimes cause visual c++ to generate link errors. Usually the problem can be resolved by rebuild the solution. the terrain onload and config file now uses the new attribute file parser instead of hard-coding with scanf. The new parser is both faster and flexible. Each attribute should be on a seperate line.


  • Both local and global objects search can be treated efficiently. Local object search must specify a 2D location.
  • IGameObject persistency implemented.
  • The SceneObject can now load and save NPC from/to database. Object with the same identifier will not be attached.
  • persistent NPC will be loaded in the terrain's on_load function() after the on_load script is called.
  • character and skin settings are also saved to database in binary format.
  • NOTE: for unknown reason, sql analizer can not open database created by the new version of sqlite3. I may need to upgrade it. One work around is to work on an older version of sql database. The new version of sqlite3 can work with previous db format.


  • NPC data provider is finished. see ./NpcDatabase.cpp
  • Expose data provider interface to script. Data provider are added to the ParaWorld table in NPL.
  • ParaScripting is split into two files due to compiler error. See ParaScripting2.cpp notes.
  • SceneObject::SaveLocalCharacters() to save all modified and unsaved local characters in the scene to the current NPC database.
  • currently all characters are set to modified when created. Character loaded from database is set to unmodified. TODO: How to properly set modify bit at other time.
  • reload world on_load script when a new world is loaded. On_load Script will be called after static scene and NPC characters have all been loaded.
  • when a new terrain tile is loaded, load all NPC that are inside the terrain tile from Database.
  • NOTE: IC is turned off to prevent application exit error.It seems that it is either a bug of sqlite3 or db manager(IC gen, etc.).


  • CSQLStatement is added.
  • TODO: seperate CRecordSet and CSQLStatement. i.e. make CRecordSet a managed list under CSQLStatement and make CSQLStatement a managed list of DBEntity. and make DBEntity a managed list of DBManager
  • NPC database is implemented. see resource./*.sql and /data providers/*.*
  • SQLITE upgraded to 3.3.5. It fixes some bugs that I needed in the NPC database. Now I can use "@name" as in MS SQL.


  • sequence controller: command goto Lable:string is added.
  • TODO:some simple conditions may be introduced in sequence controller. Such as if_true, if_lessthan, if_greaterthan, if_not, if_equal with then() and end() for scoping
  • CICDBManager has been documented and slightly improved.
  • data providers are introduced to the game engine for database data management in the game engine.


  • sqlite3 scripting interface now works with ParaEngine::DBEntity. It allows the C++ programming and NPL scripting interface to share database connections. One of the common mistakes about using scripting interface is forgetting to call db:close(), which will lead to memory leaks of sqlite3. The Lua wrapper depends on __gc function to close a database. However, __gc is usually not called by ParaEngine when program exits. So script writer must explicitly close database or statements in script. if statements are cleared, one can ignore closing the database. Because ParaEngine automatically shut down all db connections when application exits. However if statements are not released in script, ParaEngine will fail to close the associated database and generate db-busy warning in the log file. This usually leads to some memory leak.
  • some minor improvements to CICDBManager. see ICDBManager.cpp and .h
  • RPG character class is implemented for DnD based game characters.
  • RpgCharacter, BipedObject, IGameObject's attribute fields are installed.


  • doxygen updates for NPL class properties. Documentation is now being grouped by modules.Some script examples are also added to the NPL reference doc.


  • TODO:use dynamic branch in PS for fully fogged pixels.
  • HLSL does not generate static flow control for ps_2_x. I do not know why.
  • Most FX files now have a SM2_X compatible shader, except for the terrain.


  • Sequence Controller is implemented for the AI module. Combined with IGameObject interface and a few other controllers, we can now write fairly sophisticated AI behaviors, such as, patroling, guider, following, facing, evading, attacking, dialoging, etc. Basically all NPC logics for a typical RPG game can be built very easily. Sequence controller data can be shared by multiple AI instances.
  • TODO: Adding file and database storage for sequence controller data.


  • [ATI bug Workaround]: ATI card texture problem for shaders may be caused by the following. sampler and texture states are not properly matched to GPU sampler register S#. so for sampler states that will change by the SetSamplerState() call during the execution of shaders, one should explicitly specify sampler registers in HLSL. Moreover, I have no idea who caused the following bug on ATI card (X1300,etc): the behavior of d3d SetTexture and that of the effect SetTexture are different.The effect SetTexture call is totally unpredicatable on ATI cards. It seems to crash when setting multiple times between BeginPass() and EndPass(). The effect's SetTexture can set the shader sampler texture even outside BeginPass() and EndPass() except for ATI card, and d3d SetTexture only works inside the BeginPass() and EndPass() for both Nvidia and ATI cards. In order to workaround the ATI bug, the problem is solved by using d3d SetTexture instead of effect SetTexture(which is preferred); moreover, I have to set ALL textures between BeginPass() and EndPass() of any effect file, this may be inefficient since duplicated SetTexture calls may be called for the same sampler.
  • [ATI bug]: TODO: texkill in PS3_0 simply does not work on ATI card, no matter where I put it. In other words, on ATI X1300 card, anything that compile with PS3_0 with a texkill/clip instruction and static flows will fail to function. This problem does not appear on any Nvidia cards.
  • terrain shader now support 12 simultaneous textures and samplers. But my GPU does not support that much, so I disabled it by macro.



  • shadowmap size is now adjustable.


  • character exporter's pivot is being exported, which solved the wheel animation problem.
  • The ParaEngine Solution will output *.txt and *.fxo (binary) from the *.fx file at compile time. This makes shader optimization more direct. The effect system also loads the compiled *.fxo from now on, which will speed up the application loading time. Always check *.txt file in shaders/Bin_NoVss/ for the coorepsonding *.fx file. This will solve some ATI and NVidia card specific problems, because the optimized assembly code generated by FXC may not be equivalent to the original HLSL code. I guess this is a defect of FXC caused by not following some coding constraints assumed by HLSL branch. Please note: I have turned on /Gfp in fxc compiler to prefer flow control constructs.This will put all boolean constants to b# registers instead of c# registers. So if one wants to avoid flow control, use lerp() explicitly, instead of if-else in FX file.
  • static branch in HLSL effect file is only available for boolean constants in register b#. For this reason, I have to move shadow map flag, lights enable flag, terrain layers flag to several boolean shader constants (I used integers previously). I think, in future, GPU should support more static branch options. Using boolean is very inconvinient.
  • light Attenuation implemented in shader
  • shadow map size changed from 1536 to 1024


  • camera mouse now handles smooth roll back. Camera now uses directX mouse delta.
  • sqlite3's scripting interface, doc and examples are added.


  • when adding and deleting objects, the terrain content will be marked as changed.
  • event systems have been upgraded.


  • the terrain can now generate bounding box information from the last tessellation result. This bounding box will be used as the terrain's shadow receiver.
  • texture 2 is reserved for shadow map. shadow map uses the following sampler: AddressU = BORDER;AddressV = BORDER;BorderColor = 0xffffffff;
  • shadow map implementation in ParaEngine is now stable. All big objects are now potential shadow casters. The terrain's detailed range (30 meters from the eye) is treated as the shadow receiver. Scenes outside the bounding box of shadow receievers will not receive shadows.
  • Floating point 32 is used as the shadow map if the hardware shadow map is not supported. Over sampling is done using a 2x2 square when F32 is used.
  • alpha testing is now completely emulated in shaders using texkill/clip function. There is no performace gain at the moment, since pixel shaders are executed in texture blocks, but maybe in the future.
  • Terrain_normal.fx shadow is too long to be compiled with PS2, I have to use PS3.
  • border color of F32 shadow map is now emulated in pixel shader.


  • Four kinds of shadow mapping methods are implemented. Only TSM and StandardSP seems to be stable.
  • TODO: But LiPSM has much better effect on the Nvidia's PSM sample,however, I can not tune it right in ParaEngine. PLEASE NODE : shadow map texture coordinate projection is done in vertex shader, rather than the texture stage as suggested by the original PSM sample.
  • The entire ParaEngine pipeline have eliminated the use of GetTransfrom(world,...), instead all hierachical renderable objects now uses the game engine's own matrix stack management functions. Hence it makes setting world transformation a simple matter of pushing a matrix to the stack, which unified the interface for both the fixed and programmable pipeline. However, view and projection transformation are still different for the two pipeline.
  • The ParaXmodel can now also be rendered using programmable pipeline.
  • ray, plane, box and vector in the terrain engine now share the same implementation in the ParaEngine couterparts(CShapeRay, CShapePlane, CShapeBox, D3DXVector3). (Macro is used for migaration).


  • movie capture and movie clip management interface are implemented. Everthing is now rendered to texture for motion capture GUI can be toggled on and off during motion capture mode.default mouse is rendered to texture during motion capture when GUI is enabled.
  • screen shot's capture texture is fixed so that d3d texture can be saved to video file.
  • GuiRoot and GUIDirectInput now support rendering image cursor or not. Image cursor is only rendered for video capture with GUI.
  • screen shot can now be taken and saved in jpg or any other file format using the d3dxsavetexture function.
  • codec settings are now in resource file.
  • Demo GUI for screen and movie capture is finished.


  • hardware shadow mapping is added to the pipeline.
TODO: only do shadow if camera moves or the time of day advances significantly since last update.
  • demo GUI interface is updated with new ParaEngine setting dialog.


  • View Frustum Class and CShapeSphere are implemented
  • The scene culling method is changed, which uses the intersection of the bounding sphere of the frustum and the eye centered fog sphere for rough view testing.
  • shadow caster and shadow receiver added, which will render shadow caster's shadows even they are not visible with the current camera.
  • CShadowMap is added.
  • DONE: 3dsmax exporter still have problems for wheel animations.I still can not extract pivot point for any bones. wheel problem can only be resolved when interpolating using the pivot point in ParaXModel.


  • Animation in 3dsmax should be longer than 0.3 seconds to enable motion wrapping in ParaEngine. Otherwise, the imported animation may jerk.
  • terrain_normal.fx shader is written. I changed to addictive blending for all texture layers (this is true for both fixed and programmable pipeline). The PP support 4 to 8 simulatanious textures (according to GPU caps). In case of 8, up to three texture layers can be rendered in a single pass. // terrain texture layers: There are no limit to the total number of terrain surface layers (for performance reasons, I still limit it to 6). // multiple passes can be used if there are more than 3 layers. All color operations are addictive and fog is applied to the first pass only. // Pass1: (base+common)+shadowmap+(alpha+detail)+(alpha+detail)+(bump) // Pass2: (alpha+detail)+shadowmap+(alpha+detail)+(alpha+detail)+(bump) // PassN: same as Pass2 // Shadow map and bump map are shared textures for all passes. // formula I used: <pass0>{(1-FogFactor)*[(base*common)+detail*alpha+detail*alpha] + FogFactor*FogColor} +<pass1>{(1-FogFactor)*[(base*common)+detail*alpha+detail*alpha]}+...+<passN>{...}
  • TODO: local light is not supported by terrain shader. Only per-pixel lighting on terrain can do the job. It is better to use projected shadows to emulate local lights on terrain surface.


  • underwater color will use the current fog color, with a little blue tint.
  • hardware occlussion query is the killer of framerate: the same geometry with occlussion query on is 0.011s/frame, without it is 0.004s/frame. the hardware spend 200% more time in waiting.
  • TODO: hardware occlusion query can only be use for querying results from the previous frames.
  • TODO [must do]: use hardware occlusion query to eliminate ocean and terrain rendering from the result of the previous frame. use shader for terrain. Implemented shadow mapping for all terrain (the major shadow receiver).
  • The effect file and effect manager now support share mode, in which all objects will share the same render pass and technique. The default mode of effect manager is unshare mode, in which render pass and technique is used on a per object basis There is no performance difference for the moment, because all effect files use only a single technique. Share mode may be useful in condition when the first pass is render all objects to depth buffer to establish the depth map, and the subsequent passes are for the actual drawing.
  • compared to other processes of the game engine: the two most time consuming process is scene state building and terrain tessellation and buffer building.
  • Scripting interface for the light and effect system are added: ParaScene, ParaObject, ParaTerrain and ParaEngine(ParaSettings)


  • LightManager and LightParam are implemeted. The game engines now supports unlimited number of local lights in the game world. For each scene object, the game engine will automatically select the best lights which are affecting (near) the object. The number of best lights can be limited to some predefined value, such as 4. The light system supports both fixed function pipeline and programmable pipeline. Light Manager now works with: any mesh object with normals and any character parax models.
  • TODO: Terrain quad should also be supported.
  • TODO: FF seems to have 30% or above speed up compared to the PP I wrote, when light is enabled. I do not know why. even without light, FF is faster. Could it be that my shader is compiled without static branching automatically detected?
  • CViewCullingObject can now be cached in the mesh class by a C++ macro. The macro is not on by default, because I found there is only a 10% speed up for the scene state building module, which takes (0.007sec/frame for a complex scene on CPU AMD3000+).
  • TODO: Some bugs in the ParaXModel exporter is corrected: But there seems to be problems when there are multiple animated meshes. also, a mesh linked to a bone is not supported at the moment, only physique and skin can be used. In future, I may need to support it. The ParaX attachment template includes a Vec3D offset,which will translate an attached object(such as GUN) to the hand position in the figure mode of 3dsmax. However, at the moment, the user must construct the attached mesh and put it to the correct position in the figure mode, this will makes the attached mesh object not reuseable for different bone systems.


  • mesh construction animation shader is made.
  • alpha testing and culling mode can be disable in the effect manager. This is useful for the mesh construction effect:smesh_ctor.fx
  • fog color will change with the sun parameters.
    use a fog table, instead of parametric fog, might have a better effect.
  • TODO:shadow should be turned off at night?
  • construction percentage is added for the base class, and implemented by mesh object to provide construction animation. The managed loader will set all objects'construction percentage to 1.0. thus, only newly created objects have a construction value smaller than 0.
  • the simulation of construction percentage is done in meshobject's draw method. This forces user to watch the object for it to grow.
  • sky mesh will be turned darker at night. Some optimizations: - The effect file supports shared mode: staticmesh class uses effect file. Speed may be accelarated by moving effect's technique and pass to the main rendering pipeline, instead of on a per-object basis. - the effect file by default do not save render state on a per object basis to futher optimize speed. - TODO: Alpha blending can be disabled for objects close to the camera. (Will alpha blending be slow if turned on?) GT6600 card: using FFP is even 10% faster than using PP.The PP only does one more vertex*matrix4 multiplication in VS, and two more static branching in PS. But why it is slower than the emulated FFP?


  • the bone calculation has been optimized by manually do SRT key assembling.
  • a bug with WOW character model, where the main body geosets are missing, is corrected. Multiple geosets may have the same main body id(0).
  • missiles are also added to post rendering list and sorted for rendering.
  • the rendering function of scene object is broken into two parts: - rebuilding scene state - rendering objects in the scene state


  • Sunlight class is completely rewritten. The time of day can be changed.
  • character and particle rendering now works with the new pipeline.
  • render state changes are kept minimum in ParaXModel


  • ambient and diffuse mapping regarding the sun color and direction is implemented.
  • Terrain normal rendering can be toggled on and off dynamically. See CGlobals::GetGlobalTerrain()->GetSettings()->SetUseNormals(true); This is a fairly expensive way of rendering diffuse color(looks like self shadows) on terrain. But the effect is not very obvious. Using light map on terrain surface for more expressive shadow effect.
  • make alpha test whenever alpha blend is enabled, this will correct some bugs in WOW models.
  • the user clip planes are implemented for both FF and PF pipeline. See EffectManager(). This enables water reflection rendering with both FF and PF. user clip planes is an issue when managing both FF and PF in a game engine.


  • Ocean, Terrain, Sky, Mesh, Mesh(using Normal) have all been transformed to the new effect pipeline.
  • mipfilter is used for terrain and mesh.
  • sky rendering now uses clamp texture addressing to remove texture seams.
  • Pixel fog and object fading is implemented in mesh effect files. (Fixed pipeline still uses the old fog and no fading effect.) Alpha blending is supported as a global parameter in mesh effect files. [static braching in PS] Alpha testing is supported as a global parameter in mesh effect files.
  • the effect file entity is entended to support all shader rendering used in ParaEngine.
  • an ocean disappear bug currented.
  • zmask bit is turned off. WOW's wmo seems to set this bit on for most models.
  • TODO: GeForce 7 serias supports something called transparent multi-sampling, this is a solution to the rendering of vegetations in ParaEngine, where alpha testing and blending is used. In the new method, only alpha testing is enabled so it does not require sorting the triangles back to front as does alpha blending. I need to buy a GeForce 7 card to try it. Currently in ParaEngine, sorting on triangle basis is too expensive, so I used alpha testing only, with alpha blending for fading effect.


  • The rendering pipeline now supports both fixed programming pipeline and effect files. See EffectManager class. Each CBaseObject is now associated with an effect technique handle.Effect handle can be dynamically mapped to different effect file at run time.
  • hardware occlussion queries now goes in parallel and in batch.
  • the pipeline now first batch post rendering objects by effect handle, and then by either primary asset or object-to-camera distance.


  • ParaEngine's model exporter for 3dsmax 7.0 is finished in version 0.2. It now supports all 3dsmax animation systems and some optimizations for the exported vertices and materials.


  • ParaMovieSite has be constructed using 2.0 + sql. Forums, events, messages, articles, galaries, ParaEngine assets can be accessed and managed through the website or web services(todo). 2.0 certified role manager is used to provide site security.


  • the entire simulation framework is rewritten. It now supports unlimited characters in the scene. The simulation will automatically put unrelated game object to sleep and wake up related ones. The entire 3D event and call back system is rewritten. All simulation results can be retrieved from the script interface and script functions can be used as call backs.The terrain quad-tree logics and C++ AI controllers are completely rewritten to be compatible with the new simulation framework. The simulation pipeline nows keeps no intermediary data, instead all data are kept by the scene objects and on the global quad-tree terrain tiles. In case of a single server, 2000 players with 100,000++ creatures may be in the scene. However, there may only be 3000+ sentient game objects, all others are put to sleep. The simulation complexity is O(N), where N is sentient game objects. Hence, there can be unlimited unsentient game objects in the scene.


  • the quad tree terrain tile class has been reimplemented to support fast neighbour query.
  • when attaching scene object, all IGameObject will be treated as point and always attached to the leaf node of the quad tree. the environment simulator will be able to take advantage of this rule and simply finding objects in the neighouring tiles for collision detections.
  • the base object now stores a pointer to the container quad terrain tile.The ParaObject thus do not need to store this pointer. A number of places have been simplified, such as scene attaching, ray picking, etc.


  • IGameObject is added. The biped object is now implemented through this class. Characters can now react to a number of call back functions, these callbacks are called by the network layer, the environment simulator and per-frame mouse events. User can turn off scene mouse event callback by a special function in ParaScene namespace.


  • static mesh object will now locate textures in the mesh file directory if the texture file contains no directory information.
  • paraX model's database interface is compleltely rewritten using CCharacterDB and IC record set.
  • we can now log all non-unicode sql commands in by defining LOG_ALL_SQL_COMMANDS in ICrecordset.cpp. This is useful for including only used db record in release build.
CCharacterDB : it should create character database when it does not exists. Insert records from Logged text file to character db.



  • asset reloading is now supported. ParaAssetObject::Reload();
  • ParaIO scripting table added a number of directory functions. so that it can perform directory and file listing and searching functionalities.


  • physics can now be toggled on and off.
  • the base object is now fully encapsulated. One can only communicate with it through functions.


  • the scene can now be saved. see SceneWriter.cpp New objects(excluding global bipeds) are attached to the scene, the associated terrain is automatically set as modified. So when a terrain is saved, the on_load script will be automatically updated.
  • the CGlobal class now has a loading state, which is set during long loading such as reading script file from file.


  • Para file interface can now load data from windows32 resources, disk file or zip file.
  • The ocean shader and ParaX templates are now loaded from win32 resource using ParaFile interface.


  • Water Simulation: with reflection and alpha-blended refraction:
it combines the Nvidia's Vertex Texture Fetch with my own FFT based ocean simulation.
  • 3D Scene pipeline can now selectively render objects, this is useful for render to texture operations
  • Sky box has been upgraded to work with the view matrix rather than using the camera eye. This is useful during reflection rendering. The fog triangles now use the default CCW winding.
  • The Ocean manager supports several effect rendering technique, and will downgrade according to the GPU's shader versions.
  • TODO: 'Press P key' to take a snap short of the water reflection texture, SAVED to "E:\reflection[n].jpg".
  • Terrain are now automatically re-tessellated accroding to the camera move state in scene state structure. This makes reflection rendering easier in the rendering pipeline.
  • All objects in the rendering pipeline are post rendered,which allows the effects such as ocean reflection to be nicely fit in to the rendering pipeline.
  • All objects will set their triangle winding CCW or CW, according to the parameter in scene state structure.
  • When rendering reflections: We can not mirror a camera in 3D. And we do not want to mirror the objects (all triangles winding must be reversed.i.e.CCW to CW). My solution: The basic idea is to mirror the camera, rather than the entire world. The camera is moved to the opposite side of the water surface.The camera UP vector is also mirrored. Mirror the position of camera and its up direction, render the scene with the new camera, and flip the X texture coordinate in the image space of the corresponding shader. This solution also makes terrain tessellation easier, which internally uses camera view frustum planes to cull objects. Alternative method: premultiply the camera view matrix(View) with a plane reflection matrix(R). This would cause all geometry(M) to be mirrored when multiplied. M*(R*View)*(Proj). However, this technique requires rewinding all triangle vertex order(i.e. CCW or CW). Also it makes the camera matrix invalid. Hence, algorithms that require valid camera view frustum, such as the terrain tessellation,will need to be rewritten to handle this special case.
  • the DirectX Projection function in terrain metrics calculation is replaced by a shorter version.It is in TerrainBlock.cpp.
  • The global terrain will update a global pool of view parameters duringn each moving frame, such as view projection matrix, viewport parameters, eye position, etc. They are used by all terrain tiles in the frame.
  • CGlobal class now supports matrix stacks for model, view and projection. It provides simulator function in OpengGL's push() and pop() function.
  • use the macros in oceanmanager.cpp for means of the ocean rendering parameters.
  • the ocean manager will default to animating quad texture, when shader is not supported on the target machine.
  • BUG: the ocean manager quad technique has an alpha set according to the view angle. I do not know why. No matter I disable alpha blending,fog,etc. This effect will not go away.


  • TODO: 3D Rendering Optimization:
  • use NX occlussion query(asynchronous). it can issue N queries and retrieve results for each of them.
  • escape occlussion query for the next consecutive N frames, for objects that are visible
  • render Light bounding box for occlusion test, if passed the test, enable lighting. Associate geometry with lit region. Determine if geometry is occluded or not to tell you if light is relevant.
  • Use global matrix stack, rather than D3D->GetTransform(). And possibly combine view and world matrix in d3d.
  • TODO: Rainbow and fog: very easy to implement


  • Ocean effect file is not supported in some system. I will disable ocean rendering in such cases.
  • Terrain alpha texture will default to 32bits if 8bits alpha is not supported.
  • Texture management is updated, corrected some bug.
  • Terrain buffer will not be reused each time. This saves quite some time on some machine.But it seams that the time has been moved to D3D->Present() function.
  • script error messages are dumped to frame based report. Turn on debug mode, to display it.


  • TODO: I do not know how present() functions, by chaning the order as follows does not help parallelism. Is it that the GPU is caching something? DirectX SDK help for Present() functions says it will improve parallism,where it is not that obvious. changing the order of framemove and render, so that the order is. Render(){BeginScene() ...EndScene()} FrameMove(){} Present(). This function is less likely to block.Since by the time FrameMove() is finished, the GPU has done its job, so that Present() can immediately swap buffer and return.
  • UNKNOWN issue: the combination of stencil buffer with the rendering pipeline will generate very unstable frame rate even for the same static scene. The main thing is that the Present() function takes unpredictable time to return.
  • the performance counter is upgraded
  • keeping the most recent MAX_NUMBER items or keeping a user specified range.An attribute to output all data or selected one. PERF_RANGE(name, from, nMaxCount). if from =-1, most recent nMaxCount items. otherwise it is the activation frame number to begin.
  • statistical reporting or per item reporting. PERF_REPORT_METHOD(name, "statistic|per item")
  • associate the global time(mins:seconds) with frame number when reporting
  • calculate the min, max and deviation on the fly.
  • associate the timer with a user KEY event to start counting. PERF_USER_START_KEY(name, KEY_F9);


  • Terrain interface has been optimized both on memory usage and code speed.
  • the terrain now uses breadth first trasversal of terrain quad-tree which is more like ROAM based terrain
  • both triangle strips and fans are allocated on demands.
  • the tessellation, repair and building buffer process have been optimized a lot in terms of code efficiency.
  • NPL can now output error messages correctly to log file during file loading and LUA program execution.


  • Script interface for Directory IO: TODO: This IO should work with ZIP file system. For an example, see the Test button on the object creation dialog.


  • New World can be created according to a given world.
  • object position modification can now be relative to the camera. See the script.


  • terrain detail textures and height field saving. detail texture clearance supported: when saving, empty layer will be removed(optimized). unused textures in textureset are also removed (optimized).
  • TODO: Empty World Generation from XML data.
  • ERROR TODO: there is an unknown error that occurs only when network protected software is installed. Those given to ZJU and the one on our own server. when the sample scene is loaded the application exits unexpectedly, however the startup screen and the GUI IDE works fine.


  • terrain base texture can be any texture size larger than 64x64 and with power of 2 width and height. originally I used 2048x2048 as the base texture, now that 512x512 works just fine. The texture cells are now no longer depends on the base texture size, instead it can now be set explicitly by the CTerrain::SetBastTexture() function. The default texture cells are a grid of 8x8 cells. The terrain base texture are also devided into this grid. Each texture cell is consists of a base texture and any number of detail textures(with alpha maps) Currently the base texture cell and alpha maps are memory textures managed by the Terrain's texture management class.
  • an MSVC8 windows installer project has been created for ParaEngine SDK demo.


  • Microsoft Visual C++ 2005 is supported: See the migration node below
  • MSVC7 and MSVC8 solution and project files are all under source control, and they share the same source code. now the vc2003 and vc2005 solution can work together in source control, provided one do not add or delete project files. I used the procedure
    1. duplicate all MSVC7 project files and rename them to _vc8.
    2. remove read-only attribute and edit the source control file mssccprj.scc to bind it to the new project file.
    3. open and convert the new file using MSVC8 and add only the project file to source control. Hence the source control will have two different project files for MSVC7 and MSVC8
  • all external libs are re-compiled MSVC8 using multi-threaded libray or C/C++ runtime. These include NPL, Lua, Luabind, Sqlite3. libraries that does not use multi-threaded C/C++ runtime are removed from ParaEngine, this include MPQ and JPEG libs. Hence MPQ and BLP support is not available in the new build.
  • all libs for MSVC8 is output to lib_release/lib_msvc8
  • all libs for MSVC7 is output to lib_release/lib
  • luabind produces compiler error for OUT_VALUE(), so I have to remove it and use return value only. See ParaScripting.cpp. The mailing list of Luabind website is giving some updates.
  • use of for ( int i;; ), that i is local to the for loop.
  • enum XXX{abc}; the use of XXX::abc will produce warnings, use abc directly instead. I almost changed every file to make it compatible with the new compiler.
  • All MPQ files have been changed to ZIP archive files. MPQ will no longer be supported.
- TODO: use XXX_s which is the secure version for C/C++ runtime for string, file and conversion functions.
  • some checked iterator bug is detected by MSVC8 compiler and have been corrected.
  • no default static type is possible with MSVC8: static i=0 is invalid. use static int i=0;
  • the ParaEngine core will now use lib in the ./lib_release/lib
  • ParaEngine.lib 's sample application has both MSVC7 and MSVC8 solution files.
  • Now that all ParaEngine and third-party open-source modules are under source control. There is no third-party lib which does not provide source code.
  • asset reference count warning will be dumped to log file in debug build.
  • TODO: I find that OpenMP is usuallly useful for game engine development in multi-processor environment. The new MSVC8 supports it. XBox 360 uses it. I might consider using it in ParaEngine, too.


  • Garbage collector is now supported through the scripting interface. It is better to run garbage collector between scene loading. All ParaScene objects now accurately maintain the reference count of its asset objects. To Increase and decrease the reference count of asset objects, please use the safe macros GRAB_ASSET() and DROP_ASSET() defined in the ParaEngine.h.


  • CParaEngineApp is created as a C++ programming interface to ParaEngine. ParaWorld.cpp is now used as a sample of using ParaEngine's programming interface through the CParaEngineAPP's class
  • the game loop script GameInterface.lua can now be changed dynamically.
  • ParaEngine can now be built to a static lib file. I have created a test application in ../lib_release/samples/. The ParaEngine's static library files are in ../lib_release/include/ and ../lib_release/lib/ When lib build is enabled, ParaWorld.cpp will not be compiled. When lib build is not enabled, the output is a win32 exe created by ParaWorld.cpp.
  • ParaScene.Reset() function has been added, which set the scene to its initial blank state.


  • Virtual System Updated: a replacement to MPQ using zlib. This is a multi-file archiever. Now we support two achiver format: zip file and MPQ file.
  • zip file: zip is a chunked file format. Hence, adding new files to zip file is very fast (just appending). The list file building is read from the central directory at the end of the file.
  • mpq file: mpq is ideal for random file access and is very quick in terms of list file loading. Because it has a hash function and it also has build-in (listfile) as described above.
  • ZIP file is case insensitive.
  • Sky Box can not be created, selected and deleted. The scene will run good without loading a sky mesh. However, a default CSunLight will be created in such cases.
  • all asset interface now uses std::string class instead of const TChar* for string operation.


  • ParaX file is now fully completely.
  • TODO: There are several untested file nodes documented in the ParaXSerializer.cpp, such as the particle system.


  • ParaX's new model definition X file template is finished. ParaX File format: ParaXHeader {...} # all paraengine model files should have this small header, otherwise it will treated like a directX retain model model file. ParaXBody {...} # all model data structures are in this node. XDWORDArray ParaXRawData{...} # raw binary data referenced by structures in the ParaXBody by offset in bytes. {...} # other unknown struct. For more information, please see ParaXModel.templates and ParaXSerializer.cpp both binary and text serialization is supported. both zip-compressed or uncompressed serialization is supported.
  • ParaX model's serialization class is added:
  • ParaXModel and modelheader.h has been optimized for memory and speed.
  • ParaXModel.templates is now loaded as an application module resources.
  • TODO: DirectX's X file has efficiency problems when parsing data field even they are fixed length. this is why I made extensive use of raw bytes arrays for all large continous data blocks. DirectX's X file only treat DWORD arrays as continous memory block. All other fixed length data structures are parsed individually and stored with their data types. So to increase performace during parsing data in the ParaXBody {}section, I may need to write my own X file API implementations, which optimizes fix-length data structures. (as continous memory block, rather then embedding type bytes and separators)
  • The advantage of using X file template is that they are self-explainatory (like XML), and easy for upgrading. and it support both binary and text encoding. XML also has a binary encoding proposed by W3C and SUN corp. but at the time of writing, they are poorly written and only avaliable in Java beta.
  • I decided to use seperate C++ classes for different model types, such as character, static mesh, etc. but I wonder if I should implement through some shared interface, so that all models have animations, etc.
  • TODO: how can I avoid reading the same file from virtual file twice, since the first time I just want to see its header for bounding volume information? Maybe save header info in database base with a date info, and get automatically updated? But this is not a wise solution.


  • event handler is added which can register mouse or key event handler through script interface.
  • ray-picking interface is added to script.
  • object filtering functionality is added, which allows further filtering during ray-picking.
  • scene event registering and unregistering is implemented, which allows the user to handle global key or mouse events from scripts.See EventHandler
  • CBaseObject::GetMyType is supported by script
  • The demo script can now perform ray-picking and modify.


  • Texture Infor such as Width and Height can now be set for texture entities. And people can now create render target typed texture entity
  • TODO: APP built with directX 9.0c december will fail on Asus notebook computer unless some 3D application built by previous DX version is run before it.
  • The ray picking is finished for any oriented bounding box in the scene. For static objects, it is the view clipping's bounding box, for biped object it is the physical bounding box.This is a separate collision detection system from the physics engine.
  • matrix3x3 and (TODO:matrix4x4) implemented
  • shape objects are implemented, including OBB, plane, AABB, ray
  • shape colliders are implemented for Ray and (TODO:AABB). RayCollider will be used for ray picking of scene objects.


  • Terrain filters are implemented:DigCircleFlat, Roughen_Smooth,RadialScale,GaussianHill. And scripting interface are also added for these filters.
  • TODO: We should use a special detailed texture layer to specify what vertices are affected by a certain filter. Right now, the entire terrain blocks are updated.
  • alpha operation of detailed texture is changed to modulate.


  • dynamic terrain height-field modification is implemented. However, caution must be paied when the character is standing on a terrain, because the physics is not automatically updated. Call snaptoterrainsurface for bipeds on the terrain.
  • terrain block generation and tesselation methods are greatly simplified. The terrain approximation plane is not used for tesselation, instead the min, max box of the terrain block is used. However, it rarely simplifies anything, except for very flat lands. The original method can also simplify flat slope. But it is not necessary any more; because such slope is not common anyway.So the approximation plane are not generated any more. In Future, I may choose to render far away terrain with a pre-defined low resolution, and turn off Z-testing and Z-writing during rendering.


  • terrain multi-texturing editing environment is finished. The boarder of terrain tile can be painted properly. The Paint() function for latticed terrain paint on multiple terrain tiles if the splat is on boarder
  • clamping sampling is used for Terrain texture stage 0 for base and alpha textures. This removes ugly seams on borders of the terrain cells.

2005/12/09 TODO list for Kids Education For LWL:

  • UI indicator: telling the user which button to press next. For building those tutorials.ParaUI.highlight("name", ParaUIObj);
  • GUI painter: like paint brush;one can select a specified pen and color to draw on a surface,which can be saved to disk.
  • Path roll-back system
  • Sound recording system (saving to compressed wav file): For building the tutorials.
  • database design and implementation for Kid's software: User:user name, apprearance, levels, completed tasks, map spots, etc. And many more
  • Skybox, weather and day-time system (ambient light and color): Introduction to 3D programming.
  • (optional) water surface rendering with reflection and refractions: Introduction to Shader programming and 3D rendering pipeline.

For LXZ:

  • (DONE)In-game terrain height field modification.
  • (DONE)terrain multi-texturing editing environment.terrain multi-texturing loading and saving environment.
  • (DONE)static mesh and object ray-picking using bounding box.
  • (DONE)Virtual system: an replacement to MPQ using zlib. This is a multi-file archiever.
  • (DONE)Script interface for Directory IO: some assets UI may be built directly from the disk IO. This IO should work with ZIP file system.
  • object deletion and file saving in the virtual world, supporting all functions required by the kid's software.
  • character animation recording and auto-loading, supporting all functions required by the kid's software.
  • Tutorial building and replaying platform: a movie driven tutorial system, with sound and UI indicator support and auto suspend point during the movie so that user can follow the movie step by step.
  • (DONE)ParaX Model file definition, (TODO)interface to and from 3dsmax. Combine mesh format for both static and dynamic mesh;and solid and transparent mesh.
  • (optional )Asset management program: C#
  • (optional )Effect editor in 3dsmax.


  • OUTPUT_** functions have been moved to paradebug.h with some improvement


  • scenestate will clear device dependent objects such as particle systems.This will prevent cracking during device changes.


  • TODO: free camera can be improved by incorperating look at point using the left click button. whereas the right click is still rotating a point at infinity. See also (paper): Exploring 3D Navigation: Combining Speed-coupled Flying with Orbiting
  • TODO: particle render origin has problems when rendering under low frame rates.
  • TODO: there should be a mechanism to prevent deleting creatures which are currently mounted by another object.
  • NOTE: The male babarian model's mount animation's looping property is set to false, which makes it stand on horse back every few seconds. this is a model problem, and need not to be fixed.


  • Screen video capture is updated. When it begins. the video is automatically paused.Press F9 to resume and pause video recording Recording state is displayed on the title bar.
  • player position and facing is reported when debugging mode is turned on.


  • ParaIO can now back up files as well as checking file existance
  • TODO: character physics during movie playing. Physics should be reloaded?
  • TODO: GUI: editbox should add support for numeric key board (NUM_LOCK).
  • TODO: GUI: editbox should lose focus as early as possible. Such as when ENTER key or any other event(Mouse) is down.


  • creatures now have three replaceable skins, instead of two
  • Ridable creatures can be scaled.
  • in the movie platform: player recording and movie playing are bounded together. One can use the player recording page to play the entire movie. Record button: record the character animation, and play the entire movie Play button: play both the character being recorded, and the entire movie Pause button: pause both the character being recorded, and the entire movie Stop button: Stop both the character being recorded, and the entire movie
  • Player mounting action can now be recorded. To record better mounting animation, jump on the back of horses and when it is approaching the mount point, click the Shift button to smoothly transit to mount animation.
  • both the mounted object and the character can be scaled.
  • when shooting animation, focus the camera on mounted object and the character itself will give different effects. Once focused on the character, the camera will shake as if it is on a real horse back.
  • looping key frame can now be inserted through the movie platform.So that creatures can have a looped animation when the movie is playing.


  • Biped object can now ride on another biped object, and performing actions while mounted.
  • Press left Shift Key to mount on the nearest creature(horse). Please note some objects are not mountable Once mounted, one should move the two bipeds by taking control of the horse biped.
  • Press Space key to unmount from the creature(horse).
  • + and - key on numerial keyboard will change the camera look at height during follow mode.


  • now that every action of the biped is carried out through the biped state manager.
  • character can now toggle between running and walking as its default moving style.
  • The moving style(running|walking) and all character animations can now be recorded in the movie controller. The biped state manager will activate the movie recorder proactively.
  • When the time of the movie is set, the character is immediately shifted to the keyframe before the time just set.
  • The keyframe interface now supporting inserting key frames.
  • The camera C key will now correctly switch to free-camera.
  • casting Missile and Magic can also be recorded.
  • biped facing is recorded to movie and can be replayed.


  • terrain object can now return the onload script of a given point on the terrain.
  • everything is the terrain can now be saved and loaded, to a similar onload script in the temp dir.
  • we can now launch missile between two global points. And we can attach effect objects to any attachment point.
  • in the world construction script, everything can be loaded and saved and re-modified.
  • demo script UI implementation in NPL:
    • world object creation kits, - physics object creation: an effect played where a new object is created - object removing:delete the selected object from the kits. - object deletion:delete the selected object from the scene - object selection: firing a missile to the selected object for path-finding. - temporary scene loading and saving on a terrain tile basis. Files are saved to ./temp directory and can be reloaded over an existing scene next time. - per object manipulation: moving, rotation and scaling; - object re-naming.
    • movie recording kits - per actor recording and replaying; record file saving and loading.(TODO: more actions) - actor dialog recording and replaying. - multi-character movie replaying kits. - actor list editing (adding, removing and deleting actors) - movie files saving and loading (which contains the list of actors.)
    • character action kits - plenty character actions.
    • global object listing and searching kits - object search and listing - float bar auto-positioning.
    • spell and missile kits - attaching to any slot of a character. - drag and drop spell item. - skillbar shotcut.
    • animal creation - skin configuration. - changing global or local character attribute. - creature scale configuration.
    • character creation - 8 races, two genders. - customizable clothing sets.
    • demo bar updated: all-in-one menu for the movie platform.
    • Press 'P': pause the game, the camera can still move to observe the static scene.
    • message box and file log(log.txt) are extensively used for reporting.


  • global object deletion is implemented. the current player is automatically changed to the next global object if deleted.
  • the entire demo scripts are written. Movie making and creature creation scripts are fully tested.
  • Shadow is casted only for the first model in the model canvas. This is a limitation, because each biped object can only have one shadow rendering technique enabled. For biped objects having more than one models, only the first one is rendered.


  • The ParaAssetManager will now delete all dds files in the temporary files
  • The charModelInstance will now distinguish customizable character models and non-customizable character models.
  • replaceable texture groups are implemented for non-customizable character models. E.g. a model may now have different skins, such as a black bear, a white bear, etc. However, such information has to be read from the character database(CreatureModel and Skin database).
    • TODO: Due to a mistake,the skin database only exported two skins per model.Yet, there is actually three. So some models who has three replaceable textures will not render with the third texture.
  • when game is paused, the camera can still move to observe the static scene.
  • Animation Table is added to CAnimTable. Now that animation will default to correct one. such as swimming will default to running, etc


  • each particle instance in the ParaX model's particle system now has an owner assigned. When the update and draw method of the particle system is called, only particles whose owner is the current scene object is animated or drawn. this will prevent the same particle system being animated several times if instantiated on several different models.
    • TODO: but there is still a problem when the same particle system is attached to the same scene model twice. In such cases, one may set other ID rather than the pointer of the scene object as the owner of the particle. For simplicity, I assume that the same particle system is only instantiated on one scene object only.
    • TODO: ribbon is not animated so far. only particle system is. Add the update method for ribbon class. see the update function of the particle system.
  • global particles will delete itself automatically, rather than depending on the owner object. I.e. Even if the owner object is destroyed, the global particles may still be active for some time, except that it will no longer generate any new particles.
  • Local particles will be deleted whenever its owner object is deleted.
  • the particle system instance count and the total particle counts are now reported to the console in the format: nPS:%1 Num:%2 where %1 is the particle system instance count, %2 is the total particle counts
  • The rotation matrix for particle bill-boarding is calculated on a per-particle system basis. The gravity (average) point of the particle system is used to calculate the rotation matrix.
    • TODO: In future, I may use per-particle rotation which is more accurate for particle bill-boarding.
  • all global particles are post rendered. The scene manager added explicit support for particle system post rendering and animation.


  • Missile class is now part of the scene objects. Missile objects are animated using the environment simulators. Missile objects have render and physics radius of 0 The scene and camera can now perform view culling with 0 sized object, in which case they are treated as a point and bounding box rendered as a rectangluar
  • The character model now has an automatic character mark.Automatic character model will generate some of its own bone matrix, such as the upper body turning angle, according to the physics and other constraints.
  • we can now launch two particle systems:
    • static particle systems are attached to the launcher's model canvas.
    • missile-like particle systems are global objects in the scene. They will be deleted when they are timed-out or reached the target.
    • TODO: event system may be used for hitting target alert.
    • TODO: we should delete particles from the particle system, when the particle system has no other instances in the scene. Use ref count, etc.


  • TODO[liuweili]: Down Event Up State(DEUS) rule: you should follow the DEUS rule for mouse and keyboard input. This rule mean you determind whether a holding key or mouse button process should happen by checking the mousedown or keydown events not the states. In the same way, when you decide that process should end, you should check the mouse or keyboard state. In this way, you will avoid lots of the problems


  • Particle system and ribbon system implemented for ParaX class. The particle system may either be global or local. Please, refer to Particle.cpp for more information. The render offset displacement is used for each global particle system to calculate its movement for each particle in the global coordinate system, while avoiding floating point inaccuracy problems for very large scenes.
  • global scene objects can be queried from a hash map.Hence, it is faster now.
  • The character attachment structure now works with particle system. Once can attach or dettach particle system or other models to a specified attachment point, such as head, shoulder, hands.
  • TODO: pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP,D3DTOP_MODULATE); should be used instead of D3DTOP_SELECTARG1 for some models.
    there is a bug when rendering water after rendering particle or other transparent objects. The ocean color seems to blend into transparent objects, even if they are in front of the water.


  • Physics mesh object can now be rotated or moved dynamically. But ParaScene.Attach needs to be manually called.
  • TODO: Terrain Engine:
    • In the future, the texture for terrain will no longer be tiled. Hence, current implementation is OK. However, for the moment, we need to support tiled detailed textures, such as road rocks, bump maps, etc. (enabled according to alpha map). There is no need for additional texture coordinates. I.e. all texture layers can share the same texture coordinates. hence, all I need to do is to modify the pixel shader. The terrain config file thus contains 5 textures: base, dirt, detail, bump and alpha. Pass1(no light) Pass2(light enabled) - Texture0: base texture - Texture0: detailed texture(tiled) - Texture1: dir texture(tiled) - Texture1: bump texture(tiled) - Texture2: alpha map
    • Some people argue that ROAM is too CPU intensive to be used in present day game engine. A brutal force algorithm will be more CPU friendly. I agree, but ROAM is not that much CPU intensive. we can use it anyway.
  • TODO: Water reflection should be implemented. EMBM (environment mapped bump mapping) should be used. First render objects in the water mirror into a texture, then use a bump map(animated using a timer) to displace this texture and blend with the FFT water surface.
  • TODO: Rewrite the mesh class, use a single interface for both static and animated mesh. I.e ParaXModel. Right now, it is in three places: ParaXModel, MDXModel and StaticMesh.
  • TODO: when a (mesh) asset is not found, default to invalid mesh object.


  • TODO:IME SongTi 11 has caret alignment problems
  • TODO:GUI Selection + delete
  • TODO: Delete Character, where is camera
  • TODO: actors back up. loadscene to Script VSS control.
  • TODO: more actions of the biped
  • TODO: allow character movie controller to immediately shift biped to the next waypoint.
  • TODO: movie recorder lib documentation. (10 TODO: the physics is only available near the camera, what if there are many active objects in the scene as in the movie making.
  • TODO: 3D GUI is only attached to the current player, it should be attached to a certain biped. when will 3D GUI display itself or destroy itself?
  • Shadow for ParaX done. See ParaXModel
  • TODO: 3D GUI jerks. it still jerks at 0.4999->0.50001, but it works better at motion with TO_PIXEL round up. it also jerks when the mouse is controlling the character, the mouse actually jerks, maybe applying some inertia to the mouse motion. if using keyboard, it rarely shakes.


  • ToString() implement for biped object
  • Movie recorder and player implemented.
  • SetTimer and KillTimer are implemented. Timer is supported.
    Timer is not accurately timed right now, only 1 second, 5seconds, 10 seconds are accurate.


  • 2D GUI in 3D space. Attach 3D to 2D, or vice versa.
  • Right button in non-follow mode will not roll back to behind the biped.
  • TODO: smooth camera follow target transition. loot at position as YAW and liftup angle around the eye position.


  • Biped animation improved. Now that the animation of biped is demtermined by the following independent paramters: (model) facing, speed facing and {headTurning_angle, arm, leg, etc}
    • the rendering transform is determined by model facing
    • the speed direction for physics is determined by speed facing
    • the camera follow direction is determined by model facing + headTurning_angle;
    • the shift walking direction is determined by model facing + headTurning_angle +-PI/2;
  • AI controller and AI module are completely rewritten.
    • Face tracking AI controller is implemented.
  • ParaIO in implemented in script for write-only or read-only file.
  • Write-only file access is also implemented in CParaFile.


  • boost 1.33 is used by both ParaEngine and lualind. boost header at ../boost boost lib at ../boostlib
  • ParaScene:GetObject("name") supports "*" as a matching character.
  • BipedStateManager will now use a timer for state transitions for its jump start and jump end animations.
  • UI demo is finished.


  • the camera will now handle user input from GUI's direct input interface.
  • camera mouse key is refined.
  • the biped object will draw physics bounding box, instead of clipping bounding box.
  • SetStandingState() and SetWalkingState() of the biped object is replaced by Action manager. Use ForceStop() and ForceMove() to send the biped with way point commands.
  • the acceleration of biped under water is Gw= 0.2*G -(V*V)*k where G is gravity of the earth, V is the vertical speed of the biped. k denotes water resistance, which is 0.1f.


  • rendering pipeline is updated. All scene objects are put to three major post rendering list for rendering. Each list is sorted according to object to camera distance. And then they will be rendered in the following order
  • solid object list: sorted from front to back. In mesh report, it will display "F->B:%d". Their bounding boxes will be rendered as red boxes.
  • transparent object list: sorted from back to front. In mesh report, it will display "B->F:%d(%d1)". where %d is the total number of meshes rendered and that %d1 is the number of meshes that has been occluded during occlussion testing. Their bounding boxes will be rendered as blue boxes.
  • Biped list: sorted by primary asset. In mesh report, it will display "Biped:%d". Their bounding boxes will be rendered as green boxes.
  • occlusion query is implemented for object in transparent object list. See also ALWAYS_DRAW__TAN_ANGLE in SceneObject.cpp.
    • However, this is still not optimum,since sometimes, we only need to render to a smaller (e.g. 300*240) render target for occlusion testing.
    • the occlusion object is defined in CBaseObject. However, I may use more simplified model to draw the object. Currently I used the line primitive of the bounding box. Maybe Point primitive is enough(I tested it. it is not working well with point primitive even with fixed screen point size set.).
  • file can now be extracted to disk. it is for exporting a more compact version of the game.
  • biped can change speed while in air.


  • Biped state manager is implemented. The biped will now walk in 8 directions with approprite animation played.
  • a quaternion bug is corrected for rotation interpolation in ParaX model.
  • Biped Swimming is implemented using biped state manager.
  • mouse cursor dissappear bug corrected.
  • Font can be changed at runtime.
  • Biped can rotate its upper body.
    • TODO: the bone hierachy is different for different models. I need to know the body information for each model in order to rotate the bone chain. currently, I used the HEAD attachment ID to get the neck bone. It works well until the attachment ID is valid.
  • character model scale bug is corrected for ParaX character models of different sizes.
  • the camera now will handle water-land transition gracefully.


  • The biped objects now will align to terrain when running with better jump up and down speed.
  • the physics in Biped object can now be split in to several even-length sub steps.Some bugs regarding the climb up and physical height have been corrected.
  • The entire ray-casting biped physics logics is rewritten. a bug about walking along concave meshes have been corrected. Three group of sensor rays is used.
    • Climb up speed is maintained when the biped is below physical scene.
  • BUG: camera jerks at the position with physics correction. This is another floating point inaccuracy issues.


  • A texture bug with ParaX character is corrected.
  • TODO: ParaX opimization:
    • Skinned animation may be more efficiently implemented with attribute groups, where several vertex may share the same vertex group.
    • Bone matrices should use 4*3, instead of 4*4.
    • Bone matrices should be transposed in m2 file.
    • m2 file should have a ParaX file format counterpart.

  • TODO: collision detection with skinned animation should be implemented with software skinning.
  • BUG: there is a bug where the attached models can not be positioned precisely when the translation value is very big.
  • rendering coordinate system is a 3D coordinate system parallel to the world coordinate system, but with a different origin
  • called render origin.Render origin is an arbitrary 3D point chosen near the current camera
  • eye position. All scene objects and the camera view are transformed to the rendering coordinate system
  • for rendering. This is because if we use the world coordinate system for rendering, the components of
  • transform matrix that is used for object manipulation will be inconsistent (i.e. of different magnitudes.)
  • By doing so, it will correct floating point calculation imprecisions, due to large numbers in object's
  • coordinates, such as the simple addition of (20000.01f+0.01234f). The result of using world
  • coordinate system for rendering is that we will get increasingly jerky object on screen as
  • its global position shifts away from the origin of the world coordinate system.(this is usually the case for games
  • with a very large map. One may consider using double type to store the global position of scene object in world units.)
  • In the rendering coordinate system, however, all components in the matrix will be comparatively small
  • and consistent. Hence objects can be positioned more precisely near the render origin, which is
  • near the camera eye position. The following has been changed: - the render origin is always near the camera eye in the 3d space. - terrain engine now uses local coordinate system. - ocean manager now uses local cooridnate system.(the shader will do the render origin tansform job. See worldPos parameter in the effect file.)
  • ocean will only be drawn when it is above the visible terrain.
  • under water effect is rendered using very simple method. Shader and post-processing is not done. See Oceanmanager and underwater.fx
  • ocean is now rendered after most scene objects have been rendered.
  • TODO: physics engine may also suffer floating point inaccuracy problems. See also 2005/10/7.


  • now biped objects can change its base model dynamically. It also allow NULL type base object, which defaults to a dummy biped object with a certain radius.
  • character settings can not be loaded from file.
  • TODO: ParaCharacter::Set...() functions have not been tested.


  • ParaX character animation is implemented.
  • the biped nows uses physics radius, instead of the model radius for physics calculation and camara tracking.
  • Now ParaScripting HAPI has been put into several source files. They are GUI, Character, Scene(HAPI), Global.


  • virtual destructors for all scene, GUI objects and asset objects are added Scene object is now deleted using Release(): TODO: reference count may be implemented for some type GUI object is now deleted using Release(): TODO: reference count may be implemented for some type asset entity can be released using Release()
  • TODO: buffer overrun examined for all string functions.
  • memory leak and dump performed when the application exits please include "memdebug.h" for each cpp file which need to display additional filename and line number for the memory leak location. this is a MSVC bug, please see "memdebug.h" for more information.
  • TODO: a exception class is added for paraengine.
  • TODO: key and mouse handling converted to DirectInput.


  • Asset Entity in NPL is now returned in a simple data structure called ParaAssetObject.
  • ParaX entity is added and implemented in CBipedObject
  • a severe memory leak bug is corrected for AssetEntity and its derived class objects. Now, each derived asset entity's destructor function is properly called.
  • a memory leak is corrected for asset entity clean up order in asset manager, such as the texture entity is cleaned up last, whereas other resource entity (ParaXmodel) may reference texture entity.
  • a memory damage bug is corrected for ocean manager, the ocean manager is now cleaned up before the asset manager.
  • a memory damage bug is corrected in ParaWorld.cpp. the asset manager will be cleaned up only when the scene and GUI objects are already cleaned up. This is because the scene and GUI object may decrease the reference count of assets entity in their destructor functions.


  • SQLite is added for client database system.
  • A lua interface for SQLite is added.
  • New character animation system is implemented.
  • ParaWorld solution is cleaned up to be fully compilable from source control plus a small package.


  • NPL network layer moved to solution
  • Config.txt is added, which allows the user to specify a resolution at start up.


  • glia file is added. CNPLRuntime is rewritten with the new logic.
  • All biepd objects are supposed to be spherical
  • if a biped is created with 0 radius. it is considered freespace object, which will not collide with other objects. however it can still be perceived by other bipeds.
  • TODO: there is a bug, when loading some of the models. And there seems to be some triangles connected between models. this maybe the same problem, when turn on shadow casting for some models.
  • TODO: accurate mouse picking (face level).
  • TODO: left mouse to change the camera view. Slide the camera along ground when camera faces upward


  • we allow holes in the terrain. the terrain elevation at hole is always -INFINITY. and any ray interection with holes will always return negative value(i.e. no intersection ever returns). Currently, the terrain hole map is a low resolution array of vertices. It is stored bitwise in a bitmap just as the terrain elevation file(heightmap).
  • In Biped movetowards method, the biped will not move below LOWEST_WORLD.
  • The Smoothmove in Autocamera has been corrected by adding square root to the distance.
  • When right click in follow mode, the camera will always immediately catch up the targets.
  • Both the camera and the biped objects are allowed to fall down holes in terrain, and subject to no global terrain physical laws.
  • the biped will strictly subject to terrain surface when there is one.
  • DoFileLocal is added. Now that we allow execution of lua files using ParaFile interface. i.e. files can be loaded from ZIP package
  • (TODO:)d3dx_26.dll is required to run.
  • screen video capture bug fixed.
  • water tiles are implemented.
  • the whole WOW is exported.
  • character Jump is implemented.
  • a bug with biped event parsor is corrected.
  • TODO: ParaGlobal.loadobject can not return nil object. See CPP for more information.
  • sun position is matched on the fake sky (by changing time of day).
  • TODO: use a local database to store the information of the (min, max) of a mesh entity. so that it does not need to be calculated on the fly.
  • The scaling problem of physics mesh has been corrected.


  • TODO: static mesh objects are sorted according to their distance to the camera. So that they will be drawn in a front-to-back order
  • TODO: Define several view culling frustum for terrain, water, objects, etc. Allow values to be changed from script.
  • CEffectFile entity and manager is added to asset manager
  • Ocean manager is implemented. (4.1) Pixel shader has not been tested. The implementation is based on FFT and bump mapping.
  • Global water level is implemented.
  • TODO: Use triangle strips for terrain surface. Use 4 degenerate triangles to connect disjoint strips
  • TODO: When in REF mode, BLP model created with D3DXCreateTexture(pd3dDevice, width, height, 0, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &pTexture))) Will not LOCK properly. Please Check blp.cpp Line 242. [possible Solution:] load BLP directly
  • a new configuration mode DEBUG_shaders is added, please see effect_file.cpp for more information
  • TODO: use bump mapping and environment mapping for ocean surfaces. optimize shader code.



  • During rendering, the rough object-level testing takes the object size in to consideration. Smaller objects has a short visible range; whereas larger object has longer object size. Since fog effects is used to fade object in and out. The radius of the visibility circle for each object tries to approximate the result that each object gives the same amount of scene color changes.
  • the sky mesh class has been redesigned. It now supports several sky type. The most simple type is static mesh. To work with fog effects, I have blended with static sky mesh background with the color of the fog.
  • it is so strange that my ATI 7500 card does not support FLAT mode shading. It runs very slow when I turned it on.
  • I used some ad-hoc method to side step the physics with the new WALK_FORWARD biped waypoint.
  • the shadow bug has been corrected.
  • the static mesh will not render faces without textures.
  • Camera occlusion control is improved for physics mesh.


  • Blending or alpha testing enabled material will disable backing culling attribute during static mesh rendering. if blending or alpha testing is not specified, counter clock-wise(CCW) back facing is used, by default. So please model your rendering and physics model in CCW order.
  • Z-masking is added to the attribute bit of material in static mesh.
  • WMO exporter is almost finished. In deep explorer, one can set the texture search path to what the texture is located.
  • Auto camera reference height is no longer used. The free camera becomes independent from the scene.Follow camera is subject to physics.
  • In the scene manager, objects are rendered aroung the camera when in free-camera mode
  • View Culling Object is redesigned as a transformed AABB box.
  • A bug is corrected for Physics shape.
  • static mesh and physics mesh now supports 4*3 local transform matrix to its mesh entity. And so it is with the ParaWorld HAPI.
  • TODO: Add fog effects, so objects will not pop out abruptly. Maybe alpha blending and shader should be used in future version.
  • Occulsion camera controller implemented. Improved for global terrain (near camera plane safe). It ensures that no object occludes the line of sight from the camera to the biped.
  • Biped camera controller designed. (With mouse drag and key board combined. Support always running.) Two follow camera supported. First person and third person. A new type of biped command is added which is called move forward.
  • BUG (corrected): the detail texture on terrain does not show up.


  • mesh physics object is now dynamically loaded near the current player and the camera eye in the environment simulator.
  • Add eraser object, which will clear all scene objects in its bounding box.
  • TODO*: garbage collect physics objects and device assets by hit count.
  • TODO**: use portal to dig holes in global terrain. Maybe in the terrain file.
  • TODO**: Use ray-interection for both camera and player motion against the global terrain(with portals) and the physics objects
  • Camera report added
  • Para File Manager now supports relative path.
  • Static mesh now supports alpha blending and alpha testing. the specular power component of directX material is used to encode such information. WOW model exporter now takes advantage of this property
  • TODO: dynamically calculate the bounding box of managed loader.
  • reuse texture of global terrain object.
  • Managed loader object is implemented for dynamic scene object loading and unloading.
  • Added an optional script loader file in terrain tile configuration file. The file will be executed as dofile(...).


  • The latticed terrain engine is fully implemented.
  • RAW elevation file of (2*2*...*2+1) quad sized height map is supported.
  • Latticed configutation file is implemented.
  • Single terrain configutation file is implemented.
  • HAPI CreateWorld is added. Quad tree depth is now automatically caculated.
  • Blank Terrain now defaults to a plane at y=0.
  • WoW terrain exporter implemented.
  • Global Report class support string value now and it internally uses map instead of list for all reporting items.
  • Latticed terrain rendering is now reported.
  • A detailed (none tessellation radius) is added.
  • Tiled (or latticed)terrain objects are dynamically loaded into memory and automatically cached.
  • No cracks between terrain tiles.
  • detail texture logic has been moved to the tessellation process.
  • The latticed terrain cache uses an indexed map, which hashes (x,y) to an interger. x,y can be any integer(negative is OK)
  • Gray scale image is still supported. RGB(0.5,0.5,0.5) is regarded as 0 height.
  • ParaObject::SetPosition(), now y height is relative to world coordinate system.
  • The biped object is only normalized to terrain surface along the facing direction.

2005/4/29 Resource management changes:

  • The asset (resource) management has been completely rewritten. Reference count is added. Performance for searching is optimizied.
  • Asset entity can either be named or unnamed. One can also assign different names to the same entity. However, the resource file name (NOT the user assigned name)is used as the key and is maintained in a sorted set.
  • File management class is added. A unified interface for all real or virtual files.
  • All textures in paraengine are globally managed, expect those used in global terrain rendering.
  • Static Mesh class is implemented. Although it is still based on DX file, I have moved it to the game engine namespace.And all textures are now globally managed.
  • all resources are lazy loaded. No need to call ParaAsset::Init() any more.
  • TODO: garbage collection in asset management.
  • To compute bounding boxes, all mesh and parax mesh object are fully loaded after the asset is created.(Of course not with textures)
  • A bug with m_pViewClippingObject object is corrected. It will now add an offset(in the mesh file) to its global location for correct object-level culling.

2005/4/27 Terrain engine changes:

    • high-res texture tile is implemented. High res texture will be be dynamically loaded and deleted due to the camera view location. high-res texture usually has 16 or 32 times resolution than the low-res texture. The low-res texture is always persistent in system memory;whereas high resolution textures are dynamically loaded and deleted from the system memory(also video memory). A system cache for high-res textures is maintained. A hit count/miss is recorded with each cached texture. The total number of cached high-res textures in memory are a constant, such as 40. Old textures are unloaded according to its hit count in the last
      1. render frames, when the cache is full. There is a mechanism to prevent current used textures to be unloaded (in case that all cached textures are being used simultaneously).
    • texture coordinates are no longer generated, but computed at runtime.
    • chopped texture are no longer flipped, because I use texture coordinates larger than 1 for tiling.
    • Internally file system uses "boost 1.32.0". Currently, there are two boost version used in ParaEngine. the file system is linked as static library. It automatically select the release or debug version to link. The boost build system takes quite sometime to build. and I have put the boost 1.32.0 install directory to the boost folders.
    • TODO: I want to use bump mapping for high-res textures. But it seems lots of work for the artists. Please refer to the terrain document 1.14. Embross bump mapping may be used. But a more general UV bump mapping (bump/light maps) with reflective surfaces may be supported in future version.
    • A terrain buffer is used which is only rebuilt when the camera view is changed.
    • The terrain rendering has been further optimized by using a sorted set for texture grouping.
    • TODO: High-res textures may be reused on a tile basis, such as reading from a central configuration files. The current implementation supports texture reference already.i.e. there is a texture list internally, and each high-res tile references into this list to retrieve texture. But there has been no interface to directly modify the texture index matrix from the outside.


  • character sliding wall physics is fully implemented.
  • Mesh physics facing is now supported. Mesh data will be loaded only when it is attached to the scene
  • The scene root object now has a triangle list for geometry dumping during debugging
  • Collision now uses 16 bits indices. And a bug with physics loading is fixed(a cloned mesh with only position vertex is used rather than the original mesh to create physical data).
  • Now that each scene object may be associated with a view culling object. it is the dimension of this object that will test again rendering clipping and scene insertion.
  • Now that all 3D objects will not need to specify their view bounding box, only physical bounding box is specified.
  • 3D Scene ray picking has been completely redesigned to integrate with the current physics framework.
  • Smooth jump up and down of the biped is implemented
  • Environment simulation has a worst cast frame rate, lower than which simulation will be sub divided.
  • Character sliding wall is implemented.
  • Object bounding boxes can now be drawn.
  • A reporter class is now added, which provide a better interface to output per-frame debug information to the screen.
  • NPL script to display the above OBB and report are added to ParaScene::Execute() function
  • CAutoCamera renames CullObject() to CanSeeObject(). More accurate object-level view clipping is implemented in the camera class.
  • The CBaseObject and CSceneObject has been optimized.The shape is more accurately defined in CBaseObject.
  • A global class has been added to retrieve all singleton object in paraengine.
  • An Ad hoc 3D collision detection is added in BipedObject's MoveTowards() method.
    • It casts three rays in front of a moving character to decide whether it can move or not.
  • The engine kernel has changed from directX 9.0b to direct 9.0c. So one need to have its driver installed to run the game
  • The complete NPL script interface has been changed.It is now fully data driven and use only unambiguous functions. Please refer to the "1.14 NPL scripting reference" for the guidance. Luabind is used to generate HAPI. Major differences:
    • scene objects and UI objects can be retrieved in a class object, which can be used for further manipulation
    • A Window GUI class is added, which simplified the original UI scripts. A window class can display text, back ground images, receive mouse clicks events and key stroke events.
    • the mechanism for mouse and key event handling in NPL script has changed. A single Pick() function is used to generate both types of events.
    • 2D GUI will not share key or mouse event with 3D scene objects.
  • A doxygen documentation project for NPL script is saved in ./ParaScriptingRef
  • Some demo scripts based on the new NPL interfaces are made, please see following for details script/gameinterface.lua, script/pol_intro.lua, script/gamehelp/help.lua, script/scenes/loadscene1.lua,
  • NPL script files can now be edited in LuaEdit or LuaQDE. Run _Tools/LuaEdit.exe
  • Several new documents are added:
    1. 11 ParaEngine and Frame Rate Control.doc
    2. 12 ParaEngine and Game Engine Survey.doc
    3. 13 ParaEngine and Physics.doc
    4. 14 ParaEngine and Scripting Reference.doc
    5. 15 ParaEngine and Research Proposal.doc
  • A bug with loading static mesh is corrected. Please see \xmodels\shop.x. Pay attention to its coordinate system, model world positions and scales. The script to load this model can be found in script/scenes/loadscene1.lua.
  • scaling is temperorily disabled for static mesh; while remain enabled for animated mesh object(such as characters)
  • The game engine now support full 3D,instead of 2.5D. I.e. Object is always specified with (x,y,z), instead of (x,terrain_height(x,z),z).
  • F1 key to display help
  • F10 key to show the console on top of the screen


  • In-game Screen shot is supported, press F12 to capture still image. Video recording is also supported
  • Rect Camera Follow mode is changed.if character is reaches the edge of this rect, camera will be centered on it again.
  • ParaX model can now enforce shadow capping when created by the script
    • ParaCreateAsset("MA", "tree0", "Doodads\\Terrain\\AshenTree\\AshenTree3.mdx", nil, 1); -- create asset enforcing shadow capping
    • Model that enforces shadow volume capping will always use Z-fail algorithm, some simple models with transparent textures may use this option (such as trees)
  • Shadows of objects are not draw if they are too small after projection to the 2D screen (screen distance testing).
  • Shadows of objects are drawn using z-fail, if their bounding box or bounding sphere are also zero.
    • such object will always pass screen distance testing. see above.
  • shadow volume is now very robust, it will automatically swich to Z-Fail algorithm, when camera near plane intersect with any of the shadow
  • ParaX model cull_mode changed to CCW, this will make some blending face only visible from one side.
  • Shadow HAPI added: ParaExecuteCmd("shadow", 1); -- turn on shadow
  • Sun light is added in the sky mesh object. It will change 24 hours a day.
  • Shadow support added to ParaX animation model: shadow volume implemented for CMDXmodel. hash table is used for building edges in shadow volume
    • //TODO: use hardware Shader to extrude faces of shadow edges
    • //TODO: Class comments should be moved to the header file. ParaX file
    • //TODO: ParaX currently only support one kind of layer, this may have problems with blending and transparent textures specially when used with shadow volume
  • ParaEngine's own 3D model and animation format is defined and implemented in the game engine.
  • Para-X animation now uses compressed key frames.
  • Smooth animation is supported for Para X file.
  • Hermite interpolation is removed in animation keys.
  • A binary search is used, instead of linear search for animation key finding
  • A new HLE is added to biped called 'spds FLOAT', it will enable HAPI to change the speed scale of any character.
  • A framerate problem is solved by forcing 30FPS. See notes in d3dapp.cpp
  • Scene object culling now uses a pyramide, rather than a circle.
  • The environment simulator now distringuishes between intentional way points and other way points, it is now a fixed feedback system. A character may generate new waypoints(user control or AI), but it must be verified by environment simulator, before it is carried out in the virtual space.
  • A bug with object avoidence is fixed.
  • F1 key: in game help neuron script is added.
  • Z-buffer bug in ParaX file rendering is fixed. Blending and additive textures are rendered with Z-buffer testing enabled and z-buffer writing disabled.
  • // TODO: Most MDX file rendering code are in the GeoChunks.cpp render(); Emitter(particle system) have not been ported to directx
  • // TODO: para X file can not be parsed properly from memory chunk(MPQ). It is now only possible to parse from disk file.
  • // TODO: binary para X file exporting.


  • Roam terrain added. Object is aligned to terrain.
  • HAPI for terrain creation is added.
  • Teamglow in MDX model is fixed
  • Motion warping is supported in MDX animation
  • English translation of script text is added
  • A dynamic buffer problem for MDX animation is fixed.


  • MDX(warcraft3) model support. Use dynamic memory allocation
  • VRML convertor is created for building map scripts from VRML.
  • WARCRAFT viewer is modified for exporting resources from WAR3 models.
  • replaceble ID finished in WAR3 mdx support 2004/7/26
  • Replaced by MDX model. Some machine wonot run because of no support for indexed meshes as used in the multi-animation object
  • OPC should be a hashset on id, HAPI should be added to get the object by id. the server will transmit everything about the OPC to paraworld that need them so that if it's not found, it can be constructed without further requesting the server. - The environment simulator is reengineered
  • TODO: key board sensor, transparent color of GUI, player control, mesh name to define coordinate system,
  • TODO 2004-7-26: Follow camera movement. When distance is smaller than a value, use smooth movement. When distance is too large use immediate shift.
  • TODO: there is bug when character moves to a inf position.Divided by 0.
  • TODO: error There is some unexpected NULL memory access error when testing on one machine. But I have not - encountered it when on multiple machines.
  • TODO: GameConfig.exe 's text should be changed
  • TODO: OPC biped are linearly tested in both collision detection and view culling.
  • since they are not attached to the scene. If the number is greater than MAX
  • we should use dirty page and garbage collect method to delete some of them.
  • MAX can be set to 10.
  • TODO: in asset manager addref() to all d3d object. and pair them with release
  • TODO: allow player to be null.
  • TODO: alter load sdk9 file in dxutil.h
  • TODO: Sky mesh should have a boundary property


  • sprite 2D support
  • 2D display added
  • follow camera constrains.
  • Mesh rendering has been tested thotoughly
  • Done Z-buffer: Z-buffer problem is now fixed.
  • Adding IgoreTargetTurning in the Biped AnimationMoving();
  • Fast biped turning enabled. Orbiting detection is removed. Turning speed is increased.

@section TODO_List TODO lists 2006/6

  • add vehicle and ship simulation for millitary applications.
  • native 2D map, displaying the current player position.
Topic revision: r1 - 2008-03-01 - LiXizhi
This site is powered by the TWiki collaboration platform Powered by PerlCopyright © 2008-2024 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding TWiki? Send feedback