Sign in to follow this  
  • entries
  • comments
  • views

About this blog

This is a blog about my daily development of my game and codebase, which I develop in my spare time while taking transit to and from work.

Entries in this blog

Hey Everyone!

I haven't posted a blog entry in a long long time. I've been so busy with work and the kids at home that it's hard to find the time these days to write up an entry.

I have been busy though, building costumes, fun projects with my 3d printer like a jukebox and an arcade cabinet. I've also been hard at work on a new programming project, and that project is a tool to aid in the building and designing of costumes. Something like this exists already called Pepakura Designer, but it's more aimed at paper craft models and not so much at actually building costumes and the development was fairly stale with not much for updates to the core functionality.

I decided it was time to do something about this and build a new tool myself. I'm using my own c++ framework that I've been developing for the last few years and Awesomium to handle the frontend. Using something like Awesomium for the frontend is great, there's so many samples out there for html that it was pretty easy to cobble together an interface. It will also make it easier if in the future I decide to bring on an artist for UI design, as they won't have to learn a new technology.

So my initial attempt was fairly simple, just get a PDO file( the format that pepakura uses ) loading and rendering. I wanted to add the ability to import PDO's as there's a wealth of them available out there and a large community behind them. It was crucial that I have that capability in the tool.

So here was my first attempt, just a 3d model( my own Iron Man Mark 3 chest ) and some line rendering for the unfolded patterns.


The next step was start to add some functional tools. The first ones I implemented were Translate, Rotate, and Cut/Join for the 2d patterns.


Now that I had some tools in place I wanted to get my own basic unfold algorithm in place so that a user could load up a 3d model and generate their own unfolded patterns from it without needing any external tool. This took me a while to get all the bugs out of it. Even now there's a few lingering things I need to fix up with it.

Next I did some work on the actual rendering of the 2d patterns. I added a mesh for the geometry, numbers for the edge Ids, and tabs for where the edges need to be glued together.

Now I was starting to get somewhere. I wanted to get the tool out to people so I could start getting feedback on what people thought. I spent a few months cleaning everything up. I added undo/redo functionality. I hooked up print functionality so users could print out their costumes. I created a file format for saving and loading. I also did a big overhaul to the front end.

To get ready for the first alpha release I put together a video demoing most of the features I had in the first alpha build.


I released the first early alpha last month, and quickly found out that not all versions of Windows are created equal. It crashed on all versions except Windows 7. It took me a while to figure it out but I was trying to access some memory before it had been allocated because of an early resize message from Windows. For whatever reason it seems that on Windows 7 accessing that memory doesn't cause a crash ( though one would think that it should ) and on all other versions of windows it crashes.

From trying to figure out that crash I discovered this awesome Microsoft site that has free virtual machines of all the different OS's for testing purposes.

So now here I am, here's the two latest screens from the tool. I just added support for textured models, which really bring things to life. I'm working on getting a scalable dummy in the tool that you can mount costume parts on to make scaling easier. Nothing worst than printing out a piece, building it, and finding out it needed to be 5% smaller or bigger. I'm hoping to get another stable alpha build out before the end of the month.

You can find out more about the tool, like download links at the discussion page.

As well you can follow me on Facebook to see all my latest projects,

I'll try to post more regularly as I continue to develop this tool. Thanks for reading!
This is a repost from my external blog

Hey Readers,

So I mentioned at the end of my last post that I was going to give this One Game a Month thing a go as a sort of New Years resolution to complete more projects.

So here I sit at the end of the month with my first finished project, Asteroid Alan. I present you with a bit of a post mortem on the first project in this series.


It's a mash-up of Dig Dug and Asteroids. The idea is to maneouver your ship in behind the asteroids and latch on to mine gems and minerals from the mines. Once you latch on you tap the space bar and the asteroid blows up, leaving a bunch of gems floating? to collect and splitting the asteroid into smaller pieces. You can also fire the latch at the asteroids from in front but it splits the asteroid immediately, doesn't leave any gems, and you don't get as many points so it's in your benefit to manouever behind the asteroid but still leaves you with options if there's an asteroid barreling down on you.

Plan of Attack

I knew immediately that this idea wasn't going to succeed without some kind of planning. I broke up my schedule into 4 weeks of 5 days since I only work on my projects while I'm on transit. I allocated 2 weeks for coding features, 1 week for art and sound, and 1 week for polish and bug fixing.

What Went Right

A whole lot went right. Having a schedule for all the pieces that needed to go into the game I knew exactly whether or not I was on track to finish. This helped me on a day by day basis by letting me know if I had the time to spend fleshing out a feature that extra little bit. I'm also really happy with how much this furthered my engine. I've now got the start of a great particle system as well as a basic approach to laying out post process effects. It's also a great feeling to actually finish a project from start to finish.

What Went Wrong

Not a ton of things went wrong, I'm quite happy with the end result. However there were a few things I wish I had of gotten to. The first and most obvious being the lack of sound in the game. I managed to integrate sound playback into the engine but I didn't leave enough time to scour the internet for sound effects to put into the game. I think on the next go I'll do more research into sound, maybe try out some of those sound generation programs they have for generating 8-bit sounding effects.
Another thing that could have gone better is actually sticking closer to the schedule. While the schedule was great for helping me to keep track of where I was, after the second week I kind of started jumping around the schedule I had layed out. As a result my front end kind of fell to the wayside because rather than working on frontend when it was scheduled I just blocked in the flow and moved on to other tasks. This wasn't necessarily a bad thing though, I can't say for certain that I would have gotten everything going as well as it is if I had of dedicated more time to fleshing out the frontend.
One last thing that didn't necessarily go wrong but I hadn't accounted for were bugs in my engine. It's funny how many times you hear, "Make games, not engines." it's actually quite true. I had built this complex engine with a bunch of tech demos but when it came time to turn the chunks of code into a real game I ran into quite a few use cases that I just hadn't accounted for.

What Needs To Change

One thing that I really need to change is how I have my engine layed out. It's currently all in a single visual studio project along with all the source code for all my projects. I have a launcher menu that lets me select what game/tool I want to launch into. As I've been developing this has been great because it allows me to quickly jump between different projects, making sure I don't break anything along the way. This was annoying though when I was trying to get this game ready to release because I had to comment out a ton of the launcher stuff and a few other items that were slowing down the launch. It's also a real pain when I make a low level change because all of the source is in this one project and on my little netbook I can waste a whole commute just compiling.
Moving forward I think I'd like to separate out the engine into it's own library and move all my projects into their own project files. This should help with compile times since I'll only be building the code that I'm working on at that time.

The Game

So I present to you, Asteroid Alan. I think the only requirements are DirectX 9 and a graphics card capable of shader model 3.0.

Controls are:
W for thrusters
A,D to maneouver left and right
Spacebar to fire latch





Earth Cubed

This is a repost from my blog

It's been a long time since my last post!

Life has been so busy the last couple of months I just haven't been able to find the time to post. I took a break from the bar game over the month of December. As you readers have probably noticed my attention span for a project usually lasts about a month before I need a change of pace. So as a change I decided to spend some more time on my voxel earth project.

Kind of took a step back and decided to get a voxel globe rendering first rather than getting all the height maps loading properly. It should be fairly easy to drop in the height maps though. I've got a nice chunked lod working so each tile subdivides as the camera gets closer and closer to the surface down to about 100 meters. There's a lot of depth issues I need to resolve at that resolution but I'll revisit that down the road.

I spent some time on the rendering as well. The atmosphere rendering in particular. I used Sean O'Neils implementation of atmospheric scattering as a starting point and made a few modifications to get more of it running in the pixel shader rather than the vertex shader which gave a smoother result. The big thing that's still missing is to render in HDR and apply some kind of tonemapping. I'd get much better results that way. For now I'm just applying some tonemapping to the end pixel result so that I get a nicer visual range of values.

Now that I've got the rendering working there's going to be quite a bit of work on my post processing tool that splits up the DEM's into bite sized chunks to map onto the surface. The work is fairly straight forward but it will take some time to switch everything around. Probably more time than I really want to invest at the moment. Not to worry though, I always come back to projects.

Moving forward for the new year I'll be taking a break from these big projects and giving the one game a month competition a try. More to come about that in my next post.








This is a repost from my external blog

Hey readers, the last two weeks I've been working on game resource management and progressing on my job system.

Job System

My initial plan for the job system is essentially that every job has a set of abilities. These abilities can be learned by having that job assigned. The user can issue requests which need to be executed but not directly use the abilities. I iterate over all the character looking for a character that has an ability which can execute the request. Initially I implemented the abilities as a chain of actions. This worked good for my basic needs, my first ability being a build item ability, which consisted of an action chain with a move action and a build item action. This worked but then I started looking at resource management( like using resources to build something, not like in game assets ) and quickly realized that my simple chain of actions was not going to get the job done.

Behaviour Trees

What I decided to do was to make each ability it's own Behaviour Tree. This way I can define very detailed behaviour for how each ability will work. For example my initial flow for the build ability is:

  • Check to see if character is holding construction resource
  • If they are
  • .....Check to see if character is in range of the item to build
  • .....If they are
  • .........Start using resources to build item
  • ....If they aren't
  • ........Move towards build area
  • If they aren't
  • ....Check to see if resources available on map
  • ....If there is
  • ........Check to see if character is in range of resource
  • ........If they are
  • ............Pick up as much resources as character can carry
  • ........If they aren't
  • ............Move towards closest resource pile
  • ....If there isn't
  • ........Fail out job can't be completed right now.

    If the job can't be completed it's unbound from the character ability and returned to the bottom of the command queue.

    Actions and Decisions

    The way I've gone about implementing this is to set up two templated classes, Action and Decision. They both take a templated type which has the implementation for that type of action or decision. Decisions are designed to be the logic which decides which path to take in the tree. Actions are designed to be small pieces of logic which are at the end of a chain of decisions. This is all then linked together with fast delegates. Every decision has a pass, and a fail delegate. Decisions and actions then have a function for get a delegate instance which can be hooked into the pass or the fail.


    These behaviour trees are then assigned to an ability. Currently the only implemented ability is the build ability. The idea is that every job has a number of abilities that can be used by the character that has that job equipped. For example the build ability is a part of the Handyman job. The user doesn't actually control these abilities. What they do is generate a request, so

    • The user chooses a tile they want to build.
    • They generate a build request. This request goes into a global request queue that the characters have access to.
    • On the character update if they aren't already fulfilling a request they will check the request queue and see if any of their abilities can be used to perform a request.
    • If an ability can be used, that ability is bound to the request and the character can start performing the request.
    • When the request is completed or can no longer be executed the ability is unbound and the request is deleted.

      I have a video demoing the evaluation of the build ability. The blue tiles are spots where I've laid down a build request and the crate in the corner is a resource crate that contains some construction resources.

      Apologies for the frame rate. I recorded it on my mobile dev machine, a Toshiba Netbook, so the recording software taxed the system a bit.


I Love This Bar

This is a repost from my external blog

Holy smokes its been a long time since my last blog post.

I've kind of switched gears in my codebase and I wanted to have something to show before I wrote up my next post. For the last year or so I've really been concentrating on getting a lot of the core components I needed to write a game at the level I'm used to from working on games professionally. After finishing most of the core front end code I finally felt like I had enough blocked out that I could start to write a game. So I pulled the trigger and got down to work.

The game I'm working on takes a lot from simulation heavy games like towns or gnomoria which both draw a lot from dwarf fortress, a game which I've read a lot about but never played. This game I'm building differs a fair bit from those games though in that I'm not trying to simulate a medieval world, what I'm hoping to simulate is a bar/night club. I spent a lot of my youth bar hopping and I feel there's a lot of material that can be pulled from that environment and translated to a really fun game.The basic premise is that you start off with 4 characters and an empty lot and you have to assign jobs to your characters, build up a bar, get patrons, build up a regular clientel and just try to have the best bar in town.

I've done some research into what's out there but most of what's already out there just feels like farmville in a bar environment. That is not what I want to build, what I want to build is something for more core gamers with lots of different jobs to master, experience building, stats to track. I want to create an environment that feels somewhat alive.

So far I have a small lot working, with characters that respond to commands. Currently the only "job" I've implemented is "The Handyman" which will be responsible for construction in the game. The characters are able to build walls and that's about it.

Over the course of the next year I'm hoping to crank out something that's a lot of fun to play and filled with lots of quirky humor. I'll try to be better about the weekly updates. In the mean time here's a few screenshots from my progress. Also all art is just placeholder.






This is a repost from my external blog

Week 1

What a tough 2 week sprint!

The first task to pick off was getting screen saving and loading working. This was actually really easy to get going because serialization was built into my sprocket system. So in order to save and load all I had to do was serialize out the sprocket data to xml and then for loading I just had to write some code to place the loaded data into the right containers. I also ported over the code for throwing up the save/load dialogs. I kinda cheated when I originally setup the save/load dialogs. I just call the default win32 dialogs rather than create my own dialogs. I neatly packaged it up in my platform code so it should be easy to abstract it out when I do eventually get the code running cross-platform.

The next big thing was fixing the broken window drag functionality. I had a really tough time for this one for stupid reasons. It made for a really bad morning. Basically the problem was that all my mouse handling code was in local space. This works great for some things but when you're trying to move an object and the local space is changing everytime you move the object it creates some serious jitter! I didn't have a good way to expose the screen space deltas which is what I needed to move things properly. What I wound up having to do was calculate the delta based on the parent's coordinate space. I can't help but feel that's going to bite me down the road but for now the mouse drag is actually working better than before I started refactoring the UI system.

Once drag was working I was able to hook up the scale and translate buttons in the gizmo I created for manipulating UI Elements. I decided to leave rotation alone for now. Currently my UIClickable sprocket doesn't take into account rotation. I don't imagine it'd be a tough change, I already have a transformation matrix, it's just that I'm only using the translation element of it. Still I know it's going to be a lot more complicated then just multiplying by a rotation matrix.
I also spent some time just getting all the UI elements working with the UI Editor. While I was mucking around with that I needed to get arrays working with the protoform editor for certain create params. I managed to get them working the only problem is that they only work for simple types. So the problem is that I'm already using comma separated lists for the complicated types like Float3 which take multiple parameters for initialization and the way I'm parsing arrays is a comma separated list. This shouldn't be too tough to clean up in the future, just use brackets or something to separate items between commas.

Another big thing for this week was building a better way of viewing loaded assets as well as providing a means to select what textures to use in a UI element. The old way to select a texture for an element was to open up the xml package, check what I had set the id for on that particular asset and then type that id into the texture field in the protoform editor. I was about to start laying out the components in code when I realized this was a perfect test case for the editor! I always find when I actually start using a tool I find all sorts of bugs and come up with new feature ideas. The first bug/problem I ran into was that objects sorted in the order that they were placed. This was no good, I needed to be able to control the layering. For a simple solution to this problem I decided to use the z value I had been ignoring up until this point to sort the objects. I wrote some code that does a sort whenever an objects z value changed.

So once I had the sorting issue worked out I set about creating the asset entry ui element. This was easy, lay out a UISprite background, UISprite for a thumbnail placeholder and a UIText for the asset name and I was done. Then I realized that I had no way to load the object up and actually hook some code into it to replace the placeholder elements. I decided that the best thing to do was just start pounding out some code and see how it feels. I had the objects loaded into a UIContainer object and set up some code so I could clone that container so that I could create multiple objects using that template. I set up a UIAssetViewer class that held a bunch of these containers and did the logic for swapping out the placeholders. It works but I think it still needs some refinement.

Week 2

In the second week I managed to get the asset panels loaded and populating a UI container. There was another big cleanup operation, I needed to get scroll bars fixed up and switch my window class to use the UIComponentContainer for storing all the objects parented to it. This wasn't too bad of a change it was mostly copy and paste with a few little fix ups. The scroll bar on the other hand.....

I spent the majority of the week working on getting this damn scroll bar working. Funny thing is it's still not working properly. The big problem was that I was trying to debug something that was a few layers deep. Getting all the math working properly was just turning out to be a huge pain. I managed to get something kind of working and that's going to have to do for now. The way it works is that it's designed to just move the components in the container around. It seems easy enough but for some reason I just couldn't get the math right for the life of me. I think it's one of those silly things where if I sit down and draw it out on paper it's going to become painfully obvious where the problem is coming from.

I also spent a little bit of time on cleanup. I cleaned up how I was calculating a lot of my element positions so that it's more data driven. This will make reskinning my UI elements a breeze. As it stood before I would had to have adjusted a lot of math but now it should just work.


[size=2]WIP shot while I was getting the dragging working.


[size=2]Showing off a few of the different UI elements.


[size=2]First shot of the Asset Viewer working.


[size=2] Adjusted the dimensions a bit to something that fit better on screen.


[size=2] Showing off the scaled down UI. It makes better use of space but kind of loses the pixellated look I liked.

This is a repost from my external blog

I spent the last 2 weeks working on a 2 week sprint to try and get the beginnings of a UI editor in place.

Week 1

The first step was cleaning up all the UI Elements I'd accrued over the last year or so. The big problem was that as my codebase evolved I didn't want to spend the time to go back and clean up old systems. On one hand this worked to my advantage because I was able to iterate much faster. On the other hand it left me with a lot of cruft in my codebase.

The first thing I wanted to clean up was the UIClickable. Maybe I should go into a bit of background though before I go into the details. Almost every UIComponent is made up of 4 core sprockets, TransformSprocket, UIDimensions, UIClickable, and UIRenderable.

TransformSprocket: The transform sprocket is a common sprocket that just wraps a matrix, I use it in any component that needs a transform of some kind.

UIDimensions: This guy contains a width and height and is used to calculate the bounding box of a UI element.

UIClickable: Things get a little messy here, bad naming choice. This guy basically takes care of any input functions a UI component might need, these are currently mouse events and keyboard events.

UIRenderable: I haven't been a fan of this guy from the start, but basically any UI element that can be displayed has one of these and gets linked up through the IO system with a render callback which handles any necessary rendering.

Ok so where was I, ah yes the UIClickable. So previously I had an old message passing system which packed any necessary data into a message class so any function which took a message would have to pull out the data it needed from the Message object. The problem with this of course is that the person implementing the function doesn't actually have any idea what's actually in the message since it's really just a blob of data. Anyways over the course of the project this evolved into my Energon IO system which takes strongly typed messages so you know exactly what you're getting. The problem though was that I still had a lot of the old message handling going on and UIClickable had paths for both. So the first step was ripping out all the old message handling and clean up any of the UI elements that were still using that code path.

While I was cleaning up the code paths another problem I had with the UIClickable was that all of my coordinates for an object were based on their parents coordinate system, so a button at 0,0 that lived in a window, the 0,0 would refer to the center of the window. Now to accomplish this I had put all of the code in the mouse event callbacks in every UI element so that meant a lot of duplicated code, and in some cases the math was slightly different then other elements.

To clean this up I moved all of the conversion to local space calculations into the UIClickable. Since every sprocket can access it's parent and from there could access the TransformSprocket and UIDimensions it wasn't much work to refactor all this code. The downside to doing this though was that it meant not only did I have to rip out all the old codepaths in the UI elements, I also would have to refactor the current code paths to take into account that this was now being calculated inside of the UIClickable.

Another thing I put in that I didn't have before was mouse over events. I think this gives a really nice touch to the UI. Makes everything feel more alive when there's some kind of texture change or effect on mouse over. This led me to rework my buttons a little more. As it stood currently the buttons had support for textures on different states ie, mouse over, mouse down, idle. However I hadn't actually hooked those textures up to the UISprite which is a part of the button. So I set about adding a simple state machine for the button and setting up the sprite to take a different texture depending on the state that the button was in. I set up some safe guards so if a texture for a state isn't set in the create params it will just use the idle texture and of course if there isn't an idle texture set it will assert.

At this point I took a little break from the UI and had a look at revamping some of the code I had in place for hot swapping assets. What I had in place previously was a system which allowed you to specify a directory and a callback and if any files in that directory changed the callback would be called with the name of the file allowing you to perform any needed code to reload the asset.

This didn't really work very well for assets that were nested within multiple directories or if multiple asset types lived in one folder. What I decided to do instead was change my FileWatcher task to register with the AssetInventory callbacks based on asset types. So in this way there was a callback for Textures, Shaders, VoxelSprites, etc etc. I set up callbacks for all the main asset types I'm currently loading and plan on expanding it down the road with user specified type callbacks. So now it queries the AssetInventory every so often for the loaded assets. It then calculates an initial time stamp for any new assets. If the asset is already registered with the watcher it checks to see if the timestamp has changed. If the timestamp has changed then the asset is reloaded and swapped out of the AssetInventory. This way it's seamless to all the other systems, since all assets in the engine are passed around as handles which point back to the AssetInventory.

At least... all assets should be handles. The reality of it was that I had written a lot of my code that works with textures before the AssetInventory was in place. So this meant refactoring a lot of my material system to work with handles to textures instead of pointers. While there's a bit of a hit dereferencing the handles I think it's worth it in the long run. It'll help a lot when I get into streaming textures, so that I'll be able to seamlessly load in different mip levels by just swapping out textures in the AssetInventory.

Finally I started fleshing out the UIEditor. I set up a new game state that's selectable from the main screen. I also added in some of the components I had in the level editor, a protoform type list box for selecting what type of sprocket I'd like to create, and a protoform property window, which allows editing of the create params for a sprocket type. I also started to ponder how I would handle hooking up these UI screen's I create to actual gameplay logic. I settled on a solution where I would create an interface sprocket which would contain a number of inputs and outputs that I could link up in my IO Editor component to handle most of the logic that would be necessary for the screen. I also pondered setting up a scripting language to use with the front end. I'd like to get a scripting language in eventually for gameplay so I thought it might be as good a time as any. I put that on the back burner for now though because that comes with it's own set of problems that I'm sure will keep me busy for a few weeks.

Week 2

While I had added the protoform property window in the previous week, with all my changes to the UI nothing worked on it. It didn't even render! So I spent most of the day getting all the UI sprockets it uses working again. It was mostly easy work, just a lot of ripping out code and waiting for builds.

The next thing I wanted to get going was a gizmo for quick editing the UI sprocket. My plan was basically a border around the object with 3 buttons in 3 of the corners. A button for translation, rotation and scale. Clicking and dragging on the appropriate button would perform that transformation. I was able to get a button spawning but it's a bit of a hack for right now and currently the gizmo isn't hooked up to anything.
I also began pondering what my next sprint would be. I think I'd like to spend one more week fleshing out the basics of the UI Editor and then start working on an Animation Editor. It's kind of a big jump but I'd really like to get going on gameplay mechanics again and one of the things that was holding me back was getting in some placeholder animations. I think an animation editor would help get me going again.

Unfortunately this week was mostly all about the builds. I was changing a lot of core headers which caused 15-20 minute builds on this little netbook, that's a good chunk of my commute! I ran into a lot of problems with my protoforms which are essentially an xml tree of variables, inputs, and output definitions with state stored with them. I use protoforms as a way of serializing in/out of objects as well as editing the create params for a sprocket before I actually spawn it. All of this is done via a few handy macro's that do some code generation to create some functions that the protoforms query to get reflection data on all of the create params, inputs, and outputs an object can have.

I also started cleaning up another element of my UI Sprockets. Every UI Sprocket took in an FEContext as a create param. The FEContext had pointers to all the necessary systems that the sprocket would need to create itself things like memoryAllocators, renderContext, fontSystem, assetInventory. The thing is though that I added a ConstructionContext that gets automatically stored with every create param and this already has all the necessary systems in it. I added that a while after I started building my first set of UI Sprockets so none of them were really taking advantage of the ConstructionContext.

I spent a lot of time at the end of the week thinking about refactoring how the protoforms currently work. One thing that really bugs me about them is that they kind of encompass both the reflection data and the state data. I'd like to separate them so each class only has one set of reflection data and the actual state for each of those peices of data is stored separately in the protoform as a tree of state data. For example I have a VariableInfo, it stores things like the name, the type, the data offset from the beginning of the create params, the size, etc... however it also store the actual state of the variable inside of an object that manages converting to and from a string representation of the variable. I'd like to make these two concepts very separate. It'd be a big overhaul of the system as it stands now though so I think for now I'll just leave it how it is.

So that brings us up to date. I'm currently working on a one week sprint that cleans up some of the leftover things like addressing the gizmo a bit more in depth, saving/loading screens and properly handling multiple UI objects. I also need to address properly parenting a child UI Sprocket to a parent UI Sprocket, but that's all for another week.


Before Mouse Over


After Mouse Over


First shot of my gizmo for editing, I know it looks awful it's just placeholder


Showing a spawned button

Illustrating a pressed button on the gizmo, when dragging that button the width and height of the UI Element gets changed.


A bunch of spawned buttons of different sizes.

This is a repost from my external blog

I have something totally different for you this week. To give you some background, my other hobby is costuming, and on top of that it's mostly armor based costuming. I build things like, transformers, Iron man, that sort of thing. The piece of software I use to do this is called Pepakura Designer. It allows a user to "unfold" a 3d model into 2 dimensions so that it can be printed out on cardstock and re-assembled. The problem is that it's been designed with building little papercraft model's not costuming. This results in a lot of little things I don't like about the software. Now rather than just accept those things I started planning out a better piece of software more designed for costuming in mind.

The problem with this though is that even if I built out this piece of software noone is going to use it because all of the existing content is built for pepakura. So I decided the number one thing I needed was in importer that could load pdo( the pepakura file format ) files into my software. The problem with doing this though is that pdo files are a closed format and besides one hacked together python script I found that could import parts of the 3d data there wasn't really any information about the format out there in the wild.

So I set about reverse engineering the format and started building up a spec of how it was layed out in memory. I've never done anything like this before and so it was a slippery slope trying to figure out where to begin. I've done lots of work with binary files though so I have a pretty solid grounding in how a lot of different formats are layed out so it gave me a bit of a base to start from. So I started with a simple box model and just started poking and prodding in a hex editor. Change a vertex, re-export see what changed. Change a color, re-export see what changed. Slowly but surely a picture started to emerge. Within a few days I had a clear picture of what the 3d data looked like in memory. One thing that really held me up was that I expected all of the floating point data to be stored as floats, but they decided to store them as doubles, I can't imagine why they would think they would really need that level of precision, were they thinking someone would be trying to unfold an earth sized object? Another thing that held me up a bit was that the strings are encoded. I saw patterns that looked like null terminated strings, a string length, a set of characters ending with a 0. When I looked at the data though the strings were jibberish. With a bit of fiddling around though I figured out that if I subtracted a constant from each element of the string I could decode it into the original string value. Turned out though that this constant changes from file to file. The good thing though was after a quick search of the header I found out one of the blocks of data I was unsure about stored the decoder value.

So that was about as far as I got a few months ago I got distracted by other things and there it lied dormant. A couple weeks ago though I got the itch again. So for the last couple weeks I've been poking and prodding at the data structures and finally have an almost complete picture of how everything is stored. I've also set up a pdo viewer option in my project for viewing pdo files. Now the next big question for me is do I go back to my voxel earth project or do I put some love into my costume designer project I planned out so many months ago.

Anyways, I've compiled how things are layed out in memory, it can be found on my external blog here


Everything that's important for rendering a pdo is there, there's a few odd and end flags that haven't been decoded yet. If anyone has any questions or feedback on what some of those unknown fields do, please leave a comment.

Model almost decoded.

There we go model decoded

Hmm those unfolds don`t quite look right

Hmm the bounding boxes are looking right

Hey there we go, unfolds rendering correctly

Found the normals for them model!

FIgured out which edges were the internal edges.
Sign in to follow this