Yeah, I know, clearly I’ve had threads on the mind a little too much lately. I’ve been working on a major refactor of the engine at work and thread synchronization problems are tricky.

Usually when I have dreams like this I wake up in the morning and have a good laugh wondering what the heck I was thinking. This time, however, I think there may be something to it. Now, I’m not suggesting a design built literally on the model exactly as it is in the dream but I think there are elements that could be useful.

The part that is intriguing about the turret defense thread model is that you can guarantee completion (all units hit) without guaranteeing really very much at all about either the turrets or the units. The units are not synchronized with each other; in fact, in many tower games faster units can overtake slower ones. A unit does not guarantee a minimum speed–it may even be allowed to stop entirely on occasion–although it does guarantee a maximum speed. The turrets are not synchronized with each other, nor do they communicate any information to each. A turret does not guarantee a specific number of units hit, only that it will hit units at a specific rate. A turret also does not guarantee what order it will fire at units in. A unit likewise guarantees nothing about when or by whom it will be hit except that it can be hit when it is within a valid range.

Yet, with a sufficient number of correctly placed turrets all the units will be hit with none escaping. More importantly, most of the time you can have far fewer turrets than units and still complete successfully. The number of turrets required is a simple function of the maximum speed of the turret, the maximum speed of the unit, and the number of times the turret must hit the unit for completion. Placement is trickier, but with a thread model you could surely replicate that with signals.

Fascinating, isn’t it?

I’m not sure yet where to go with all this, but it seems like there’s a useful idea to be gleaned. It’s not that different that a traditional worker pool, but the lack of communication seems important. I’m sure there’s something useful that can be done with this.

1. For anyone who cares, the specific game seems to be Crystal Defenders, but with some elements of Bloons Tower Defense 3.

In a nutshell: the problem is you can’t tape a cupholder to a formula one race car and declare it street legal. It still doesn’t have any bumpers, it’s too low to be safe around other cars, and if you aren’t an expert driver you still shouldn’t be driving it. A cupholder doesn’t change that.

So what? A cupholder is still an improvement… right? Who doesn’t want a cupholder? Imagine for a moment that having the cupholder suddenly disqualified you from a number of races. You couldn’t run that race if you have a cupholder. It also slowed down your car–not a lot, but a tiny fraction of a second. Maybe it doesn’t slow it down enough to matter, but in those few races won by hundredths… well, maybe it does. Suddenly that cupholder doesn’t seem so nice.

To be clear, I’m not suggesting giving up on attempts to improve memory management and prevent buffer overruns. I just question if this exact approach was the best one.

Memcpy_s is basically a race car with a cupholder. While memcpy_s will certainly prevent some bugs, the same people who got one parameter wrong are just as likely to get two parameters wrong… and cause all new bugs in the process. Garbage In = Garbage Out. It doesn’t matter what the calling convention is.

On two occasions I have been asked,—”Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?” … I am not able rightly to apprehend the kind of confusion of ideas that could provoke such a question.”

— Charles Babbage, 1864
discussing the first mechanical computer

The change also comes with a price: it breaks cross-compatibility with other compilers, including older compilers on the same operating system as well as other platforms. This means the same code can’t cross-compile anymore if you use memcpy_s. Someone with Microsoft suggested that GCC should pick up the change as well. Perhaps, but that assumes that GCC is the only other compiler that matters. Certainly, it’s the most popular other compiler that matters, but it’s far from the only one especially if you do embedded systems work or anything running on “exotic” hardware. And let’s be honest–if you’re not writing something that’s fast or exotic, you’re probably not writing it in C. The exception, of course, being legacy code… but surely that’s even less likely to be changed. The whole point of legacy code is that you don’t have the time\budget to update it, otherwise you wouldn’t be running it at all. These are the guys who will wrap memcpy_s in a macro named memcpy, defeating it entirely. Sigh.

As for that speed difference I mentioned? We’re obviously only talking about an extra comparison operator and perhaps a branch or two here. I know an extra comparison operator seems trivial, but if an extra comparison operator didn’t matter ASSERT macros wouldn’t exist. The speed difference is nominal, but it’s very, very real. On a lark I timed it. Copying 32 bytes 100,000 times with memcpy took on average 3952 counts, or about 0.001104 seconds, measured to nanosecond accuracy with QueryPerformanceCounter. Performing the identical operation with memcpy_s took on average 9706 counts, or about 0.002712 seconds. This was in “release mode” using Visual Studio 2008. (For the curious, in debug mode the difference averaged 8028 counts to 11340 counts, but you shouldn’t be shipping your code in debug mode anyway!)

Now hopefully you’ve done everything you can to avoid memcpy in your inner loop in the first place, but we all know there are rare occasions where it’s unavoidable. This all brings me back to my earlier point: if you’re not writing something that’s fast or exotic, you’re probably not writing it in C. Yes, you can write your own memcpy that’s probably faster than the system memcpy if you’re really worried about speed, but now we’re back to the portability issue. In short, I’m certain that to the people where the choice of language matters, those few clock cycles matter too. We’re talking folks writing device drivers here, not business applications.

Nobody is twisting anyone’s arm to use memcpy_s. You can easily disable the compiler warnings and continue to use memcpy all you like. But hopefully you see where I’m going with this: A lot of the reason that people continue to use C for certain projects has to do with performance and portability. This change sacrifices both for dubious return. If the change is not going to have tangible benefits that outweigh the problems, why do it at all?

Sooner or later, you need to trust that the programmer knows what they are doing. If the programmer can’t manage memory responsibly, you’ve got a bigger problem than an extra parameter is going to fix. To be honest, while a lot of people don’t like to admit it programmers sometimes leak or botch memory even in managed languages. There’s certainly a thesis paper or two in “possible alternatives” to the approach taken–perhaps checking the block size by querying the allocator instead of asking the programmer which would be even slower but more reliable, borrowing ideas from double entry accounting, etc, etc.–although the “real” fix surely involves more intelligent ways of thinking about memory, which realistically means a fundamental change in constructs, not a patched function.

As always, XKCD sums it up best (panel #2):

Ah, I wait for the day…

If you’re into reverse engineering biological systems–in my mind, one of the most fun parts about AI programming–this talk by Drew Endy is absolutely a blast. Also be sure to check out the BioBricks project at openwetware.org or download the actual “bricks” at the MIT Registry of Standard Biological Parts.

The BioBricks are sequences of DNA described in a standardized, open-source format where each sequence represents a single, interchangeable part or “device”. A data sheet is provided for each device that describes what it does and what its tolerances and parameters are, etc., similar to the data sheet for an electronics part. Like an electronic component, devices can be combined together to make more complicated structures. When you’re finished designing your device, the sequenced DNA can be inserted as a plasmid into a suitable host cell and used to make all kinds of cool stuff, like this biological film where the bacteria change color in response to light.

Hello World displayed by light-sensitive, color-changing eColi

More tips? Ideas you would recommend? Post a comment!

Gyosan asked Isan, “If a million objects come to you, what should you do?” Isan answered, “A green object is not yellow. A long object is not short. Each object manages its own fate. Why should I interfere with them?” Gyosan bowed in homage.

It’s good advice for programming multi-core, too.

Technically speaking, ambient occlusion is a global illumination technique. However, in common usage of the term it is often referred to as a cheap alternative to global illumination. To clear up any confusion, what most renderers refer to as “global illumination” is actually an amalgamation of several techniques such as radiosity, metropolis light transport, image-based lighting or photon mapping. The actual techniques used differ slightly from renderer to renderer. Some renderers include an ambient occlusion term as part of their global illumination calculation; others do not.

Like most global illumination techniques, ambient occlusion is dependent on the other geometry in the scene. Ambient occlusion on its own generates less realistic lighting than “full” global illumination. However, ambient occlusion is much faster and less complex to calculate than other methods which is why it is still popular among game developers and in production animation.

(Left) Without Ambient Occlusion. (Right) With Ambient Occlusion
Click for larger image.

How Does Ambient Occlusion Work?

To understand how ambient occlusion works, it’s helpful to break down the terms.

“Ambient” refers to the indirect light in the scene. Ambient light is light that doesn’t come from an identifiable light source. It is light that is accumulated from stray photons bouncing around the room. Photographers sometimes also call this kind of light source “available light” or “existing light”.

“Occlusion” is the act of one object blocking another object. For example, if you are taking a picture and at the last moment a truck drives in front of you blocking the shot, the truck is “occluding” your view of your subject. Occlusion is important to computer graphics for many things besides just shadows. For example, many renderers can optimize the scene and render faster by culling objects that are occluded, or hidden, by other objects.

Ambient occlusion is a measurement of how much ambient light is blocked by nearby things. If an object or surface is occluded, less light can reach it, which means the surface will be in shadow. Creases, corners, hollows and the undersides of things tend to have a lot of ambient occlusion.

For Artists: Rendering with Ambient Occlusion

Most modern renderers support either some form of global illumination or ambient occlusion; many support both alone or in combination.

Ambient occlusion improves your render by making small details more visible and improving depth perception. A lot of the way humans perceive depth has to do with the size, darkness, and placement of shadows. Using ambient occlusion to add shading to your scene will help the viewer comprehend the placement of objects better.

Ambient occlusion in Poser 6

While each renderer is different, often the basic concepts are pretty similar between many of them. As an example, here’s how you can add ambient occlusion to your render in Poser:

- Click to the Materials tab
- Use the eye dropper to select the material you want to edit
- In the Material Properties node editor, click the Set Up Ambient Occlusion Button. This will add an ambient occlusion node to you material shader.

Poser 6 gives you four properties you can adjust on the ambient occlusion node:

Samples – The number of ray samples that will be cast. The more rays, the finer the lighting, but the longer the render. Keep this number as low as you can unless the lighting looks splotchy, in which case, turn it up.

MaxDist – The maximum distance the ray will test. Larger values generally result in more shadows.

RayBias – The smallest distance the ray will test for objects. If you get black blotches on your figure, very slightly increase your ray bias. If you increase it too much, you will start missing shadows, so don’t turn it up more than you need to.

Strength – The blend weight of the effect.

For Programmers: Implementing Ambient Occlusion

As far as bang for the buck, ambient occlusion is one of the fastest ways to improve the quality of your game’s lighting without a tremendous amount of pain. There are many, many algorithms out there for calculating ambient occlusion and each has advantages and disadvantages depending on your engine features. That said, there are two methods in particular I’d like to point out.

Monte Carlo Ray Casting Method
I’m not sure if this is the oldest method for calculating ambient occlusion or not, but it was certainly the first method learned. Assuming you already have some sort of ray-triangle collision code, this method is very easy to understand and implement.

For each point you want to calculate lighting for, shoot out a number of random rays. (In truth, you don’t really want completely random rays… small random offsets from your surface normal seem to work best.) If the ray hits something, increase the shadow value proportional to the distance along the ray where the collision occurred.

With enough samples per point, this method can produce very good results. The downside is that this method can be very slow. Many games utilizing this method don’t calculate the ambient occlusion in real-time… the ambient occlusion is calculated when the level is loaded or off-line when the level is built, and the results are stored in a texture map.

[Incidentally... yes... looking at Poser's settings, I'm guessing this or something very similar is the method they are using!]

Screen Space Method
Screen space ambient occlusion has been generating a lot of buzz lately. Screen space rendering methods in general are always desirable to real-time programmers because they run in constant time and constant memory, and aren’t inhibited by scene complexity. A good starting point for learning about screen space ambient occlusion is Martin Mittring of Crytek’s Siggraph 2007 presentation.

Basically, the notion is that by sampling surrounding points in the depth buffer you can estimate shadowed areas. Think of it (sort of) like running an edge-detection routine on the z-buffer. The method can produce some artifacts, but there are number of ways to combat them… and the benefit of course is that this method is fast even on complex scenes.

Again, there are many methods out there and numerous variations, but hopefully this is enough to get you pointed in the right direction!

Questions? Ideas? Links to your favorite method? Post a comment!

[youtube:http://www.youtube.com/watch?v=0awjPUkBXOU 350 292]

Graphic artists occasionally modify images this way by hand when doing page layouts for magazines–think of it like a visual form of copy-fitting–but an automated approach opens a world of possibilities. The number of of potential practical applications are immense, and include everything from dynamic web page re-flowing to widescreen-to-standard aspect texture fitting for games.

[youtube:http://www.youtube.com/watch?v=vIFCV2spKtg 350 292]
A better version of the video as well as the research paper can be found on Dr. Shamir’s home page. What’s really neat is how straight-forward the method seems to be. The paper is well worth the read if you are interested in graphics algorithms.

If you’d like to play around with this technique on your own images, someone’s already implemented the algorithm in Flash.

To use this macro, copy and paste the code below into ThisOutlookSession. (Careful! Don’t overwrite other stuff that might already be in there.) You can access ThisOutlookSession from Tools > Macro > Visual Basic Editor. You must have Visual Basic for Applications installed; this is normally installed as part of Office.

Download the source code.

Function GetEmailsMarkedForFollowUp(myOlFolder As Outlook.Folder)
Dim objTable As Outlook.Table
Dim objRow As Outlook.Row
Dim strFilter As String
Dim strReturn As String
Dim myObjSubFolder As Outlook.Folder
Dim intCurrent As Integer

‘ ignore certain folders in the interest of having outlook return sometime in the foreseeable future
If (myOlFolder.Name = “Trash”) Or (myOlFolder.Name = “Archive”) Or (myOlFolder.Name = “Junk”) Or (myOlFolder.Name = “Junk E-mail”) Then
GetEmailsMarkedForFollowUp = “”
Exit Function
End If

‘ clear string
strReturn = “”

‘ Define a DASL filter that finds items marked for follow-up
strFilter = “@SQL=” & Chr(34) & “http://schemas.microsoft.com/mapi/proptag/0x0E2B0003” & Chr(34) & ” = 1″

‘ construct a table of items using the filter
Set objTable = myOlFolder.GetTable(strFilter)

With objTable

‘ Add task-related columns to the table.
.Columns.Add (“TaskDueDate”) ‘ this always seems to be blank in imap, but might be useful if you use exchange
.Columns.Add (“Subject”)
.Columns.Add (“Categories”)
.Columns.Add (“SenderName”)

‘ add flagged e-mails to the formatted task string
Do Until .EndOfTable
Set objRow = .GetNextRow

strReturn = strReturn & “<div style=”"margin: 0; padding: 0; width: 100%; font-size: .85em; font-family: Verdana; background-color: #EDEDED;”">”
strReturn = strReturn & objRow(“Subject”) & “</div><div style=”"margin: 0; padding: 0;”">”
strReturn = strReturn & “<span style=”"font-size: .75em;”"><b>From:</b> ” & objRow(“SenderName”) & “</span><br/>”
strReturn = strReturn & “<span style=”"font-size: .75em;”"><b>Category:</b> ” & objRow(“Categories”) & “</span><br/>”
strReturn = strReturn & “<br/></div>”
Loop
End With

‘ clean up
Set objRow = Nothing
Set objTable = Nothing

‘ check subfolders
intCurrent = 1
While intCurrent < myOlFolder.Folders.count
strReturn = strReturn & GetEmailsMarkedForFollowUp(myOlFolder.Folders.Item(intCurrent))
intCurrent = intCurrent + 1
Wend

‘ return the result
GetEmailsMarkedForFollowUp = strReturn
End Function

Sub CreateToDoMail(strAccountName As String)
Dim myOlApp As New Outlook.Application
Dim myOlNameSpace As Outlook.NameSpace
Dim objTaskFolder As Outlook.Folder
Dim myObjTask As Outlook.TaskItem
Dim myObjMail As Outlook.MailItem
Dim strEmailBody As String

‘ get the task list
Set myOlNameSpace = myOlApp.GetNamespace(“MAPI”)
Set objTaskFolder = myOlNameSpace.GetDefaultFolder(olFolderTasks)

‘ add each task item to an html-formatted list
strEmailBody = “<h3 style=”"font-family: Verdana; padding: 0: margin: 0″”>Tasks</h3>”
For Each myObjTask In objTaskFolder.Items
If Not myObjTask.Complete Then
strEmailBody = strEmailBody & “<div style=”"margin: 0; padding: 0; width: 100%; font-size: .85em; font-family: Verdana; background-color: #EDEDED;”">”
If myObjTask.Importance = 2 Then
strEmailBody = strEmailBody & “<span style=”"font-weight: bold; color: red;”">!</span> ”
End If
strEmailBody = strEmailBody & myObjTask.Subject & “</div><div style=”"margin: 0; padding: 0;”">”
strEmailBody = strEmailBody & “<span style=”"font-size: .75em;”"><b>Date due:</b> ” & myObjTask.DueDate & “</span><br/>”
strEmailBody = strEmailBody & “<span style=”"font-size: .75em;”"><b>Category:</b> ” & myObjTask.Categories & “</span><br/>”
strEmailBody = strEmailBody & “<br/></div>”
End If
Next

‘ also add mail items that have been marked for follow-up
strEmailBody = strEmailBody & “<h3 style=”"font-family: Verdana; padding: 0: margin: 0″”><br/>Mail Items Marked for Follow-Up</h3>”
strEmailBody = strEmailBody & GetEmailsMarkedForFollowUp(myOlNameSpace.Folders(strAccountName))

‘ create a new html e-mail message
Set myObjMail = myOlApp.CreateItem(olMailItem)
myObjMail.Subject = “My To-Do List: ” & Date
myObjMail.BodyFormat = olFormatHTML
myObjMail.HTMLBody = strEmailBody
myObjMail.Display
End Sub

After you have added the macro, you can assign it to a button by right-clicking within Outlook and selecting “Customize”. This macro is designed to handle multiple e-mail accounts, so you’ll need to add a stub function for each account if you want to add it to a button, like so:

Sub ExportMyToDoList()
CreateToDoMail “yourname@yourdomain.com” ‘ fill this in with your e-mail address
End Sub

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.