Colin Fahey
Personal and Professional Projects
OpenGL 3.3+ Game Engine
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
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
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
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#
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#
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
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
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
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)
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
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)
(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
(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
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. ]