void btgGLInit3D(CView *pView)
{
oldRect = drawRect;
pView->GetClientRect(&drawRect);
if (oldRect != drawRect)
{
if (hGLDeviceContext != NULL)
{
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hGLRenderContext);
hGLRenderContext = 0;
}
}
hGLDeviceContext = wglGetCurrentDC();
if (hGLDeviceContext == NULL || hGLRenderContext == 0)
{
hGLDeviceContext = ::GetDC(pView->GetSafeHwnd());
setupPixelFormat(hGLDeviceContext);
setupPalette(hGLDeviceContext);
hGLRenderContext = wglCreateContext(hGLDeviceContext);
wglMakeCurrent(hGLDeviceContext, hGLRenderContext);
auxInitPosition(0, 0, drawRect.right - drawRect.left, drawRect.bottom - drawRect.top);
auxInitDisplayMode(AUX_RGB);
}
else
{
//wglMakeCurrent(hGLDeviceContext, hGLRenderContext);
}
CBTGDoc* pDoc = (CBTGDoc*)pView->GetDocument();
glClearColor((GLfloat)pDoc->mBGRed / 255.0f,
(GLfloat)pDoc->mBGGreen / 255.0f,
(GLfloat)pDoc->mBGBlue / 255.0f,
1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50.0, (float)(drawRect.right - drawRect.left) / (float)(drawRect.bottom - drawRect.top), 1.0, 2000.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
btgGLRecalc3DCamera();
gluLookAt(eye[0], eye[1], eye[2],
look[0], look[1], look[2],
0.0, 0.0, 1.0);
glDisable(GL_LIGHTING);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
}
void btgGLInit(CView *pView)
{
oldRect = drawRect;
pView->GetClientRect(&drawRect);
if(oldRect != drawRect)
{
if (hGLDeviceContext != NULL)
{
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hGLRenderContext);
hGLRenderContext = 0;
}
}
hGLDeviceContext = wglGetCurrentDC();
if (hGLDeviceContext == NULL || hGLRenderContext == 0)
{
hGLDeviceContext = ::GetDC(pView->GetSafeHwnd());
setupPixelFormat(hGLDeviceContext);
setupPalette(hGLDeviceContext);
hGLRenderContext = wglCreateContext(hGLDeviceContext); //create GL render context and select into window
wglMakeCurrent(hGLDeviceContext, hGLRenderContext);
//create the viewport for rendering
auxInitPosition(0, 0, drawRect.right - drawRect.left, drawRect.bottom - drawRect.top);
//set mode (direct color)
auxInitDisplayMode(AUX_RGB);
}
else
{
//wglMakeCurrent(hGLDeviceContext, hGLRenderContext);
}
CBTGDoc* pDoc = (CBTGDoc*)pView->GetDocument();
glClearColor((GLfloat)pDoc->mBGRed / 255.0f,
(GLfloat)pDoc->mBGGreen / 255.0f,
(GLfloat)pDoc->mBGBlue / 255.0f,
1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluOrtho2D(0, drawRect.right - drawRect.left, 0, drawRect.bottom - drawRect.top);
glDisable(GL_LIGHTING);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
}
bool GLPlatform::initialize()
{
if (false == setupPixelFormat())
{
return false;
}
if (false == setupWGL())
{
return false;
}
return true;
}
int init_ogl(HWND hwnd,HGLRC *hglrc,HDC *hdc)
{
if(hwnd && hglrc && hdc){
HDC hDC;
HGLRC hGLRC;
hDC=GetDC(hwnd);
if(hDC){
setupPixelFormat(hDC);
hGLRC=wglCreateContext(hDC);
if(hGLRC){
wglMakeCurrent(hDC,hGLRC);
if(hglrc)
*hglrc=hGLRC;
gl_init();
}
//SelectObject(hDC,GetStockObject(SYSTEM_FONT));
//wglUseFontBitmaps(hDC,0,255,1000);
//ReleaseDC(hv,hDC);
if(hdc)
*hdc=hDC;
}
}
}
// main window procedure
LONG WINAPI MainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
LONG lRet = 1;
PAINTSTRUCT ps;
RECT rect;
switch (uMsg) {
case WM_CREATE:
ghDC = GetDC(hWnd);
if (!setupPixelFormat(ghDC)) {
PostQuitMessage(0);
}
initializeGL();
GetClientRect(hWnd, &rect);
resize(rect.right, rect.bottom); // added in leiu of passing dims to initialize
g_programs.compilePrograms();
setupData(rect.right, rect.bottom);
::SetTimer(hWnd, DRAW_TIMER_ID, 0, DrawTimerProc);
break;
case WM_PAINT:
BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
break;
case WM_SIZE:
GetClientRect(hWnd, &rect);
resize(rect.right, rect.bottom);
break;
case WM_CLOSE:
doCleanup(hWnd);
DestroyWindow(hWnd);
break;
case WM_DESTROY:
doCleanup(hWnd);
PostQuitMessage(0);
break;
case WM_KEYDOWN:
switch (wParam) {
case 'P':
g_paused = !g_paused;
break;
//case 'W':
// if (g_shiftPressed) {
// g_camera.moveUp(MOVE_AMOUNT);
// }
// else {
// g_camera.moveForward(MOVE_AMOUNT);
// }
// redoModelViewMatrix();
// break;
//case 'A':
// g_camera.moveSide(-MOVE_AMOUNT);
// redoModelViewMatrix();
// break;
//case 'S':
// if (g_shiftPressed) {
// g_camera.moveUp(-MOVE_AMOUNT);
// }
// else {
// g_camera.moveForward(-MOVE_AMOUNT);
// }
// redoModelViewMatrix();
// break;
//case 'D':
// g_camera.moveSide(MOVE_AMOUNT);
// redoModelViewMatrix();
// break;
//case 'Q':
// g_camera.spinAroundFwd(SPIN_AMOUNT);
// redoModelViewMatrix();
// break;
//case 'E':
// g_camera.spinAroundFwd(-SPIN_AMOUNT);
// redoModelViewMatrix();
// break;
//case VK_UP:
// g_camera.spinAroundSide(-SPIN_AMOUNT);
// redoModelViewMatrix();
// break;
//case VK_DOWN:
// g_camera.spinAroundSide(SPIN_AMOUNT);
// redoModelViewMatrix();
// break;
//case VK_LEFT:
// //if (g_shiftPressed) {
// // g_camera.spinAroundFwd(SPIN_AMOUNT);
// //}
// //else {
// g_camera.spinAroundUp(SPIN_AMOUNT);
// //}
// redoModelViewMatrix();
// break;
//case VK_RIGHT:
// //if (g_shiftPressed) {
// // g_camera.spinAroundFwd(-SPIN_AMOUNT);
// //}
// //else {
// g_camera.spinAroundUp(-SPIN_AMOUNT);
// //}
// redoModelViewMatrix();
// break;
case VK_SHIFT:
g_shiftPressed = true;
break;
}
break;
case WM_KEYUP:
switch (wParam) {
case VK_SHIFT:
g_shiftPressed = false;
break;
}
break;
case WM_LBUTTONDOWN:
g_mouse.l_btn_down = true;
break;
case WM_LBUTTONUP:
g_mouse.l_btn_down = false;
break;
case WM_MOUSEMOVE: {
int x = GET_X_LPARAM(lParam);
int y = GET_Y_LPARAM(lParam);
if (g_mouse.l_btn_down) {
moveCameraByMouseMove(x, y, g_mouse.last_x, g_mouse.last_y);
}
g_mouse.last_x = x;
g_mouse.last_y = y;
break;
}
case WM_MOUSEWHEEL: {
int delta = GET_WHEEL_DELTA_WPARAM(wParam);
zoomCameraByMouseWheel(delta);
break;
}
default:
lRet = DefWindowProc(hWnd, uMsg, wParam, lParam);
break;
}
return lRet;
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HWND shwnd;
static HDC hdc;
static HGLRC hglrc, hglrc_legacy;
static Engine altEngine;
static POINT center;
static WSADATA wsadata;
switch (message)
{
case WM_CREATE:
WSAStartup(MAKEWORD(2, 2), &wsadata);
AllocConsole();
RedirectIOToConsole();
SetTimer ( hwnd, TICK_TIMER, 16, NULL );
hdc = GetDC(hwnd);
setupPixelFormat(hdc);
#ifndef DIRECTX
hglrc_legacy = wglCreateContext(hdc);
wglMakeCurrent(hdc, hglrc_legacy);
glewInit();
if(wglewIsSupported("WGL_ARB_create_context") == TRUE)
{
const int context[] =
{
WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
WGL_CONTEXT_MINOR_VERSION_ARB, 1,
// WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
0
};
const int pixelformat[] =
{
WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
WGL_COLOR_BITS_ARB, 32,
WGL_DEPTH_BITS_ARB, 24,
WGL_STENCIL_BITS_ARB, 8,
0,
};
int format;
unsigned int num_formats;
wglChoosePixelFormatARB(hdc, (int *)pixelformat, NULL, 1, &format, &num_formats);
hglrc = wglCreateContextAttribsARB(hdc, 0, context);
wglMakeCurrent(NULL,NULL);
wglDeleteContext(hglrc_legacy);
wglMakeCurrent(hdc, hglrc);
}
else
{
//opengl 2.0
hglrc = hglrc_legacy;
}
#endif
shwnd = hwnd;
altEngine.init(&shwnd, &hdc);
return 0;
case WMU_RENDER:
altEngine.render();
return 0;
case WM_TIMER:
if (glGetError() != GL_NO_ERROR)
{
printf("GL_ERROR\n");
}
switch(wParam)
{
case TICK_TIMER:
altEngine.step();
break;
}
return 0;
case WM_MOUSEMOVE:
{
int x, y;
x = LOWORD(lParam);
y = HIWORD(lParam);
if ((x == center.x) && (y == center.y))
return 0;
if ( altEngine.mousepos(x, y, x - center.x, y - center.y) )
{
POINT screen = center;
ClientToScreen(hwnd, &screen);
SetCursorPos(screen.x, screen.y);
}
}
return 0;
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
{
bool pressed = (message == WM_LBUTTONDOWN) ? true : false;
altEngine.keypress("leftbutton", pressed);
return 0;
}
case WM_MBUTTONDOWN:
case WM_MBUTTONUP:
{
bool pressed = (message == WM_MBUTTONDOWN) ? true : false;
altEngine.keypress("middlebutton", pressed);
return 0;
}
case WM_RBUTTONDOWN:
case WM_RBUTTONUP:
{
bool pressed = (message == WM_RBUTTONDOWN) ? true : false;
altEngine.keypress("rightbutton", pressed);
return 0;
}
case WM_KEYDOWN:
case WM_KEYUP:
{
bool pressed = (message == WM_KEYDOWN) ? true : false;
switch (wParam)
{
case VK_PAUSE:
break;
case VK_TAB:
break;
case VK_RETURN:
altEngine.keypress("enter", pressed);
break;
case VK_SHIFT:
altEngine.keypress("shift", pressed);
break;
case VK_CONTROL:
altEngine.keypress("control", pressed);
break;
case VK_ESCAPE:
altEngine.keypress("escape", pressed);
break;
case VK_UP:
altEngine.keypress("up", pressed);
break;
case VK_LEFT:
altEngine.keypress("left", pressed);
break;
case VK_DOWN:
altEngine.keypress("down", pressed);
break;
case VK_RIGHT:
altEngine.keypress("right", pressed);
break;
}
return 0;
}
case WM_CHAR:
altEngine.keystroke((char)wParam);
return 0;
case WM_SIZE:
{
int width, height;
width = LOWORD(lParam);
height = HIWORD(lParam);
center.x = width / 2;
center.y = height / 2;
altEngine.resize(width, height);
}
return 0;
case WM_SYSCOMMAND:
switch(wParam)
{
case SC_SCREENSAVE:
case SC_MONITORPOWER:
return 0;
}
break;
case WM_DESTROY:
#ifndef DIRECTX
if (hglrc)
{
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hglrc);
ReleaseDC(hwnd, hdc);
}
#endif
altEngine.destroy();
WSACleanup();
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hwnd, message, wParam, lParam);
}
LRESULT APIENTRY
WndProc(
HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
switch (message) {
case WM_CREATE:
/*
** Set up for OpenGL rendering. Bind the rendering context to
** the same device context that the palette will be selected into.
*/
hDC = GetDC(hWnd);
setupPixelFormat(hDC);
setupPalette(hDC);
hGLRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hGLRC);
if (!checkExtension("SGI_index_texture")) {
char message[1024];
sprintf(message,
"SGI_index_texture is required by this application\n"
"but is not supported by the current OpenGL renderer.\n\n"
"Vendor: %s\nRenderer: %s\nVersion: %s",
glGetString(GL_VENDOR),
glGetString(GL_RENDERER),
glGetString(GL_VERSION));
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hGLRC);
hGLRC = NULL;
MessageBox(hWnd, message, "OpenGL Extension Required",
MB_ICONERROR | MB_OK);
exit(1);
}
init();
idleFunc = doRedraw;
return 0;
case WM_DESTROY:
/*
** Finish OpenGL rendering.
*/
idleFunc = NULL;
if (hGLRC) {
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hGLRC);
}
ReleaseDC(hWnd, hDC);
PostQuitMessage(0);
return 0;
case WM_SIZE:
if (hGLRC) {
winWidth = (int) LOWORD(lParam);
winHeight = (int) HIWORD(lParam);
resize();
return 0;
}
case WM_PALETTECHANGED:
/*
** Update palette mapping if this *is not* the active window.
*/
if (hGLRC && hPalette && (HWND) wParam != hWnd) {
UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
redraw();
return 0;
}
break;
case WM_QUERYNEWPALETTE:
/*
** Update palette mapping if this *is* the active window.
*/
if (hGLRC && hPalette) {
UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
redraw();
return TRUE;
}
break;
case WM_PAINT:
/*
** Update the window. Don't use the device context returned by
** BeginPaint as it won't have the right palette selected into it.
*/
if (hGLRC) {
PAINTSTRUCT ps;
BeginPaint(hWnd, &ps);
redraw();
EndPaint(hWnd, &ps);
return 0;
}
break;
case WM_CHAR:
switch ((int)wParam) {
case VK_ESCAPE:
DestroyWindow(hWnd);
return 0;
default:
break;
}
break;
default:
break;
}
/* Deal with any unprocessed messages */
return DefWindowProc(hWnd, message, wParam, lParam);
}
ImageTargetFileWic::ImageTargetFileWic( DataTargetRef dataTarget, ImageSourceRef imageSource, const string &extensionData )
: ImageTarget(), mDataTarget( dataTarget )
{
mCodecGUID = getExtensionMap()[extensionData];
setSize( imageSource->getWidth(), imageSource->getHeight() );
// determine the pixel format we'll request
WICPixelFormatGUID formatGUID;
if( imageSource->hasAlpha() ) {
bool premultAlpha = imageSource->isPremultiplied();
// WIC doesn't support gray+alpha, so we need to do RGBA regardless
if( imageSource->getDataType() == ImageIo::UINT8 )
formatGUID = premultAlpha ? GUID_WICPixelFormat32bppPBGRA : GUID_WICPixelFormat32bppBGRA;
else if( imageSource->getDataType() == ImageIo::UINT16 )
formatGUID = premultAlpha ? GUID_WICPixelFormat64bppPRGBA : GUID_WICPixelFormat64bppRGBA;
else
formatGUID = premultAlpha ? GUID_WICPixelFormat128bppPRGBAFloat : GUID_WICPixelFormat128bppRGBAFloat;
}
else {
if( imageSource->getColorModel() == ImageIo::CM_GRAY ) {
if( imageSource->getDataType() == ImageIo::UINT8 )
formatGUID = GUID_WICPixelFormat8bppGray;
else if( imageSource->getDataType() == ImageIo::UINT16 )
formatGUID = GUID_WICPixelFormat16bppGray;
else
formatGUID = GUID_WICPixelFormat32bppGrayFloat;
}
else {
if( imageSource->getDataType() == ImageIo::UINT8 )
formatGUID = GUID_WICPixelFormat24bppBGR;
else if( imageSource->getDataType() == ImageIo::UINT16 )
formatGUID = GUID_WICPixelFormat48bppRGB;
else
formatGUID = GUID_WICPixelFormat128bppRGBFloat;
}
}
::HRESULT hr = S_OK;
msw::initializeCom();
// Create WIC factory
IWICImagingFactory *IWICFactoryP = NULL;
hr = ::CoCreateInstance( CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&IWICFactoryP) );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedLoad();
shared_ptr<IWICImagingFactory> IWICFactory = msw::makeComShared( IWICFactoryP );
IWICBitmapEncoder *encoderP = NULL;
hr = IWICFactory->CreateEncoder( *mCodecGUID, 0, &encoderP );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedLoad();
mEncoder = msw::makeComShared( encoderP );
// create the stream
IWICStream *pIWICStream = NULL;
hr = IWICFactory->CreateStream( &pIWICStream );
if( ! SUCCEEDED(hr) )
throw ImageIoExceptionFailedLoad();
shared_ptr<IWICStream> stream = msw::makeComShared( pIWICStream );
// initialize the stream based on properties of the cinder::DataSouce
if( mDataTarget->providesFilePath() ) {
hr = stream->InitializeFromFilename( toUtf16( mDataTarget->getFilePath() ).c_str(), GENERIC_WRITE );
if( ! SUCCEEDED(hr) )
throw ImageIoExceptionFailedLoad();
}
else {
shared_ptr<msw::ComOStream> comOStream = msw::makeComShared( new msw::ComOStream( mDataTarget->getStream() ) );
hr = stream->InitializeFromIStream( comOStream.get() );
if( ! SUCCEEDED(hr) )
throw ImageIoExceptionFailedLoad();
}
hr = mEncoder->Initialize( stream.get(), WICBitmapEncoderNoCache );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedLoad();
// create the frame encoder
IPropertyBag2 *pPropertybag = NULL;
IWICBitmapFrameEncode *pBitmapFrame = NULL;
hr = mEncoder->CreateNewFrame( &pBitmapFrame, &pPropertybag );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedLoad();
mBitmapFrame = msw::makeComShared( pBitmapFrame );
hr = mBitmapFrame->Initialize( 0 );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedLoad();
hr = mBitmapFrame->SetSize( mWidth, mHeight );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedLoad();
// ask for our ideal pixel format and then process the one we actually get
hr = mBitmapFrame->SetPixelFormat( &formatGUID );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedLoad();
setupPixelFormat( formatGUID );
mData = shared_ptr<uint8_t>( new uint8_t[mHeight * mRowBytes], boost::checked_array_delete<uint8_t> );
}
LRESULT APIENTRY
WndProc(
HWND hWnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
switch (message) {
case WM_CREATE:
/* initialize OpenGL rendering */
hDC = GetDC(hWnd);
setupPixelFormat(hDC);
setupPalette(hDC);
hGLRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hGLRC);
init();
return 0;
case WM_DESTROY:
/* finish OpenGL rendering */
if (hGLRC) {
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hGLRC);
}
if (hPalette) {
DeleteObject(hPalette);
}
ReleaseDC(hWnd, hDC);
PostQuitMessage(0);
return 0;
case WM_SIZE:
/* track window size changes */
if (hGLRC) {
winWidth = (int) LOWORD(lParam);
winHeight = (int) HIWORD(lParam);
resize();
return 0;
}
case WM_PALETTECHANGED:
/* realize palette if this is *not* the current window */
if (hGLRC && hPalette && (HWND) wParam != hWnd) {
UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
redraw();
break;
}
break;
case WM_QUERYNEWPALETTE:
/* realize palette if this is the current window */
if (hGLRC && hPalette) {
UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
redraw();
return TRUE;
}
break;
case WM_PAINT:
{
PAINTSTRUCT ps;
BeginPaint(hWnd, &ps);
if (hGLRC) {
redraw();
}
EndPaint(hWnd, &ps);
return 0;
}
break;
case WM_CHAR:
/* handle keyboard input */
switch ((int)wParam) {
case VK_ESCAPE:
DestroyWindow(hWnd);
return 0;
default:
break;
}
break;
default:
break;
}
return DefWindowProc(hWnd, message, wParam, lParam);
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HWND shwnd;
static HDC hdc;
static HGLRC hglrc, hglrc_legacy;
static Engine altEngine;
static POINT center;
switch (message)
{
case WM_CREATE:
AllocConsole();
RedirectIOToConsole();
SetTimer ( hwnd, TICK_TIMER, 16, NULL );
hdc = GetDC(hwnd);
setupPixelFormat(hdc);
#ifndef DIRECTX
hglrc_legacy = wglCreateContext(hdc);
wglMakeCurrent(hdc, hglrc_legacy);
//opengl 2.0
hglrc = hglrc_legacy;
#endif
shwnd = hwnd;
altEngine.init(&shwnd, &hdc);
return 0;
case WMU_RENDER:
altEngine.render();
return 0;
case WM_TIMER:
switch(wParam)
{
case TICK_TIMER:
altEngine.step();
break;
}
return 0;
case WM_MOUSEMOVE:
{
}
return 0;
case WM_SIZE:
{
int width, height;
width = LOWORD(lParam);
height = HIWORD(lParam);
center.x = width / 2;
center.y = height / 2;
altEngine.resize(width, height);
}
return 0;
case WM_SYSCOMMAND:
switch(wParam)
{
case SC_SCREENSAVE:
case SC_MONITORPOWER:
return 0;
}
break;
case WM_DESTROY:
#ifndef DIRECTX
if (hglrc)
{
wglMakeCurrent(NULL, NULL);
wglDeleteContext(hglrc);
ReleaseDC(hwnd, hdc);
}
#endif
altEngine.destroy();
PostQuitMessage(0);
return 0;
}
return DefWindowProc (hwnd, message, wParam, lParam);
}
ImageTargetFileWic::ImageTargetFileWic( DataTargetRef dataTarget, ImageSourceRef imageSource, ImageTarget::Options options, const string &extensionData )
: ImageTarget(), mDataTarget( dataTarget )
{
mCodecGUID = getExtensionMap()[extensionData];
setSize( imageSource->getWidth(), imageSource->getHeight() );
// determine the pixel format we'll request
WICPixelFormatGUID formatGUID;
if( imageSource->hasAlpha() ) {
bool premultAlpha = imageSource->isPremultiplied();
// WIC doesn't support gray+alpha, so we need to do RGBA regardless
if( imageSource->getDataType() == ImageIo::UINT8 )
formatGUID = premultAlpha ? GUID_WICPixelFormat32bppPBGRA : GUID_WICPixelFormat32bppBGRA;
else if( imageSource->getDataType() == ImageIo::UINT16 )
formatGUID = premultAlpha ? GUID_WICPixelFormat64bppPRGBA : GUID_WICPixelFormat64bppRGBA;
else
formatGUID = premultAlpha ? GUID_WICPixelFormat128bppPRGBAFloat : GUID_WICPixelFormat128bppRGBAFloat;
}
else {
ImageIo::ColorModel cm = options.isColorModelDefault() ? imageSource->getColorModel() : options.getColorModel();
if( cm == ImageIo::CM_GRAY ) {
if( imageSource->getDataType() == ImageIo::UINT8 )
formatGUID = GUID_WICPixelFormat8bppGray;
else if( imageSource->getDataType() == ImageIo::UINT16 )
formatGUID = GUID_WICPixelFormat16bppGray;
else
formatGUID = GUID_WICPixelFormat32bppGrayFloat;
}
else { // RGB
if( imageSource->getDataType() == ImageIo::UINT8 )
formatGUID = GUID_WICPixelFormat24bppBGR;
else if( imageSource->getDataType() == ImageIo::UINT16 )
formatGUID = GUID_WICPixelFormat48bppRGB;
else
formatGUID = GUID_WICPixelFormat128bppRGBFloat;
}
}
::HRESULT hr = S_OK;
msw::initializeCom();
// Create WIC factory
IWICImagingFactory *IWICFactoryP = NULL;
hr = ::CoCreateInstance( CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&IWICFactoryP) );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedWrite( "Could not create WIC Factory." );
shared_ptr<IWICImagingFactory> IWICFactory = msw::makeComShared( IWICFactoryP );
IWICBitmapEncoder *encoderP = NULL;
hr = IWICFactory->CreateEncoder( *mCodecGUID, 0, &encoderP );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedWrite( "Could not create WIC Encoder." );
mEncoder = msw::makeComShared( encoderP );
// create the stream
IWICStream *pIWICStream = NULL;
hr = IWICFactory->CreateStream( &pIWICStream );
if( ! SUCCEEDED(hr) )
throw ImageIoExceptionFailedWrite( "Could not create WIC stream." );
shared_ptr<IWICStream> stream = msw::makeComShared( pIWICStream );
// initialize the stream based on properties of the cinder::DataSouce
if( mDataTarget->providesFilePath() ) {
#if defined( CINDER_WINRT)
std::string s = mDataTarget->getFilePath().string();
std::wstring filePath = std::wstring(s.begin(), s.end());
#else
std::wstring filePath = mDataTarget->getFilePath().wstring().c_str();
#endif
hr = stream->InitializeFromFilename( filePath.c_str(), GENERIC_WRITE );
if( ! SUCCEEDED(hr) )
throw ImageIoExceptionFailedWrite( "Could not initialize WIC Stream from filename." );
}
else {
shared_ptr<msw::ComOStream> comOStream = msw::makeComShared( new msw::ComOStream( mDataTarget->getStream() ) );
hr = stream->InitializeFromIStream( comOStream.get() );
if( ! SUCCEEDED(hr) )
throw ImageIoExceptionFailedWrite( "Could not initialize WIC Stream from IStream." );
}
hr = mEncoder->Initialize( stream.get(), WICBitmapEncoderNoCache );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedWrite( "Could not initialize WIC Encoder." );
// create the frame encoder
IPropertyBag2 *pPropertybag = NULL;
IWICBitmapFrameEncode *pBitmapFrame = NULL;
hr = mEncoder->CreateNewFrame( &pBitmapFrame, &pPropertybag );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedWrite( "Could not ceate WIC Frame." );
mBitmapFrame = msw::makeComShared( pBitmapFrame );
// setup the propertyBag to express quality
PROPBAG2 option = { 0 };
option.pstrName = L"ImageQuality";
VARIANT varValue;
VariantInit(&varValue);
varValue.vt = VT_R4;
varValue.fltVal = options.getQuality();
hr = pPropertybag->Write( 1, &option, &varValue );
hr = mBitmapFrame->Initialize( pPropertybag );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedWrite( "Could not initialize WIC PROPBAG2." );
hr = mBitmapFrame->SetSize( mWidth, mHeight );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedWrite( "Could not set WIC Frame size." );
// ask for our ideal pixel format and then process the one we actually get
hr = mBitmapFrame->SetPixelFormat( &formatGUID );
if( ! SUCCEEDED( hr ) )
throw ImageIoExceptionFailedWrite( "Could not set WIC Frame pixel format." );
setupPixelFormat( formatGUID );
mData = shared_ptr<uint8_t>( new uint8_t[mHeight * mRowBytes], std::default_delete<uint8_t[]>() );
}
LRESULT GLWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_CREATE: // window creation
{
m_hdc = GetDC(hWnd);
setupPixelFormat();
//Set the version that we want, in this case 3.0
int attribs[] = {
WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
WGL_CONTEXT_MINOR_VERSION_ARB, 0,
0}; //zero indicates the end of the array
//Create temporary context so we can get a pointer to the function
HGLRC tmpContext = wglCreateContext(m_hdc);
//Make it current
wglMakeCurrent(m_hdc, tmpContext);
//Get the function pointer
wglCreateContextAttribsARB = (GLEEPFNWGLCREATECONTEXTATTRIBSARBPROC) wglGetProcAddress("wglCreateContextAttribsARB");
//If this is NULL then OpenGL 3.0 is not supported
if (!wglCreateContextAttribsARB)
{
MessageBox(NULL, "OpenGL 3.0 is not supported, falling back to GL 2.1", "An error occurred", MB_ICONERROR | MB_OK);
m_hglrc = tmpContext;
}
else
{
// Create an OpenGL 3.0 context using the new function
m_hglrc = wglCreateContextAttribsARB(m_hdc, 0, attribs);
//Delete the temporary context
wglDeleteContext(tmpContext);
}
//Make the GL3 context current
wglMakeCurrent(m_hdc, m_hglrc);
m_isRunning = true; //Mark our window as running
}
break;
case WM_DESTROY: // window destroy
case WM_CLOSE: // windows is closing
wglMakeCurrent(m_hdc, NULL);
wglDeleteContext(m_hglrc);
m_isRunning = false; //Stop the main loop
PostQuitMessage(0); //Send a WM_QUIT message
return 0;
break;
case WM_SIZE:
{
int height = HIWORD(lParam); // retrieve width and height
int width = LOWORD(lParam);
s_Cam()->onResize(width, height);
}
break;
case WM_KEYDOWN:
if (wParam == VK_ESCAPE) //If the escape key was pressed
{
DestroyWindow(m_hwnd); //Send a WM_DESTROY message
}
s_Keyboard()->handleKeyDown(wParam);
break;
case WM_KEYUP:
s_Keyboard()->handleKeyUp(wParam);
break;
default:
break;
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
LRESULT GLWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_CREATE: // window creation
{
m_hdc = GetDC(hWnd);
setupPixelFormat();
//Set the version that we want, in this case 3.0
int attribs[] = {
WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
WGL_CONTEXT_MINOR_VERSION_ARB, 0,
WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
0}; //zero indicates the end of the array
//Create temporary context so we can get a pointer to the function
HGLRC tmpContext = wglCreateContext(m_hdc);
//Make it current
wglMakeCurrent(m_hdc, tmpContext);
GLenum err = glGetError();
if (err != GL_NO_ERROR)
{
MessageBox(NULL, "Error before creating context", "OpenGL Error!", MB_ICONERROR | MB_OK);
}
//If this is NULL then OpenGL 3.0 is not supported
//if (!wglCreateContextAttribsARB)
//{
std::cerr << "OpenGL 3.0 is not supported, falling back to GL 2.1" << std::endl;
m_hglrc = tmpContext;
//}
/*else
{
// Create an OpenGL 3.0 context using the new function
m_hglrc = wglCreateContextAttribsARB(m_hdc, 0, attribs);
err = glGetError();
if (err != GL_NO_ERROR)
{
MessageBox(NULL, "Error creating context", "OpenGL Error!", MB_ICONERROR | MB_OK);
}
//Delete the temporary context
wglDeleteContext(tmpContext);
err = glGetError();
if (err != GL_NO_ERROR)
{
MessageBox(NULL, "Error deleting context", "OpenGL Error!", MB_ICONERROR | MB_OK);
}
}*/
//Make the GL3 context current
wglMakeCurrent(m_hdc, m_hglrc);
err = glGetError();
if (err != GL_NO_ERROR)
{
MessageBox(NULL, "Error making context current", "OpenGL Error!", MB_ICONERROR | MB_OK);
}
m_isRunning = true; //Mark our window as running
}
break;
case WM_DESTROY: // window destroy
case WM_CLOSE: // windows is closing
wglMakeCurrent(m_hdc, NULL);
wglDeleteContext(m_hglrc);
m_isRunning = false; //Stop the main loop
PostQuitMessage(0); //Send a WM_QUIT message
return 0;
break;
case WM_SIZE:
{
int height = HIWORD(lParam); // retrieve width and height
int width = LOWORD(lParam);
getAttachedEngine()->onResize(width, height); //Call the example's resize method
}
break;
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE :
DestroyWindow(m_hwnd);
break;
default :
break;
}
break;
default:
break;
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
