传真(Fax)编程

开发平台：
Visual C++

glview.cpp：源码内容
							// glview.cpp
//
#include "stdafx.h"
#include "glview.h"
#include <math.h>
GLView3D::GLView3D(void)
{
	InitImage();
}
GLView3D::~GLView3D(void)
{
}
void GLView3D::CreateImage(UINT32 width, UINT32 height)
{
	if ((width > 0) && (height > 0))
	{
		m_dib.Create(width,height,24);
		if (!IsInitialized())
		{
			InitializeOpenGL();
			if (CreateView())
			{
				m_IsInitialized = 1;
			}
		}
	}
}
void GLView3D::SizeImage(UINT32 width, UINT32 height)
{
	if ((width > 0) && (height > 0))
	{
		if (!IsInitialized())
		{
			CreateImage(width,height);
		}
		else
		{
			if (!m_dib.IsCreated())
			{
				m_dib.Create(width,height,24);
				if (SetImagePixelFormat(*m_dib.GetDC()))
				{
					CreateImageGLContext(*m_dib.GetDC());
				}
			}
			else if ((width != m_dib.Width()) || (height != m_dib.Height()))
			{
				m_dib.Create(width,height,24);
				CreateView();
			}
		}
		glViewport(0,0,width,height);
		double aspect;
		aspect = (height == 0) ? (double)width : (double)width/(double)height;
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluPerspective(45,aspect,0.000001,50.0);
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		m_reRender = true;
	}
}
void GLView3D::InitializeOpenGL(void)
{
	m_hGLContext = NULL;
	m_GLPixelIndex = 0;
	InitGeometry();
}
void GLView3D::InitGeometry(void)
{
	m_model_matrix.SetRotation(30.0,0.0,0.0);
	m_model_matrix.SetScale(1.0,1.0,1.0);
	m_model_matrix.SetPosition(0.0,0.0,0.0);
}
  // Lights, camera, action...
int GLView3D::CreateView(void)
{
	int result = 0;
	  // do the standard OpenGL initialization
	if(SetImagePixelFormat(*m_dib.GetDC()) && CreateImageGLContext(*m_dib.GetDC()))
		result = 1;
	else
		return result;
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	glShadeModel(GL_SMOOTH);
	glEnable(GL_NORMALIZE);
	glEnable(GL_COLOR_MATERIAL);
	// Lights, material properties
	GLfloat	ambientProperties[]  = {0.3f, 0.3f, 0.3f, 0.7f};
	GLfloat	diffuseProperties[]  = {0.9f, 0.9f, 0.9f, 1.0f};
	GLfloat	specularProperties[] = {0.7f, 0.7f, 0.7f, 1.0f};
	GLfloat mat_amb_diff[] = { 0.7f, 0.7f, 0.7f, 1.0f};
	GLfloat shine[] = { 128.0f};
	GLfloat emissionProperties[] = {0.2f, 0.2f, 0.2f, 1.0f};
		
	glLightfv( GL_LIGHT0, GL_AMBIENT, ambientProperties);
	glLightfv( GL_LIGHT0, GL_DIFFUSE, diffuseProperties);
	glLightfv( GL_LIGHT0, GL_SPECULAR, specularProperties);
	glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1.0);
	//glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_amb_diff);
	//glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, shine);
	//glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emissionProperties);
	// lighting
	glEnable(GL_LIGHT0);
	glEnable(GL_LIGHTING);
	glEnable(GL_DEPTH_TEST);
	m_reRender = true;
	return result;
}
BOOL GLView3D::SetImagePixelFormat(HDC hDC)
{
	PIXELFORMATDESCRIPTOR pixelDesc;
	
	pixelDesc.nSize = sizeof(PIXELFORMATDESCRIPTOR);
	pixelDesc.nVersion = 1;
	
	pixelDesc.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL |
		PFD_SUPPORT_GDI;
	
	pixelDesc.iPixelType = PFD_TYPE_RGBA;
	pixelDesc.cColorBits = 24;
	pixelDesc.cRedBits = 0;
	pixelDesc.cRedShift = 0;
	pixelDesc.cGreenBits = 0;
	pixelDesc.cGreenShift = 0;
	pixelDesc.cBlueBits = 0;
	pixelDesc.cBlueShift = 0;
	pixelDesc.cAlphaBits = 0;
	pixelDesc.cAlphaShift = 0;
	pixelDesc.cAccumBits = 0;
	pixelDesc.cAccumRedBits = 0;
	pixelDesc.cAccumGreenBits = 0;
	pixelDesc.cAccumBlueBits = 0;
	pixelDesc.cAccumAlphaBits = 0;
	pixelDesc.cDepthBits = 24;
	pixelDesc.cStencilBits = 0;
	pixelDesc.cAuxBuffers = 0;
	pixelDesc.iLayerType = PFD_MAIN_PLANE;
	pixelDesc.bReserved = 0;
	pixelDesc.dwLayerMask = 0;
	pixelDesc.dwVisibleMask = 0;
	pixelDesc.dwDamageMask = 0;
	
	int pix_index = ChoosePixelFormat(hDC,&pixelDesc);
	
	if(!SetPixelFormat(hDC,pix_index,&pixelDesc))
	{
		DWORD code = GetLastError();
		return FALSE;
	}
	
	return TRUE;
}
BOOL GLView3D::CreateImageGLContext(HDC hDC)
{
	m_hGLContext = wglCreateContext(hDC);
	
	if(m_hGLContext==NULL)
		return FALSE;
	
	if(wglMakeCurrent(hDC,m_hGLContext)==FALSE)
		return FALSE;
	
	return TRUE;
}
void GLView3D::SetBackgroundColor(double r, double g, double b)
{
	m_red_bg = r;
	m_green_bg = g;
	m_blue_bg = b;
	m_reRender = true;
}
void GLView3D::SetOrientation(void)
{
	  // Position / translation / scale
	glTranslated(m_model_matrix.X(),m_model_matrix.Y(),m_model_matrix.Z());
	glRotated(m_model_matrix.XRot(), 1.0, 0.0, 0.0);
	glRotated(m_model_matrix.YRot(), 0.0, 1.0, 0.0);
	glRotated(m_model_matrix.ZRot(), 0.0, 0.0, 1.0);
	glScaled(m_model_matrix.XScale(),m_model_matrix.YScale(),m_model_matrix.ZScale());
}
void GLView3D::PickObject(int x, int y, int& id)
{
	m_pickMode = true;
	m_pickX = x;
	m_pickY = y;
	m_pickID = 0;
	RenderImage();
	m_pickMode = false;
	RenderImage();
}
void GLView3D::RenderImage(void)
{
	//if (m_reRender)
	//{
		if (m_IsInitialized && m_dib.IsCreated())
		{
			glClearColor((float)m_red_bg,(float)m_blue_bg,
				(float)m_green_bg,1.0f);
			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
			
			  // put a working copy on the matrix stack
			glPushMatrix();
			
			SetOrientation();
			  // build the scene...if necessary
			RenderPrimaryImage();
			glFlush();
		
			  // pop the working copy of the matrix stack
			glPopMatrix();
		}
		m_reRender = false;
	//}
}
void GLView3D::RenderPrimaryImage(void)
{
}
void GLView3D::DrawImage(CWnd * wnd)
{
	CClientDC dc(wnd);
	m_dib.Draw(&dc,0,0);
}
void NormalVector(GLdouble p1[3], GLdouble p2[3],
				  GLdouble p3[3], GLdouble n[3])
{
	GLdouble v1[3], v2[3], d;
	// calculate two vectors, using the middle point
	// as the common origin
	v1[0] = p3[0] - p1[0];
	v1[1] = p3[1] - p1[1];
	v1[2] = p3[2] - p1[2];
	v2[0] = p3[0] - p2[0];
	v2[1] = p3[1] - p2[1];
	v2[2] = p3[2] - p2[2];
	// calculate the cross product of the two vectors
	n[0] = v1[1] * v2[2] - v2[1] * v1[2];
	n[1] = v1[2] * v2[0] - v2[2] * v1[0];
	n[2] = v1[0] * v2[1] - v2[0] * v1[1];
	// normalize the vector
	d = ( n[0] * n[0] + n[1] * n[1] + n[2] * n[2] );
	// try to catch very small vectors
	if (d < (GLdouble)0.00000001)
	{
		d = (GLdouble)100000000.0;
	}
	else
	{
		d = (GLdouble)1.0 / sqrt(d);
	}
	n[0] *= d;
	n[1] *= d;
	n[2] *= d;
}

						