First thing is to order the parts: I bought the following from NewEgg:

* Antec NeoPower NeoHE 550 ATX12V 550W Power Supply – Retail $118.00 (NOT RECOMMENDED)
* eVGA 256-P2-N515-AX Geforce 7800GT 256MB GDDR3 PCI Express x16 – $345.00
* AMD Athlon 64 X2 4200+ Manchester 1GHz FSB Socket 939 Dual Core Processor – $400.00
* Seagate Barracuda 7200.9 ST3160812AS 160GB 7200 RPM SATA 3.0Gb/s Hard Drive – OEM – $92.00
* OCZ 2GB (2 x 1GB) 184-Pin DDR SDRAM DDR 400 (PC 3200) Unbuffered Dual Channel Platinum System Memory Model – $252.55
* ASUS A8N-SLI Premium Socket 939 NVIDIA nForce4 SLI ATX AMD Motherboard – $169.00
* Antec Performance I P180 Silver Steel ATX Mid Tower Computer Case – $118.99

Subtotal: $1,492.55 – compared to ~$2500 from a store/bespoke retailer.

I had to return the Antec Neo HE power supply and would not recommend it. It has extremely low amps on the +5V rail which powers the CPU and motherboard chipsets. As a result the machine once built would power off after a few mins.
I replaced the PSU with a Seasonic 600w S12. NewEgg then sent me the wrong one (a 330W version) so had to RMA that one also. They were nice enough about it although it was extremely aggravating. All told I’ve had far worse experiences with Gateway customer service back in the days when I bought off the shelf. Comes with the territory.

General rule: Don’t over-tighten anything.
General rule: Push firm but not too hard, don’t want to break anything.
General rule: Hold cards by the edges and try not to touch anything electronic.
General rule: Don’t do this on carpet, you’ll probably get a static discharge and zap something.

1) Take your case out of it’s box and remove the packaging. Keep a phillips head screwdriver handy and be sure to DE-STATIC yourself (touch something metal).

2) Unpack the mobo and find the back-plane cover. Replace the one in your case with the one that comes with your mobo.

3) Screw in your mobo. You may need to add brass stand-offs to the case (these just screw in).

4) Push in your memory modules. Consult the motherboard manual for which slots to use depending on how many memory sticks you’re using.

5) Remove a PCI card cover from the case and push in your graphics card. If you have 2 repeat the process and push on your SLI connector. Do the memory first (step 4) as some boards won’t let you fit in memory once the graphics card is installed.

6) Clean your hands and take out your CPU. Whether it’s Intel or in my case AMD there’s only 1 way this goes in, make sure you line it up right. Raise the lever and drop it in. There should be NO pressure required for it to slot in.

7) This is the part when you begin to sweat. Install the CPU heatsink. Don’t touch the bottom of the heatsink, you don’t want grease or anything on here. Remove any pieces of plastic that might be on there. Before you start figure out what you’re doing as once it’s on the thermal grease or pad will stick to the CPU and it’s hard to re-position. Manufacturers recommend a thermal pad on the heatsink as it lasts longer than grease but most enthusiasts use grease (arctic silver) as it lets you change out your heatsink/processor more frequently. Either way you’ll usually need to apply some force to the heatsink to get it clicked in. Don’t be shy but be careful, too much pressure or uneven pressure will snap the CPU and it’s off to the silicon hospital for you.

Next, snap out the metal covering your 5 1/4″ drive bays. Keep the plastic cover. Install some drive rails on your optical drive and push it in from the front of the case. Repeat per drive.

9) Install your hard drive using the screws from the case.

10) Install the PSU and snake your wires all over the place. You’ll have some combination of the following:
a) Either a 20 or 24pin connector on the mobo.
b) A second 4pin connector on the mobo (might be 8pin if you have dual CPUs).
c) A Sata power cable for each drive – looks like a thin wide connector.
d) A molex (4pin) for each IDE drive.
e) Some PSUs can power the fans in your case. Some fans can be powered off the motherboard. Depending on your setup connect the fans either to the motherboard (look on the board for the connectors, usually 3 pins sticking up) or the PSU (through a molex connector).
f) Power for the PCI-E graphics card (looks like a 6pin connector with 3 yellow and 3 black wires) or a 4-pin molex to your AGP graphics card.
g) The case you bought will have a power button, some lights that come on when the hard-drive’s working, a power light and some other stuff. For the power switch and lights, there’s usually a little tiny bank of pins all in a row where you plug in the connectors from the case. Find these and consult the motherboard manual for where to plug in what.
h) If your case has other connections for things like USB or front Firewire ports or Audio connections just take these one at a time and find them on the mobo using the manual and plug them in.

11) Last thing, install your IDE cable to your optical drives (big wide ribbon) or a SATA cable to your hard drives (skinny red cable).

Button her up and you’re done. Check the connections, tighten any screws and you should be ready to fire up the machine.

Install the OS by booting from CD. Once you get the OS installed it’s time to “burn in” the machine. The idea is to stress the machine in it’s first few days. If something’s going to go wrong it’ll go wrong then (usually).

a) If your motherboard has self-diagnostic features, turn them on the first few times you boot. Run any memory tests the board has. This stuff is typically enabled by default, if not you can go into the BIOS and turn it on. You can also test memory with Microsoft’s memory scanning utility.

b) Update your motherboards BIOS and drivers. The BIOS flashing procedure is usually described by your motherboard’s manual. Sometimes you’ll need to update the chipset drivers (done through the WindowsUpdate or nVidia.com) BEFORE flashing the bios, again read the manual and you’ll be all set.

c) Install something like SANDRA lite and use it to check your machine’s temperature and voltages. CPU should be around 30-40C whilst idle but don’t be surprised if it gets up to 60C under load. Any higher and I’d start to get concerned. GPU (graphics processing unit) temps can be checked through the utilities that came with your card, in the case if nVidia just right-click on the desktop and click “Nvidia Properties”. ATI will have something similar. GPU temps will be around 40-50C and can get as high as 80C but this is unusual.

d) Run utilities like 3DMark and SuperPi to generate some load on the machine. Run these for a couple of hours. If the machine doesn’t overheat or blue-screen then you’re golden(probably). If it does overheat or bluescreen it’s time to hit the message boards and diagnose the problem.

Hopefully that helps de-mystify the process of building a PC. Of course you may run into problems, but there are plenty of forums to help you.

The Motherboard Box (you’ll need one of these)	Open Motherboard box	The motherboard itself	Alternative motherboard angle	The Case box (you’ll need one of these)
The Power supply (you’ll need one of these). DON’T buy this one, it’s garbage. I recommend the Seasonic S-12 600Watt. You’ll see later that I returned this Antec unit for a Seasonic.	The Video Card. You’ll need at least one of these but could buy 2 for an SLI machine. This is an eVGA brand 7800GT PCI Express card. Good value for the money and a killer card overall.	The motherboard box again (it’s too pretty). This is an SLI motherboard from Asus. It sports a passive (no fan) cooled chipset and an excellent layout.	The Hard Drive (you’ll need at least one of these). This is an OEM hard drive and literally comes with NOTHING else. You can save money buy buying OEM parts.	The Processor (you’ll need one of these). This is an AMD 64 bit Athlon 4200+ dual core. An EXCELLENT processor. I don’t recommend buying an OEM processor, it’s not worth the savings.
2 sticks of Memory. You’ll need at least 1 memory stick but I recommend buying 2 matched sticks like this. This is 2x1GB of OCZ Platinum DDR400 memory.	The Antec P180 case coming out of it’s box.	The Antec P180. I have a passive recommendation of this case. It’s cheap and quiet but don’t expect Lian Li build quality.	The motherboard box’s contents. Don’t be alarmed, you don’t need all this stuff. It’s nice to have for the future though.	The mobo one more time.
Take off the side panels.	Take out the drive cages and other removable fans.	This is the backplane, it’s gotta go and be replaced by the one that came with the mobo.	The P180 hides it’s screws in a box behind one of the cages.	You can find brass-standoffs in this box but I didn’t need them.
The new backplane in place, it just pushes in.	Slide the motherboard up and lift the tabs on the backplane up over the motherboard ports.	The mobo is in place, screw that baby down.	The Power Supply contents. NOTE: This is an Antec 550W and I ended up returning it. I’m just leaving the pictures in to demonstrate the assembly.	Unscrew the cage from the P180 and wrap the PSU with it.
It’s a good fit but the Seasonic I ended up using won’t fit this thing. It’s not needed anyway.	Depending on your PSU you’ll have different cables. This is what a 4 pin motherboard connection looks like. There are 2 in case you have a dual cpu motherboard. Plug in 1.	Can you guess where this goes?	These are molex connectors, they go to things like fans and IDE drives (not SATA drives).	This big fan is not really needed but blows air on the PSU. I took it out to make wiring easier.
For the optical drives, you’ll need to break off a piece like this for each drive.	Screw two of the drive rails onto each drive. Metal tabs face the front and should be flush with the front of the drive.	I use these itty bitty screws.	Slide the drive in from the front until it clicks.	Hard drive next. Screw each drive into the drive cage.
You have to use these elongated screws to make it through the silicone grommits.	Nice drive in it’s cage.	Contents of the video card box.	This is where the video card is going.	Put the memory in like this, BEFORE the video card. Otherwise the memory won’t fit past the card. Use slots 1 and 3 or whatever your mobo manual says.
Push in the graphics card.	Contents of the CPU’s box.	AMD CPUs come with a easy to follow sheet.	Hold the CPU gingerly, remember not to touch the pins and not to get grease on the chip. Marvel at the amazing pins. Lift the handle and slot that sucker home. No force should be needed.	Here’s the bottom of the heatsink. Keep that baby clean.
It’s the most nerve wracking thing to squash that heatsink on the chip but here’s the finished product.	Slide the drive cages in.	No time to wire up the case to the motherboard. This is a mess but take your time, consult the motherboard manual and you’ll find where everything goes.	Stick a SATA cable in your drive (the red thing).	Some wiring is needed.
	A cable tie can help keep things neat.	I ended up replacing my power supply as the Antec 550W has a low Amp rating on the +5v rail. This meant the machine would turn off unexpectedly. I returned it for a Seasonic S-12 600W. Here you see a Seasonic S-12 330W which New Egg sent me by mistake. Imagine my dismay!	Finished product, ready to be powered up.

My job occasionally involves hosting “Brown Bag” type sessions where I demonstrate a technology to other folks in the office. The topics can range from Web Services to basic .NET stuff to Remoting etc.

Recently I decided to demonstrate Biztalk 2004 including the integration with Visual Studio, the new orchestration designer, the pipeline editor, mapper and schema designer and so on. Traditionally this would mean I create a PowerPoint presentation and some sample code on my laptop, get everyone together over lunch and project the entire thing onto a big screen with an overhead projector.

Couple of issues with this are that
a) It means getting everyone who’s interested together at one time. When some folks are in Bangalore India, New Delhi India, Chicago, Boston or offsite at a client that can be difficult.
b) If I ever needed to give the demo again it would mean setting up the entire thing, including the project from scratch. This sucks when you’re dealing with Biztalk as the system is very complicated, even for the simplest orchestrations and to set it up takes a lot of time and planning.
c) If heaven forbid something went wrong during the demo, I have to scramble and debug it on the spot which rarely happens but when it does it’s a nightmare.

So, the answer I felt was to somehow record the session offline into a movie and make the movie available on our corporate network.

I figured I’ll just download some free software and get started. I come to find out there really is no free software and I’m not about to spend my hard-earned cash just to give a demo for the good of my health. Especially with a compiler and Visual Studio gleaming in my Programs menu.

So last week once my daughter had gone to bed I fired up Studio and whipped up a simple utility to capture screenshots every X milliseconds and convert them into an AVI file. It’s multi-threaded and gets pretty good performance without slowing down what you’re trying to demonstrate.

It also draws a fake mouse “pointer” as it’s not possible to capture the mouse image with a screenshot.

Since AVIs can get pretty large, it automatically chunks the screenshots so for example, every 50 screenshots it’ll start a new AVI file.

Lastly it captures audio in the form of a WAV at about 11Khz which isn’t CD quality but is good enough to get the message across without bloating the resulting movie.

Once you have the AVI and the WAV, these can be combined using Windows Movie Maker into a WMV file or into an MPEG2 encoded movie using TMPGEnc. Both are free.

So now I have a complete presentation with mouse-movements and audio stored in about 5 WMV files, each about 20MB in size that I can distribute to whomever’s interested. The entire thing’s about 1 hour in length. Not bad for a weeks’ work.

You can download the utility from this site [HERE] , instructions on how to use it are included in the README.txt.

In this lesson we’ll create a simple MFC project, workspace and application. The project will create a window complete with menu, toolbar, status bar and rotate a nice torus in the window.

First off, Download the code for this lesson.

This tutorial is intended to describe how to setup MFC with OpenGL or how to setup OpenGL with MFC, depending on your point of view. Many people have asked for this and it’s a topic that comes up frequently on the message boards so here it is. It’s also surprisingly simple to do.
MFC really is easy to use once you get used to it and Visual C++ IDE does a tremendous job of automating the development process. So let’s get started.

In this lesson we’ll create a simple MFC project, workspace and application. The project will create a window complete with menu, toolbar, status bar and rotate a nice torus in the window.

First thing you want to do is create the project. Fire up VC++ and create a new MFC App Wizard project. Move through the wizard, entering the parameters as you see fit. It really doesn’t matter what you pick here so go nuts.
Here’s a shot of the classes you’ll end up with.

VC generates lots of neat code for you. It’s a good idea to have it insert “TODO” comments as this will help you figure out what most of the methods are for.
Now let’s prepare the window. First off you need to modify the window in the PreCreateWindow method of the View class so that the window can work with OpenGL. Do this by adding the following lines to your project:

BOOL CMfc_basicView::PreCreateWindow(CREATESTRUCT& cs)
{
// Add Window styles required for OpenGL before window is created
cs.style |= (WS_CLIPCHILDREN | WS_CLIPSIBLINGS | CS_OWNDC);

return CView::PreCreateWindow(cs);
}

Make your PreCreateWindow look like mine ( with the exception of the CMFC_basicView:: piece, this is the class name and will differ based on what you named your project/class ).

Ok, let’s get the include files inserted into the project. But where do they go I hear you ask: Since we’ll be using openGL calls from potentially anywhere in the application, we’ll add them to a file called stdafx.h. You may need to go find this file under the “headers” section in the File view of the Workspace window.
Here’s a snippet from that file that includes the last line generated by VC++ and the include files I’ve added.

#include <afxcmn.h>
// MFC support for Windows Common Controls

// Inserted these files for openGL
#include <gl.h>
#include <glut.h>
#include <glu.h>
#include <glaux.h>

#endif // _AFX_NO_AFXCMN_SUPPORT

Now we’ll setup the PixelFormat etc. for OpenGL. Before we do, here are a couple of member variables I find it useful to add to the View class at this point. They are the following.
Just paste these into your View class .h file under Attributes, public section.

HGLRC m_hRC; // Permanent Rendering Context
HDC m_myhDC; // Private GDI Device Context
int m_height; // Stores the height of the View
int m_width; // Stores the width of the view

These variables store the rendering and Device context information.
I also like to store the width and height in case I need them. I could use a GetRect call to obtain these when I need them but I like to grab’em and store them when the window is re-sized. We’ll see that later.

While you’re in the View class header add the following method : BOOL SetupPixelFormat();
You can use VC++’s tool to do this by right-clicking on the View class and then selecting Add Member Function. I recommend using this method as it’s going to generate the .h statement and the body of the function for you. Here’s the code I enter into that method. It’s pretty much the same as every other OpenGL function and I’ve commented the code so it should make sense. Let me know if you need any further explanation.

BOOL COglm_demoView::SetupPixelFormat()
{
GLuint PixelFormat;
static PIXELFORMATDESCRIPTOR pfd= {
sizeof(PIXELFORMATDESCRIPTOR),
// Size Of This Pixel Format Descriptor
1,
// Version Number (?)
PFD_DRAW_TO_WINDOW | // Format Must Support Window
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format
24, // Select A 24Bit Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored (?)
0, // No Alpha Buffer
0, // Shift Bit Ignored (?)
0, // No Accumulation Buffer
0, 0, 0, 0, // Accumulation Bits Ignored (?)
16, // 16Bit Z-Buffer (Depth Buffer)
0, // No Stencil Buffer
0, // No Auxiliary Buffer (?)
PFD_MAIN_PLANE, // Main Drawing Layer
0, // Reserved (?)
0, 0, 0 // Layer Masks Ignored (?)
};

m_myhDC = ::GetDC(m_hWnd); // Gets A Device Context For The Window
PixelFormat = ChoosePixelFormat(m_myhDC, &pfd); // Finds The Closest Match To The Pixel Format We Set Above

if (!PixelFormat)
{
::MessageBox(0,”Can’t Find A Suitable PixelFormat.”,”Error”,MB_OK|MB_ICONERROR);
PostQuitMessage(0);
// This Sends A ‘Message’ Telling The Program To Quit
return false ; // Prevents The Rest Of The Code From Running
}

if(!SetPixelFormat(m_myhDC,PixelFormat,&pfd))
{
::MessageBox(0,”Can’t Set The PixelFormat.”,”Error”,MB_OK|MB_ICONERROR);
PostQuitMessage(0);
return false;
}

m_hRC = wglCreateContext(m_myhDC);
if(!m_hRC)
{
::MessageBox(0,”Can’t Create A GL Rendering Context.”,”Error”,MB_OK|MB_ICONERROR);
PostQuitMessage(0);
return false;
}

if(!wglMakeCurrent(m_myhDC, m_hRC))
{
::MessageBox(0,”Can’t activate GLRC.”,”Error”,MB_OK|MB_ICONERROR);
PostQuitMessage(0);
return false;
}

// Now that the screen is setup we can
// initialize OpenGL();
InitGL();
return true;
}

Next you’ll want to disable the WM_ERASEBACKGROUND message. Without disabling this you’ll see a nasty flicker in your applications. Do this by returning FALSE from the OnEraseBkgnd() method. Your view won’t have this by default so you’ll need to right-click on the view class in the workspace window. Next select “Add Windows Message Handler” from the pop-up menu.In the Dialog that opens up look in the list box for the WM_ERASEBKGND message. Finally hit the “Add and Edit” button to add this
message handler and edit it. This will point you at the newly created message handler for that message, aka
OnEraseBkgnd(CDC* pDC).

Getting back to disabling this method: in the message handler just return FALSE. Make itlook like this.

BOOL CMfc_basicView::OnEraseBkgnd(CDC* pDC)
{
return FALSE;
}

Alright, we’re almost half-way there. You’ll have noticed that in SetupPixelFormat I called a function InitGL(). Let’s add that function to your View class. This will initialize OpenGL and you can modify it as you see
fit.

void CMfc_basicView::InitGL()
{
// Enables Depth Testing
glEnable(GL_DEPTH_TEST);

// Enable the point size for selected points
glPointSize(5.0f);

// This Will Clear The Background Color To Black
glClearColor(.4, 0.2, 0.0, 0.0f);

// Reset the current projection matrix
SetProjection();

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

//Enable back face culling, defaults to Clock wise vertices.
glEnable(GL_CULL_FACE);

glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glShadeModel(GL_SMOOTH);
glPolygonMode(GL_FRONT, GL_FILL);

}

Next we’ll want to write some code to handle the window resizing. In order to do this we add some code to another message handler. This time it’s the OnSize Message Handler. Right-click as before and follow the same steps to create the OnSize Message handler. You’ll notice the “UINT nType, int cx, int cy” paramaters that get passed into the method. These are the new width and height, cx and cy, of the window. We can use these to adjust our viewport and
projection matrices like accordingly.

void CMfc_basicView::OnSize(UINT nType, int cx, int cy)
{

CView::OnSize(nType, cx, cy);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

// Make the rendering context current
wglMakeCurrent(m_myhDC,m_hRC);

// Reset The Current Viewport And Perspective Transformation
glViewport(0, 0, cx, cy);

m_height= cy;
m_width = cx;

// Calculate The Aspect Ratio Of The Window
gluPerspective(60.0f,
(GLfloat)cx/(GLfloat)cy,
0.1f,
1000.0f);
}

Ok, we just have one more function to add and that’s this one.

void CMfc_basicView::SetProjection()
{

glViewport(0, 0, m_width, m_height);

// Reset The Projection Matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

// It’s a perspective projection
// Calculate The Aspect Ratio Of The Window
gluPerspective(60.0f,(GLfloat)m_width/(GLfloat)m_height, 0.1f,3000.0f);
}

This is just a simple function I use sometimes to reset the projection matrices. It’s up to you if you want to include this in your project.

So where do we put the Drawing code? Before we do that let’s link in the OpenGL libraries we need. Go the Project Menu and select Settings. Hit the Link tab and add the following statements to the end of the library entries.

opengl32.lib glu32.lib glut.lib glaux.lib

Next we want to add the call to SetupPixelFormat. The best time to do this is on window creation, just like you’d do in a normal win32 application. For this we’ll make use of the OnCreate message handler. Add this as you’ve added the other message handlers. Here’s the code to call the SetupPixelFormat function. Note I’ve added the call to wglMakeCurrent(NULL,NULL). This gives up the context to other processes.

int CMfc_basicView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CView::OnCreate(lpCreateStruct) == -1)
return -1;

SetupPixelFormat();
wglMakeCurrent(NULL,NULL);

return 0;
}

Let’s compile, hit Ctrl-F5 and you should get a working application that just draws a window. It won’t even clear the screen for you. We need to add some drawing code. I’ve added a call to draw a few Toruses.

/////////////////////////////////////////////////////////////////////////////
// CMfc_basicView drawing
// This function draws three toruses on the screen and rotates them
// Replace this with your own drawing code.
//
void CMfc_basicView::OnDraw(CDC* pDC)
{
// Integer declared as static so the value is maintained
static int i=0;

// Increase i, this is the rotation value.
i += 1.11;

// Make the rendering context current as we’re about to
// draw into it
wglMakeCurrent(m_myhDC,m_hRC);

// Clear the screen and the depth buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// Reset the model matrix
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

// Translate to a suitable position
glTranslatef(0,0,-100);

// We’re going to draw using this color. ( an orange )
glColor3f( 0.89f, 0.36f, 0.0f);

// Rotate to some angle (i)
glRotatef(i, 1,0,0);
glRotatef(i ,0,1,0);
glRotatef(i ,0,0,1);

// Draw the first torus.
auxSolidTorus( 8,50);

// Rotate some more and draw the second.
glRotatef(i ,0,1,0);
glRotatef(i ,0,0,1);
auxSolidTorus( 8,30);

// Rotate some more and draw the third
glRotatef(-i ,0,1,0);
glRotatef(i ,0,0,1);
auxSolidTorus( 8,10);

// Swap the virtual screens
SwapBuffers(m_myhDC);

// Invalidate the window as we’re
// ready to draw another frame
Invalidate(FALSE);

}

And that’s it. Ths application is complete. Obviously this can be improved, the app only draws three toruses. It also uses a lot of CPU in idle time. I left these features as they are since I only wanted to illustrate the use of OpenGL with MFC. If you’d like to experiment, take this code and run with it. I’ll be happy to post anything you come up with. I hope found this TUT useful, if you did let me know.