Sessions now detailed

After some fighting with multi-threading issues, texture renderer and Line anti-aliasing, I now have CPU consumption detail appearing in the right side of the screen. I've been inspired from Ghost In The Shell SAC (which contains great ideas about GUI).

In the lower left part of the screen, we can see the active number of sessions, ie the number of connected ACTIVE sessions:



The number of detailed sessions is up to 5 but I guess I could display more.

Regarding the displayed information, I may add other ones (Logical IO, Physical IO...) :o)

Internet is back

After 10 days without Internet, I'm back on the web!

Session Control Panel r2.0, finally working!

At last, it works now with accurate collision detection using TrianglePickResults. The extruded faces are now distinguish Box (own version with only 5 faces, extrudable, with OrientedBoundingBox):



I think I even discovered a bug... waiting to update the jME 2.0 code to verify it!

A new problem: user interaction with the mouse

Currently, I'm trying to solve a common problem mainly related to multithreading, dynamic mesh (vertices moving inside a mesh), accurate collision detection (between the mouse cursor and the scene) using dynamic bounding volumes.

Following the mouse cursor (white cross) is over a far tablespace but the session control panel (dynamically extruded quarter of sphere) is in front of it. Thus the collision detection failed (I think because of the Bounding Sphere I'm using for the session panel:



Following the dynamic Bounding Sphere of the session control panel:

Small one:


Large one:

Two cool links for environment rendering

Sky scattering

Real-time grass rendering

Thanks to Mr Coder (jME)

jME 2.0 threadsafe problem with the Sphere shape

Sadly this kind of issues seems to be present in the second version, I may focus on it during a next Bug hunting party ;o)



Look the sphere in the lower left hand corner...

Session control panel r1.0

Yes!

I finally get something working:



The quarter of sphere in the bottom displays information about Oracle sessions. The more a face is extruded, the more the CPU it is currently consuming. Using fast FloatBuffer copy allows a good framerate while the TriMesh vertices are quicky updated (20 times per second).

Next: memory representation + data flows!!!

Face extrusion under JME?

I'm currently thinking about the rendering of the Oracle sessions and I guess, I've got a cool idea... but for that I'll need some sort of face extrusion to work inside JME. In brief, I would like to be able to change at runtime and with minimum resource consumption this sphere:



into:



Easy?

Dynamic mouse cursor!

Now I successfully implemented dynamic mouse cursor: when I move it over an object, it changes:
- appear/disappear
- denotes the name of the object over which the mouse is

Proof:

Third tutorial: transparency

This one is available here.

And a picture:

Second material tutorial

This one is available here.

CamStudio - Free Streaming Video Software

This tool is free and available here.

To download it: http://camstudio.org/dev/CamStudio.2.5.b1.bin.zip

Thanks nymon ;o)

Next tutorial about material: colors fading

And it seems I should use a com.jme.scene.Controller. Hopefully, the JME forum provides an example.

JME 2.X: my first bug detected...

...and corrected!

JME IRC channel

Server: kubrick.freenode.net, channel #jme.

Logs available here.

First Material tutorial

Can be found here.

Step 1: diffuse reflection only; no ambient no specular


Step 2: diffuse and specular reflection; low shininess; no ambient


Step 3: diffuse and specular reflection; high shininess; no ambient


Step 4: diffuse reflection; emission; no ambient or specular reflection


Step 5: ambient (gray) and diffuse reflection; no specular


Step 6: ambient (gray), diffuse and specular reflection; low shininess


Step 7: ambient (gray), diffuse and specular reflection; high shininess


Step 8: ambient (gray) and diffuse reflection; emission; no specular


Step 9: colored ambient and diffuse reflection; no specular


Step 10: colored ambient, diffuse and specular reflection; low shininess


Step 11: colored ambient, diffuse and specular reflection; high shininess


Step 12: colored ambient and diffuse reflection; emission; no specular

An interesting document about Quaternions

Quaternion and Virtual Trackball

Thanks to Andreas.

The HUD tutorial migrated to JME 2.X

In order to understand texturing, transparency and HUD in JME 2.X, I proposed a migration of the JME 1.X tutorial:

Tablespaces organized and scaled according to their allocated size

Finally, my tablespaces look good. The size of the "container" is proportional to the allocated size of the tablespace:



Also I've included picking feature to be able to select one tablespace and (in the future) get detailed information. However, I note right now that the BoundingBox class that I use for bounding volumes (mainly used for collisions detection and picking) is not very good for cylinders...

At last, normals work (flat and auto-smooth)

Well how may I say that... the normals present in a .blend file must not be used. They must be recomputed on a per face basis. For auto-smoothing, one must recompute per vertex normals. I've used this doc to do it.

Now I get auto-smoothed models and "faceted" models:

Translation, scaling and rotations for import

Oups I forgot to say that when a model is build in Blender then moved, scaled or rotated, these transformations are not "permanent". To make them permanent, select the object(s) then Apply the transformations using CTRL + A in Object mode.

Normals... the sequel

Well I've fought some days because of strange behaviour regarding normals in Blender and I'm beginning to know what I'm talking about (at last).

To export a Blender model in JME, consider modeling as if the rendering view (JME) is Y axis Up (keypad 7). Thus you won't have to rotate by yourself while exporting (or worse importing).

After that you'll have to deal with the normals as I've done. Your normals can be displayed in Edit mode using the Edit Panel called "Mesh Tools 1" (F9 key):



Note that the panel may be hidden on the right of the window so either scroll or collapse some panels (see in red). To display the vertices normals, you'll have to push down the "Draw VNormals" button.

Then you'll perhaps be able to detect normals inconsistencies as I did: a same point had several different normals.

Also it would be useful not to rely on vertices normals but preferably to recompute the normals for every faces. Thus you get a "solid" looking object but at least you don't get annoying effects when moving your objects while lights are activated.

Finally, you may want to flip the normal when in Object mode, a face seems to disappear.

Next steps: material and UV-mapping!

The next steps in my Java Blender file reader/parser: interpret material data and particularly UV-mapping :) How fun this will be, I've no idea ^_^;

Blender and normals argh!!

Being relatively a newbie to Blender, I fought to render properly my tablespace object during days until today! I've found that some normals of the faces of the fan are fliped thus producing a very bad render!

After fliping them back to normal (W key in Edit Mode), the rendering is now good; at least not more "annoying light effect" :)

First JME contribution; the DevelopmentState

Screen shot:

A JME forum thread can be consulted here.

Rotation and normals weird behaviour

As I'm struggling with JME 2.0, I encountered a strange issue, while applying a continual rotation on my object, I can see different light applications which produce weird effects. Displaying the normals (thanks to the DebugGameState), it appears that the rotation is not applied to them :(

Rotation 1:


Rotation 2 (the rendering is quite different!):


Rotation 1 and normals:


Rotation 2 and normals:

Development state

As it is really hard to distinguish something in the default black world of JME, I'm developping a DevlopmentState inspired by Blender "3D view" and DebugGameState:


But as you can see, it seems my Lines are subject to light. Now looking in the Spatial class, I've found quite easily (thanks to the documentation and the simplicity brought by Java 5 Enums) that I should have set the LightCombineMode of my Lines. Setting it to Off solved my problem:

Multiple mesh to build an object... or a Node

Now, the BlenderReader class can interpret Blender parent/children hierarchy and implements it as Node/Geometry for JME. :)

Blender to JME 2.0 - very first rendering

My tablespace now renders:

JME 2.0 - pre alpha

JME version 2.0 is currently under development, more information: here

After having downloaded Subversion and Maven 2, a quick installation of the thirdparty libraries (see: ./lib/mvn-lib-install); a simple mvn install run successfully!

Just one very small mistake: the version in the pom.xml file should be set to "2.0-SNAPSHOT".

And the tests run with success, well done!

Now I'm waiting for the wiki to have more information on this release ;o)

Lamp, Camera and Object data blocks

Each Lamp and Camera is linked to an Object through there blockAddress. This address can also be found in the correponding Object in the data property.

Now, I can import lights into JME!!!

Next: meshes!

Deeper into Blender file format

It appears that the DNA1 data block is the most important one. It is a sort of meta-block because it describes the structure of all other blocks.

I've successfully created a Java class generator that can write a Java class file from DNA1 information. I've worked only on the 32bits / little endian version of the format.

Using these classes (280+), I'm now able to decypher a Blender file.

The next step will consist of understanding the links between data blocks and the meaning of the data blocks of type DATA.

From Blender to JME

I'm currently having a close look (thanks to open source) on the way .blend files (version 2.45) are formated. I'm confident to be able to directly import .blend file into JME then saving them into JME native format.

The .blend file structure is simple and consists of multiple blocks independent from each others thus guarantiing compatibility among different Blender versions (newer and older).

These blocks require to firstly decode the DNA1 structure which mainly consists of the description of the internal C object types (length and C structs...).

JME - Java Monkey Engine

Java Monkey Engine has of course been chosen to handle 3D in Java.

Importing objects created in Blender into JME seems complex and require export of the models (MD5 or Collada) and then thirdparty Java classes to import them into JME object definition... Somewhat hard regarding the tools being no more supported or not complete.

Tablespace: basic model

The basic model is created. Texturing and without doubts new faces will allow good rendering.

3D models

I'll use the free tool blender.

Tablespace design

A tablespace will look like this. The upper part will turn according to write and read activity. The two tubes will show read and write activity as well. If intense activity is detected, it may turn to bright red. The tablespace name will appear on the 3D object. Clicking on the object will display a small chart displaying tablespace files activity.

Starting

Oracle Fun: work with the Oracle database while having fun.

I'll try to detail the steps I'll use to build a new tool around the Oracle database: a 3D monitoring tool !?!