Alright. So I started out this morning by writing a long post where I detailed my decisions that were going in to my Texture Pool design. I nearly finished it, before finally realizing my argument could become moot with a couple simple hacks.

Disappointed in that, I put my head down and got to work.

While working, I realized I could combine both methods, and get the benefit of both.

And eventually finished.

So the Texture Pool is done, but it is late, so I’d rather call it a night. I may revisit earlier post, since it does have some meaningful information in it.

As for a Sunday tool, we’ll see. I gotta read over my notes and think a bit about how badly I want the image slicer stuff, or if I should get on to the slightly hacky screen builder. Hmm..

Toodles!

I have a seemingly endless list of libraries and tools I want, and a few I need to finish up my current project. So I’ll be starting with something I need. If all goes according to plan, I’ll get to start another one tomorrow.

So I need a Texture Pool. In other words, I want a nice way to say “hey, load blah.png”, and it’ll use it’s brains to know that I already loaded “blah.png”, and return me the same copy. Pretty straight forward stuff.

This Texture Pool is a piece I’m adding to my graphics library. Said library is designed to wrap multiple graphics API’s. Currently it wraps OpenGL (1.5) and OpenGL ES (1.1), but it also has a slightly out of date software renderer too (lacking texture support, but does geometry and transformations).

The Texture Pool itself I’d like to eventually support several formats. Currently it supports a hybrid format of mine, LZMA’d Power VR (PVR) files. The way it’s structured, it’s easy enough for me to support ZLIB, BZIP, or RAW PVR files as well, I just don’t currently. And while I don’t yet support them, I have stubs in place for PNG and DDS files.

I have some other wild goals for the Texture Pool down the line. Right now, one of my main target platforms requires square power-of-two textures. So I’d like to build a tool for combining multiple smaller images in to a single texture atlas. I’d also like a way to automatically fatten up a PNG image file, yet still somehow remember the original dimensions. This slicing information I’d like to be known by the Texture Pool, so I can draw centered or aligned texture elements with just a call, instead of having to build geometry or remember dimensions.

My solution to both is a custom file format, vaguely like an archive format. As an added bonus, I want it to be able to support storing multiple images in the same file. But the important point is to create this “many to one” relationship, where I have a single texture and some way to say it contains many elements. I’m leaning towards throwing together a text based format and tool to generate a sliced file, so I can start using this right away.

Alas, that’s a tomorrow issue.

Today, we’re building a Texture Pool. After some breakfast, we’ll do it.

If you’ve already experienced Towlr, you don’t need this.  But if you plan to sacrifice any friends to Towlr, I’ve made some useful fixes and changes.

http://junk.mikekasprzak.com/Research/Towlr/Towlr2.zip

First off, I’ve removed the ESC and F10 keys, since they’ll just make the player sad (or relieved).  Next, I changed the background color to gradually become more red over time, to add to the “driving you crazy” factor.  Finally, I named the executable correctly, so in the future people can stop asking me if it’s towel-r or t-owl-r.

Enjoy.

EDIT: Linux Version (Experimental)
EDIT: MacOS X Version (Intel) (Experimental)

Here’s how to upload an image.  You need to do this for your screenshot to show up in the Image Grid.

Make or edit a post, and click the Add An Image Icon.

Then select “Choose Files to Upload“, and pick your image file.

Leave all the options default, scroll down and click “Insert in to Post“.

Presto!  Your image should appear in your post.

It’s here.  PoV’s 2 hour game.  Towlr

http://junk.mikekasprzak.com/Research/Towlr/Towlr.zip

Towlr is a puzzle.

I will not explain it.  You will be scarred.  You will be scored.

Share your score in the comments.

Source.  Made using Allegro and my LD11 library.

Audio courtesy of sfxr.

EDIT: Windows Version (Added Background Color Change)
EDIT: Linux Version (Experimental)
EDIT: MacOS X Version (Intel) (Experimental)

Yes.  It’s actually playable.  Finishing touches now…

Oh my!

Yes.  I’m totally not doing the compo…

however… words and drawings are appearing on my paper.

PoV has a deadline that he’s already missed.

Totally not doing the compo.

[scribble scribble scribble... dot dot]

Same old same old.

You can check out the library here.

I’m busily finishing up an important little project (that was supposed to be done last week). So I’m unfortunately going to be unable to enter the compo, or work on the little things I had hoped to (unifying the site look and such).

However I’ll be around IRC as usual, offering my wacky flavor of commentary, and whatever administrative help I usually provide. You’ll probably catch me joining in on the various goof-off extras (Desk photos, food photos, motivational posters).

MINI LD #3 should be interesting.  I’ll release some details after the compo.  Stay tuned.

Hey everybody,

The migration seems to have gone smoothly so far.  We’re still playing around with things, but it looks like we’re almost moved in now.  The rules wiki link is something we still have to fix, but if you find anything else wrong, feel free to let us know.

I think I’m blind.

Started at about 2 PM today.

Spent pretty much all day working on cleaning up the camera, and the interaction (integration) between the mouse and the camera. It’s also to a point where it could nearly support multiple views, but it doesn’t yet (or at least I’m not happy with how that code would look right now). I don’t really need multiple views for the prototype, but the editor could use them… when I get around to that.

Hehe, it’s a good thing I don’t have a real Ludum Dare deadline.

I should just stop the clock, and start it up again once begin on actually hacking together a level/the mechanics.

I suppose the camera’s been fixed for a bit now.  Not quite done for the night, but if I do call it one, I’m at a good spot.

I still need/want to clean up the camera code.  It’s just some blah chunk of code sitting in main at the moment.  I need to sit down (in a different chair) and figure out what I want to do with it.  I would like this taken care of before I call it a night.

Next step is to perhaps hack together a level, or do the character particle stuffs.  The game I’m working on is one that would have suited the LD8’s “Swarms” theme.  Well, there’s aspects that could suit several themes, but it’s a swarm game more than any other.

Fun fun.

PoV’s Fake LD Compo! Me versus me! Winner takes all.

I actually planned to start this on the weekend, but it’s Monday already. I’ve had a game concept I wanted prototyped for the past few weeks, but between library development work and some portability stuff, I just hadn’t got around to it yet. Maybe a little bit of slacking too.

So I started today just after 1:00 PM EST (not that I’m forcing a 48 hour limit). The first order of business was to butcher the test suite application from my work in progress geometry tests library. It currently uses a wrapped version of 2D Allegro for graphics (suspiciously featuring many function calls that make it work like a 2D OpenGL, matrix stack and all). Currently the only drawing operations supported are circle and line based, which exactly what I want for geometry tests and prototyping.

Prior to LD11, I was working on a file format and loader/saver for 2D geometry. I call them PolyMap’s. It’s whitespace delimited text based format, sort of like an assembly source file. Unlike the dozens of geometry formats I’ve written in the past, I wanted this one to be generic and extensible. The last one I wrote was was a convoluted 2D mess supporting vertex, texture, geometry and spring constraints animation. Eventually I’d like to assimilate that format in to this one, but I want to keep the format simple enough to do other random things with it.

As is, it’s suitable for creating static background collision (polygons), creating 2D paths/rails, placing “things” that you’d normally find in a game level, and numerous straightforward hacks. The format could also be used to make polygons/circles + springs objects, but I don’t need that right. I’m editing files by hand at the moment, but eventually I’d like to have an easily reconfigurable tool for creating stuff in the format. I’m expecting to hack something together soon.

So anyways, the first order of business was to load and use a PolyMap file with my fake OpenGL rendering code. That came together quickly, so I dived in to some camera stuff. That pretty much brings me to where I am right now.

(The shape with the normals is actually a polygon, I was just too lazy to create a more obvious shape.)

Camera stuff “sorta” works. I can pan and zoom, and the camera is bound to a region of the map (noted in the PolyMap file). Cursor relative zooming doesn’t work right yet, and the bounds don’t restrict correctly when zoomed. Once that’s sorted out, I’ll probably gut the camera code and make it a feature of my fake OpenGL renderer.

Back to the fun.