Тихомиров Ю. Программирование трёхмерной графики / Files / PixFrmtCheck / OpenGL

// OpenGL.cpp : реализация
//

#include "stdafx.h"
#include "PixFrmt.h"
#include "OpenGL.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// COpenGLView

//IMPLEMENT_DYNCREATE(COpenGLView, CView)

COpenGLView::COpenGLView()
{
}

COpenGLView::~COpenGLView()
{
}

BEGIN_MESSAGE_MAP(COpenGLView, CView)
	//{{AFX_MSG_MAP(COpenGLView)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_WM_SIZE()
	ON_WM_NCCREATE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// COpenGLView: рисование

void COpenGLView::OnDraw(CDC* pDC)
{
	m_pGL->Render();
}

/////////////////////////////////////////////////////////////////////////////
// COpenGLView: обработчики сообщений

void COpenGLView::OnInitialUpdate() 
{
  m_pGL->Init();
  CView::OnInitialUpdate();
}

BOOL COpenGLView::PreCreateWindow(CREATESTRUCT& cs) 
{
  // OpenGL требует обязательной установки стилей
  // WS_CLIPSIBLINGS и WS_CLIPCHILDREN
  cs.style |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
	
	return CView::PreCreateWindow(cs);
}

int COpenGLView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CView::OnCreate(lpCreateStruct) == -1)
		return -1;
	
  m_pGL = GetOpenGL();
	ASSERT(m_pGL);
	
  BOOL bResult = m_pGL->Create(this);
	if (bResult)
		return 0;
	else
		return -1;
}

void COpenGLView::OnDestroy() 
{
  m_pGL->Destroy();
  CView::OnDestroy();
}

void COpenGLView::OnSize(UINT nType, int cx, int cy) 
{
	CView::OnSize(nType, cx, cy);
	
  m_pGL->Resize(cx,cy);
}

BOOL COpenGLView::OnNcCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (!CView::OnNcCreate(lpCreateStruct))
		return FALSE;
	
  m_pGL = GetOpenGL();
	ASSERT(m_pGL);
		
	return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// COpenGL

// Конструктор
//
COpenGL::COpenGL()
{
	m_hrc = NULL ;
	m_pdc = NULL ;
	
	m_bDoubleBuffer = FALSE ;
}

// Деструктор
//
COpenGL::~COpenGL()
{
	Destroy() ;
}

// Destroy: 
//
void COpenGL::Destroy() 
{
	if (m_hrc) 
	{
		// Удаляем контекст воспроизведения
		if (m_hrc == wglGetCurrentContext())
			wglMakeCurrent(NULL,NULL) ; 

		wglDeleteContext(m_hrc) ;
		m_hrc = NULL ;
	}		
}

// Create
//
BOOL COpenGL::Create(CWnd* pWnd, int iPixelType, DWORD dwFlags)
{
	ASSERT(pWnd) ;
	ASSERT((iPixelType == PFD_TYPE_RGBA) ||
         (iPixelType == PFD_TYPE_COLORINDEX)) ;

	// Заполняем структуру Pixel Format Descriptor
	//
  PIXELFORMATDESCRIPTOR pfd ;
	memset(&pfd,0, sizeof(PIXELFORMATDESCRIPTOR));
  pfd.nSize        = sizeof(PIXELFORMATDESCRIPTOR);  
  pfd.nVersion     = 1;              // Номер версии
	pfd.dwFlags      = dwFlags;
	pfd.iPixelType   = iPixelType;
	pfd.cColorBits   = 64;             // 64 бита для цвета
  pfd.cAlphaBits   = 64;             // 64 бита для альфа
  pfd.cAccumBits   = 64;             // 64 бита для аккумулятора
  pfd.cDepthBits   = 64;             // 64-разрядный буфер глубины
  pfd.cStencilBits = 64;             // 64 бита для трафарета
  pfd.cStencilBits = 64;             // 64 бита для дополнительного буфера
  pfd.iLayerType   = PFD_MAIN_PLANE; // тип уровня

  //pfd.dwFlags |= (//PFD_DRAW_TO_BITMAP |
  //                PFD_GENERIC_FORMAT |
  //                PFD_NEED_PALETTE   |
  //                PFD_STEREO);//         |
                  //PFD_NEED_SYSTEM_PALETTE);

	// За создание отвечает потомок
  //
	OnCreate(pWnd, &pfd) ;

	// Для воспроизведения битового массива следует использовать
  // другую версию функции Create
	//
	ASSERT( !(dwFlags & PFD_DRAW_TO_BITMAP)) ;
	ASSERT( (dwFlags & PFD_DRAW_TO_WINDOW)) ;

	// Определение наличия двойной буферизации
  //
	m_bDoubleBuffer = pfd.dwFlags & PFD_DOUBLEBUFFER ;

	// Создаем контекст устройства
  //
	m_pdc = new CClientDC(pWnd);

	// Выбираем наиболее подходящий формат пикселей
  //
   int nPixelFormat = ChoosePixelFormat(m_pdc->m_hDC, &pfd);
	if (nPixelFormat == 0)
	{
		TRACE("ChoosePixelFormat Failed %d\r\n",GetLastError()) ;
		return FALSE ;
	}

	// Устанавливаем формат пикселей
  //
   BOOL bResult = SetPixelFormat(m_pdc->m_hDC, nPixelFormat, &pfd);
	if (!bResult)
	{
		TRACE("SetPixelFormat Failed %d\r\n",GetLastError()) ;
		return FALSE ;
	}
	
  // Создаем контекст воспроизведения
  //
  m_hrc = wglCreateContext(m_pdc->m_hDC);
	if (!m_hrc)
	{
		TRACE("wglCreateContext Failed %x\r\n", GetLastError()) ;
		return FALSE;
	}

	// Здесь не следует устанавливать текущий контекст воспроизведения,
  // вызывая wglMakeCurrent. Это будет сделано  в Resize
  //
	return TRUE;
}

// Изменение размеров
//
BOOL COpenGL::Resize(int cx, int cy) 
{
	if ( (cx <= 0) || (cy <= 0) ) return FALSE;

	return OnResize(cx, cy) ;    
}

// Инициализация
//
BOOL COpenGL::Init()
{
	return OnInit() ;
}

// Воспроизведение
//
BOOL COpenGL::Render()
{
	// Рисование
	OnRender();

	glFlush();

	// Если режим двойной буферизации,
  // то обновление буфера воспроизведения
  if (m_bDoubleBuffer)
		SwapBuffers(m_pdc->m_hDC);

	return TRUE;
}