[dead] [allware] JPS (fuit jupiter)

This project won’t be developed any further

Project Name: JPS

Type: 3D Game Editor

License: MIT

Recruiting: no

Links: http://sourceforge.net/projects/jpspj/

Latest distribution files: http://jpspj.svn.sourceforge.net/viewvc/jpspj/launcher/jps_latest.zip?view=log

Status: in developement

Required libraries: Java SE 6, substance, cortado, JME2 for the jme2 engine module

Java Web Start

preprepreprealpha - in progress


module chooser

sdi ui module + jme2 engine module

sdi ui structure (no laf)

main screen, no active tool

main screen, camera controller active



short test of the numpad and video player

Camera tool

Plotter, in progress, 001 Retired

Plotter, in progress, 002 Retired

Structure builder, 001


Far in the future it will be a game editor. Right now it’s a framework in developement. It’s a modular application in the sense that there is a set of basic definitions in a core package and a launcher subprogram that gathers modules to compose the application’s session.

There is one kind of module, defined in an interface named (guess it) Module.

Modules are life-cycle based entities that exist in an Application. Modules interact through the Application via type-based discovery.

There are two specialized versions of the Module type, Engine and UI. Engine abstracts the scene viewer, UI the gui functions.

I’m working on the Engine and UI definitions. Currently an UI is defined as something that can display multiple components in five different regions, i have to add the toolbar and menubar contract. The engine itself has a very basic contract: it receives, updates or removes elements and is an EngineEvent source. The engine interface will probably remains as it is: informations needed to display things will be packed in SceneElements.

I have to finish the UI contract then i’ll start creating some module to see how practical is the interaction among them. Will it work? I don’t know.

Source code and javadoc available through sourceforge. I originally planned to use Scala but i switched to Java, mostly due to poor IDE support but a few doubts in the scala memory model also kicked in.

The codebase is split into several netbeans project. The list can be found at:


Comments/suggestions/critiques always welcome.

“What’s going on”

Camera controller completed. Working on the first tool that actually draws something (the “plotter” tool)

I’m testing ui structure with the camera tool. It is not that different from the old one but the new ui (in the sdi implementation) can be more focused, displaying just components that are needed in the context activated by a tool.

Sample. The cameracontroller module allow the user to control CameraElement object (abstraction of an engine camera). The module installs a control in the top region toolbar so when the program starts it looks like this:

main screen, no active tools

when the user presses the “camera” button the module installs tool-dependent views.

main screen, camera tool active

There’s nothing new in this per se but compared to the old interface, where everything was up all the time, it’s a better behavior.

Ok, i just added something that screams in my my ears “you will never finish this project”  :smiley:

I was thinking how a help system could be appealing, usable, really helpful and things like that. Well, I like video tutorials so…

behold the mighty video-help!


In the screenshot there is a test video (elephantsdream), the plan is to create video tutorials of the functions. The help component uses html pages that can link ogg theora streams. The player is “cortado” and it really works like a charm.

The amount of work needed to produce video tutorials for the editor’s functions is overwhelming but it’s so funny i couldn’t resist  :smiley:

A short video

vimeo - jps first video

I think it may be funny to have to program running in a tablet like device so i’ll use an interaction model suitable to work in a touch screen environment.

I’ve uploaded the skeletons for the ardor3d and jmonkeyengine 3 backends. I’m not really confident with the ardor3d backend (the rendering thread doesn’t seem to die as I expected) but the integration works, the rest is just a matter of translating the jps types.

For now there are three basic skeletons (jme3, ardor3d, java3d) and one real backend (JME2).

I changed the popup numpad to be a small calculator (I don’t trust it too much because i start reading about polish notation, stack machines then I get annoyed and i wrote the first thing that came to my mind).

Not particularily useful but funny.

new pad

Next step is actually moving camera and start with the “geometry drawer” tool.

Added a zip distribution of the program to the svn repository.

svn download page

It is for testing purposes and doesn’t include the jme libraries to keep the size small (~2 megabyte)

The jps.bat file is a demo launcher. To start the program open a console session and run something like:

java -Djava.library.path=libpath -Dswing.defaultlaf=laf -cp=classpath it.tukano.jps.launcher.Main


libpath is the path of the directory that contains the JMonkeyEngine 2 dynamic libraries

laf is org.pushingpixels.substance.api.skin.SubstanceRavenLookAndFeel

classpath must include the launcher.jar file and the jars of JMonkeyEngine 2

The start command could look like:

java -Djava.library.path=“x:jps libs” -Dswing.defaultlaf=org.pushingpixels.substance.api.skin.SubstanceRavenLookAndFeel -cp .;launcher.jar;x:jmedistjme.jar;x:jmedistlib* it.tukano.jps.launcher.Main

The zip will be updated to avoid checking out the entire svn repository for people interested in looking at the progress.

Might I suggest changing the black on grey color/font scheme that dominates the instructional text?  I think something like beige in a Helvetica would look rather spiffy and greatly improve readability.

Other than that, its looking very good :D  It's cool to see you so persistent on improvements and kind of 're-inventions'

The default color combination of raven for text editors is rather shady. In beige:


it looks cleaner with raven but a bit strange with other skins (like nebula or graphite).

I guess there's a reason UI designers get the big bucks ;)  Darker colors are definitely harder to work with though, I'm working on a project that makes heavy use of black transparency now and I'm pretty sure changing one element of the design without changing everything would be impossible!

The camera tool is finished - at least if nothing else comes to my mind or a more than welcome suggestion to improve it is made.

camera tool

The user can add multiple CameraElement objects to the scene and control them. The result is similar to the jupiter camera controller but the way it works is quite different (in fact much more complicated which isn’t a good achievement but i found no other way). Btw, i’m always impressed by the amount of short lived objects the JVM can create and waste with a smile on his (her?) face.

Next step is a “plotter” tool to actually create geometries. Some kind of freehand drawing with optional constraints. I’ll try to define a 3D element that can act as a plane chooser and a cursor. Pressing the mouse will define the plane, dragging it will create a sequence of connects segments on that plane. The resulting line will be considered the outline of a 3D shape that will be created via an automatic extrusion. The 3D shape will be later refined with the same tool, switched to “sculpt” mode. Maybe.

I lied, the camera tool needed one more thing (a menu to select the current view).

The plotter cursor is coming to life. Tired of vimeo and youtube I posted the video using a java ogg player (cortado)

plotter video test 001 (java applet)

Coding that little arrowed piece of junk was a pain. In jupiter the mapping between mouse movement and 3d displacement was a little naive, here things works as they are supposed to do (the cursor moves where the mouse cursor is).

The cursor moves, now I have to do the drawing. The plotter tool requires transparent surfaces to do that so I’ve started coding the abstraction layer for materials where a Material will be a scene element that maps 3D space to 4 component colors.

pgi said:

Coding that little arrowed piece of junk was a pain. In jupiter the mapping between mouse movement and 3d displacement was a little naive, here things works as they are supposed to do (the cursor moves where the mouse cursor is).

The framerate of the video must not be doing your work justice then, the cursor seems to continuously get further away from the triple arrow widget in the video :(

The video is right.

The plotter cursor follows the drag direction but not the mouse location. I still don't know if I want the second part.

It is quite a problem coding something with no idea of what the program has to do  :smiley:

A jnlp test (~15 mb)

java web start link

It was clearly better, I just had to find a suitable way to use it across different look and feels.

To be perfectly honest I should say that I have no idea how to make something useful out of this, but it works.

plotter 002 (java applet video)

THANK YOU for changing the colors of the instruction sheet, my less bright by the day laptop screen made it nearly impossible to understand the words before :wink:

I made the final jump to Ubuntu and lost some time to get up and running again. I played a bit with the plotter

plotter 001

The 3D cursor doesn’t seem particularly useful so i’ll trash the idea.

What works well is the “build stuff extruding lines” idea: it’s like the 3D projection of a 2D vector graphics tool. I have no experience on the subject but i suppose that 3D CAD systems work like that. With a snap-to-grid button, a couple of 2D shapes and some kind of control over the grid (location, orientation, resolution) it could become something useful.

The framework itself is done, adding new modules is quite easy, there is a class to extend, a life cycle, a way to talk with other modules when needed and two predefined modules, the engine and the UI. The UI is just a bunch of empty regions where components can be placed and the Engine looks more like a database than a 3D engine.

Here’s the javadoc for the core package.


Comments appreciated.

Here's the plotter replacement (structure builder)

plotter 001

The grid can be moved on the y axis to draw stuff on different levels. I haven't put that in the video because white appearance really doesn't help understanding the 3d structure of the scene.

This is cool, I like your research-like approach :slight_smile:

Do you think that at some point in time you could put some of your knowledge into some mesh creation tool for jMP?