jMonkeyEngine.org » jME3

jMonkeyEngine 3 SDK Alpha-2 Released!

admin — Sun, 29 Aug 2010 19:23:15 +0000

The jMonkeyEngine team is happy to announce the release of jMonkeyEngine3 SDK Alpha-2!

Many improvements have been made to the core jMonkeyEngine as well as to the jMonkeyPlatform since Alpha-1 and generally jME3 is gaining more and more steam. We are happy to see many new users and even contributors and that tells us that we are on the right way. Everybody is very determined to make the jME3 SDK a premier OpenGL and game development tool and we are just as eager as you to see a beta soon .

See a partial list of changes hee:

jMonkeyEngine

PSSM / SSAO
Picking / Collision fixed
New Input System
Many Physics improvements, esp. Vehicle
Physics load/save
First implementation of a water shader (WIP)
Many small bug fixes and added methods

jMonkeyPlatform

Way faster jMP due to fixed logging bug
Material (j3m) editing in jMP (video)
Improved SceneComposer (see video below)
Linking of models into scenes (see video below)
Physics support in SceneExplorer
Texture editing tool
Online Documentation for jMP and jME3 via “F1″
GLSL Code Editor (Contribution Center)
Collada Import (Contribution Center, Alpha)

This is the first release that introduces a new installer and by using advanced compression, we were able to reduce the release download size to 75MB, including jMP, jME and all test data.

jMP alpha-2 also introduces the “jMonkeyPlatform User Contributions” update center. If you go to “Tools”->”Plugins”->”Available Plugins” you can install some new plugins to jMP that are not part of the core jMP but have been contributed by users or are packaged from external libraries/projects (Category jMP User Contributions).

Download jMonkeyEngine3 SDK Alpha-2 for your OS now:

If you have problems after installing, delete your jMonkeyPlatform settings folder:

Windows: C:\Users\\AppData\Roaming\.jmonkeyplatform
Windows (alt): C:\Users\\.jmonkeyplatform\
MacOSX: /Users//Library/Application Support/jmonkeyplatform
Ubuntu: /home//.jmonkeyplatform

Happy coding,

the jMonkeyEngine Team

Screen Space Ambient Occlusion for jMonkeyEngine 3.0

nehon — Mon, 16 Aug 2010 22:54:03 +0000

Everybody in the 3D computer graphics neighborhood has heard about SSAO, but what is really hiding behind those four letters?

If you want to know, this paper is for you. This is a quick abstract on the technique, with a focus on how it has been implemented for JME3.

What is ambient occlusion?

Ambient occlusion refers to the shadows that nearby objects cast on each other under an ambient lighting. It‘s an approximation of how light would radiate in a real life scene.

It usually entails casting rays from each point of a surface in random directions; lighten the point if the ray reached the background, darken it if the ray reached an object.

As you might have guessed, this method put a heavy burden on the CPU, and is not yet exploitable in real time 3D.

However in 2007 Perumaal Shanmugam and Okan Arikan released a paper on a hardware accelerated implementation available here.

What about the “Screen Space” thing?

First time SSAO acronym popped out was in this paper by Crytek in 2007 (chapter 8.5.4.3)

They explain how they managed to implement ambient occlusion in the Cry Engine 2 for the game Crysis, by comparing depth for each pixel 3D position neighborhood in a full screen quad pass. This is a credible alternative to the “real” AO implementation that makes it usable in real time 3D graphics.

What about jMonkey Engine 3.0?

Since then, there are a lot of implementations available on the Internet (some of them available in the reference section), but a particularly clever implementation got my attention in A simple and practical approach to SSAO by José María Méndez on GameDev.net. It’s fast, simple, and gives very good results.

The idea is, for each pixel of the scene, we take a random sample of pixels around it and calculate it’s occlusion factor using the distance between samples and angular difference between the receiver´s normal and the receiver to occluder direction. For more details I suggest you read the paper.

I made a GLSL version of this implementation with little adaptations to it :

- I only use front faces as this is faster and gives sufficiently good results.

- I don’t sample a position buffer as advised by the author because it requires extra memory and an extra scene render pass. Moreover I wanted to take advantage of the fact that JME3 can sample for “free” a depth texture of the scene during the main render pass. I reconstruct the 3D position of each pixel from depth using the one frustum corner method.

- For the random sampling, instead of using a random texture, I use a random function suggested by Martin Upitis in this game-dev thread. It’s a little faster and gives a more regular repartition of the samples, thus avoiding the common “grainy” look of SSAO. It also gives a smoother result so the AO looks good on the rendered scene even without an additional blur pass. However it makes some banding artifacts, and for high quality render purpose, I will probably implement an optional blur pass for the filter.

jME3 has a SceneProcessor system that allow the addition of custom scene processing to a view-port (Shadow processing for example). I had already implemented a 2D filtering post processor (more info in this post), so I just implemented an SSAOFilter for this processor.

I had to adapt the processor in order to allow a filter to compute a pre-rendering pass (here for the normal buffer sampling).

So now SSAO can be stacked with any other 2D filter on a scene.

What will monkeys have to do to use this awesome feature?

- Create a FilterPostProcessor and add it to the view-port.

- Create a SSAOFilter and add it to the processor

- Maybe play a little with SSAO configuration parameters, but that’s more of an artist duty.

Voilà!!

By Rémy Bouquet aka nehon

References

Forum History

http://www.jmonkeyengine.com/forum/index.php?topic=14393.0

http://www.jmonkeyengine.com/forum/index.php?topic=14624.0

Nvidia SSAO implementation

http://developer.download.nvidia.com/SDK/10.5/direct3d/samples.html

Presentations from NVIDIA :

http://developer.download.nvidia.com/presentations/2008/GDC/GDC08_Ambient_Occlusion.pdf

http://developer.download.nvidia.com/presentations/2008/SIGGRAPH/HBAO_SIG08b.pdf

http://developer.download.nvidia.com/SDK/10.5/direct3d/Source/ScreenSpaceAO/doc/ScreenSpace AO.pdf

StarCraft2 SSAO implementaion

http://developer.amd.com/gpu_assets/S2008-Filion-McNaughton-StarCraftII.pdf

Which do I choose: Old yet steady jME2, or new and developing jME3?

Erlend Sogge Heggen — Sun, 08 Aug 2010 18:28:53 +0000

Lately the question of ‘which version of jME should I choose?’ has been coming up frequently, mostly to our great delight of course. However unless we give newcomers some straightforward principles for them to make an informed decision for their project, we’re gonna keep repeating ourselves. That’s why I started this collaborative mini-event. Most of the suggestions actually came in through online chats, but the event was a success none the less. The comparison as of today is posted below, but please refer to the Do I Choose jME2 or jME3 wiki page for up-to-date information. As a bonus, I finally updated the technical comparison to a wiki page as well, courtesy of Kirill’s previous writeup.

Why choose jME2?

Stability right now

jME2 has been deemed stable since 2009, with no major feature additions or reworks since 2008. Although there are plans for a final point version release (2.1), jME2 is practically in complete feature freeze.

Support for low-end computers

jME2 fully supports OpenGL 1, while jME3 does not. Coupled with careful programming this means you can achieve very low hardware requirements for your project.

Abundance of Community Tools

With well written utilities like SceneMonitor, SceneWorker, HottBJ exporter as well as others ensure that you aren’t starting your path to jME enlightenment with a blank slate.

Thoroughly documented

There are literally hundreds of pages of documentation for jMonkeyEngine 2.0, detailing development practices with the engine from beginners’ levels through intermediate to advanced. Do note however that as jME3 grows more popular this documentation will be maintained by the community alone (see ‘Ever-improving documentation’ in the jME3 section below).

Why choose jME3?

Current- & next-generation graphics

From the beginning, jME3 was designed with modern principles and hardware in mind. Being shader based and only supporting OpenGL 2 or higher, jME3 is meant for the higher end of today’s computers, and what’s yet to come.

Actively developed

As opposed to it’s legacy counterpart, jME3 is very actively developed by a team of core developers and a huge community of contributors. Any aspect of jME3 can be brought up for debate at any time.
P.S. The earlier you get involved the greater the chance you can have a changing impact on the project.

Ever-improving documentation

The majority of new docs created today are documentation for jMonkeyEngine3. While naturally part of a grand community effort, these docs benefit greatly from the added support and continued iteration by core team members.

jMonkeyPlatform

With jMonkeyPlatform jME3 is the first jME version with a dedicated platform for application development, deployment, asset management and composition tools.

Integrated Physics

jME3 is also the first jME version to include a physics implementation by default. It is based on bullet physics and is developed and maintained by the core team.

We’ll be so happy to have you!

Naturally we are thrilled every time someone has decided to adopt jME3 for their [game-] development needs. Prospectively speaking, this means more testing, more commits, more buzz, more projects, more innovation; better community.

>>>

For something strictly technical, check the official comparison of the two engines.

jME3 SDK – First Alpha Release

Erlend Sogge Heggen — Mon, 17 May 2010 22:08:19 +0000

It is truly a historic day ladies and gentlemen! For today, on the 17th of May, Norway became independent. Oh, and jMonkeyEngine 3.0 releases its first official ALPHA!

Direct Download – jME3 SDK Alpha1, no questions asked, for the impatient and daring.

We have decided to release jME3 in two different packages:

jMonkeyEngine3 SDK (includes jMonkeyEngine3 and jMonkeyPlatform)
jMonkeyEngine3 Standalone (includes jMonkeyEngine3 only)

Go to our download repository and pick whichever flavor suits you.

Showcase videos

jMonkeyEngine3 Demo Video

jMonkeyEngine3 SDK Demo Video

Documentation

If you’re wondering how the new jME3 matches up to the good ol’ jME2, check out the newly updated comparison, and join in on the discussion if you want to have your say.

We are also attempting to build an exhaustive list of all current and upcoming features. As of this writing, only the current and most complete features are listed.

Now let’s talk community!

Please read our contributor’s handbook. Make sure you don’t miss the part about reporting bugs. This is an alpha after all.

We could also use more video footage.

Frankly, we’re all rather exhausted now! There’s so much in store for the days to follow though. Here’s a taste:

Plenty more showcase contents
Webstarts!
What’s up next? (general core, Android, terrain, jMonkeyPlatform plugins)

Happy Alpha Day, fellow jMonkeys!

~ jMonkey Team

jMonkeyEngine 3 now available through nightly builds

Momoko_Fan — Sat, 10 Apr 2010 07:14:21 +0000

If you’re afraid of SVN, fear no more. jME3 builds are now available to download right here:

http://www.jmonkeyengine.com/nightly/

Included you will receive the jars, libs, and javadoc, all that is necessary to use jME3 in an application. Developers who want to view the source code or compile jME3 should use SVN instead.

Note that the date in the builds are in US format, e.g the first number is month, then followed by the day of the month, not the other way like in Europe.

jMonkeyEngine 3.0 gets a very nifty GUI

Momoko_Fan — Wed, 07 Apr 2010 01:47:27 +0000

For those who haven’t heard, NiftyGUI is a powerful and flexible GUI library for games and multimedia applications. I have taken some time to write a complete implementation of NiftyGUI for jME3. This means you can now write user interfaces for jME3 easily by using this library! Nifty uses XML internally, so no Java experience required to make the guis, plus it supports a wide range of effects and styles. Update from SVN and check jme3test.niftygui.TestNiftyGui to see the official tutorial demo running in jME3.

Also an mention should also be given to some efforts to get Nifty to work in jME2. void256, the creator of NiftyGUI himself is directing that implementation. An attempt is already in NiftyGUI SVN. It isn’t ready for use yet, but it will be soon.

Normen joins the 'core' – whatever that is

Erlend Sogge Heggen — Thu, 11 Feb 2010 16:17:00 +0000

Please join us in the welcome of Normen Hansen ‘normen‘ to the jMonkey Engine ‘core team’. This entity, the ‘core’, has yet to be properly detailed in a more public, formal manner. Regardless, it represents the small group of dedicated people whos main goal is to further ‘jMonkey’ and everything it stands for. To reiterate, the team is now as follows, in order of join date.

The ‘Core Team’

Kirill Vainer ‘Momoko_Fan’

Lead Programmer, jME3 Architect
Student at New Jersey Institute of Technology

Erlend Sogge Heggen ‘Sadr‘

Project Manager, Junior Webmaster
Student at Vancouver Film School (on-hiatus)

Skye Book ‘sbook’

Project Manager, Senior Webmaster
Student at Polytechnic Institute of NYU

Normen Hansen ‘normen’

GDE architect & general integrations
Engineer at a theater in Bremen

We have been in close contact with Normen over the course of three weeks now, getting to know his personality and working habits. Reckon he’ll fit in just fine

Normen’s prevalent projects:

jBullet-JME
This jBullet integration coupled with Normen’s overall dedication on the forum is what made him stick out in the first place. This integration will almost certainly find its way into JME3 at a later point, so it’s well worth getting affiliated with.

GDE for JME3
This here is Normen’s pet project, and will probably stay as such for some good weeks ahead. With an influx of novice programmers (e.g. ‘designers’ such as myself) we have seen an increased interest in JME usability. A full featured GDE is just what we need to widen JME’s appeal to all kinds of game designers, without affecting the solid base of technology underneath.

Thanks for listening, and please don’t hesitate to let us know if you think you could be an asset to the JME project.

contact@jmonkeyengine.com

~ Erlend Sogge Heggen

Android Support Confirmed for jME3

admin — Wed, 10 Feb 2010 07:45:52 +0000

It’s an interesting time in the gaming world as devices other than PC’s and Consoles are gaining the horsepower required to run real 3D games. These powerful little devices are bringing a new aspect to the physicality of gameplay with their many integrated features. Accelerometers, touchscreens, camera, even GPS! All aspects of the device are being drawn upon for various applications and now for games. With that in mind, a member of the jMonkeyEngine team made an announcement in the forums that he was instituting Android support for the third installment of the engine.

Running a jME3 Demo Inside of Android

The adoption of Android abilities into jME3 means big things for game developers using the engine. The ability to develop for many platforms with expertise in one engine will empower jMonkeyEngine users like never before. Games, scientific applications, and just about anything else you can dream up are all coming to an Android phone near you. One of the most portable, and open source, engines around just got more accessible.

Android has made a splash in the mobile industry not only as the first operating system to be put forth by Google, but by being the first real competitor to Apple’s iPhone OS. The operating system is currently available on a number of phones including the HTC Dream(marketed as the G1), HTC Hero (marketed as the G2), Motorola Droid, and the Nexus One. More phones are forthcoming meaning that Android is likely to keep getting into new hands.

Excited? We sure are. Hop over to the forums, start playing with jME2 or the in-development jME3, and join in the fun!