Erik McClure

Fuck economics. I studied dutifully for that test and almost everyone in the class was still confused over badly written, misleading questions. In math, either you are right or you are wrong. In philosophy, either you make a convincing argument, or you don't. In economics, either you are wrong, or you are very, very wrong. I swear to god there is no "right" in economics, there are only varying degrees of wrongness and you must strive to be as not wrong as possible in order to pass the stupid class. Either that or you need to be telepathic.

I want my fucking programming classes, damn it.

Fuck breakfast.

Bunnies, bunnies, bunnies, bunnies :3

Whenever I do intensive performance testing on delicate math operations, the results almost always surprise me. Today I have learned that if a program preforms a divide-by-zero on a floating point operation (which does not blow up the program), the resulting performance hit is almost equivalent to taking a square root.

1. Do a depth render with additive blending, counterclockwise polygon culling
2. Do a depth render with additive blending, clockwise polygon culling.
3. Subtract 1 from 2 (or 2 from 1, whichever works), and you get precisely how much that pixel is "inside" the volumetric in question.

The following movie was made, in its entirety, by a single person. It is entirely CGI, and if you don't believe me, check out the compositing breakdown.

The Third & The Seventh from Alex Roman on Vimeo.

Today I woke up after having the most amazing dream ever. What I've tried to do here is extract the essence of the dream's plot ideas and work them into a concrete story. Note that the story would be used in a playable game that functions a lot like Myst, although with real-time interactions and time-based events. I've so far recognized elements that have been subconsciously influenced from: Terminator 4, Myst, Myst 3, Jump Start 3rd Grade (I'm not kidding), Aeon Flux, Watchmen, The Westing Game, and others. I have used several other previous dreams as jumping off points for ideas as well. The song I'm currently listening to also sounds like the theme song.

Extraordinary
by Erik McClure

- Prologue -
ex·traor·di·nar·y (k-strôrdn-r, kstr-ôr-)
adj.
1. very unusual, remarkable, or surprising
2. not in an established manner, course, or order
3. employed for particular events or purposes

The House On Top Of The World. That was it's name. A magnificent mansion perched on the cliff-side of a mountain overlooking the sea. With windows of glass, over 20 levels, and technology more advanced then most people thought possible, it was a king's paradise. Five people currently lived there, the most advanced scientific minds of the 22^nd Century. A sixth was to join them soon.

Brianna Vexhearth - Genome Splicer, Botanist and mechanical engineer.
Jack Nolung - Physicist, Architect, Mathematician and structural engineer.
Zachary Nchateul - Organic technology expert and Computer Programmer.
Vidyal Mistral - Quantum theorist, Mathematician, and Game Theorist.
Natasha Sabisten - Physicist, Quantum Gravity Theorist, Electrical Engineer, and Audio Engineer.

And the sixth; an AI/human Interaction Specialist and Interface Designer. They say they're building something up there. Something big. Perhaps Nick McCrath is the missing link.

Synopsis
The player is carried to a mansion on top of a mountain, inside which the entirety of the game exists. The entry level has a welcoming area and the guest services, the floor below that, along with the basement and sub-basement house the inner workings of the house (like a miniature fusion reactor). The floor above the entry level is reserved for entertainment, the second floor is designed for meetings and collaborative research efforts, then there's a garden and every 2 floors above that are dedicated to each member of The Five, with Brianna Vexhearth on the bottom and Jack Nolung (the designer of the house) on top. The floors above that are unknown.

Sub-basement - Fusion Maintenance and supporting infrastructure.
Basement - Fusion reactor, heating, boiler, electrical management, Supercomputer, etc.
Floor 0 - Self-sufficient cleaning apparatus (air scrubbers, water purifiers, etc.)
Lobby
1^st Floor - Entertainment
2^nd Floor - Collaborative Research
3^rd Floor - Garden
4^th Floor - Brianna Vexhearth Labs
5^th Floor - Brianna Vexhearth Living Quarters
6^th Floor - Zachary Nchateul Labs
7^th Floor - Zachary Nchateul Living Quarters
8^th Floor - Vidyal Mistral Labs
9^th Floor - Vidyal Mistral Living Quarters
10^th Floor - Natasha Sabisten Labs
11^th Floor - Natasha Sabisten Living Quarters
12^th Floor - Jack Nolung Labs
13^th Floor - Jack Nolung Living Quarters
14^th Floor - Classified
15^th Floor - Classified
16^th Floor - Classified
17^th Floor - Classified
18^th Floor - Classified
19^th Floor - Classified
20^th Floor - Classified

The fact that the house is on the side of a giant cliff makes for some interesting visuals. On several levels there are glass enclosures outside the main structure, and multiple catwalks which are, shall we say, interesting to walk across. There are obviously several elevators and various staircases. While the initial appearance of the house seems relatively normal, if quite nice looking, it has subtle instances of incredible technology. Holograms are common place, 3D interfaces, a supercomputer running the house, and automated systems all over the place. The house is capable of repairing itself and cleaning itself without human interference, and with the fusion reactor it is estimated that it could keep itself running perfectly fine for over 5 centuries if need be.

The player is the sixth member that is permitted to enter the house. As per protocol, they are given two weeks to explore the house and get acquainted with everything and everyone before moving in permanently. Of course, that's when things start to go wrong. Experiments start exploding (or rather, start exploding at a higher rate then normal), robots start to misbehave, and things escalate until one of The Five goes missing entirely. Naturally, the player is immediately under suspicion, but the player knows it couldn't be him, because he's trying to find whoever is sabotaging the systems. It becomes obvious that the player isn't the saboteur when they are almost killed and catch a glimpse of a shadowing figure wandering around the outside of the house.

The remaining scientists are convinced that someone must have caught a ride with the player and broke into the house. Sleeping is dangerous. Experiments could go wrong at any time. Tensions are high and fights are common. Then, Jack does the unthinkable - he blames the player. He says that he knows it's the player, even after he has saved numerous scientists from their own experiments gone haywire. Then, he explains what has happened.

The player is an expert in Human/AI interactions. Human interactions. What has in fact occurred is a conspiracy so ingenious that the player isn't even aware of it. He has set out a series of notes to himself such that he engineered almost all of the experiment failures except the ones he saved several scientists from. When he told that one scientist where to go, it was the wrong way that he remembered from his _notes_. Everything he did according to his notes in fact worked against them. He was an unknowing agent of destruction, perpetrated by himself, and then somehow forgotten using some kind of memory modification technique. This is suddenly proven true when the player realizes that the path he was taking was not, in fact, a shortcut like his notes claimed, but a path that would have kept him and only him out of harms way while leaving the rest of them to die.

The problem is that the player doesn't want to kill them, and now he has already set in motion a series of events that will overload the fusion reactor and now they must escape. The front door gets jammed shut and several pathways out are blocked to the point that they can't get far enough away from the blast radius. Then Jack says something about the restricted area. This is a bit confusing because the player had been given access to all the classified levels shortly after arriving and had helped in some of them.

"There's a 23^rd floor."

And then the player gets to see something totally amazing and I haven't entirely decided what it is, but its at least 3 stories tall, since the floor numbers go from 19, to 20, to 23.

Music: Emit [Remix]

It never ends.

Hahahaha I'm so funny.

Also if anyone cares, here's a new song.

We are next-door neighbors to one of the floor advisors, who patrol the hallways to make sure people don't go raping each other and whatnot. Our door is also propped open because it gets too hot in our room; Unfortunately that means we get to hear everything that goes on in the hallways, such as:

9:32 PM - A group of idiots walks past our door talking loudly when one of them trips and screams like an idiot. They all proceed to laugh hysterically right outside our door.
9:34 PM - We hear a very loud conversation through our wall in the RA's room next door, We begin talking about how pointless the quiet hours are.
9:36 PM - An RA tells us to be quiet and shuts our door.

WHAT THE FUCK?! Where were you guys like FOUR FUCKING MINUTES AGO?! But hey, you know what, I don't care. I don't even care if we get cited with a noise violation because I'm getting the _FUCK_ out of this idiotic place.

88 hours to go.

Portals.

In Portal, the graphics programmers came up with a way of using the stencil buffer to rapidly redraw a bunch of portals at once. This allowed the whole infinite portal effect - if you put it up to a max depth of 9, the 9th iteration was so small you couldn't even see it anymore. An extremely common problem in today's graphics engines is reflective glass, especially on giant skyscrapers - there are simply too many reflections going everywhere at once to possibly keep track of them.

The answer? Use the same technology built to allow portal rendering for windows. Simply treat any pixel rendered on a reflective plane as a lightray that went through a "portal" and came back out with its axis reversed. Properly done, this can allow for multiple reflection depths (as many as the graphics card can handle) in fairly complex lighting situations. It won't be able to handle everything and requires complex frustrum culling, but the applications are endless. I'm fairly sure that a version of this is already used in many mirror implementations, but what isn't used is the fact that there now exists a technique for doing multiple depth portal renders. This same technique could be applied to reflections to achieve some seriously awesome results, especially in urban renders.

The following post is going to make very little sense:

Modern CPUs have started to branch out into parallelism and increased cache size due to their inability to decrease latency, since electricity can only travel so fast. A signal from one side of the CPU can no longer get to the other side in a single cycle. This has led to an exponential increase in cache size and other bizarre optimizations, such as the CPU attempting to guess what the code is going to do. In some cases the CPU might even decide to do something completely different then what the assembly told it to do just for the sake of speed, which can introduce serious issues for threading. The cache, however, is what we are concerned with. L1 cache takes 2 cycles, L2 takes about 14 cycles, and I don't know what L3 takes but its probably somewhere around 50. RAM on the other hand takes, on average, nearly 200 cycles. This means that cache misses are ridiculously expensive and made even worse by the fact that you can't really be sure that the CPU is actually doing what you're telling it to do. There's little we can do about the CPU running off with your code, but we can help it along by paying attention to data locality.

Linked lists have long had issues with data locality, and this makes it even more obvious. However, the answer isn't immediately obvious. We could switch over to vectors and arrays, sure, but in practice these incur even worse overheads when you simply iterate through them. One solution here is to combine the two - make a linked list that's a vector. However, while that does achieve what we're doing here, there is an even better, if slightly more complicated solution.

The number one slowdown in any program is memory allocation. If you aren't allocating something on the stack, it will likely cost as much time just to allocate a tiny chunk of memory then your entire function's execution time. This actually gets to the point of total absurdity when dealing with rapidly allocated and de-allocated small chunks of memory. In one example, a 2D graphics engine must assemble a list of pictures that are sorted by an optimization function, every single frame. If you even attempt to do this with the default memory allocation, it slows the application down to an absolute crawl. If, however, we implement our own memory management, the speed increases are somewhere around %15000. No, I'm not kidding, and yes, that is based off real-world testing.

The general attitude of the C++ community is that home-baked memory allocators are overkill, but as CPU technology advances, it turns out that in practice, the opposite is true. The default allocator was built in the 1990s and on modern architecture is pathetically slow. This, however, does not have to be a necessity. I have built several allocators for my graphics engine and every single one of them has increased performance by a factor of at least 2. The sheer amount of speed that can be gained from custom memory allocators is astounding, and there is a reason for it.

Custom memory allocators have a very distinct feature - they often concentrate a single class type into one compressed memory allocation space. When used with in conjunction with linked lists we get the best of both worlds, especially since when we free the memory, we aren't actually freeing the memory. We're just marking it as unused and then using it again next time we need it. Obviously I've only used this in situations where its obvious that the memory will be needed again very soon, but if done properly it can be expanded greatly. The fact that the memory is all in one place means that it results in a massive reduction of cache misses, which on modern hardware translates to a whole lot of cycles. Your program will run a lot faster if it isn't spending half its execution time just waiting for memory.

Those of you who are still following this explanation may have an idea of where I'm going with this. To answer the problem of data locality and memory management in modern applications, we require an entirely new kind of memory management, one based around locality, not memory efficiency (although as we'll see later, the resulting allocator can actually succeed at being efficient at the same time).

We start with a simple concept - an allocator for a given class type. All classes are, by definition, the same size. This means that any allocator designed for a single class will be incredibly fast. Usually in this situation, a bucket based approach is ideal, since we want the data to be close together, but we don't want to be dealing with stupidly large chunks of memory either. However we must also take note of how important data locality is on modern hardware, so we want those buckets to be comparatively large. But then we have another problem - what if a given class is only instantiated once? The answer is to have a bucket size algorithm that looks something like this:



Of course, this is made a lot easier if we know what the intended use of the class is in the first place. As long as the programmer tells the allocator how many classes of a given type to start with, we can skip to that amount on our allocation curve. Notice that at some point, the allocation curve flattens out to a 1:1 ratio, since if we're allocating anything larger the 32kb, its probably going to be something like 50 megs and should be delegated to the default memory allocator anyway.

Now we have an efficient method of building an allocator for a single type of class. But if we think about what we are actually doing here, an interesting optimization comes to mind. We are basing this allocator off 2 concepts: similar classes often end up being accessed often, and they are the same size.

Wait, they're the same size. What if we extended our concept such that if two classes are the same size, they get thrown into the same allocator? But we have a problem: going back to our original example, if we have a program-critical linked list that should obviously have a memory locale of its own in its own allocator or the entire point of reducing cache misses is lost. This is where we stumble on a very interesting concept: We allow the programmer to define their own locality.

What we do is have multiple allocators for each given class size. If we have several classes that are all 12 bytes (the sheer amount of classes that are 12 bytes is actually quite astounding), they'll be grouped into a single 12-byte bucket allocator. What happens is that we can assign an Index ID to this allocator. If a programmer has a class that he wants to have single allocator for, he can input an index ID of, for example, 12. This will cause another allocator to be created and used only for that class. However, we introduce the additional possibility of assigning an allocator for say, 2 or 3 classes. If they all have the same unique index ID, they'll be routed to the same allocator. This allows the programmer to have an unprecedented amount of control over data locality.

To complete our memory management pool, we require a global allocator to take care of our smaller allocators. The global allocator manages a gigantic pool of memory that is segmented into chunks for the various n-byte pools. When a new pool requires an amount of memory that is greater then the largest chunk available, the global allocator grabs another chunk from the default allocator. Furthermore, whenever this occurs, it triggers an optimization run on the memory pools. Empty buckets are freed and memory is moved where it is feasible. The global allocator will also need to pay attention to where the memory is freed so that, even if we have to allocate a giant chunk for some very large byte pool, we then have a bunch of memory that's available for less-used pools, again allowing us to avoid allocating additional memory. The combination of all 3 concepts allows a relatively efficient and super fast cache-aware memory allocator that can be implicitly built into any class by the inclusion of a very simple static template class. Almost everything can be done behind the scenes, and we never even overload the global new operator, since participating classes are marked (there are a buttload of reasons why we wouldn't want to overload the global new operator but I won't go into that here).

No tests of this system are available as I have not built it yet, but I will report on the results once I have them.

Because I got into MATH 125.

of course its now 3 AM so tomorrow is going to suck balls but I DONT CARE.

How do I know? Because iZone stole 6 of my songs, without even bothering to rename them. It all started when a friend of mine pointed out that someone had stolen Retarded Windows Song, which eventually led me to a guy giving out his e-mail so he can use The Dark Temple in his game.

That was the most fun I've ever had writing an e-mail.

I reported him, but not before taking this screenshot.

I don't have anyone on MSN to excitedly spew out this idea to so I'll just do this as a journal entry. Everyone knows about Celshading. Cheap Anime games use it to try and make 3D look 2D and often fail spectacularly, although its still a nifty effect.

After studying The Secret of NIMH, I've noticed several particular aspects of the movie that could feasibly be recreated in a 3D graphics engine in such a way that it would be indistinguishable from the real thing, provided it did not break certain constraints.

Shading: Cel-shading is not used all the time. Modern anime-inspired animation often likes to cel-shade everything, but if you look at many classic films, it's actually only used in instances of high contrast, and more particularly its very unevenly done, even if its a relatively stable light source. In a 3D context this would mean flatshading almost all the dynamic models and implementing a very special lighting system that would only trigger with certain "tagged" lights (there is no possible way to dynamically figure this out in a manner consistent with traditional animation). In contrast to this, the backgrounds are extremely detailed paintings, which often end up being lit with either celshading or an interesting gradient effect.

A separate interpretative shader for the background could be adopted (along with a special case for lighting if necessary) to create the painting effect, but the most striking feature about all backgrounds in all 2D animations is the fact that they are always static. That is to say, if the character is "walking around a table," the background is really just a long, looping single picture. This is an effect that is exceedingly difficult to duplicate in 3D because it is very much not 3D. One way to get around this problem is to take a different approach, and that is to take advantage of the fact that in 99% of circumstances in a 2D animation, a given camera angle will stay on a flat 2D plane, even if the characters are supposedly moving around in 3 dimensions. Because of this, we can orient our camera for the beginning of a scene, and then unwrap the entire background's 3D model into a panoramic representation. If done correctly, it would allow an artist to build a 3D model and then orient the camera and figure out how the panning in a 2D context would be done from that perspective.

Lines: The lineart in a traditional 2D animation turns out to be one of the most important aspects, which is to be expected. However an unexpected detail that most of us miss when watching an animated film is the fact that those black lines are actually very, very thin. Forget the thick black lines you see them attempting to do in those idiotic 3D hackups, all of the lines in traditional animation are thin, and the exact same width. Except for eyebrows, they are all the same width.

Hence, getting the lines right is going to be a make-or-break part of a 3D interpretative shader. This is usually done via an edge shader by doing a per-pixel depth check. In theory, this would also allow us to make lines that are relatively closer to the viewer thicker, and ones farther away, thinner, but it turns out that this isn't actually needed if we're mimicking traditional 2D animation (this is probably because doing so would be a total bitch to animate). I'm going to come back to this later so keep it in mind.

Getting lines right is hard for humans in the first place, and often requires meticulous design of a 3D model, but its even more ridiculous for furry mice. Hair in particular requires a static 3D model or it goes all over the place. The requirements for fur, however, are less strict, and often it looks completely wrong if you attempt to model it. The trick is to get the shader to do what a human does when examining where to put tufts of fur. Steep angles, joints, and 1-3 possible curls on longer stretches, equidistant apart with a slight deviation of approximately 10% of the length of the stretch. This is influenced by how "furry" a given section is; for example, Mrs. Brisby has a particularly furry chin and thus we end up with a large tuft there. what gets more ridiculous, however, is that if your going to get this to line up with the lines is that you have to model all these tufts of fur on the model itself so that the edge shader can properly line it. This can be done either with a displacement map or with a geometry shader.

Realtime: The possibility of a geometry shader opens up the stunning possibility of doing this in realtime. Because this algorithm translates a detailed 3D scene into a traditional 2D animation, it would suddenly become possible to do what was previously impossible - Design a 2D game that is dynamic, able to generate an entire, completely random forest, and then figure out how to render it as a background that looks painted and is unwrapped into a 2D panorama. The character that you control could look hand drawn and yet respond to literally anything using procedural animation. You could explore any angle in any way possible and the game could still figure out how its supposed to look.

Future work: This technique allows an animation to do things that were not previously possible, such as animating lines that take into account their distance from the viewer, as well as characters being able to interact with background elements without the background elements having to be cel-shaded. Even weirder possibilities include seamless integration of realistic CGI characters with cel-shaded ones, and putting cel-shaded characters in a realistic CGI environment, a la Roger Rabbit except there would be no combining footage - it'd all just work in a single environment and the 2D characters would be able to perfectly respond to their surroundings.

So yeah that's my essay for the week.

Also I figured out that you can embed a Hulu video into LiveJournal, so for those of you who are still without the grace of The Secret of NIMH, here it is:

...Is an amazing movie. Mrs. Brisby and her family are also the most adorable animated characters that exist.

I hate this stupid sore throat.

Accessing the internet while I'm riding the bus home has to be one of the most awesome things I've done in a while. A pity the UW security is too ridiculous for me to tunnel through with hamachi on my router. But no worries, I'm getting the hell out of that shithole in less then 3 weeks, and then I won't have to worry about taking my clothes back and forth and back and forth... just my laptop.

Whispers are working except the Router plugin for Raknet is apparently not actually supported... but it turns out that it's rather unnecessary except for insane peer-to-peer connections anyway, so I replaced it with an RPC that's working quite nicely. Now I am programming a PHP serverlist that will double as a facilitator for a NAT punchthrough technique, which should remove the issue of we-have-to-use-hamachi-to-connect. Then its off to the most difficult networking task in the entire project - Physics interpolation. My task will be to both get a physics object to update itself over the network in an efficient manner, and I will require a networking interpolation hack in box2D in order to make it work in the first place, which of course must be optimized to ridiculousness. Luckily i think there's a way to put in a negative step into the interpolation function to get it to interpolate backwards, which would solve my security issue, although not the collision problem. I'd have to basically discard all collisions for the reversal. I'm really not sure how to get that to work, especially since I still need to figure out how and which collisions to disregard for the interpolation forward.

Once that works the only remaining physics problems to solve are 1. how to stagger the update packets based on proximity to an active player and 2. how to interpolate complex animated objects. The latter will be done whenever i get around to having complex animated objects, but the former will have to be the result of ongoing optimization and fine tuning.

In other news, I have invented a method of document reconstruction that would allow art programs to recover all information from a drawing-in-progress even in extreme circumstances, such as power outages. Unfortunately while this isn't that difficult to implement, it requires a subtle feature that is implemented from the ground-up, so i wasn't able to code a proof of concept in paint.net :C

Bunny seems to originate from the Scottish "bun" as a pet word for a rabbit in 1690, although it had previously been used for squirrels in 1587^[source]. "Bun" also meant "Tail of a hare" in scottish, but the word might have its roots in either the french "bon" or possibly Scandinavian origin.

In other news, FUCK RAKNET. Seriously, that stupid library blows up if you so much as create one object before another, even when those objects seem to have nothing to do with each other, except for a hidden low level relationship you're never told about and is helpfully ignored in all the tutorials. Even some of the sample code I copied turned out to be fatally flawed. Thankfully i have now passed and successfully processed my first packet. All that means, however, is that I now get to implement 3 different plugins of varying complexity to do something you think would be simple - chatting. After that I have the joyous task of inventing my own interpolation algorithm for box2D, when I have had no experience with physics engines. Awesome.

Meanwhile, there have been no less then 5 sirens outside my window today, my roommate cannot stop playing his horribly broken electric guitar (that's not plugged into an amp, which means it sounds like someones dragging a guitar pick across sandpaper; BROKEN sandpaper), the food still sucks, and I just so happen to get the absolute lowest priority for class registration, and if I can't pull off the miracle of a schedule I've got laid out I'll never get out of this mess. Even then I am sorely disappointed in myself after my work ethic collapsed and I ended up sleeping for almost 12 hours yesterday (and managed to miss a philosophy homework assignment, but no one cares about that anyway). It's taken me 2 days to make 0.1% progress on my game. Fuck.

Sometimes I really wish I could just stop acting like a rational human being and scream everything I want to scream even if I know its wrong and then bawl my eyes out for no good reason.

Also I fixed the stupid comment box text. Its black now and much easier to read.

...so please comment :C

To-Do-List
----------
- Get cUser Replicas to work
- Get Remote procedure calls to work
- Use RPC to implement chat using the cUser as a base
- Get the Router to work
- User the router for user specific messages
- Get Brick replica to work
- Define 4 levels of physics serialization
- Finish writing box2D networking interpolation hack
- process packets and implement interpolation on a simple level
- Network physics
- throw bricks
- Implement destructables
- Implement destructable serialization
- Implement a physics callback system

The philosophical definitions of people's various stances on the existence of God:

Athiest: There is no god.
Theist: There must be a god.
Agnostic: We cannot know if god exists.

Concurrently, if you are an atheist, you must PROVE that god does not exist. The same thing goes for Theists. This has the interesting implication of poking a giant hole in Pascal's Wager: If there isn't a god and you don't go to church, you cease to exist. On the other hand, if there is a god and you don't go to church, you get sent to hell. Therefore its better to believe in god "just in case." Philosophers don't give a crap about that - philosophers only care about which point of view has a set of logical reasons that can be proved.

Following this logic, I think a huge number of people are actually Agnostics that either choose to believe in Atheism or choose to believe in Theism for their own personal reasons, and yet their logical reasoning is exactly the same. What's the point of this?

We are no longer arguing about the existence of god. We are instead arguing about which point of view is more beneficial to humanity in general?