jPCT-AE Game Development App

jPCT-AE

by Jpct

free 3D solution for Java and Android
Helps with: Cross Platform Frameworks,Game Development
Similar to: Candroid Engine App Wire3D App Adobe Air App Ardor3D App More...
Source Type: Open
License Types:
Supported OS:
Languages: Java VB.NET Java Script

What is it all about?

jPCT-AE with its easy to learn API offers you all the features you need to write a cool looking, mobile 3D game, simulation or business application for Google's Android platform in a short time. jPCT-AE is light weight and only loosely coupled to the OpenGL context. It doesn't force you into a specific code structure and can be used in any Acitvity.

Key Features

•optimized for the Android mobile platform, works fine on OUYA •supports OpenGL ES 1.x and 2.0 on Android 1.5 or higher •loads 3DS, OBJ, MD2, ASC and serialized files •keyframe animations (from a MD2-file or self defined) •skeletal animations via raft's Bones API •shader support via GLSL for OpenGL ES 2.0 •offers a set of default shaders to ease ES 2.0 usage •supports anti-aliasing •supports advanced depth buffer settings on NVidia Tegra devices •vertex, ambient, diffuse and specular lighting •build-in primitives like cones, cubes, spheres... •render to texture •texture compression •in memory compression •supports swapping texture and vertex data to SD •collision detection (ray-polygon, sphere-polygon and ellipsoid-polygon) •generates vertex normals, face normals and tangent vectors automatically •pixel perfect, geometry based picking •transparency and fog effects •billboarding •lens flares •single pass multi texturing using up to 4 texture stages •support for VBOs, FBOs and vertex arrays •support for octrees for rendering and/or collision detection


Pricing

Yearly
Monthly
Lifetime
Free
Freemium
Trial With Card
Trial No Card
By Quote

Description

see site

Alternatives

View More Alternatives

View Less Alternatives

Product Analysis

Game Development

Frameworks and cross platform libraries for game and graphics development

jPCT

jPCT

By Hugo Reyes | 9/28/2016 | Product Analysis |Beginners

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.

 

By Hugo Reyes | 9/28/2016 | Product Analysis

{{CommentsModel.TotalCount}} Comments

Your Comment

{{CommentsModel.Message}}

Top DiscoverSDK Experts

User photo
1820
Shelley Beck
Game developer for 8 years now.
Mobile | Game Development
View Profile
User photo
1220
John Cole
Experienced Cross-Platform developer.
Mobile | Game Development and 2 more
View Profile
User photo
1130
Nikki Morrison
12 years of experience in game development.
Mobile | Game Development
View Profile
User photo
1130
Jesse Noiman
Experienced developer of Cross-Platform games and applications for mobile devices.
Mobile | Game Development and 1 more
View Profile
Show All

Interested in becoming a DiscoverSDK Expert? Learn more

X

Compare Products

Select up to three two products to compare by clicking on the compare icon () of each product.

{{compareToolModel.Error}}

Now comparing:

{{product.ProductName | createSubstring:25}} X
Compare Now