Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.

Topics - cyberkilla

Pages: 1 [2] 3
Projects / Skeletal Animation Idea?
« on: February 06, 2007, 01:52:36 am »
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:

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).

Feedback / Translating AWT and LWJGL Virtual Key Codes
« on: February 05, 2007, 12:49:36 am »
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:)

Code: [Select]

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;

Feedback / Bitmap Fonts For Ingame Blitting
« on: February 04, 2007, 05:39:04 pm »
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 page(/cyberkilla), if you need them.

Feedback / Powers of 2
« on: February 03, 2007, 10:19:49 pm »
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...


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)

Support / Blitting a UI onto the FrameBuffer
« on: February 02, 2007, 08:45:50 pm »
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:)

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?:)

Support / Compressed Textures
« on: February 02, 2007, 02:45:27 pm »
Does anyone know if the textures used in OpenGL mode are compressed?

I know that the standard images are not compressed in memory(Java2D),
but I did hear something like this on an OpenGL forum.

Its strange how Java doesnt natively use some form of RLE compression for in-memory images.

If you have a 640x480 image in memory, its a good few MB.
On the hard disk, in png format, its a few KB.
Naturally RLE isnt as powerful as the compression in pngs, but I feel my point is still valid.

Support / AWTGLCanvas Speed
« on: January 31, 2007, 03:08:39 pm »
Hello, I am experimenting with billboarding, to see if there are any performance
benefits from using pure 3d, instead of rendering in 2d.
I am using the jpct implementation of awtglcanvas.

I have heard that the canvas is a lot slower than a native window.
Is this so? I can imagine some extra processing to render into awt,
but has anybody got any idea how much?

It is more than possible for me to use a native gl window, if needed, but im discouraged from this approach, because I would need to blit my menus into the

I also use scrollpanes, and skinned buttons via SkinLF.jar.

This is merely a test. A test to evaluate the performance boost, if any, when using  pure 3d, and not using trickery to put 3d onto 2d.

Thanks in advance, for any help:)

Feedback / jPCT
« on: January 31, 2007, 01:55:52 pm »
Egon, I use this piece of code to add an entire stack trace to the logs.

Perhaps you can find use for it in the official logger.

Code: [Select]

public static String getStackTrace(Throwable aThrowable)
   final Writer result           = new StringWriter();
   final PrintWriter printWriter = new PrintWriter(result);
   return result.toString();

To use this, I have a Logger.addError(Throwable e) method.
It just turns the stack trace into a string.

I cannot use the official logger, because I already had my own.

It is very useful for me, so I thought I'd share it.

Feedback / Learn 3D Concepts! Tutorials!
« on: January 23, 2007, 07:09:56 pm »
This website is a fantastic tutorial!

It explains zbuffering, octrees, backface culling, uv normals,
perspective correction, world/camera coorinate systems,
matrices, texture mapping, and so much more!

It touches on almost everything, and provides examples, and/or links to other

Check it out! Seriously, its the easiest to grasp one I've found yet.

It just makes the fact that this engine works so well, even more of a wonder;)

By the way, somehow I am able to make this a sticky. I was under the impression only mods could do this :twisted:

Support / Transparent Backbuffers
« on: January 23, 2007, 06:32:07 pm »
Egon, is it possible to have a quick method/constructor parameter,
that would allow the use of a BITMASK backbuffer, when possible?

I know this isn't used on the 1.1vm, but on the later sun vm's, it is just a simple
change of a flag from OPAQUE to BITMASK.

It don't know how it all works, but, is is possible to set up such an option?

That way, I could pass a transparent color to clear the framebuffer before render.
Then, I would not have to have the additional step of drawing to another image, to manually set the background to transparent.
It is a difference of 25fps, shockingly.

This would be a great help to anyone trying to superimpose rendered models
into a 2d environment.

Perhaps, if its possible, the next version of Jpct could have this functionality?

My appologies, I realise I am asking a lot of questions:) I just want to squeeze as much power out of the engine as possible.

Support / Special Effects.
« on: January 22, 2007, 02:35:25 pm »
Yes, im back again, asking strange questions:).

I was thinking about how I could implement effects into my game.

What I mean by this is:

Player fires gun  -  >  bullet comes out:).
Player casts a spell  -  >  magical sphere encapsulates them.

I suppose this is possible using 2d animation, but, has anyone got any opinions in 3d?

I can use 3d projectiles with ease right now, so bullets, etc, can be 3d.
With forcefields, etc, has anyone got any tricks?

Perhaps a large sphere, with a transparency set, and a plasma-like texture?
If i rotated it along a few axis' it might look good.

Maybe fire would work as a fast rotating sphere with texture only at the bottom, where the players feet would be?

Any ideas are very welcome;)

Feedback / Wavefront OBJ Format
« on: January 20, 2007, 12:15:50 pm »
I wonder if anyone has planned a loader for this?
It seems to be the ONLY format Blender exports properly!
I am shocked to find out that:

MD2 Models export as a solid block of disortion, but with correct UV Coords!

3DS Models export as a correct model, but entirely destroyed UV Coords,
and no reference to the texture!

ASC is not supported, not even a plugin can be found.

JAW is naturally not supported.
It is sickening that is doesn't work. I like these OBJ formats more and more.
I would like to build one myself eventually, but I have only minimal free time right now.

If anyone has any ideas about a workaround, I'd appreciate it.
Regardless of any help, I will be making an OBJ loader at some point:)
How on earth could they make a faulty MD2 importer? The format is so simple, there are even tutorials!

I will post any links I can find that are interesting...
That last link has some example import/export source code,
and many small examples of models.
Look how simple it looks...
Code: [Select]

# cube.obj
g cube
v  0.0  0.0  0.0
v  0.0  0.0  1.0
v  0.0  1.0  0.0
v  0.0  1.0  1.0
v  1.0  0.0  0.0
v  1.0  0.0  1.0
v  1.0  1.0  0.0
v  1.0  1.0  1.0

vn  0.0  0.0  1.0
vn  0.0  0.0 -1.0
vn  0.0  1.0  0.0
vn  0.0 -1.0  0.0
vn  1.0  0.0  0.0
vn -1.0  0.0  0.0
f  1//2  7//2  5//2
f  1//2  3//2  7//2
f  1//6  4//6  3//6
f  1//6  2//6  4//6
f  3//3  8//3  7//3
f  3//3  4//3  8//3
f  5//5  7//5  8//5
f  5//5  8//5  6//5
f  1//4  5//4  6//4
f  1//4  6//4  2//4
f  2//1  6//1  8//1
f  2//1  8//1  4//1

Support / Changing Display Mode
« on: January 11, 2007, 07:02:04 pm »
Egon, I was wondering, how did you change the display mode on your game project? I cant remember its name:)

You see, I am using the standard GraphicsDevice/setDisplayMode method.
But it doesnt work reliably in Linux because of strange problems related to the enumeration of available modes.

HOWEVER, your game CAN change the display mode in both linux and windows for me:O.

Is there any chance you can tell me how you did it?

Thanks again :wink:

Support / Bounding Box
« on: January 11, 2007, 04:15:15 am »

Does the bounding box( which tells me not to call it too much ), change values
as a sequence of key frame animation is played out?

I would assume so, because my "dirty rectangle" clipping doesn't cover the avatar when he lifts his arms:).

If this is so, how can I make sure I have the right bounding box, without a major speed slowdown? I would appreciate any help on this;).

Support / Increasing Quality in Software Mode
« on: December 16, 2006, 02:49:50 am »
Hey I know it might be because im rendering small,
but I seem to get a lot of diffusion.

Is there some way of making the shading a bit cleaner, without
having to resort to scaling a larger render?
Im really trying to keep my rendering costs down.

It looks beautiful if I render at 400px by 400px, then scale down to 200x200,
even at the lowest scaling quality(linear, i imagine).
However, i dont want to loose any speed.

Any ideas?

Pages: 1 [2] 3