git.cworth.org Git - apitrace/blob - retrace/glretrace_ws.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2011-2012 Jose Fonseca
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  *
  24  **************************************************************************/
  25
  26
  27 /**
  28  * Window system helpers for glretrace.
  29  */
  30
  31
  32 #include <string.h>
  33
  34 #include "os_thread.hpp"
  35 #include "retrace.hpp"
  36 #include "glproc.hpp"
  37 #include "glstate.hpp"
  38 #include "glretrace.hpp"
  39
  40
  41 namespace glretrace {
  42
  43
  44 static glws::Visual *
  45 visuals[glws::PROFILE_MAX];
  46
  47
  48 inline glws::Visual *
  49 getVisual(glws::Profile profile) {
  50     glws::Visual * & visual = visuals[profile];
  51     if (!visual) {
  52         visual = glws::createVisual(retrace::doubleBuffer, profile);
  53         if (!visual) {
  54             std::cerr << "error: failed to create OpenGL visual\n";
  55             exit(1);
  56         }
  57     }
  58     return visual;
  59 }
  60
  61
  62 inline glws::Profile
  63 getDefaultProfile(void)
  64 {
  65     if (retrace::coreProfile) {
  66         return glws::PROFILE_CORE;
  67     } else {
  68         return glws::PROFILE_COMPAT;
  69     }
  70 }
  71
  72
  73 static glws::Drawable *
  74 createDrawableHelper(glws::Profile profile, int width = 32, int height = 32, bool pbuffer = false) {
  75     glws::Visual *visual = getVisual(profile);
  76     glws::Drawable *draw = glws::createDrawable(visual, width, height, pbuffer);
  77     if (!draw) {
  78         std::cerr << "error: failed to create OpenGL drawable\n";
  79         exit(1);
  80     }
  81
  82     return draw;
  83 }
  84
  85
  86 glws::Drawable *
  87 createDrawable(glws::Profile profile) {
  88     return createDrawableHelper(profile);
  89 }
  90
  91
  92 glws::Drawable *
  93 createDrawable(void) {
  94     return createDrawable(getDefaultProfile());
  95 }
  96
  97
  98 glws::Drawable *
  99 createPbuffer(int width, int height) {
 100     return createDrawableHelper(getDefaultProfile(), width, height, true);
 101 }
 102
 103
 104 Context *
 105 createContext(Context *shareContext, glws::Profile profile) {
 106     glws::Visual *visual = getVisual(profile);
 107     glws::Context *shareWsContext = shareContext ? shareContext->wsContext : NULL;
 108     glws::Context *ctx = glws::createContext(visual, shareWsContext, profile, retrace::debug);
 109     if (!ctx) {
 110         std::cerr << "error: failed to create OpenGL context\n";
 111         exit(1);
 112         return NULL;
 113     }
 114
 115     return new Context(ctx);
 116 }
 117
 118
 119 Context *
 120 createContext(Context *shareContext) {
 121     return createContext(shareContext, getDefaultProfile());
 122 }
 123
 124
 125 static thread_specific Context *
 126 currentContextPtr;
 127
 128
 129 bool
 130 makeCurrent(trace::Call &call, glws::Drawable *drawable, Context *context)
 131 {
 132     Context *currentContext = currentContextPtr;
 133     glws::Drawable *currentDrawable = currentContext ? currentContext->drawable : NULL;
 134
 135     if (drawable == currentDrawable && context == currentContext) {
 136         return true;
 137     }
 138
 139     if (currentContext) {
 140         glFlush();
 141         if (!retrace::doubleBuffer) {
 142             frame_complete(call);
 143         }
 144     }
 145
 146     flushQueries();
 147
 148     bool success = glws::makeCurrent(drawable, context ? context->wsContext : NULL);
 149
 150     if (!success) {
 151         std::cerr << "error: failed to make current OpenGL context and drawable\n";
 152         exit(1);
 153         return false;
 154     }
 155
 156     if (currentContext) {
 157         currentContext->drawable = NULL;
 158     }
 159
 160     if (drawable && context) {
 161         context->drawable = drawable;
 162         currentContextPtr = context;
 163
 164         if (!context->used) {
 165             initContext();
 166             context->used = true;
 167         }
 168     }
 169
 170     return true;
 171 }
 172
 173
 174 Context *
 175 getCurrentContext(void) {
 176     return currentContextPtr;
 177 }
 178
 179
 180 /**
 181  * Grow the current drawble.
 182  *
 183  * We need to infer the drawable size from GL calls because the drawable sizes
 184  * are specified by OS specific calls which we do not trace.
 185  */
 186 void
 187 updateDrawable(int width, int height) {
 188     Context *currentContext = getCurrentContext();
 189     if (!currentContext) {
 190         return;
 191     }
 192
 193     glws::Drawable *currentDrawable = currentContext->drawable;
 194     assert(currentDrawable);
 195
 196     if (currentDrawable->pbuffer) {
 197         return;
 198     }
 199
 200     if (currentDrawable->visible &&
 201         width  <= currentDrawable->width &&
 202         height <= currentDrawable->height) {
 203         return;
 204     }
 205
 206     // Ignore zero area viewports
 207     if (width == 0 || height == 0) {
 208         return;
 209     }
 210
 211     // Check for bound framebuffer last, as this may have a performance impact.
 212     GLint draw_framebuffer = 0;
 213     glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &draw_framebuffer);
 214     if (draw_framebuffer != 0) {
 215         return;
 216     }
 217
 218     currentDrawable->resize(width, height);
 219     currentDrawable->show();
 220
 221     glScissor(0, 0, width, height);
 222 }
 223
 224
 225 int
 226 parseAttrib(const trace::Value *attribs, int param, int default_ = 0) {
 227     const trace::Array *attribs_ = dynamic_cast<const trace::Array *>(attribs);
 228
 229     if (attribs_) {
 230         for (size_t i = 0; i + 1 < attribs_->values.size(); i += 2) {
 231             int param_i = attribs_->values[i]->toSInt();
 232             if (param_i == 0) {
 233                 break;
 234             }
 235
 236             if (param_i == param) {
 237                 int value = attribs_->values[i + 1]->toSInt();
 238                 return value;
 239             }
 240         }
 241     }
 242
 243     return default_;
 244 }
 245
 246
 247 } /* namespace glretrace */