jMonkeyEngine.org

There are local version of most (if not all) vector methods that store the result in the vector itself, e.g. Vector3f.addLocal(Vector3f) rather than Vector3f.add(Vector3f).
Vector3f.scaleAdd(float, Vector3f), however, is local already.
To do the calculation v = v + F*(dt/m), where v and F are vectors and (dt/m) is a scalar, you could do v.addLocal(F.multLocal(dt/m)).

you can use TempVars.
It’s a JME Util class that reuse the variables.

usage is

TempVars vars = TempVars.get();
Vector3f v = vars.vect1;
....
do your stuff;

vars.release(); //don't forget to release the vars

Really, JME misses a decent add and multiple method on Vector. There is the very strange scaled vector add one that seems three kinds of backwards to me but not a simple addScaledVectorLocal() which is an extremely common operation to want to do.

I ended up just writing a util method that operates directly on the fields:
public static Vector3f scaledAdd( Vector3f target, Vector3f source, float scale ) {
target.x += source.x * scale;
target.y += source.y * scale;
target.z += source.z * scale;
return target;
}

And in my double-based math stuff I have a version of this method on my own Vector3d.

No, it’s just not possible. There is no implementation that would work… especially since vector3f exposes its fields directly. There just isn’t a way to do it without killing the performance of everything for everyone.

We cannot protect users from all of the mistakes they will make. So there must be a balance between performance and safety.

thank you pspeed
scaledAdd( v, F, dt );
scaledAdd( r, v, dt );
works well, I dindn’t know that x,y,z fields of Vectro3f are visible externally from class. It’s for me much better than make it private.

I’m a bit lost in the other discussion. Nevertheless – it would be also usefull to know when a vector is cloned and when just pointer is copied
for example in
Box1 = new Geometry(“Box”, new Box( A, B);
A.addLocal(1,1,1);
Would this change position of Box1? – This is just example, I’m always not sure anywhere where I pass vectors.
It’s again question about effectivness, I don’t want to bother writing own rutines, if I find that somewher in to process of rendering new objects are still created and that this kills CPU and memory performance.

Or maybe allocation of new objects is not a problem in Java? – as said normen?

normen > thank’s

OK, just last question, what is recomanded (most efficient) approach if I want vizualize motion of large number (thousands) of simple objects according to user defined equations of motion?

The easies way I see is to make one instance of the objects

class MyBody{
float vx,vy,vz; // velocity
float x,y,z;  // possition
float mass;
}

to propagate equation of motion, and an other instance (of type com.jme3.scene.Geometry) to visualize it?
however I guess com.jme3.scene.Geometry need large amount of memory, and also it could be a slow-down to move all Geometry instances in each frame by myGeometry.setLocalTranslation(MyBody.x, MyBody.y, MyBody.z);

I’m not sure if geometry class is supposed to be used this way to visualize large number of very simple objects (Box, sphere)

Actually I did a test some time ago with jbullet, that uses a object pool normally, I changed that with normal object allocations, performance difference where on modern jvm near to 0%
Why?
Cause the jvm can!!! stackallocate objects when it determines that you dont use them outside of the scope.
So methods like

Vector3f scale(factor,result){}

can allocate internal used objects with nearly no cost at all, as long as you only return the already given variable you give the JIT compiler much freeroom to do such tricks, While still having a complete defensive coded method with no sideeffects.

Bonus JIT:
The jit can do this under certain circumstances as well, when you instanciate a new object and return this, for example

public void applygravity(){
    local pos = getTranslation()
    pos.add(Vector3f(0,-10,0)
    setTranslation(pos)
}

setTranslation(Vector3f v){
   this.localtranslation.set(v)
}

Node getTranslation(){
return new Vector3f(this.localtranslation)
}

can be found out to do the following at runtime
public void applygravity(){
this.localtranslation-=10
}
The JDK7 and JDK6 ers in the later version do this kind of JIt optimisation, and can do this also for more complex cases (like with a if, they will just create two highly optimized version for each case, and select the correct one at the start)