C++, GDI BitBlt, and nothing else! – under current development

Strong graphics knowledge must be built from a strong foundation, and I could think of no better way to learn the entire graphics pipeline than to implement everything from scratch. My real time software renderer uses no graphics library, no math library, and only the lowest level of the win32 API to blit device independent bitmaps to the screen.

The current build of the software renderer supports OBJ model loading with flat, gouraud, and phong shading. N number of directional lights are supported as well as a prerender depth buffer pass.

Currently the rendering pipeline is being restructured to become a true multithreaded lockless deferred software renderer.

the Stanford Dragon

in the wild

the Stanford Bunny

the Current Build

the Glorious Code – snippet

Just a taste

void pixel3d::Display::drawBitmap(
    const HDC& hdc, const HBITMAP& bitmap,
    const unsigned int* const frame_buffer ) const
{
    HDC const new_hdc = CreateCompatibleDC(hdc);
    HBITMAP const old_bitmap = (HBITMAP)SelectObject(new_hdc, bitmap);

    SetDIBits(new_hdc, bitmap, 0, height_, frame_buffer, bitmap_info_, DIB_RGB_COLORS);

    if (show_text_){
        if (show_fps_)
            drawFPS(new_hdc);

        for(unsigned int i = 0; i < display_text_.size(); i++){
            text_info info = display_text_[i];
            drawText(new_hdc, info.x, info.y, info.text);
        }
    }

    BitBlt(hdc, 0, 0, width_, height_, new_hdc, 0, 0, SRCCOPY);

    SelectObject(new_hdc, old_bitmap);
    DeleteDC(new_hdc);
}

const int pixel3d::Display::newDIB(
    HDC hdc, HBITMAP* dib_bitmap, BITMAPINFO** bitmap_info,
    const int width, const int height )
{
    void* pvBits;

    //BITMAPINFO bitmap_info;
    (*bitmap_info) = new BITMAPINFO();
    ZeroMemory(&(*bitmap_info)->bmiHeader, sizeof(BITMAPINFOHEADER));
    (*bitmap_info)->bmiHeader.biWidth = width;
    (*bitmap_info)->bmiHeader.biHeight = -height;
    (*bitmap_info)->bmiHeader.biPlanes = 1;
    (*bitmap_info)->bmiHeader.biBitCount = 32;
    (*bitmap_info)->bmiHeader.biCompression = BI_RGB;
    (*bitmap_info)->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

    (*dib_bitmap) = CreateDIBSection(hdc, (*bitmap_info),
        DIB_RGB_COLORS, &pvBits, NULL, 0);

    return 0;
}

const int pixel3d::Display::freeDIB( HBITMAP* bitmap )
{
    if (!(*bitmap))
        return -1;

    DeleteObject(*bitmap);
    (*bitmap) = NULL;

    return 0;
}

Crowd Flow, Island Paradise, Multithreading, and more

The Paradise tech demo is a massive crowd simulation of a 1000 individual AI’s all walking toward shared goal locations. Each AI utilizing one of many shared flow maps for navigation, and its own individual steering for avoidance. Once an individual AI actually reaches their goal they will randomly swap to another goal location and begin walking toward this new location.

The idea behind Paradise was born from AMD’s Froblins paper and demo. The key difference between AMD’s implementation and Paradise is where multithreading takes place. In Froblins all threading was offloaded to the GPU while in Paradise all threading was run on the CPU, implemented with Intel’s Thread Building Blocks.

Shown at the Spring 2011 USC Demo Day

the Island

in the wild

the Masses

the Tech

the Glorious Code – snippet

Just a taste

std::vector<CrowdCharacter*> CrowdSceneCreator::createAIs(
    const unsigned int number,
    const unsigned int lower,
    const unsigned int upper,
    const std::vector<std::vector<Ogre::Vector2> >& excludes){

    unsigned int remaining = number;
    unsigned int x,y;
    float height;
    std::vector<CrowdCharacter*> crowd;

    int x1, x2, y1, y2, y_max, x_max, y_min, x_min;

    while(remaining){
        x = rand() % x_width;
        y = rand() % y_width;

        bool exclude = false;

        for (unsigned int i = 0; i < excludes.size(); i++){
            if (excludes[i].size() != 2)
                continue;
            x1 = excludes[i][0].x;
            y1 = excludes[i][0].y;

            x2 = excludes[i][1].x;
            y2 = excludes[i][1].y;

            y_max = (y1 > y2) ? y1 : y2;
            x_max = (x1 > x2) ? x1 : x2;
            y_min = (y1 < y2) ? y1 : y2;
            x_min = (x1 < x2) ? x1 : x2;

            if (x < x_max && x > x_min && y < y_max && y > y_min){
                exclude = true;
                break;
            }
        }

        if (!exclude){
            height = getHeight(x,y);

            if (height >= lower && height <= upper){
                crowd.push_back(createAI((float)x,(float)y,CrowdCharacter::TAN_RED));
                remaining--;
            }
        }
    }
    return crowd;
}

Scripting, Physics, Animation, and more

The USC GamePipe Game Engine, GGE, is a generic game engine created from the past work of many dedicated USC graduates. Numerous student groups build games, demos, and prototypes from the GGE. Modules such as UI, to Physics, to Rendering have been integrated into making a robust engine. One component though has always been severely lacking from the GGE, Artificial Intelligence.

In the past, two different teams have attempted to create a robust generalized AI system in the GamePipe Game Engine, which have only lead to multiple failures.

My implementation of the GGE AI was successful not just through long nights of coding, but through working very closely with each and every group responsible for the different systems within the GGE.

Platforms such as Havok, Ogre, OpenSteer, and Lua were all leveraged to allow for a flexible and robust AI system.

the Creation

in the wild

running

crowding

deserting

visual Debugging with Havok

the Documentation

Because documentation comes first!

Online C++ Doxygen

the Tech

evolving the past, one generation at a time

NeuroEvolution, or better yet Real Time NeuroEvolution of Augmenting Topologies(rtNEAT) uses generic algorithms and selective breeding to both train and shape neural networks into their optimal configuration. The original C++ rtNEAT algorithm was developed at the University of Texas, at Austin by Dr. Kenneth Stanley.

My experiment in rtNEAT ported the C++ centered algorithm into a Java implementation and implemented both C++ and Java algorithms into StarCraft for performance and feasibility testing.

AIIDE 2010 Tournament maps

the battlegrounds

The 2010 AI and Interactive Digital Entertainment Conference hosted an AI StarCraft competition which pitted various StarCraft bots against one another in numerous setups. I used the Tier 1 tournament maps against the built in StarCraft computer to both train and test rtNEAT.

the Design

in the beginning

The design was simple, just like the goals, to build ever evolving, ever improving, autonomous agents. The approach I choose was a frugal approach based around the needs of the tier 1 AIIDE maps.

Two state managers were used:

• the MapStateManager – kept the current state of the map geometry and was used for querying distance calculations between units and geometry
• the UnitStateManager – kept knowledge about all current ally and known enemy units. Used for querying both ally and enemy distance, locations, and health.

Each ally was represented by a RtNeatUnit which contained StarCraft specific unit logic as well as a rtJavaNeat organism which determined the unit’s actions.

the Library

after the beginning

The library powering the neuroevolution algorithm was very closely modeled after the original rtNEAT implementation by Dr. Kenneth Stanley.

My implementation of the library though took a handful of shortcuts in order to speed up and short circuit implementation of recursion. The overall architecture of the neural networks, mutation, and evolution remained unchanged.

the Creation

in the wild

the Documentation

Because documentation always comes first!

Online JavaDocs

the Tech

embrace Change

System Information Monitor was born with the idea of breaking free from platforms and installers. 4 weeks and a lot of sleepless nights, we have success.

the Prototype

click to launch the prototype

the Product

the Tech

sharing is Caring

Sourceforge

http://sysinfomonitor.sourceforge.net

Subversion

svn co https://sysinfomonitor.svn.sourceforge.net/svnroot/sysinfomonitor sysinfomonitor

the Glorious Code

Because documentation comes first!

Online JavaDocs

Download

System Information Monitor

Just a taste

// only a snippet to protect the eyes

    @Override
    public void update() {
        final int currentCpu = this.cpu;

        Runnable updateData = new Runnable() {

            public void run() {
                chart.setNotify(false);

                LinkedList<LinkedList<Double>> cpuHistory = cpuProcess.getCpuHistory();
                LinkedList<Double> cpu;

                counter = counter.add(BigInteger.ONE);

                if (dataset.getColumnCount() > 0) {
                    dataset.removeColumn(0);
                }

                if (currentCpu == -1) {
                    // Number of CPUs
                    for (int i = 0; i < cpuHistory.size(); i++) {
                        cpu = cpuHistory.get(i);
                        dataset.addValue((Number) cpu.getFirst(), i, counter);
                    }
                } else {
                    if (currentCpu < cpuHistory.size()) {
                        cpu = cpuHistory.get(currentCpu);
                        dataset.addValue((Number) cpu.getFirst(), currentCpu, counter);
                    }
                }

                chart.setNotify(true);
                chart.fireChartChanged();
            }
        };
        SwingUtilities.invokeLater(updateData);
    }

    /**
     * Moves all the data from the CpuProcess to the dataset.  This operation
     * will do a complete replace on the dataset information.
     */
    private void moveData() {
        final int currentCpu = this.cpu;

        Runnable updateData = new Runnable() {

            public void run() {
                chart.setNotify(false);
                dataset.clear();

                LinkedList<LinkedList<Double>> cpuHistory = cpuProcess.getCpuHistory();
                LinkedList<Double> cpu;

                if (currentCpu == -1) {
                    // Number of CPUs
                    for (int i = 0; i < cpuHistory.size(); i++) {
                        cpu = cpuHistory.get(i);

                        BigInteger beforeCount = counter;

                        // Number of datapoints
                        for (int j = 0; j < cpu.size(); counter = counter.add(BigInteger.ONE), j++) {
                            dataset.addValue((Number) cpu.get(j), i, counter);
                        }

                        counter = beforeCount;
                    }
                } else {
                    cpu = cpuHistory.get(currentCpu);

                    BigInteger beforeCount = counter;

                    // Number of datapoints
                    for (int j = 0; j < cpu.size(); counter = counter.add(BigInteger.ONE), j++) {
                        dataset.addValue((Number) cpu.get(j), currentCpu, counter);
                    }

                    counter = beforeCount;
                }

                counter = counter.add(BigInteger.valueOf(cpuHistory.get(0).size()));

                chart.setNotify(true);
                chart.fireChartChanged();
            }
        };
        SwingUtilities.invokeLater(updateData);
    }
}

Because documentation and testing come first