diff options
Diffstat (limited to 'src/mesa')
| -rw-r--r-- | src/mesa/glapi/glX_XML.py | 86 | ||||
| -rw-r--r-- | src/mesa/glapi/glX_proto_send.py | 348 | ||||
| -rw-r--r-- | src/mesa/glapi/gl_API.xml | 92 | ||||
| -rw-r--r-- | src/mesa/glapi/gl_XML.py | 52 |
4 files changed, 533 insertions, 45 deletions
diff --git a/src/mesa/glapi/glX_XML.py b/src/mesa/glapi/glX_XML.py index 35341320537..6da454c58c1 100644 --- a/src/mesa/glapi/glX_XML.py +++ b/src/mesa/glapi/glX_XML.py @@ -1,6 +1,6 @@ #!/usr/bin/python2 -# (C) Copyright IBM Corporation 2004 +# (C) Copyright IBM Corporation 2004, 2005 # All Rights Reserved. # # Permission is hereby granted, free of charge, to any person obtaining a @@ -400,6 +400,36 @@ class glXFunction(gl_XML.glFunction): def command_payload_length(self): size = 0 + + if self.image: + [dim, junk, junk, junk, junk] = self.dimensions() + + # The base size is the size of the pixel pack info + # header used by images with the specified number + # of dimensions. + + if dim <= 2: + size = 20 + elif dim <= 4: + size = 36 + else: + raise RuntimeError('Invalid number of dimensions %u for parameter "%s" in function "%s".' % (dim, self.image.name, self.name)) + + if self.image.img_null_flag: + size += 4 + + if self.image.img_pad_dimensions: + size += 4 * (dim & 1) + + # If the image has offset parameters, like + # TexSubImage1D or TexSubImage3D, they need to + # be padded out as well. + + if self.image.img_xoff: + size += 4 * (dim & 1) + + + size_string = "" for p in gl_XML.glFunction.parameterIterator(self): if p.is_output: continue @@ -507,6 +537,60 @@ class glXFunction(gl_XML.glFunction): return self.fn_return_type != 'void' or self.output != None + def dimensions(self): + """Determine the dimensions of an image. + + Returns a tuple representing the number of dimensions and the + string name of each of the dimensions of an image, If the + function is not a pixel function, the number of dimensions + will be zero.""" + + if not self.image: + return [0, "0", "0", "0", "0"] + else: + dim = 1 + w = self.image.width + + if self.image.height: + dim = 2 + h = self.image.height + else: + h = "1" + + if self.image.depth: + dim = 3 + d = self.image.depth + else: + d = "1" + + if self.image.extent: + dim = 4 + e = self.image.extent + else: + e = "1" + + return [dim, w, h, d, e] + + + def pad_after(self, p): + """Returns the name of the field inserted after the + specified field to pad out the command header.""" + + if self.image and self.image.img_pad_dimensions: + if not self.image.height: + if p.name == self.image.width: + return "height" + elif p.name == self.image.img_xoff: + return "yoffset" + elif not self.image.extent: + if p.name == self.image.depth: + # Should this be "size4d"? + return "extent" + elif p.name == self.image.img_zoff: + return "woffset" + return None + + class GlxProto(gl_XML.FilterGLAPISpecBase): name = "glX_proto_send.py (from Mesa)" diff --git a/src/mesa/glapi/glX_proto_send.py b/src/mesa/glapi/glX_proto_send.py index 7a93ef10b64..e7cda2f7797 100644 --- a/src/mesa/glapi/glX_proto_send.py +++ b/src/mesa/glapi/glX_proto_send.py @@ -1,6 +1,6 @@ #!/usr/bin/python2 -# (C) Copyright IBM Corporation 2004 +# (C) Copyright IBM Corporation 2004, 2005 # All Rights Reserved. # # Permission is hereby granted, free of charge, to any person obtaining a @@ -32,15 +32,87 @@ from xml.sax.handler import feature_namespaces import gl_XML import glX_XML import license -import sys, getopt +import sys, getopt, copy + +def hash_pixel_function(func): + """Generate a 'unique' key for a pixel function. The key is based on + the parameters written in the command packet. This includes any + padding that might be added for the original function and the 'NULL + image' flag.""" + + [dim, junk, junk, junk, junk] = func.dimensions() + + d = (dim + 1) & ~1 + h = "%uD%uD_" % (d - 1, d) + + for p in func.parameterIterator(1, 1): + h = "%s%u" % (h, p.size()) + + if func.pad_after(p): + h += "4" + + if func.image.img_null_flag: + h += "_NF" + + n = func.name.replace("%uD" % (dim), "") + n = "__glx_%s_%uD%uD" % (n, d - 1, d) + return [h, n] + + +class glXPixelFunctionUtility(glX_XML.glXFunction): + """Dummy class used to generate pixel "utility" functions that are + shared by multiple dimension image functions. For example, these + objects are used to generate shared functions used to send GLX + protocol for TexImage1D and TexImage2D, TexSubImage1D and + TexSubImage2D, etc.""" + + def __init__(self, func, name): + # The parameters to the utility function are the same as the + # parameters to the real function except for the added "pad" + # parameters. + + self.name = name + self.image = copy.copy(func.image) + self.fn_parameters = [] + for p in gl_XML.glFunction.parameterIterator(func): + self.fn_parameters.append(p) + + pad_name = func.pad_after(p) + if pad_name: + pad = copy.copy(p) + pad.name = pad_name + self.fn_parameters.append(pad) + + + if self.image.height == None: + self.image.height = "height" + + if self.image.img_yoff == None: + self.image.img_yoff = "yoffset" + + if func.image.depth: + if self.image.extent == None: + self.image.extent = "extent" + + if self.image.img_woff == None: + self.image.img_woff = "woffset" + + + self.set_return_type( func.fn_return_type ) + self.glx_rop = ~0 + self.can_be_large = func.can_be_large + self.count_parameters = func.count_parameters + self.counter = func.counter + return class PrintGlxProtoStubs(glX_XML.GlxProto): def __init__(self): glX_XML.GlxProto.__init__(self) self.last_category = "" - self.license = license.bsd_license_template % ( "(C) Copyright IBM Corporation 2004", "IBM") + self.license = license.bsd_license_template % ( "(C) Copyright IBM Corporation 2004, 2005", "IBM") self.generic_sizes = [3, 4, 6, 8, 12, 16, 24, 32] + self.pixel_stubs = {} return def printRealHeader(self): @@ -48,7 +120,7 @@ class PrintGlxProtoStubs(glX_XML.GlxProto): print '#include <GL/gl.h>' print '#include "indirect.h"' print '#include "glxclient.h"' - print '#include "size.h"' + print '#include "indirect_size.h"' print '#include <GL/glxproto.h>' print '' print '#define __GLX_PAD(n) (((n) + 3) & ~3)' @@ -125,6 +197,19 @@ setup_vendor_request( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen ) req->contextTag = gc->currentContextTag; return (GLubyte *)(req) + sz_xGLXVendorPrivateReq; } + +const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 }; + +#define zero (__glXDefaultPixelStore+0) +#define one (__glXDefaultPixelStore+8) +#define default_pixel_store_1D (__glXDefaultPixelStore+4) +#define default_pixel_store_1D_size 20 +#define default_pixel_store_2D (__glXDefaultPixelStore+4) +#define default_pixel_store_2D_size 20 +#define default_pixel_store_3D (__glXDefaultPixelStore+0) +#define default_pixel_store_3D_size 36 +#define default_pixel_store_4D (__glXDefaultPixelStore+0) +#define default_pixel_store_4D_size 36 """ for size in self.generic_sizes: @@ -135,7 +220,10 @@ setup_vendor_request( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen ) if f.fn_offset < 0 or f.handcode or f.ignore: return if f.glx_rop != 0 or f.vectorequiv != None: - self.printRenderFunction(f) + if f.image: + self.printPixelFunction(f) + else: + self.printRenderFunction(f) elif f.glx_sop != 0 or f.glx_vendorpriv != 0: self.printSingleFunction(f) else: @@ -182,8 +270,38 @@ generic_%u_byte( GLint rop, const void * ptr ) return offset - def large_emit_begin(self, indent, f): - print '%s const GLint op = %s;' % (indent, f.opcode_real_name()) + def pixel_emit_args(self, f, pc, indent, adjust, dim, large): + """Emit the arguments for a pixel function. This differs from + common_emit_args in that pixel functions may require padding + be inserted (i.e., for the missing width field for + TexImage1D), and they may also require a 'NULL image' flag + be inserted before the image data.""" + + offset = 0 + for p in f.parameterIterator(1, 1): + self.common_emit_one_arg(p, offset, pc, indent, adjust) + offset += p.size() + + if f.pad_after(p): + print '%s (void) memcpy((void *)(%s + %u), zero, 4);' % (indent, pc, offset + adjust) + offset += 4 + + if f.image.img_null_flag: + if large: + print '%s (void) memcpy((void *)(%s + %u), zero, 4);' % (indent, pc, offset + adjust) + else: + print '%s (void) memcpy((void *)(%s + %u), (void *)((%s == NULL) ? one : zero), 4);' % (indent, pc, offset + adjust, f.image.name) + + offset += 4 + + return offset + + + def large_emit_begin(self, indent, f, op_name = None): + if not op_name: + op_name = f.opcode_real_name() + + print '%s const GLint op = %s;' % (indent, op_name) print '%s const GLuint cmdlenLarge = cmdlen + 4;' % (indent) print '%s GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);' % (indent) print '%s (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);' % (indent) @@ -199,9 +317,7 @@ generic_%u_byte( GLint rop, const void * ptr ) print '{' - def common_func_print_header(self, f): - self.common_func_print_just_header(f) - + def common_func_print_just_start(self, f): print ' __GLXcontext * const gc = __glXGetCurrentContext();' # The only reason that single and vendor private commands need @@ -224,6 +340,15 @@ generic_%u_byte( GLint rop, const void * ptr ) if f.count_parameters != None: print ' const GLuint compsize = __gl%s_size(%s);' % (f.name, f.count_parameters) + elif f.image: + [dim, w, h, d, junk] = f.dimensions() + + compsize = '__glImageSize(%s, %s, %s, %s, %s, %s)' % (w, h, d, f.image.img_format, f.image.img_type, f.image.img_target) + if not f.image.img_send_null: + compsize = '(%s != NULL) ? %s : 0' % (f.image.name, compsize) + + print ' const GLuint compsize = %s;' % (compsize) + print ' const GLuint cmdlen = %s;' % (f.command_length()) @@ -241,6 +366,12 @@ generic_%u_byte( GLint rop, const void * ptr ) return 0 + def common_func_print_header(self, f): + self.common_func_print_just_header(f) + return self.common_func_print_just_start(f) + + + def printSingleFunction(self, f): self.common_func_print_header(f) @@ -284,6 +415,203 @@ generic_%u_byte( GLint rop, const void * ptr ) return + def printPixelFunction(self, f): + """This function could use some major refactoring. :(""" + + # There is a code-space optimization that we can do here. + # Functions that are marked img_pad_dimensions have a version + # with an odd number of dimensions and an even number of + # dimensions. TexSubImage1D and TexSubImage2D are examples. + # We can emit a single function that does both, and have the + # real functions call the utility function with the correct + # parameters. + # + # The only quirk to this is that utility funcitons will be + # generated for 3D and 4D functions, but 4D (e.g., + # GL_SGIS_texture4D) isn't typically supported. This is + # probably not an issue. However, it would be possible to + # look at the total set of functions and determine if there + # is another function that would actually use the utility + # function. If not, then fallback to the normal way of + # generating code. + + if f.image.img_pad_dimensions: + # Determine the hash key and the name for the utility + # function that is used to implement the real + # function. + + [h, n] = hash_pixel_function(f) + + + # If the utility function is not yet known, generate + # it. + + if not self.pixel_stubs.has_key(h): + self.pixel_stubs[h] = n + pixel_func = glXPixelFunctionUtility(f, n) + + print 'static void' + print '%s( unsigned opcode, unsigned dim, %s )' % (n, pixel_func.get_parameter_string()) + print '{' + + if self.common_func_print_just_start(pixel_func): + indent = " " + trailer = " }" + else: + indent = "" + trailer = None + + + if pixel_func.can_be_large: + print '%s if (cmdlen <= gc->maxSmallRenderCommandSize) {' % (indent) + print '%s if ( (gc->pc + cmdlen) > gc->bufEnd ) {' % (indent) + print '%s (void) __glXFlushRenderBuffer(gc, gc->pc);' % (indent) + print '%s }' % (indent) + indent += " " + + [dim, width, height, depth, extent] = pixel_func.dimensions() + + if dim < 3: + adjust = 20 + 4 + else: + adjust = 36 + 4 + + + print '%s emit_header(gc->pc, opcode, cmdlen);' % (indent) + + offset = self.pixel_emit_args(pixel_func, "gc->pc", indent, adjust, dim, 0) + + [s, junk] = pixel_func.command_payload_length() + + pixHeaderPtr = "gc->pc + 4" + pcPtr = "gc->pc + %u" % (s + 4) + + if pixel_func.image.img_send_null: + condition = '(compsize > 0) && (%s != NULL)' % (pixel_func.image.name) + else: + condition = 'compsize > 0' + + print '%s if (%s) {' % (indent, condition) + print '%s (*gc->fillImage)(gc, dim, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, width, height, depth, pixel_func.image.img_format, pixel_func.image.img_type, pixel_func.image.name, pcPtr, pixHeaderPtr) + print '%s }' % (indent) + print '%s else {' % (indent) + print '%s (void) memcpy( %s, default_pixel_store_%uD, default_pixel_store_%uD_size );' % (indent, pixHeaderPtr, dim, dim) + print '%s }' % (indent) + + print '%s gc->pc += cmdlen;' % (indent) + print '%s if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }' % (indent) + + if f.can_be_large: + adjust += 4 + + print '%s}' % (indent) + print '%selse {' % (indent) + + self.large_emit_begin(indent, pixel_func, "opcode") + offset = self.pixel_emit_args(pixel_func, "pc", indent, adjust, dim, 1) + + pixHeaderPtr = "pc + 8" + pcPtr = "pc + %u" % (s + 8) + + print '%s __glXSendLargeImage(gc, compsize, dim, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, width, height, depth, f.image.img_format, f.image.img_type, f.image.name, pcPtr, pixHeaderPtr) + + print '%s}' % (indent) + + if trailer: print trailer + print '}' + print '' + + + + # Generate the real function as a call to the + # utility function. + + self.common_func_print_just_header(f) + + [dim, junk, junk, junk, junk] = f.dimensions() + + p_string = "" + for p in gl_XML.glFunction.parameterIterator(f): + p_string += ", " + p.name + + if f.pad_after(p): + p_string += ", 1" + + print ' %s(%s, %u%s );' % (n, f.opcode_name(), dim, p_string) + print '}' + print '' + return + + + if self.common_func_print_header(f): + indent = " " + trailer = " }" + else: + indent = "" + trailer = None + + + if f.can_be_large: + print '%s if (cmdlen <= gc->maxSmallRenderCommandSize) {' % (indent) + print '%s if ( (gc->pc + cmdlen) > gc->bufEnd ) {' % (indent) + print '%s (void) __glXFlushRenderBuffer(gc, gc->pc);' % (indent) + print '%s }' % (indent) + indent += " " + + [dim, width, height, depth, extent] = f.dimensions() + + if dim < 3: + adjust = 20 + 4 + else: + adjust = 36 + 4 + + + print '%s emit_header(gc->pc, %s, cmdlen);' % (indent, f.opcode_real_name()) + + offset = self.pixel_emit_args(f, "gc->pc", indent, adjust, dim, 0) + + [s, junk] = f.command_payload_length() + + pixHeaderPtr = "gc->pc + 4" + pcPtr = "gc->pc + %u" % (s + 4) + + if f.image.img_send_null: + condition = '(compsize > 0) && (%s != NULL)' % (f.image.name) + else: + condition = 'compsize > 0' + + print '%s if (%s) {' % (indent, condition) + print '%s (*gc->fillImage)(gc, %u, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, dim, width, height, depth, f.image.img_format, f.image.img_type, f.image.name, pcPtr, pixHeaderPtr) + print '%s }' % (indent) + print '%s else {' % (indent) + print '%s (void) memcpy( %s, default_pixel_store_%uD, default_pixel_store_%uD_size );' % (indent, pixHeaderPtr, dim, dim) + print '%s }' % (indent) + + print '%s gc->pc += cmdlen;' % (indent) + print '%s if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }' % (indent) + + if f.can_be_large: + adjust += 4 + + print '%s}' % (indent) + print '%selse {' % (indent) + + self.large_emit_begin(indent, f) + offset = self.pixel_emit_args(f, "pc", indent, adjust, dim, 1) + + pixHeaderPtr = "pc + 8" + pcPtr = "pc + %u" % (s + 8) + + print '%s __glXSendLargeImage(gc, compsize, %u, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, dim, width, height, depth, f.image.img_format, f.image.img_type, f.image.name, pcPtr, pixHeaderPtr) + + print '%s}' % (indent) + + if trailer: print trailer + print '}' + print '' + return + + def printRenderFunction(self, f): # There is a class of GL functions that take a single pointer # as a parameter. This pointer points to a fixed-size chunk diff --git a/src/mesa/glapi/gl_API.xml b/src/mesa/glapi/gl_API.xml index d87813600ce..b594ca37632 100644 --- a/src/mesa/glapi/gl_API.xml +++ b/src/mesa/glapi/gl_API.xml @@ -24,6 +24,20 @@ counter CDATA #IMPLIED count_scale CDATA #IMPLIED output CDATA #IMPLIED + img_width CDATA #IMPLIED + img_height CDATA #IMPLIED + img_depth CDATA #IMPLIED + img_extent CDATA #IMPLIED + img_xoff CDATA #IMPLIED + img_yoff CDATA #IMPLIED + img_zoff CDATA #IMPLIED + img_woff CDATA #IMPLIED + img_format CDATA #IMPLIED + img_type CDATA #IMPLIED + img_target CDATA #IMPLIED + img_send_null CDATA #IMPLIED + img_null_flag CDATA #IMPLIED + img_pad_dimensions CDATA #IMPLIED variable_param CDATA #IMPLIED> <!ATTLIST return type CDATA #REQUIRED> <!ATTLIST glx rop CDATA #IMPLIED @@ -58,6 +72,24 @@ param: single enum parameter. Most of the gl*Parameter[if]v functions use this. Additionally, the enums that can be passed should be properly annotated. + img_width / img_height / img_depth / img_extent - name of parameters + (or hardcoded integer) used for the dimensions of pixel data. + img_xoff / img_yoff / img_zoff / img_woff - name of parameters used + for x, y, z, and w offsets of pixel data. + img_format - name of parameter used as the pixel data format. + img_type - name of parameter used as the pixel data type. + img_target - name of parameter used as a texture target. Non-texture + pixel data should hardcode 0. + img_send_null - boolean flag to determine if blank pixel data should + be sent when a NULL pointer is passed. This is only used by + TexImage1D and TexImage2D. + img_null_flag - boolean flag to determine if an extra flag is used to + determine if a NULL pixel pointer was passed. This is used by + TexSubImage1D, TexSubImage2D, TexImage3D and others. + img_pad_dimensions - boolean flag to determine if dimension data and + offset data should be padded to the next even number of dimensions. + For example, this will insert an empty "height" field after the + "width" field in the protocol for TexImage1D. glx: rop - Opcode value for "render" commands @@ -73,8 +105,8 @@ glx: return value data (e.g., glGetLightfv). Other single commands take reply data only as an array (e.g., glGetClipPlane). handcode - some functions are just too complicated to generate - (e.g., glTexImage2D) or operate only on client-side data (e.g., - glVertexPointer) and must be handcoded. + (e.g., glSeperableFilter2D) or operate only on client-side data + (e.g., glVertexPointer) and must be handcoded. ignore - some functions have an entry in the dispatch table, but aren't suitable for protocol implementation (e.g., glLockArraysEXT). This also applies to functions that don't have any GLX protocol specified @@ -775,8 +807,8 @@ glx: <param name="yorig" type="GLfloat"/> <param name="xmove" type="GLfloat"/> <param name="ymove" type="GLfloat"/> - <param name="bitmap" type="const GLubyte *"/> - <glx rop="5" handcode="true"/> + <param name="bitmap" type="const GLubyte *" img_width="width" img_height="height" img_format="GL_COLOR_INDEX" img_type="GL_BITMAP" img_target="0" img_pad_dimensions="false"/> + <glx rop="5" large="true"/> </function> <function name="Color3b" offset="9" vectorequiv="Color3bv"> @@ -1706,8 +1738,8 @@ glx: </function> <function name="PolygonStipple" offset="175"> - <param name="mask" type="const GLubyte *"/> - <glx rop="102" handcode="true"/> + <param name="mask" type="const GLubyte *" img_width="32" img_height="32" img_format="GL_COLOR_INDEX" img_type="GL_BITMAP" img_target="0" img_pad_dimensions="false"/> + <glx rop="102"/> </function> <function name="Scissor" offset="176"> @@ -1759,8 +1791,8 @@ glx: <param name="border" type="GLint"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="pixels" type="const GLvoid *"/> - <glx rop="109" handcode="true"/> + <param name="pixels" type="const GLvoid *" img_width="width" img_format="format" img_type="type" img_target="target" img_send_null="true" img_pad_dimensions="true"/> + <glx rop="109" large="true"/> </function> <function name="TexImage2D" offset="183"> @@ -1772,8 +1804,8 @@ glx: <param name="border" type="GLint"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="pixels" type="const GLvoid *"/> - <glx rop="110" handcode="true"/> + <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_format="format" img_type="type" img_target="target" img_send_null="true" img_pad_dimensions="true"/> + <glx rop="110" large="true"/> </function> <function name="TexEnvf" offset="184"> @@ -2249,8 +2281,8 @@ glx: <param name="height" type="GLsizei"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="pixels" type="const GLvoid *"/> - <glx rop="173" handcode="true"/> + <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_format="format" img_type="type" img_target="0" img_pad_dimensions="false"/> + <glx rop="173" large="true"/> </function> <function name="GetBooleanv" offset="258"> @@ -2826,8 +2858,8 @@ glx: <param name="width" type="GLsizei"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="pixels" type="const GLvoid *"/> - <glx rop="4099" handcode="true"/> + <param name="pixels" type="const GLvoid *" img_width="width" img_xoff="xoffset" img_format="format" img_type="type" img_target="target" img_null_flag="true" img_pad_dimensions="true"/> + <glx rop="4099" large="true"/> </function> <function name="TexSubImage2D" offset="333"> @@ -2839,8 +2871,8 @@ glx: <param name="height" type="GLsizei"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="pixels" type="const GLvoid *"/> - <glx rop="4100" handcode="true"/> + <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_xoff="xoffset" img_yoff="yoffset" img_format="format" img_type="type" img_target="target" img_null_flag="true" img_pad_dimensions="true"/> + <glx rop="4100" large="true"/> </function> <function name="AreTexturesResident" offset="322"> @@ -3035,8 +3067,8 @@ glx: <param name="width" type="GLsizei"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="table" type="const GLvoid *"/> - <glx rop="2053" handcode="true"/> + <param name="table" type="const GLvoid *" img_width="width" img_pad_dimensions="false" img_format="format" img_type="type" img_target="target"/> + <glx rop="2053" large="true"/> </function> <function name="ColorTableParameterfv" offset="340"> @@ -3090,8 +3122,8 @@ glx: <param name="count" type="GLsizei"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="data" type="const GLvoid *"/> - <glx rop="195" handcode="true"/> + <param name="data" type="const GLvoid *" img_width="count" img_pad_dimensions="false" img_format="format" img_type="type" img_target="target"/> + <glx rop="195" large="true"/> </function> <function name="CopyColorSubTable" offset="347"> @@ -3109,8 +3141,8 @@ glx: <param name="width" type="GLsizei"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="image" type="const GLvoid *"/> - <glx rop="4101" handcode="true"/> + <param name="image" type="const GLvoid *" img_width="width" img_format="format" img_type="type" img_target="target" img_pad_dimensions="true"/> + <glx rop="4101" large="true"/> </function> <function name="ConvolutionFilter2D" offset="349"> @@ -3120,8 +3152,8 @@ glx: <param name="height" type="GLsizei"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="image" type="const GLvoid *"/> - <glx rop="4102" handcode="true"/> + <param name="image" type="const GLvoid *" img_width="width" img_height="height" img_format="format" img_type="type" img_target="target" img_pad_dimensions="true"/> + <glx rop="4102" large="true"/> </function> <function name="ConvolutionParameterf" offset="350"> @@ -3296,8 +3328,8 @@ glx: <param name="border" type="GLint"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="pixels" type="const GLvoid *"/> - <glx rop="4114" handcode="true"/> + <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_depth="depth" img_format="format" img_type="type" img_target="target" img_null_flag="true" img_pad_dimensions="true"/> + <glx rop="4114" large="true"/> </function> <function name="TexSubImage3D" offset="372"> @@ -3311,8 +3343,8 @@ glx: <param name="depth" type="GLsizei"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="pixels" type="const GLvoid *"/> - <glx rop="4115" handcode="true"/> + <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_depth="depth" img_xoff="xoffset" img_yoff="yoffset" img_zoff="zoffset" img_format="format" img_type="type" img_target="target" img_null_flag="true" img_pad_dimensions="true"/> + <glx rop="4115" large="true"/> </function> <function name="CopyTexSubImage3D" offset="373"> @@ -6545,7 +6577,7 @@ glx: <param name="border" type="GLint"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="pixels" type="const GLvoid *"/> + <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_depth="depth" img_extent="size4d" img_format="format" img_type="type" img_target="target" img_null_flag="true" img_pad_dimensions="true"/> <glx rop="2057" ignore="true"/> </function> @@ -6562,7 +6594,7 @@ glx: <param name="size4d" type="GLsizei"/> <param name="format" type="GLenum"/> <param name="type" type="GLenum"/> - <param name="pixels" type="const GLvoid *"/> + <param name="pixels" type="const GLvoid *" img_width="width" img_height="height" img_depth="depth" img_extent="size4d" img_xoff="xoffset" img_yoff="yoffset" img_zoff="zoffset" img_woff="woffset" img_format="format" img_type="type" img_target="target" img_null_flag="true" img_pad_dimensions="true"/> <glx rop="2058" ignore="true"/> </function> </category> diff --git a/src/mesa/glapi/gl_XML.py b/src/mesa/glapi/gl_XML.py index a58f2851556..f984d5f87fb 100644 --- a/src/mesa/glapi/gl_XML.py +++ b/src/mesa/glapi/gl_XML.py @@ -1,6 +1,6 @@ #!/usr/bin/python2 -# (C) Copyright IBM Corporation 2004 +# (C) Copyright IBM Corporation 2004, 2005 # All Rights Reserved. # # Permission is hereby granted, free of charge, to any person obtaining a @@ -154,7 +154,45 @@ class glParameter( glItem ): else: self.is_output = 0 - if self.p_count > 0 or self.counter != None or self.p_count_parameters != None : + + # Pixel data has special parameters. + + self.width = attrs.get('img_width', None) + self.height = attrs.get('img_height', None) + self.depth = attrs.get('img_depth', None) + self.extent = attrs.get('img_extent', None) + + self.img_xoff = attrs.get('img_xoff', None) + self.img_yoff = attrs.get('img_yoff', None) + self.img_zoff = attrs.get('img_zoff', None) + self.img_woff = attrs.get('img_woff', None) + + self.img_format = attrs.get('img_format', None) + self.img_type = attrs.get('img_type', None) + self.img_target = attrs.get('img_target', None) + + pad = attrs.get('img_pad_dimensions', "false") + if pad == "true": + self.img_pad_dimensions = 1 + else: + self.img_pad_dimensions = 0 + + + null_flag = attrs.get('img_null_flag', "false") + if null_flag == "true": + self.img_null_flag = 1 + else: + self.img_null_flag = 0 + + send_null = attrs.get('img_send_null', "false") + if send_null == "true": + self.img_send_null = 1 + else: + self.img_send_null = 0 + + + + if self.p_count > 0 or self.counter or self.p_count_parameters: has_count = 1 else: has_count = 0 @@ -193,7 +231,7 @@ class glParameter( glItem ): to glCallLists, are not variable length arrays in this sense.""" - return (self.p_count_parameters != None) or (self.counter != None) + return self.p_count_parameters or self.counter or self.width def is_array(self): @@ -222,7 +260,7 @@ class glParameter( glItem ): def size(self): - if self.p_count_parameters != None or self.counter != None or self.is_output: + if self.p_count_parameters or self.counter or self.width or self.is_output: return 0 elif self.p_count == 0: return self.p_type.size @@ -241,6 +279,8 @@ class glParameter( glItem ): pass elif self.p_count_parameters != None and self.counter != None: b_prod = self.counter + elif self.width: + return "compsize" else: raise RuntimeError("Parameter '%s' to function '%s' has size 0." % (self.name, self.context.name)) @@ -281,6 +321,7 @@ class glFunction( glItem ): def __init__(self, context, name, attrs): self.fn_alias = attrs.get('alias', None) self.fn_parameters = [] + self.image = None temp = attrs.get('offset', None) if temp == None or temp == "?": @@ -318,6 +359,9 @@ class glFunction( glItem ): if tag_name != "param": raise RuntimeError("Trying to append '%s' to parameter list of function '%s'." % (tag_name, self.name)) + if p.width: + self.image = p + self.fn_parameters.append(p) |