everything works great
i think that rescaling everything by 10 or 100 will do the job, cause I won't have to use so small values (I use such a small speed because even 1 is slightly too fast)

thanks for your effort

YAY! (or not...)
I found it! I took this example, copy-pasted it, compiled... it works, so OK. Let's start adding things one by one so that it get's like my code until it stops working...
it stopped working after I set the speed (i mean the value which multiplies the vector which is checked and then added to the resultant) to 0.2

here is the code, the SPEED is set to 1 and it works, but if you change it to 0.2 (should be bigger than moveDamp) it stops working (oh, and BTW, I changed the renderer to OpenGL and made a camera on the back of the cube)

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import com.threed.jpct.*;
import com.threed.jpct.util.*;

public class CollisionDemo {

    private static float moveDamp = 0.1f;
    private static float SPEED = 1f;
    private static float MAXSPEED = 1f;

    private Graphics g = null;
    private KeyMapper keyMapper = null;
    private FrameBuffer fb = null;
    private World world = null;
    private Object3D plane = null;
    private Object3D ramp = null;
    private Object3D cube = null;
    private Object3D cube2 = null;
    private Object3D sphere = null;

    private SimpleVector moveRes = new SimpleVector(0, 0, 0);

    private boolean up = false;
    private boolean down = false;
    private boolean left = false;
    private boolean right = false;

    private boolean doloop = true;

    private SimpleVector ellipsoid = new SimpleVector(2, 2, 2);

    public CollisionDemo() {
        Config.glFullscreen=false;
    }

    private void initStuff() {
        //keyMapper = new KeyMapper(this);
        fb = new FrameBuffer(1024, 768, FrameBuffer.SAMPLINGMODE_NORMAL);
        world = new World();
        fb.enableRenderer(IRenderer.RENDERER_SOFTWARE);
        fb.enableRenderer(IRenderer.RENDERER_OPENGL, IRenderer.MODE_OPENGL);
        fb.disableRenderer(IRenderer.RENDERER_SOFTWARE);
        keyMapper = new KeyMapper();

        plane = Primitives.getPlane(20, 10);
        ramp = Primitives.getCube(20);
        ramp.setAdditionalColor(Color.BLUE);
        plane.setAdditionalColor(Color.GREEN);
        sphere=Primitives.getSphere(30);
        sphere.setAdditionalColor(Color.CYAN);
        sphere.translate(-50,10,50);
        cube2=Primitives.getCube(20);
        cube2.setAdditionalColor(Color.ORANGE);
        cube2.translate(60,-20,60);

        plane.rotateX((float) Math.PI / 2f);
        ramp.rotateX((float) Math.PI / 2f);

        cube = Primitives.getCube(2);

        plane.setCollisionMode(Object3D.COLLISION_CHECK_OTHERS);
        ramp.setCollisionMode(Object3D.COLLISION_CHECK_OTHERS);
        sphere.setCollisionMode(Object3D.COLLISION_CHECK_OTHERS);
        cube2.setCollisionMode(Object3D.COLLISION_CHECK_OTHERS);
        cube.setCollisionMode(Object3D.COLLISION_CHECK_SELF);

        world.addObject(plane);
        world.addObject(ramp);
        world.addObject(cube);
        world.addObject(sphere);
        world.addObject(cube2);

        cube.translate( -50, -10, -50);

        Light light = new Light(world);
        light.setPosition(new SimpleVector(0, -80, 0));
        light.setIntensity(40, 25, 22);

        world.buildAllObjects();
    }

    private void move() {
        KeyState ks = null;
        while ((ks = keyMapper.poll()) != KeyState.NONE) {
            if (ks.getKeyCode() == KeyEvent.VK_UP) {
                up = ks.getState();
            }
            if (ks.getKeyCode() == KeyEvent.VK_DOWN) {
                down = ks.getState();
            }
            if (ks.getKeyCode() == KeyEvent.VK_LEFT) {
                left = ks.getState();
            }
            if (ks.getKeyCode() == KeyEvent.VK_RIGHT) {
                right = ks.getState();
            }
            if(ks.getKeyCode() == KeyEvent.VK_ESCAPE) {
                doloop = false;
            }
        }

        // move the cube
        if (up) {
            SimpleVector t = cube.getZAxis();
            t.scalarMul(SPEED);
            //t = cube.checkForCollisionEllipsoid(t, ellipsoid, 5);
            //cube.translate(t);
            moveRes.add(t);
        }

        if (down) {
            SimpleVector t = cube.getZAxis();
            t.scalarMul(-SPEED);
            //t = cube.checkForCollisionEllipsoid(t, ellipsoid, 5);
            //cube.translate(t);
            moveRes.add(t);
        }

        if (left) {
            cube.rotateY((float)Math.toRadians(-1));
        }

        if (right) {
            cube.rotateY((float)Math.toRadians(1));
        }

        // finally apply the gravity:
        SimpleVector t=new SimpleVector(0,1,0);
        t=cube.checkForCollisionEllipsoid(t,ellipsoid,1);
        cube.translate(t);

        //avoid too high speed
        if(moveRes.length()>MAXSPEED) {
            moveRes.makeEqualLength(new SimpleVector(0,0,MAXSPEED));
        }

        moveRes = cube.checkForCollisionEllipsoid(moveRes, ellipsoid, 5);
        cube.translate(moveRes);

        //damping
        if(moveRes.length()>moveDamp) {
            moveRes.makeEqualLength(new SimpleVector(0,0,moveDamp));
        } else {
            moveRes = new SimpleVector(0,0,0);
        }
    }

    private void doIt() throws Exception {
        Camera cam = world.getCamera();
        cam.moveCamera(Camera.CAMERA_MOVEOUT, 100);
        cam.moveCamera(Camera.CAMERA_MOVEUP, 100);
        cam.lookAt(ramp.getTransformedCenter());

        while(doloop) {
            move();
            cam.setPositionToCenter(cube);
            cam.align(cube);
            cam.rotateCameraX((float)Math.toRadians(30));
            cam.moveCamera(Camera.CAMERA_MOVEOUT, 50);
            fb.clear(Color.RED);
            world.renderScene(fb);
            world.draw(fb);
            fb.update();
            fb.displayGLOnly();
        }
        fb.disableRenderer(IRenderer.RENDERER_OPENGL);
        System.exit(0);
    }

    public static void main(String[] args) throws Exception {
        CollisionDemo cd = new CollisionDemo();
        cd.initStuff();
        cd.doIt();
    }
}

if(bloom.getMeaning()=="darkness also gets bloom") {
  Voter.setVote("bloom", "NO");
}
// if this "bloom" will be like this: take the render, apply gaussian blurr (or some other blurr), apply it to the main render with alpha blend ("half-transparen") then please don't do it, it will cause shadows and other darkness to cause bloom while it shouldn't... or just tell me that it won't cause such nasty effect

depth - i tried 1, 4, 6, 25
size - generated dynamically with the getMesh().getBoundingBox
threshold - i tried 0.01 and it started working but only for the smallest ramp (it's almost unnoticably rised)

the FPS example uses cameraCheckCollisionEllipsoid(), maybe it differs

maybe it's because I use cube.checkForCollisionEllipsoid, not theWorld.check..., maybe... I don't know, maybe I have to make my own SWEPT, but I don't know how... :?

damn, after commenting it out everything is cool :/

in my old DirectX game i used such thing to round to the second number after the comma so that I don't have someting like 0.0000000000001...
that's why I added it as soos as I added the "resultant vector movement" technique

thanks

first I do the gravity
       SimpleVector theG = cube.checkForCollisionEllipsoid(GRAVITY, CUBE_SIZE, 1);
        moveResultant.add(theG);
then I "move" (actually at this point I only set the resultant vector) the cube according to pressed keys
       boolean movinDaC = false;

        cube.rotateY(MX*0.01f);

        if(left && moveResultant.x>-3) {
            SimpleVector a = cube.getXAxis();
            a.scalarMul(-BASESPEED);
            moveResultant.add(a);
            movinDaC=true;
        }
        if(right && moveResultant.x<3) {
            SimpleVector d = cube.getXAxis();
            d.scalarMul(BASESPEED);
            moveResultant.add(d);
            movinDaC=true;
        }
        if(forward && moveResultant.z<3) {
            SimpleVector w = cube.getZAxis();
            w.scalarMul(BASESPEED);
            moveResultant.add(w);
            movinDaC=true;
        }
        if(back && moveResultant.z>-3) {
            SimpleVector s = cube.getZAxis();
            s.scalarMul(-BASESPEED);
            moveResultant.add(s);
            movinDaC=true;
        }
        if(MX!=0) {
            camRot+=MX*0.01f;
        }
        if(MY!=0) {
            CAMANGLE-=MY*0.01f;
        }
then comes the translaition
       moveResultant = cube.checkForCollisionEllipsoid(moveResultant, CUBE_SIZE, 1);
        cube.translate(moveResultant);

        moveResultant.x=Math.round(moveResultant.x*10)/10f;
        moveResultant.y=Math.round(moveResultant.y*10)/10f;
        moveResultant.z=Math.round(moveResultant.z*10)/10f;
and if no keys are pressed I do the velocity loss
       if(!movinDaC) {
            if(moveResultant.x>FRICTION) {
                moveResultant.x-=FRICTION;
            } else if(moveResultant.x<-FRICTION) {
                moveResultant.x+=FRICTION;
            } else {
                moveResultant.x=0f;
            }
            if(moveResultant.y>FRICTION) {
                moveResultant.y-=FRICTION;
            } else if(moveResultant.y<-FRICTION) {
                moveResultant.y+=FRICTION;
            } else {
                moveResultant.y=0f;
            }
            if(moveResultant.z>FRICTION) {
                moveResultant.z-=FRICTION;
            } else if(moveResultant.z<-FRICTION) {
                moveResultant.z+=FRICTION;
            } else {
                moveResultant.z=0f;
            }
        }

the SimpleVector CUBE_SIZE is achieved by
       float b[] = cube.getMesh().getBoundingBox();
        CUBE_SIZE.x = (Math.abs(b[0])+Math.abs(b[1]))/2f;
        CUBE_SIZE.y = (Math.abs(b[2])+Math.abs(b[3]))/2f;
        CUBE_SIZE.z = (Math.abs(b[4])+Math.abs(b[5]))/2f;

The problem is that if I move forwads it's cool but when I rotate 45 degrees (so it's positioned "diagonally" to global axis) the cube moves very slowly, like ten times slower.
Any ideas what might cause it?

openGL mode