static struct dri_swrast_renderbuffer * swrast_new_renderbuffer(const struct gl_config *visual, __DRIdrawable *dPriv, GLboolean front) { struct dri_swrast_renderbuffer *xrb = calloc(1, sizeof *xrb); struct gl_renderbuffer *rb; GLuint pixel_format; TRACE; if (!xrb) return NULL; rb = &xrb->Base.Base; _mesa_init_renderbuffer(rb, 0); pixel_format = choose_pixel_format(visual); xrb->dPriv = dPriv; xrb->Base.Base.Delete = swrast_delete_renderbuffer; if (front) { rb->AllocStorage = swrast_alloc_front_storage; } else { rb->AllocStorage = swrast_alloc_back_storage; } switch (pixel_format) { case PF_A8R8G8B8: rb->Format = MESA_FORMAT_B8G8R8A8_UNORM; rb->InternalFormat = GL_RGBA; rb->_BaseFormat = GL_RGBA; xrb->bpp = 32; break; case PF_X8R8G8B8: rb->Format = MESA_FORMAT_B8G8R8A8_UNORM; /* XXX */ rb->InternalFormat = GL_RGB; rb->_BaseFormat = GL_RGB; xrb->bpp = 32; break; case PF_R5G6B5: rb->Format = MESA_FORMAT_B5G6R5_UNORM; rb->InternalFormat = GL_RGB; rb->_BaseFormat = GL_RGB; xrb->bpp = 16; break; case PF_R3G3B2: rb->Format = MESA_FORMAT_B2G3R3_UNORM; rb->InternalFormat = GL_RGB; rb->_BaseFormat = GL_RGB; xrb->bpp = 8; break; default: free(xrb); return NULL; } return xrb; }
static struct swrast_renderbuffer * swrast_new_renderbuffer(const struct gl_config *visual, GLboolean front) { struct swrast_renderbuffer *xrb = calloc(1, sizeof *xrb); GLuint pixel_format; TRACE; if (!xrb) return NULL; _mesa_init_renderbuffer(&xrb->Base, 0); pixel_format = choose_pixel_format(visual); xrb->Base.Delete = swrast_delete_renderbuffer; if (front) { xrb->Base.AllocStorage = swrast_alloc_front_storage; swrast_set_span_funcs_front(xrb, pixel_format); } else { xrb->Base.AllocStorage = swrast_alloc_back_storage; swrast_set_span_funcs_back(xrb, pixel_format); } switch (pixel_format) { case PF_A8R8G8B8: xrb->Base.Format = MESA_FORMAT_ARGB8888; xrb->Base.InternalFormat = GL_RGBA; xrb->Base._BaseFormat = GL_RGBA; xrb->Base.DataType = GL_UNSIGNED_BYTE; xrb->bpp = 32; break; case PF_X8R8G8B8: xrb->Base.Format = MESA_FORMAT_ARGB8888; /* XXX */ xrb->Base.InternalFormat = GL_RGB; xrb->Base._BaseFormat = GL_RGB; xrb->Base.DataType = GL_UNSIGNED_BYTE; xrb->bpp = 32; break; case PF_R5G6B5: xrb->Base.Format = MESA_FORMAT_RGB565; xrb->Base.InternalFormat = GL_RGB; xrb->Base._BaseFormat = GL_RGB; xrb->Base.DataType = GL_UNSIGNED_BYTE; xrb->bpp = 16; break; case PF_R3G3B2: xrb->Base.Format = MESA_FORMAT_RGB332; xrb->Base.InternalFormat = GL_RGB; xrb->Base._BaseFormat = GL_RGB; xrb->Base.DataType = GL_UNSIGNED_BYTE; xrb->bpp = 8; break; default: return NULL; } return xrb; }
/* * Create a new X/Mesa visual. * Input: display - X11 display * visinfo - an XVisualInfo pointer * rgb_flag - GL_TRUE = RGB mode, * GL_FALSE = color index mode * alpha_flag - alpha buffer requested? * db_flag - GL_TRUE = double-buffered, * GL_FALSE = single buffered * stereo_flag - stereo visual? * ximage_flag - GL_TRUE = use an XImage for back buffer, * GL_FALSE = use an off-screen pixmap for back buffer * depth_size - requested bits/depth values, or zero * stencil_size - requested bits/stencil values, or zero * accum_red_size - requested bits/red accum values, or zero * accum_green_size - requested bits/green accum values, or zero * accum_blue_size - requested bits/blue accum values, or zero * accum_alpha_size - requested bits/alpha accum values, or zero * num_samples - number of samples/pixel if multisampling, or zero * level - visual level, usually 0 * visualCaveat - ala the GLX extension, usually GLX_NONE * Return; a new XMesaVisual or 0 if error. */ PUBLIC XMesaVisual XMesaCreateVisual( Display *display, XVisualInfo * visinfo, GLboolean rgb_flag, GLboolean alpha_flag, GLboolean db_flag, GLboolean stereo_flag, GLboolean ximage_flag, GLint depth_size, GLint stencil_size, GLint accum_red_size, GLint accum_green_size, GLint accum_blue_size, GLint accum_alpha_size, GLint num_samples, GLint level, GLint visualCaveat ) { XMesaDisplay xmdpy = xmesa_init_display(display); XMesaVisual v; GLint red_bits, green_bits, blue_bits, alpha_bits; if (!xmdpy) return NULL; /* For debugging only */ if (_mesa_getenv("MESA_XSYNC")) { /* This makes debugging X easier. * In your debugger, set a breakpoint on _XError to stop when an * X protocol error is generated. */ XSynchronize( display, 1 ); } v = (XMesaVisual) CALLOC_STRUCT(xmesa_visual); if (!v) { return NULL; } v->display = display; /* Save a copy of the XVisualInfo struct because the user may Xfree() * the struct but we may need some of the information contained in it * at a later time. */ v->visinfo = (XVisualInfo *) malloc(sizeof(*visinfo)); if (!v->visinfo) { free(v); return NULL; } memcpy(v->visinfo, visinfo, sizeof(*visinfo)); v->ximage_flag = ximage_flag; v->mesa_visual.redMask = visinfo->red_mask; v->mesa_visual.greenMask = visinfo->green_mask; v->mesa_visual.blueMask = visinfo->blue_mask; v->visualID = visinfo->visualid; v->screen = visinfo->screen; #if !(defined(__cplusplus) || defined(c_plusplus)) v->visualType = xmesa_convert_from_x_visual_type(visinfo->class); #else v->visualType = xmesa_convert_from_x_visual_type(visinfo->c_class); #endif v->mesa_visual.visualRating = visualCaveat; if (alpha_flag) v->mesa_visual.alphaBits = 8; (void) initialize_visual_and_buffer( v, NULL, rgb_flag, 0, 0 ); { const int xclass = v->visualType; if (xclass == GLX_TRUE_COLOR || xclass == GLX_DIRECT_COLOR) { red_bits = _mesa_bitcount(GET_REDMASK(v)); green_bits = _mesa_bitcount(GET_GREENMASK(v)); blue_bits = _mesa_bitcount(GET_BLUEMASK(v)); } else { /* this is an approximation */ int depth; depth = v->visinfo->depth; red_bits = depth / 3; depth -= red_bits; green_bits = depth / 2; depth -= green_bits; blue_bits = depth; alpha_bits = 0; assert( red_bits + green_bits + blue_bits == v->visinfo->depth ); } alpha_bits = v->mesa_visual.alphaBits; } /* initialize visual */ { struct gl_config *vis = &v->mesa_visual; vis->rgbMode = GL_TRUE; vis->doubleBufferMode = db_flag; vis->stereoMode = stereo_flag; vis->redBits = red_bits; vis->greenBits = green_bits; vis->blueBits = blue_bits; vis->alphaBits = alpha_bits; vis->rgbBits = red_bits + green_bits + blue_bits; vis->indexBits = 0; vis->depthBits = depth_size; vis->stencilBits = stencil_size; vis->accumRedBits = accum_red_size; vis->accumGreenBits = accum_green_size; vis->accumBlueBits = accum_blue_size; vis->accumAlphaBits = accum_alpha_size; vis->haveAccumBuffer = accum_red_size > 0; vis->haveDepthBuffer = depth_size > 0; vis->haveStencilBuffer = stencil_size > 0; vis->numAuxBuffers = 0; vis->level = 0; vis->sampleBuffers = 0; vis->samples = 0; } v->stvis.buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK; if (db_flag) v->stvis.buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK; if (stereo_flag) { v->stvis.buffer_mask |= ST_ATTACHMENT_FRONT_RIGHT_MASK; if (db_flag) v->stvis.buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK; } v->stvis.color_format = choose_pixel_format(v); if (v->stvis.color_format == PIPE_FORMAT_NONE) { free(v->visinfo); free(v); return NULL; } v->stvis.depth_stencil_format = choose_depth_stencil_format(xmdpy, depth_size, stencil_size); v->stvis.accum_format = (accum_red_size + accum_green_size + accum_blue_size + accum_alpha_size) ? PIPE_FORMAT_R16G16B16A16_SNORM : PIPE_FORMAT_NONE; v->stvis.samples = num_samples; v->stvis.render_buffer = ST_ATTACHMENT_INVALID; /* XXX minor hack */ v->mesa_visual.level = level; return v; }
PUBLIC void XMesaBindTexImage(Display *dpy, XMesaBuffer drawable, int buffer, const int *attrib_list) { struct st_context_iface *st = stapi->get_current(stapi); struct st_framebuffer_iface* stfbi = drawable->stfb; struct pipe_resource *res; int x, y, w, h; enum st_attachment_type st_attachment = xmesa_attachment_type(buffer); x = 0; y = 0; w = drawable->width; h = drawable->height; /* We need to validate our attachments before using them, * in case the texture doesn't exist yet. */ xmesa_st_framebuffer_validate_textures(stfbi, w, h, 1 << st_attachment); res = xmesa_get_attachment(stfbi, st_attachment); if (res) { struct pipe_context* pipe = xmesa_get_context(stfbi); enum pipe_format internal_format = res->format; struct pipe_transfer *tex_xfer; char *map; int line, ximage_stride; XImage *img; internal_format = choose_pixel_format(drawable->xm_visual); tex_xfer = pipe_get_transfer(pipe, res, 0, 0, /* level, layer */ PIPE_TRANSFER_WRITE, x, y, w, h); if (!tex_xfer) return; /* Grab the XImage that we want to turn into a texture. */ img = XGetImage(dpy, drawable->ws.drawable, x, y, w, h, AllPlanes, ZPixmap); if (!img) { pipe_transfer_destroy(pipe, tex_xfer); return; } map = pipe_transfer_map(pipe, tex_xfer); if (!map) { pipe_transfer_destroy(pipe, tex_xfer); return; } /* The pipe transfer has a pitch rounded up to the nearest 64 pixels. We assume 32 bit pixels. */ ximage_stride = w * 4; for (line = 0; line < h; line++) memcpy(&map[line * tex_xfer->stride], &img->data[line * ximage_stride], ximage_stride); pipe_transfer_unmap(pipe, tex_xfer); pipe_transfer_destroy(pipe, tex_xfer); st->teximage(st, ST_TEXTURE_2D, 0, /* level */ internal_format, res, FALSE /* no mipmap */); } }
bool process(convert_params& params, convert_stats& stats) { texture_type tex_type = params.m_texture_type; crn_comp_params comp_params(params.m_comp_params); crn_mipmap_params mipmap_params(params.m_mipmap_params); progress_params progress_state; progress_state.m_pParams = ¶ms; progress_state.m_canceled = false; progress_state.m_start_percentage = 0; params.m_status = false; params.m_error_message.clear(); if (params.m_pIntermediate_texture) { crnlib_delete(params.m_pIntermediate_texture); params.m_pIntermediate_texture = NULL; } params.m_pIntermediate_texture = crnlib_new<mipmapped_texture>(*params.m_pInput_texture); mipmapped_texture& work_tex = *params.m_pInput_texture; if ((params.m_unflip) && (work_tex.is_flipped())) { console::info("Unflipping texture"); work_tex.unflip(true, true); } if (params.m_y_flip) { console::info("Flipping texture on Y axis"); // This is awkward - if we're writing to KTX, then go ahead and properly update the work texture's orientation flags. // Otherwise, don't bother updating the orientation flags because the writer may then attempt to unflip the texture before writing to formats // that don't support flipped textures (ugh). const bool bOutputFormatSupportsFlippedTextures = params.m_dst_file_type == texture_file_types::cFormatKTX; if (!work_tex.flip_y(bOutputFormatSupportsFlippedTextures)) { console::warning("Failed flipping texture on Y axis"); } } if ((params.m_dst_format != PIXEL_FMT_INVALID) && (pixel_format_helpers::is_alpha_only(params.m_dst_format))) { if ((work_tex.get_comp_flags() & pixel_format_helpers::cCompFlagAValid) == 0) { console::warning("Output format is alpha-only, but input doesn't have alpha, so setting alpha to luminance."); work_tex.convert(PIXEL_FMT_A8, crnlib::dxt_image::pack_params()); if (tex_type == cTextureTypeNormalMap) tex_type = cTextureTypeRegularMap; } } pixel_format dst_format = params.m_dst_format; if (pixel_format_helpers::is_dxt(dst_format)) { if ((params.m_dst_file_type != texture_file_types::cFormatCRN) && (params.m_dst_file_type != texture_file_types::cFormatDDS) && (params.m_dst_file_type != texture_file_types::cFormatKTX)) { console::warning("Output file format does not support DXTc - automatically choosing a non-DXT pixel format."); dst_format = PIXEL_FMT_INVALID; } } if (dst_format == PIXEL_FMT_INVALID) { // Caller didn't specify a format to use, so try to pick something reasonable. // This is actually much trickier than it seems, and the current approach kind of sucks. dst_format = choose_pixel_format(params, comp_params, work_tex, tex_type); } if ((dst_format == PIXEL_FMT_DXT1) && (comp_params.get_flag(cCRNCompFlagDXT1AForTransparency))) dst_format = PIXEL_FMT_DXT1A; else if (dst_format == PIXEL_FMT_DXT1A) comp_params.set_flag(cCRNCompFlagDXT1AForTransparency, true); if ((dst_format == PIXEL_FMT_DXT1A) && (params.m_dst_file_type == texture_file_types::cFormatCRN)) { console::warning("CRN file format does not support DXT1A compressed textures - converting to DXT5 instead."); dst_format = PIXEL_FMT_DXT5; } const bool is_normal_map = (tex_type == cTextureTypeNormalMap); bool perceptual = comp_params.get_flag(cCRNCompFlagPerceptual); if (is_normal_map) { perceptual = false; mipmap_params.m_gamma_filtering = false; } if (pixel_format_helpers::is_pixel_format_non_srgb(dst_format)) { if (perceptual) { console::message("Output pixel format is swizzled or not RGB, disabling perceptual color metrics"); perceptual = false; } } if (pixel_format_helpers::is_normal_map(dst_format)) { if (perceptual) console::message("Output pixel format is intended for normal maps, disabling perceptual color metrics"); perceptual = false; } bool generate_mipmaps = texture_file_types::supports_mipmaps(params.m_dst_file_type); if ((params.m_write_mipmaps_to_multiple_files) && ((params.m_dst_file_type != texture_file_types::cFormatCRN) && (params.m_dst_file_type != texture_file_types::cFormatDDS) && (params.m_dst_file_type != texture_file_types::cFormatKTX))) { generate_mipmaps = true; } if (params.m_param_debugging) { params.print(); print_comp_params(comp_params); print_mipmap_params(mipmap_params); } if (!create_texture_mipmaps(work_tex, comp_params, mipmap_params, generate_mipmaps)) return convert_error(params, "Failed creating texture mipmaps!"); bool formats_differ = work_tex.get_format() != dst_format; if (formats_differ) { if (pixel_format_helpers::is_dxt1(work_tex.get_format()) && pixel_format_helpers::is_dxt1(dst_format)) formats_differ = false; } bool status = false; timer t; t.start(); if ((params.m_dst_file_type == texture_file_types::cFormatCRN) || ((params.m_dst_file_type == texture_file_types::cFormatDDS) && (pixel_format_helpers::is_dxt(dst_format)) && //((formats_differ) || (comp_params.m_target_bitrate > 0.0f) || (comp_params.m_quality_level < cCRNMaxQualityLevel)) ((comp_params.m_target_bitrate > 0.0f) || (comp_params.m_quality_level < cCRNMaxQualityLevel)))) { status = write_compressed_texture(work_tex, params, comp_params, dst_format, progress_state, perceptual, stats); } else { if ((comp_params.m_target_bitrate > 0.0f) || (comp_params.m_quality_level < cCRNMaxQualityLevel)) { console::warning("Target bitrate/quality level is not supported for this output file format.\n"); } status = convert_and_write_normal_texture(work_tex, params, comp_params, dst_format, progress_state, formats_differ, perceptual, stats); } console::progress(""); if (progress_state.m_canceled) { params.m_canceled = true; return false; } double total_write_time = t.get_elapsed_secs(); if (status) { if (params.m_param_debugging) console::info("Work texture format: %s, desired destination format: %s", pixel_format_helpers::get_pixel_format_string(work_tex.get_format()), pixel_format_helpers::get_pixel_format_string(dst_format)); console::message("Texture successfully written in %3.3fs", total_write_time); } else { dynamic_string str; if (work_tex.get_last_error().is_empty()) str.format("Failed writing texture to file \"%s\"", params.m_dst_filename.get_ptr()); else str.format("Failed writing texture to file \"%s\", Reason: %s", params.m_dst_filename.get_ptr(), work_tex.get_last_error().get_ptr()); return convert_error(params, str.get_ptr()); } if (params.m_debugging) { crnlib_print_mem_stats(); } params.m_status = true; return true; }
bool process(convert_params& params, convert_stats& stats) { texture_type tex_type = params.m_texture_type; crn_comp_params comp_params(params.m_comp_params); crn_mipmap_params mipmap_params(params.m_mipmap_params); progress_params progress_state; progress_state.m_pParams = ¶ms; progress_state.m_canceled = false; progress_state.m_start_percentage = 0; params.m_status = false; params.m_error_message.clear(); if (params.m_pIntermediate_texture) { crnlib_delete(params.m_pIntermediate_texture); params.m_pIntermediate_texture = NULL; } params.m_pIntermediate_texture = crnlib_new<dds_texture>(*params.m_pInput_texture); dds_texture& work_tex = *params.m_pInput_texture; if ((params.m_dst_format != PIXEL_FMT_INVALID) && (pixel_format_helpers::is_alpha_only(params.m_dst_format))) { if ((work_tex.get_comp_flags() & pixel_format_helpers::cCompFlagAValid) == 0) { console::warning(L"Output format is alpha-only, but input doesn't have alpha, so setting alpha to luminance."); work_tex.convert(PIXEL_FMT_A8, crnlib::dxt_image::pack_params()); if (tex_type == cTextureTypeNormalMap) tex_type = cTextureTypeRegularMap; } } pixel_format dst_format = params.m_dst_format; if (dst_format == PIXEL_FMT_INVALID) { // Caller didn't specify a format to use, so try to pick something reasonable. // This is actually much trickier than it seems, and the current approach kind of sucks. dst_format = choose_pixel_format(params, comp_params, work_tex, tex_type); } if ((dst_format == PIXEL_FMT_DXT1) && (comp_params.get_flag(cCRNCompFlagDXT1AForTransparency))) dst_format = PIXEL_FMT_DXT1A; else if (dst_format == PIXEL_FMT_DXT1A) comp_params.set_flag(cCRNCompFlagDXT1AForTransparency, true); const bool is_normal_map = (tex_type == cTextureTypeNormalMap); bool perceptual = comp_params.get_flag(cCRNCompFlagPerceptual); if (is_normal_map) { perceptual = false; mipmap_params.m_gamma_filtering = false; } if (pixel_format_helpers::is_pixel_format_non_srgb(dst_format)) { if (perceptual) { //console::warning(L"Output pixel format is swizzled or not RGB, disabling perceptual color metrics"); perceptual = false; } } if (pixel_format_helpers::is_normal_map(dst_format)) { //if (perceptual) //console::warning(L"Output pixel format is intended for normal maps, disabling perceptual color metrics"); perceptual = false; } bool generate_mipmaps = texture_file_types::supports_mipmaps(params.m_dst_file_type); if ((params.m_write_mipmaps_to_multiple_files) && ((params.m_dst_file_type != texture_file_types::cFormatCRN) && (params.m_dst_file_type != texture_file_types::cFormatDDS))) { generate_mipmaps = true; } if (params.m_param_debugging) { params.print(); print_comp_params(comp_params); print_mipmap_params(mipmap_params); } if (!create_texture_mipmaps(work_tex, comp_params, mipmap_params, generate_mipmaps)) return convert_error(params, L"Failed creating texture mipmaps!"); bool formats_differ = work_tex.get_format() != dst_format; if (formats_differ) { if (pixel_format_helpers::is_dxt1(work_tex.get_format()) && pixel_format_helpers::is_dxt1(dst_format)) formats_differ = false; } bool status = false; timer t; t.start(); if ( (params.m_dst_file_type == texture_file_types::cFormatCRN) || ( (params.m_dst_file_type == texture_file_types::cFormatDDS) && (pixel_format_helpers::is_dxt(dst_format)) && ((formats_differ) || (comp_params.m_target_bitrate > 0.0f) || (comp_params.m_quality_level < cCRNMaxQualityLevel)) ) ) { status = write_compressed_texture(work_tex, params, comp_params, dst_format, progress_state, perceptual, stats); } else { status = convert_and_write_normal_texture(work_tex, params, comp_params, dst_format, progress_state, formats_differ, perceptual, stats); } console::progress(L""); if (progress_state.m_canceled) { params.m_canceled = true; return false; } double total_write_time = t.get_elapsed_secs(); if (status) { if (params.m_param_debugging) console::info(L"Work texture format: %s, desired destination format: %s", pixel_format_helpers::get_pixel_format_string(work_tex.get_format()), pixel_format_helpers::get_pixel_format_string(dst_format)); console::message(L"Texture successfully written in %3.3fs", total_write_time); } else { dynamic_wstring str; if (work_tex.get_last_error().is_empty()) str.format(L"Failed writing texture to file \"%s\"", params.m_dst_filename.get_ptr()); else str.format(L"Failed writing texture to file \"%s\", Reason: %s", params.m_dst_filename.get_ptr(), work_tex.get_last_error().get_ptr()); return convert_error(params, str.get_ptr()); } if (params.m_debugging) { crnlib_print_mem_stats(); } params.m_status = true; return true; }
GHOST_TSuccess GHOST_ContextWGL::initializeDrawingContext() { #ifdef GHOST_OPENGL_ALPHA const bool needAlpha = true; #else const bool needAlpha = false; #endif #ifdef GHOST_OPENGL_STENCIL const bool needStencil = true; #else const bool needStencil = false; #endif #ifdef GHOST_OPENGL_SRGB const bool sRGB = true; #else const bool sRGB = false; #endif HGLRC prevHGLRC; HDC prevHDC; int iPixelFormat; int lastPFD; PIXELFORMATDESCRIPTOR chosenPFD; SetLastError(NO_ERROR); prevHGLRC = ::wglGetCurrentContext(); WIN32_CHK(GetLastError() == NO_ERROR); prevHDC = ::wglGetCurrentDC(); WIN32_CHK(GetLastError() == NO_ERROR); iPixelFormat = choose_pixel_format(m_stereoVisual, m_numOfAASamples, needAlpha, needStencil, sRGB); if (iPixelFormat == 0) goto error; lastPFD = ::DescribePixelFormat(m_hDC, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &chosenPFD); if (!WIN32_CHK(lastPFD != 0)) goto error; if (needAlpha && chosenPFD.cAlphaBits == 0) fprintf(stderr, "Warning! Unable to find a pixel format with an alpha channel.\n"); if (needStencil && chosenPFD.cStencilBits == 0) fprintf(stderr, "Warning! Unable to find a pixel format with a stencil buffer.\n"); if (!WIN32_CHK(::SetPixelFormat(m_hDC, iPixelFormat, &chosenPFD))) goto error; activateWGLEW(); if (WGLEW_ARB_create_context) { int profileBitCore = m_contextProfileMask & WGL_CONTEXT_CORE_PROFILE_BIT_ARB; int profileBitCompat = m_contextProfileMask & WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; #ifdef WITH_GLEW_ES int profileBitES = m_contextProfileMask & WGL_CONTEXT_ES_PROFILE_BIT_EXT; #endif if (!WGLEW_ARB_create_context_profile && profileBitCore) fprintf(stderr, "Warning! OpenGL core profile not available.\n"); if (!WGLEW_ARB_create_context_profile && profileBitCompat) fprintf(stderr, "Warning! OpenGL compatibility profile not available.\n"); #ifdef WITH_GLEW_ES if (!WGLEW_EXT_create_context_es_profile && profileBitES && m_contextMajorVersion == 1) fprintf(stderr, "Warning! OpenGL ES profile not available.\n"); if (!WGLEW_EXT_create_context_es2_profile && profileBitES && m_contextMajorVersion == 2) fprintf(stderr, "Warning! OpenGL ES2 profile not available.\n"); #endif int profileMask = 0; if (WGLEW_ARB_create_context_profile && profileBitCore) profileMask |= profileBitCore; if (WGLEW_ARB_create_context_profile && profileBitCompat) profileMask |= profileBitCompat; #ifdef WITH_GLEW_ES if (WGLEW_EXT_create_context_es_profile && profileBitES) profileMask |= profileBitES; #endif if (profileMask != m_contextProfileMask) fprintf(stderr, "Warning! Ignoring untested OpenGL context profile mask bits."); std::vector<int> iAttributes; if (profileMask) { iAttributes.push_back(WGL_CONTEXT_PROFILE_MASK_ARB); iAttributes.push_back(profileMask); } if (m_contextMajorVersion != 0) { iAttributes.push_back(WGL_CONTEXT_MAJOR_VERSION_ARB); iAttributes.push_back(m_contextMajorVersion); } if (m_contextMinorVersion != 0) { iAttributes.push_back(WGL_CONTEXT_MINOR_VERSION_ARB); iAttributes.push_back(m_contextMinorVersion); } if (m_contextFlags != 0) { iAttributes.push_back(WGL_CONTEXT_FLAGS_ARB); iAttributes.push_back(m_contextFlags); } if (m_contextResetNotificationStrategy != 0) { if (WGLEW_ARB_create_context_robustness) { iAttributes.push_back(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB); iAttributes.push_back(m_contextResetNotificationStrategy); } else { fprintf(stderr, "Warning! Cannot set the reset notification strategy."); } } iAttributes.push_back(0); if (!s_singleContextMode || s_sharedHGLRC == NULL) m_hGLRC = ::wglCreateContextAttribsARB(m_hDC, NULL, &(iAttributes[0])); else m_hGLRC = s_sharedHGLRC; } else { if (m_contextProfileMask != 0) fprintf(stderr, "Warning! Legacy WGL is unable to select between OpenGL profiles."); if (m_contextMajorVersion != 0 || m_contextMinorVersion != 0) fprintf(stderr, "Warning! Legacy WGL is unable to select between OpenGL versions."); if (m_contextFlags != 0) fprintf(stderr, "Warning! Legacy WGL is unable to set context flags."); if (!s_singleContextMode || s_sharedHGLRC == NULL) m_hGLRC = ::wglCreateContext(m_hDC); else m_hGLRC = s_sharedHGLRC; } if (!WIN32_CHK(m_hGLRC != NULL)) goto error; if (s_sharedHGLRC == NULL) s_sharedHGLRC = m_hGLRC; s_sharedCount++; if (!s_singleContextMode && s_sharedHGLRC != m_hGLRC && !WIN32_CHK(::wglShareLists(s_sharedHGLRC, m_hGLRC))) goto error; if (!WIN32_CHK(::wglMakeCurrent(m_hDC, m_hGLRC))) goto error; initContextGLEW(); initClearGL(); ::SwapBuffers(m_hDC); #ifndef NDEBUG reportContextString("Vendor", m_dummyVendor, reinterpret_cast<const char*>(glGetString(GL_VENDOR))); reportContextString("Renderer", m_dummyRenderer, reinterpret_cast<const char*>(glGetString(GL_RENDERER))); reportContextString("Version", m_dummyVersion, reinterpret_cast<const char*>(glGetString(GL_VERSION))); #endif return GHOST_kSuccess; error: ::wglMakeCurrent(prevHDC, prevHGLRC); return GHOST_kFailure; }