jPCT-AE

Jpct-ae is a 3D game engine focused on the Android and Java markets. There are actually two versions of it, one for Java which can output games for PC and Mac and another one for Android. Jpct-ae is a lightweight API distributed for free.

FEATURES

As a 3D game engine, Jpct-ae includes the options to create primitives only and doesn’t offer full 3D modelling. By primitives we mean you can build polygons like cones, cubes and spheres but can’t create a full model with. However, you can always import your models from your preferred 3D modelling program. The Java version loads 3DS, OBJ, ASC, MD2 and XML files. When it comes to textures, it uses a single pass multi texturing system using a maximum of 4 stages. It has a render to texture and texture compression built-in. In the Java version, it also supports OpenGL.

The physics support is pretty good and allows you to calculate collisions much easier than doing it normally in Java. It supports ray-polygon, sphere-polygon and ellipsoid-polygon.

It allows OpenGL up to 2.0 version for most versions of Android and also uses the same system to support the default shaders via GLSL.

When it comes to light support, you can use the most commonly used in the industry like ambient, diffuse, specular and vertex lightning. It also allows the usual effects like fog and transparency.

Jpct-ae is a Java based API and as such, it is mandatory to know that programming language to build any games with it. It doesn’t have any visual interface to create your assets so, you will have to import them.

The Bones API can be used with Jpct-ae for you to animate your models. This is a very good animation API, used by many other game engines. Many AAA games have been animated with this API.

One of the worst features about Jpct-ae is the lack of documentation or tutorials. It is not really difficult to figure it out if you are an experienced programmer, but for the young developer who has never built a program it is near impossible. There are, of course, millions of tutorials on how to learn to program in Java, because this will be essential in your adventure to create games with Jpct, but how to use the game engine itself can be a little bit tricky even for expert programmers.

So, if you go with this option to build your games you are going to have to learn Java. Basically, there are a few useful classes included in the engine to easy your life as a developer, but not much more.

Jpct-ae is a free distribution program with a very open license. For the most part you can do whatever you want with your project and you won’t have to pay anything to download or to create games. Once you distribute your games and you are making money with them you don’t need to pay anything either. You don’t even have to mention you used this program in the credits or any splash screen, albeit it would be a nice thing to do.

However, you are not allowed to tinker with the game engine in any way. The source code is not available and you can’t use reverse engineering on it. The classes must stay as they are.

The community behind Jpct-ae is quite small due to most of its users being experienced Java programmers who don't need much help, but you can find some help in the official forums. Don’t expect to find a whole lot of tutorials and videotutorials. Actually it is difficult to find even basic information about this game engine.

Jpct-ae is a pretty difficult to use engine and needs of a lot of code to do things that can be done easily with other game engines. For example, the following is a snippet for you to create a cube.

Object3D box=new Object3D(12);

SimpleVector upperLeftFront=new SimpleVector (-1,-1,-1);
SimpleVector upperRightFront=new SimpleVector (-1,-1,-1);
SimpleVector lowerLeftFront=new SimpleVector (-1, 1,-1);
SimpleVector lowerRightFront=new SimpleVector (1,-1,-1);

SimpleVector upperLeftBack=new SimpleVector (-1,-1, 1);
SimpleVector upperRightBack=new SimpleVector (1,-1, 1);
SimpleVector lowerLeftBack=new SimpleVector (-1, 1, 1);
SimpleVector lowerRightBack=new SimpleVector (1, 1, 1);

//Front
box.addTriangle(upperLeftFront, 0,0, lowerLeftFront,0,1, upperRightFront, 1,0);
box.addTriangle(upperRightFront, 1,0, lowerLeftFront,0,1, upperRightFront, 1,1);

//Back
box.addTriangle(upperLeftBack, 0,0, lowerRightBack,1,0, lowerLeftBack,0,1);
box.addTriangle(upperRightBack, 1,0, lowerRightBack,1,1, lowerLeftBack,0,1);

//Upper
box.addTriangle(upperLeftBack, 0,0, upperLeftFront,0,1, upperRightBack,1,0);
box.addTriangle(upperRightBack, 1,0, upperLeftFront,0,1, upperRightFront,1,1);

//Lower
box.addTriangle(lowerLeftBack, 0,0, lowerRightBack,1,0, lowerLeftFront, 0,1);
box.addTriangle(lowerRightBack, 1,0, lowerRightFront,1,1, lowerLeftFront, 0,1);

//Left
box.addTriangle(upperLeftFront, 0,0, upperLeftBack,1,0, lowerLeftFront, 0,1);
box.addTriangle(upperLeftBack, 1,0, lowerLeftBack,1,1, lowerLeftFront, 0,1);

//Right
box.addTriangle(upperRightFront, 0,0, lowerRightFront,0,1, upperRightBack, 1,0);
box.addTriangle(upperRightBack, 1,0, lowerRightFront,0,1, lowerRightBack, 1,1);

box.setTexture(“base”);
box.build();

As you can see, it is not an easy thing when you compare it to other SDKs where you only have to drag and drop a cube to the main screen or just go to the options and hit the create cube button.

However, it is not so difficult to create controls to move your camera like for example in a FPS. Take a look at the following snippet.

In the first 2 lines we say the engine we want to assign the movement of the mouse to the variables. In the last lines of it we say to the program we want the camera to move according to the variables, and then to the movement of the mouse. Not too difficult.

int dx = <mouse delta x>;
int dy = <mouse delta y>;

if (dx!=0) {
       camera.rotateAxis(camera.getYAxis(), dx/500f);
}
if (dy!=0) {
    camera.rotateX(dy/500f);
}

PROS and CONS

PROS

• Lightweight
• Free
• Java based

CONS

• Not simple or intuitive to use
• A bit outdated
• No strong community supporting it
• Need to code a lot, actually almost everything
• Doesn’t support many platforms
• Lack of documentation or tutorials to use it

CONCLUSION

This is a very particular engine, designed for Java users. It can be powerful, because Java is a very powerful programming language but the game engine itself doesn’t offer much help or features when you compare it with other game engines out there. The fact that you can’t create your assets with it and that it is not visual at all makes it cumbersome and almost impossible to use for somebody who is not used to coding so much. Also, there is a heavy lack of documentation online, because it is not a widely used game engine. If you are a young developer who wants to start in the world of game developing, this shouldn’t be your first option unless you want to learn Java first. However, if you are already an expert Java programmer, this game engine may give you what you need to create your games.