git.cworth.org Git - apitrace/blob - glstate.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2011 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 #include <string.h>
  28
  29 #include <algorithm>
  30 #include <iostream>
  31 #include <map>
  32 #include <sstream>
  33
  34 #include "image.hpp"
  35 #include "json.hpp"
  36 #include "glproc.hpp"
  37 #include "glsize.hpp"
  38 #include "glstate.hpp"
  39
  40
  41 #ifdef __APPLE__
  42
  43 #include <Carbon/Carbon.h>
  44
  45 #ifdef __cplusplus
  46 extern "C" {
  47 #endif
  48
  49 OSStatus CGSGetSurfaceBounds(CGSConnectionID, CGWindowID, CGSSurfaceID, CGRect *);
  50
  51 #ifdef __cplusplus
  52 }
  53 #endif
  54
  55 #endif /* __APPLE__ */
  56
  57
  58 namespace glstate {
  59
  60
  61 static inline void
  62 resetPixelPackState(void) {
  63     glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
  64     glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
  65     glPixelStorei(GL_PACK_LSB_FIRST, GL_FALSE);
  66     glPixelStorei(GL_PACK_ROW_LENGTH, 0);
  67     glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0);
  68     glPixelStorei(GL_PACK_SKIP_ROWS, 0);
  69     glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
  70     glPixelStorei(GL_PACK_SKIP_IMAGES, 0);
  71     glPixelStorei(GL_PACK_ALIGNMENT, 1);
  72     glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
  73 }
  74
  75
  76 static inline void
  77 restorePixelPackState(void) {
  78     glPopClientAttrib();
  79 }
  80
  81
  82 // Mapping from shader type to shader source, used to accumulated the sources
  83 // of different shaders with same type.
  84 typedef std::map<std::string, std::string> ShaderMap;
  85
  86
  87 static void
  88 getShaderSource(ShaderMap &shaderMap, GLuint shader)
  89 {
  90     if (!shader) {
  91         return;
  92     }
  93
  94     GLint shader_type = 0;
  95     glGetShaderiv(shader, GL_SHADER_TYPE, &shader_type);
  96     if (!shader_type) {
  97         return;
  98     }
  99
 100     GLint source_length = 0;
 101     glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &source_length);
 102     if (!source_length) {
 103         return;
 104     }
 105
 106     GLchar *source = new GLchar[source_length];
 107     GLsizei length = 0;
 108     source[0] = 0;
 109     glGetShaderSource(shader, source_length, &length, source);
 110
 111     shaderMap[enumToString(shader_type)] += source;
 112
 113     delete [] source;
 114 }
 115
 116
 117 static void
 118 getShaderObjSource(ShaderMap &shaderMap, GLhandleARB shaderObj)
 119 {
 120     if (!shaderObj) {
 121         return;
 122     }
 123
 124     GLint object_type = 0;
 125     glGetObjectParameterivARB(shaderObj, GL_OBJECT_TYPE_ARB, &object_type);
 126     if (object_type != GL_SHADER_OBJECT_ARB) {
 127         return;
 128     }
 129
 130     GLint shader_type = 0;
 131     glGetObjectParameterivARB(shaderObj, GL_OBJECT_SUBTYPE_ARB, &shader_type);
 132     if (!shader_type) {
 133         return;
 134     }
 135
 136     GLint source_length = 0;
 137     glGetObjectParameterivARB(shaderObj, GL_OBJECT_SHADER_SOURCE_LENGTH_ARB, &source_length);
 138     if (!source_length) {
 139         return;
 140     }
 141
 142     GLcharARB *source = new GLcharARB[source_length];
 143     GLsizei length = 0;
 144     source[0] = 0;
 145     glGetShaderSource(shaderObj, source_length, &length, source);
 146
 147     shaderMap[enumToString(shader_type)] += source;
 148
 149     delete [] source;
 150 }
 151
 152
 153 static inline void
 154 dumpProgram(JSONWriter &json, GLint program)
 155 {
 156     GLint attached_shaders = 0;
 157     glGetProgramiv(program, GL_ATTACHED_SHADERS, &attached_shaders);
 158     if (!attached_shaders) {
 159         return;
 160     }
 161
 162     ShaderMap shaderMap;
 163
 164     GLuint *shaders = new GLuint[attached_shaders];
 165     GLsizei count = 0;
 166     glGetAttachedShaders(program, attached_shaders, &count, shaders);
 167     std::sort(shaders, shaders + count);
 168     for (GLsizei i = 0; i < count; ++ i) {
 169        getShaderSource(shaderMap, shaders[i]);
 170     }
 171     delete [] shaders;
 172
 173     for (ShaderMap::const_iterator it = shaderMap.begin(); it != shaderMap.end(); ++it) {
 174         json.beginMember(it->first);
 175         json.writeString(it->second);
 176         json.endMember();
 177     }
 178 }
 179
 180
 181 static inline void
 182 dumpProgramObj(JSONWriter &json, GLhandleARB programObj)
 183 {
 184     GLint attached_shaders = 0;
 185     glGetObjectParameterivARB(programObj, GL_OBJECT_ATTACHED_OBJECTS_ARB, &attached_shaders);
 186     if (!attached_shaders) {
 187         return;
 188     }
 189
 190     ShaderMap shaderMap;
 191
 192     GLhandleARB *shaderObjs = new GLhandleARB[attached_shaders];
 193     GLsizei count = 0;
 194     glGetAttachedObjectsARB(programObj, attached_shaders, &count, shaderObjs);
 195     std::sort(shaderObjs, shaderObjs + count);
 196     for (GLsizei i = 0; i < count; ++ i) {
 197        getShaderObjSource(shaderMap, shaderObjs[i]);
 198     }
 199     delete [] shaderObjs;
 200
 201     for (ShaderMap::const_iterator it = shaderMap.begin(); it != shaderMap.end(); ++it) {
 202         json.beginMember(it->first);
 203         json.writeString(it->second);
 204         json.endMember();
 205     }
 206 }
 207
 208 /*
 209  * When fetching the uniform name of an array we usually get name[0]
 210  * so we need to cut the trailing "[0]" in order to properly construct
 211  * array names later. Otherwise we endup with stuff like
 212  * uniformArray[0][0],
 213  * uniformArray[0][1],
 214  * instead of
 215  * uniformArray[0],
 216  * uniformArray[1].
 217  */
 218 static std::string
 219 resolveUniformName(const GLchar *name,  GLint size)
 220 {
 221     std::string qualifiedName(name);
 222     if (size > 1) {
 223         std::string::size_type nameLength = qualifiedName.length();
 224         static const char * const arrayStart = "[0]";
 225         static const int arrayStartLen = 3;
 226         if (qualifiedName.rfind(arrayStart) == (nameLength - arrayStartLen)) {
 227             qualifiedName = qualifiedName.substr(0, nameLength - 3);
 228         }
 229     }
 230     return qualifiedName;
 231 }
 232
 233 static void
 234 dumpUniform(JSONWriter &json, GLint program, GLint size, GLenum type, const GLchar *name) {
 235     GLenum elemType;
 236     GLint numElems;
 237     __gl_uniform_size(type, elemType, numElems);
 238     if (elemType == GL_NONE) {
 239         return;
 240     }
 241
 242     GLfloat fvalues[4*4];
 243     GLdouble dvalues[4*4];
 244     GLint ivalues[4*4];
 245     GLuint uivalues[4*4];
 246
 247     GLint i, j;
 248
 249     std::string qualifiedName = resolveUniformName(name, size);
 250
 251     for (i = 0; i < size; ++i) {
 252         std::stringstream ss;
 253         ss << qualifiedName;
 254
 255         if (size > 1) {
 256             ss << '[' << i << ']';
 257         }
 258
 259         std::string elemName = ss.str();
 260
 261         json.beginMember(elemName);
 262
 263         GLint location = glGetUniformLocation(program, elemName.c_str());
 264
 265         if (numElems > 1) {
 266             json.beginArray();
 267         }
 268
 269         switch (elemType) {
 270         case GL_FLOAT:
 271             glGetUniformfv(program, location, fvalues);
 272             for (j = 0; j < numElems; ++j) {
 273                 json.writeNumber(fvalues[j]);
 274             }
 275             break;
 276         case GL_DOUBLE:
 277             glGetUniformdv(program, location, dvalues);
 278             for (j = 0; j < numElems; ++j) {
 279                 json.writeNumber(dvalues[j]);
 280             }
 281             break;
 282         case GL_INT:
 283             glGetUniformiv(program, location, ivalues);
 284             for (j = 0; j < numElems; ++j) {
 285                 json.writeNumber(ivalues[j]);
 286             }
 287             break;
 288         case GL_UNSIGNED_INT:
 289             glGetUniformuiv(program, location, uivalues);
 290             for (j = 0; j < numElems; ++j) {
 291                 json.writeNumber(uivalues[j]);
 292             }
 293             break;
 294         case GL_BOOL:
 295             glGetUniformiv(program, location, ivalues);
 296             for (j = 0; j < numElems; ++j) {
 297                 json.writeBool(ivalues[j]);
 298             }
 299             break;
 300         default:
 301             assert(0);
 302             break;
 303         }
 304
 305         if (numElems > 1) {
 306             json.endArray();
 307         }
 308
 309         json.endMember();
 310     }
 311 }
 312
 313
 314 static void
 315 dumpUniformARB(JSONWriter &json, GLhandleARB programObj, GLint size, GLenum type, const GLchar *name) {
 316
 317     GLenum elemType;
 318     GLint numElems;
 319     __gl_uniform_size(type, elemType, numElems);
 320     if (elemType == GL_NONE) {
 321         return;
 322     }
 323
 324     GLfloat fvalues[4*4];
 325     GLint ivalues[4*4];
 326
 327     GLint i, j;
 328
 329     std::string qualifiedName = resolveUniformName(name, size);
 330
 331     for (i = 0; i < size; ++i) {
 332         std::stringstream ss;
 333         ss << qualifiedName;
 334
 335         if (size > 1) {
 336             ss << '[' << i << ']';
 337         }
 338
 339         std::string elemName = ss.str();
 340
 341         json.beginMember(elemName);
 342
 343         GLint location = glGetUniformLocationARB(programObj, elemName.c_str());
 344
 345         if (numElems > 1) {
 346             json.beginArray();
 347         }
 348
 349         switch (elemType) {
 350         case GL_DOUBLE:
 351             // glGetUniformdvARB does not exists
 352         case GL_FLOAT:
 353             glGetUniformfvARB(programObj, location, fvalues);
 354             for (j = 0; j < numElems; ++j) {
 355                 json.writeNumber(fvalues[j]);
 356             }
 357             break;
 358         case GL_UNSIGNED_INT:
 359             // glGetUniformuivARB does not exists
 360         case GL_INT:
 361             glGetUniformivARB(programObj, location, ivalues);
 362             for (j = 0; j < numElems; ++j) {
 363                 json.writeNumber(ivalues[j]);
 364             }
 365             break;
 366         case GL_BOOL:
 367             glGetUniformivARB(programObj, location, ivalues);
 368             for (j = 0; j < numElems; ++j) {
 369                 json.writeBool(ivalues[j]);
 370             }
 371             break;
 372         default:
 373             assert(0);
 374             break;
 375         }
 376
 377         if (numElems > 1) {
 378             json.endArray();
 379         }
 380
 381         json.endMember();
 382     }
 383 }
 384
 385
 386 static inline void
 387 dumpProgramUniforms(JSONWriter &json, GLint program)
 388 {
 389     GLint active_uniforms = 0;
 390     glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &active_uniforms);
 391     if (!active_uniforms) {
 392         return;
 393     }
 394
 395     GLint active_uniform_max_length = 0;
 396     glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &active_uniform_max_length);
 397     GLchar *name = new GLchar[active_uniform_max_length];
 398     if (!name) {
 399         return;
 400     }
 401
 402     for (GLint index = 0; index < active_uniforms; ++index) {
 403         GLsizei length = 0;
 404         GLint size = 0;
 405         GLenum type = GL_NONE;
 406         glGetActiveUniform(program, index, active_uniform_max_length, &length, &size, &type, name);
 407
 408         dumpUniform(json, program, size, type, name);
 409     }
 410
 411     delete [] name;
 412 }
 413
 414
 415 static inline void
 416 dumpProgramObjUniforms(JSONWriter &json, GLhandleARB programObj)
 417 {
 418     GLint active_uniforms = 0;
 419     glGetObjectParameterivARB(programObj, GL_OBJECT_ACTIVE_UNIFORMS_ARB, &active_uniforms);
 420     if (!active_uniforms) {
 421         return;
 422     }
 423
 424     GLint active_uniform_max_length = 0;
 425     glGetObjectParameterivARB(programObj, GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB, &active_uniform_max_length);
 426     GLchar *name = new GLchar[active_uniform_max_length];
 427     if (!name) {
 428         return;
 429     }
 430
 431     for (GLint index = 0; index < active_uniforms; ++index) {
 432         GLsizei length = 0;
 433         GLint size = 0;
 434         GLenum type = GL_NONE;
 435         glGetActiveUniformARB(programObj, index, active_uniform_max_length, &length, &size, &type, name);
 436
 437         dumpUniformARB(json, programObj, size, type, name);
 438     }
 439
 440     delete [] name;
 441 }
 442
 443
 444 static inline void
 445 dumpArbProgram(JSONWriter &json, GLenum target)
 446 {
 447     if (!glIsEnabled(target)) {
 448         return;
 449     }
 450
 451     GLint program_length = 0;
 452     glGetProgramivARB(target, GL_PROGRAM_LENGTH_ARB, &program_length);
 453     if (!program_length) {
 454         return;
 455     }
 456
 457     GLchar *source = new GLchar[program_length + 1];
 458     source[0] = 0;
 459     glGetProgramStringARB(target, GL_PROGRAM_STRING_ARB, source);
 460     source[program_length] = 0;
 461
 462     json.beginMember(enumToString(target));
 463     json.writeString(source);
 464     json.endMember();
 465
 466     delete [] source;
 467 }
 468
 469
 470 static inline void
 471 dumpArbProgramUniforms(JSONWriter &json, GLenum target, const char *prefix)
 472 {
 473     if (!glIsEnabled(target)) {
 474         return;
 475     }
 476
 477     GLint program_parameters = 0;
 478     glGetProgramivARB(target, GL_PROGRAM_PARAMETERS_ARB, &program_parameters);
 479     if (!program_parameters) {
 480         return;
 481     }
 482
 483     GLint max_program_local_parameters = 0;
 484     glGetProgramivARB(target, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &max_program_local_parameters);
 485     for (GLint index = 0; index < max_program_local_parameters; ++index) {
 486         GLdouble params[4] = {0, 0, 0, 0};
 487         glGetProgramLocalParameterdvARB(target, index, params);
 488
 489         if (!params[0] && !params[1] && !params[2] && !params[3]) {
 490             continue;
 491         }
 492
 493         char name[256];
 494         snprintf(name, sizeof name, "%sprogram.local[%i]", prefix, index);
 495
 496         json.beginMember(name);
 497         json.beginArray();
 498         json.writeNumber(params[0]);
 499         json.writeNumber(params[1]);
 500         json.writeNumber(params[2]);
 501         json.writeNumber(params[3]);
 502         json.endArray();
 503         json.endMember();
 504     }
 505
 506     GLint max_program_env_parameters = 0;
 507     glGetProgramivARB(target, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &max_program_env_parameters);
 508     for (GLint index = 0; index < max_program_env_parameters; ++index) {
 509         GLdouble params[4] = {0, 0, 0, 0};
 510         glGetProgramEnvParameterdvARB(target, index, params);
 511
 512         if (!params[0] && !params[1] && !params[2] && !params[3]) {
 513             continue;
 514         }
 515
 516         char name[256];
 517         snprintf(name, sizeof name, "%sprogram.env[%i]", prefix, index);
 518
 519         json.beginMember(name);
 520         json.beginArray();
 521         json.writeNumber(params[0]);
 522         json.writeNumber(params[1]);
 523         json.writeNumber(params[2]);
 524         json.writeNumber(params[3]);
 525         json.endArray();
 526         json.endMember();
 527     }
 528 }
 529
 530
 531 static inline void
 532 dumpShadersUniforms(JSONWriter &json)
 533 {
 534     GLint program = 0;
 535     glGetIntegerv(GL_CURRENT_PROGRAM, &program);
 536
 537     GLhandleARB programObj = glGetHandleARB(GL_PROGRAM_OBJECT_ARB);
 538
 539     json.beginMember("shaders");
 540     json.beginObject();
 541     if (program) {
 542         dumpProgram(json, program);
 543     } else if (programObj) {
 544         dumpProgramObj(json, programObj);
 545     } else {
 546         dumpArbProgram(json, GL_FRAGMENT_PROGRAM_ARB);
 547         dumpArbProgram(json, GL_VERTEX_PROGRAM_ARB);
 548     }
 549     json.endObject();
 550     json.endMember(); // shaders
 551
 552     json.beginMember("uniforms");
 553     json.beginObject();
 554     if (program) {
 555         dumpProgramUniforms(json, program);
 556     } else if (programObj) {
 557         dumpProgramObjUniforms(json, programObj);
 558     } else {
 559         dumpArbProgramUniforms(json, GL_FRAGMENT_PROGRAM_ARB, "fp.");
 560         dumpArbProgramUniforms(json, GL_VERTEX_PROGRAM_ARB, "vp.");
 561     }
 562     json.endObject();
 563     json.endMember(); // uniforms
 564 }
 565
 566
 567 static inline void
 568 dumpTextureImage(JSONWriter &json, GLenum target, GLint level)
 569 {
 570     GLint width, height = 1, depth = 1;
 571     GLint format;
 572
 573     glGetTexLevelParameteriv(target, level, GL_TEXTURE_INTERNAL_FORMAT, &format);
 574
 575     width = 0;
 576     glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
 577
 578     if (target != GL_TEXTURE_1D) {
 579         height = 0;
 580         glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
 581         if (target == GL_TEXTURE_3D) {
 582             depth = 0;
 583             glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, &depth);
 584         }
 585     }
 586
 587     if (width <= 0 || height <= 0 || depth <= 0) {
 588         return;
 589     } else {
 590         char label[512];
 591
 592         GLint active_texture = GL_TEXTURE0;
 593         glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
 594         snprintf(label, sizeof label, "%s, %s, level = %d",
 595                  enumToString(active_texture), enumToString(target), level);
 596
 597         json.beginMember(label);
 598
 599         json.beginObject();
 600
 601         // Tell the GUI this is no ordinary object, but an image
 602         json.writeStringMember("__class__", "image");
 603
 604         json.writeNumberMember("__width__", width);
 605         json.writeNumberMember("__height__", height);
 606         json.writeNumberMember("__depth__", depth);
 607
 608         json.writeStringMember("__format__", enumToString(format));
 609
 610         // Hardcoded for now, but we could chose types more adequate to the
 611         // texture internal format
 612         json.writeStringMember("__type__", "uint8");
 613         json.writeBoolMember("__normalized__", true);
 614         json.writeNumberMember("__channels__", 4);
 615
 616         GLubyte *pixels = new GLubyte[depth*width*height*4];
 617
 618         resetPixelPackState();
 619
 620         glGetTexImage(target, level, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 621
 622         restorePixelPackState();
 623
 624         json.beginMember("__data__");
 625         char *pngBuffer;
 626         int pngBufferSize;
 627         image::writePixelsToBuffer(pixels, width, height, 4, true, &pngBuffer, &pngBufferSize);
 628         json.writeBase64(pngBuffer, pngBufferSize);
 629         free(pngBuffer);
 630         json.endMember(); // __data__
 631
 632         delete [] pixels;
 633         json.endObject();
 634     }
 635 }
 636
 637
 638 static inline void
 639 dumpTexture(JSONWriter &json, GLenum target, GLenum binding)
 640 {
 641     GLint texture_binding = 0;
 642     glGetIntegerv(binding, &texture_binding);
 643     if (!glIsEnabled(target) && !texture_binding) {
 644         return;
 645     }
 646
 647     GLint level = 0;
 648     do {
 649         GLint width = 0, height = 0;
 650         glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
 651         glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
 652         if (!width || !height) {
 653             break;
 654         }
 655
 656         if (target == GL_TEXTURE_CUBE_MAP) {
 657             for (int face = 0; face < 6; ++face) {
 658                 dumpTextureImage(json, GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, level);
 659             }
 660         } else {
 661             dumpTextureImage(json, target, level);
 662         }
 663
 664         ++level;
 665     } while(true);
 666 }
 667
 668
 669 static inline void
 670 dumpTextures(JSONWriter &json)
 671 {
 672     json.beginMember("textures");
 673     json.beginObject();
 674     GLint active_texture = GL_TEXTURE0;
 675     glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
 676     GLint max_texture_coords = 0;
 677     glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);
 678     GLint max_combined_texture_image_units = 0;
 679     glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &max_combined_texture_image_units);
 680     GLint max_units = std::max(max_combined_texture_image_units, max_texture_coords);
 681     for (GLint unit = 0; unit < max_units; ++unit) {
 682         GLenum texture = GL_TEXTURE0 + unit;
 683         glActiveTexture(texture);
 684         dumpTexture(json, GL_TEXTURE_1D, GL_TEXTURE_BINDING_1D);
 685         dumpTexture(json, GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D);
 686         dumpTexture(json, GL_TEXTURE_3D, GL_TEXTURE_BINDING_3D);
 687         dumpTexture(json, GL_TEXTURE_RECTANGLE, GL_TEXTURE_BINDING_RECTANGLE);
 688         dumpTexture(json, GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BINDING_CUBE_MAP);
 689     }
 690     glActiveTexture(active_texture);
 691     json.endObject();
 692     json.endMember(); // textures
 693 }
 694
 695
 696 static bool
 697 getDrawableBounds(GLint *width, GLint *height) {
 698 #if defined(_WIN32)
 699
 700     HDC hDC = wglGetCurrentDC();
 701     if (!hDC) {
 702         return false;
 703     }
 704
 705     HWND hWnd = WindowFromDC(hDC);
 706     RECT rect;
 707
 708     if (!GetClientRect(hWnd, &rect)) {
 709        return false;
 710     }
 711
 712     *width  = rect.right  - rect.left;
 713     *height = rect.bottom - rect.top;
 714
 715 #elif defined(__APPLE__)
 716
 717     CGLContextObj ctx = CGLGetCurrentContext();
 718     if (ctx == NULL) {
 719         return false;
 720     }
 721
 722     CGSConnectionID cid;
 723     CGSWindowID wid;
 724     CGSSurfaceID sid;
 725
 726     if (CGLGetSurface(ctx, &cid, &wid, &sid) != kCGLNoError) {
 727         return false;
 728     }
 729
 730     CGRect rect;
 731
 732     if (CGSGetSurfaceBounds(cid, wid, sid, &rect) != 0) {
 733         return false;
 734     }
 735
 736     *width = rect.size.width;
 737     *height = rect.size.height;
 738
 739 #else
 740
 741 #if !TRACE_EGL
 742     Display *display;
 743     Drawable drawable;
 744     Window root;
 745     int x, y;
 746     unsigned int w, h, bw, depth;
 747
 748     display = glXGetCurrentDisplay();
 749     if (!display) {
 750         return false;
 751     }
 752
 753     drawable = glXGetCurrentDrawable();
 754     if (drawable == None) {
 755         return false;
 756     }
 757
 758     if (!XGetGeometry(display, drawable, &root, &x, &y, &w, &h, &bw, &depth)) {
 759         return false;
 760     }
 761
 762     *width = w;
 763     *height = h;
 764 #else
 765     return false;
 766 #endif
 767
 768 #endif
 769
 770     return true;
 771 }
 772
 773
 774 static const GLenum texture_bindings[][2] = {
 775     {GL_TEXTURE_1D, GL_TEXTURE_BINDING_1D},
 776     {GL_TEXTURE_2D, GL_TEXTURE_BINDING_2D},
 777     {GL_TEXTURE_3D, GL_TEXTURE_BINDING_3D},
 778     {GL_TEXTURE_RECTANGLE, GL_TEXTURE_BINDING_RECTANGLE},
 779     {GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BINDING_CUBE_MAP}
 780 };
 781
 782
 783 static bool
 784 bindTexture(GLint texture, GLenum &target, GLint &bound_texture)
 785 {
 786
 787     for (unsigned i = 0; i < sizeof(texture_bindings)/sizeof(texture_bindings[0]); ++i) {
 788         target  = texture_bindings[i][0];
 789
 790         GLenum binding = texture_bindings[i][1];
 791
 792         while (glGetError() != GL_NO_ERROR)
 793             ;
 794
 795         glGetIntegerv(binding, &bound_texture);
 796         glBindTexture(target, texture);
 797
 798         if (glGetError() == GL_NO_ERROR) {
 799             return true;
 800         }
 801
 802         glBindTexture(target, bound_texture);
 803     }
 804
 805     target = GL_NONE;
 806
 807     return false;
 808 }
 809
 810
 811 static bool
 812 getTextureLevelSize(GLint texture, GLint level, GLint *width, GLint *height)
 813 {
 814     *width = 0;
 815     *height = 0;
 816
 817     GLenum target;
 818     GLint bound_texture = 0;
 819     if (!bindTexture(texture, target, bound_texture)) {
 820         return false;
 821     }
 822
 823     glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, width);
 824     glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, height);
 825
 826     glBindTexture(target, bound_texture);
 827
 828     return *width > 0 && *height > 0;
 829 }
 830
 831
 832 static GLenum
 833 getTextureLevelFormat(GLint texture, GLint level)
 834 {
 835     GLenum target;
 836     GLint bound_texture = 0;
 837     if (!bindTexture(texture, target, bound_texture)) {
 838         return GL_NONE;
 839     }
 840
 841     GLint format = GL_NONE;
 842     glGetTexLevelParameteriv(target, level, GL_TEXTURE_INTERNAL_FORMAT, &format);
 843
 844     glBindTexture(target, bound_texture);
 845
 846     return format;
 847 }
 848
 849
 850
 851 static bool
 852 getRenderbufferSize(GLint renderbuffer, GLint *width, GLint *height)
 853 {
 854     GLint bound_renderbuffer = 0;
 855     glGetIntegerv(GL_RENDERBUFFER_BINDING, &bound_renderbuffer);
 856     glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
 857
 858     *width = 0;
 859     *height = 0;
 860     glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_WIDTH, width);
 861     glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_HEIGHT, height);
 862
 863     glBindRenderbuffer(GL_RENDERBUFFER, bound_renderbuffer);
 864
 865     return *width > 0 && *height > 0;
 866 }
 867
 868
 869 static GLenum
 870 getRenderbufferFormat(GLint renderbuffer)
 871 {
 872     GLint bound_renderbuffer = 0;
 873     glGetIntegerv(GL_RENDERBUFFER_BINDING, &bound_renderbuffer);
 874     glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
 875
 876     GLint format = GL_NONE;
 877     glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_INTERNAL_FORMAT, &format);
 878
 879     glBindRenderbuffer(GL_RENDERBUFFER, bound_renderbuffer);
 880
 881     return format;
 882 }
 883
 884
 885 static bool
 886 getFramebufferAttachmentSize(GLenum target, GLenum attachment, GLint *width, GLint *height)
 887 {
 888     GLint object_type = GL_NONE;
 889     glGetFramebufferAttachmentParameteriv(target, attachment,
 890                                           GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
 891                                           &object_type);
 892     if (object_type == GL_NONE) {
 893         return false;
 894     }
 895
 896     GLint object_name = 0;
 897     glGetFramebufferAttachmentParameteriv(target, attachment,
 898                                           GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
 899                                           &object_name);
 900     if (object_name == 0) {
 901         return false;
 902     }
 903
 904     if (object_type == GL_RENDERBUFFER) {
 905         return getRenderbufferSize(object_name, width, height);
 906     } else if (object_type == GL_TEXTURE) {
 907         GLint texture_level = 0;
 908         glGetFramebufferAttachmentParameteriv(target, attachment,
 909                                               GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL,
 910                                               &texture_level);
 911         return getTextureLevelSize(object_name, texture_level, width, height);
 912     } else {
 913         std::cerr << "warning: unexpected GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = " << object_type << "\n";
 914         return false;
 915     }
 916 }
 917
 918
 919
 920 static GLint
 921 getFramebufferAttachmentFormat(GLenum target, GLenum attachment)
 922 {
 923     GLint object_type = GL_NONE;
 924     glGetFramebufferAttachmentParameteriv(target, attachment,
 925                                           GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
 926                                           &object_type);
 927     if (object_type == GL_NONE) {
 928         return GL_NONE;
 929     }
 930
 931     GLint object_name = 0;
 932     glGetFramebufferAttachmentParameteriv(target, attachment,
 933                                           GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
 934                                           &object_name);
 935     if (object_name == 0) {
 936         return GL_NONE;
 937     }
 938
 939     if (object_type == GL_RENDERBUFFER) {
 940         return getRenderbufferFormat(object_name);
 941     } else if (object_type == GL_TEXTURE) {
 942         GLint texture_level = 0;
 943         glGetFramebufferAttachmentParameteriv(target, attachment,
 944                                               GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL,
 945                                               &texture_level);
 946         return getTextureLevelFormat(object_name, texture_level);
 947     } else {
 948         std::cerr << "warning: unexpected GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = " << object_type << "\n";
 949         return GL_NONE;
 950     }
 951 }
 952
 953
 954
 955 image::Image *
 956 getDrawBufferImage() {
 957     GLenum format = GL_RGB;
 958     GLint channels = __gl_format_channels(format);
 959     if (channels > 4) {
 960         return NULL;
 961     }
 962
 963     GLint draw_framebuffer = 0;
 964     glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &draw_framebuffer);
 965
 966     GLint draw_buffer = GL_NONE;
 967     GLint width, height;
 968     if (draw_framebuffer) {
 969         glGetIntegerv(GL_DRAW_BUFFER0, &draw_buffer);
 970         if (draw_buffer == GL_NONE) {
 971             return NULL;
 972         }
 973
 974         if (!getFramebufferAttachmentSize(GL_DRAW_FRAMEBUFFER, draw_buffer, &width, &height)) {
 975             return NULL;
 976         }
 977     } else {
 978         glGetIntegerv(GL_DRAW_BUFFER, &draw_buffer);
 979         if (draw_buffer == GL_NONE) {
 980             return NULL;
 981         }
 982
 983         if (!getDrawableBounds(&width, &height)) {
 984             return NULL;
 985         }
 986     }
 987
 988     image::Image *image = new image::Image(width, height, channels, true);
 989     if (!image) {
 990         return NULL;
 991     }
 992
 993     while (glGetError() != GL_NO_ERROR) {}
 994
 995     GLint read_framebuffer = 0;
 996     glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &read_framebuffer);
 997     glBindFramebuffer(GL_READ_FRAMEBUFFER, draw_framebuffer);
 998
 999     GLint read_buffer = 0;
1000     glGetIntegerv(GL_READ_BUFFER, &read_buffer);
1001     glReadBuffer(draw_buffer);
1002
1003     // TODO: reset imaging state too
1004     resetPixelPackState();
1005
1006     glReadPixels(0, 0, width, height, format, GL_UNSIGNED_BYTE, image->pixels);
1007
1008     restorePixelPackState();
1009     glReadBuffer(read_buffer);
1010     glBindFramebuffer(GL_READ_FRAMEBUFFER, read_framebuffer);
1011
1012     GLenum error = glGetError();
1013     if (error != GL_NO_ERROR) {
1014         do {
1015             std::cerr << "warning: " << enumToString(error) << " while getting snapshot\n";
1016             error = glGetError();
1017         } while(error != GL_NO_ERROR);
1018         delete image;
1019         return NULL;
1020     }
1021
1022     return image;
1023 }
1024
1025
1026 /**
1027  * Dump the image of the currently bound read buffer.
1028  */
1029 static inline void
1030 dumpReadBufferImage(JSONWriter &json, GLint width, GLint height, GLenum format,
1031                     GLint internalFormat = GL_NONE)
1032 {
1033     GLint channels = __gl_format_channels(format);
1034
1035     json.beginObject();
1036
1037     // Tell the GUI this is no ordinary object, but an image
1038     json.writeStringMember("__class__", "image");
1039
1040     json.writeNumberMember("__width__", width);
1041     json.writeNumberMember("__height__", height);
1042     json.writeNumberMember("__depth__", 1);
1043
1044     json.writeStringMember("__format__", enumToString(internalFormat));
1045
1046     // Hardcoded for now, but we could chose types more adequate to the
1047     // texture internal format
1048     json.writeStringMember("__type__", "uint8");
1049     json.writeBoolMember("__normalized__", true);
1050     json.writeNumberMember("__channels__", channels);
1051
1052     GLubyte *pixels = new GLubyte[width*height*channels];
1053
1054     // TODO: reset imaging state too
1055     resetPixelPackState();
1056
1057     glReadPixels(0, 0, width, height, format, GL_UNSIGNED_BYTE, pixels);
1058
1059     restorePixelPackState();
1060
1061     json.beginMember("__data__");
1062     char *pngBuffer;
1063     int pngBufferSize;
1064     image::writePixelsToBuffer(pixels, width, height, channels, true, &pngBuffer, &pngBufferSize);
1065     //std::cerr <<" Before = "<<(width * height * channels * sizeof *pixels)
1066     //          <<", after = "<<pngBufferSize << ", ratio = " << double(width * height * channels * sizeof *pixels)/pngBufferSize;
1067     json.writeBase64(pngBuffer, pngBufferSize);
1068     free(pngBuffer);
1069     json.endMember(); // __data__
1070
1071     delete [] pixels;
1072     json.endObject();
1073 }
1074
1075
1076 static inline GLuint
1077 downsampledFramebuffer(GLuint oldFbo, GLint drawbuffer,
1078                        GLint colorRb, GLint depthRb, GLint stencilRb,
1079                        GLuint *rbs, GLint *numRbs)
1080 {
1081     GLuint fbo;
1082     GLint format;
1083     GLint w, h;
1084
1085     *numRbs = 0;
1086
1087     glGenFramebuffers(1, &fbo);
1088     glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1089
1090     glBindRenderbuffer(GL_RENDERBUFFER, colorRb);
1091     glGetRenderbufferParameteriv(GL_RENDERBUFFER,
1092                                  GL_RENDERBUFFER_WIDTH, &w);
1093     glGetRenderbufferParameteriv(GL_RENDERBUFFER,
1094                                  GL_RENDERBUFFER_HEIGHT, &h);
1095     glGetRenderbufferParameteriv(GL_RENDERBUFFER,
1096                                  GL_RENDERBUFFER_INTERNAL_FORMAT, &format);
1097
1098     glGenRenderbuffers(1, &rbs[*numRbs]);
1099     glBindRenderbuffer(GL_RENDERBUFFER, rbs[*numRbs]);
1100     glRenderbufferStorage(GL_RENDERBUFFER, format, w, h);
1101     glFramebufferRenderbuffer(GL_FRAMEBUFFER, drawbuffer,
1102                               GL_RENDERBUFFER, rbs[*numRbs]);
1103
1104     glBindFramebuffer(GL_READ_FRAMEBUFFER, oldFbo);
1105     glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
1106     glDrawBuffer(drawbuffer);
1107     glReadBuffer(drawbuffer);
1108     glBlitFramebuffer(0, 0, w, h, 0, 0, w, h,
1109                       GL_COLOR_BUFFER_BIT, GL_NEAREST);
1110     glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1111     ++*numRbs;
1112
1113     if (stencilRb == depthRb && stencilRb) {
1114         //combined depth and stencil buffer
1115         glBindRenderbuffer(GL_RENDERBUFFER, depthRb);
1116         glGetRenderbufferParameteriv(GL_RENDERBUFFER,
1117                                      GL_RENDERBUFFER_WIDTH, &w);
1118         glGetRenderbufferParameteriv(GL_RENDERBUFFER,
1119                                      GL_RENDERBUFFER_HEIGHT, &h);
1120         glGetRenderbufferParameteriv(GL_RENDERBUFFER,
1121                                      GL_RENDERBUFFER_INTERNAL_FORMAT, &format);
1122
1123         glGenRenderbuffers(1, &rbs[*numRbs]);
1124         glBindRenderbuffer(GL_RENDERBUFFER, rbs[*numRbs]);
1125         glRenderbufferStorage(GL_RENDERBUFFER, format, w, h);
1126         glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
1127                                   GL_RENDERBUFFER, rbs[*numRbs]);
1128         glBindFramebuffer(GL_READ_FRAMEBUFFER, oldFbo);
1129         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
1130         glBlitFramebuffer(0, 0, w, h, 0, 0, w, h,
1131                           GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_NEAREST);
1132         glBindFramebuffer(GL_FRAMEBUFFER, fbo);
1133         ++*numRbs;
1134     } else {
1135         if (depthRb) {
1136             glBindRenderbuffer(GL_RENDERBUFFER, depthRb);
1137             glGetRenderbufferParameteriv(GL_RENDERBUFFER,
1138                                          GL_RENDERBUFFER_WIDTH, &w);
1139             glGetRenderbufferParameteriv(GL_RENDERBUFFER,
1140                                          GL_RENDERBUFFER_HEIGHT, &h);
1141             glGetRenderbufferParameteriv(GL_RENDERBUFFER,
1142                                          GL_RENDERBUFFER_INTERNAL_FORMAT, &format);
1143
1144             glGenRenderbuffers(1, &rbs[*numRbs]);
1145             glBindRenderbuffer(GL_RENDERBUFFER, rbs[*numRbs]);
1146             glRenderbufferStorage(GL_RENDERBUFFER, format, w, h);
1147             glFramebufferRenderbuffer(GL_FRAMEBUFFER,
1148                                       GL_DEPTH_ATTACHMENT,
1149                                       GL_RENDERBUFFER, rbs[*numRbs]);
1150             glBindFramebuffer(GL_READ_FRAMEBUFFER, oldFbo);
1151             glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
1152             glDrawBuffer(GL_DEPTH_ATTACHMENT);
1153             glReadBuffer(GL_DEPTH_ATTACHMENT);
1154             glBlitFramebuffer(0, 0, w, h, 0, 0, w, h,
1155                               GL_DEPTH_BUFFER_BIT, GL_NEAREST);
1156             ++*numRbs;
1157         }
1158         if (stencilRb) {
1159             glBindRenderbuffer(GL_RENDERBUFFER, stencilRb);
1160             glGetRenderbufferParameteriv(GL_RENDERBUFFER,
1161                                          GL_RENDERBUFFER_WIDTH, &w);
1162             glGetRenderbufferParameteriv(GL_RENDERBUFFER,
1163                                          GL_RENDERBUFFER_HEIGHT, &h);
1164             glGetRenderbufferParameteriv(GL_RENDERBUFFER,
1165                                      GL_RENDERBUFFER_INTERNAL_FORMAT, &format);
1166
1167             glGenRenderbuffers(1, &rbs[*numRbs]);
1168             glBindRenderbuffer(GL_RENDERBUFFER, rbs[*numRbs]);
1169             glRenderbufferStorage(GL_RENDERBUFFER, format, w, h);
1170             glFramebufferRenderbuffer(GL_FRAMEBUFFER,
1171                                       GL_STENCIL_ATTACHMENT,
1172                                       GL_RENDERBUFFER, rbs[*numRbs]);
1173             glBindFramebuffer(GL_READ_FRAMEBUFFER, oldFbo);
1174             glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
1175             glDrawBuffer(GL_STENCIL_ATTACHMENT);
1176             glReadBuffer(GL_STENCIL_ATTACHMENT);
1177             glBlitFramebuffer(0, 0, w, h, 0, 0, w, h,
1178                               GL_STENCIL_BUFFER_BIT, GL_NEAREST);
1179             ++*numRbs;
1180         }
1181     }
1182
1183     return fbo;
1184 }
1185
1186
1187 /**
1188  * Dump images of current draw drawable/window.
1189  */
1190 static void
1191 dumpDrawableImages(JSONWriter &json)
1192 {
1193     GLint width, height;
1194
1195     if (!getDrawableBounds(&width, &height)) {
1196         return;
1197     }
1198
1199     GLint draw_buffer = GL_NONE;
1200     glGetIntegerv(GL_DRAW_BUFFER, &draw_buffer);
1201     glReadBuffer(draw_buffer);
1202
1203     if (draw_buffer != GL_NONE) {
1204         GLint read_buffer = GL_NONE;
1205         glGetIntegerv(GL_READ_BUFFER, &read_buffer);
1206
1207         GLint alpha_bits = 0;
1208 #if 0
1209         // XXX: Ignore alpha until we are able to match the traced visual
1210         glGetIntegerv(GL_ALPHA_BITS, &alpha_bits);
1211 #endif
1212         GLenum format = alpha_bits ? GL_RGBA : GL_RGB;
1213         json.beginMember(enumToString(draw_buffer));
1214         dumpReadBufferImage(json, width, height, format);
1215         json.endMember();
1216
1217         glReadBuffer(read_buffer);
1218     }
1219
1220     GLint depth_bits = 0;
1221     glGetIntegerv(GL_DEPTH_BITS, &depth_bits);
1222     if (depth_bits) {
1223         json.beginMember("GL_DEPTH_COMPONENT");
1224         dumpReadBufferImage(json, width, height, GL_DEPTH_COMPONENT);
1225         json.endMember();
1226     }
1227
1228     GLint stencil_bits = 0;
1229     glGetIntegerv(GL_STENCIL_BITS, &stencil_bits);
1230     if (stencil_bits) {
1231         json.beginMember("GL_STENCIL_INDEX");
1232         dumpReadBufferImage(json, width, height, GL_STENCIL_INDEX);
1233         json.endMember();
1234     }
1235 }
1236
1237
1238 /**
1239  * Dump the specified framebuffer attachment.
1240  *
1241  * In the case of a color attachment, it assumes it is already bound for read.
1242  */
1243 static void
1244 dumpFramebufferAttachment(JSONWriter &json, GLenum target, GLenum attachment, GLenum format)
1245 {
1246     GLint width = 0, height = 0;
1247     if (!getFramebufferAttachmentSize(target, attachment, &width, &height)) {
1248         return;
1249     }
1250
1251     GLint internalFormat = getFramebufferAttachmentFormat(target, attachment);
1252
1253     json.beginMember(enumToString(attachment));
1254     dumpReadBufferImage(json, width, height, format, internalFormat);
1255     json.endMember();
1256 }
1257
1258
1259 static void
1260 dumpFramebufferAttachments(JSONWriter &json, GLenum target)
1261 {
1262     GLint read_framebuffer = 0;
1263     glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &read_framebuffer);
1264
1265     GLint read_buffer = GL_NONE;
1266     glGetIntegerv(GL_READ_BUFFER, &read_buffer);
1267
1268     GLint max_draw_buffers = 1;
1269     glGetIntegerv(GL_MAX_DRAW_BUFFERS, &max_draw_buffers);
1270     GLint max_color_attachments = 0;
1271     glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &max_color_attachments);
1272
1273     for (GLint i = 0; i < max_draw_buffers; ++i) {
1274         GLint draw_buffer = GL_NONE;
1275         glGetIntegerv(GL_DRAW_BUFFER0 + i, &draw_buffer);
1276         if (draw_buffer != GL_NONE) {
1277             glReadBuffer(draw_buffer);
1278             GLint attachment;
1279             if (draw_buffer >= GL_COLOR_ATTACHMENT0 && draw_buffer < GL_COLOR_ATTACHMENT0 + max_color_attachments) {
1280                 attachment = draw_buffer;
1281             } else {
1282                 std::cerr << "warning: unexpected GL_DRAW_BUFFER" << i << " = " << draw_buffer << "\n";
1283                 attachment = GL_COLOR_ATTACHMENT0;
1284             }
1285             GLint alpha_size = 0;
1286             glGetFramebufferAttachmentParameteriv(target, attachment,
1287                                                   GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE,
1288                                                   &alpha_size);
1289             GLenum format = alpha_size ? GL_RGBA : GL_RGB;
1290             dumpFramebufferAttachment(json, target, attachment, format);
1291         }
1292     }
1293
1294     glReadBuffer(read_buffer);
1295
1296     dumpFramebufferAttachment(json, target, GL_DEPTH_ATTACHMENT, GL_DEPTH_COMPONENT);
1297     dumpFramebufferAttachment(json, target, GL_STENCIL_ATTACHMENT, GL_STENCIL_INDEX);
1298
1299     glBindFramebuffer(GL_READ_FRAMEBUFFER, read_framebuffer);
1300 }
1301
1302
1303 static void
1304 dumpFramebuffer(JSONWriter &json)
1305 {
1306     json.beginMember("framebuffer");
1307     json.beginObject();
1308
1309     GLint boundDrawFbo = 0, boundReadFbo = 0;
1310     glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &boundDrawFbo);
1311     glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &boundReadFbo);
1312     if (!boundDrawFbo) {
1313         dumpDrawableImages(json);
1314     } else {
1315         GLint colorRb = 0, stencilRb = 0, depthRb = 0;
1316         GLint draw_buffer0 = GL_NONE;
1317         glGetIntegerv(GL_DRAW_BUFFER0, &draw_buffer0);
1318         bool multisample = false;
1319
1320         GLint boundRb = 0;
1321         glGetIntegerv(GL_RENDERBUFFER_BINDING, &boundRb);
1322
1323         GLint object_type;
1324         glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, draw_buffer0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &object_type);
1325         if (object_type == GL_RENDERBUFFER) {
1326             glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, draw_buffer0, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &colorRb);
1327             glBindRenderbuffer(GL_RENDERBUFFER, colorRb);
1328             GLint samples = 0;
1329             glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, &samples);
1330             if (samples) {
1331                 multisample = true;
1332             }
1333         }
1334
1335         glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &object_type);
1336         if (object_type == GL_RENDERBUFFER) {
1337             glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &depthRb);
1338             glBindRenderbuffer(GL_RENDERBUFFER, depthRb);
1339             GLint samples = 0;
1340             glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, &samples);
1341             if (samples) {
1342                 multisample = true;
1343             }
1344         }
1345
1346         glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &object_type);
1347         if (object_type == GL_RENDERBUFFER) {
1348             glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &stencilRb);
1349             glBindRenderbuffer(GL_RENDERBUFFER, stencilRb);
1350             GLint samples = 0;
1351             glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, &samples);
1352             if (samples) {
1353                 multisample = true;
1354             }
1355         }
1356
1357         glBindRenderbuffer(GL_RENDERBUFFER, boundRb);
1358
1359         GLuint rbs[3];
1360         GLint numRbs = 0;
1361         GLuint fboCopy = 0;
1362
1363         if (multisample) {
1364             // glReadPixels doesnt support multisampled buffers so we need
1365             // to blit the fbo to a temporary one
1366             fboCopy = downsampledFramebuffer(boundDrawFbo, draw_buffer0,
1367                                              colorRb, depthRb, stencilRb,
1368                                              rbs, &numRbs);
1369         }
1370
1371         dumpFramebufferAttachments(json, GL_DRAW_FRAMEBUFFER);
1372
1373         if (multisample) {
1374             glBindRenderbuffer(GL_RENDERBUFFER_BINDING, boundRb);
1375             glDeleteRenderbuffers(numRbs, rbs);
1376             glDeleteFramebuffers(1, &fboCopy);
1377         }
1378
1379         glBindFramebuffer(GL_READ_FRAMEBUFFER, boundReadFbo);
1380         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, boundDrawFbo);
1381     }
1382
1383     json.endObject();
1384     json.endMember(); // framebuffer
1385 }
1386
1387
1388 static const GLenum bindings[] = {
1389     GL_DRAW_BUFFER,
1390     GL_READ_BUFFER,
1391     GL_PIXEL_PACK_BUFFER_BINDING,
1392     GL_PIXEL_UNPACK_BUFFER_BINDING,
1393     GL_TEXTURE_BINDING_1D,
1394     GL_TEXTURE_BINDING_2D,
1395     GL_TEXTURE_BINDING_3D,
1396     GL_TEXTURE_BINDING_RECTANGLE,
1397     GL_TEXTURE_BINDING_CUBE_MAP,
1398     GL_DRAW_FRAMEBUFFER_BINDING,
1399     GL_READ_FRAMEBUFFER_BINDING,
1400     GL_RENDERBUFFER_BINDING,
1401     GL_DRAW_BUFFER0,
1402     GL_DRAW_BUFFER1,
1403     GL_DRAW_BUFFER2,
1404     GL_DRAW_BUFFER3,
1405     GL_DRAW_BUFFER4,
1406     GL_DRAW_BUFFER5,
1407     GL_DRAW_BUFFER6,
1408     GL_DRAW_BUFFER7,
1409 };
1410
1411
1412 #define NUM_BINDINGS sizeof(bindings)/sizeof(bindings[0])
1413
1414
1415 void dumpCurrentContext(std::ostream &os)
1416 {
1417     JSONWriter json(os);
1418
1419 #ifndef NDEBUG
1420     GLint old_bindings[NUM_BINDINGS];
1421     for (unsigned i = 0; i < NUM_BINDINGS; ++i) {
1422         old_bindings[i] = 0;
1423         glGetIntegerv(bindings[i], &old_bindings[i]);
1424     }
1425 #endif
1426
1427     dumpParameters(json);
1428     dumpShadersUniforms(json);
1429     dumpTextures(json);
1430     dumpFramebuffer(json);
1431
1432 #ifndef NDEBUG
1433     for (unsigned i = 0; i < NUM_BINDINGS; ++i) {
1434         GLint new_binding = 0;
1435         glGetIntegerv(bindings[i], &new_binding);
1436         if (new_binding != old_bindings[i]) {
1437             std::cerr << "warning: " << enumToString(bindings[i]) << " was clobbered\n";
1438         }
1439     }
1440 #endif
1441
1442 }
1443
1444
1445 } /* namespace glstate */