so, here is my issue:

I had made my game project.

it kind of sucked as a game, granted.

no one cared, and no money was made.

now my ideas and motivation to work on it have largely run flat as well, few new ideas, fewer still that I feel motivated to work on.

spent a while working on video stuff, managed to get a specialized codec up to passable bitrate/quality.

bitrate/quality is worse than mainstream video codecs, but compares favorably here to many other low-complexity VQ based codecs, and can be used for recording full-screen video in real time both on my current main PC and also pretty good on an 11 year old laptop.

I was actually left considering trying to encode video on an ASUS EEE 701, except I seem to have misplaced the thing.

extrapolation gave a good solid "maybe" as to whether real-time encoding could be done on it (basically, seeing if 800x480 could be encoded real-time on a 630 MHz Celeron).

but, motivation fizzled, and there wasn't really much left that really needed to be worked on with this.

it basically achieved design goals (all that would really be left would be fine-tuning for supporting decoding to BC7 partitioned-mode blocks).

then, stuff has gone in a more pointless direction...

I also sat around recently and wrote a basic software rasterizer, with the goal of basically using it as a limited function OpenGL 1.x implementation. the OpenGL API layer hasn't been fully implemented, but it gives "reasonable" results for straightforward rendering tasks (simple rendering test-cases often in the triple-digit fps, on a 3.4GHz CPU, *).

*: it can also do 80-90 fps doing a "console" test, filling a 1440x900 image with 8x8 pixel textured triangles to draw characters. but, if drawing a single big triangle or quad, it can do ~ 250fps for a 1440x900 big textured quad, and ~ 400 fps at 1024x768 (and ~ 900 fps for flat-color fills).

it tries to gain speed mostly by cutting a lot of corners, like for example only supporting NEAREST and NEAREST_MIPMAP_NEAREST filtering, ... and would probably skip out on supporting a bunch of stuff I have pretty much never see used. is also tries to gain some speed via hard-coding a lot of "common-special-case" spans-drawing loops, and mostly using fixed-point and pseudo SIMD (where SIMD is faked mostly via packing multiple values into integer registers).

little to say how it would hold up in an actual game though. the big risk is mostly that a game may potentially have a lot of overdraw, or may draw a lot of geometry which falls outside the special-cases. the goal may be to eventually test using it with Quake 2 or similar (once the OpenGL layer is basically implemented and similar).

but, what people I know basically somewhat express hate on the idea...

basically, people being like "but Mesa already does software rendering!".

it is already established that it is most likely a software GL renderer is pretty much useless though.

vaguely related to the above was sitting around trying to write a basic Windows emulator, where in this case most of the effort was going into basically hacking together some basic mock-ups of basic Win32 DLLs (kernel32, gdi32, ws2_32, ...), which at this point consist almost entirely of stubs (basically, implementing functions when the program dies and helpfully gives a message which Win32 API function was called...).

it is also running in an x86 interpreter/emulator, so in this sense is technically a little closer to something like DosBox than it is like something like Wine. (also, the x86 interpreter itself runs a subset, limited pretty much entirely to Ring-3 32-bit PMode and a 486-like ISA). the PE/COFF loader is also basically built-into the interpreter.

the core libs were being rewritten partly both because the Wine libs wouldn't fit very well on my x86 emulator, and also because I am not particularly wanting the core machinery to be stuck with GPL or LGPL (probably, I will use an MIT license).

also, it is limited to a small subset of the Win32 API (+ GL), mostly because, seriously, I can't possibly, nor am I trying, to re-implement the entirety of Windows (and I also largely consider DirectX and .NET to be somewhat outside the scope of such an effort).

people don't seem to get the idea that it is not the goal to try to recreate the entire OS nor to have any world-changing or community building or whatever. (the initial goal would more be something like being able to run things like MinGW and GLQuake and similar on the thing...).

but, yeah, also a lot of hate over this one, and once again, it is already established that this stuff is probably pretty much useless...

I am like, "I feel like doing this stuff, I will do it", unless something better or more interesting comes along...

like, this stuff is new for me, I haven't personally done this stuff before, so it seems like something to do, and everything I am doing pretty much all seems to be a waste of time anyways, so not like it can probably be all that much worse off on this front...

thoughts / comments?...

The Development of a Developer

by TheComet

You are exposed to a world of infinite possibilities, a world containing more projects, technologies and algorithms than sand on a beach, a world so overwhelming, you will never be able to grasp and understand even a fraction of it in a single lifetime.

You want to see everything! You want to experiment! You want to accumulate as much knowledge as you can! You want to download every project, read every tutorial, sieve through every last piece of code, participate on forums and ask as many questions as you can so you can understand it, and so you can replicate it!

You're thriving with ideas! There are so many cool things to do! So many awesome libraries to use! The code practically flows from your fingertips, testing, experimenting, learning, evolving. Every free minute of your life is used to match braces and brackets, allocate structures and streams, step over and under and into function calls and instructions. You're elaborately weaving more and more complex and successful programs as time progresses, and you've never felt so alive and happy, as you look back proudly at your creations.

Your creations... The smile on your face slowly vanishes. Your creations... They're good, but they're not perfect.

There's so much more to learn... Too much...

How do these libraries work? What's inside them? Can I make them better?

You start digging deeper into covered ground. You try to learn more about how things really work, how others implemented them. "So that's how they're done!" You're overwhelmed. You try to implement new knowledge into existing code, or maybe try implementing it in new code but it's hard, and it's not perfect.

You realise everything is way ahead of what you're doing. You realise every piece of code you write is primitive, buggy, not up to quality with what you've witnessed. You spend days trying to perfect even single classes, trying to find the perfect hierarchy between your objects. You realise you will never be as good as any of the projects you've seen. You realise that everything you do has already been done before, and it has been done one hundred times better than you will ever be able to.

You get depressed. You don't know what to do now. You want to contribute to the collective with new stuff, but you lack the knowledge to do so. Every idea that pops into your head you instantly discard as primitive, a waste of time, an idea not worth anyone's attention because you know for a fact that no one will be interested. You stop writing code , hindered solely by fear of it being inferior.

Lost, you reflect over all of the projects you've created. You're not happy anymore. Your projects suck. No one will ever want to see them.

Your motivation is drained. Why even bother with code? What purpose does it have? Everything I've written is useless, and has already been done before.

-------------------------------------------------------------------------------------------------------

I'm cutting this story off right here, and leave you with a few simple questions: What changed between the young you and the old you, and why has it affected you in the way it did?

when I was younger, it seemed like I could write pretty much anything.

now I have found it is limited mostly by how quickly I can write code + any time spent testing/debugging/doing other stuff.

so, this works out to about 500 kLOC/day average, or 2-4 kLOC/day when basically just writing code at closer to full speed.

but, this is insufficient to recreate the entirety of large systems, and one has to limit things to subsets if they want to implement it, or use 3rd party code.

I have often recreated things, often not much liking 3rd party code.

the major thing that is lame though is that often other people have little better to do than condemn and belittle everything I am working on.

but, pretty much everything that can be done, already exists, so it all amounts mostly to recreating things...

"well, I want this thing, but also don't really want to deal with GPL or similar...".

but, people often look down on whatever I am doing or how I go about things, it gets rather annoying.

well, and people complaining about how I deal with the passage of time, ... like, seriously.

it also starts to appear as if nearly everything is basically everything else but with slightly different macro-architecture.

like, say, game engine vs OS kernel:

both may have a VFS, internal memory management, ...

an OS kernel adds process management and hardware drivers, of which the various drivers may effectively make up like 95% of the kernel, and one may observe that the kernel actually needs to be kept pretty small to be bootable (say, the kernel image needs to fit into around 500kB or so).

the game engine adds a 3D renderer, ...

the Win32 emulator is, ironically, built largely with older code from part of my 3D engine project that I had later dropped from the main project.

at one point, I was like, "I want to do something like Native Client, but lazier...", so just wrote an x86-subset interpreter based around PE/COFF, then messed with it and was, like, "ok, x86 machine code kind of sucks for scripting...".

some years later, I was like, "hey, why don't I write some mock-up Win32 libraries for the thing? then maybe I can run simple Win32 apps on it.".

yes, currently this is the primary extent of this sub-project.

it also becomes quickly apparent that, effectively, there are a "teh crapload" of Win32 API functions...

not that it means it can't be done, but one can't just pull a reasonably complete Win32 implementation out of thin air.

then got in an argument, and it came up that (hypothetically) if this thing were ported to raw hardware (such as a reboot of an older/dead OS project of mine), it would likely need a 2D/3D rendering backend (both for OpenGL, and also GDI calls), and would probably lack HW accelerated graphics drivers ('cause, you know...), so this crap would probably be stuck with VESA/VBE or similar.

hence the OpenGL mock-up.

the rasterizer was the main new-part, but was written mostly based off of my vague-memory of how the SW renderer in Quake worked.

a lot of the rest being intended to be code mostly copy/pasted from my 3D renderer, then modified to mimic OpenGL.

I looked at Mesa, but in the simple case, Mesa in SW mode is kind-of, dead-slow (*).

skimming the source, I had noted that things like nested-switches in the inner loops and similar probably don't help (nor does casually mixing integer and float calculations, ...).

I was mostly doing things like dealing with blend-modes/... via function-pointer magic, and pretty much everything in the rasterizer is fixed-point.

*: there are faster cases, but they aren't built into Mesa, but are external rasterizers it can use via DRI or similar.

but, the eventual usefulness of any of this? probably none...

but, I lack much better to do.

or such...

Let me see if I've boiled this down properly. First, you made a game, and it wasn't a very good game, so you lost motivation there. So you decided to spend your time working on 'utility' projects, but all your utility projects are either utilities that already exist in some other form, or utilities that other people just aren't interested in using, and so you're losing motivation there as well.

I think you're partly right regarding the usefulness of any of the utility projects you're working. You're also right that there's only so much an individual can do. I would personally recommend switching back to actual game development. Either evaluate why your current game isn't very good and try to fix it, or evaluate why your current game isn't very good and start a new game project with a new design that tries to address the shortcomings of your previous game. I think you're more likely to eventually come up with a fun game design than you are to eventually come up with a useful utility that doesn't already exist.

Just my two cents.

Let me see if I've boiled this down properly. First, you made a game, and it wasn't a very good game, so you lost motivation there. So you decided to spend your time working on 'utility' projects, but all your utility projects are either utilities that already exist in some other form, or utilities that other people just aren't interested in using, and so you're losing motivation there as well.

I think you're partly right regarding the usefulness of any of the utility projects you're working. You're also right that there's only so much an individual can do. I would personally recommend switching back to actual game development. Either evaluate why your current game isn't very good and try to fix it, or evaluate why your current game isn't very good and start a new game project with a new design that tries to address the shortcomings of your previous game. I think you're more likely to eventually come up with a fun game design than you are to eventually come up with a useful utility that doesn't already exist.

Just my two cents.

I mostly started out originally cloning Quake, and being fairly systematic about it.

its basic engine architecture is similar to the Quake engine, albeit with a lot of infrastructural differences, and a somewhat different renderer.

then I was playing Minecraft a lot, and then ended up doing a less-faithful Minecraft clone and gluing it on top.

it manages to be neither as entertaining as either Quake or Minecraft...

so, while it works, the essence of it their entertainment value is largely absent.

besides minor features, and things I didn't bother bringing over (*), there isn't really a whole lot left to copy, and I lack ideas for what else to add.

*: for example, it lacks Minecraft's inventory and crafting system.

it is also not file-format compatible with MC, using its own representation for chunks and regions.

also, it mostly uses real-time lighting and shadow maps instead of voxel lighting, ...

I tried at one point to make a 2D platformer, but managed to run out of ideas and motivation here even more quickly.

I guess possible (closer to the original idea for this one) would have been to try to do a clone of the original "Sonic The Hedgehog" games, vs what I ended up implementing (a jetpack dude with bullet-hell style pixelated pedobears as enemies...).

with my other stuff, people dislike it based on general premise I think.

otherwise, yeah, I have made a lot of utility software over the years, most of it has been more for whatever I needed software to do at the time.

now it is more like, "I lack ideas and am bored, maybe go clone some crap..." (at least stuff that I haven't beat to death or cloned already).

like, while I could, for example, go and implement a newer scripting language and VM and maybe fix up some issues with my older one, this would be pretty solidly in "yeah, been there" territory, and the only real likely gain would be trying to make it more performance competitive with C, vs like 3x slower than C (in the JITted case), mostly because this slowdown largely keeps scripting code from being usable in performance-sensitive areas (such as in the renderer). (the planned scripting language would have been somewhat more C-like, vs my old one being at this point more of an AS3 clone).

but, meh, dunno...

Wait, no one thought Quake + destructible voxels would be cool? What kind of people you hang out with dude!?

Wait, no one thought Quake + destructible voxels would be cool? What kind of people you hang out with dude!?

not many...

the main people I know (on the internet) are:

one person who mostly like TBS (turn-based strategy) games (CIV and Alpha Centauri and similar);

another who is mostly into iOS games;

...

other people seem to not care about anything unless it has AAA production values and is available on Steam or XBox Live.

...

none of my family members seems to care.

I also don't currently know anyone IRL who is not a family member.

...

so, this mostly just leaves me by myself...

main games I had liked were mostly games like Wolf3D, Doom, Quake, ...

also Half-Life 1/2, Portal 1/2, Borderlands, ...

but, mostly Minecraft in recent years, since the ability to modify the terrain and build stuff and similar is a bit of an appeal.

If you are really lacking ideas and are bored, then maybe you should just give programming a rest and do something else until you actually have an idea to implement, or find something that's better than programming.

I gave programming a rest for maybe a year, that I came back for the Kraken contest, and programming again was awesome.

Burning out from Lego design, I will probably head back to programming.

one thing I did when i was feeling the burnout coming, I created a software that was to my very own benefit (not entertainment). You may ask what software can be of a personal benefit if you make distributable aplications. Well, there is plenty... just think about all this pile of new technology platforms and frameworks, they push aplications to be dependant- and you can just make it not so. There is a bunh of open source well established aplications that miss third level framewroks on many platforms and so on.

I have recently mostly just been throwing together a pure-software OpenGL implementation.

maybe pointless, but whatever sometimes...

much beyond this, dunno right now...

I guess it is more enjoyable from an experience POV to just do whatever, and forsake for a while giving a crap whether or not it is actually useful (or what might happen in the future, ...), and if it gets frustrating/boring, switch to something else...

may eventually try to get back to "useful" endeavors when the mental burnout wears off...

as for the SW GL:

rasterizer, basically written and tested, currently pulls 500-600 Mpix/sec for big/simple texture-mapped primitives, and around 800 for interpolated colors.

this was after fiddling with some of the arithmetic and similar.

but, it will require being fully implemented to see what the overall performance is like.

technically, will be a bit of a GL subset though.

if performance holds up ok, may consider supporting linear interpolation for textures.