Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[cooldude234]

Apparently between work and programming, I got tendinitis. Gah! I have to program with one hand.
Well at least there will be less rambling.

[cooldude234]

So I never really got far on that project (0 game content made )
Between my arms feeling like they are going to explode and the state of the engine I just didn't get very far.
HOWEVER because of this project I realized that the engine was the equivalent of a DIY motorbike made from a washing machine and oven stove-top. Meaning I ran into a TON of issues that I wouldn't have noticed other wise.
Most of these issue relate to the structure of the engine and the lack of just very important (and seemingly basic but a lot more complex when you go to code it) stuff.

So the entire time I was working on the engine, which of course isn't a bad thing. But I will continue to work on this project until the deadline is up as it's laying down the ground work, foundation, and structure plus the roof of the engine

Simple form of what I have got done
-Better GUI functions
-GUI is now more dynamic (as in you can resize the screen and the GUI will move to fit the screen if you want to, this was working before but wasn't very widget based)
-Better state checks
-ACTUAL states checks of GUI elements (yea that wasn't really a thing until now )
-A broken FIFO buffer (which can handle one update every ten or so seconds without blowing up, yea defiantly broken)
-Controller idiot proof (so you cant blowup your program by ripping out the controller during running)
-Reimplemented Particles and sort-of improved their structure to be more reusable and less memory wasteful
-Fixed a position problem in the fonts then rebroke (<-not an actual word) it (word wrapping).
-realized I was stupid and never added in a dead-zone threshold for joysticks (realized this when I got another joystick which is a lot less accurate near the center position) so I added it to the config file to be changed by the end user without having to run the application
-Still haven't solved the collision problem, but did figure out a nicer way to implement it into the rest of the structure.
-and of course the overall structure has been improved to keep the main loop as clean and smooth as possible while retaining the no bugs guarantee sticker I intend on giving it.

simple form of what I realized I need to do, or do better.
-Better widget structure for GUI
-Text functions needs to be converted to just functions and global variables, no point in having a dedicated class and wasting the extra byte ;p
-Text needs to be both AA AND compatible on all platforms (probably multiple rendering modes for text will be the answer for better performance vs compatibility)
-Resource Manager, so you can't accidentally load up more than one copy of a file
-A sorting function for the render functions
-Better rendering structure to support a sorting function
-Clean up OpenGL specific functions to be able to wait less on receiving info from the graphics card
-Make an interpolation or average of the frame rate to remove stuttering that can occur at random times when the OS does stuff in the background
-EVEN BETTER code structure, what I got is just the beginning
And a ton more stuff that doesn't matter as much right now.

[cooldude234]

OH the JOYS of programing...
...So for about a few months now I have been trying to re-implement shaders. However I kept running into some issues; opengl kept sending me the error flag "invalid operation" whenever I tried to use my shader. I had no clue what was causing this to happen, everything seemed to be perfectly fine. However today after a few hours of programing I realized that my main function for the shader, or more specifically the function type (void) was written with a capital as so Void. It's supposed to be void, not Void.
That's about 3 months, THREE WHOLE MONTHS all because of ONE capital.
Oh, the joys of programing.




stupid capital v

[thecolclough]

ouch - deepest commiserations, cooldude!

[cooldude234]

yea it just happened again 
this time it was only 2 hours and it was a semi colon (end line)
I just remembered that glsl code needs to have end lines just like c.
No wonder why it kept sending me errors 

[cooldude234]

A quick look at what Graphics Library Shading Language (GLSL) is.
Basically it's a bunch of code that runs on the graphics card and overrides how things are drawn on screen
I know, I know, I'm the greatest teacher in the world. No need for an applause 
There are two main important parts to GLSL that one needs to know, Vertex shaders, and Fragment shaders
(there's also geometery shaders for more specific gemeotry stuff, but not bothering with those yet).
-Vertex shaders is what handles the points that make up the geometry.
-Fragment shaders is what handles the individiual pixels that are drawn between the vertices that make up the polygons.
Now with that out of the way...


So I decided on how GLSL will be implemented.
I'm going to make it so that the user can write using GLSL code directly (so that way using any GLSL code from the internet or other sources will work pretty much all the same) with the added benefit of my scripting language tied right in.
Hopefully this way I can make some functions for shaders specifically in so that it can make it easier to program.
For example, a normal vertex shader in GLSL would look like this.

Code: [Select]

void main(void)
{
gl_Position = gl_Vertex * gl_ModelViewProjectionMatrix;
}
How GLSL shaders could look with functions from my engine.

Code: [Select]

void main()
{
Pos = VertexPos;
}
Simply I would just parse through the shader when loading it and when I come across one of my functions I would then change it around so that GLSL could read it like normal.
So Pos = VertexPos; would then be changed to gl_Position = gl_Vertex * gl_ModelViewProjectionMatrix; making it easier to read and write if your not used to such stuff. But even better this then allows me to follow the same naming convention style as the rest of the scripting language. And as well I'm going to allow the full standard GLSL functionality so if you want to handle it that way you can!

[cooldude234]

Oh yea, and this is what happens when you accidentally multiply one variable in a shader

[cooldude234]

And some long awaited (I hope  ) screen shots.
Basically just showing off some really simple stuff you can do with shaders.
More importantly there is now a much much better contrast and brightness control instead of the old method I had which used a rather brute force workaround method using blending functions with quads being render to the scene in front of the camera.

EDIT: Apparently this was my 700th post, didn't realize I had made that many lol

[cooldude234]

Alrighty, I haven't been able to give much of an update as I have been taking a lot of time to make the code much better and doing stuff that you can't so visually see, such as variable creation on the fly!

Yes that's right, you can now script in variables; and considering that scripts aren't compiled they're just read in real-time by the parser that technically means you can define variables whenever! This gave me an idea of having a script editor that you can edit while running your application (however that is just an idea, nothing said in stone about that). So far you can define a integer! WOO! but the ground is there for others.

Now because Steve decided to add shaders to anim8ors preview render (the opengl workspace) I decided to get on my lazy butt and program in some lights! So now we have screenies to share. Yup that means there are now technically shaded lights (mostly just ground work again )

EDIT: 3rd image has some bad normals in it, that's due to my obj loader or anim8ors exporter, I still haven't found the issue of it (not like I looked very well into it ) but the image shows a good amount of detail the lighting can do.

[cooldude234]

Real-time audio now works (even though you can't play an audio clip longer than the buffer as it gets cut off).
Nuff said

[davdud101]

Ahhh cooldude, this has been one of the coolest dev processes to watch, ever. To see that you're still working hard on it is just inspiring!

[cooldude234]

Yea keeping at it is one of the hardest things to do; just as hard if not harder than actually doing said thing (especially when switching jobs and shifts while managing everything else in life and still having enough time to sleep ;P).

P.S. Most of the work I did on this project for that past half a year has been engine structure, look forward to it in the next post.

[cooldude234]

The engine is divided up into sections which are designed to enable you to do specific things, or to handle specific things for you (so you don't have to go through my pain right now ).
These include:
   Audio
      -loading and saving
      -low latency audio playback (with control over sample rates and buffer sizes)
      -Audio manager (which manages long sections of audio to continuously feed
       the buffer till that audio is finished)
   Rendering
      -Primitives
      -models (loading and saving, the latter will be implemented later)
      -Shading
         -lighting
      -specific drawing algorithms
         -tessellation
         -generation functions (eg. random point on triangle function)
         -etc
   Scripts
      -Variable handling (<- realtime creation and destruction, array support will
       come later)
      -Control handling (loops and functions/sub scripts)
      -Wrapping
   General functions
      -Math stuff
      -other simple functions (such as conversions between variable types like string to int and more!)

The scripts will be able to wrap a bunch of functions in the engine to give support for a wider range of functionality; as well the scripts will be able to wrap a lot of C functions directly so that way the user (the one scripting the engine) can access to a lot of functions post compilation and in realtime (in other words the engine reads the scripts version of that function in realtime and calls the compiled version of said function).

You can get a sense for scripting by comparing it to a car.
When you drive a car you are only physically moving the steering wheel and pedals. You don't directly move the pistons and wheels but yet you still have control over where and how fast the car goes. Scripting is like the steering wheel and pedals, much easier to move and steer your car; but you may not have full control over how efficient your engine runs or the max speed of at which it can be. Programing and compiling code is much like the engine and the rest of the car.

The following images illustrate the architecture (more so in this state -> the basic structure) of each section (excluding rendering because at the moment there isn't too much going on there other than some generic opengl calls and some functions I have made, I will be making an rendering manager thingy at some point).

[cooldude234]

took a break from memory management stuff to try and fix the normals.
I am 99 percent sure my obj loader needs to be fixed and for sure optimized so I might just go ahead and implement the parser for the anim8or files.
But during that I worked out multiple lights and added attenuation to them.
So yea any excuse for a screenshot

[cooldude234]

Having some fun with glsl making a cheap volumetric fog.
*sigh* I should get back to the real work now.

Edit: that last one I was just srewing around with values and got that