CuBengine Ported to OpenFL - New Demo Rendering Voxelstein3D's Map at Full Size

Finally, I finished porting my CuBengine prototype to OpenFL, so the engine now supports more platforms instead of Flash only. Here are some screen shots from the Windows binary, showing the engine rendering the Voxelstein3D's map. Different from the old demo of the original Bengine, which is rendering a scaled Voxelstein3D's map with size 256x256x64, in this new demo, CuBengine is rendering the map with full size (1024x1024x256). This is one advantage of CuBengine over Bengine - Bengine use the raw voxel data format so it only support maximum map size of 256^3, while CuBengine can support very large voxel map with a compressed format, and the maximum size can be 65536^3, subject to hardware limits.

You can download the Win-32 build at https://drive.google.com/file/d/0B5V2PrQ8xX_ENkZsbER6b1UtY2M/view?usp=sharing

First Demo of My New Voxel Rendering Engine - CuBengine

CuBengine is the latest derivative of my voxel engine Bengine. The main difference of CuBengine and original Bengine is that CuBengine renders each voxel as a 3D cube while Bengine render each voxel as a 2D pixel square (or 3D billboard). Besides the screen representation of voxels, CuBengine also has many enhanced features over the original Bengine, such as higher resolution, less memory consumption and supporting larger level maps. Actually, CuBengine is a completely rewrite from scratch. Currently CuBengine is written in AS3 with rendering core in HaXe, but it will be soon ported to OpenFL and HaXe.

First Demo of CuBengine (Flash):
https://googledrive.com/host/0B5V2PrQ8xX_EUzI3OGt1S202TVk

Controls:

KeyBoard
WSAD - Move
Arrow Keys - Look
Ctrl - Go Down
Space - Go Up

You can also use the on screen joystick, which is designed for touch enabled devices, to replace all the keyboard controls. To hide/show the joystick, right click and then left click the menu button "◇{On Screen Joystick}".

BNote - A Free Online Simple Application for Taking Handwriting Notes

BNote is a simple note-taking app based on the the smooth drawing application by Dan Gries at http://www.flashandmath.com. The application is specially designed for touch enabled screen notebooks/tablets to take handwriting notes.

Launch the Application

Features:

Smooth Strokes: Thanks to the smooth drawing function by Dan Gries.
Double Input Modes: Pen Input Mode for multi-touch enabled devices and Mouse Input Mode for non-touch screens.
Experimental Software Palm Rejection: Based on input pad, allowing users to rest part of their hands on the screen. Works only in Pen Input Mode and designed for capacitive touchscreen devices without hardware palm detection function and build-in stylus support.

Note the current release (Version 0.1) may contain bugs and deficiencies. Report of bugs, suggestions and feature requests are welcomed, just leave a comment below!

User Guides:

Writing: The app will switch between Pen Input Mode and Mouse Input Mode according to whether the device supports multi-touch mode.
For the Mouse Input Mode, you can use the mouse to write the notes just as any common graffiti board app.
For the Pen Input Mode, you can use a stylus or your finger to write on the board. The input pad (transparent circle) is the area where input/strokes will be accepted while any moves of pen or finger outside the input pad will not produce any stroke on the canvas. This is how the palm rejection works. This allows you to rest part of your hand on the screen, however, too much part of palm on the screen may prevent the app from detecting any moves inside the input pad. So if you find that you can't write anything inside the input pad (while the pen tip is out), try to lift your hand off the screen a bit to let the input pad get focus. It is recommended to use a small point tip stylus pen instead of rubber nib, such as Adonit JOT pro/mini for better writing experience.
How to move the input pad (for Pen Input Mode): During the writing when you want to reposition the input pad (e.g., when starting a new line), tap the pen icon (above the input pad) to stretch back the pen tip. Now you're in protection mode and you can tap any place to move the input pad there. Finally tap the pen icon to stretch out the tip and you can write again.
Settings: Tap the setting icon in the top-right corner to open the setting menu. In the setting menu you can Load/Save notes as a .png picture, switch to full screen, change pen color and thickness, undo last stroke and erase the notes.

Credits:

Smooth drawing application by By Dan Gries (dan@flashandmath.com)
UI Framework: JiuGongGeUI-v0.1 By Bruce Jawn
Icon Artist: Austin Andrews (@templarian)

Links:

http://www.flashandmath.com/advanced/smoothdraw/
http://www.nocircleno.com/graffiti/
http://modernuiicons.com/
Support this Free Sofware!

RealBengine - When Bengine Goes to Real 3D

This maybe the future version of my voxel based rendering engine Bengine, code name "RealBengine". Different from the current version of Bengine, which use ray-casting and is 2.5D, RealBengine will use ray-tracing and hence you will have 6 degree of freedom instead only 4. That means you can look up and down freely without any limit. The current version of Bengine can simulate look up and down a little bit using the distorted projection trick, but this is very limited - about +/-30 degree rotation around the X-Y plane at most. What's more, in RealBengine, you're working with real 3D, so most of the algorithm has been simplified because now you're using 3D vectors rather than fake 3D trick math.

And because of the essential difference in the rendering core, RealBengine will be a totally different engine and will be written from scratch in the future. However, RealBengine is not my priority for now. A similar example with source code using ray-tracing for voxel rendering can be found at:
http://bruce-lab.blogspot.com/2011/08/simple-ray-tracing-voxel-demo.html

An old working demo of RealBengine(Win32 binary):
https://drive.google.com/file/d/0B5V2PrQ8xX_EaEZ0ai1hblMwZGc/edit?usp=sharing

This demo was written in HaXe/NME and compiled to the CPP target some time ago. This is just a simple quick proof of the ray-tracing voxel rendering algorithm. The demo needs optimization as it is slow (about 10~15 FPS in my test). A Flash/SWF version exists but too slow now.

Pixel Bender, Molehill - Updates and Future Plans for Bengine

The new low-level Flash 3D API Molehill is about to launch, I don't know what it means for Bengine. For Bengine's voxel rendering, I only need a fast way to push all Screen Buffer to the Screen, though, a fast rendering algorithm is more important. Here I want to share some new demos and plans for Bengine.

First,  the game BengineRace. I added submit scores function, now you can submit three kind of scores: Best Racer for the time you spent to complete the game, High Scores for the total score you earn and Best Destructor estimate how many voxels you destroy or more specifically, voxels left in total. You must make through the game to submit scores for the first two and you can submit the score of voxels left in total at any time during the play. Press "X" to enter destroyer mode, energy required for destroying walls is limited. After you fell in holes or died, click "continue" to respawn, then voxels destroyed last time will still be contained in your final score.

Second, I made a 8-bit version of BengineRace and now have given up that idea. The advantage of 8-bit is that the screen looks "better" in a higher resolution because of fewer colors used, maybe it's more like a solid fill engine. Besides, less memory needed for storing the voxel data when you use a palette. The disadvantage is limited color choice and the trouble to design and make the palette. You can find the early build of the game in 8-bit here:
https://flaswf.googlecode.com/svn/trunk/Bengine/demo/8-bit/Bengine-8bit.swf
Some pictures:

Third, my attempt to render Voxelstein3D/Voxlap .vxl maps in Flash!
Bengine can render those maps in a low res at a slow speed.
Voxlap demo map:

demo:
https://flaswf.googlecode.com/svn/trunk/Bengine/demo/vxl/Bengine_voxlap.swf

Cave demo map:

demo:
https://flaswf.googlecode.com/svn/trunk/Bengine/demo/vxl/Bengine_cave.swf

Voxelstein3D map:

demo:
https://flaswf.googlecode.com/svn/trunk/Bengine/demo/vxl/Bengine_wolf.swf

And finally, new plan for Bengine. Bengine will be renamed to PBengine, which initially means PixelBender+Bengine but now represents for PreBengine(Editors)+PlayBengine(Game Core)+Benigne(Voxel Rendering Core)+PostBengine(PixelBender Post-Processing).
It will be a bigger project. I hope to exploit the advantage of Molehill through PixelBender in the future.
But what can PixelBender do with Bengine? Many many things, I have to say. I will mainly use PixelBender for various Post-Processing effects for Bengine. Here is a simple example showing what it will be like:
https://flaswf.googlecode.com/svn/trunk/PBengine/demo/water/PBengineWater_buggy.swf
Make sure try to interact with the water surface with your mouse.

In this demo, I use Bengine for rendering the voxels and PixelBender for the water effect. It is still buggy, the reflection is not correct. And it is terribly slow, only about 10fps in my test. I hope Molehill can make it faster. Optimazions of Post-Processing are needed, but it will be done when Molehill is available.

But how fast can Bengine be? I don't know. I'm still improving it. The rendering algorithm has been written for several times. In the past, after each written, I always thought may be it can not be faster any more. But I proved I'm wrong. Before I wrote this engine, I never expect a voxel engine like this can run at real time in flash, let alone making a playable game. So no one knows how fast it can be and how fast it will be. I will continue optimizing it. Here is the latest demo testing the rendering speed, with a slightly different rendering algorithm from BengineRace. In my laptop, it can render the same map from Bengine Race at/above 30fps.
The demo:
https://flaswf.googlecode.com/svn/trunk/Bengine/demo/speed-test/BengineSpeedTest.swf

PS: Controls for all demos mention above:
==========
W/up: move forward
S/down: move back/recharge speed
A/left: turn left
D/right: turn right
Q: look down
E: look up
----------
Z: max speed(speed*2)
X: max armor(to destroy walls)
C: max power(to fly)
----------
Space: fly
Enter: pause

STALKER flash - project by F.L.A.S.W.F

S.T.A.L.K.E.R - one of the best games I ever played now comes to flash.
This is a project by my z-ground engine .


Z-Ground is the world creator of F.L.A.S.W.F ; it is used to set up and display objects in
a fake 3D space.


Z-Ground has nothing to do with any 3D engine (like papervision ,swfz, away3D , sandy or alternativa 3D ) and flash-10's 3D support . It looks like Wolfenstein 3-D or old Doom , so it has lots of limitations , you can't look freely at any angle but at some static angles.
It is not real 3D and it doesn't use ray-casting nor voxel rendering technology.

The main technology is 3D slice engine.
Actually , it is a further development of mode-7 and z-mapping .

Here are some pics of what I have done . What I'm doing now is optimization.


Real swf demos is coming soon and I will upload the source some time later!
Main features of Z-Ground (v-0.0001):

1. Pseudo-3D with Y-axis rotation support:3D displacement ground and scrolling paramatic background.(v-1.0000)
2. Room creator:add textured walls and ceilings.(v-1.0000)
3. Z-sorting and Clipping.(v-1.0000)
4. Inter-activative environment: 3D-Movie Clip & Sprite.(v-1.0000)
5. 3D slice objects.(v-1.0000)
6. Dynamic lighting and shadows.(v-1.0000)
7. 2.5 D skeleton animation characters(v-0.0001)(powered by X-bone engine ( v-0.0001 ) - character studio of F.L.A.S.W.F )

Further development:

1. More inter-activation(v-0.0000)
2. Collision detection(v-0.0000)
3. Bump map and bump lighting(v-0.0001)
4. Terrain rendering(v-0.0001)
5. Tunnel effect (v-0.0000)
6. Free view change-look up & down screen rotation and shaking(v-0.0000)
7. Physics simulation(v-0.0000)

Links:
A Free Version of the game S.T.A.L.K.E.R. Shadow of Chernobyl:
http://www.moddb.com/games/stalker-build-1935/downloads/