Version 0.4.7 is finished and merged with the tip. The next milestone will be version 0.5
Here’s some changes from 0.4.0:
- Animation: Engine now supports animations, hierarchical or skeletal, animations can now be binded to models and there’s also a component for that purpose.
- Character Animation: Support for character animation is finished (via animchar component), we are still waiting for better test models and animations to test our system. Animation editor tool (something like Unity’s Meckanim), is nearly done and in the final works. I guess we’ll finish and test it till version 0.5
- Hardware Instanced skinning: Skinned meshes can be rendered automatically with hardware skinning just like normal non-skinned meshes.
- Clip edit, model preview: h3dimport-gui tool now includes a model preview and clip editor.
- Documentation: Documents are initiated, I’ve made a new tool called pymdWiki , which eased a lot of wiki and documentation writing, I’ll write more in next iterations, here is the link.
- Tutorials: Initiated and added two tutorials, you can find them in /tutorials directory, their documents are also available in docs.
- Triggers: Support for triggers (and use them in script) is added
- MacOS Support: It now supports MacOS mountaine lion and up. thanks to Davide Bacchet for his constribution
- Waf build system: We had a discussion with Davide about ditching CMake and we finally did it. Currently the engine builds with waf on all supported platforms, and supports MSVC, GCC and Clang compilers.
- MSVC compatible: As you may know, the project was written with C99 standards, and MSVC2012 and lower compilers couldn’t compile it, so I had to use ICC, which raised a lot of problems for me, so I decided to ditch it and make the code compatible with CPP compiler such as MSVC2012.
- GLFW: GLFW library is integrated for OpenGL support, and ditched my previous method of GL Context management
- Attachments: Engine now supports Attach Docks and Attachment (via attachdock and attachment components), that non-physics objects can be attached together. For physics object I have to implement joints in the next version.
- Unified application interface: Previous application interfaces sucked, because there were a lot of platform dependent interfaces that you couldn’t write an app for all platforms with the same interface. But I’ve re-written the whole thing and now it supports all platforms with the same app interface.
- Physics data import: Engine now supports full rigid-body physics data, that can be imported from Physx3 plugins. Now the h3dimport tool supports importing of rigid bodies and their shapes with automatic baking (convex/triangle-mesh)
In the next version (v0.5), I’ll be focusing on polishing and testing character animation controller, Physics joints, Initiating multi-threaded task manager and moving some workload (including loading resources) to other threads, A flexible GUI system and improving the lighting system.
In: News · Tagged with: animation, attachments, character animation, glfw, hardware instanced skinning, physx data import, triggers, waf
It’s been a while that I haven’t updated the blog. For couple of months, we have been busy with other projects and bunch of other stuff, including me. But for the last 2 months we’ve been working on the engine again and it’s going pretty well.
I’m currently working on the branch 0.4.7, which brings alot of changes, the most important one is engine’s Character Animation System which we are reaching it’s first release. I’m developing the engine side coding and Amin is working on the Animation editor tool and .NET wrapper (Which is another open source project itself). The system roughly mimics the Unity’s awesome Mecanim tool.
I’m also preparing a wiki and couple of tutorials, and update the reference docs. Hopefully branch 0.4.7 will be finished within a week or two. So until then, so long …
It’s becoming ALIVE!
Good news, the project is rolling to version 0.4.6 and becoming more alive …
It’s no one man project anymore, we now have two more developers contributing to the project:
- Amin Valinejad (tools developer): Designed this awesome animation tool (see below), we are currently designing and implementing animation system (which will be released in v0.5). He is also the founder of sharphammer project, which is a collection of software (including editors and tools) and C# bindings for dark-hammer engine.
- Davide Bacchet (OSX port/build tools): Davide liked the engine at this early stage and decided to contribute to the project by porting the current version to OSX, we also worked together to apply more multi-platform changes and implement the awesome waf build scripts, which he introduced to me. The engine currently runs on Windows, OSX and Linux platforms and can be compiled easily with a single script on all platforms (supported compilers are GCC, ICC and Clang).
The new website for the engine is also up, check it out.
Initial physics test
Physics sub-system is setup and integrated in the engine, I have integrated nVIDIA’s physx 3.2 sdk into the engine. It is abstracted as phx_device, So in the future, 3rdparty physics could be replaced if necessary. Currently the basic rigid body is implemented. By importing Physx data files (RepX) (which can be used for other physics engines as well), all shapes including cooking of triangle/convex meshes with their transform, properties, etc. are supported.
In the video, you’ll see two scenes, first scene is rigid-body soup which dozen of rigid bodies are spawned and the script do random impulses to object (well, to make it look more chaotic). Second one is a domino effect scene which simulates a spiral domino scene.
In: News, Physics · Tagged with: physics, Physx, rigid body
I’ve finished working version 0.4.0 of the engine, in this iteration, I mainly focused on rendering optimization methods.
Whats new ? :
- Occlusing culling: software occlusion culling optimized with SSE instructions (no binning, multi-threading yet).
- Uniform Grid Space Partitioning
- Discrete LODs: Definable using JSON data and LOD schemes
- Hot-Loading: Hot-loading and automatic import of all current resources, which are animation files, models, scripts and textures.
- Lua script system overhaul: Different design changes, performance improvements and timer events.
- Python Bindings: Initialized python bindings, now engine can be programmed in python. I mainly will use this feature for tools/editor development.
- Physcally based lighting
In the current demo, I stress tested with a lua script by calculating path movement of 150 objects in the scene, which should be handled by engine’s animation system in the future.
The binaries (for windows) can be downloaded at:
I have also uploaded a new video demonstrating web-based profiler and memory monitor tool:
In: News · Tagged with: hot-loading, occlusion culling, python game engine, Scene management, script system
Content creation and hot-loading
What this video demonstrating dark-hammer’s immediate content update and hot-loading capabilities.
Currently, resource manager implements hot-loading for all resource types like, models, textures,animations and scripts. h3dimport-gui tool is also updated with hot-loading. so there will be automatic mesh import/texture compression whenever anything changes in modeler/photoshop.
Direct link: http://www.youtube.com/watch?v=exOkFoyiCb0
I’ve published the first documentation for API reference:
It’s still very incomplete, I’ll improve it overtime, and right now, don’t have much time for docs.
Core library: http://hmrengine.com/docs/core/html/
Engine Library: http://hmrengine.com/docs/engine/html/
Software occlusion culling
Here’s a video that Demostrates software occlusion culling technique, and simple space partitioning implementation in dark-hammer engine v0.3.5:
Direct link: http://www.youtube.com/watch?v=Onvsn-N7Ruk
DarkHammer – v0.3.0
Moving on … just finished v0.3.0 roadmap. some major graphical stuff implemented in this version, most of the code borrowed from my previous engine hmrengine and translated to dark-hammer.
Features added in v0.3.0:
- Deferred rendering system supports, diffuse-maps, specular-maps, normal-maps, opacity-maps, ambient-color, specular-color, diffuse-color, glossiness.
- Cascaded shadow maps (PSSM split scheme), spherical cascades, Optimized with geometry-shaders, PCF filtering and shadow edge stabilization.
- SSAO downsampled rendering with bilateral upsample
- HDR lighting and filmic tonemapping, automatic exposure adaptation
- FXAA anti-aliasing
- Paki tool for creating (.pak) files for file-system
- Updated meshimport tool with automatic texture compression to support easier importing of models
I have uploaded a simple demo which spawns bunch of meshes on a plane to visualize the new graphical features. It works in windows/linux with DirectX/OpenGL APIs. The windows binary can be downloaded here. For linux, I haven’t built a binary yet, I’ll build and upload one soon, but you can download the media files and build/run the binary for yourself.
Next update is gonna be exciting for me, because I will focus more on optimization algorithms and methods, like LOD schemes, space partitioning and occlusion culling. plus working more on stream lining the content pipeline and loading, improving the content tools and adding support for character animation. I’ll also start implementing python bindings and initiate map editor with PyQt.
In: Graphics, News · Tagged with: CSM, DirectX, HDR, OpenGL, SSAO
PS4 .. finally we have something good
Finally next-gen news are happening to be very good.
Sony announces some PS4 hardware details and surprisingly, It’s an x86 AMD integrated cpu/gpu with 8GB DDR5 shared memory. This is actually awesome for all developers especially indie developers.
They actually got it right, in order to keep the costs down, they have used a normal x86 hardware which we all love and know. No code design and implementation changes, no special algorithms for specific hardware. you can program on PC, make little changes and port it to PS4 with no special pitfalls or performance drops. Future seems a little brighter now.