X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=glstate.py;h=b54634e64efcd84985fae582cf0b4f2d27a638cb;hb=cefdd197f2f20d8afdbcac6e93680ac9aa8c0351;hp=538b808515ad1734317b7733ee9f1b8cd5b39687;hpb=dfdede4915ba744cfb3e8b8a6b9a22e32b4ba2d7;p=apitrace diff --git a/glstate.py b/glstate.py index 538b808..b54634e 100644 --- a/glstate.py +++ b/glstate.py @@ -26,17 +26,17 @@ from stdapi import * -from glenum import GLenum +from glapi import * X = None # To be determined -B = Bool -I = Int +B = GLboolean +I = GLint E = GLenum -F = Float -D = Double +F = GLfloat +D = GLdouble P = OpaquePointer(Void) -S = String +S = CString # TODO: This table and the one on glenum.py should be unified parameters = [ @@ -320,18 +320,18 @@ parameters = [ ("glGet", I, 1, "GL_MAP1_GRID_SEGMENTS"), # 0x0DD1 ("glGet", F, 4, "GL_MAP2_GRID_DOMAIN"), # 0x0DD2 ("glGet", I, 2, "GL_MAP2_GRID_SEGMENTS"), # 0x0DD3 - ("glGet", I, 1, "GL_TEXTURE_1D"), # 0x0DE0 - ("glGet", I, 1, "GL_TEXTURE_2D"), # 0x0DE1 + ("glGet", B, 1, "GL_TEXTURE_1D"), # 0x0DE0 + ("glGet", B, 1, "GL_TEXTURE_2D"), # 0x0DE1 ("glGet", P, 1, "GL_FEEDBACK_BUFFER_POINTER"), # 0x0DF0 ("glGet", I, 1, "GL_FEEDBACK_BUFFER_SIZE"), # 0x0DF1 - ("glGet", I, 1, "GL_FEEDBACK_BUFFER_TYPE"), # 0x0DF2 + ("glGet", E, 1, "GL_FEEDBACK_BUFFER_TYPE"), # 0x0DF2 ("glGet", P, 1, "GL_SELECTION_BUFFER_POINTER"), # 0x0DF3 ("glGet", I, 1, "GL_SELECTION_BUFFER_SIZE"), # 0x0DF4 - ("glGet", X, 1, "GL_TEXTURE_WIDTH"), # 0x1000 - ("glGet", X, 1, "GL_TEXTURE_HEIGHT"), # 0x1001 - ("glGet", X, 1, "GL_TEXTURE_INTERNAL_FORMAT"), # 0x1003 - ("glGet", X, 1, "GL_TEXTURE_BORDER_COLOR"), # 0x1004 - ("glGet", X, 1, "GL_TEXTURE_BORDER"), # 0x1005 + ("glGetTexLevelParameter", I, 1, "GL_TEXTURE_WIDTH"), # 0x1000 + ("glGetTexLevelParameter", I, 1, "GL_TEXTURE_HEIGHT"), # 0x1001 + ("glGetTexLevelParameter", E, 1, "GL_TEXTURE_INTERNAL_FORMAT"), # 0x1003 + ("glGetTexParameter", F, 4, "GL_TEXTURE_BORDER_COLOR"), # 0x1004 + ("glGetTexLevelParameter", I, 1, "GL_TEXTURE_BORDER"), # 0x1005 ("glGet", X, 1, "GL_DONT_CARE"), # 0x1100 ("glGet", X, 1, "GL_FASTEST"), # 0x1101 ("glGet", X, 1, "GL_NICEST"), # 0x1102 @@ -462,10 +462,10 @@ parameters = [ ("glGet", X, 1, "GL_LINEAR_MIPMAP_NEAREST"), # 0x2701 ("glGet", X, 1, "GL_NEAREST_MIPMAP_LINEAR"), # 0x2702 ("glGet", X, 1, "GL_LINEAR_MIPMAP_LINEAR"), # 0x2703 - ("glGet", X, 1, "GL_TEXTURE_MAG_FILTER"), # 0x2800 - ("glGet", X, 1, "GL_TEXTURE_MIN_FILTER"), # 0x2801 - ("glGet", X, 1, "GL_TEXTURE_WRAP_S"), # 0x2802 - ("glGet", X, 1, "GL_TEXTURE_WRAP_T"), # 0x2803 + ("glGetTexParameter", E, 1, "GL_TEXTURE_MAG_FILTER"), # 0x2800 + ("glGetTexParameter", E, 1, "GL_TEXTURE_MIN_FILTER"), # 0x2801 + ("glGetTexParameter", E, 1, "GL_TEXTURE_WRAP_S"), # 0x2802 + ("glGetTexParameter", E, 1, "GL_TEXTURE_WRAP_T"), # 0x2803 ("glGet", X, 1, "GL_CLAMP"), # 0x2900 ("glGet", X, 1, "GL_REPEAT"), # 0x2901 ("glGet", F, 1, "GL_POLYGON_OFFSET_UNITS"), # 0x2A00 @@ -594,18 +594,18 @@ parameters = [ ("glGet", X, 1, "GL_RGB10_A2"), # 0x8059 ("glGet", X, 1, "GL_RGBA12"), # 0x805A ("glGet", X, 1, "GL_RGBA16"), # 0x805B - ("glGet", X, 1, "GL_TEXTURE_RED_SIZE"), # 0x805C - ("glGet", X, 1, "GL_TEXTURE_GREEN_SIZE"), # 0x805D - ("glGet", X, 1, "GL_TEXTURE_BLUE_SIZE"), # 0x805E - ("glGet", X, 1, "GL_TEXTURE_ALPHA_SIZE"), # 0x805F - ("glGet", X, 1, "GL_TEXTURE_LUMINANCE_SIZE"), # 0x8060 - ("glGet", X, 1, "GL_TEXTURE_INTENSITY_SIZE"), # 0x8061 + ("glGetTexLevelParameter", I, 1, "GL_TEXTURE_RED_SIZE"), # 0x805C + ("glGetTexLevelParameter", I, 1, "GL_TEXTURE_GREEN_SIZE"), # 0x805D + ("glGetTexLevelParameter", I, 1, "GL_TEXTURE_BLUE_SIZE"), # 0x805E + ("glGetTexLevelParameter", I, 1, "GL_TEXTURE_ALPHA_SIZE"), # 0x805F + ("glGetTexLevelParameter", I, 1, "GL_TEXTURE_LUMINANCE_SIZE"), # 0x8060 + ("glGetTexLevelParameter", I, 1, "GL_TEXTURE_INTENSITY_SIZE"), # 0x8061 ("glGet", X, 1, "GL_REPLACE_EXT"), # 0x8062 ("glGet", X, 1, "GL_PROXY_TEXTURE_1D"), # 0x8063 ("glGet", X, 1, "GL_PROXY_TEXTURE_2D"), # 0x8064 ("glGet", X, 1, "GL_TEXTURE_TOO_LARGE_EXT"), # 0x8065 - ("glGet", X, 1, "GL_TEXTURE_PRIORITY"), # 0x8066 - ("glGet", X, 1, "GL_TEXTURE_RESIDENT"), # 0x8067 + ("glGetTexParameter", I, 1, "GL_TEXTURE_PRIORITY"), # 0x8066 + ("glGetTexParameter", B, 1, "GL_TEXTURE_RESIDENT"), # 0x8067 ("glGet", I, 1, "GL_TEXTURE_BINDING_1D"), # 0x8068 ("glGet", I, 1, "GL_TEXTURE_BINDING_2D"), # 0x8069 ("glGet", I, 1, "GL_TEXTURE_BINDING_3D"), # 0x806A @@ -613,10 +613,10 @@ parameters = [ ("glGet", F, 1, "GL_PACK_IMAGE_HEIGHT"), # 0x806C ("glGet", I, 1, "GL_UNPACK_SKIP_IMAGES"), # 0x806D ("glGet", F, 1, "GL_UNPACK_IMAGE_HEIGHT"), # 0x806E - ("glGet", I, 1, "GL_TEXTURE_3D"), # 0x806F + ("glGet", B, 1, "GL_TEXTURE_3D"), # 0x806F ("glGet", X, 1, "GL_PROXY_TEXTURE_3D"), # 0x8070 - ("glGet", X, 1, "GL_TEXTURE_DEPTH"), # 0x8071 - ("glGet", X, 1, "GL_TEXTURE_WRAP_R"), # 0x8072 + ("glGetTexLevelParameter", I, 1, "GL_TEXTURE_DEPTH"), # 0x8071 + ("glGetTexParameter", E, 1, "GL_TEXTURE_WRAP_R"), # 0x8072 ("glGet", I, 1, "GL_MAX_3D_TEXTURE_SIZE"), # 0x8073 ("glGet", B, 1, "GL_VERTEX_ARRAY"), # 0x8074 ("glGet", B, 1, "GL_NORMAL_ARRAY"), # 0x8075 @@ -775,10 +775,10 @@ parameters = [ ("glGet", X, 1, "GL_TEXTURE_WRAP_Q_SGIS"), # 0x8137 ("glGet", I, 1, "GL_MAX_4D_TEXTURE_SIZE_SGIS"), # 0x8138 ("glGet", I, 1, "GL_PIXEL_TEX_GEN_SGIX"), # 0x8139 - ("glGet", X, 1, "GL_TEXTURE_MIN_LOD"), # 0x813A - ("glGet", X, 1, "GL_TEXTURE_MAX_LOD"), # 0x813B - ("glGet", X, 1, "GL_TEXTURE_BASE_LEVEL"), # 0x813C - ("glGet", X, 1, "GL_TEXTURE_MAX_LEVEL"), # 0x813D + ("glGetTexParameter", F, 1, "GL_TEXTURE_MIN_LOD"), # 0x813A + ("glGetTexParameter", F, 1, "GL_TEXTURE_MAX_LOD"), # 0x813B + ("glGetTexParameter", F, 1, "GL_TEXTURE_BASE_LEVEL"), # 0x813C + ("glGetTexParameter", F, 1, "GL_TEXTURE_MAX_LEVEL"), # 0x813D ("glGet", I, 1, "GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX"), # 0x813E ("glGet", I, 1, "GL_PIXEL_TILE_CACHE_INCREMENT_SGIX"), # 0x813F ("glGet", I, 1, "GL_PIXEL_TILE_WIDTH_SGIX"), # 0x8140 @@ -854,7 +854,7 @@ parameters = [ ("glGet", X, 1, "GL_TEXTURE_LOD_BIAS_S_SGIX"), # 0x818E ("glGet", X, 1, "GL_TEXTURE_LOD_BIAS_T_SGIX"), # 0x818F ("glGet", X, 1, "GL_TEXTURE_LOD_BIAS_R_SGIX"), # 0x8190 - ("glGet", X, 1, "GL_GENERATE_MIPMAP"), # 0x8191 + ("glGetTexParameter", B, 1, "GL_GENERATE_MIPMAP"), # 0x8191 ("glGet", E, 1, "GL_GENERATE_MIPMAP_HINT"), # 0x8192 ("glGet", X, 1, "GL_GEOMETRY_DEFORMATION_SGIX"), # 0x8194 ("glGet", X, 1, "GL_TEXTURE_DEFORMATION_SGIX"), # 0x8195 @@ -980,7 +980,7 @@ parameters = [ ("glGet", X, 1, "GL_RESET_NOTIFICATION_STRATEGY_ARB"), # 0x8256 ("glGet", X, 1, "GL_PROGRAM_BINARY_RETRIEVABLE_HINT"), # 0x8257 ("glGet", X, 1, "GL_PROGRAM_SEPARABLE"), # 0x8258 - ("glGet", X, 1, "GL_ACTIVE_PROGRAM"), # 0x8259 + ("glGet", I, 1, "GL_ACTIVE_PROGRAM"), # 0x8259 ("glGet", I, 1, "GL_PROGRAM_PIPELINE_BINDING"), # 0x825A ("glGet", X, 1, "GL_MAX_VIEWPORTS"), # 0x825B ("glGet", X, 1, "GL_VIEWPORT_SUBPIXEL_BITS"), # 0x825C @@ -1199,7 +1199,7 @@ parameters = [ ("glGet", X, 1, "GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT"), # 0x8510 ("glGet", X, 1, "GL_NORMAL_MAP"), # 0x8511 ("glGet", X, 1, "GL_REFLECTION_MAP"), # 0x8512 - ("glGet", X, 1, "GL_TEXTURE_CUBE_MAP"), # 0x8513 + ("glGet", B, 1, "GL_TEXTURE_CUBE_MAP"), # 0x8513 ("glGet", X, 1, "GL_TEXTURE_BINDING_CUBE_MAP"), # 0x8514 ("glGet", X, 1, "GL_TEXTURE_CUBE_MAP_POSITIVE_X"), # 0x8515 ("glGet", X, 1, "GL_TEXTURE_CUBE_MAP_NEGATIVE_X"), # 0x8516 @@ -1346,7 +1346,7 @@ parameters = [ ("glGet", X, 1, "GL_SLICE_ACCUM_SUN"), # 0x85CC ("glGet", X, 1, "GL_QUAD_MESH_SUN"), # 0x8614 ("glGet", X, 1, "GL_TRIANGLE_MESH_SUN"), # 0x8615 - ("glGet", X, 1, "GL_VERTEX_PROGRAM_ARB"), # 0x8620 + ("glGet", B, 1, "GL_VERTEX_PROGRAM_ARB"), # 0x8620 ("glGet", X, 1, "GL_VERTEX_STATE_PROGRAM_NV"), # 0x8621 ("glGetVertexAttrib", B, 1, "GL_VERTEX_ATTRIB_ARRAY_ENABLED"), # 0x8622 ("glGetVertexAttrib", I, 1, "GL_VERTEX_ATTRIB_ARRAY_SIZE"), # 0x8623 @@ -1360,8 +1360,8 @@ parameters = [ ("glGet", X, 1, "GL_INVERSE_NV"), # 0x862B ("glGet", X, 1, "GL_TRANSPOSE_NV"), # 0x862C ("glGet", X, 1, "GL_INVERSE_TRANSPOSE_NV"), # 0x862D - ("glGet", X, 1, "GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB"), # 0x862E - ("glGet", X, 1, "GL_MAX_PROGRAM_MATRICES_ARB"), # 0x862F + ("glGet", I, 1, "GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB"), # 0x862E + ("glGet", I, 1, "GL_MAX_PROGRAM_MATRICES_ARB"), # 0x862F ("glGet", X, 1, "GL_MATRIX0_NV"), # 0x8630 ("glGet", X, 1, "GL_MATRIX1_NV"), # 0x8631 ("glGet", X, 1, "GL_MATRIX2_NV"), # 0x8632 @@ -1372,8 +1372,8 @@ parameters = [ ("glGet", X, 1, "GL_MATRIX7_NV"), # 0x8637 ("glGet", X, 1, "GL_CURRENT_MATRIX_STACK_DEPTH_ARB"), # 0x8640 ("glGet", X, 1, "GL_CURRENT_MATRIX_ARB"), # 0x8641 - ("glGet", X, 1, "GL_VERTEX_PROGRAM_POINT_SIZE"), # 0x8642 - ("glGet", X, 1, "GL_VERTEX_PROGRAM_TWO_SIDE"), # 0x8643 + ("glGet", B, 1, "GL_VERTEX_PROGRAM_POINT_SIZE"), # 0x8642 + ("glGet", B, 1, "GL_VERTEX_PROGRAM_TWO_SIDE"), # 0x8643 ("glGet", X, 1, "GL_PROGRAM_PARAMETER_NV"), # 0x8644 ("glGetVertexAttrib", P, 1, "GL_VERTEX_ATTRIB_ARRAY_POINTER"), # 0x8645 ("glGet", X, 1, "GL_PROGRAM_TARGET_NV"), # 0x8646 @@ -1435,7 +1435,7 @@ parameters = [ ("glGet", X, 1, "GL_MAP2_VERTEX_ATTRIB14_4_NV"), # 0x867E ("glGet", X, 1, "GL_MAP2_VERTEX_ATTRIB15_4_NV"), # 0x867F ("glGet", X, 1, "GL_TEXTURE_COMPRESSED_IMAGE_SIZE"), # 0x86A0 - ("glGet", X, 1, "GL_TEXTURE_COMPRESSED"), # 0x86A1 + ("glGetTexLevelParameter", B, 1, "GL_TEXTURE_COMPRESSED"), # 0x86A1 ("glGet", X, 1, "GL_NUM_COMPRESSED_TEXTURE_FORMATS"), # 0x86A2 #XXX: the list is GL_NUM_COMPRESSED_TEXTURES #("glGet", E, 1, "GL_COMPRESSED_TEXTURE_FORMATS"), # 0x86A3 @@ -1754,7 +1754,7 @@ parameters = [ ("glGet", E, 1, "GL_STENCIL_BACK_FAIL"), # 0x8801 ("glGet", E, 1, "GL_STENCIL_BACK_PASS_DEPTH_FAIL"), # 0x8802 ("glGet", E, 1, "GL_STENCIL_BACK_PASS_DEPTH_PASS"), # 0x8803 - ("glGet", X, 1, "GL_FRAGMENT_PROGRAM_ARB"), # 0x8804 + ("glGet", B, 1, "GL_FRAGMENT_PROGRAM_ARB"), # 0x8804 ("glGet", X, 1, "GL_PROGRAM_ALU_INSTRUCTIONS_ARB"), # 0x8805 ("glGet", X, 1, "GL_PROGRAM_TEX_INSTRUCTIONS_ARB"), # 0x8806 ("glGet", X, 1, "GL_PROGRAM_TEX_INDIRECTIONS_ARB"), # 0x8807 @@ -1809,11 +1809,11 @@ parameters = [ ("glGet", E, 1, "GL_MATRIX_INDEX_ARRAY_TYPE_ARB"), # 0x8847 ("glGet", X, 1, "GL_MATRIX_INDEX_ARRAY_STRIDE_ARB"), # 0x8848 ("glGet", X, 1, "GL_MATRIX_INDEX_ARRAY_POINTER_ARB"), # 0x8849 - ("glGet", X, 1, "GL_TEXTURE_DEPTH_SIZE"), # 0x884A - ("glGet", X, 1, "GL_DEPTH_TEXTURE_MODE"), # 0x884B - ("glGet", X, 1, "GL_TEXTURE_COMPARE_MODE"), # 0x884C - ("glGet", X, 1, "GL_TEXTURE_COMPARE_FUNC"), # 0x884D - ("glGet", X, 1, "GL_COMPARE_R_TO_TEXTURE"), # 0x884E + ("glGetTexLevelParameter", I, 1, "GL_TEXTURE_DEPTH_SIZE"), # 0x884A + ("glGetTexParameter", E, 1, "GL_DEPTH_TEXTURE_MODE"), # 0x884B + ("glGetTexParameter", E, 1, "GL_TEXTURE_COMPARE_MODE"), # 0x884C + ("glGetTexParameter", E, 1, "GL_TEXTURE_COMPARE_FUNC"), # 0x884D + (None, X, 1, "GL_COMPARE_R_TO_TEXTURE"), # 0x884E ("glGet", X, 1, "GL_TEXTURE_CUBE_MAP_SEAMLESS"), # 0x884F ("glGet", X, 1, "GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV"), # 0x8850 ("glGet", X, 1, "GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV"), # 0x8851 @@ -1847,10 +1847,10 @@ parameters = [ ("glGet", X, 1, "GL_DEPTH_STENCIL_TO_RGBA_NV"), # 0x886E ("glGet", X, 1, "GL_DEPTH_STENCIL_TO_BGRA_NV"), # 0x886F ("glGet", X, 1, "GL_FRAGMENT_PROGRAM_NV"), # 0x8870 - ("glGet", X, 1, "GL_MAX_TEXTURE_COORDS"), # 0x8871 - ("glGet", X, 1, "GL_MAX_TEXTURE_IMAGE_UNITS"), # 0x8872 + ("glGet", I, 1, "GL_MAX_TEXTURE_COORDS"), # 0x8871 + ("glGet", I, 1, "GL_MAX_TEXTURE_IMAGE_UNITS"), # 0x8872 ("glGet", I, 1, "GL_FRAGMENT_PROGRAM_BINDING_NV"), # 0x8873 - ("glGet", X, 1, "GL_PROGRAM_ERROR_STRING_ARB"), # 0x8874 + ("glGet", S, 1, "GL_PROGRAM_ERROR_STRING_ARB"), # 0x8874 ("glGet", X, 1, "GL_PROGRAM_FORMAT_ASCII_ARB"), # 0x8875 ("glGet", X, 1, "GL_PROGRAM_FORMAT_ARB"), # 0x8876 ("glGet", X, 1, "GL_WRITE_PIXEL_DATA_RANGE_NV"), # 0x8878 @@ -2178,7 +2178,7 @@ parameters = [ ("glGet", I, 1, "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS"), # 0x8B4C ("glGet", I, 1, "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS"), # 0x8B4D ("glGet", E, 1, "GL_OBJECT_TYPE_ARB"), # 0x8B4E - ("glGet", E, 1, "GL_SHADER_TYPE"), # 0x8B4F + ("glGetShader", E, 1, "GL_SHADER_TYPE"), # 0x8B4F ("glGet", X, 1, "GL_FLOAT_VEC2"), # 0x8B50 ("glGet", X, 1, "GL_FLOAT_VEC3"), # 0x8B51 ("glGet", X, 1, "GL_FLOAT_VEC4"), # 0x8B52 @@ -2214,12 +2214,12 @@ parameters = [ ("glGet", X, 1, "GL_ATTACHED_SHADERS"), # 0x8B85 ("glGet", X, 1, "GL_ACTIVE_UNIFORMS"), # 0x8B86 ("glGet", X, 1, "GL_ACTIVE_UNIFORM_MAX_LENGTH"), # 0x8B87 - ("glGet", X, 1, "GL_SHADER_SOURCE_LENGTH"), # 0x8B88 + ("glGetShader", I, 1, "GL_SHADER_SOURCE_LENGTH"), # 0x8B88 ("glGet", X, 1, "GL_ACTIVE_ATTRIBUTES"), # 0x8B89 ("glGet", X, 1, "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH"), # 0x8B8A ("glGet", X, 1, "GL_FRAGMENT_SHADER_DERIVATIVE_HINT"), # 0x8B8B ("glGet", X, 1, "GL_SHADING_LANGUAGE_VERSION"), # 0x8B8C - ("glGet", X, 1, "GL_CURRENT_PROGRAM"), # 0x8B8D + ("glGet", I, 1, "GL_CURRENT_PROGRAM"), # 0x8B8D ("glGet", X, 1, "GL_IMPLEMENTATION_COLOR_READ_TYPE"), # 0x8B9A ("glGet", X, 1, "GL_IMPLEMENTATION_COLOR_READ_FORMAT"), # 0x8B9B ("glGet", X, 1, "GL_COUNTER_TYPE_AMD"), # 0x8BC0 @@ -2829,9 +2829,142 @@ parameters = [ (None, X, 1, "GL_INVALID_INDEX"), # 0xFFFFFFFFu ] +texture_targets = [ + ('GL_TEXTURE_1D', 'GL_TEXTURE_BINDING_1D'), + ('GL_TEXTURE_2D', 'GL_TEXTURE_BINDING_2D'), + ('GL_TEXTURE_3D', 'GL_TEXTURE_BINDING_3D'), + #(GL_TEXTURE_CUBE_MAP, 'GL_TEXTURE_BINDING_CUBE_MAP') +] + + +class GetInflector: + '''Objects that describes how to inflect.''' + + reduced_types = { + B: I, + E: I, + I: F, + } + + def __init__(self, radical, suffixes): + self.radical = radical + self.suffixes = suffixes + + def reduced_type(self, type): + if type in self.suffixes: + return type + if type in self.reduced_types: + return self.reduced_type(self.reduced_types[type]) + raise NotImplementedError + + def inflect(self, type): + return self.radical + self.suffix(type) + + def suffix(self, type): + type = self.reduced_type(type) + assert type in self.suffixes + return self.suffixes[type] + -class ParamDumper(Visitor): - '''Dump an instance.''' +class StateGetter(Visitor): + '''Type visitor that is able to extract the state via one of the glGet* + functions. + + It will declare any temporary variable + ''' + + def __init__(self, radical, suffixes): + self.inflector = GetInflector(radical, suffixes) + + def __call__(self, *args): + pname = args[-1] + + for function, type, count, name in parameters: + if type is X: + continue + if name == pname: + if count != 1: + type = Array(type, str(count)) + + return type, self.visit(type, args) + + raise NotImplementedError + + def temp_name(self, args): + '''Return the name of a temporary variable to hold the state.''' + pname = args[-1] + + return pname[3:].lower() + + def visit_const(self, const, args): + return self.visit(const.type, args) + + def visit_scalar(self, type, args): + temp_name = self.temp_name(args) + elem_type = self.inflector.reduced_type(type) + inflection = self.inflector.inflect(type) + if inflection.endswith('v'): + print ' %s %s = 0;' % (elem_type, temp_name) + print ' %s(%s, &%s);' % (inflection, ', '.join(args), temp_name) + else: + print ' %s %s = %s(%s);' % (elem_type, temp_name, inflection, ', '.join(args)) + return temp_name + + def visit_string(self, string, args): + temp_name = self.temp_name(args) + inflection = self.inflector.inflect(string) + assert not inflection.endswith('v') + print ' %s %s = (%s)%s(%s);' % (string, temp_name, string, inflection, ', '.join(args)) + return temp_name + + def visit_alias(self, alias, args): + return self.visit_scalar(alias, args) + + def visit_enum(self, enum, args): + return self.visit(GLint, args) + + def visit_bitmask(self, bitmask, args): + return self.visit(GLint, args) + + def visit_array(self, array, args): + temp_name = self.temp_name(args) + if array.length == '1': + return self.visit(array.type) + elem_type = self.inflector.reduced_type(array.type) + inflection = self.inflector.inflect(array.type) + assert inflection.endswith('v') + print ' %s %s[%s];' % (elem_type, temp_name, array.length) + print ' memset(%s, 0, %s * sizeof *%s);' % (temp_name, array.length, temp_name) + print ' %s(%s, %s);' % (inflection, ', '.join(args), temp_name) + return temp_name + + def visit_opaque(self, pointer, args): + temp_name = self.temp_name(args) + inflection = self.inflector.inflect(pointer) + assert inflection.endswith('v') + print ' GLvoid *%s;' % temp_name + print ' %s(%s, &%s);' % (inflection, ', '.join(args), temp_name) + return temp_name + + +glGet = StateGetter('glGet', { + B: 'Booleanv', + I: 'Integerv', + F: 'Floatv', + D: 'Doublev', + S: 'String', + P: 'Pointerv', +}) + +glGetVertexAttrib = StateGetter('glGetVertexAttrib', {I: 'iv', F: 'fv', D: 'dv', P: 'Pointerv'}) +glGetTexParameter = StateGetter('glGetTexParameter', {I: 'iv', F: 'fv'}) + + +class JsonWriter(Visitor): + '''Type visitor that will dump a value of the specified type through the + JSON writer. + + It expects a previously declared JSONWriter instance named "json".''' def visit_literal(self, literal, instance): if literal.format == 'Bool': @@ -2846,7 +2979,10 @@ class ParamDumper(Visitor): print ' json.writeString((const char *)%s);' % instance def visit_enum(self, enum, instance): - raise NotImplementedError + if enum.expr == 'GLenum': + print ' writeEnum(json, %s);' % instance + else: + print ' json.writeNumber(%s);' % instance def visit_bitmask(self, bitmask, instance): raise NotImplementedError @@ -2854,8 +2990,25 @@ class ParamDumper(Visitor): def visit_alias(self, alias, instance): self.visit(alias.type, instance) + def visit_opaque(self, opaque, instance): + print ' json.writeNumber((size_t)%s);' % instance + + __index = 0 + + def visit_array(self, array, instance): + index = '__i%u' % JsonWriter.__index + JsonWriter.__index += 1 + print ' json.beginArray();' + print ' for (unsigned %s = 0; %s < %s; ++%s) {' % (index, index, array.length, index) + self.visit(array.type, '%s[%s]' % (instance, index)) + print ' }' + print ' json.endArray();' + + class StateDumper: + '''Class to generate code to dump all GL state in JSON format via + stdout.''' def __init__(self): self.level = 0 @@ -2866,100 +3019,415 @@ class StateDumper: print print '#include "json.hpp"' print '#include "glimports.hpp"' - print '#include "glstate.hpp"' + print '#include "glproc.hpp"' + print '#include "glsize.hpp"' + print '#include "glretrace.hpp"' print - print 'static inline void' - print 'writeEnum(JSONWriter &json, GLenum pname)' + print 'static const char *' + print '_enum_string(GLenum pname)' print '{' print ' switch(pname) {' - for function, type, count, name in parameters: + for name in GLenum.values: print ' case %s:' % name - print ' json.writeString("%s");' % name - print ' break;' + print ' return "%s";' % name print ' default:' + print ' return NULL;' + print ' }' + print '}' + print + + print 'static const char *' + print 'enum_string(GLenum pname)' + print '{' + print ' const char *s = _enum_string(pname);' + print ' if (s) {' + print ' return s;' + print ' } else {' + print ' static char buf[16];' + print ' snprintf(buf, sizeof buf, "0x%04x", pname);' + print ' return buf;' + print ' }' + print '}' + print + + print 'static inline void' + print 'writeEnum(JSONWriter &json, GLenum pname)' + print '{' + print ' const char *s = _enum_string(pname);' + print ' if (s) {' + print ' json.writeString(s);' + print ' } else {' print ' json.writeNumber(pname);' print ' }' print '}' print - print 'void state_dump(std::ostream &os)' + # shaders + print ''' +static void +writeShader(JSONWriter &json, GLuint shader) +{ + if (!shader) { + return; + } + + GLint shader_type = 0; + glGetShaderiv(shader, GL_SHADER_TYPE, &shader_type); + if (!shader_type) { + return; + } + + GLint source_length = 0; + glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &source_length); + if (!source_length) { + return; + } + + GLchar *source = new GLchar[source_length]; + GLsizei length = 0; + source[0] = 0; + glGetShaderSource(shader, source_length, &length, source); + + json.beginMember(enum_string(shader_type)); + json.writeString(source); + json.endMember(); + + delete [] source; +} + +static inline void +writeCurrentProgram(JSONWriter &json) +{ + GLint program = 0; + glGetIntegerv(GL_CURRENT_PROGRAM, &program); + if (!program) { + return; + } + + GLint attached_shaders = 0; + glGetProgramiv(program, GL_ATTACHED_SHADERS, &attached_shaders); + if (!attached_shaders) { + return; + } + + GLuint *shaders = new GLuint[attached_shaders]; + GLsizei count = 0; + glGetAttachedShaders(program, attached_shaders, &count, shaders); + for (GLsizei i = 0; i < count; ++ i) { + writeShader(json, shaders[i]); + } + delete [] shaders; +} + +static inline void +writeArbProgram(JSONWriter &json, GLenum target) +{ + if (!glIsEnabled(target)) { + return; + } + + GLint program_length = 0; + glGetProgramivARB(target, GL_PROGRAM_LENGTH_ARB, &program_length); + if (!program_length) { + return; + } + + GLchar *source = new GLchar[program_length + 1]; + source[0] = 0; + glGetProgramStringARB(target, GL_PROGRAM_STRING_ARB, source); + source[program_length] = 0; + + json.beginMember(enum_string(target)); + json.writeString(source); + json.endMember(); + + delete [] source; +} +''' + + # texture image + print ''' +static inline void +writeTextureImage(JSONWriter &json, GLenum target, GLint level) +{ + GLint width, height = 1, depth = 1; + + width = 0; + glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width); + + if (target != GL_TEXTURE_1D) { + height = 0; + glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height); + if (target == GL_TEXTURE_3D) { + depth = 0; + glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, &depth); + } + } + + if (width <= 0 || height <= 0 || depth <= 0) { + json.writeNull(); + } else { + json.beginObject(); + + // Tell the GUI this is no ordinary object, but an image + json.writeStringMember("__class__", "image"); + + json.writeNumberMember("__width__", width); + json.writeNumberMember("__height__", height); + json.writeNumberMember("__depth__", depth); + + // Hardcoded for now, but we could chose types more adequate to the + // texture internal format + json.writeStringMember("__type__", "uint8"); + json.writeBoolMember("__normalized__", true); + json.writeNumberMember("__channels__", 4); + + GLubyte *pixels = new GLubyte[depth*width*height*4]; + + glGetTexImage(target, level, GL_RGBA, GL_UNSIGNED_BYTE, pixels); + + json.beginMember("__data__"); + json.writeBase64(pixels, depth * width * height * 4 * sizeof *pixels); + json.endMember(); // __data__ + + delete [] pixels; + json.endObject(); + } +} + +static inline void +writeDrawBufferImage(JSONWriter &json, GLenum format) +{ + GLint width = glretrace::window_width; + GLint height = glretrace::window_height; + + GLint channels = __gl_format_channels(format); + + if (!width || !height) { + json.writeNull(); + } else { + json.beginObject(); + + // Tell the GUI this is no ordinary object, but an image + json.writeStringMember("__class__", "image"); + + json.writeNumberMember("__width__", width); + json.writeNumberMember("__height__", height); + json.writeNumberMember("__depth__", 1); + + // Hardcoded for now, but we could chose types more adequate to the + // texture internal format + json.writeStringMember("__type__", "uint8"); + json.writeBoolMember("__normalized__", true); + json.writeNumberMember("__channels__", channels); + + GLubyte *pixels = new GLubyte[width*height*channels]; + + GLint drawbuffer = glretrace::double_buffer ? GL_BACK : GL_FRONT; + GLint readbuffer = glretrace::double_buffer ? GL_BACK : GL_FRONT; + glGetIntegerv(GL_DRAW_BUFFER, &drawbuffer); + glGetIntegerv(GL_READ_BUFFER, &readbuffer); + glReadBuffer(drawbuffer); + + glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT); + glPixelStorei(GL_PACK_ALIGNMENT, 1); + + glReadPixels(0, 0, width, height, format, GL_UNSIGNED_BYTE, pixels); + + glPopClientAttrib(); + glReadBuffer(readbuffer); + + json.beginMember("__data__"); + json.writeBase64(pixels, width * height * channels * sizeof *pixels); + json.endMember(); // __data__ + + delete [] pixels; + json.endObject(); + } +} + +''' + + # textures + print 'static inline void' + print 'writeTexture(JSONWriter &json, GLenum target, GLenum binding)' + print '{' + print ' GLint texture = 0;' + print ' glGetIntegerv(binding, &texture);' + print ' if (!glIsEnabled(target) && !texture) {' + print ' json.writeNull();' + print ' return;' + print ' }' + print + print ' json.beginObject();' + print + print ' GLfloat param;' + for function, type, count, name in parameters: + if function != 'glGetTexParameter' or count != 1: + continue + print ' glGetTexParameterfv(target, %s, ¶m);' % name + print ' json.beginMember("%s");' % name + JsonWriter().visit(type, 'param') + print ' json.endMember();' + print + print + print ' json.beginMember("levels");' + print ' json.beginArray();' + print ' GLint level = 0;' + print ' do {' + print ' GLint width = 0, height = 0;' + print ' glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);' + print ' glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);' + print ' if (!width || !height) {' + print ' break;' + print ' }' + print ' json.beginObject();' + print + # FIXME: This is not the original texture name in the trace -- we need + # to do a reverse lookup of the texture mappings to find the original one + print ' json.beginMember("binding");' + print ' json.writeNumber(texture);' + print ' json.endMember();' + print + # TODO: Generalize this + for function, type, count, name in parameters: + if function != 'glGetTexLevelParameter' or count != 1: + continue + print ' glGetTexLevelParameterfv(target, level, %s, ¶m);' % name + print ' json.beginMember("%s");' % name + JsonWriter().visit(type, 'param') + print ' json.endMember();' + print + print ' json.beginMember("image");' + print ' writeTextureImage(json, target, level);' + print ' json.endMember();' + print + print ' json.endObject();' + print ' ++level;' + print ' } while(true);' + print ' json.endArray();' + print ' json.endMember(); // levels' + print + print ' json.endObject();' + print '}' + print + + print 'void glretrace::state_dump(std::ostream &os)' print '{' print ' JSONWriter json(os);' self.dump_parameters() - + self.dump_current_program() + self.dump_textures() + self.dump_framebuffer() print '}' print def dump_parameters(self): - print ' const GLubyte * sparams[1];' - print ' GLboolean bparams[16];' - print ' GLint iparams[16];' - print ' GLfloat fparams[16];' - print ' GLdouble dparams[16];' - print ' GLvoid * pparams[16];' + print ' json.beginMember("parameters");' + print ' json.beginObject();' + + self.dump_atoms(glGet) + + self.dump_vertex_attribs() + + print ' json.endObject();' + print ' json.endMember(); // parameters' print - print ' (void)dparams;' + + def dump_vertex_attribs(self): + print ' json.beginMember("GL_VERTEX_ATTRIB");' + print ' json.beginArray();' + print ' GLint max_vertex_attribs = 0;' + print ' __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &max_vertex_attribs);' + print ' for (GLint index = 0; index < max_vertex_attribs; ++index) {' + print ' json.beginObject();' + self.dump_atoms(glGetVertexAttrib, 'index') + print ' json.endObject();' + print ' }' print - print ' json.beginMember("parameters");' + print ' json.endArray();' + print ' json.endMember(); // GL_VERTEX_ATTRIB' + print + + def dump_current_program(self): + print ' json.beginMember("shaders");' + print ' json.beginObject();' + print ' writeCurrentProgram(json);' + print ' writeArbProgram(json, GL_FRAGMENT_PROGRAM_ARB);' + print ' writeArbProgram(json, GL_VERTEX_PROGRAM_ARB);' + print ' json.endObject();' + print ' json.endMember(); //shaders' + print + + def dump_textures(self): + print ' json.beginMember("textures");' + print ' json.beginArray();' + print ' GLint active_texture = GL_TEXTURE0;' + print ' glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);' + print ' GLint max_texture_coords = 0;' + print ' glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);' + print ' for (GLint unit = 0; unit < max_texture_coords; ++unit) {' + print ' glActiveTexture(GL_TEXTURE0 + unit);' + print ' json.beginObject();' + for target, binding in texture_targets: + print ' json.beginMember("%s");' % target + print ' writeTexture(json, %s, %s);' % (target, binding) + print ' json.endMember();' + print ' json.endObject();' + print ' }' + print ' glActiveTexture(active_texture);' + print ' json.endArray();' + print ' json.endMember(); // texture' + print + + def dump_framebuffer(self): + print ' json.beginMember("framebuffer");' print ' json.beginObject();' + # TODO: Handle real FBOs + print + print ' json.beginMember("GL_RGBA");' + print ' writeDrawBufferImage(json, GL_RGBA);' + print ' json.endMember();' + print + print ' GLint depth_bits = 0;' + print ' glGetIntegerv(GL_DEPTH_BITS, &depth_bits);' + print ' if (depth_bits) {' + print ' json.beginMember("GL_DEPTH_COMPONENT");' + print ' writeDrawBufferImage(json, GL_DEPTH_COMPONENT);' + print ' json.endMember();' + print ' }' + print + print ' GLint stencil_bits = 0;' + print ' glGetIntegerv(GL_STENCIL_BITS, &stencil_bits);' + print ' if (stencil_bits) {' + print ' json.beginMember("GL_STENCIL_INDEX");' + print ' writeDrawBufferImage(json, GL_STENCIL_INDEX);' + print ' json.endMember();' + print ' }' + print + print ' json.endObject();' + print ' json.endMember(); // framebuffer' + pass + + def dump_atoms(self, getter, *args): for function, type, count, name in parameters: - if function != 'glGet': + if function != getter.inflector.radical: continue if type is X: continue - elif type is B: - buf = 'bparams' - getter = 'glGetBooleanv' - writer = 'json.writeBool(%s)' - elif type is I: - buf = 'iparams' - getter = 'glGetIntegerv' - writer = 'json.writeNumber(%s)' - elif type is E: - buf = 'iparams' - getter = 'glGetIntegerv' - writer = 'writeEnum(json, %s)' - elif type is F: - buf = 'fparams' - getter = 'glGetFloatv' - writer = 'json.writeNumber(%s)' - elif type is D: - buf = 'dparams' - getter = 'glGetDoublev' - writer = 'json.writeNumber(%s)' - elif type is P: - buf = 'pparams' - getter = 'glGetPointerv' - writer = 'json.writeNumber((size_t)%s)' - elif type is S: - buf = 'sparams' - getter = 'glGetString' - writer = 'json.writeString((const char *)%s)' - else: - raise NotImplementedError - print ' memset(%s, 0, %u * sizeof *%s);' % (buf, count, buf) - if getter.endswith('v'): - print ' %s(%s, %s);' % (getter, name, buf) - else: - assert count == 1 - print ' %s[0] = %s(%s);' % (buf, getter, name) - print ' if (glGetError() != GL_NO_ERROR) {' - #print ' std::cerr << "warning: %s(%s) failed\\n";' % (getter, name) - print ' } else {' - print ' json.beginMember("%s");' % name - if count == 1: - print ' %s;' % (writer % ( '%s[0]' % buf)) - else: - print ' json.beginArray();' - for i in range(count): - print ' %s;' % (writer % ( '%s[%u]' % (buf, i))) - print ' json.endArray();' - print ' json.endMember();' - print ' }' - print ' json.endObject();' - print ' json.endMember(); // parameters' - print + print ' // %s' % name + print ' {' + type, value = getter(*(args + (name,))) + print ' if (glGetError() != GL_NO_ERROR) {' + #print ' std::cerr << "warning: %s(%s) failed\\n";' % (glGet.radical, name) + print ' } else {' + print ' json.beginMember("%s");' % name + JsonWriter().visit(type, value) + print ' json.endMember();' + print ' }' + print ' }' + print def write_line(s): self.write(' '*self.level + s + '\n')