Turns out it's not as easy as I thought. Getting the files and libs and exes to compile is pretty easy. The problem came with controlling the build process. Within visual studio extensibility you can only start builds. There isn't any way (that I found) to begin the build process but control it from there. The following is the code I used to get all of the files to compile and to build them. Unfortunately each call to compile/build starts and stops a seperate build process, the equivalent of right-clicking and compiling each individual file. It seems going for a solution like Jam would be better.
ArrayList PCHFiles = new ArrayList();
ArrayList NormalFiles = new ArrayList();
ArrayList Libraries = new ArrayList();
ArrayList Executables = new ArrayList();
for (int i = 1; i <= b.BuildDependencies.Count; ++i)
{
    BuildDependency d = (BuildDependency)b.BuildDependencies.Item(i);
    VCProject project = d.Project.Object as VCProject;
    Configuration active = d.Project.ConfigurationManager.ActiveConfiguration;
    IVCCollection configs = project.Configurations as IVCCollection;
    VCConfiguration cfg = configs.Item(active.ConfigurationName) as VCConfiguration;


    if (cfg.ConfigurationType == ConfigurationTypes.typeStaticLibrary)
    {
        Libraries.Add(cfg);
    }
    else
    {
        Executables.Add(cfg);
    }

    foreach (VCFile f in (project.Files as IVCCollection))
    {
        IVCCollection fconfigs = (f.FileConfigurations as IVCCollection);
        VCFileConfiguration fcfg = fconfigs.Item(active.ConfigurationName) as VCFileConfiguration;
        VCCLCompilerTool tool = fcfg.Tool as VCCLCompilerTool;

        if (tool != null)
        {
            if (tool.UsePrecompiledHeader == pchOption.pchCreateUsingSpecific)
                PCHFiles.Add(fcfg);
            else
                NormalFiles.Add(fcfg);
        }
    }
}

// build
foreach (VCFileConfiguration fcfg in PCHFiles)
{
    fcfg.Compile(true, true);
}
foreach (VCFileConfiguration fcfg in NormalFiles)
{
    fcfg.Compile(true, true);
}
foreach (VCConfiguration cfg in Libraries)
{
    cfg.Build();
}
foreach (VCConfiguration cfg in Executables)
{
    cfg.Build();
}
I'm going to take a little break from my current break to look into something that's started bugging me yesterday. While doing some compile time performance testing we found out that Incredibuild, with a multi-core license, is about as fast on a single computer with 4 cores as it is using an entire network of machines but only using one core from each. So I did some googling and found out that there's no simple solutions for Visual Studio.NET 2003 that simply adds multi-core support to the compiling process.

So during my break I'm going to see if I can whip together a simple Add-in for Visual Studio that simply re-orders the build process and forks off multiple threads. Stay tuned!

I'm still around. I've been working really hard on my secret project and it's turning out nicely. I'll give a little info on it. It's an editor of sorts. Using .NET 2.0 and GDI+ is amazing. I've been able to create such a wonderfully interactive program in such a short time and it really gets your blood boiling to see great results so quickly.

Using C# in Visual Studio 2005 is also really great. For a most part I can program while I'm running. If I don't like how something turns out I just set a break point and modify the code and continue running. You can pretty much modify anything within a function. It won't work if you try to add functions to a class though. I'm not sure of the exact restrictions, but it is amazing none-the-less. The refactoring tools in 2005 are also really nice. You write a big algorithm and you want to move it into a function, just create a prototype before your algorithm, pass in the parameters like you normally would, right click and select 'Create Method Stub' and it creates it just below the current function with all the parameters properly typed and named. Then you just move the algorithm and you're done.

Finally DockPanel. This little library started as a CodeProject article and since moved into a source forge project. It's great and you can very quickly and easily create a setup very similar to Visual Studio 2005. It really makes your app feel professional in no time. Add to that the new Menu/Tool/Status Strip classes in .NET 2.0 and development is quick and easy.

After getting the basic noise function working I had a series of epiphanies and I'm now working on a super secret ultra project of DOOM! No screenshots or info until it's ready for world domination (read: doesn't look like poop and actually does something). It's really cool so if there are any lurkers out there start getting excited!

I have an update sooner than expected. I was looking into noise functions today and it was pretty easy to implement. What I'm showing today is a greyscale 3d noise using the point normal plus (1,1,1). For some reason simply using the normal gives a horrible blocky result. What I have right now is extremly slow. At 6 octaves with smoothing and interpolation it takes a couple minutes to generate 4 256x256 textures. The really nice bonus the edges match up perfectly.

I think for the next step I'll apply this to the subdivision scheme and see if I can get a transition from space to ground.

noise1.jpg

My next step is to start generating textures and geometry. I've been taking a little break, playing some games (Civ4, Dawn of war, Fear). I fixed that seam problem, it was just clamping, I just had to set it in the shader (.fx) not the render state. I'm still a bit new to shaders. I also managed to map an image of the earth to my globe which looks kinda neat, though the scale is still a little off, and there's some nasty seams between quadrants. It might be a few more days up to a week before a decent update, still taking my break.



Good news: Have an algorithm that generates a texture based on position info. Once I create a nice function to procedurally generate height, also based on position info, I can use the same function to generate the texture that will be seen from high up and seemlessly blend into the tiled terrain. Atleast that's the plan.

Bad news: That damn seam. Not sure why but for some reason the edges seem to be wrapping by one pixel. I've outputed the generated textures to file and they are fine so the problem isn't there. I'm too tired to figure it out now.

positionbasedtexture.jpg

Quick update. I've made converted the plasma heightmap generation to work with on a sphere. I've set it up so it creates 4 textures, one per quadrant (as seen on the bottom of the screenshot). It's mapped in a wierd way that skews it a bit but it seems to look fine from space.

Bonus: In the edges you can see the patching at work. It's really easy to determing which patch to use, I can just test each edge and shift a bit up and add it to result and the final number is simply the index of the index buffer to use. (e.g. if edge 2 is at a lower level I just use index buffer 2, if 1 and 2 are lower I use buffer 3).

betterheightmapandsubdivs.jpg