http://www.jpct.net/download/jpctapi.zip

1. google for 'visio.xsd' , download it (5 min)
2. use Apache XMLBeans to generate XML stubs for visio document schema (5 min)
3. create custom property set and a couple of simple objects (walls, buildings  and trees) - 10 min
4. write a testcase for loading templates and objects on map - accessing coordinates, bounds and custom property sets - 15 min.

Hey Manu,

try this

model.rotateZ(z);
model.rotateMesh();


- added animated characters to the new terrain. a
- added weather conditions to the world

I recall the first time I came here looking for a 3d applet engine. The cool thing about jPCT was its simplicity, lightweightness and compatibility with older VMs. I still think it is the #1 solution for applets that need 3D.

  I admit i had a slight feeling of FUD after using jpct for a half of a year. It seemed that the development would stuck after going to desktop.  I did research on other engines jME and XITH and to my surprise they turned out to be even FUDer because of the feeling of incompleteness, overcomplexity and the way they are developed.

The right way to go is to consider JPCT not the silver bullet but stable and usable 3D java middleware. It does have own pros and cons thought but turns out to be well-suitable for most cases.

Talking about the future, i am not sure what are motivations for Egon to make this project evolve. JPCT is not affiliated by any business (I hope this is a subject to change in future to get motivation ), does not have community contributions, lacks demos and promotion. IMO working in these directions should reduce FUD and give the project more marketing value.

Added texture maps to map builder.
Different textures could be bound to colors of pixels on texture map


this is how the relief map looks like:


texture map that defines textures for map squares:


and the result:

- Animation editor redesigned to support custom skeletons

animation editor


naked character

Sand storm on the surface ...


Here is the terrain generator code that uses images to generate 3D terrain. ClientFactory.addPlane() generates rectangle by 4 points, the code should be somewhere here in one of the forums.


//load map image and grab pixels data
        Image map = ClientFactory.getImage("/resources6/test_map2.gif").getScaledInstance(MAP_WIDTH, MAP_HEIGHT, Image.SCALE_SMOOTH);
        PixelGrabber pg = new PixelGrabber(map, 0, 0, MAP_WIDTH, MAP_HEIGHT, true);
        pg.grabPixels(0);
        int[] pixels = (int[]) pg.getPixels();

        //create terrain object
        ground = new Object3D(pixels.length * 4);

        //store map heights
        int[][] cols = new int[MAP_HEIGHT][MAP_WIDTH];

        for (int i = 0; i < pixels.length; i++) {
            int x = i / MAP_WIDTH;
            int y = i % MAP_WIDTH;
            int col = getCol(i, pixels);
            cols[x][y] = col;
        }

        //preload random textures for map tiles
        String[] textures = new String[]{
            "/resources6/test_texture.jpg",
            "/resources6/test_texture2.jpg",
            "/resources6/test_texture3.jpg",
            "/resources6/test_texture4.jpg",
            "/resources6/test_texture5.jpg"
        };
        for (int i = 0; i < textures.length; i++) {
            ClientFactory.getTexture(textures[i]);
        }
       
        //add polygons to Ground
        for (int i = 0; i < MAP_HEIGHT - 1; i++) {
            for (int j = 0; j < MAP_WIDTH - 1; j++) {

                int nw = cols[i][j];
                int ne = cols[i][j + 1];
                int se = cols[i + 1][j + 1];
                int sw = cols[i + 1][j];

                int x = j;
                int y = i;

                int textureId = TextureManager.getInstance().getTextureID(textures[(int) (Math.random() * textures.length)]);

                ClientFactory.addPlane(ground,
                        new SimpleVector(x * CELL_SIZE, y * CELL_SIZE + CELL_SIZE, HEIGHT_PER_UNIT * sw), //sw
                        new SimpleVector(x * CELL_SIZE, y * CELL_SIZE, HEIGHT_PER_UNIT * nw), //nw
                        new SimpleVector(x * CELL_SIZE + CELL_SIZE, y * CELL_SIZE, HEIGHT_PER_UNIT * ne), //ne
                        new SimpleVector(x * CELL_SIZE + CELL_SIZE, y * CELL_SIZE + CELL_SIZE, HEIGHT_PER_UNIT * se), //se
                        CELL_SIZE,
                        textureId);

            }
        }

        ground.calcNormals();