Changing vb code to handle inputs correctly.

Start beginning of pixel shader generator..

Forgot to increase the length.

Looks like we need at least one instruction for pixel shader.

Get vertex programs supplied by the user work properly with immediate mode - vertex buffer mode worked by accident.

Fix alu_offset in SINGLE_TEXTURE_PIPELINE.

Since high bits can be used for flags, mask them out.
This stops arbvpwarpmesh from segfaulting and it actually works - with immediate mode rendering.

Remove redundant instructions from fixed pipelines, looks like they do not do anything, at least on my hardware.

Mark ZBIAS definitions.

This was too optimistic sorry - all that register does is something weird with polygon culling.

Get Polygon offset fill to work.
Make WARN_ONCE message more informative.

Added a bunch of extensions that were previously supported but weren't
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.

Check for heap == NULL before driSetTextureSwapCounterLocation.

Don't try to kick textures from a NULL tex heap.

Fixed flushing of client-side vertex buffers.

Fixed some debug output that was unconditionally enabled.

clamp viewport against ctx->Const.MaxViewportWidth/Height instead of MAX_WIDTH/HEIGHT

Changed parts of r300_setup_routing to use WARN_ONCE.

Small refactor.  Add glXFunctionIterator, which derrives from
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.

Add a missing break and a reminder.

Implement appropriate src checks for attribs/params.

Implemented bunch of ops.

Vertex programs work now with some restrictions. I expect arbvptorus to work
correctly when normals are delivered. Please note that some programs only
start in vb mode as there is something wrong in immediate mode vb code.

Make WARN_ONCE messages more informative.

Reduce noiseness of the driver.

Get alpha in textures to work properly.

Properly set ABLEND and CBLEND registers. The older code worked, but by accident.

Looks like we can define FIRE_VERTICES correctly.

It helps to print actual values instead of random ones.

Small refactor.  Move several utility functions from glX_XML.py to
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.

Add GlxProto::createEnumFunction and add a 'context' parameter to the
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.

Bug #2428: #ifdef GLX_DIRECT_RENDERING in DRI drivers is pointless.

makefile update (readtex, showbuffer)

Add magic sequence to prevent ClearBuffer from locking up.
Change Polygon.OffsetFill from fallback to warn once.
Quake demo now works, modulo texture rendering issues due to absent pixel shader pipeline.

Use SecondaryColorPtr, not ColorPtr[1] (the latter is NULL).
This fixes segfault in tuxracer-demo. It locks up after this though.

My bad, the old code works fine if updated to newer Mesa tree.

struct ati_fragment_shader was not defined anywhere, define it to get r300_vertexprog.c to compile.

fix max viewport query

Fix for compiler warnings.

add number of passes count to ati_fragment_shader

* Fixed uploading of textures of certain sizes.
* When glTexSubImageND is used, track the set of changed tiles in a
  bit vector and upload only dirty tiles later. This should improve
  the performance of dynamic light maps and gl movie player plugins.
* Renamed debug item "lru" to "tex". Indicate which levels are
  uploaded completely or partially.

Added 0x4e54 (Thinkpad r50p) as PCI_CHIP_RV350_NP

Beginings of program generation. This code havent been tested nor hooked up.

remove stray span.y++

added osmesa16 stuff

assorted fixes

fix initial viewport size bug

added missing glFinish()

Cleaning up.

Refactor the code to emit multiple-inclusion protection to
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.

move file

Properly annotate variable-length output parameters.  Make sure that the
client-side code doesn't try to calculate the size of the output
parameters.  The server will tell the client how big it is.

Fix some get / set errors with COLOR_TABLE_*.  SCALE and BIAS can be
parameters to GetColorTableParameter[if]v.  FORMAT, WIDTH, and the SIZE
enums cannot be parameters to ColorTableParameter[if]v.

Slightly modify the meaning of the 'handcode' attribute in a 'glx' element.
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.

Add an option to emit extra debug code in the generated protocol functions.
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.

Fix wrong comment.

Forgot one comment...

Add basic sceleton for vertex programs + some other fixes

Mark a couple more function parameters as counters.

Add numerous 'get'-type functions to most of the enums supported by the
server-side GLX implementation.

Correct the protocol for EXT_convolution.  Several functions were
incorrectly listed as 'sop' that should have been 'vendorpriv'.

Remove TexParameter[if]v from the list of functions associated with
TEXTURE_RESIDENT.  The state associated with this enum is read-only.

Sort the enums by value for each particular size.  This ensures that the
signature is the same no matter what the ordering is of the enums in the XML
file.  The side effect is that there are some extra changes in
indirect_size.c.

Add vector distance operator for vertex programs.

The 'mode' setting of a function within an 'enum' element is now used.
Parameters to glX_proto_size.py are now used to determine whether to emit
either get-type function, set-type functions, or both.  When only get-type
functions are emitted, they can optionally alias set-type functions.  This
would be useful if, for example, the two types were in different source
files.

The real work to implement this is in SizeStubFunctionIterator class.  All
of the logic for which functions to iterate and in which order is
implemented there.

remove a bunch of temporary #defines, now that glext.h was updated

(Stephane Marchesin, me) Add support for color (framebuffer) tiling to the radeon and r200 driver

new version check to allow to test for a range of ddx major versions, instead of just one major version

remove a bunch of temporary #defines, now that glext.h was updated

replace magic number with macro constant RADEON_ZBLOCK16

just comments/clean-up

added mutex to-do comment

just fix a comment and update date

RGB/LUMINANCE texelfetchers (float version) returned 255.0F for alpha channel, instead of 1.0F

Add a glFunctionIterator class to iterate over the functions stored in a
higher-level API object.  Use this type of object to implement the
printFunctions method.  Modify other functions that iterate over the list of
functions to use this type of object.

Fixes for clamp modes.

Use the _mesa_HashNextEntry() function to walk over all textures in the
hash table.
Moving toward removing the gl_texture_object's Next pointer (only used by
glide and tdfx drivers).

Stupid text editor...convert wayward tabs to spaces.

Add a "count" attribute to "enums" elements to set the default count
used for "size" sub-elements.  In the future the "count" attribute may
be removed completely from "size" sub-elements, so gl_API.xml was also
updated.

Support was added for a (currently unused) "mode" attribute for "size"
elements.  Basically, functions are marked as either "get" or "set".  This
will be used in generating size functions for the server-side (where the
"get" functions have to know how much data to return).  It could also be
used to help generate code for src/mesa/main/get.c.

Correctly set the name of the generating script.

Move all the code for generating "size" related functions to its own
source file.

Correct some of the dependencies and clean things up a bit.

Remove glEnum::startElement, but refactor out some of the common code from
there and glXEnum::startElement to glEnum::process_attributes.

Since only one of the places that used glXFunction::command_payload_length
actually used both values, it was refactored into command_fixed_length and
command_variable_length.  glXFunction::offset_of_first_parameter was also
added.

Make sure that functions added to gl_API.xml that do not have any GLX
section are marked as ignored.  Also ignore any functions that don't have
assigned dispatch offsets.

Fold Adam Jackson's changes to indirect_size.c into the generator scripts so
that they don't get lost.  "DO NOT EDIT" really means "DO NOT EDIT". ;)

border_color causes lockups with vertex buffers. Disabling for now.

Remove lots of old code that dealed with "magic" texture formats.

reenable some assertions

Converted the Savage texture management to use Ian's common texmem code.

Added _mesa_HashNextEntry() function to allow walking over all entries
in a hash table.
Added _mesa_test_hash_functions() for unit testing.
Updated comments, etc.

reapply Keiths workaround for zbs emit that got dropped during
state change patches....

Remove unused variables from r300_context

Fix more warnings and compilation issues.

Synchronize r300_reg.h.
Fix unportable whitespace before preprocessor commands.

add sync debugging to the radeon driver

HAVE_ALIAS was never defined anywhere, add some logic to turn it on
automagically.

silence makedepend warnings about non-portable whitespace

Fixed initialization of draw destination to front buffer on single
buffered visuals. Also don't change span draw/read buffers in
savageDDDrawBuffer. Now glean's polygon offset test works (and PASSes
with fixed point depth buffer) with single buffered visuals without
winding up in an infinite loop.

My last attempt to fix polygon offsets with the reversed viewport depth
range used by the savage driver by negating ctx->MRD broke polygon
offsets with software fallbacks. This one adds a REVERSE_DEPTH parameter
to t_dd_tritmp.h (defaults to 0) that allows reversing polygon offsets
for hardware rendering but not for software fallbacks. For software
fallbacks depth values are reversed after polygon offsets have been
applied by the depth span functions.

Determine ahead of time whether a display list will include vertices
which have to be processed in the 'loopback' path.  If so, send
all vertices that way as the transition from playback->loopback has
several problems.

Properly configure routing - based on advice by Keith Whitwell.

Fixed polygon offset with reversed viewport depth range.

Properly input stencil info contributed by Wladimir.

fix glGetString funniness