... and this is what's wrong with a lot of programs released today.

To be blunt, as I am always blunt, knowing how things work under the hood allows you to write more solid and optimized code. Just linking things together in a way that works usually leads to a huge mess in the end, sure it runs, but you will have tons of memory leaks, extra CPU/GPU polls, and you will have no idea of how to fix those issues. A program is a work of art, not a hammer.

I really described that badly. I should have stated shared VBOs, I think. I was half asleep when I typed that out. lol

Bascially, one VBO can contain several objects instead of one object per set of VBOs, using offsets and counts that are easily managed inside the mesh object classes for quick reference.

To give an idea of what the new rendering engine will look like:



Full armature/skeleton support for animated meshes, two texture layers, one for diffuse the other for emit. Though my library actually has capabilities for 3, to keep my target audience a little wider I opted to skip the specular highlights to reduce GPU/CPU drain, since my target audience are the generic computer users not hardcore gamers I have to accommodate a lot of low level capabilities. Most of the engine is low level stuff, using pure VBO/VAO objects, even layered VBOs as well.

The "camera" object is a game camera specifically, so all movements are based on the same coordinates as objects. Object linking is hierarchical as well, and textures are fully dynamic, you can paint on them very easily. There is also a low memory, fast, texture sequence in the core engine. Working on the new GUI engine next. I will be caught back up in about a week, I think, give or take a few days.

Okay, coding in raw OpenGL ... not as annoying as I thought. I will release the graphics+game library as well, which will be open source. I have way better material settings and shaders than previously demonstrated, and they'll work on older graphics cards as well, as old as 2006 at least, as that is what I am testing it with and developing it on. I may go up to 2008 but nothing newer as I don't want to alienate too many computer users, and that's part of why I ditched jPCT for this. The library I am working on only uses pure OpenGL and mostly modern stuff, there should at least be extensions available for your card to support it. Current test runs include 8 lights per object, unlimited in the world environment, multipass rendering with and without FBOs, and a very simple but elaborate material system that mimics Blender's materials very closely, with lower quality results as it's real time and to do raytracing the exactly how Blender does would not be possible in real time. Even wrote the engine using Blender units though the Y/Z coordinates are exchanged, as I prefer that coordinate system anyway.

In other words, lots of new coming.

Thank you, that PDF was extremely useful. But I'm really hoping for some examples of sending uniforms to the shaders, I'm still struggling with that part, instead of using the glLight and glMaterial commands I mean. But that PDF will be VERY useful once I get that far.

Okay, looking for information on the NEW light and material methods for OpenGL, specifically pure version 4 methods. So far everything I find is only the old method of lighting and I notice that both lights and materials in version OpenGL 4 are not in the list of functions, so if they're changing to a new system, I would like to keep up. Please let me know if you have any links or ideas on how to migrate from the 1.1 method to the newest one.

Zelda tree houses!

Slight delay, not much of one really. The library I was using for the graphics may not work out too well, so I'm probably going to do what I should have done anyway and develop my own graphics routines. Which will benefit the game a lot because there are some nifty effects I discovered a long time ago using OpenGL which are just not available on any of the libraries, not even the big ones. Such as altering the shadow and specular colors per object, just for one example, which, if done correctly, can produce better glowing effect without any extra work on the processor.

Actually, Jimmt, I tested out some darker coloring, and it does look a bit better. So, yeah, thanks for the advice.

lol Well, that would kind of ruin the whole look. There will be changes to make it more mellow though, and the world itself is really dark, except the lines. It's suppose to feel like 80's virtual reality but with a more modern style.

On another note, I'm having issues with the scaling, working on it, but it's just not placing things correctly yet in the loader and I can't figure out why. I actually can't play these type of games, 3D games make me dizzy, so it slows development a bit when I have to take breaks just to let my head stop spinning. So if you're wondering why it's taking so long to get the demo working, it's because right now I'm working on that part that makes me dizzy to test.

Now the fun shots, these are all in game shots. The first three showcase one of the avatars that will be available, Shiva.





The few numerical stats.

Program management.

File management, includes programs not loaded.

One more generic building/server.


Anderhall Bank and Loan server, one of the demo's servers.


Wondermill Robotics server, the other of the demo's servers.

Just for some technical.

Polygon counts are, all quads still:

First: 137
Second: 117
Third: 83

I had forgotten I started another thread on the graphics already .... so ... I'm posting the new ones there.

Edit: Thank you Riven!

Alright, some more images, these are rendered with Blender so they don't look exactly like they will in game, but it's pretty close:

This is a problem many programmers fail to address, so simply by paying attention I am impressed.

Check how many objects you are creating, then discarding soon after using it. If it's an object that you need to use a lot, you should consider creating long term "junk" versions of the object to use in method calls, because those objects will take up less memory, especially if the method is called a lot. When you leave a method call, or some such, the objects created are not immediately reclaimed by the system, the garbage collector does that, so they continue to use up memory until the garbage collection pass, which should be left to the system. Any object that is not a primitive can cause this.

There were several actually. Confuse ans charm would do it, those ones the player could attain as well.

Thank you. I'll post more as I finish them. I am finally far enough in the code development to actually work on this part.

I'm finally getting into making the game models. Here's one.



Helps if I paste the correct link.

I play my PS2 or watch movies. My favorite movie is Tron Legacy, as awesome as the story is for Tron, Tron Legacy has more inspirational imagery.

I don't have a definitive answer, it's a wild guess based on old Java issues and just maybe they didn't correct it. Did you clear your stored files in the Java applet control panel? If not, give it a try, that may work.

It's a nuance of Java that often takes a bit for coders from c/c++ and others to get the hang of. Everything is a pointer, basically, except primitives. Also there is no operator overloading, so comparisons always compare pointer values for everything that is not a primitive, thus the compareTo and equal methods are usually employed to compare the stuff in the objects you create, such as String. Just remember, if it's a class then operators will effect the pointer, so look for the comparison methods. You can overload equal and if you implement the comparator interface you can add a compareTo as well, which is really helpful in sorting.

Personally, I prefer this nuance, it's probably my favorite aspect of Java.

You can rent space on servers, a good one that I use is:

https://www.webfaction.com/

Very reasonable prices, full access to your server or directories, it's great for testing things.

Another good one is string.compareTo(otherstring) if you want to know the order as well. I always use compareTo == 0 for matches, just out of habit.

Compact ... I'm a minimalist. I don't even comment ... much.

Hmm ... that could be a fun project, 3D, FPS, and strategy in an MMO. The AI could would have to be insane ... but ...

It's a non-issue, one of those old throwbacks that's not really important anymore. For some of us it's just an old habit, I do it sometimes without thinking.

To your get/set notion, I base it on how volatile the the data is and what would happen if something changed it unexpectedly. If you have to control changes made then protected/private is the best method, so when a change happens the class can do the other work. But if it's just a data holding class for something where if the contents change unexpectedly you won't get an exception, then do what's comfortable. Some classes in Java I think over use the private/protected members, things like Color should be a bit more transparent than they are, but meh.

Time tracking and a lower sleep, say 20 or 30 milliseconds.

Here's a quick time tracking class example.



Just every time you pass through your loop start off by calling the getTimePassed method to get the number of milliseconds passed since the last call then interpolate your movement and animations based on that.

Vectors are about the only time I use it, and that's because I use vectors to communicate between threads. Otherwise I avoid it, you can manage locking inside the class if the object really needs it.