Another One Bites the Dust

Man, remember that post I made about that game I was working on? Hah. I do, and now it’s rather hilarious and embarrassing that I even posted about it at all. So, what is going on? Well, I’ve had a lot of life stuff happen this year, which has eaten a lot of time from me working on stuff. The game I was working on codenamed Adrenaline is no longer happening.

Adrenaline Dev Log - 01

While this is technically the second update for my game, the first update was really just a GIF dump. This is also pretty much going to be a GIF dump, but with some explanations. I’ve done a lot over the last few months to the game, but have been slacking a bit too much lately. My goal is to have 5 levels by next month so I can start doing some shader programming and look and feel polish.

Shibboleth Dev Log - 01

Once again, it has been several months since I’ve posted anything. I’ve decided it would be beneficial to keep a development log of what I’m working on. So, here it goes. The two main things I have been working on are re-writing the reflection system and how I handle engine modules. My goal is that when writing modules to extend the engine, I’d like as little boilerplate code as possible when hooking up the DLLs.

Project Progress

First off, I’ve begun doing a major refactor of Shibboleth. I’ve currently replaced all of my containers in Gaff with those from EASTL. I have also begun re-writing the reflection system. Hopefully this re-write will come with better functionality and simpler implementation. I have started this work in a branch, so the original code is still about if anyone is curious to run a functional, but broken version of the engine.

Not According to Plan

As per the usual, I’ve been extremely late on posting about … anything. I also completely invalidated some of my former posts. I’ve dropped working on Contrivance (the editor). This is due to a couple factors. I hate Qt. I spent 99% of my development time fighting Qt and trying to work around it than actually implementing features. Qt’s support for dockable windows is fairly non-existent. To that end, I have been attempting to integrate Nuklear and embed the tools into the engine.

Contrivance Progress

Hello again! Another update in roughly a month and a half! This time I’m talking about some of the work I’m doing with my editor, Contrivance! I’ve shifted my focus away from Shibboleth for a bit and am focusing on getting my editor up and running. I have started accruing enough data formats that it would be nice to not have to edit JSON files by hand. I am making the editor with the ever popular Qt library.

Shibboleth Engine Structure – Part 1

I feel like I haven’t said anything particularly useful in a while, so I’m going to go over the architectural design and flow of my work-in-progress game engine, Shibboleth. Application Layer Our journey begins at what I call the Application Layer, which is nothing more than what the executable the end-user runs actually does, which isn’t much. To start, let me explain the expected folder structure the executable assumes.

Back from Long Hiatus

It’s been a few months without any updates from me. Fear not, I have still been working on Shibboleth. Most of my work has been updates to supporting libraries more than actual engine work though. To name a few, I added schema validation to my JSON class, restructured my job pool system, and started adding in the actual graphics pipeline to the engine. I’m having to do a bit of a refactor on my graphics multithreading.

Things And Stuff

I really missed my one post a month target by a long shot this time. Two months late! I got my update system to run in stages. So now you can specify updates stages that all run independently of each other, but in order. The updates all operate on frame data that is saved and passed to each stage. This way one stage can continue generating the next frame while the other stages are doing work.

Getting Sidetracked

I got a little distracted these past couple months. While hashing out my camera system, I realized that I didn’t have all the support in reflection that I needed. Mainly, I didn’t support reflecting arrays. It took a hell of a long time to get it in, but I finally have it. I also got distracted from writing this post, so it’s a month later than my usual month late posts.

Memory Leaks are Fun

Well, I had a pretty uninteresting weekend on engine progress. Effectively, I haven’t made any real progress on the engine part. I mostly spent time tracking down and fixing bugs. I fixed a very egregious error in my HashMap code when removing elements. I was trying to get smart and try not to rebuild the entire HashMap when removing an element, but it was failing in certain cases. I have resorted, for now, to do the brute force HashMap rebuild methodology.

Yet Another Uninteresting Progress Update

Again, nothing interesting has been happening lately on the game engine front. I’ve spent this weekend implementing the necessary classes for doing frustum culling. For those who don’t know what that is, this will allow me to figure out which objects are actually within the camera’s frustum and only render those objects. This, however, does not take occlusion into account, so I could be looking at a wall and it will still return objects that are behind the wall.

Fixing Gleam

I’ve been silent for a little while, but I have been getting some work done! I ended up fixing a bunch of threading issues with the OpenGL version of my API. The problems were with sharing display lists and loading resources on worker threads. Shibboleth can now run with both Direct3D 11 and OpenGL 4.3 renderers. I’ve also implemented deferred versions of render device on both versions of the API. With these you can generate command lists on other threads and then play them back on the main thread.

Long Time No Post

Been a bit lazy on posting. Been in a little bit of a slump, but I have started making progress again. I’ve been having some difficulty figuring out how to further develop my reflection system. To help me figure this out, I have begun working on my editor. I’m hoping that by working out how properties will be consumed and displayed in the editor will give me some insight as to how to proceed fleshing out reflection.

Graffix!

Missed my once a month post. Been a little silent, but I have made some good progress. I finally got mesh and skeleton loading finished. Or at least functional. It took me a little while to figure out how I should structure my vertex data, but I think I’ve gotten a pretty good solution. I do have graphics actually running in my engine now! … sort of. I hacked in a couple things just to get something drawing quickly.

Moving Along

I’m slowly but surely making progress. I’ve since added an UpdateManager, which essentially manages the updating of other manager. Some engines call what I refer to as managers as systems. I have an IUpdateQuery interface that a manager can inherit from. When all the managers have loaded, the UpdateManager goes through each manager and queries for that interface, then adds their update entry to a list in the order specified in a JSON file that is passed in.

Blowing Off Steam

Missed my one post a month quota by a little bit here, but better late than never I guess. Things have been going pretty slow these last few weeks. I’ve been taking a little bit of a break from developing Shibboleth to relax and release some stress. I’ve recently just played through a couple of Daedalic Entertainment‘s point-and-click adventure games set in The Dark Eye universe. These games would be The Dark Eye: Chains of Satinav and Memoria.

Premake Conversion

A little past a month, but better late than never I guess. This month I converted all my projects over to premake, specifically premake5, which you can only get by building it yourself! I’m not expecting everyone to build premake and generate their own projects, so I pre-generate Visual Studio 2013 solutions and Linux makefiles for you! I also converted the projects for ResIL and ResILU from generating statically linked libraries to dynamically linked libraries, to comply with the LGPL license.

Late Post is Late

I missed my one month window for my post! Nuuuuuuuuu! This is just a quick post to say that I’m not dead. I’m a bit tired and it’s late to start something technical, but I have made some progress on Shibboleth. I’ve gotten some of the basic infrastructure down and started integrating Gleam and OtterUI into the engine. Although, I should point out that my “integration” is completely optional from an engine standpoint.

Message Broadcasting in Gaff/Shibboleth

Hello all! Today I’m writing another technical post about how message broadcasting is done in Gaff/Shibboleth. The high level idea isn’t very complicated: Listeners are registered as either functions, member functions, or functors. When a listener registers themselves, they are returned a “receipt”. When this receipt is released, it will automatically unregister the listener. While this adds some extra memory usage from having to store all these receipts, the end user no longer needs to remember to unregister manually!

Raw Input on Windows

An actual technical post! Whooo! To start, why am I posting about this? Well, for one thing, this is one of the most recent things I’ve implemented in Gleam. First thing to note is, when I saw “raw input”, I do not mean DirectInput. Modern versions of DirectInput are simply wrappers around Windows’ raw input API. While you can still use DirectInput, it is not recommended, as it has been deprecated for quite some time.

Game Engine Progress (I need better titles)

Man, my titles really are boring. I’ve made some pretty significant progress. I’ve actually started developing the game engine! Yay! One of my main efforts in this engine is to make everything as data driven as possible. Although, this may lead to some overkill with DLLs, or, as I’m calling them, dynamic modules, since other platforms do not use DLL as their extension. I’ve implemented a wrapper around Jansson, a JSON parser written in C.

Multi-Device/Monitor Support!

Been switching gears from Gaff to Gleam. Did a big round of bug fixes, majority on the OpenGL side. Turns out glTexStorageXD() (X being the dimension) followed by glTexSubImageXD() does not produce the same result as calling glTexImageXD(). While it compiled and glError() reported nothing, textures were not getting loaded correctly. The texture would have a random sized black block in the bottom-right corner. Switching to glTexImageXD() fixed this issue.

Nothing Much

My monthly post is a little bit late. Not much to say though. Work has been pretty busy, so I haven’t been putting a whole lot of time into my projects as I’d like. I’ve mostly been reworking the way objects that give receipts work. My plan is to basically have the receipt have a pointer to an interface that it can call release on when it needs to. This way I’ll avoid the need to make receipts template objects that need to know about the allocator used by the object that created it.

Gaff: Threading

New post in under a month! Yay! For serious though, I’ve found that I haven’t really posted anything on the internals of some of my projects. I really want to, I just don’t really know how to go about it. That and a lot of the things that I am doing, I’m learning at the same time. Take for instance, threading. I know what a thread id and I know some of the basic synchronization techniques such as mutexes, semaphores, and what-not.

Happy Thanksgiving

Hello all! I didn’t quite meet my one post every month quota this time. But I am here to wish you all a happy Thanksgiving! Not as much to talk about as I’d like, but I’ve made quite a bit of progress on Gaff and Gleam. I cleaned up the codebase a bit and added some cool new classes by using typename aliases and variadic templates. Not sure if I mentioned, but I kind of changed the scope of Gleam a little bit.

Gleam Progress

No pictures or video yet, but shader support is complete and I have a working camera that you can move around the world! I have some basic shapes that I’m generating in code as test cases right now. I had to go around the code base a bit and make abstract interfaces for some of my classes, since it was possible that they could be compiled into different versions depending on whether you were compiling for Direct3D or OpenGL.

Graduated

Just checked my grades and it is now official! I have graduated from DigiPen with my bachelors in Computer Science! Or Real-Time Interactive Simulation (RTIS), if you want the useless name for it. I also have just gotten my graphics engine, Gleam, into a state where things are actually appearing on the screen. Here’s a screenshot of my first test! I just have to clean a few things up and fix/implement some things on the OpenGL side and I’ll be off to a very good start.

Gaff, Gleam, and Reminiscing About Project Mercury

New post within a month! Lately I’ve been having a lot of fun doing some cross-platform development. I’ve got two libraries I’ve been working on. Gaff, which is my general purpose, stick whatever I feel like in it, library thing. It encompasses a lot of stuff, such as timers, personal implementations of standard data structures (i.e. vector, list), and other useful things that I make C++ wrappers for. Gleam is the other library I’ve been developing.

Network Programming is Hard

I just finished up the Advanced Networking class at DigiPen, and I just gotta say it. Network programming is hard! It’s easy to screw up, and even implementing simple features cleanly and robustly can be challenging. Take enet as an example. If you read through their feature list, it looks like pretty standard fair for a networking engine. My team and I more or less implemented this in our class. It fell quite short of enet.

Bjarne Stroustrup’s GoingNative 2012 Keynote

I just watched Bjarne Stroustrup’s keynote from GoingNative that happened in February of last year. He had a lot of great insight on how to write better code that is easier to read, less error prone, and faster! Now, I still have concerns about the STL. It’s great to see a lot of potentially more portable code being made available via the STL, especially if you look at the concurrency domain.