colinfahey.com
 
Colin Fahey
 
Personal and Professional Projects
 

OpenGL 3.3+ Game Engine

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format

Download video: WEBM format

YouTube: http://www.youtube.com/watch?v=j9QA_wJAhNM

 

This is a game engine prototype I developed. My goal was to create a game engine for "2D" games with support for extreme resources. My engine supports 16384x16384 textures, gigabytes of texture and audio data in RAM, and on the order of 6000 simultaneously playing sounds, and 32000 simultaneously-active game entities.

TECHNOLOGIES: C/C++; 64-bit Windows 7/Vista; OpenGL 3.3+ (not fixed-pipeline); XAudio2 API (part of DirectX); Box2D physics code

[2011 March - 2012 September]

64-bit Windows 7/Vista Demo:
opengl33_cpp_game_engine_demo_2012sept24.zip [198 MB]
(1) Requires "Microsoft Visual C++ 2010 Redistributable Package (x64)";
(2) Requires "Microsoft DirectX End-User Runtimes (June 2010)";
(3) Recommend installing latest GPU driver
(See the final section of this web page for details on downloading and installing these items.)

 

"Creative Fury" - a comic book editor

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [23 MB]

Download video: WEBM format [13 MB]

YouTube: http://www.youtube.com/watch?v=NXidQNEle50

 

In early 2006, I joined a company which had developed and sold software for editing comic books. For their existing product, the company had decided that enabling users to create comic books intended for the printed page was a core requirement of the software. The company had also decided that making the process of editing comic books easy was a greater priority than offering a potentially intimidating or bewildering array of editing features (as in Photoshop). However, the company later decided that expanding the product to include interactive multimedia elements, such as sound effects and video, would expand the market for the product. Although the product was successfully expanded to include these multimedia elements, it was evident that the original code base (Visual Basic, and code which accumulated new features without the benefit of a master plan) was difficult to maintain and expand further. I was given the task of creating a new code base in C#/.NET (and not C/C++) that would duplicate the functionality of the existing product while eliminating many of the limitations of that product. Over the next 19 months, working alone, I created a program that was ultimately named "Creative Fury".

In 2006, very few people had dual-core CPUs, and most people were using 32-bit Windows XP or 32-bit Windows 2000 which impose a limit of ~3 GiB of RAM for each program, and most people had GPUs with access to less than 256 MiB of dedicated RAM. Meanwhile, C# code, even with "unsafe" code blocks, runs at half the speed of C/C++ code, or far slower (e.g., 10X slower in some situations). After creating a prototype of a comic book editor using C# and the GDI+ drawing library, I discovered that program responsiveness was disappointingly sluggish. Therefore, I modified the program to use Direct3D as the drawing method -- and this delivered fantastic speed, and visual effects with pixel shaders, but made it impractical to do many of the 2D drawing operations offered by GDI+ (e.g., very-high DPI vector graphics effects and text). So, I needed to settle on GDI+, and put a lot of effort in to optimizing drawing performance (by avoiding slow GDI+ functions and drawing modes, and by using "unsafe" C# blocks, and by implementing some functions in C code in the form of a DLL that can be used by C#).

Program features: * Drag images, SVG graphics, and videos from File Explorer or a web browser and drop on to a comic book page; * Panels visually clip their contents to the panel area; * Panels can be contained in other panels in a hierarchical fashion; * All elements on a page can be freely rotated, scaled, and sheared; * Vertices of panels, word balloons, and SVG clip art can be freely moved to change the shapes; * A drop-down menu can instantly change the language of the entire user interface (from 12 world languages), and the continuous spell-checking for all text areas will update to the newly selected language; * The playback properties of videos and animated GIFs can be freely changed (e.g., frame index range, frame rate, frame increment, looping behavior). * All images and videos can have basic image processing (e.g., sepia, gray scale, invert color, sharpen, binarize) applied; * Unlimited undo and redo on all editing actions; * 1/2/4/8-page view modes; * Page-order panel allows page order to be freely changed by simple dragging of live thumbnails; * Export comic books to image files, HTML (and image files), or PDF; * Upload comic book to an online forum; * Comic book stored as easily parsed (and easily generated) XML (referencing images, sounds, videos, SVG clip art files, copied to the folder containing the XML file); * Multiple objects can be selected simultaneously for modification; * Objects can be grouped in to composite objects, and composite objects can be ungrouped back to individual objects; * Individual objects can be exported as images or printed; * Every single character in each text area can be individually formatted (e.g., font, size, color, style); * When in multi-page view, objects can be freely dragged between pages; * When editing, the view magnification level can be freely adjusted from 0.075X through 128X; * Sound effects can be triggered in many different ways (key presses, mouse hovers, mouse clicks, time intervals with optional variance); * Text is drawn using vector graphics, so that the outline and fill can be independently altered;

Unfortunately, merging the printed-page paradigm and the interactive/multimedia paradigm in to a single product made the overall product confusing and constrained. Interactive elements would generally not translate well to a printed page. Meanwhile, only being able to format stories using "pages", "panels", and "word balloons", seems rather quaint and constraining for an interactive story editor. Also, the high-DPI requirement for the printed page clashes with the bitmap-oriented nature of video and images. I wish the company had decided to commit to one paradigm or the other, or had decided to offer two separate products. Instead, they asked for a single product, which, because of the mutual constraints imposed by the two paradigms, led to a disappointing mediocrity.

TECHNOLOGIES: C#; .NET; GDI+; multi-threaded; Video decoding; Windows Vista/XP; Direct3D/pixel shaders (for a highly-functional prototype); manual SVG parsing and drawing; XML; DirectSound; Some functions in DLLs compiled from C/C++ code; Custom drawing in Windows Forms controls; HTTP post (via .NET WebClient) for upload to servers; Hit testing for complex polygons with quadratic or cubic curves; Coordinate transformations

[2006 June - 2007 December]

 

2D body photograph animation based on Kinect data

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [3 MB]

Download video: WEBM format [2 MB]

YouTube: http://www.youtube.com/watch?v=OWxtZ8JyKGM

 

This program enables a user to drag a collection of joint vertices on top of an arbitrary image of a humanoid body, and then see the body animate to new poses based on previously recorded pose animations (captured using the Microsoft Kinect device). I implemented the entire GUI with GDI+ drawing functions (for drawing rectangles, lines, and text, and doing clipping); no Windows Forms controls are used. (My plan was to port this to OpenGL.) The video first shows the program executing in 64-bit Windows 7, and then shows the program running in 64-bit Ubuntu 12.10 (Linux) within VirtualBox.

TECHNOLOGIES: C#/.NET; GDI+; Windows 7/Vista; Ubuntu Linux; Microsoft Kinect device

[2011 October - 2012 August]

64-bit Windows/Ubuntu Linux Demo:
kinect_skeletal_animation_in_windows_and_linux_demo_2012sept24.zip [1 MB]
(1) Requires "Microsoft .NET Framework 4 (Standalone Installer)";
(See the final section of this web page for details on downloading and installing this item.)

 

C# interface to OpenGL

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [20 MB]

Download video: WEBM format [8 MB]

YouTube: http://www.youtube.com/watch?v=ZmnLos3CBB0

 

This program demonstrates a C# interface I created for legacy, fixed-pipeline OpenGL (i.e., prior to 3.3), including all of the thousands of published extension functions. My interface was a simple and convenient alternative to the popular Tao library. This code continues to work (e.g., in 64-bit Windows 7), but non-fixed-pipeline OpenGL has made fixed-pipeline OpenGL obsolete. The video shows a demonstration using two instances of my OpenGL Windows Forms "Control" in a split panel, with the left panel showing a pixel shader describing the pixels of the polygons of a cube along with a 512x512 texture updated at full frame rate with the results of GDI+ drawing to a Bitmap (thus demonstrating how the power of the 2D GDI+ drawing API can be used in an OpenGL scene).

TECHNOLOGIES: C#/.NET; Windows 7/Vista/2000/XP; fixed-pipeline OpenGL (i.e., prior to 3.3); Windows Forms custom control; Option to use GDI+ to draw to Bitmap and copy to OpenGL texture for real-time overlay

[2003 - 2012 (ongoing minor fixes and enhancements)]

I wrote an article about this project:
http://colinfahey.com/csharp_wrapper_for_opengl/csharp_wrapper_for_opengl.html
Complete C# source code, and precompiled sample executables, can be downloaded from that web page.
(1) Requires "Microsoft .NET Framework 4 (Standalone Installer)";
(See the final section of this web page for details on downloading and installing this item.)

 

Real-time audio processing in C#

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [1 MB]

Download video: WEBM format [1 MB]

YouTube: http://www.youtube.com/watch?v=2Ue4HZ1cTvw

 

This program demonstrates real-time audio data processing in C#. Audio can be captured from a microphone. Processed audio is streamed as audio output (e.g., speakers or headphones). This program includes several simple audio data processing methods, such as sinusoidal modulation, reverb, and pitch-shifting. The Fast Fourier Transform (FFT) is used for the pitch-shifting example. A slider enables continuous alteration of a parameter that affects the audio processing. (A simple DLL compiled from C code is used to simplify the work that the C# code needs to do to access the streaming audio capture and output abilities of DirectSound.)

TECHNOLOGIES: C#/.NET; Windows 7/Vista/2000/XP; DirectSound API; C-code DLL; Multi-threaded code; Audio data processing (including use of Fast Fourier Transform (FFT))

[2011, 2012 August]

64-bit Windows 7/Vista Demo:
real_time_audio_processing_in_csharp_demo_64bit_2012sept24.zip [1 MB]
(1) Requires "Microsoft Visual C++ 2010 Redistributable Package (x64)";
(2) Requires "Microsoft .NET Framework 4 (Standalone Installer)";
(See the final section of this web page for details on downloading and installing these items.)

 

"Remote desktop" app in C#

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [15 MB]

Download video: WEBM format [2 MB]

YouTube: http://www.youtube.com/watch?v=q1GYI4YsPo8

 

This pair of C# programs for "server" and "client" implements a "remote desktop" application. In the video above, the laptop computer is running the server, and the desktop computer is running the client -- and the Desktop area of the server appears in the window for the client program. Clicking and dragging the mouse, or typing, in the client program window will send those events to the server program, where those events will be resynthesized (thus affecting the state of programs running on the server's Desktop). The server sends images of its Desktop to the client program to be displayed. The computers shown in the video are linked by WiFi on a LAN. The more useful case of connecting over the Internet would likely introduce significant lag, and perhaps a lower frame rate. This program was merely intended as a fun demonstration of mouse and keyboard event synthesis.

TECHNOLOGIES: C#/.NET; Windows 7/Vista; TCP sockets; Multi-threaded code; JPEG encoding/decoding using .NET API; Mouse and keyboard monitoring and synthesis

[2012 April-May]

Windows 7/Vista Demo:
csharp_tcp_remote_desktop_demo_2012sept24.zip [3 MB]
(1) Requires "Microsoft .NET Framework 4 (Standalone Installer)";
(See the final section of this web page for details on downloading and installing this item.)

 

Push-2-Pwn : Plug device in to Windows 7/Vista and push button to start RegEdit

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [6 MB]

Download video: WEBM format [1 MB]

YouTube: http://www.youtube.com/watch?v=aXMfv3SvsVM

 

I wrote C code for a microcontroller device with a USB hardware interface that can be configured for host or slave mode My C code implements parts of the USB protocol, to emulate a "composite device" that includes several HID-class interfaces, defining several types of mice (e.g., relative and absolute (normalized) mice) and a keyboard. Then I simply added code to send a particular sequence of keyboard commands to Windows 7 or Windows Vista to launch RegEdit, and dismissing the "User Account Control" (UAC) dialog box if it appears. I put the microcontroller in to a box and added a button. Thus, I can plug a USB cable in to any Windows 7 or Windows Vista machine, and start RegEdit with a push of a button, "bypassing" the UAC dialog box that would thwart a typical user-mode program attempting to achieve the same result through synthetic keyboard events. A programmable keyboard can achieve the same result as my device, of course! Also, physical access to a computer is an unusual advantage when hacking. This project is merely a fun demonstration of using a microcontroller to generate mouse and keyboard events.

TECHNOLOGIES: Future Technology Devices International (FTDI) V2DIP2-32 module (with Vinculum-II (VNC2) microcontroller chip); USB protocol, including Human Interface Device (HID) class interface description and protocol for both mouse and keyboard; Multi-threaded C code for the microcontroller

[2012 April-May]

 

Tetris playing algorithm with video capture and shape recognition

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [1 MB]

Download video: WEBM format [1 MB]

YouTube: http://www.youtube.com/watch?v=L-L_4-_-5wY

 

This program -- which I ported to both C++ and C# -- implements a strictly-conforming version of the "Tetris" video game, and includes the world's best real-time strategy algorithm for playing Tetris, and uses video capture to recognize Tetris pieces on the screen of another computer to enable this program to play Tetris on a second computer (with a web camera as its "eyes", and a hardware or software mechanism to relay keyboard events to serve as its "hands"). The video above shows examples of the strategy algorithm playing Tetris within the context of the program itself, and then shows examples of the program recognizing Tetris piece shapes from the real-time video captured from a web camera. (This video does not show this program playing a second instance of Tetris (runnning on a second computer). When I created this program in 2003, I relied on a hardware device -- with 8 relay switches controlled by commands sent through a serial port -- to enable one computer to control the keyboard of a second computer, to thus use the same input device that a human player must use to play Tetris. I simply didn't have time to restore that configuration to prepare this video. Simulating this link with TCP sockets would be easy, of course.)

TECHNOLOGIES: C/C++/C#; OpenGL; Tetris-playing algorithm; Video capture (using legacy "Video for Windows" API); Image processing and simple pattern recognition

[2003-2005, and various minor updates in subsequent years]

I wrote an article about this project:
http://colinfahey.com/tetris/tetris.html
(That web page has a link to download complete source code and precompiled binary executables.)

 

OpenGL GUI System

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [13 MB]

Download video: WEBM format [6 MB]

YouTube: http://www.youtube.com/watch?v=USE35e9EYQU

 

After working at a video game company in 1999-2000, I was interested in creating my own video game engine and game. I wanted to enable users to edit game worlds with the game playing engine itself, thus eliminating the difference between game editing and game playing; i.e., a true "What You See Is What You Get" editing experience. Obviously, accessing files, and setting object properties, etc, for game editing would require a lot of GUI elements. I used the Windows "Desktop" and the assortment of Windows controls as my inspiration for my own GUI system, implemented in OpenGL. I created model viewer "apps", and a "File Explorer", and an audio player "app", and an image viewer "app", and various other viewers and control panels. I created GUI elements, like buttons, text boxes, sliders, scroll bars, tree controls, check boxes, and windows. Unfortunately, I couldn't find funding for my independent game ideas.

TECHNOLOGIES: C++; Win32 API; DirectSound; OpenGL 1.2; MD2 and MDL parsers written by other people; My own BMP/WAV/3DS/ASE file parsers (based on published file format specifications)

[2000-2002]

32/64-bit Windows 7/Vista/XP Demo:
opengl_gui_system_year_2000_demo_2012sept24.zip [37 MB]
(1) Requires "Microsoft Visual C++ 2010 Redistributable Package (x86)";
(2) Recommend installing latest GPU driver
(See the final section of this web page for details on downloading and installing these items.)

 

"My Aquarium" iPhone app (with Windows version)

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [19 MB]

Download video: WEBM format [9 MB]

YouTube: http://www.youtube.com/watch?v=nE-QgMhT1Bs

 

In the middle of 2008, I decided to create a C++/OpenGL engine for the iPhone, so I could collaborate with a friend on creating and selling apps for the iPhone. The first app we created, "My Aquarium", was approved by Apple, and was available for sale, very close to Christmas, 2008. Although our app was simple and boring in an absolute sense, our app was relatively nice compared to the then limited offerings in the Apple app store in late 2008. So, our mediocre app ended up selling more than 26,000 copies, with most sales concentrated in the first few weeks. At the time, I did not own an iPhone, and I didn't own a Mac, and I wanted to use Visual C++ for code development. So, after developing my C++/OpenGL engine within the context of a Hackintosh (hacked version of Mac OS X running on a dual-core Dell laptop computer) using XCode and the iOS API functions and a tiny amount of Objective-C, I decided to port the engine code to Windows. Because most of the app was plain vanilla C++, very little modification was required for most of the code. However, setting up the app window and OpenGL obviously works a little bit differently between iOS and Windows. Audio also required custom code for Windows. For my Windows version, I draw an iPhone image, and draw an iPhone screen (by drawing to a texture with the same horizontal and vertical pixel counts as the iPhone 1/2/3G/3GS screens: 320x480), and enable the user to rotate this virtual iPhone (with a corresponding effect on the simulated accelerometer readings). I also convert the real-time linear motions of the virtual iPhone in to accelerometer effects; thus, shaking the virtual iPhone by dragging it with the mouse will produce the same numeric values from the accelerometer as if the physical device were moved at the same rates through the same actual-size distances.

TECHNOLOGIES: Original iPhone code: C++, tiny amount of Objective-C, OpenGL ES 1.1, PVRTC decoder, multi-touch API, accelerometer API, camera/photo-roll API, WAV/MP3 audio playback library;
Windows version: C++; OpenGL 1.5; DirectSound; PNG decoder; MP3 decoder; Win32

[2008 December (first sale date); 2009 August (last app-store update)]

A free "lite" version of this app is offered in the Apple App Store under the name of my collaborator, Sam:
http://itunes.apple.com/us/app/my-aquarium-lite/id327409164?mt=8

32/64-bit Windows 7/Vista/XP Demo:
MyAquarium_Windows_2009aug13.exe [6 MB]
(1) Requires "Microsoft Visual C++ 2008 Redistributable Package (x86)";
(2) Recommend installing latest GPU driver
(See the final section of this web page for details on downloading and installing these items.)

 

C++/OpenGL 3.3+, dynamic library loading in Ubuntu Linux

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [1 MB]

Download video: WEBM format [1 MB]

YouTube: http://www.youtube.com/watch?v=u0EKZXfl9N0

 

I created a clean C++ interface to OpenGL 3.3+ as an alternative to the very popular GLEW (OpenGL Extension Wrangler) library, and ported it from 64-bit Windows to 64-bit Linux (Ubuntu 12.10). A simple fractal shader demonstrates that a significant portion of the interface is working properly.

This same C++ interface to OpenGL is used in my OpenGL 3.3+ game engine prototype for Windows, a demo for which can be downloaded from my past-project page:

http://colinfahey.com/past_projects/

TECHNOLOGIES: C++; 64-bit Windows 7/Vista; 64-bit Linux (Ubuntu 12.10); dynamic loading of libraries, and retrieving function pointers

[2012 April-May]

 

"Space Gems" iPhone app (with Windows version)

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [12 MB]

Download video: WEBM format [4 MB]

YouTube: http://www.youtube.com/watch?v=P8Cxj9vwp0k

 

(See the notes for "My Aquarium".)

TECHNOLOGIES: Original iPhone code: C++, tiny amount of Objective-C, OpenGL ES 1.1, PVRTC decoder, multi-touch API, accelerometer API, camera/photo-roll API, WAV/MP3 audio playback library;
Windows version: C++; OpenGL 1.5; DirectSound; PNG decoder; MP3 decoder; Win32

[2009 app-store sale date]

32/64-bit Windows 7/Vista/XP Demo:
SpaceBlock_Windows_2009sept1.exe [7 MB]
(1) Requires "Microsoft Visual C++ 2008 Redistributable Package (x86)";
(2) Recommend installing latest GPU driver
(See the final section of this web page for details on downloading and installing these items.)

 

Pure C# app to convert x64 assembly language to native CPU byte code and execute

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [26 MB]

Download video: WEBM format [14 MB]

YouTube: http://www.youtube.com/watch?v=bcgtk0fo0SI

 

(NOTE: The video above was created for a tutorial on x64 assembly language which I will publish in the future.)

This pure C# program parses the almost-ML64-compatible x64 assembly-language listing generated by Microsoft Visual C++ 2010 (when configured to produce x64 assembly-language listing files), and forms corresponding x64 CPU byte code, and executes that byte code in a new thread. This dynamic generation and execution of x64 CPU byte code is similar to what the .NET Common Language Runtime (CLR) does during the Just-In-Time (JIT) compiling process and subsequent execution.

TECHNOLOGIES: C#/.NET; 64-bit Windows 7/Vista; Multi-threaded code; x64 CPU byte code;

[2012 April-May]

64-bit Windows 7/Vista Demo:
pure_csharp_x64_assembler_with_native_cpu_execution_tutorial_demo_2012sept24.zip [15 MB]
(1) Requires "Microsoft .NET Framework 4 (Standalone Installer)";
(See the final section of this web page for details on downloading and installing this item.)

 

Electronic Arts "NCAA Football 2001" for the PlayStation

 

VIDEO : Hover mouse over video to see playback controls.

Download video: MP4 format [91 MB]

Download video: WEBM format [21 MB]

YouTube: http://www.youtube.com/watch?v=132KibOxlng

 

About the video:

The game play shown in the first half of the video above does NOT show my "official" contributions to the game, but instead shows some of my zany free-time experiments with the game engine, involving new player moves (e.g., teleportation, jet packs, circular dive tackle, pyramid field goal kick, earthquake), and "Quake 3 Arena" sound effects.

The game play video was recorded using a PlayStation emulator on a relatively slow computer, and so there is some stuttering in the motion and audio.

The second half of the video shows a Windows program I developed to replay and analyze game play recorded from actual PlayStation hardware. My program shows various game engine state information, and the A.I. states of all players. This was invaluable in determining the causes of emergent behavior problems.

 

In 1999, Electronic Arts contracted the company I was working for at the time to develop the 2001 version of their "NCAA Football" game franchise. We started with the 2000-version of their code base, and a negotiated list of art and code features to add, and spent approximately nine months racing through the milestones, delivering on time, and producing a sequel that was well-received and sold approximately 800,000 copies. (You can read much more about my role in this project on the web page whose link appears below.)

TECHNOLOGIES: C code; PlayStation libraries and development hardware; Skeletal animation code; Priority-queue-based A.I. system for players;

[1999 - 2000]

I wrote an article about this project:
http://colinfahey.com/ncaa_football_2001_playstation/ncaa_football_2001_playstation.html
(That article includes sample software, including an OpenGL screen saver based on game models and captured data.)

 

Cartoon Network/BAM! Entertainment "Power Puff Girls" for the Nintendo GameCube

 
 


Figure: My depth-buffer-based character outlining effect.


Figure: A diagram I made while creating code to perform a particular visual effect with Nintendo GameCube hardware.

In early 2002, I returned to work at a previous employer on another video game contract. This time, the game was based on the "Power Puff Girls" cartoon. I worked on a Maya exporter plugin for animated textures (for flip-book animations, and for face animations) and texture matrix animations (linear/cubic interpolated keyframe matrix states for scrolling or rotating textures for flowing fluids or clouds). I also worked on Level-Of-Detail (LOD) blending (i.e., fade in a new LOD level, and then fading out the old LOD level, to prevent abrupt LOD model changes). I worked on audio scheduling, and controller input processing, and sorting semi-transparent objects by distance from the camera to draw in an order for proper blending. I also implemented automatic eye blinking and face emotional state logic. I implemented a depth-buffer-based character outlining effect (to make the characters appear more like hand-drawn characters in a cartoon). Much of my work required detailed understanding of the graphics hardware (controlled by various registers, for texture units, and other data sources). Unfortunately, the publisher ran out of money, and the project was canceled before completion.

TECHNOLOGIES: C/C++ code; Nintendo GameCube SDK and development system;

[2002 April]

I wrote a few brief, general notes about this project:
http://colinfahey.com/sennari_desk_2002/sennari_desk_2002.html

 

Miscellaneous Images

 


Figure: An OpenGL "screen-saver" for the PC which I created in late 2000 after working on the "NCAA Football 2001" video game for the PlayStation 1 on behalf of Electronic Arts. To create my "screen saver" program, I used model data, texture data, audio data, and motion capture data from the PlayStation game. My "screen saver" cycled through several plays which were recorded from a PlayStation development system.


Figure: In 2001, I used the mathematics of plane-triangle intersections to create a "constructive solid geometry" software library. I was interested in duplicating the destructible terrain effect found in the video game "Red Faction" (released in late 2001 for the PC). My friend Greg Moulton used my library to build the nice tower shown in the image above. In 2003, I ported this code to C#. My code was efficient enough to be used in real time, with dynamic boolean additions and subtractions between moving shapes.


Figure: Running multiple instances of my client and server "remote desktop" programs on a single computer, thus creating a recursive effect.


Figure: The V2DIP2-32 microcontroller module, with the Vinculum-II (VNC2) chip, with two USB interfaces (which can be independently configured in host mode or slave mode), manufactured by Future Technology Devices International (FTDI). I used this module, and my own C code, to emulate various USB hardware devices (variations of keyboards and mice).


Figure: The V2DIP2-32 module on a breadboard, with outputs controlled by simple C++ or C# programs running in Windows 7/Vista, without the need to install any new hardware drivers.


Figure: Ways in which my C code running on the V2DIP2-32 module can be used to interact with a computer, emulating keyboards and mice. One interesting application is to use the microcontroller as a relay for events -- essentially converting software-generated mouse and keyboard event requests in to *real* hardware-generated mouse and keyboard events. Such relay behavior can be used to interact with Windows "User Account Control" (UAC) dialog boxes (which user-space software cannot do with synthetic keyboard and mouse events, for obvious security reasons). The relay can also be used to test any code which uses the "Raw Input" API (similar to the *old* implementation of DirectInput, which itself has been changed to operate using Windows messages, which *can* be generated by software, with some limitations related to relative permission levels of running programs).


Figure: My collection of Rubik cubes and V-Cubes


Figure: A C#/OpenGL program I created to study the motion of "cubies" when performing various move sequences

 

Downloading and Installing Drivers and Libraries

 

INTRODUCTION

Some of the projects listed above include links to download demonstration versions of the software. For some software items, various libraries are required to execute the programs on your computer.

You might already have some of the required libraries installed on your computer. Running the library installer will indicate whether or not you already have the library installed.

All of these libraries can coexist with older and newer versions of libraries currently on your computer. So, there is no harm in installing, or reinstalling, any combination of these libraries.


CURRENT GPU DRIVERS

Please take a couple of minutes to visit the web page of the manufacturer of your GPU and download and install the latest driver. You will benefit from the latest improvements to the speed and correctness of the driver implementation of OpenGL 3.3+/4.x.

  * nVidia GPU Driver Downloads (USA/English link) :

     http://www.nvidia.com/Download/index.aspx?lang=en-us

  * ATI (AMD) GPU Driver Downloads (USA/English link)

     http://support.amd.com/us/gpudownload/Pages/index.aspx



MICROSOFT LIBRARIES

This section describes five Microsoft libraries used by some of the demonstration programs mentioned in previous sections. You need only download and install the libraries explicitly mentioned in the descriptions of the demonstration programs above.

  (1) Microsoft Visual C++ 2010 Redistributable Package (x64)
  (2) Microsoft Visual C++ 2010 Redistributable Package (x86)
  (3) Microsoft Visual C++ 2008 Redistributable Package (x86)
  (4) Microsoft .NET Framework 4 (Standalone Installer)
  (5) Microsoft DirectX End-User Runtimes (June 2010)




  (1) Microsoft Visual C++ 2010 Redistributable Package (x64)

     http://www.microsoft.com/en-us/download/details.aspx?id=14632

  (If that link is broken, then search online for "Microsoft Visual C++ 2010 Redistributable Package (x64)", and only download directly from microsoft.com.)

  "The Microsoft Visual C++ 2010 Redistributable Package installs runtime components of Visual C++ Libraries required to run applications developed with Visual C++ on a computer that does not have Visual C++ 2010 installed."

  CAUTION: Please note the "(x64)" part of the package name, indicating that this run-time library is intended for programs compiled to execute in 64-bit mode.



  (2) Microsoft Visual C++ 2010 Redistributable Package (x86)

     http://www.microsoft.com/en-us/download/details.aspx?id=5555

  (If that link is broken, then search online for "Microsoft Visual C++ 2010 Redistributable Package (x86)", and only download directly from microsoft.com.)

  "The Microsoft Visual C++ 2010 Redistributable Package installs runtime components of Visual C++ Libraries required to run applications developed with Visual C++ on a computer that does not have Visual C++ 2010 installed."

  CAUTION: Please note the "(x86)" part of the package name, indicating that this run-time library is intended for programs compiled to execute in 32-bit mode.



  (3) Microsoft Visual C++ 2008 Redistributable Package (x86)

     http://www.microsoft.com/en-us/download/details.aspx?id=29

  (If that link is broken, then search online for "Microsoft Visual C++ 2008 Redistributable Package (x86)", and only download directly from microsoft.com.)

  "The Microsoft Visual C++ 2008 Redistributable Package (x86) installs runtime components of Visual C++ Libraries required to run applications developed with Visual C++ on a computer that does not have Visual C++ 2008 installed."

  CAUTION: Please note the "(x86)" part of the package name, indicating that this run-time library is intended for programs compiled to execute in 32-bit mode.



  (4) Microsoft .NET Framework 4 (Standalone Installer)

     http://www.microsoft.com/en-us/download/details.aspx?id=17718

  (If that link is broken, then search online for "Microsoft .NET Framework 4 (Standalone Installer)", and only download directly from microsoft.com.)

  "The Microsoft .NET Framework 4 redistributable package installs the .NET Framework runtime and associated files that are required to run and develop applications to target the .NET Framework 4."




  (5) Microsoft DirectX End-User Runtimes (June 2010)

     http://www.microsoft.com/en-us/download/details.aspx?id=8109

  (If that link is broken, then search online for "DirectX End-User Runtimes (June 2010)", and only download directly from microsoft.com.)

  "This download provides the DirectX end-user redistributable that developers can include with their product."

Programs compiled to use the DirectSound or XAudio2 libraries of DirectX will require the "DirectX End-User Runtimes" to be installed on a user's computer to execute. My programs are currently compiled in a way which requires the "June 2010" version of the DirectX end-user runtime package.

  CAUTION: Please note the "(June 2010)" part of the package name. (My code requires that "June 2010" version. As of 2012 May, I do not see a more recent version, but there are older versions. Older versions will not enable my code to work.)

  I apologize for the inconvenience of installing this DirectX run-time library package. Ordinarily, a program with its own installer would silently execute this DirectX run-time installer on the user's behalf. But creating an installer for my collection of programs would itself present you with a bit of a hassle (e.g., choosing where to install things, etc). So, please pardon the task of installing the DirectX run-time libraries manually.

Before executing "directx_Jun2010_redist.exe", create a new folder in a convenient place on your computer, such as your "Desktop" folder. For example, after creating a new folder "dummy" on my Desktop, the following path exists:

  C:\Users\colin\Desktop\dummy

Having an empty folder before running directx_Jun2010_redist.exe will spare you from a bit of trouble.

Now execute the "directx_Jun2010_redist.exe" program.

The installer displays the following prompt:

  Please type the location where you want to place the extracted files.

The path text edit box is empty.

Clicking on "Browse..." automatically showed, for me, the following path, selected in a tree of folders:

  C:\Users\colin\AppData\Local\Temp

Use the tree of folders to locate and select your new, empty folder (which, for me, was "C:\Users\colin\Desktop\dummy"). Then press "OK", and text similar to the following will appear in the text edit box for the path:

  C:\Users\colin\Desktop\dummy

Now you can press the "OK" button, which will cause files to be written directly to the folder you specified. You can then close the "directx_Jun2010_redist.exe" program.

Next, use File Explorer to navigate to your folder, and you will see 157 files (all *.cab files, except for an *.exe file and two *.dll files). Among those files is the following file:

  DXSETUP.exe

Double-click the DXSETUP.exe file. This installer is easy to use.

After the DXSETUP.exe installer finishes installing the DirectX runtime libraries, the folder that you created for this process (which, for me, was "C:\Users\colin\Desktop\dummy") can now be deleted.

[ Note: If, when running the "directx_Jun2010_redist.exe" program, you simply pressed the "Browse..." button and accepted the "Temp" path it offered by default (e.g., "C:\Users\colin\AppData\Local\Temp"), and then pressed the "OK" button to write files to that location, then it would just be a bit more work to find "DXSETUP.EXE", and, after "DXSETUP.EXE" finished installing, you could sort the files in "Temp" by date to identify the 157 files that could be deleted. Or you could just leave all of those files in there. I just wanted to put the files in a place that I could conveniently delete, without causing any side-effects. ]


 
 
colinfahey.com