| Age | Commit message (Collapse) | Author |
|---|
|
extension that was missing the GL_ part and uses the core GL type names for
vertex buffer object functions instead of the ARB names.
Also commits the resulting changes to the generated code. Some how, the
#if sequence disappeared in the 1.52 version of glapi_x86.S.
|
|
|
|
|
|
|
|
|
|
return type".
|
|
return type".
|
|
input. This allows use of GL API scripts in pipelines.
|
|
parse_GL_API, in gl_XML.py.
|
|
|
|
|
|
|
|
|
|
The main difference is that white-space is used to separate the names
instead of comas.
|
|
|
|
wherever possible. Correct a couple mis-uses of the 'counter' attribute
when 'count' was intended. Fix some errors in the DTD and in the data with
'doubles_in_order'.
|
|
variable. Without this, GET_CURRENT_CONTEXT would *always* result in a call
to _glapi_get_context (because _glapi_Context is a const pointer to NULL in
TLS builds).
|
|
|
|
DRI drivers. A TLS enabled libGL can load a TLS or a non-TLS DRI driver,
but a TLS DRI driver requires a TLS enabled libGL.
This fixes bug #1822.
|
|
committed in the last version.
|
|
functions. There are two parts to this. First, a size element with a name
"Get" is shorthand for having four separate size elements with names
"GetIntegerv", "GetDoublev", "GetFloatv", and "GetBooleanv". Additionally,
a count of "?" is treated specially. This causes a call to a handcoded
function named "__gl<base name>_variable_size". This is *only* needed to
support GL_COMPRESSED_TEXTURE_FORMATS. That enum can return a variable
number of values depending how many compressed texture formats are supported
by the implementation.
Fix a problem with glGetProgram{Local,Env}Parameter[df]vARB,
glAreProgramsResidentNV, and glGetVertexAttribivNV. These changes only
affect code generated for the server-side.
The changes to enum.c are caused by enums added for the server-side
__glGetBooleanv_size functions.
|
|
FilterGLAPISpecBase::xref is replaced by
FilterGLAPISpecBase::functions_by_name. The notable difference between the
two is that ::functions_by_name includes all functions, whether they have an
assigned offset or not. This feature will be useful (necessary) when more
server-side code is generated.
|
|
same set of functions will be iterated for both the generated C-source file
and the generated header file.
|
|
'GLvoid *'). This fixes the GLX protocol for glGetProgramStringARB. This
fixes bugzilla #2747.
Remove the 'ignore="true"' from glVertexAttrib4bvARB. This fixes bugzilla
#2746.
|
|
for these extensions (as well as ARB_vertex_program and ARB_matrix_palette)
was just approved by the ARB on 8-Mar-2005. Now the only extension missing
for 1.5 support is ARB_vertex_buffer_object.
The opcodes for ARB_matrix_palette were also added to gl_API.xml. Since
this extension isn't supported by Mesa, no code is generated for it. Some
tabs were also converted to spaces in the comment for
GetCompressedTexImageARB.
|
|
|
|
program related functions.
|
|
endElement handler for <function>. This catches the errors as early as
possible and makes debugging other code easier.
|
|
now contains 3 static tables. The first table is a single, large string of
all the enum names. The second table is an array, sorted by enum name, of
indexes to the string table and the matching enum value. The extra string
table is used to eliminate relocs (and save space) in the compiled file.
The third table is an array, sorted by enum value, of indexes into the
second table.
The [name, enum] table contains all of the enums, but the table sorted by
enum-value does not. This table contains one entry per enum value. For
enum values that have multiple names (e.g., 0x84C0 has GL_TEXTURE0_ARB and
GL_TEXTURE0), only an index to the "best" name will appear in the table.
gl_enums.py gives precedence to "core" GL versions of names, followed by ARB
versions, followed by EXT versions, followed, finally, by vendor versions
(i.e., anything that doesn't fall into one of the previous categories). By
filtering the unneeded elements from this table, not only can we guarantee
determinism in the generated tables, but we save 364 elements in the table.
The optimizations outlined above reduced the size of the stripped enums.o
(on x86) from ~80KB to ~53KB.
The internal organization of gl_enums.py was also heavily modified.
Previously enums were stored in an unsorted list as [value, name] tuples
(basically). This list was then sorted, using a user-specified compare
function (i.e., VERY slow in most Python implementations) to generate a
table sorted by enum value. It was then sorted again, using another
user-specified compare function, to generate a table sorted by name.
Enums are now stored in a dictionary, called enum_table, with the enum value
as the key. Each dictionary element is a list of [name, priority] pairs.
The priority is determined as described above. The table sorted by enum
value is generated by sorting the keys of enum_table (i.e., very fast). The
tables sorted by name are generated by creating a list, called name_table,
of [name, enum value] pairs. This table can then be sorted by doing
name_table.sort() (i.e., very fast).
The result is a fair amount more Python code, but execution time was reduced
from ~14 seconds to ~2 seconds.
|
|
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
|
|
setup_single_request, and setup_vendor_request to the global functions
__glXReadPixelReply, __glXReadReply, __glXSetupSingleRequest, and
__glXSetupVendorRequest. This will make it easier to add handcoded Single /
VendorPrivate / VendorPrivteWithReply functions.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
when ready.
|
|
<include name="file"/> element as a sub-element of <OpenGLAPI>.
|
|
files that have been trivially changed by other recent commits.
|
|
|
|
in the gl_API.xml database. Add "official" support for SGI_color_matrix
and SGI_texture_color_table. These were previously supported only by
way of ARB_imaging.
|
|
glFunctionIterator and is used by GlxProto. The difference between the two
iterator classes is that glXFunctionIterator skips functions that the GLX
protocol code does not care about.
Replace all the remaining occurances of glParameter::p_count_parameters and
glFunction::count_parameters with the count_parameter_list.
Add GlxProto::size_call to generate the C code to calculate 'compsize'.
These trivially modify the generated code.
|
|
FilterGLAPISpecBase (in gl_XML.py). When these functions are used to emit
common #define lines, the will automatically be undefined in
FilterGLAPISpecBase::printFooter if header_tag is set (i.e., the file is a
header file).
These changes do not modify the generated code.
|
|
glXEnumFunction constructor. The allows sub-classes of GlxProto to
over-ride the concrete class used for glXEnumFunction.
In addition to tracking p_count_parameters in glParameter, break the comma
separated list of parameter names into a Python list called
count_parameter_list. It is now possible to query if a name is the name of
one of the count parameters just by comparing
param.count_parameter_list.count(n) to zero. Eventually the remaining uses
of p_count_parameters will be replaced with uses of count_parameter_list.
Make sure that 'void *' parameters are handled correctly in
glParameter::size_string.
Add PrintGlxReqSize_h and PrintGlxReqSize_c. These classes emit prototypes
and functions used on the server-side to determine the expected size of an
incoming GL command.
|
|
FilterGLAPISpecBase. Since the size_h mode of glX_proto_size.py will be
used to generate multiple header files, add an option to specify the define
that is used for multiple-inclusion protection.
The changes to the header files in this commit are just a side-effect of the
changes to the Python scripts.
|
|
client-side code doesn't try to calculate the size of the output
parameters. The server will tell the client how big it is.
|
|
parameters to GetColorTableParameter[if]v. FORMAT, WIDTH, and the SIZE
enums cannot be parameters to ColorTableParameter[if]v.
|
|
The attribute can now take one of 4 states. "false" (the default value)
means that no handcoding is required for the function. "client" means that
the function must be handcoded on the client-side only. "server" means that
the function must be handcoded on the server-side only. "true" menas that
the function must be handcoded on both the client-side and the server-side.
Version 1.14 of glX_proto_send.py accidentally contained a line of this
change.
|
|
The debug version of indirect.c has proven very helpful during the
development of new client-side and server-side GLX protocol code. This is
put here instead of in the DISPATCH and DISPATCH_RETURN macros in dispatch.c
for two reasons.
1. I only want the debug information when indirect-rendering is used.
2. Functions that require a reply from the server, some of which do not have
a return value (e.g., glFlush, glFinish, glGetLightfv, etc.), do not need
the extra glFinish call.
|
