As I’ve mentioned before my renderer right now is a “hybrid” between a forward renderer and a deferred renderer.
I use both of these hand-in-hand to produce a single image, and I’ve been careful to design it in a way that there isn’t that much data that gets wasted frame to frame.
Where this system fails, however, is when you get a new idea of something you want to implement. My latest example of this was the water I posted about just before this post.

Now, I know I mentioned that I just basically hacked the water in there without much planning and such. And this is in no way false. But imagine my surprise when I examined it more thoroughly and it showed that there isn’t that much I could’ve done differently with the current setup.
I’m saddened by this, because it means I have to spend even more time planning out this renderer, just as I thought I was getting closer to a working setup.

All planning and no programming makes me a dull boy.

(Also there’s that dagger again from the last video.)
So. After that bit of video I’m going to hammer my fingers against this keyboard for a little while, like so:

Just for a brief moment I’m going to tell you what you just saw in that video.
The most apparent thing, I guess, is the water. Both the water plane and the flowing water out of the gargoyle’s face.
The flow is just particles, as simple as that. Tiny billboards with textures, nothing fancy.

The water plane, however, is a little bit more complicated.
The main feature I decided to implement was the refraction, the rippling of whatever is seen through the surface.
So, because of this I left out reflections completely, and I decided to go with simple cubemap reflection for now.
I also have a simple Fresnel term for the water, meaning the refractions/reflections are only visible depending on the viewer angle. Although this doesn’t show too much in this video.

There are plenty of things left to be done. Like specular highlights from nearby lights on the water surface, or depth “fog” etc.
And after this little stunt my poor renderer is left bleeding. I picked it apart a lot and now it’s just kinda there, like some kind of mysterious monolith, staring back at me.

No, but on a serious note- the things in this video are seriously hacked together in a matter of hours, so there’s a good deal of negligence going on. That particle system, for example, is- I don’t dare to speak the words- hard coded.
And it’s just tacked on top of everything else like a gross ol’ band-aid.
Bottom line: It’s, technically, ugly as hell.
There are even some negligence visible in the video… Hint: Did you see that water-stream jump a little at times? That’s a frame-rate dependent bug. It did that when I was recording, but it doesn’t do that generally when I run it on my computer.

So why did I produce this monstrosity?
Hey, gotta start somewhere. Now that I know what I want, I can work on a better way of implementing it.

Bye now.

Here’s something I haven’t done earlier… A video! Yay!

Watch it and then proceed to tremble on the ground from the awesomeness. I’m just kidding… It’s not that great.
But it does show a model (which I also made), and my hybrid renderer in action.
Now since I wanted the cubemap reflection to show a lot, and it didn’t, this video is partially a failure.
But I’ll just go along with it for now.

I’m sure to post more videos if there’s anything interesting to show.

I’ve now completed the very basic animation support implementation that I started a while back and it’s actually kind of useable right now.
It’s of course missing important things such as morph targets and IK support. (Though I probably won’t bother with IK just yet.)
I’m also going to try to put in things such as “jiggle bones” and other secondary animation controllers just for completeness sake.

Even though most of what should be working is working right now, there’s still a mountain of things to change and fix that have to do with how the engine communicates with itself, primarily.
The renderer right now is pretty self-sufficient. But since I decided to make it “absolute” it’s not very customizable from outside influence.
I’m fine with this “design flaw”, since it was never my intention to make a really generalized engine anyhow, and for projects that need something else I can customize the pipeline.
But all this is secondary, I feel. It’s important to have it working as intended first, then have it well implemented- once you know what the hell you’re doing.

Hmmm… That should be it for now. I’ll pop back in later to maybe post some screenshots.

Bye.

Now on to another thing that I touched upon like two posts back, that project that I was working on.
Well I might as well say what it is, since I’m likely going to be posting progress stuff on here.
Since I apparently can’t get enough of it, having it be my primary programming endeavor, I am actually writing another engine.
But this time it’s downgraded one dimension which effectively puts it in 2 dimensions.
It’s a 2d engine!

(That subtitle is not actually accurate, but there will be coding… And engines… Err… Engine. Note also that the name “Junebug” is just a codename for this project.)
I call it Junebug, originally named as a reminder for me to keep it small, to keep it reeeaaally tiny. Like a Junebug.

Now this project isn’t without its own share of ifs and buts, most of which have to do with the end result.
The original goal is to actually release this library as open source where I just flat out give out all the code to the library, how it works and someone, somewhere might have a laugh with how poorly it is written.
I’m also aiming at making it cross-platform (to some extent). Simply because it’s something I love and I want to work on that, or start working on that stuff since it’s for me, as a developer, a thing I haven’t done before. The downside is that I’ll only be able to work on Linux and Windows. I’d be happy to work on other platforms but from a practical standpoint that is not possible right now.
But. All of the above can only happen if I’m satisfied with the end result and if I think that it might actually benefit from an.. uh… “open-source… ification.”. And by those parameters alone it’s already very arbitrary.
Nevertheless, we’ll see how it turns out.

This is going to be my new go-to toy whenever I’m feeling worn down by other stuff, so I can’t guarantee that I’ll work on it that much. But right now I’m eager to get the foundation up and running at least.

I might have to make another post sometime soon that goes through the project a little more in depth, but until that time this is just an idea, basically. Yes, the project is established enough to have a codename and a cute little logo, But I still regard it as an “idea”. Making it sound too official is scary to me.
Also, in cold reality it’s just a small project that I can work on, it doesn’t have to amount to anything at all really. It’s just like my 3d engine, but smaller, and… Different.

More details on this at a later time.

And by “works” I mean that it’s on par with the old exporter (for Blender 2.49b that I have mentioned on several occasions) and what results it managed to spit out back in its heyday.

The rotations are nowadays stored as Quaternions without the ‘W’ component opposed to Euler angles like they were back then. I recreate the ‘W’ component when I load the animations, mostly to conserve a little space in the format, storing a 3d vector instead of the 4d.

That’s all for now…

It’s the dreaded animation again, the Blender switch I made a while back broke something. But without the chance to really mess with it inside the engine I didn’t know that it was broken. So I just chalked it up as a smooth conversion and didn’t think about it more.
But that has changed, in a bad way. It’s completely messed up and that’s because how I dealt with matrices back in the old Blender Python API doesn’t translate that great into the new API.
Or maybe they do translate 1:1 but I just haven’t found the right matrices yet.

It really seems like I can’t catch a break with this at all. Even when I’m doing my best at logically tracking what’s going on with the matrices it leaves me confused. It’s actually come to the point where I’m starting to blame the API for pulling tricks behind my back, knowing of course that that’s just a lame excuse, if any.

So, in the worst case scenario I get to spend a little more time with the old exporter for Blender 2.49. Just until I figure that stuff out with the newer one.

I’ll figure it out somehow…

Back to it… Wheeeeee…

Edit: Forgot to mention. There’s a project I’ve been working on, sort of like a toy project just to do something different alongside everything else. And I might make a sort of an “announcement” post about it here. I’m just not sure if I’m going to follow through with that project to the end, since it does have a planned “end goal” type thing.
We’ll see.

(Click on them for larger size.)

They are both of the same scene, obviously, but one of them contains an orange light in shot, which right now circles around the scene.

There are some things that cannot be seen that easily in the screenshots that the engine does. The metallic and glass surfaces in the scene are actually faking a reflection by using simple cubemapping. Since this cannot be seen in still shots like these, I’m planning on putting up a video once the demo scene is done.

So, I’ll just continue now. Bye.

It’s almost always something trivial, but you never expect it to be that simple, do you?
Anyhow. It works fine now.
I started working a little on some actual optimization, and so far it’s going pretty good, except for some tiny bugs creeping in, but those can probably be squashed pretty effortlessly.
In fact, the only thing that doesn’t work right now is the stencil culling routine for eliminating more of those pesky overdrawn pixels.

I’ll just get back to it now, it’s so exciting!

This is the part where I hit my first snag.
But regardless it’s not that big of a deal right now.

It’s once more about the different spaces making it difficult on my poor brain.
And it feels a little counter-productive to have results that almost work.
Right now I try to keep my spaces in world space, as I find it more intuitive that way than other spaces such as view space. But I’ll eventually get to view space when I need to really optimize it.

So as I said, everything is in world space, except for depth, which I store as linear scene z depth.
I then go on to recreate a view space position from this depth and then convert it into world space to accommodate the other data.
But this just produces an “almost right” result. There’s something I’m missing, but I just don’t know what yet.

But like I said, I can roll with the world space position buffer a little while longer. I’m not really supposed to deal with optimizations just yet, but I’m just a human.

So anyway, it looks to me that this renderer will be a pretty sweet base for my projects if and when I do get the basic optimizations working for the deferred renderer.

Back to it!