Hello again;)

I just thought I should point out that I'm still hanging around.
I have been so busy at work that I've not been able to finish my 3d projects.

I do intend to return in a few month. This message is just to ensure you don't think I've given up and start deleting my project threads:)

http://www.tweakguides.com/Graphics_1.html

The above website explains in reasonably good depth, what antialiasing is, dot pitches, the difference between lcd and crt(visually speaking), and many other things. Not a bad site;)

Hello, I am slightly confused with collision detection.

I can get it working, but the movement seems a little unrealistic.

I mean, my character is able to walk up a rock face that is at a very steep slope.
Is there anything I can do about this?

Sorry, another question;).

Has anyone managed to implement LOD in jPCT?
I heard something about Raft achieving this.

Does anyone have any information you can volunteer to me?

Hello:)

I am trying to minimize the polygon usage of my models.

What is the most reasonable number of polygons/vertices/faces/etc for an online game, where several of these models are likely to share the screen at the same time.

I keep hearing a polygon count of 2-3000 per model, in UT.

It feels a bit too much for me.

My current model is "created using 226 polygons and 117 vertices".

It doesn't look too bad, but I would like it too look good when the camera is close up too.

Any thoughts?

Hello, I was wondering about this, so I thought I'd ask...

Is there a maximum size for a map?
I mean, I would like to make maps that are rather large - they will go far into the distance.

Will performance be hit be large?
I do have fog enabled, and a few over Config flags set.

Does anyone have and tips for me? My environments will be large, but the vertex count will be limited as much as possible in all of my models.
They will generally be outdoor maps.

I forgot to mention this...

The Java Web Start example is very nice!
I like the bloom effect very much.

Nothing that is "required", but i thought I would suggest them...

matrix.reset() <- return matrix to original state, without making new instance.
matrix.set(anothermatrix) <- set matrix values to another, without a new instance.

Probably possible with get/setDump() anyway though;)

I have two rotations, similar to below.

<rotate angle="0.224545">
<axis x="0.999774" y="-0.019487" z="0.008553"/>
</rotate>


I need to "add" them together, to get the final rotation.
For some reason, it doesn't appear to work like this...


matrix1.matMul(matrix2);


The result appears to swap the actual axis.
It is hard to explain. Basically...

The first matrix is the bone's rotation axis, and the second is the rotation of the current keyframe.
It is my assumption that the keyframe is relative to the rest pose/rotation of the bone.

If I have a rest rotation that has an axis pointing 45 degrees up on the Y axis,
applying a keyframe rotation with an axis of 45 degrees up on y also, it is almost as if it stays 45 degrees up Y, but moves ~45 degrees along another axis.

Strange, huh?

EDIT:
Worth mentioning...
The skeletal system works BRILLIANT, if the rest post has no rotations.

If I make a snake, with all the bones in a line, i can animate it any way I want,
and it works fine.
It seems to be due to the adding of rest rotation with keyframe rotations.

Is is possible for me to use hardware skinning using the Hardware Rendering mode?

I read that it can be very beneficial.
Perhaps I should research this in the lwjgl documentation

Egon, how costly is using a VertexController, in a case like skeletal animation,
when you need to have mesh access for almost every frame?

Is there a way to rotate around an axis, like this:


rotateAxis

public void rotateAxis(SimpleVector axis,
                      float angle)

   Rotates the object's rotation matrix around an arbitrary axis. The method is more powerfull than the normal rotate-around-an-axis methods, but also a bit slower. The resulting matrix will be orthonormalized to ensure numerical stability.

   Parameters:
       axis - a direction-vector pointing into the axis direction with the object's rotation pivot as position vector
       angle - the angle of the rotation


..but for SimpleVector:)

I need to rotate the vertices around an axis, by an angle.

This must mean that I need to rotate around this axis, like in Object3D, but also take into account that it isn't the center.

Something like this?

vertex = vertex.calcSub(axis);
vertex.rotateAxis(axis,angle);
vertex.add(axis);


In what order do I receive the mesh vertices in my extension of GenericVertexController?

I insert the triangles with vertices in the order :

triangle one:v1,v2,v3.
triangle two:v4,v5,v6.

Will I get them back in the same 123456 order?

In OgreXML format, there are Blended Vertexes.

I do not fully understand these.
Anyone got some documents on them?

I found this:

Quote
A blended vertex is how one bone shares a vertex with another bone.  Like a raw vertex, it has an offset in 3D space and a normal, but instead of a 2D texture point, it has a reference to a raw vertex (necessarily on a different bone?) and the blending info.  When applied, it modifies (deforms) the effective position and normal of the raw vertex.

Note to self: Don't ask questions when nobody is here :wink:

I am getting nothing from pickPolygon in some circumstances.

In the render loop, I try it just after the scene is rendered/drawn/displayed to framebuffer. It works!

Still inside render loop, but before rendering, I very rarely get anything from it.

I do use multiple cameras, and multiple framebuffers.
I am certain it is because of this.
I have tried setting the world to the active camera, and even rendering the scene again, before pickPolygon, but no luck:)

Just incase it is obvious to someone..

public synchronized Object3D getObjectAtCursor(int x,int y,RenderPane renderPane)
{
Camera      camera      = renderPane.camera;
FrameBuffer frameBuffer = renderPane.frameBuffer;


world.setCameraTo(camera);
world.renderScene(frameBuffer);
//world.draw(frameBuffer);

SimpleVector td  = Interact2D.reproject2D3D(camera,frameBuffer,x,y);
int[]        res = Interact2D.pickPolygon(
world.getVisibilityList(),td,
Interact2D.EXCLUDE_NOT_SELECTABLE);
if (res == null)
return null;
//Never gets past here,outside of paintComponent().

Object3D obj = world.getObject(Interact2D.getObjectID(res));

return obj;
}


I was just thinking of this. Please tell me if its possible - not if its plausible - I like to do strange things:)....
Its just an example of what I might try...

----
Export model in OBJ format...
----
Make a quick app, to create a list of vertex coords for each "bone".
Perhaps using the pickPolygon to select a few.
----
Save those coords in an xml file.
Also save any skeletal movements.
----
Load actual model in jpct.
----
At load time...
Get mesh somehow, and create a new one, finding the object space coords(same as in modeler? would think so)...
Rotate them around the already found(guessed;)) bone pivots,
and save as a new mesh.
----
Put all the meshes into a keyframe animation like you would with multiple 3ds files, as we once discussed.

Is this possible?


If it is, I would like to make a generic bone editor, and a skeletal-like api,
that could be used if needed.
I do not know how others achieve this effect, but I see it as this:

SimpleVectors,
Rotation Around Pivot(with parent/child)
Storage(in xml) of each bone, its parent/children, and the connected vertexes.
For each mesh vertex, apply rotations.
Make keyframe animation from skeletal stages.

Some form of this is the only thing missing from the jpct features.
It need not be included by default, but as another jar, if needed.

I'd like to do this myself, as my contribution:)
How would I know which vertex is which? Well, by its original coordinate:)
doubles might cause trouble, but I don't own a model that has vertexes in the EXACT same place:)
The bone editor could be programmed to point out these double vertexes, so i dont think its a problem.



Now, whats the point of this? Well, you could get the data for the model, and do the same for clothing, and be able to make a new skeleton animation, without having to manually mess around with all of the clothing sets you've made! I have no idea why I needed to point that out. Its obvious;)

Still, if this is even a tiny possibility, it would be great! An MMORPG game would benefit from such dynamic animation, and it wouldnt have to be blocky.

I heard rolz used a kind of skeleton system by making each limb an object, and rotating them.
It would be like that, but the limbs could be connected, and not hinge-like(I am assuming here, unless you found a way to join the arms with the torso, etc).

This took some time:)
I hope it helps someone. I think  covered everything.
A lot of the FROM AWT was on a forum, but I had to sit and reverse
every single switch case for the TO AWT:)


private int translateFromAWT( int aCode ) {
   switch ( aCode ) {
     case KeyEvent.VK_ESCAPE: return Keyboard.KEY_ESCAPE;
     case KeyEvent.VK_1: return Keyboard.KEY_1;
     case KeyEvent.VK_2: return Keyboard.KEY_2;
     case KeyEvent.VK_3: return Keyboard.KEY_3;
     case KeyEvent.VK_4: return Keyboard.KEY_4;
     case KeyEvent.VK_5: return Keyboard.KEY_5;
     case KeyEvent.VK_6: return Keyboard.KEY_6;
     case KeyEvent.VK_7: return Keyboard.KEY_7;
     case KeyEvent.VK_8: return Keyboard.KEY_8;
     case KeyEvent.VK_9: return Keyboard.KEY_9;
     case KeyEvent.VK_0: return Keyboard.KEY_0;
     case KeyEvent.VK_MINUS: return Keyboard.KEY_MINUS;
     case KeyEvent.VK_EQUALS: return Keyboard.KEY_EQUALS;
     case KeyEvent.VK_BACK_SPACE: return Keyboard.KEY_BACK;
     case KeyEvent.VK_TAB: return Keyboard.KEY_TAB;
     case KeyEvent.VK_Q: return Keyboard.KEY_Q;
     case KeyEvent.VK_W: return Keyboard.KEY_W;
     case KeyEvent.VK_E: return Keyboard.KEY_E;
     case KeyEvent.VK_R: return Keyboard.KEY_R;
     case KeyEvent.VK_T: return Keyboard.KEY_T;
     case KeyEvent.VK_Y: return Keyboard.KEY_Y;
     case KeyEvent.VK_U: return Keyboard.KEY_U;
     case KeyEvent.VK_I: return Keyboard.KEY_I;
     case KeyEvent.VK_O: return Keyboard.KEY_O;
     case KeyEvent.VK_P: return Keyboard.KEY_P;
     case KeyEvent.VK_OPEN_BRACKET: return Keyboard.KEY_LBRACKET;
     case KeyEvent.VK_CLOSE_BRACKET: return Keyboard.KEY_RBRACKET;
     case KeyEvent.VK_ENTER: return Keyboard.KEY_RETURN;
     case KeyEvent.VK_CONTROL: return Keyboard.KEY_LCONTROL;
     case KeyEvent.VK_A: return Keyboard.KEY_A;
     case KeyEvent.VK_S: return Keyboard.KEY_S;
     case KeyEvent.VK_D: return Keyboard.KEY_D;
     case KeyEvent.VK_F: return Keyboard.KEY_F;
     case KeyEvent.VK_G: return Keyboard.KEY_G;
     case KeyEvent.VK_H: return Keyboard.KEY_H;
     case KeyEvent.VK_J: return Keyboard.KEY_J;
     case KeyEvent.VK_K: return Keyboard.KEY_K;
     case KeyEvent.VK_L: return Keyboard.KEY_L;
     case KeyEvent.VK_SEMICOLON: return Keyboard.KEY_SEMICOLON;
     case KeyEvent.VK_QUOTE: return Keyboard.KEY_APOSTROPHE;
     case KeyEvent.VK_DEAD_GRAVE: return Keyboard.KEY_GRAVE;
     case KeyEvent.VK_SHIFT: return Keyboard.KEY_LSHIFT;
     case KeyEvent.VK_BACK_SLASH: return Keyboard.KEY_BACKSLASH;
     case KeyEvent.VK_Z: return Keyboard.KEY_Z;
     case KeyEvent.VK_X: return Keyboard.KEY_X;
     case KeyEvent.VK_C: return Keyboard.KEY_C;
     case KeyEvent.VK_V: return Keyboard.KEY_V;
     case KeyEvent.VK_B: return Keyboard.KEY_B;
     case KeyEvent.VK_N: return Keyboard.KEY_N;
     case KeyEvent.VK_M: return Keyboard.KEY_M;
     case KeyEvent.VK_COMMA: return Keyboard.KEY_COMMA;
     case KeyEvent.VK_PERIOD: return Keyboard.KEY_PERIOD;
     case KeyEvent.VK_SLASH: return Keyboard.KEY_SLASH;
     case KeyEvent.VK_MULTIPLY: return Keyboard.KEY_MULTIPLY;
     case KeyEvent.VK_ALT: return Keyboard.KEY_LMENU;
     case KeyEvent.VK_SPACE: return Keyboard.KEY_SPACE;
     case KeyEvent.VK_CAPS_LOCK: return Keyboard.KEY_CAPITAL;
     case KeyEvent.VK_F1: return Keyboard.KEY_F1;
     case KeyEvent.VK_F2: return Keyboard.KEY_F2;
     case KeyEvent.VK_F3: return Keyboard.KEY_F3;
     case KeyEvent.VK_F4: return Keyboard.KEY_F4;
     case KeyEvent.VK_F5: return Keyboard.KEY_F5;
     case KeyEvent.VK_F6: return Keyboard.KEY_F6;
     case KeyEvent.VK_F7: return Keyboard.KEY_F7;
     case KeyEvent.VK_F8: return Keyboard.KEY_F8;
     case KeyEvent.VK_F9: return Keyboard.KEY_F9;
     case KeyEvent.VK_F10: return Keyboard.KEY_F10;
     case KeyEvent.VK_NUM_LOCK: return Keyboard.KEY_NUMLOCK;
     case KeyEvent.VK_SCROLL_LOCK: return Keyboard.KEY_SCROLL;
     case KeyEvent.VK_NUMPAD7: return Keyboard.KEY_NUMPAD7;
     case KeyEvent.VK_NUMPAD8: return Keyboard.KEY_NUMPAD8;
     case KeyEvent.VK_NUMPAD9: return Keyboard.KEY_NUMPAD9;
     case KeyEvent.VK_SUBTRACT: return Keyboard.KEY_SUBTRACT;
     case KeyEvent.VK_NUMPAD4: return Keyboard.KEY_NUMPAD4;
     case KeyEvent.VK_NUMPAD5: return Keyboard.KEY_NUMPAD5;
     case KeyEvent.VK_NUMPAD6: return Keyboard.KEY_NUMPAD6;
     case KeyEvent.VK_ADD: return Keyboard.KEY_ADD;
     case KeyEvent.VK_NUMPAD1: return Keyboard.KEY_NUMPAD1;
     case KeyEvent.VK_NUMPAD2: return Keyboard.KEY_NUMPAD2;
     case KeyEvent.VK_NUMPAD3: return Keyboard.KEY_NUMPAD3;
     case KeyEvent.VK_NUMPAD0: return Keyboard.KEY_NUMPAD0;
     case KeyEvent.VK_DECIMAL: return Keyboard.KEY_DECIMAL;
     case KeyEvent.VK_F11: return Keyboard.KEY_F11;
     case KeyEvent.VK_F12: return Keyboard.KEY_F12;
     case KeyEvent.VK_F13: return Keyboard.KEY_F13;
     case KeyEvent.VK_F14: return Keyboard.KEY_F14;
     case KeyEvent.VK_F15: return Keyboard.KEY_F15;
     case KeyEvent.VK_KANA: return Keyboard.KEY_KANA;
     case KeyEvent.VK_CONVERT: return Keyboard.KEY_CONVERT;
     case KeyEvent.VK_NONCONVERT: return Keyboard.KEY_NOCONVERT;
     case KeyEvent.VK_CIRCUMFLEX: return Keyboard.KEY_CIRCUMFLEX;
     case KeyEvent.VK_AT: return Keyboard.KEY_AT;
     case KeyEvent.VK_COLON: return Keyboard.KEY_COLON;
     case KeyEvent.VK_UNDERSCORE: return Keyboard.KEY_UNDERLINE;
     case KeyEvent.VK_KANJI: return Keyboard.KEY_KANJI;
     case KeyEvent.VK_STOP: return Keyboard.KEY_STOP;
     case KeyEvent.VK_DIVIDE: return Keyboard.KEY_DIVIDE;
     case KeyEvent.VK_PAUSE: return Keyboard.KEY_PAUSE;
     case KeyEvent.VK_HOME: return Keyboard.KEY_HOME;
     case KeyEvent.VK_UP: return Keyboard.KEY_UP;
     case KeyEvent.VK_PAGE_UP: return Keyboard.KEY_PRIOR;
     case KeyEvent.VK_LEFT: return Keyboard.KEY_LEFT;
     case KeyEvent.VK_RIGHT: return Keyboard.KEY_RIGHT;
     case KeyEvent.VK_END: return Keyboard.KEY_END;
     case KeyEvent.VK_DOWN: return Keyboard.KEY_DOWN;
     case KeyEvent.VK_PAGE_DOWN: return Keyboard.KEY_NEXT;
     case KeyEvent.VK_INSERT: return Keyboard.KEY_INSERT;
     case KeyEvent.VK_DELETE: return Keyboard.KEY_DELETE;
     case KeyEvent.VK_META: return Keyboard.KEY_LWIN;
   }
   return Keyboard.KEY_NONE;
 }
private int translateToAWT( int aCode ) {
   switch ( aCode ) {
     case Keyboard.KEY_ESCAPE: return KeyEvent.VK_ESCAPE;
     case Keyboard.KEY_1: return KeyEvent.VK_1;
     case Keyboard.KEY_2: return KeyEvent.VK_2;
     case Keyboard.KEY_3: return KeyEvent.VK_3;
     case Keyboard.KEY_4: return KeyEvent.VK_4;
     case Keyboard.KEY_5: return KeyEvent.VK_5;
     case Keyboard.KEY_6: return KeyEvent.VK_6;
     case Keyboard.KEY_7: return KeyEvent.VK_7;
     case Keyboard.KEY_8: return KeyEvent.VK_8;
     case Keyboard.KEY_9: return KeyEvent.VK_9;
     case Keyboard.KEY_0: return KeyEvent.VK_0;
     case Keyboard.KEY_MINUS: return KeyEvent.VK_MINUS;
     case Keyboard.KEY_EQUALS: return KeyEvent.VK_EQUALS;
     case Keyboard.KEY_BACK: return KeyEvent.VK_BACK_SPACE;
     case Keyboard.KEY_TAB: return KeyEvent.VK_TAB;
     case Keyboard.KEY_Q: return KeyEvent.VK_Q;
     case Keyboard.KEY_W: return KeyEvent.VK_W;
     case Keyboard.KEY_E: return KeyEvent.VK_E;
     case Keyboard.KEY_R: return KeyEvent.VK_R;
     case Keyboard.KEY_T: return KeyEvent.VK_T;
     case Keyboard.KEY_Y: return KeyEvent.VK_Y;
     case Keyboard.KEY_U: return KeyEvent.VK_U;
     case Keyboard.KEY_I: return KeyEvent.VK_I;
     case Keyboard.KEY_O: return KeyEvent.VK_O;
     case Keyboard.KEY_P: return KeyEvent.VK_P;
     case Keyboard.KEY_LBRACKET: return KeyEvent.VK_OPEN_BRACKET;
     case Keyboard.KEY_RBRACKET: return KeyEvent.VK_CLOSE_BRACKET;
     case Keyboard.KEY_RETURN: return KeyEvent.VK_ENTER;
     case Keyboard.KEY_LCONTROL: return KeyEvent.VK_CONTROL;
     case Keyboard.KEY_A: return KeyEvent.VK_A;
     case Keyboard.KEY_S: return KeyEvent.VK_S;
     case Keyboard.KEY_D: return KeyEvent.VK_D;
     case Keyboard.KEY_F: return KeyEvent.VK_F;
     case Keyboard.KEY_G: return KeyEvent.VK_G;
     case Keyboard.KEY_H: return KeyEvent.VK_H;
     case Keyboard.KEY_J: return KeyEvent.VK_J;
     case Keyboard.KEY_K: return KeyEvent.VK_K;
     case Keyboard.KEY_L: return KeyEvent.VK_L;
     case Keyboard.KEY_SEMICOLON: return KeyEvent.VK_SEMICOLON;
     case Keyboard.KEY_APOSTROPHE: return KeyEvent.VK_QUOTE;
     case Keyboard.KEY_GRAVE: return KeyEvent.VK_DEAD_GRAVE;
     case Keyboard.KEY_LSHIFT: return KeyEvent.VK_SHIFT;
     case Keyboard.KEY_BACKSLASH: return KeyEvent.VK_BACK_SLASH;
     case Keyboard.KEY_Z: return KeyEvent.VK_Z;
     case Keyboard.KEY_X: return KeyEvent.VK_X;
     case Keyboard.KEY_C: return KeyEvent.VK_C;
     case Keyboard.KEY_V: return KeyEvent.VK_V;
     case Keyboard.KEY_B: return KeyEvent.VK_B;
     case Keyboard.KEY_N: return KeyEvent.VK_N;
     case Keyboard.KEY_M: return KeyEvent.VK_M;
     case Keyboard.KEY_COMMA: return KeyEvent.VK_COMMA;
     case Keyboard.KEY_PERIOD: return KeyEvent.VK_PERIOD;
     case Keyboard.KEY_SLASH: return KeyEvent.VK_SLASH;
     case Keyboard.KEY_MULTIPLY: return KeyEvent.VK_MULTIPLY;
     case Keyboard.KEY_LMENU: return KeyEvent.VK_ALT;
     case Keyboard.KEY_SPACE: return KeyEvent.VK_SPACE;
     case Keyboard.KEY_CAPITAL: return KeyEvent.VK_CAPS_LOCK;
     case Keyboard.KEY_F1: return KeyEvent.VK_F1;
     case Keyboard.KEY_F2: return KeyEvent.VK_F2;
     case Keyboard.KEY_F3: return KeyEvent.VK_F3;
     case Keyboard.KEY_F4: return KeyEvent.VK_F4;
     case Keyboard.KEY_F5: return KeyEvent.VK_F5;
     case Keyboard.KEY_F6: return KeyEvent.VK_F6;
     case Keyboard.KEY_F7: return KeyEvent.VK_F7;
     case Keyboard.KEY_F8: return KeyEvent.VK_F8;
     case Keyboard.KEY_F9: return KeyEvent.VK_F9;
     case Keyboard.KEY_F10: return KeyEvent.VK_F10;
     case Keyboard.KEY_NUMLOCK: return KeyEvent.VK_NUM_LOCK;
     case Keyboard.KEY_SCROLL: return KeyEvent.VK_SCROLL_LOCK;
     case Keyboard.KEY_NUMPAD7: return KeyEvent.VK_NUMPAD7;
     case Keyboard.KEY_NUMPAD8: return KeyEvent.VK_NUMPAD8;
     case Keyboard.KEY_NUMPAD9: return KeyEvent.VK_NUMPAD9;
     case Keyboard.KEY_SUBTRACT: return KeyEvent.VK_SUBTRACT;
     case Keyboard.KEY_NUMPAD4: return KeyEvent.VK_NUMPAD4;
     case Keyboard.KEY_NUMPAD5: return KeyEvent.VK_NUMPAD5;
     case Keyboard.KEY_NUMPAD6: return KeyEvent.VK_NUMPAD6;
     case Keyboard.KEY_ADD: return KeyEvent.VK_ADD;
     case Keyboard.KEY_NUMPAD1: return KeyEvent.VK_NUMPAD1;
     case Keyboard.KEY_NUMPAD2: return KeyEvent.VK_NUMPAD2;
     case Keyboard.KEY_NUMPAD3: return KeyEvent.VK_NUMPAD3;
     case Keyboard.KEY_NUMPAD0: return KeyEvent.VK_NUMPAD0;
     case Keyboard.KEY_DECIMAL: return KeyEvent.VK_DECIMAL;
     case Keyboard.KEY_F11: return KeyEvent.VK_F11;
     case Keyboard.KEY_F12: return KeyEvent.VK_F12;
     case Keyboard.KEY_F13: return KeyEvent.VK_F13;
     case Keyboard.KEY_F14: return KeyEvent.VK_F14;
     case Keyboard.KEY_F15: return KeyEvent.VK_F15;
     case Keyboard.KEY_KANA: return KeyEvent.VK_KANA;
     case Keyboard.KEY_CONVERT: return KeyEvent.VK_CONVERT;
     case Keyboard.KEY_NOCONVERT: return KeyEvent.VK_NONCONVERT;
     case Keyboard.KEY_CIRCUMFLEX: return KeyEvent.VK_CIRCUMFLEX;
     case Keyboard.KEY_AT: return KeyEvent.VK_AT;
     case Keyboard.KEY_COLON: return KeyEvent.VK_COLON;
     case Keyboard.KEY_UNDERLINE: return KeyEvent.VK_UNDERSCORE;
     case Keyboard.KEY_KANJI: return KeyEvent.VK_KANJI;
     case Keyboard.KEY_STOP: return KeyEvent.VK_STOP;
     case Keyboard.KEY_DIVIDE: return KeyEvent.VK_DIVIDE;
     case Keyboard.KEY_PAUSE: return KeyEvent.VK_PAUSE;
     case Keyboard.KEY_HOME: return KeyEvent.VK_HOME;
     case Keyboard.KEY_UP: return KeyEvent.VK_UP;
     case Keyboard.KEY_PRIOR: return KeyEvent.VK_PAGE_UP;
     case Keyboard.KEY_LEFT: return KeyEvent.VK_LEFT;
     case Keyboard.KEY_RIGHT: return KeyEvent.VK_RIGHT;
     case Keyboard.KEY_END: return KeyEvent.VK_END;
     case Keyboard.KEY_DOWN: return KeyEvent.VK_DOWN;
     case Keyboard.KEY_NEXT: return KeyEvent.VK_PAGE_DOWN;
     case Keyboard.KEY_INSERT: return KeyEvent.VK_INSERT;
     case Keyboard.KEY_DELETE: return KeyEvent.VK_DELETE;
     case Keyboard.KEY_LWIN: return KeyEvent.VK_META;
   }
   return Keyboard.KEY_NONE;
 }


I find a nice bitmapped font is useful for games, and I've been searching.

I found the following character sets, incase anyone is having great difficulty.
NOTE: They *may* not be perfectly monospaced for blitting in these images.

I am converting them myself slowly, so you might not have to go to the trouble.
If anyone has a better way I doing this, It would be great to share it with us:).

I used to use the Tauron VGA Utilities to edit fonts, but it only exports into asm byte declarations.
There are some windows utilities hanging around, but none of them seem to install under Wine in Ubuntu.





The sites I found them on are bookmarked on my del.icio.us page(/cyberkilla), if you need them.

I understand that textures need powers of 2, or there or problems,
and if your lucky, they are just scaled beyond recognition:)
I found this list on the internet, which might be useful for quick reference...

Quote
2^1       =    2
                (1 digits)
2^2       =    4
                (1 digits)
2^3       =    8
                (1 digits)
2^4       =   16
                (2 digits)
2^5       =   32
                (2 digits)
2^6       =   64
                (2 digits)
2^7       =  128
                (3 digits)
2^8       =  256
                (3 digits)
2^9       =  512
                (3 digits)
2^10      =    1,024
                (4 digits)
2^11      =    2,048
                (4 digits)
2^12      =    4,096
                (4 digits)

Hello again, yes, it is that time of the week:)
The time when I suddenly feel the urge to ask strange questions;).

Here we go......

I have a user interface. It is composed of several transparent images.



I looked through some of the Paradroidz source code, and found an interesting way of using textures and blitting.

Now, the blitting is fine for most of the stuff, but the bottom bar draws item thumbnails into the boxes.
This doesnt change much, so it would be a waste to keep drawing the images ontop.

Is there a way to save a copy of the blitted material, and reuse it.
Or, perhaps draw it on a BufferedImage, and create a texture from it?

Thanks again:)

EDIT:
Perhaps an ITextureEffect that uses a cached BufferedImage of the icons, and applies this to the dest[]?

Perhaps it would just be quicker to draw the item thumbnails like im doing everything else?