// ChildView.cpp : implementation of the CChildView class
//

#include "stdafx.h"
#include "Snowman.h"
#include "ChildView.h"
#include "Resource.h"
#include <cmath>
#include ".\childview.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CChildView

CChildView::CChildView()
: m_spinangle(0)
, m_spintimer(0)
{
}

CChildView::~CChildView()
{
}


BEGIN_MESSAGE_MAP(CChildView, COpenGLWnd)
	ON_WM_PAINT()
	ON_COMMAND(ID_LABSTUFF_SPIN, OnLabstuffSpin)
	ON_WM_TIMER()
END_MESSAGE_MAP()



// CChildView message handlers

BOOL CChildView::PreCreateWindow(CREATESTRUCT& cs) 
{
	if (!COpenGLWnd::PreCreateWindow(cs))
		return FALSE;

	cs.dwExStyle |= WS_EX_CLIENTEDGE;
	cs.style &= ~WS_BORDER;
	cs.lpszClass = AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS, 
		::LoadCursor(NULL, IDC_ARROW), reinterpret_cast<HBRUSH>(COLOR_WINDOW+1), NULL);

	return TRUE;
}


void CChildView::OnLabstuffSpin(){
	if(m_spintimer){
		KillTimer(m_spintimer);
		m_spintimer = 0;
	}
	else{
		m_spintimer = (UINT)SetTimer(1, 30, NULL);
	}	
}

void CChildView::OnTimer(UINT nIDEvent)
{
	m_spinangle += 2.0;
	Invalidate();
	COpenGLWnd::OnTimer(nIDEvent);
}

void drawAxes(void){
  glBegin(GL_LINES);
  glVertex3d(0.0,0.0,0.0);
  glVertex3d(10.0, 0.0, 0.0);
  glEnd();
  glBegin(GL_LINES);
  glVertex3d(0.0,0.0,0.0);
  glVertex3d(0.0,10.0,0.0);
  glEnd();
  glBegin(GL_LINES);
  glVertex3d(0.0,0.0,0.0);
  glVertex3d(0.0,0.0,10.0);
  glEnd();
}

void DrawSphere( Sphere s )
{
  glMatrixMode( GL_MODELVIEW );
  
  GLUquadricObj *quadric;
  quadric=gluNewQuadric();			
  gluQuadricNormals(quadric, GLU_SMOOTH);
  //gluQuadricDrawStyle( quadric, GLU_SOLID );

  glPushMatrix();
    glTranslated( s.GetX(), s.GetY(), s.GetZ() );
    glColor3d( s.GetRed(), s.GetGreen(), s.GetBlue() );
  	gluSphere(quadric, s.GetRadius(), 16, 16 );
  glPopMatrix();
}

void CChildView::OnGLDraw(CDC* pDC)
{
  int width, height;
  Snowman Frosty;
	
  GetSize(width, height);
  
  // Clear render buffers

  glClearColor(0.0f, 0.0f, 0.0f, 0.0f) ;
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  // Simple rectangle example
	
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(60.0, 1.0, 1.0, 100.0);
		   
  double a2r=3.1415926/180.0;
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  gluLookAt(cos(m_spinangle*a2r)*30, 5.0, sin(m_spinangle*a2r)*30,
			0.0, 0.0, 0.0,
			0.0, 1.0, 0.0);
  glColor3d(0.0, 0.0, 1.0);
  drawAxes();

  // Render our snowman

  Frosty.InitSnowman();
  Frosty.DrawSnowman();

  // Print out the snowman's volume. Format a CString, plugging in the
  // overall volume (from Snowman::GetVolume). Set the background color
  // to black, text color to white, and TextOut() through the device
  // context

  CString sVolume;
  sVolume.Format( "Snowman Volume: %.3lf", Frosty.GetVolume() );

  pDC->SetBkColor( 0 );
  pDC->SetTextColor( RGB( 255, 255, 255 ) );
  pDC->TextOut( 2, 2, sVolume );
	
  // Flush to the screen

  glFlush();
}

// MainFrm.cpp : implementation of the CMainFrame class
//

#include "stdafx.h"
#include "SnowmanApp.h"

#include "MainFrm.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CMainFrame

IMPLEMENT_DYNAMIC(CMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
	ON_WM_CREATE()
	ON_WM_SETFOCUS()
END_MESSAGE_MAP()

static UINT indicators[] =
{
	ID_SEPARATOR,           // status line indicator
	ID_INDICATOR_CAPS,
	ID_INDICATOR_NUM,
	ID_INDICATOR_SCRL,
};


// CMainFrame construction/destruction

CMainFrame::CMainFrame()
{
	// TODO: add member initialization code here
}

CMainFrame::~CMainFrame()
{
}


int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;
	// create a view to occupy the client area of the frame
	if (!m_wndView.Create(NULL, NULL, AFX_WS_DEFAULT_VIEW,
		CRect(0, 0, 0, 0), this, AFX_IDW_PANE_FIRST, NULL))
	{
		TRACE0("Failed to create view window\n");
		return -1;
	}
	
	if (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
		| CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
		!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
	{
		TRACE0("Failed to create toolbar\n");
		return -1;      // fail to create
	}

	if (!m_wndStatusBar.Create(this) ||
		!m_wndStatusBar.SetIndicators(indicators,
		  sizeof(indicators)/sizeof(UINT)))
	{
		TRACE0("Failed to create status bar\n");
		return -1;      // fail to create
	}
	// TODO: Delete these three lines if you don't want the toolbar to be dockable
	m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
	EnableDocking(CBRS_ALIGN_ANY);
	DockControlBar(&m_wndToolBar);

	return 0;
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
	if( !CFrameWnd::PreCreateWindow(cs) )
		return FALSE;
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	cs.dwExStyle &= ~WS_EX_CLIENTEDGE;
	cs.lpszClass = AfxRegisterWndClass(0);
	return TRUE;
}


// CMainFrame diagnostics

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
	CFrameWnd::AssertValid();
}

void CMainFrame::Dump(CDumpContext& dc) const
{
	CFrameWnd::Dump(dc);
}

#endif //_DEBUG


// CMainFrame message handlers

void CMainFrame::OnSetFocus(CWnd* /*pOldWnd*/)
{
	// forward focus to the view window
	m_wndView.SetFocus();
}

BOOL CMainFrame::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo)
{
	// let the view have first crack at the command
	if (m_wndView.OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
		return TRUE;

	// otherwise, do default handling
	return CFrameWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
}
//
// Name :         OpenGLWnd.cpp
// Description :  Implementation for the COpenGLWnd class.  This is a
//                class derived from CWnd that will automatically set up
//                for OpenGL.  You can use this whereever you would use
//                CWnd and you'll automatically have OpenGL in this window.
// Author :       Charles B. Owen
// Version :       1-09-01 1.00 CBO Initial version number.
//                 3-03-03 1.01 CBO Improved error handing.
//                 3-16-03 1.02 CBO Fixed problem with saving image
//


#include "stdafx.h"
#include "OpenGLWnd.h"

#include <cassert>
#include <fstream>
#include <vector>
#include <strstream>

using namespace std;

/////////////////////////////////////////////////////////////////////////////
// COpenGLWnd

COpenGLWnd::COpenGLWnd()
{
	m_pPal = NULL;
  m_created = false;
  
  // Dr. Owen's code had this flag disabled; the flicker almost gave me a
  // stroke so I turned it on. No more flicker! Sweeeet. If there's any
  // run-time problems, this should probably be turned off
  
  m_doublebuffer = false;
}

COpenGLWnd::~COpenGLWnd()
{
}


BEGIN_MESSAGE_MAP(COpenGLWnd, CWnd)
	//{{AFX_MSG_MAP(COpenGLWnd)
	ON_WM_CREATE()
	ON_WM_PAINT()
	ON_WM_ERASEBKGND()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// COpenGLWnd message handlers

BOOL COpenGLWnd::PreCreateWindow(CREATESTRUCT& cs) 
{
	if (!CWnd::PreCreateWindow(cs))
		return FALSE;

	// Added for OpenGL
   cs.style |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN ;

	return true;
}

int COpenGLWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CWnd::OnCreate(lpCreateStruct) == -1)
		return -1;
	
    CClientDC dc(this) ;
    //
    // Fill in the pixel format descriptor.
    //
    PIXELFORMATDESCRIPTOR pfd ;
    memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR)) ;
    pfd.nSize      = sizeof(PIXELFORMATDESCRIPTOR); 
    pfd.nVersion   = 1 ; 
    pfd.dwFlags    = PFD_SUPPORT_OPENGL |
                        PFD_DRAW_TO_WINDOW ;

    if(m_doublebuffer)
        pfd.dwFlags |= PFD_DOUBLEBUFFER;

    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24 ;
    pfd.cAlphaBits = 8;
    pfd.cDepthBits = 32 ;
    pfd.iLayerType = PFD_MAIN_PLANE ;
    	
    int nPixelFormat = ChoosePixelFormat(dc.m_hDC, &pfd);
    if (nPixelFormat == 0)
        return FormattedErrorAfxMsgBox("ChoosePixelFormat Failed");

    BOOL bResult = SetPixelFormat (dc.m_hDC, nPixelFormat, &pfd);
    if(!bResult)
        return FormattedErrorAfxMsgBox("SetPixelFormat  Failed");

    //
    // Create a rendering context.
    //
    m_hrc = wglCreateContext(dc.m_hDC);
    if (!m_hrc)
        return FormattedErrorAfxMsgBox("Unable to create an OpenGL rendering context");

    // Create the palette
	CreateRGBPalette(dc.m_hDC) ;

    m_created = true;
	
	return 0;
}


//
// CreateRGBPalette
//
BOOL COpenGLWnd::CreateRGBPalette(HDC hDC)
{
	//
	// Check to see if we need a palette
	//
    PIXELFORMATDESCRIPTOR pfd;
    int n = GetPixelFormat(hDC);
    DescribePixelFormat(hDC, n, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
	if (!(pfd.dwFlags & PFD_NEED_PALETTE)) return FALSE ;

    // allocate a log pal and fill it with the color table info
    LOGPALETTE* pPal = (LOGPALETTE*) malloc(sizeof(LOGPALETTE) 
                     + 256 * sizeof(PALETTEENTRY));
    if (!pPal) 
    {
        AfxMessageBox("Out of memory for pallet", MB_OK | MB_ICONSTOP);
        return FALSE;
    }
    pPal->palVersion = 0x300; // Windows 3.0
    pPal->palNumEntries = 256; // table size

	//
	// Create RGB Palette
	//
	ASSERT( pfd.cColorBits == 8) ;
     n = 1 << pfd.cColorBits;
    for (int i=0; i<n; i++)
    {
        pPal->palPalEntry[i].peRed =
                ComponentFromIndex(i, pfd.cRedBits, pfd.cRedShift);
        pPal->palPalEntry[i].peGreen =
                ComponentFromIndex(i, pfd.cGreenBits, pfd.cGreenShift);
        pPal->palPalEntry[i].peBlue =
                ComponentFromIndex(i, pfd.cBlueBits, pfd.cBlueShift);
        pPal->palPalEntry[i].peFlags = 0;
    }

	//
	// Fix up color table with system colors.
	//
    if ((pfd.cColorBits == 8)                           &&
        (pfd.cRedBits   == 3) && (pfd.cRedShift   == 0) &&
        (pfd.cGreenBits == 3) && (pfd.cGreenShift == 3) &&
        (pfd.cBlueBits  == 2) && (pfd.cBlueShift  == 6)
       )
    {
	    for (int j = 1 ; j <= 12 ; j++)
	          pPal->palPalEntry[m_defaultOverride[j]] = m_defaultPalEntry[j];
	}

    // Delete any existing GDI palette
	if (m_pPal) 
      delete m_pPal ;
	m_pPal = new CPalette ;

    BOOL bResult = m_pPal->CreatePalette(pPal);
    free (pPal);

    return bResult;
}


//////////////////////////////////////////////////////////////////////////////////////
//
// OpenGLpalette
//
unsigned char COpenGLWnd::m_threeto8[8] = {
    0, 0111>>1, 0222>>1, 0333>>1, 0444>>1, 0555>>1, 0666>>1, 0377
};
unsigned char COpenGLWnd::m_twoto8[4] = {
   0, 0x55, 0xaa, 0xff
};
unsigned char COpenGLWnd::m_oneto8[2] = {
    0, 255
};

int COpenGLWnd::m_defaultOverride[13] = {
    0, 3, 24, 27, 64, 67, 88, 173, 181, 236, 247, 164, 91
};

PALETTEENTRY COpenGLWnd::m_defaultPalEntry[20] = {
    { 0,   0,   0,    0 }, //0
    { 0x80,0,   0,    0 }, 
    { 0,   0x80,0,    0 }, 
    { 0x80,0x80,0,    0 }, 
    { 0,   0,   0x80, 0 },
    { 0x80,0,   0x80, 0 },
    { 0,   0x80,0x80, 0 },
    { 0xC0,0xC0,0xC0, 0 }, //7

    { 192, 220, 192,  0 }, //8
    { 166, 202, 240,  0 },
    { 255, 251, 240,  0 },
    { 160, 160, 164,  0 }, //11

    { 0x80,0x80,0x80, 0 }, //12
    { 0xFF,0,   0,    0 },
    { 0,   0xFF,0,    0 },
    { 0xFF,0xFF,0,    0 },
    { 0,   0,   0xFF, 0 },
    { 0xFF,0,   0xFF, 0 },
    { 0,   0xFF,0xFF, 0 },
    { 0xFF,0xFF,0xFF, 0 }  //19
  };



//
// ComponentFromIndex
//
unsigned char COpenGLWnd::ComponentFromIndex(int i, UINT nbits, UINT shift)
{
    unsigned char val;

    val = (unsigned char) (i >> shift);
    switch (nbits) {

    case 1:
        val &= 0x1;
        return m_oneto8[val];

    case 2:
        val &= 0x3;
        return m_twoto8[val];

    case 3:
        val &= 0x7;
        return m_threeto8[val];

    default:
        return 0;
    }
}


void COpenGLWnd::OnPaint() 
{
	CPaintDC dc(this); // device context for painting
	
   // Select the palette.
   CPalette* ppalOld = NULL;
	if (m_pPal)
	{
    	ppalOld = dc.SelectPalette(m_pPal, 0);
    	dc.RealizePalette();
	}
	
	// Make the HGLRC current
   BOOL bResult = wglMakeCurrent(dc.m_hDC, m_hrc);
   if (!bResult)
   {
      FormattedErrorAfxMsgBox("wglMakeCurrent Failed");
   }

   // Set the window:
   int width, height;
   GetSize(width, height);

   // Set the viewport
   glViewport(0, 0, width, height);

   glEnable( GL_DEPTH_TEST );

   //
   // Set up the mapping of 3-space to screen space
   //
   GLdouble gldAspect = GLdouble(width)/ GLdouble(height);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();

   
   gluPerspective(30.0, gldAspect, 1.0, 10.0);

	// Draw	
	OnGLDraw(&dc);

	//Swap Buffers
	if(m_doublebuffer)
      SwapBuffers(dc.m_hDC) ;

   // select old palette if we altered it
   if (ppalOld) 
      dc.SelectPalette(ppalOld, 0); 

	wglMakeCurrent(NULL, NULL) ;
}


void COpenGLWnd::SetDoubleBuffer(bool p_doublebuffer)
{
   // Double buffering must be set before the window is created.
   assert(!m_created);

   m_doublebuffer = p_doublebuffer;
}


//
// Name :         COpenGLWnd::OnGLDraw(CDC *pDC)
// Description :  Default OnGLDraw function.  This function clears the screen to a
//                strange color.
//

void COpenGLWnd::OnGLDraw(CDC *pDC)
{
   glClearColor(0.0f, 1.0f, 1.0f, 0.0f) ;
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   glFlush();
}

//
// Name :         COpenGLWnd::GetSize()
// Description :  Convenience function to obtain the window size.
//

void COpenGLWnd::GetSize(int &p_width, int &p_height)
{
   RECT rect;
   GetClientRect(&rect);

   p_width = rect.right;
   p_height = rect.bottom;
}


BOOL COpenGLWnd::OnEraseBkgnd(CDC* pDC) 
{
	return true;
}

#define DIB_HEADER_MARKER   ((WORD) ('M' << 8) | 'B')
const int DIB_PADSIZE = 4;

//
// Name :         COpenGLWnd::OnSaveImage()
// Description :  This is called by a menu option.  It saves the current window image
//                as a DIB file.  It pops up a dialog box asking for the file name.
//

void COpenGLWnd::OnSaveImage()
{
   CWaitCursor wait;

   //
   // Obtain the image pixels
   //

   GLbyte **buffer;
   if(!ObtainPixels(buffer))
      return;

   //
   // Determine the output file
   //

	static char BASED_CODE szFilter[] = "Image Files (*.bmp)|*.bmp|All Files (*.*)|*.*||";

	CFileDialog dlg(FALSE, ".bmp", NULL, 0, szFilter, NULL);
	if(dlg.DoModal() != IDOK)
   {
      delete buffer[0];
      delete buffer;
      return;
   }

   UpdateWindow();

   // Open the file
   std::ofstream file(dlg.GetPathName(), std::ios::binary);

   //
   // Write the image file header
   //

   int width, height;
   GetSize(width, height);

   int usewidth3 = (width * 3 + (DIB_PADSIZE - 1)) / DIB_PADSIZE;     
   usewidth3 *= DIB_PADSIZE;

   BITMAPFILEHEADER bmfHdr;   // Header for Bitmap file

   // Fill in the bitmap file header
	bmfHdr.bfType = DIB_HEADER_MARKER;  // "BM"
   bmfHdr.bfSize = sizeof(BITMAPFILEHEADER) + 
         sizeof(BITMAPINFOHEADER) + height * usewidth3;
   bmfHdr.bfReserved1 = 0;
   bmfHdr.bfReserved2 = 0;
   bmfHdr.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);

   // Fill in a BITMAPINFOHEADER
   BITMAPINFOHEADER bmi;

   bmi.biSize = sizeof(bmi);
   bmi.biWidth = width;
   bmi.biHeight = height;
   bmi.biPlanes = 1;
   bmi.biBitCount = 24;
   bmi.biCompression = BI_RGB;
   bmi.biSizeImage = 0;
   bmi.biXPelsPerMeter = 1;
   bmi.biYPelsPerMeter = 1;
   bmi.biClrUsed = 0;
   bmi.biClrImportant = 0;

   file.write((const char *)&bmfHdr, sizeof(BITMAPFILEHEADER));
   file.write((const char *)&bmi, sizeof(bmi));

   if(!file)
   {
      AfxMessageBox("Unable to write output file file", IDOK);
      delete buffer[0];
      delete buffer;

      return;
   }

   for(int i=0;  i<height;  i++)
   {
      file.write((const char *)&buffer[i][0], usewidth3);
   }

   delete buffer[0];
   delete buffer;

   if(!file)
   {
      AfxMessageBox("Unable to write output file file", IDOK);
      return;
   }

   file.close();

   wait.Restore();
}


//
// Name :         COpenGLWnd::ObtainPixels()
// Description :  Allocates the 2D array for p_pixels and obtains all of the 
//                image pixels into it from OpenGL.
// Returns :      true if successful.
//

bool COpenGLWnd::ObtainPixels(GLbyte **&p_pixels)
{
    // Force window to be up-to-date
    UpdateWindow();

    //
    // Make the OpenGL rendering context current
    //

    CClientDC dc(this) ;
    BOOL bResult = wglMakeCurrent(dc.m_hDC, m_hrc);
	if (!bResult)
	{
      AfxMessageBox("Unable to select OpenGL rendering context, could not obtain pixel data.");
      p_pixels = NULL;
      return false;
	}

   //
   // Allocate space for the image
   //

   int width, height;
   GetSize(width, height);

   int usewidth3 = (width * 3 + (DIB_PADSIZE - 1)) / DIB_PADSIZE;     
   usewidth3 *= DIB_PADSIZE;

   p_pixels = new GLbyte *[height];
   p_pixels[0] = new GLbyte[height * usewidth3];
   for(int j=1;  j<height;  j++)
      p_pixels[j] = p_pixels[0] + j * usewidth3; 

   //
   // Configure OpenGL for obtaining the rows.
   //

   GLint swapbytes, lsbfirst, rowlength;
   GLint skiprows, skippixels, alignment;

   /* Save current modes. */
   glGetIntegerv(GL_PACK_SWAP_BYTES, &swapbytes);
   glGetIntegerv(GL_PACK_LSB_FIRST, &lsbfirst);
   glGetIntegerv(GL_PACK_ROW_LENGTH, &rowlength);
   glGetIntegerv(GL_PACK_SKIP_ROWS, &skiprows);
   glGetIntegerv(GL_PACK_SKIP_PIXELS, &skippixels);
   glGetIntegerv(GL_PACK_ALIGNMENT, &alignment);

   glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
   glPixelStorei(GL_PACK_LSB_FIRST, GL_FALSE);
   glPixelStorei(GL_PACK_ROW_LENGTH, 0);
   glPixelStorei(GL_PACK_SKIP_ROWS, 0);
   glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
   glPixelStorei(GL_PACK_ALIGNMENT, DIB_PADSIZE);

   //
   // Actually read the pixels.
   //

   glReadBuffer(GL_FRONT);
   glReadPixels(0, 0, width, height, GL_BGR_EXT,
                GL_UNSIGNED_BYTE, (GLvoid *)&p_pixels[0][0]);

   /* Restore saved modes. */
   glPixelStorei(GL_PACK_SWAP_BYTES, swapbytes);
   glPixelStorei(GL_PACK_LSB_FIRST, lsbfirst);
   glPixelStorei(GL_PACK_ROW_LENGTH, rowlength);
   glPixelStorei(GL_PACK_SKIP_ROWS, skiprows);
   glPixelStorei(GL_PACK_SKIP_PIXELS, skippixels);
   glPixelStorei(GL_PACK_ALIGNMENT, alignment);

   wglMakeCurrent(NULL, NULL) ;

   return true;
}


//
// Name :        COpenGLWnd::FormattedErrorAfxMsgBox()
// Description : Output an error message to a message box based on
//               the GetLastError value.
//

int COpenGLWnd::FormattedErrorAfxMsgBox(const char *p_msg)
{
    LPVOID lpMsgBuf;
    FormatMessage( 
        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
        FORMAT_MESSAGE_FROM_SYSTEM | 
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        GetLastError(),
        0, // Default language
        (LPTSTR) &lpMsgBuf,
        0,
        NULL 
        );

    ostrstream str;
    str << p_msg << " " << (char *)lpMsgBuf << ends;
    
    // Free the buffer.
    LocalFree( lpMsgBuf );

    AfxMessageBox(str.str(), MB_OK | MB_ICONSTOP);
    delete str.str();

    return -1;
}



// ChildView.h : interface of the CChildView class
//


#pragma once

#include "OpenGLWnd.h"
#include "Sphere.h"

// CChildView window

void DrawSphere( Sphere );
void drawAxes(void);

class CChildView : public COpenGLWnd
{
// Construction
public:
	CChildView();

// Attributes
public:

// Operations
public:

// Overrides
	protected:
	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);

// Implementation
public:
	virtual ~CChildView();

	// Generated message map functions
protected:
	DECLARE_MESSAGE_MAP()
public:
	afx_msg void OnLabstuffSpin();
	double m_spinangle;
	UINT m_spintimer;
	afx_msg void OnTimer(UINT nIDEvent);
	void OnGLDraw(CDC* pdc);
	afx_msg void OnLabstuffNewthing();
};

// MainFrm.h : interface of the CMainFrame class
//


#pragma once

#include "ChildView.h"
class CMainFrame : public CFrameWnd
{
	
public:
	CMainFrame();
protected: 
	DECLARE_DYNAMIC(CMainFrame)

// Attributes
public:

// Operations
public:

// Overrides
public:
	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
	virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo);

// Implementation
public:
	virtual ~CMainFrame();
#ifdef _DEBUG
	virtual void AssertValid() const;
	virtual void Dump(CDumpContext& dc) const;
#endif

protected:  // control bar embedded members
	CStatusBar  m_wndStatusBar;
	CToolBar    m_wndToolBar;
	CChildView    m_wndView;

// Generated message map functions
protected:
	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
	afx_msg void OnSetFocus(CWnd *pOldWnd);
	DECLARE_MESSAGE_MAP()
};


#if !defined(AFX_OPENGLWND_H__13666F99_C0F9_4AF4_B544_4E9DC57E5FE5__INCLUDED_)
#define AFX_OPENGLWND_H__13666F99_C0F9_4AF4_B544_4E9DC57E5FE5__INCLUDED_

//
// Name :         OpenGLWnd.h
// Description :  Header file for COpenGLWnd OpenGL superclass.
// Documentation : See OpenGLWnd.cpp
// Author :       Charles B. Owen
//


#pragma once

#include <gl/gl.h>
#include <gl/glu.h>

/////////////////////////////////////////////////////////////////////////////
// COpenGLWnd window

class COpenGLWnd : public CWnd
{
// Construction
public:

	COpenGLWnd();

// Attributes
public:

// Operations
public:
   virtual void OnGLDraw(CDC *pDC);

// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(COpenGLWnd)
	protected:
	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
	//}}AFX_VIRTUAL

// Implementation
public:
	void OnSaveImage();
	void GetSize(int &p_width, int &p_height);
	bool ObtainPixels(GLbyte **&p_pixels);
	virtual ~COpenGLWnd();

   HGLRC HGLRc() {return m_hrc;}

	// Generated message map functions
protected:
	 void SetDoubleBuffer(bool p_doublebuffer);
   bool GetDoubleBuffer() const {return m_doublebuffer;}

	//{{AFX_MSG(COpenGLWnd)
	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
	afx_msg void OnPaint();
   afx_msg BOOL OnEraseBkgnd(CDC* pDC);
   //}}AFX_MSG
	DECLARE_MESSAGE_MAP()

private:
    int FormattedErrorAfxMsgBox(const char *p_msg);

	bool m_created;
	bool m_doublebuffer;
    BOOL CreateRGBPalette(HDC hDC);

    HGLRC m_hrc;
	CPalette* m_pPal ;		//Palette

   	//
	// Support for generating RGB color palette
	//
	unsigned char ComponentFromIndex(int i, UINT nbits, UINT shift) ;

 	static unsigned char   m_oneto8[2];
    static unsigned char   m_twoto8[4];
    static unsigned char   m_threeto8[8];
    static int             m_defaultOverride[13];
    static PALETTEENTRY    m_defaultPalEntry[20];
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_OPENGLWND_H__13666F99_C0F9_4AF4_B544_4E9DC57E5FE5__INCLUDED_)
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by MyRobot.rc
//
#define IDD_ABOUTBOX                    100
#define IDP_OLE_INIT_FAILED             100
#define IDR_MAINFRAME                   128
#define IDR_SnowmanTYPE                 129
#define ID_LABSTUFF_SPIN                32771
#define ID_LABSTUFF_NEWTHING            32772

// Next default values for new objects
// 
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        130
#define _APS_NEXT_COMMAND_VALUE         32773
#define _APS_NEXT_CONTROL_VALUE         1000
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif
//===========================================================================
// The Snowman Class
//===========================================================================
#include <iostream>
#include "stdafx.h"
#include "Snowman.h"
#include "Sphere.h"

using namespace std;

/*
rgb colors
grey (211, 211, 211)
black (0,0,0);
*/

//===========================================
// Snowman::InitSnowman
//   Initializes all private member spheres.
//===========================================
void Snowman::InitSnowman()
{
	// draw head
	myHead.SetRadius(1.0);
	myHead.SetBlue(232.0);
	myHead.SetGreen(232.0);
	myHead.SetRed(232.0);
	myHead.SetX(0.0);
	myHead.SetY(7.7);
	myHead.SetZ(0.0);

	//draw torso
	myMiddle.SetRadius(2.0);
	myMiddle.SetBlue(232.0);
	myMiddle.SetGreen(232.0);
	myMiddle.SetRed(232.0);
	myMiddle.SetX(0.0);
	myMiddle.SetY(4.8);
	myMiddle.SetZ(0.0);

	//draw lower body
	myBottom.SetRadius(3.0);
	myBottom.SetBlue(232.0);
	myBottom.SetGreen(232.0);
	myBottom.SetRed(232.0);
	myBottom.SetX(0.0);
	myBottom.SetY(0.0);
	myBottom.SetZ(0.0);
/*
	//draw first eye
	eyeOne.SetRadius(5.0);
	eyeOne.SetBlue(211.0);
	eyeOne.SetGreen(211.0);
	eyeOne.SetRed(211.0);
	eyeOne.SetX(10.0);
	eyeOne.SetY(10.0);
	eyeOne.SetZ(0.0);

	//draw second eye
	eyeTwo.SetRadius(5.0);
	eyeTwo.SetBlue(211.0);
	eyeTwo.SetGreen(211.0);
	eyeTwo.SetRed(211.0);
	eyeTwo.SetX(10.0);
	eyeTwo.SetY(10.0);
	eyeTwo.SetZ(2.0);
*/
}
//==================================================================
// Snowman::DrawSnowman
//   Calls the framework's DrawSphere() function for every sphere to be
//   rendered (that is, all the spheres that comprise the snowman).
//==================================================================
void Snowman::DrawSnowman()
{
	DrawSphere(myHead);
	DrawSphere(myMiddle);
	DrawSphere(myBottom);
	DrawSphere(eyeOne);
	DrawSphere(eyeTwo);
}
double Snowman::GetVolume()
{
	double volume = (myHead.GetVolume() + myMiddle.GetVolume() + myBottom.GetVolume());
	return volume;
}
//end of file//===========================================================================
// The Snowman Class
//===========================================================================
#ifndef _Snowman
#define _Snowman

//includes
#include "stdafx.h"
#include "ChildView.h"
#include "Sphere.h"

class Snowman
{
  private:
    Sphere myHead;
	Sphere myMiddle;
	Sphere myBottom;
	Sphere eyeOne;
	Sphere eyeTwo;

  public:
    void InitSnowman(),
		 DrawSnowman();
	double GetVolume();
};

//===========================================================================
// [Eof]
//===========================================================================

#endif
// Snowman.cpp : Defines the class behaviors for the application.
//

#include "stdafx.h"
#include "SnowmanApp.h"
#include "MainFrm.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CSnowmanApp

BEGIN_MESSAGE_MAP(CSnowmanApp, CWinApp)
	ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
END_MESSAGE_MAP()


// CSnowmanApp construction

CSnowmanApp::CSnowmanApp()
{
	// TODO: add construction code here,
	// Place all significant initialization in InitInstance
}


// The one and only CSnowmanApp object

CSnowmanApp theApp;

// CSnowmanApp initialization

BOOL CSnowmanApp::InitInstance()
{
	// InitCommonControls() is required on Windows XP if an application
	// manifest specifies use of ComCtl32.dll version 6 or later to enable
	// visual styles.  Otherwise, any window creation will fail.
	InitCommonControls();

	CWinApp::InitInstance();

	// Initialize OLE libraries
	if (!AfxOleInit())
	{
		AfxMessageBox(IDP_OLE_INIT_FAILED);
		return FALSE;
	}
	AfxEnableControlContainer();
	// Standard initialization
	// If you are not using these features and wish to reduce the size
	// of your final executable, you should remove from the following
	// the specific initialization routines you do not need
	// Change the registry key under which our settings are stored
	// TODO: You should modify this string to be something appropriate
	// such as the name of your company or organization
	SetRegistryKey(_T("Local AppWizard-Generated Applications"));
	// To create the main window, this code creates a new frame window
	// object and then sets it as the application's main window object
	CMainFrame* pFrame = new CMainFrame;
	if (!pFrame)
		return FALSE;
	m_pMainWnd = pFrame;
	// create and load the frame with its resources
	pFrame->LoadFrame(IDR_MAINFRAME,
		WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, NULL,
		NULL);
	// The one and only window has been initialized, so show and update it
	
	pFrame->SetWindowText( "Project 05 / CSE231: Snowmen and Spheres" );
	pFrame->ShowWindow(SW_SHOW);
	pFrame->UpdateWindow();
	// call DragAcceptFiles only if there's a suffix
	//  In an SDI app, this should occur after ProcessShellCommand
	return TRUE;
}


// CSnowmanApp message handlers



// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialog Data
	enum { IDD = IDD_ABOUTBOX };

protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

// Implementation
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
END_MESSAGE_MAP()

// App command to run the dialog
void CSnowmanApp::OnAppAbout()
{
	CAboutDlg aboutDlg;
	aboutDlg.DoModal();
}


// CSnowmanApp message handlers

// SnowmanApp.h : main header file for the Snowman application
//
#pragma once

#ifndef __AFXWIN_H__
	#error include 'stdafx.h' before including this file for PCH
#endif

#include "resource.h"       // main symbols


// CSnowmanApp:
// See Snowman.cpp for the implementation of this class
//

class CSnowmanApp : public CWinApp
{
public:
	CSnowmanApp();

// Overrides
public:
	virtual BOOL InitInstance();

// Implementation

public:
	afx_msg void OnAppAbout();
	DECLARE_MESSAGE_MAP()
};

extern CSnowmanApp theApp;#ifndef _Sphere
#define _Sphere

//=========
// Sphere
//=========

class Sphere
{
public:
	Sphere(); //constructor

	double      //all of the get functions return a respective double value
		GetX(),
		GetY(),
		GetZ(),
		GetRed(),
		GetGreen(),
		GetBlue(),
		GetRadius(),
		GetVolume();

	void		// all of the void Set* funtions take a double
		 SetX(double),
		 SetY(double),
		 SetZ(double),
		 SetGreen(double),
		 SetBlue(double),
		 SetRed(double),
		 SetRadius(double);

private:
	double
		x, y, z, r, g, b, radius;
};
//end Sphere header
#endif
#include <iostream>
#include "stdafx.h"
#include "Sphere.h"

using namespace std;


Sphere::Sphere()	//implement default Sphere constructor
{
}
double Sphere::GetX()
{
	return x;
}
double Sphere::GetY()
{
	return y;
}
double Sphere::GetZ()
{
	return z;
}
double Sphere::GetRed()
{
	return r;
}
double Sphere::GetGreen()
{
	return g;
}
double Sphere::GetBlue()
{
	return b;
}
double Sphere::GetRadius()
{
	return radius;
}
double Sphere::GetVolume()
{
	double volume = (4.0 / 3.0) * (3.14) * (radius * radius * radius);
	return volume;
}
void Sphere::SetX(double newX)
{
	x = newX;
}
void Sphere::SetY(double newY)
{
	y = newY;
}
void Sphere::SetZ(double newZ)
{
	z = newZ;
}
void Sphere::SetRed(double newRed)
{
	r = newRed;
}
void Sphere::SetGreen(double newGreen)
{
	g = newGreen;
}
void Sphere::SetBlue(double newBlue)
{
	b = newBlue;
}
void Sphere::SetRadius(double newRadius)
{
	radius = newRadius;
}#ifndef _Sphere
#define _Sphere

//=========
// Sphere
//=========

class Sphere
{
public:
	Sphere(); //constructor

	double      //all of the get functions return a respective double value
		GetX(),
		GetY(),
		GetZ(),
		GetRed(),
		GetGreen(),
		GetBlue(),
		GetRadius(),
		GetVolume();

	void		// all of the void Set* funtions take a double
		 SetX(double),
		 SetY(double),
		 SetZ(double),
		 SetGreen(double),
		 SetBlue(double),
		 SetRed(double),
		 SetRadius(double);

private:
	double
		x, y, z, r, g, b, radius;
};
//end Sphere header
#endif
// stdafx.cpp : source file that includes just the standard includes
// MyRobot.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information

#include "stdafx.h"


// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently,
// but are changed infrequently

#pragma once

#ifndef VC_EXTRALEAN
#define VC_EXTRALEAN		// Exclude rarely-used stuff from Windows headers
#endif

// Modify the following defines if you have to target a platform prior to the ones specified below.
// Refer to MSDN for the latest info on corresponding values for different platforms.
#ifndef WINVER				// Allow use of features specific to Windows 95 and Windows NT 4 or later.
#define WINVER 0x0400		// Change this to the appropriate value to target Windows 98 and Windows 2000 or later.
#endif

#ifndef _WIN32_WINNT		// Allow use of features specific to Windows NT 4 or later.
#define _WIN32_WINNT 0x0400		// Change this to the appropriate value to target Windows 98 and Windows 2000 or later.
#endif						

#ifndef _WIN32_WINDOWS		// Allow use of features specific to Windows 98 or later.
#define _WIN32_WINDOWS 0x0410 // Change this to the appropriate value to target Windows Me or later.
#endif

#ifndef _WIN32_IE			// Allow use of features specific to IE 4.0 or later.
#define _WIN32_IE 0x0400	// Change this to the appropriate value to target IE 5.0 or later.
#endif

#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS	// some CString constructors will be explicit

// turns off MFC's hiding of some common and often safely ignored warning messages
#define _AFX_ALL_WARNINGS

#include <afxwin.h>         // MFC core and standard components
#include <afxext.h>         // MFC extensions
#include <afxdisp.h>        // MFC Automation classes

#include <afxdtctl.h>		// MFC support for Internet Explorer 4 Common Controls
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h>			// MFC support for Windows Common Controls
#endif // _AFX_NO_AFXCMN_SUPPORT