Compare commits

...

292 Commits

Author SHA1 Message Date
Sean D'Epagnier
ad02042db2 Fixed fallout, glfbdev driver was calling a nop function that was removed. 2007-04-21 20:18:42 -07:00
Brian
f793e90e82 Fix color sum bug 10688. 2007-04-21 15:58:37 -06:00
Brian
112e1f2b5a specularColor.alpha should default to 1, not 0 2007-04-21 15:56:10 -06:00
Brian
e5cf37c178 fix SkipPixels bugs in _mesa_pack_bitmap(), bug 10690 2007-04-21 14:12:57 -06:00
Brian
b5e9b0e562 Remove the !rb->Data check that was added a few months ago.
Was changed while debugging #7205.  Broke the shadowtext demo.  Revisit this
if the problem w/ bug 7205 returns...
2007-04-21 13:18:06 -06:00
Brian
b1502588c4 s/occlude.h/queryobj.h/ 2007-04-21 12:54:23 -06:00
Brian
74afcabd85 Rename occlude.[ch] to queryobj.[ch] 2007-04-21 12:42:54 -06:00
Brian
b3ab925e91 Rename occlude.[ch] to queryobj.[ch] to better reflect contents. 2007-04-21 12:36:39 -06:00
Brian
2d2c6a622d prep for 6.5.3 rc2 2007-04-21 12:31:51 -06:00
Brian
fc3d6bd351 memory leaks fixed 2007-04-21 12:30:58 -06:00
Brian
e261d66d81 Remove all the USE_MEMPOOL debug code. 2007-04-21 12:30:58 -06:00
Brian
cd3e39340f Use new memory pool allocator. Lots of debug code still in place... 2007-04-21 12:30:58 -06:00
Ian Romanick
ad3cc95485 Fix FBO completeness bug in shadowtex. 2007-04-21 10:48:24 -07:00
Brian
4e0a64675c added MemPool field 2007-04-21 10:18:49 -06:00
Brian
d5e7234ba8 call grammar_alloc_free() to fix memleaks 2007-04-21 10:05:05 -06:00
Brian
bc74cb4c0a destroy window upon exit 2007-04-21 10:05:05 -06:00
Brian
257f799849 remove more unused vars, assertions 2007-04-21 10:05:05 -06:00
Brian
81c4fee160 remove unused vars, assertions 2007-04-21 10:05:05 -06:00
Brian
1fbdd9d794 added slang_mem.c 2007-04-21 10:05:05 -06:00
Brian
82839e8430 Memory pool manager.
Instead of doing intricate malloc/free tracking during compiling, allocate
everything (which would be discarded after compiling) from a pool that can
be freed en masse when done.
2007-04-21 10:05:05 -06:00
Brian
ced6f76404 undo a test/debug change 2007-04-21 10:05:05 -06:00
Brian
4cc2674aee fix instruction comment code 2007-04-21 10:05:05 -06:00
Brian
a7f7366d38 another bit of debug code 2007-04-21 10:05:05 -06:00
Brian
11e3f733ba free subroutine array (fix mem leak) 2007-04-21 10:05:05 -06:00
Brian
98ef18909a new varnames in slang_operation_insert() 2007-04-21 10:05:05 -06:00
Brian
f2346498aa fix memleak in slang_operation_insert() 2007-04-21 10:05:05 -06:00
Brian
4b7c6fc5a6 free shProg->Attributes in _mesa_free_shader_program_data() 2007-04-21 10:05:05 -06:00
Brian
fe16b9f663 move allocation of shProg->Attributes earlier in function 2007-04-21 10:05:05 -06:00
Brian
c9855a60f4 Call _mesa_warning() instead of _mesa_problem() when external s3tc lib not found.
The later incorrectly encourages filing a bug (10703, for example).
2007-04-21 09:47:36 -06:00
Jeremy Kolb
838a2a2633 Make xcb backend compile.
Add nouveau to match linux-dri config.
2007-04-20 21:53:38 -04:00
Brian
e7e5279fc0 Remove unused Imakefiles. 2007-04-20 19:18:13 -06:00
Brian
7fd3a6c521 Long obsolete. 2007-04-20 19:01:21 -06:00
Brian
720cf3aa13 added new xm_glide.c file 2007-04-20 18:55:13 -06:00
George Sapountzis
5491c8194c xmesa: call _glapi_set_dispatch() for all xserver DDXes.
This is to unify the xmesa code across xserver DDX'es. The call is intented for
XGL, but it does not hurt to call for other DDX'es. In fact it was not guarded
against XGL when it was first added in xserver.
2007-04-20 21:09:00 +03:00
George Sapountzis
e4e2068ac9 xmesa: minor cosmetic
mainly drop 'client' argument from initialize_visual_and_buffer().
2007-04-20 21:08:58 +03:00
George Sapountzis
6346a753c6 xmesa: split FX functions to separate file, part 2. 2007-04-20 21:08:57 +03:00
George Sapountzis
4d944b502f xmesa: split FX functions to separate file, part 1. 2007-04-20 21:08:56 +03:00
George Sapountzis
6aa5668871 xmesa: spilt FX code to separate functions. 2007-04-20 21:08:55 +03:00
George Sapountzis
d60009bd6d Revert "xmesa: drop glide (FX) backend."
This reverts commit 2a2f8d806f.
2007-04-20 21:08:53 +03:00
Brian
535c37e85d Notes about shared lib version. Document depth-peel fixes. 2007-04-19 14:24:58 -06:00
Brian
ba3d384e94 dFdx(), etc. don't work yet 2007-04-19 14:24:29 -06:00
Brian
8b5fce6bcc Put gl_program_machine into swrast structure rather than using a local variable.
Basically an easy way to make sure the memory gets initialized once (to zero)
to avoid lots of valgrind warnings.
2007-04-19 14:24:10 -06:00
Brian
020cdb47cf Fix valgrind problem caused by reading text[-1]. 2007-04-19 14:15:11 -06:00
Brian
121f2212cc remove invalid assertion (span->facing may be set because of polygonmode) 2007-04-19 14:07:16 -06:00
Brian
24a93dd6a4 remove invalid assertion 2007-04-19 14:06:43 -06:00
Brian
00da9afb84 fix crash when program has invalid structure field 2007-04-19 14:06:27 -06:00
Brian
4abcaf3949 init A.curFuncEndLabel = NULL 2007-04-19 14:04:30 -06:00
Brian
6bde08815f In _mesa_unpack_depth_span() look for special cases of GLuint->GLushort and GLushort->GLuint conversion.
This improves performance and avoids int/float/int conversion problems that
can introduce errors during glCopyTexImage().  Another fix for the depth peeling
algorithm.
2007-04-19 11:23:26 -06:00
Brian
8e6207396c Don't allow deferredTexture if using occlusion query and a frag shader.
Occlusion query might depend on the shader killing/discarding fragments.
Helps fix depth peeling technique.
Also, minor tweaks in interpolate_wpos().
2007-04-19 11:21:14 -06:00
Brian
5ca8d4ccf2 fix an uninitialized variable and a warning 2007-04-18 18:05:33 -06:00
Brian
6b3027e291 comments, assertions 2007-04-18 17:14:14 -06:00
Brian
8d370fb2ee new comments 2007-04-18 17:14:14 -06:00
Brian
36a6a59972 record proper datatypes for uniforms/samplers 2007-04-18 17:14:14 -06:00
Brian
addd03da2e added _slang_gltype_from_specifier() 2007-04-18 17:14:13 -06:00
Brian
c93e883b20 Start fixing some issues with uniform variables and their types. 2007-04-18 17:14:13 -06:00
Brian
274ac7a801 Fix some bugs related to querying active uniforms. 2007-04-18 17:14:13 -06:00
Brian
aaa57412c1 fix error strings, add a sanity check 2007-04-18 17:14:13 -06:00
George Sapountzis
2a2f8d806f xmesa: drop glide (FX) backend.
glide is no longer compiled with stand-alone libGL, so this will not link.
There are still the glide config files. some code in demos and the
GLX_MESA_set_3dfx_mode code which could be removed.
2007-04-19 00:01:45 +03:00
Brian
bac15c8db8 Remove bad assertions, decrement NumShaders in _mesa_detach_shader().
Fixes crashes w/ Brad King's depth peeling test.
2007-04-18 14:55:18 -06:00
Brian
f3e8c32376 s/GL_SHADER_PROGRAM/GL_SHADER_PROGRAM_MESA/ (a Mesa-specific token) 2007-04-18 14:53:23 -06:00
Brian
6d3d9c1c6d Replace _mesa_parameter_longest_name() with _mesa_longest_parameter_name().
The later takes a type parameter so we can match uniforms or attributes/inputs.
Used by the GL_ACTIVE_ATTRIBUTE_MAX_LENGTH and GL_ACTIVE_UNIFORM_MAX_LENGTH
queries.  Fixes problem reported by Brad King in VTK.
2007-04-18 14:19:17 -06:00
Brian
e57e752eee call ProgramStringNotify() after linking 2007-04-18 12:41:16 -06:00
Brian
884af40864 check _PreferPixelFog in _swrast_span_default_fog(), see bug 10669 2007-04-18 12:09:40 -06:00
Brian
30a79f76fc improved fog comment 2007-04-18 12:08:18 -06:00
Brian
8598f55091 glean glsl test now does over 150 tests 2007-04-18 09:30:07 -06:00
Brian
6d01f3f1ec added href to shading language info 2007-04-18 09:28:38 -06:00
Brian
e3caa5f891 prep for 6.5.3 release 2007-04-18 09:07:56 -06:00
Brian
d9443c2494 add progs/glsl/ to DEMO_FILES, s/pre/rc1/ 2007-04-18 08:52:18 -06:00
Xiang, Haihao
565cd49b5f fig segment fault issue in TAG(triangle), (see bug 10589)
Bit SS_TWOSIDE_BIT is set if  gl_FrontFacing lives in
fragment input (see commit 10b5895597).
However, VB->ColorPtr[1] isn't assigned after that.
2007-04-18 12:37:09 +08:00
Brian
a4b2b88337 omit the glide/svga sources from stand-alone libGL (anyone using them?) 2007-04-17 16:00:17 -06:00
Brian
04bda46739 Enable texture sampling for vertex programs/shaders.
This is a bit of a hack for now because the tnl module is using the swrast
module to fetch texels.  The texture fetch/filter code should probably be
moved into the main/ module since it doesn't really depend upon other
swrast code.
2007-04-17 15:56:46 -06:00
Brian
d2d86a3f0b In bind_inputs() set VB->EdgeFlag to NULL if it's not needed.
Otherwise, the clip/interp code was finding VB->EdgeFlag to be non-null and
reading/writing it when the memory may have been freed earlier in free_space().
This fixes several VTK segfaults/failures reported by Brad King @ Kitware.
2007-04-17 10:19:47 -06:00
Brian
9cbcf7c696 regenerated 2007-04-17 09:16:59 -06:00
Brian
468a33d19a fix/simplify some texture functions 2007-04-17 09:16:30 -06:00
Brian
893b368a82 more matrix function updates 2007-04-17 09:15:57 -06:00
Brian
41fc55dd81 don't set GL_TEXTURE_MAX_LEVEL for GL_TEXTURE_RECTANGLE_ARB as that generates an error 2007-04-17 08:29:37 -06:00
Thomas Hellstrom
1a9483c954 Defer buffer pool creation to the first context creation.
This way we have a hw context so that we can take the hardware lock.
Also, at this point, AIGLX isn't locked with the X server context as it is
at screen creation.
2007-04-17 15:21:54 +02:00
Roland Scheidegger
36949abec7 cleanups for t_vb_program.c
use VertexProgram._Current instead of VertexProgram.Current in a few more places.
Only fixup fogc and psiz in case this is really a nv program (others are fine
if undefined), and fix this case up so the values actually get written.
2007-04-17 14:01:42 +02:00
Oliver McFadden
6459adf79b r300: r300_render.c:391: warning: unused variable 'i' 2007-04-17 07:05:15 +00:00
Brian
badc346206 lots of changes, fixes, clean-ups 2007-04-16 17:56:13 -06:00
Brian
4a7c45118d just clean-ups 2007-04-16 17:36:39 -06:00
Brian
34ca2be769 move GL_EXT_stencil_two_side into alphabetical position 2007-04-16 17:18:39 -06:00
Brian
5888010362 Fix glActiveStencilFaceEXT dispatch problem (bug 10523).
OK, _all_ extensions that might get enabled by the driver need to be in the
card_extensions[] list.  driInitExtensions() is called at least twice: first
during screen creation, then once for each context that's created.
The first call sets up the dispatch table.  The second call just sets the
extension enable/disable flags.
2007-04-16 17:16:46 -06:00
Brian
dfee7619d4 remove _tnl_arb_vertex_program_stage 2007-04-16 15:15:53 -06:00
Brian
96e05da1c9 remove _tnl_arb_vertex_program_stage 2007-04-16 15:15:23 -06:00
Brian
1560de2c3c need to clamp MAD for linear fog 2007-04-16 15:09:39 -06:00
Brian
921b008419 removed unused t_vb_arbprogram stage 2007-04-16 11:03:14 -06:00
Brian
aa6992a296 remove t_vb_arbprogram.c 2007-04-16 10:59:00 -06:00
Brian
4b3835dadf unhook t_vb_arbprogram.c code - it's going away 2007-04-16 10:58:30 -06:00
Brian
64e8088667 Use generic program limits instead of NV-specific ones to init program constants.
Previously, this limited us to 12 temp regs for vertex programs.  Many vertex
shaders could exceed that.  This forces us to stop using t_vb_arbprogram.c
for now because of its particular register indexing scheme.  Need to increase
bits allocated for register indexing, etc.
2007-04-16 10:36:28 -06:00
Brian
3dfcd48469 Fix some assertions that could occur when an error was earlier logged. 2007-04-16 10:32:48 -06:00
Brian
e812a2a484 use b->display instead of b->xm_visual->display to fix some problems detected w/ valgrind 2007-04-16 09:11:20 -06:00
Thomas Hellstrom
da56df9d72 Make sure we are locked when creating drm buffer objects.
Don't place buffer objects on unfenced list when newly created.
Fix a buffer object wait-for-idle deadlock.
2007-04-16 16:04:12 +02:00
Brian
9519785e29 illegal to set GL_TEXTURE_MAX_LEVEL w/ GL_TEXTURE_RECTANGLE_ARB 2007-04-14 09:38:20 -06:00
Brian
83ad64d94a implement shadow2DRect functions 2007-04-14 09:36:17 -06:00
Brian
fde15a2bae Fix sample_depth_texture() to handle texture rectangle coords. 2007-04-14 09:33:20 -06:00
Brian
216eb81c53 set osmesa renderbuffer refcount=1 upon creation, free renderbuffer in OSMesaDestroyContext() 2007-04-14 08:09:12 -06:00
Brian
4fc46a6c82 more _mesa_unreference_framebuffer() calls, remove dead code 2007-04-14 08:06:54 -06:00
Brian
e19cfabb6e fix negative zoom factor bug (10636), more comments 2007-04-14 07:49:21 -06:00
Dave Airlie
8d8a3cc398 r300: emit different clear paths for non-TCL, this gets the clear color correct 2007-04-14 17:44:33 +10:00
Dave Airlie
fb1d22d23d r300: remove unneeded semicolon from macro 2007-04-14 17:42:59 +10:00
Dave Airlie
3d59042afd r300: if we don't have TCL don't setup state emissions for vertex shaders 2007-04-14 04:54:49 +01:00
Brian
967c1056d5 patch for Digital/Tru64 (bug 10635) - forwarded to OpenGL ARB as well 2007-04-13 09:55:35 -06:00
George Sapountzis
9f8373d5ca xmesa: drop unused XMesaPutImageHelper.
It could only be called from XMesaCopySubBuffer but this function is not used
by XFree86.

It seems that XMesaPutImageHelper would handle sub-images but never got
finished. Proper sub-image helpers should be written if need be.
2007-04-13 18:13:08 +03:00
George Sapountzis
50aaabc248 xmesa: export xmesa functions used by xfree86.
This uses xmesa.h as the GLcore interface and avoids adding an explicit GLcore
inteface which would not be a proper interface anyway.

It puts the declarations of the three functions specific for XMesa/XFree86 in
xmesa.h, we can push them down to xmesa_xf86.h if hiding behind XFree86Server
ifdef's is not enough.
2007-04-13 18:12:37 +03:00
Brian
30b6f11de1 s/version/vertex/ 2007-04-12 16:18:27 -06:00
Brian
f11604a30d fix bug in _playback_copy_to_current(): need to skip version position data (see bug 10587) 2007-04-12 16:17:01 -06:00
Brian
99193e4f74 disable debug printfs 2007-04-12 15:45:02 -06:00
Brian
5b74fe0889 Added sanity checking in _slang_sizeof_type_specifier() to be sure sizes are what's expected. 2007-04-12 15:23:55 -06:00
Brian
431d650f2b use _mesa_clear_shader_program_data() 2007-04-12 15:22:53 -06:00
Brian
3c008a014f New _mesa_reference_shader/program() function to consolidate refcounting.
Note that (unlike texture objects), shader handles remain valid (in the
hash table) after glDeleteShader/Program() if the refcount isn't zero.
2007-04-12 15:22:32 -06:00
Brian
bf287356cf restore 200x200 window size, animation, version check 2007-04-11 14:09:32 -06:00
Brian
bce7043ebc regenerated 2007-04-11 12:30:31 -06:00
Brian
70b0e123c4 checkpoint: updating non-square matrix constructors and operators 2007-04-11 12:30:03 -06:00
Brian
f98f4f6d7a move/fix texture sampling funcs 2007-04-11 12:29:38 -06:00
Brian
afc58f5f7e s/Shadow/SHADOW/ 2007-04-11 11:13:37 -06:00
Brian
b61d74c575 as with prev commit, also fix color index mode zoomed depth copies (bug 10608) 2007-04-11 09:04:18 -06:00
Brian
9f66025f54 fix invalid error detection problem in _mesa_bind_attrib_location(), bug 10602 2007-04-11 09:00:56 -06:00
Brian
183d8e0620 fix zoomed depth copies (bug 10608) 2007-04-11 08:47:05 -06:00
Brian
b0bba03846 use _mesa_reference_renderbuffer(), fix typo 2007-04-11 08:11:52 -06:00
Brian
ba876be0c0 fix/work-around allocation bugs for non-square matrices 2007-04-10 21:51:27 -06:00
Brian
319ce38fa4 update SLANG version test 2007-04-10 21:50:53 -06:00
Dave Airlie
64700be4e1 rs480: set vap cntl to what fglrx uses for non-TCL cards 2007-04-10 11:46:58 +01:00
Michel Dänzer
159ecba4b3 i915: Bring test for vsync to pipe B in line with i915tex. 2007-04-10 11:05:17 +02:00
Michel Dänzer
e798d22556 Add missing generated file. 2007-04-10 11:04:19 +02:00
Brian
0109b47106 NULL ptr check 2007-04-09 19:07:22 -06:00
Brian
7b2626f7d8 plug in GLSL 1.20 unit 2007-04-09 19:07:22 -06:00
Brian
19121e2802 undo a debug/test change 2007-04-09 19:07:22 -06:00
Dave Airlie
e0bbf46342 r300: don't enable VAP/TCL on cards that don't support it 2007-04-10 09:32:13 +10:00
Brian
702c8f1e6c remove unneeded initialization code (see bug 10569) 2007-04-09 11:21:51 -06:00
Brian
f9574c3f6b allocate __GLXdisplayPrivate w/ Xcalloc instead of Xmalloc (bug 10569) 2007-04-09 08:49:26 -06:00
Michel Dänzer
e8292d28e4 i915tex: Fix some mismatches between texels or bytes for pitch/stride. 2007-04-09 14:57:08 +02:00
Michel Dänzer
c96974f78c i915tex: Make sure texture format fetch hooks are initialized. 2007-04-09 14:53:41 +02:00
Dave Airlie
6461e91ac3 the RS400 definitely doesn't work at this point so don't let it init 2007-04-09 22:03:31 +10:00
Brian
af807a4696 enable GLSL 1.20 2007-04-08 21:48:19 -06:00
Brian
5c0c60a13c support for GLSL 1.20 non-square matrices 2007-04-08 16:47:32 -06:00
Brian
5dba996dba add glsl to PROGRAM_DIRS 2007-04-08 15:50:31 -06:00
Brian
9612a3011f fix some dependencies, remove some CFLAGS 2007-04-08 15:42:26 -06:00
Brian
0d3d930912 add 2.1 functions 2007-04-08 15:41:02 -06:00
Adam Jackson
d8bfc42bb7 Make sure GLX entrypoints are marked PUBLIC.
Fedora bug #229808.
2007-04-08 14:40:03 -04:00
Wei Wang
ca7885f733 fix bug 9823: GL_CLIENT_ATTRIB_STACK_DEPTH query fails for indirect rendering 2007-04-08 11:24:08 -06:00
Michel Dänzer
9176752172 i915tex: Clean up resizing of renderbuffers. 2007-04-08 14:04:15 +02:00
Michel Dänzer
79bf692420 driUpdateFramebufferSize: Use ctx->Driver.ResizeBuffers. 2007-04-08 14:02:14 +02:00
Brian
f72e7fb1d6 MAX_TEXTURE_COORDS_ARB and MAX_TEXTURE_IMAGE_UNITS_ARB had wrong glGet info.
Fixes bug 10371.
2007-04-07 20:38:25 -06:00
Brian
4647f13c43 fix etags command to find headers 2007-04-07 19:36:58 -06:00
George Sapountzis
20ec486baf Drop XFree86Server from execmem.c
This is a remnant from the libcwrapper days that can be removed now. It is the
last XFree86 glitch in Mesa core.

Reverts the following commit (thanks to Brian Paul for pointing to it):

commit 8b1dc68662
Author: Alan Hourihane <alanh@tungstengraphics.com>
Date:   Tue Jan 24 21:40:53 2006 +0000

    pull in fix from 6.4 branch for XFree86Server definition

commit cc7b6810e2
Author: Ian Romanick <idr@us.ibm.com>
Date:   Fri Oct 21 18:09:24 2005 +0000

    Make execmem.c compile in the server (libGLcore).  Since xf86mmap
    doesn't know about MAP_ANONYMOUS, this is the only viable fix.  This
    issue will likely have to be revisited at some point.
2007-04-07 18:41:14 +03:00
Richard Hughes
55000888b9 set version for tarballs to 6.5.3pre for now 2007-04-07 08:48:07 -06:00
Richard Hughes
4f9d3a07bb fix references to non-existant sz4 field 2007-04-07 08:46:44 -06:00
Richard Hughes
84803279ca fix some CHAN_TYPE==GL_FLOAT breakage 2007-04-07 08:46:10 -06:00
Brian
8d2d6e5194 fix comment typo 2007-04-07 08:43:40 -06:00
Richard Hughes
e9c614a1af remove array_cache/, add vbo/ 2007-04-07 08:39:24 -06:00
Brian
8f3fc5221c added glActiveStencilFaceEXT 2007-04-07 08:38:36 -06:00
Brian
ae55d5322c for evaluators, loop to VBO_ATTRIB_TEX7, not VBO_ATTRIB_INDEX. See bug 10543 2007-04-06 15:45:11 -06:00
George Sapountzis
92b7fa7b48 xmesa: use newly added xm_image.[hc]
Keep external includes to glxheader.h and xmesa includes to xmesaP.h.

Drop the following from xm_image.h:
- dix-config.h (comes from glheader.h)
- xfree86 includes (come from GL/xmesa_xf86.h)
- ifdef __CYGWIN__ (leftover ? xm_api.c has something similar)
2007-04-06 13:28:39 +03:00
George Sapountzis
eb4a8b4bb5 xmesa: add xf86glx_util.[hc] from xserver as xm_image.[hc] 2007-04-06 13:27:43 +03:00
George Sapountzis
663a3e9ba7 Drop the funky SSE exception test on linux.
Replace the check for IN_DRI_DRIVER with the appropriate kernel version check
and just disable SSE on older (pre 2.4) kernels.
2007-04-06 13:22:41 +03:00
Brian
51a894e6eb fix color storage bug in convolution path 2007-04-05 21:12:44 -06:00
Brian
ac32b644ee include points.h to fix warnings 2007-04-05 11:43:07 -06:00
George Sapountzis
487f7a73cb Remove SI imports/exports remnants. 2007-04-05 19:01:51 +03:00
George Sapountzis
aa1c79eaea glx: minor cosmetic in glcontextmodes.c
move memory macros to separate block and unwrap malloc/free for miniglx towards
cleaning Mesa core glitches in glx...
2007-04-05 19:00:47 +03:00
George Sapountzis
885111518e Move glcontextmodes.c to glx.
It is no longer linked with DRI drivers, libGL passes function pointers through
the DRI interface.
2007-04-05 18:59:42 +03:00
Brian
0cae814f36 temporary add some extra renderbuffer debug code 2007-04-05 09:28:09 -06:00
Brian
33c3739628 Remove the never-used SI-style imports/exports code. 2007-04-04 22:18:53 -06:00
Brian
4d864b087e assorted updates 2007-04-04 09:33:12 -06:00
Brian
2f207dcf1e assorted documentation updates 2007-04-04 09:31:41 -06:00
Brian
f9c01c33d3 init span.y=0 to silence warnings 2007-04-04 09:30:28 -06:00
Brian
d4dc57bb13 Overlapping copies with zoomZ=-1 were broken. See bug 10521.
Need to check for overlapping src/dest regions before computing bottom-to-top
vs. top-to-bottom order.
2007-04-04 08:48:06 -06:00
Brian
a28e648690 remove debug printf 2007-04-04 08:26:41 -06:00
Xiang, Haihao
40ae3943f2 i810/i915/i915tex: reinitialize the context point state 2007-04-04 16:50:47 +08:00
Nicolai Haehnle
dba21ed913 Fix in t_vp_build: Missed necessary updates sometimes
_mesa_update_state doesn't always reset VertexProgram._Current to NULL.
This caused us to skip a necessary update of the fixed function vertex
program sometimes.

Change the logic such that we check for updates whenever the _Current
program is either NULL or the program generated by t_vp_build.
2007-04-02 21:01:32 +02:00
Brian
66d336808d Call _glapi_set_context(NULL) in _glapi_check_multithread() to make sure the _glapi_Context global gets cleared properly. 2007-04-02 10:03:34 -06:00
Brian
dccd9c4f4d use _mesa_reference_renderbuffer() in a few more places 2007-04-02 09:57:27 -06:00
Brian
3fe47d5c57 updated debug printf 2007-04-02 09:57:27 -06:00
Brian
3fd88089c0 Fix some bugs/issues related to alpha channel support. See bug 10483. 2007-04-01 18:30:28 -06:00
Brian
0683e4ce4b If using PF_8A8B8G8R, be sure alpha is correctly handled. 2007-04-01 18:28:28 -06:00
Brian
ec42af9263 re-order tokens, fix comments 2007-04-01 18:27:23 -06:00
Brian
00831b5b3b always emit BGN/ENDSUB, for now anyway 2007-03-31 09:09:48 -06:00
Brian
ec6c8f86f3 fix scoping mistake in previous commit that checked for writable LHSs 2007-03-31 09:09:21 -06:00
Brian
e608d92c5b check that LHS of assignment is writable 2007-03-30 14:59:02 -06:00
Eric Anholt
57dadf71ca Merge branch 'origin' 2007-03-30 13:18:27 -07:00
Eric Anholt
adb91c056f Merge branch 'crestline-qa', adding support for the 965GM chipset. 2007-03-30 13:11:38 -07:00
Gustavo Pichorim Boiko
6f652c89d7 call DRI_VALIDATE_DRAWABLE_INFO(), bug 10477 2007-03-30 14:10:10 -06:00
George Sapountzis
7439a36785 Clean and update XMesa/XFree86 interface.
Drop XMesaSetVisualDisplay(), XMesaReset(), no longer used.

Add XMesaCopyContext() and move the GlxSetRenderTables() call for XGL within
XMesaForceCurrent(). This is to make xserver/GL/mesa/X/xf86glx.c unaware of
Mesa internals.

Also, clean some ifdef's to make it clear that USE_XSHM and XFree86Server are
mutually exclusive.

Lastly,
- move gcstruct.h from glxheader.h up to xmesa_xf86.h since it calls *gc->ops
- drop GL/glxtokens.h from xm_api|dd.c, GLX tokens come from glcore.h and are
  used irrelevant of XFree86.
2007-03-30 19:19:00 +03:00
Brian
7eba12edce more tips, validation info 2007-03-28 17:14:35 -06:00
Brian
ba730e14ed cond code fix 2007-03-28 17:08:17 -06:00
Brian
1ba858591b fix cond code swizzle bug 2007-03-28 15:45:24 -06:00
Brian
f2f5d06853 Handle logical NOT and XOR without library functions. Results in much tighter code. 2007-03-28 15:16:33 -06:00
Brian
b2ac30ac36 optimization for the emit_not() function 2007-03-28 14:49:33 -06:00
Brian
3b7f2f53a2 remove IR_BREAK_IF_FALSE 2007-03-28 14:38:36 -06:00
Brian
8128f7143d don't generate IR_BREAK_IF_FALSE 2007-03-28 14:33:25 -06:00
Brian
393a93ea32 Get rid of IR_CONT_IF_FALSE 2007-03-28 14:25:30 -06:00
Brian
3e7d43cd48 Get rid of BRK0, BRK1, CONT0, CONT1 instructions. 2007-03-28 14:23:33 -06:00
Brian
1bbd69251b Don't emit OPCODE_CONT0/1, BRK0/1 instructions, clean-ups elsewhere. 2007-03-28 14:21:26 -06:00
Brian
f841b04601 simplify, clean-up break/cont code 2007-03-28 14:14:00 -06:00
Brian
b463d52143 added some null ptr checks to handle error recovery 2007-03-28 13:29:57 -06:00
Brian
7e4a7fdddd Use constant_to_src_reg() to simplify some code 2007-03-28 13:23:44 -06:00
Brian
ee2f31e281 added missing returns after slang_info_log_error() calls 2007-03-28 12:48:27 -06:00
Brian
dad97b4688 Fix, clean-up code related to comparisons, condition codes, etc. 2007-03-28 11:06:34 -06:00
Brian
a01616eed5 print condcodes if DEBUG_PROG 2007-03-28 11:01:28 -06:00
Brian
d750861dc2 expose _mesa_condcode_string(), fix some printing 2007-03-28 11:01:09 -06:00
Brian
59f7f6dbe9 check that if/while/do-while condition is boolean or scalar 2007-03-28 10:44:38 -06:00
Brian
20d85c609a bump version to 6.5.3 to match version.h 2007-03-28 09:07:41 -06:00
Alan Hourihane
ad766b5785 Add missing OSMesaColorClamp function 2007-03-28 15:58:08 +01:00
Brian
0420d8505a disable MakeTexture() 2007-03-27 16:06:48 -06:00
Brian
05e6fd8398 added ftransform() comment 2007-03-27 16:06:48 -06:00
Brian
e5d00e8cf4 Implement true CAL/RET subroutines. Some optimizations, clean-ups coming... 2007-03-27 16:06:48 -06:00
Brian
31dc7a3c89 fix another pc off-by one 2007-03-27 16:06:47 -06:00
Brian
17238f1ee5 added _slang_label_new_unique() 2007-03-27 16:06:47 -06:00
Brian
f407cada8a fix some printing issues related to subroutines 2007-03-27 16:06:47 -06:00
Brian
e713ef66ef fix a fragment fog regression 2007-03-27 16:06:47 -06:00
Brian
a0275b0d2c fix off by one error in OPCODE_RET 2007-03-27 16:06:47 -06:00
Brian
d6d6d20b13 init machine->StackDepth=0 2007-03-27 16:06:47 -06:00
Brian
1f1f582304 more parenthesis 2007-03-27 16:06:47 -06:00
Roland Scheidegger
811c2e9a91 i915tex compile fix (account for moved _UseTexEnvProgram var) 2007-03-27 22:57:22 +02:00
Roland Scheidegger
cda3236092 fix incorrect _MaxElement calculation
The calculation of _MaxElement was wrong if the stride was larger than
elementSize, which lead to rejection of every DrawElements call which accessed
the maximum element if CheckArrayBounds was enabled.
2007-03-27 21:03:32 +02:00
Roland Scheidegger
9b9e056615 recommit e731d8aafa.
This got lost with glsl-compiler-1 merge, it fixes segfaults when using
ATI_fragment_shader, which uses the ProgramStringNotify mechanism but doesn't
have a valid program pointer.
2007-03-27 19:33:34 +02:00
Brian
ff65fa39e8 add parenthesis around a bit-wise AND term in _tnl_InvalidateState() 2007-03-27 09:52:53 -06:00
Brian
3e45db6729 Restore the UseTexEnvProgram logic.
Was removed during glsl-compiler work.  Still need to go back and revisit this
because of the interaction with fragment shaders...
2007-03-27 09:51:52 -06:00
Roland Scheidegger
3b8ab88131 r300: Fix radeonUpdatePageFlipping() function.
Always call driFlipRenderbuffers() with pfCurrentPage value, in case it's
initially 1 instead of 0. May fix some issues with pageflip, the same fix was
applied to r128, radeon and r200 (6e0e6eff05).
2007-03-27 16:27:34 +02:00
Roland Scheidegger
32225d06b9 r128, radeon, r200: Check ctx->WinSysDrawBuffer before calling function that dereferences it.
Same fix as for r300 (which fixed https://bugs.freedesktop.org/show_bug.cgi?id=10417),
since it's likely an issue with those drivers too.
2007-03-27 16:22:00 +02:00
Bernardo Innocenti
a835939222 always print error messages, unless LIBGL_DEBUG=quiet 2007-03-27 08:05:33 -06:00
Brian
98abd1bbc8 simplify .a suffixing 2007-03-27 07:58:47 -06:00
Bernardo Innocenti
a9455bb9a7 remove static lib before building to make more bulletproof 2007-03-27 07:56:34 -06:00
Michel Dänzer
63c57a14d3 r300: Check ctx->WinSysDrawBuffer before calling function that dereferences it.
Fixes https://bugs.freedesktop.org/show_bug.cgi?id=10417 .
2007-03-27 09:44:32 +02:00
Miroslav Šustek
25f21b5331 fix r128 rendering, lockups
mis-count in offset led to mis-rendering and lockups;
units are 4 bytes rather than 1.  Noticed by Chris Salch.
fixes bug 7994, possibly others.
2007-03-26 23:40:04 -04:00
Zou Nan hai
da82d86ea0 Merge branch 'master' of git+ssh://znh@git.freedesktop.org/git/mesa/mesa 2007-03-27 09:41:31 +08:00
Zou Nan hai
075d3d892f Fix compile error 2007-03-27 09:41:01 +08:00
Brian
ae36cfc65e s/SUB/BGNSUB/ 2007-03-26 18:47:19 -06:00
Brian
9878e8ff51 Checkpoint: implementing true CAL/RET instructions for subroutine calls.
Also, found/fixed a code generation regression:  the emit_swizzle() function
was always returning NULL.  This caused emit_move() to miss its chance at peephole
optimization.
2007-03-26 18:46:07 -06:00
Brian
6583429f89 Get rid of IR_JUMP and related code. 2007-03-26 17:16:26 -06:00
Brian
037c068460 special case RET 2007-03-26 16:58:50 -06:00
Brian
c042a91b8b Get rid of SLANG_OPER_GOTO, start rewrite of 'return' handling. 2007-03-26 16:56:45 -06:00
Brian
813a0e11f1 remove debug abort() calls 2007-03-26 16:01:58 -06:00
Brian
52cc32378c Additional error checking for 'return' statements. 2007-03-26 15:46:35 -06:00
Brian
c3da0bd7dd undo some debugging hacks 2007-03-26 15:09:59 -06:00
Brian
e508155d16 dead code elimination for constant-valued if/then/else 2007-03-26 15:02:21 -06:00
Nicolai Haehnle
0426d3c0c8 r300: Remove a warning when vertex programs produce an unused output
As far as we know, the hardware prefers outputs packed tightly together
with no holes caused by outputs that are not even read by the fragment
program. Therefore, we slightly rewrite vertex programs in this case.

It would be interesting to test this interaction between vertex programs
and fragment programs further, because some of that rewrite may be
unnecessary. However, play it safe for now and don't change the current
behaviour.
2007-03-26 22:25:06 +02:00
Nicolai Haehnle
b53745ce91 r300: Whitespace cleanup (remove trailing spaces) 2007-03-26 22:25:06 +02:00
Brian
768f7231ea Fix a few issues with computing storage sizes with respect to swizzles. 2007-03-26 13:46:46 -06:00
Brian
680abf8a02 In _mesa_lookup_parameter_constant() make sure we return a full, 4-component swizzle. 2007-03-26 13:46:46 -06:00
Nicolai Haehnle
1170268088 r300: Fix warnings that were introduced by the glsl merge 2007-03-26 21:41:57 +02:00
Brian
38a1c2b495 Add _swrast_span_default_secondary_color() for use with glBitmap, glDrawPixels, etc.
Secondary color wasn't getting added to post-texture color when drawing
bitmaps, images.  See bug 10409.
2007-03-26 11:30:05 -06:00
Brian
b5d988dd19 remove incorrect assertions 2007-03-26 10:39:56 -06:00
Brian
b67d93111d minor status updates 2007-03-26 10:23:50 -06:00
Nian Wu
ee9bc897f8 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-26 17:00:29 +08:00
Nian Wu
1b354bb5e4 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-25 17:00:24 +08:00
Nian Wu
44fb5156bb Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-24 17:00:29 +08:00
Nian Wu
ad76128204 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-23 17:00:28 +08:00
Nian Wu
2eb656ef4f Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-22 17:00:33 +08:00
Nian Wu
8ba06464ac Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-21 17:00:32 +08:00
Nian Wu
76444d042c Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-20 13:10:46 +08:00
Nian Wu
e01ee3da57 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-19 17:00:19 +08:00
Nian Wu
fd1b1fce3f Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-18 17:00:18 +08:00
Nian Wu
38889f5221 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-17 17:00:25 +08:00
Nian Wu
a02870f4f6 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-16 17:00:24 +08:00
Nian Wu
d63eef4b86 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-15 17:00:22 +08:00
Nian Wu
805b1cf482 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-14 17:00:15 +08:00
Nian Wu
4110fac389 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-13 17:00:18 +08:00
Nian Wu
5a5b55943d Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-12 09:03:27 +08:00
Nian Wu
1e055089a3 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-07 16:01:36 -05:00
Nian Wu
87c9ad6fd5 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-06 16:01:23 -05:00
Nian Wu
c05b6f800a Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-06 07:43:03 -05:00
Nian Wu
540e1c70cc Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-05 09:01:31 -05:00
Nian Wu
180c0d70c4 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-02 09:01:27 -05:00
Nian Wu
6a47e35065 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-03-01 09:01:58 -05:00
Nian Wu
381b4b0c91 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-02-27 14:42:16 -05:00
Nian Wu
675f7f627b Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2007-02-25 09:40:28 -08:00
Wang Zhenyu
51bfb8fc8c Add Intel 965GM chipset info 2007-02-02 10:04:48 +08:00
Wang Zhenyu
6b6760d6bc Revert origin crestline pci id patch 2007-02-02 10:01:42 +08:00
Zou Nan hai
c171166987 1. Fix bug #155
2. I notice multiple ARB_occlusion_query should be able to overlap according to spec.

3. Declaring extern variables in a .c file is evil, fix it.
2007-01-18 14:41:38 +08:00
Keith Packard
a27d3e43fe Merge branch 'master' into crestline 2007-01-07 23:03:01 -08:00
Keith Packard
6a632de96d Merge branch 'origin' into crestline 2007-01-07 20:57:56 -08:00
Keith Packard
92de58f001 Merge branch 'master' into crestline 2007-01-06 17:14:14 -08:00
Wang Zhenyu
caf8010652 Merge branch 'master' into crestline
Conflicts:

	src/mesa/drivers/dri/i965/brw_tex_layout.c

Michel Dänzer replaced the copy of the 945 mipmap layout code with that from
the 945 driver directly.
2007-01-06 15:49:23 -08:00
Nian Wu
f34cad0f97 Merge branch 'crestline' into crestline-qa 2006-12-26 16:46:51 -08:00
Haihao Xiang
adccb084df Support linear format in i965.
Fix bug #117 #118
2006-12-26 16:45:02 -08:00
Nian Wu
ead0f46d5f Merge branch 'crestline' into crestline-qa 2006-12-17 10:49:43 -08:00
Nian Wu
77b862a849 Merge git://proxy01.pd.intel.com:9419/git/mesa/mesa into crestline 2006-12-13 13:49:00 -08:00
Zou Nan hai
ed7fbad206 Fix bug #93, i965 driver not thread safe.
I am not confident of it is 100% thread safe now.
  bufmgr_fake.c need a total rewrite later
(cherry picked from 606632ca27558ee1335be2f4a5906f2baa240a6a commit)
2006-12-13 13:29:37 -08:00
Zou Nan hai
4720cd0050 fix bug #99.
prim_count overflow when there is more than 1 cliprect
(cherry picked from 84b958d66fe7d3fe03ed12b493e3f3197f656531 commit)
2006-12-13 13:29:20 -08:00
Michel Dänzer
c9795c6ca2 minstall: Pass correct destination file path to $RM regardless of source path.
(cherry picked from 26626c0052 commit)
2006-12-13 13:26:09 -08:00
Michel Dänzer
bce82efe1f minstall: Always remove destination file before (re-)creating it.
This avoids issues with overwriting files that are being used.
(cherry picked from d71a5647a3 commit)
2006-12-13 13:25:42 -08:00
Zou Nan hai
aeda4c589a ARB_occlusion_query support 2006-12-13 13:25:12 -08:00
Zou Nan hai
696fe3f52e if (tex width < 4), mipmap calculation will be out of range 2006-12-13 13:24:35 -08:00
Zou Nan hai
c34d026eb0 Fix bug #93 2006-12-13 15:27:17 +08:00
Zou Nan hai
de90bbd0b7 fix for bug #99 2006-12-12 15:00:27 +08:00
Eric Anholt
d214138910 Merge branch 'origin' into crestline 2006-12-11 10:50:25 -08:00
Wang Zhenyu
89433fef0d ARB_occlusion_query support 2006-12-11 00:01:56 -08:00
Wang Zhenyu
b4d9c0048f if (tex width < 4), mipmap calculation will be out of range 2006-12-11 00:00:51 -08:00
Eric Anholt
9a94dae4c2 Avoid branch instructions while in single program flow mode.
There is an errata for Broadwater that threads don't have the instruction/loop
mask stacks initialized on thread spawn.  In single program flow mode, those
stacks are not writable, so we can't initialize them.  However, they do get
read during ELSE and ENDIF instructions.  So, instead, replace branch
instructions in single program flow mode with predicated jumps (ADD to the ip
register), avoiding use of the more complicated branch instructions that may
fail.  This is also a minor optimization as no ENDIF equivalent is necessary.
2006-12-10 12:24:51 -08:00
Eric Anholt
183abbcd6b Connect INTEL_DEBUG=sync up to cmd/batch ioctls. 2006-12-10 12:24:46 -08:00
Wang Zhenyu
0536268267 adding pci id of Crestline 2006-12-10 12:24:40 -08:00
199 changed files with 6052 additions and 7347 deletions

View File

@@ -155,10 +155,10 @@ ultrix-gcc:
# Rules for making release tarballs
DIRECTORY = Mesa-6.5.2
LIB_NAME = MesaLib-6.5.2
DEMO_NAME = MesaDemos-6.5.2
GLUT_NAME = MesaGLUT-6.5.2
DIRECTORY = Mesa-6.5.3rc2
LIB_NAME = MesaLib-6.5.3rc2
DEMO_NAME = MesaDemos-6.5.3rc2
GLUT_NAME = MesaGLUT-6.5.3rc2
MAIN_FILES = \
$(DIRECTORY)/Makefile* \
@@ -209,9 +209,6 @@ MAIN_FILES = \
$(DIRECTORY)/src/mesa/glapi/*.[chS] \
$(DIRECTORY)/src/mesa/glapi/descrip.mms \
$(DIRECTORY)/src/mesa/glapi/sources \
$(DIRECTORY)/src/mesa/array_cache/*.[ch] \
$(DIRECTORY)/src/mesa/array_cache/descrip.mms \
$(DIRECTORY)/src/mesa/array_cache/sources \
$(DIRECTORY)/src/mesa/math/*.[ch] \
$(DIRECTORY)/src/mesa/math/descrip.mms \
$(DIRECTORY)/src/mesa/math/sources \
@@ -231,6 +228,8 @@ MAIN_FILES = \
$(DIRECTORY)/src/mesa/swrast_setup/*.[ch] \
$(DIRECTORY)/src/mesa/swrast_setup/descrip.mms \
$(DIRECTORY)/src/mesa/swrast_setup/sources \
$(DIRECTORY)/src/mesa/vbo/*.[chS] \
$(DIRECTORY)/src/mesa/vbo/descrip.mms \
$(DIRECTORY)/src/mesa/tnl/*.[chS] \
$(DIRECTORY)/src/mesa/tnl/descrip.mms \
$(DIRECTORY)/src/mesa/tnl/sources \
@@ -365,6 +364,9 @@ DEMO_FILES = \
$(DIRECTORY)/progs/samples/Makefile* \
$(DIRECTORY)/progs/samples/README \
$(DIRECTORY)/progs/samples/*.c \
$(DIRECTORY)/progs/glsl/Makefile* \
$(DIRECTORY)/progs/glsl/*.c \
$(DIRECTORY)/progs/glsl/*.txt \
$(DIRECTORY)/progs/windml/Makefile.ugl \
$(DIRECTORY)/progs/windml/*.c \
$(DIRECTORY)/progs/windml/*.bmp \

View File

@@ -212,15 +212,16 @@ case $ARCH in
# finish up
FINAL_LIBS="${LIBNAME}"
elif [ $STATIC = 1 ] ; then
LIBNAME="lib${LIBNAME}" # prefix with "lib"
echo "mklib: Making" $ARCH "static library: " ${LIBNAME}.a
LIBNAME="lib${LIBNAME}.a" # prefix with "lib", suffix with ".a"
echo "mklib: Making" $ARCH "static library: " ${LIBNAME}
LINK="ar"
OPTS="-ru"
rm -f ${LIBNAME}
# make lib
${LINK} ${OPTS} ${LIBNAME}.a ${OBJECTS}
ranlib ${LIBNAME}.a
${LINK} ${OPTS} ${LIBNAME} ${OBJECTS}
ranlib ${LIBNAME}
# finish up
FINAL_LIBS=${LIBNAME}.a
FINAL_LIBS=${LIBNAME}
else
LIBNAME="lib${LIBNAME}" # prefix with "lib"
case $ARCH in 'Linux' | 'GNU' | GNU/*)

View File

@@ -10,7 +10,7 @@ CONFIG_NAME = default
# Version info
MESA_MAJOR=6
MESA_MINOR=5
MESA_TINY=2
MESA_TINY=3
# external projects. This should be useless now that we use libdrm.
DRM_SOURCE_PATH=$(TOP)/../drm
@@ -63,7 +63,7 @@ SRC_DIRS = mesa glu glut/glx glw
GLU_DIRS = sgi
DRIVER_DIRS = x11 osmesa
# Which subdirs under $(TOP)/progs/ to enter:
PROGRAM_DIRS = demos redbook samples xdemos
PROGRAM_DIRS = demos redbook samples glsl xdemos
# Library/program dependencies

View File

@@ -22,7 +22,8 @@ ARCH_FLAGS ?=
DEFINES = -D_POSIX_SOURCE -D_POSIX_C_SOURCE=199309L -D_SVID_SOURCE \
-D_BSD_SOURCE -D_GNU_SOURCE \
-DPTHREADS -DUSE_EXTERNAL_DXTN_LIB=1 -DIN_DRI_DRIVER \
-DGLX_DIRECT_RENDERING -DHAVE_ALIAS -DUSE_XCB -DHAVE_POSIX_MEMALIGN
-DGLX_DIRECT_RENDERING -DGLX_INDIRECT_RENDERING \
-DHAVE_ALIAS -DUSE_XCB -DHAVE_POSIX_MEMALIGN
X11_INCLUDES = `pkg-config --cflags-only-I x11` `pkg-config --cflags-only-I xcb` `pkg-config --cflags-only-I x11-xcb` `pkg-config --cflags-only-I xcb-glx`
@@ -65,4 +66,4 @@ WINDOW_SYSTEM=dri
# gamma are missing because they have not been converted to use the new
# interface.
DRI_DIRS = i810 i915 mach64 mga r128 r200 r300 radeon s3v \
savage sis tdfx trident unichrome ffb
savage sis tdfx trident unichrome ffb nouveau

View File

@@ -25,6 +25,7 @@ a:visited {
<ul>
<li><a href="intro.html" target="MainFrame">Introduction</a>
<li><a href="news.html" target="MainFrame">News</a>
<LI><A HREF="developers.html" target="MainFrame">Developers</A>
<li><a href="systems.html" target="MainFrame">Platforms and Drivers</a>
<li><a href="license.html" target="MainFrame">License & Copyright</a>
<li><a href="faq.html" target="MainFrame">FAQ</a>
@@ -64,6 +65,7 @@ a:visited {
<ul>
<li><a href="http://sourceforge.net/projects/mesa3d" target="_parent">SourceForge homepage</a>
<li><a href="repository.html" target="MainFrame">Source Code Repository</a>
<li><a href="memory.html" target="MainFrame">DRI Memory Management</a>
<li><a href="shading.html" target="MainFrame">Shading Language</a>
<li><a href="utilities.html" target="MainFrame">Utilities</a>
<li><a href="helpwanted.html" target="MainFrame">Help Wanted</a>
@@ -72,7 +74,6 @@ a:visited {
<li><a href="subset.html" target="MainFrame">Subset Information</a>
<li><a href="fbdev-dri.html" target="MainFrame">fbdev/DRI Environment</a>
<li><a href="glfbdev-driver.html" target="MainFrame">glFBDev Driver</a>
<LI><A HREF="custom.html" target="MainFrame">Custom Development</A>
<LI><A HREF="dispatch.html" target="MainFrame">GL Dispatch</A>
</ul>

View File

@@ -1,27 +0,0 @@
<HTML>
<TITLE>Custom Development</TITLE>
<link rel="stylesheet" type="text/css" href="mesa.css"></head>
<BODY>
<H1>Custom Development</H1>
<p>
Mesa is primarily developed and maintained on a volunteer basis.
Some Mesa development work has been done in conjuction with contracted
projects, such as the XFree86/DRI drivers.
</p>
<p>
<pre>[Begin shameless plug]</pre>
If you have a need for specific or custom Mesa development work,
<a href="http://www.tungstengraphics.com/" target="_parent">
Tungsten Graphics, Inc.</a> may be able to help you.
<pre>[End shameless plug]</pre>
</p>
</body>
</html>

51
docs/developers.html Normal file
View File

@@ -0,0 +1,51 @@
<HTML>
<TITLE>Developers</TITLE>
<link rel="stylesheet" type="text/css" href="mesa.css"></head>
<BODY>
<H1>Developers</H1>
<p>
Both professional and volunteer developers contribute to Mesa.
</p>
<p>
<a href="http://www.tungstengraphics.com/" target="_parent">Tungsten Graphics</a>
employs several of the main Mesa developers including Brian Paul
and Keith Whitwell.
Much of the on-going work in Mesa is done through Tungsten Graphics engineering
contracts.
Prominent examples of this work includes:
</p>
<ul>
<li>DRI drivers for Intel i965, i945, i915 and other chips
<li>Advanced memory manager and framebuffer object support
<li>Shading language compiler and OpenGL 2.0 support
<li>MiniGLX environment
</ul>
<p>
Other companies including
<a href="http://www.intellinuxgraphics.org/index.html" target="_parent">Intel</a>
and IBM also actively contribute to the project.
</p>
<p>
Volunteers have made significant contributions to all parts of Mesa, including
complete device drivers.
</p>
<H1>Custom Development</H1>
<p>
Contact <a href="http://www.tungstengraphics.com/" target="_parent">
Tungsten Graphics</a>
for information about custom development in Mesa, OpenGL, X and other
graphics technologies.
</p>
</body>
</html>

View File

@@ -9,7 +9,7 @@
<H1>Downloading</H1>
<p>
Last development release: <b>6.5.2</b>
Last development release: <b>6.5.3</b>
</p>
<p>

View File

@@ -9,35 +9,31 @@
<H1>Introduction</H1>
<p>
Mesa is a 3-D graphics library with an API which is very similar to
that of <a href="http://www.opengl.org/" target="_parent">OpenGL</a>.*
To the extent that Mesa utilizes the OpenGL command syntax or state
machine, it is being used with authorization from <a
href="http://www.sgi.com/" target="_parent">Silicon Graphics,
Inc.</a>(SGI). However, the author does not possess an OpenGL license
from SGI, and makes no claim that Mesa is in any way a compatible
replacement for OpenGL or associated with SGI. Those who want a
licensed implementation of OpenGL should contact a licensed
vendor.
Mesa is an open-source implementation of the
<a href="http://www.opengl.org/" target="_parent">OpenGL</a> specification -
a system for rendering interactive 3D graphics.
</p>
<p>
Please do not refer to the library as <em>MesaGL</em> (for legal
reasons). It's just <em>Mesa</em> or <em>The Mesa 3-D graphics
library</em>. <br>
A variety of device drivers allows Mesa to be used in many different
environments ranging from software emulation to complete hardware acceleration
for modern GPUs.
</p>
<p>
* OpenGL is a trademark of <a href="http://www.sgi.com/"
target="_parent">Silicon Graphics Incorporated</a>.
Mesa ties into several other open-source projects: the
<a href="http://dri.sf.net/" target="_parent">Direct Rendering Infrastructure</a>
and <a href="http://x.org" target="_parent">X.org</a> to provide OpenGL
support to users of X on Linux, FreeBSD and other operating systems.
</p>
<H1>Project History</H1>
<p>
The Mesa project was founded by me, Brian Paul. Here's a short history
of the project.
The Mesa project was originally started by Brian Paul.
Here's a short history of the project.
</p>
<p>

View File

@@ -6,6 +6,34 @@
<BODY>
<H1>Disclaimer</H1>
<p>
Mesa is a 3-D graphics library with an API which is very similar to
that of <a href="http://www.opengl.org/" target="_parent">OpenGL</a>.*
To the extent that Mesa utilizes the OpenGL command syntax or state
machine, it is being used with authorization from <a
href="http://www.sgi.com/" target="_parent">Silicon Graphics,
Inc.</a>(SGI). However, the author does not possess an OpenGL license
from SGI, and makes no claim that Mesa is in any way a compatible
replacement for OpenGL or associated with SGI. Those who want a
licensed implementation of OpenGL should contact a licensed
vendor.
</p>
<p>
Please do not refer to the library as <em>MesaGL</em> (for legal
reasons). It's just <em>Mesa</em> or <em>The Mesa 3-D graphics
library</em>. <br>
</p>
<p>
* OpenGL is a trademark of <a href="http://www.sgi.com/"
target="_parent">Silicon Graphics Incorporated</a>.
</p>
<H1>License / Copyright Information</H1>
<p>
@@ -24,7 +52,7 @@ The default Mesa license is as follows:
</p>
<pre>
Copyright (C) 1999-2005 Brian Paul All Rights Reserved.
Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),

View File

@@ -11,6 +11,33 @@
<H1>News</H1>
<h2>April ?, 2007</h2>
<p>
<a href="relnotes-6.5.3.html">Mesa 6.5.3</a> is released.
This is a development release which will lead up to the Mesa 7.0 release
(which will advertise OpenGL 2.1 API support).
</p>
<h2>March 26, 2007</h2>
<p>
The new Shading Language compiler branch has been merged into the git
master branch. This is a step toward hardware support for the OpenGL
2.0 Shading Language and will be included in the next Mesa release.
In conjunction, <a href="http://glean.sf.net" target="_parent">Glean
</a> has been updated with a new test that does over 130 tests of the
shading language and built-in functions.
</p>
<h2>April 2007</h2>
<p>
Thomas Hellstr&ouml;m of
<a href="http://www.tungstengraphics.com" target="_parent">
Tungsten Graphics</a> has written a whitepaper describing the new
<a href="http://www.tungstengraphics.com/mm.pdf">DRI memory management
system</a>.
</p>
<h2>December 5, 2006</h2>
<p>
Mesa is now using git as its source code management system.

View File

@@ -8,10 +8,11 @@
<body bgcolor="#eeeeee">
<H1>Mesa 6.5.3 Release Notes / (in progress)</H1>
<H1>Mesa 6.5.3 Release Notes / April ??, 2007</H1>
<p>
Mesa 6.5.3 is a 6.5 follow-on development release with many internal changes.
Mesa 6.5.3 is a development release with many changes and new features.
Mesa 7.0 is expected to follow shortly.
</p>
@@ -21,12 +22,29 @@ TBD
</pre>
<h2>Shared library numbering</h2>
<p>
Mesa 6.5.3 supports the OpenGL 2.0/2.1 API. However, the (unix)
shared library version is still 1.5 (i.e. libGL.so.1.5.xxxxxx).
Bumping the shared library version to 2.x would cause linking problems
with existing OpenGL applications. Since OpenGL 2.x is backward
compatible with OpenGL 1.x the shared library version number doesn't
have to be incremented (which would indicate an incompatible ABI).
</p>
<p>
Other OpenGL vendors name their OpenGL 2.x libraries libGL.so.1.0.xxxxx
for the same reason.
</p>
<h2>New features</h2>
<ul>
<li>OpenGL 2.0 support.
<li>Entirely new Shading Language code generator.
<li>OpenGL 2.0 and 2.1 API support.
<li>Entirely new Shading Language code generator. See the
<a href="shading.html">Shading Language</a> page for more information.
<li>Much faster software execution of vertex, fragment shaders.
<li>New vertex buffer object infrastructure (replaces old array_cache code).
<li>New vertex buffer object (vbo) infrastructure
<li>Updated glext.h file (version 39)
<li>Updated glxext.h file (version 18)
<li>GL_MAX_DRAWBUFFERS is now 4 (software rendering) so
@@ -40,20 +58,25 @@ TBD
<li>With 32-bit Z buffer, the fragment Z of lines and points was sometimes wrong.
<li>GL_POST_CONVOLUTION_ALPHA_BIAS/SCALE was broken.
<li>1D convolution state could effect 2D image transfers
<li>Overlapping glCopyPixels with negative Y zoom didn't work (bug 10521)
<li>Fixed a number of framebuffer/renderbuffer reference counting bugs
<li>Fixed a few bugs in software-emulated alpha planes
<li>Assorted minor bug fixes in glCopy/DrawPixels, glPixelZoom, etc.
<li>Assorted DRI driver bug fixes.
<li>Fixed a number of bugs that prevented "depth-peeling" rendering from working.
</ul>
<h2>Internal code changes</h2>
<ul>
<li>Massive changes to the Shading Language compiler.
<li>The _MaintainTnlProgram, _MaintainTexEnvProgram, _TexEnvProgram and
_TnlProgram fields have been moved.
<li>The ctx->FragmentProgram._Active field has been removed.
<li>The ctx->Vertex/FragmentProgram._Current fields point to the program
in effect, whether it comes from a shader, user-program or generated
fixed-function program.
<li>The _UseTexEnvProgram field has been removed.
<li>Old array_cache module replaced by new vbo module. All geometry
rendering is now cast in the form of vertex buffer objects.
<li>Massive changes to the Shading Language compiler and related state.
<li>Vertex/fragment shaders are compiled into GPU instructions and
programs very similar to GL_ARB_vertex/fragment_program.
<li>Vertex and fragment programs are executed with the same code now.
<li>The SSE-optimized vertex program path has been removed since it didn't
support more than 12 temp registers, didn't support branching/looping, etc.
</ul>
@@ -71,17 +94,17 @@ fixed-function program.
Driver Status
---------------------- ----------------------
DRI drivers varies with the driver
XMesa/GLX (on Xlib) implements OpenGL 2.0
OSMesa (off-screen) implements OpenGL 2.0
Glide (3dfx Voodoo1/2) implements OpenGL 1.3
SVGA implements OpenGL 1.3
Wind River UGL implements OpenGL 1.3
XMesa/GLX (on Xlib) implements OpenGL 2.1
OSMesa (off-screen) implements OpenGL 2.1
Windows/Win32 implements OpenGL 1.5
DJGPP implements OpenGL 1.5
GGI implements OpenGL 1.3
BeOS implements OpenGL 1.5
Allegro needs updating
D3D needs updating
Glide (3dfx Voodoo1/2) implements OpenGL 1.3
SVGA unsupported
Wind River UGL unsupported
DJGPP unsupported
GGI unsupported
BeOS unsupported
Allegro unsupported
D3D unsupported
</pre>
</body>

View File

@@ -15,7 +15,7 @@ OpenGL Shading Language</a>.
</p>
<p>
Last updated on 17 Feb 2007.
Last updated on 28 March 2007.
</p>
<p>
@@ -27,6 +27,7 @@ Contents
<li><a href="#hints">Programming Hints</a>
<li><a href="#standalone">Stand-alone Compiler</a>
<li><a href="#implementation">Compiler Implementation</a>
<li><a href="#validation">Compiler Validation</a>
</ul>
@@ -40,11 +41,10 @@ in Mesa:
<ul>
<li>Dereferencing arrays with non-constant indexes
<li>User-defined structs
<li>Comparison of user-defined structs
<li>Linking of multiple shaders is not supported
<li>Integer operations are not fully implemented (most are implemented
as floating point).
<li>gl_ClipVertex
<li>The derivative functions such as dFdx() are not implemented
</ul>
<p>
@@ -67,7 +67,8 @@ All other major features of the shading language should function.
<li>The quality of generated code is pretty good, register usage is fair.
<li>Shader error detection and reporting of errors (InfoLog) is not
very good yet.
<li>There are known memory leaks in the compiler.
<li>The ftransform() function doesn't necessarily match the results of
fixed-function transformation.
</ul>
<p>
@@ -121,6 +122,9 @@ These issues will be addressed/resolved in the future.
<pre>
float x = inversesqrt(y);
</pre>
<li>
Use ++i when possible as it's more efficient than i++
</li>
</ul>
@@ -282,5 +286,24 @@ Extra NOP instructions will also be inserted.
</ul>
<a name="validation">
<h2>Compiler Validation</h2>
<p>
A new <a href="http://glean.sf.net" target="_parent">Glean</a> test has
been create to exercise the GLSL compiler.
</p>
<p>
The <em>glsl1</em> test runs over 150 sub-tests to check that the language
features and built-in functions work properly.
This test should be run frequently while working on the compiler to catch
regressions.
</p>
<p>
The test coverage is reasonably broad and complete but additional tests
should be added.
</p>
</BODY>
</HTML>

View File

@@ -42,7 +42,7 @@ WIDTH="88" HEIGHT="31" ALIGN="BOTTOM" ALT="Sourceforge.net" BORDER="0"></A>
<br>
<br>
<li>The Mesa CVS repository is hosted by
<li>The Mesa git repository is hosted by
<a href="http://freedesktop.org/" target="_parent">freedesktop.org</a>.
<br>
<br>

View File

@@ -27,10 +27,6 @@
#define MANGLE(x) mgl##x
#endif /*MANGLE*/
/* Internal symbols which may collide with other OpenGL implementations. */
#define __glCoreCreateContext __mglCoreCreateContext
#define __glCoreNopDispatch __mglCoreNopDispatch
/*REGENERATE_TO_END-----------ALL LINES BELOW HERE GET REPLACED ON REGENERATION */
#define glAccum MANGLE(Accum)

View File

@@ -386,7 +386,7 @@ typedef struct {
/* (as used in the GLX_OML_sync_control extension). */
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#include <inttypes.h>
#elif defined(__sun__)
#elif defined(__sun__) || defined(__digital__)
#include <inttypes.h>
#if defined(__STDC__)
#if defined(__arch64__)

View File

@@ -38,17 +38,11 @@
#include <sys/types.h>
#ifdef CAPI
#undef CAPI
#endif
#define CAPI
#define GL_CORE_SGI 1
#define GL_CORE_MESA 2
#define GL_CORE_APPLE 4
typedef struct __GLcontextRec __GLcontext;
typedef struct __GLinterfaceRec __GLinterface;
/*
** This file defines the interface between the GL core and the surrounding
@@ -186,81 +180,4 @@ typedef struct __GLcontextModesRec {
#define GLX_TEXTURE_2D_BIT_EXT 0x00000002
#define GLX_TEXTURE_RECTANGLE_BIT_EXT 0x00000004
/************************************************************************/
/*
** Procedures which are imported by the GL from the surrounding
** "operating system". Math functions are not considered part of the
** "operating system".
*/
typedef struct __GLimportsRec {
/* Memory management */
void * (*malloc)(__GLcontext *gc, size_t size);
void *(*calloc)(__GLcontext *gc, size_t numElem, size_t elemSize);
void *(*realloc)(__GLcontext *gc, void *oldAddr, size_t newSize);
void (*free)(__GLcontext *gc, void *addr);
/* Error handling */
void (*warning)(__GLcontext *gc, char *fmt);
void (*fatal)(__GLcontext *gc, char *fmt);
/* other system calls */
char *(CAPI *getenv)(__GLcontext *gc, const char *var);
int (CAPI *atoi)(__GLcontext *gc, const char *str);
int (CAPI *sprintf)(__GLcontext *gc, char *str, const char *fmt, ...);
void *(CAPI *fopen)(__GLcontext *gc, const char *path, const char *mode);
int (CAPI *fclose)(__GLcontext *gc, void *stream);
int (CAPI *fprintf)(__GLcontext *gc, void *stream, const char *fmt, ...);
/* Drawing surface management */
void *(*getDrawablePrivate)(__GLcontext *gc);
void *(*getReadablePrivate)(__GLcontext *gc);
/* Operating system dependent data goes here */
void *other;
} __GLimports;
/************************************************************************/
/*
** Procedures which are exported by the GL to the surrounding "operating
** system" so that it can manage multiple GL context's.
*/
typedef struct __GLexportsRec {
/* Context management (return GL_FALSE on failure) */
GLboolean (*destroyContext)(__GLcontext *gc);
GLboolean (*loseCurrent)(__GLcontext *gc);
/* oldglPriv isn't used anymore, kept for backwards compatibility */
GLboolean (*makeCurrent)(__GLcontext *gc);
GLboolean (*shareContext)(__GLcontext *gc, __GLcontext *gcShare);
GLboolean (*copyContext)(__GLcontext *dst, const __GLcontext *src, GLuint mask);
GLboolean (*forceCurrent)(__GLcontext *gc);
/* Drawing surface notification callbacks */
GLboolean (*notifyResize)(__GLcontext *gc);
void (*notifyDestroy)(__GLcontext *gc);
void (*notifySwapBuffers)(__GLcontext *gc);
/* Dispatch table override control for external agents like libGLS */
struct __GLdispatchStateRec* (*dispatchExec)(__GLcontext *gc);
void (*beginDispatchOverride)(__GLcontext *gc);
void (*endDispatchOverride)(__GLcontext *gc);
} __GLexports;
/************************************************************************/
/*
** This must be the first member of a __GLcontext structure. This is the
** only part of a context that is exposed to the outside world; everything
** else is opaque.
*/
struct __GLinterfaceRec {
__GLimports imports;
__GLexports exports;
};
extern __GLcontext *__glCoreCreateContext(__GLimports *, __GLcontextModes *);
extern void __glCoreNopDispatch(void);
#endif /* __gl_core_h_ */

View File

@@ -180,6 +180,21 @@ extern XMesaContext XMesaCreateContext( XMesaVisual v,
extern void XMesaDestroyContext( XMesaContext c );
#ifdef XFree86Server
/*
* These are the extra routines required for integration with XFree86.
* None of these routines should be user visible. -KEM
*/
extern GLboolean XMesaForceCurrent( XMesaContext c );
extern GLboolean XMesaLoseCurrent( XMesaContext c );
extern GLboolean XMesaCopyContext( XMesaContext src,
XMesaContext dst,
GLuint mask );
#endif /* XFree86Server */
/*
* Create an XMesaBuffer from an X window.
*/

View File

@@ -41,6 +41,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "scrnintstr.h"
#include "pixmapstr.h"
#include "gcstruct.h"
typedef struct _XMesaImageRec XMesaImage;
@@ -123,8 +124,7 @@ do { \
do { \
/* Assumes: Images are always in ZPixmap format */ \
(void) __d; \
if (__sx || __sy) /* The non-trivial case */ \
XMesaPutImageHelper(__d,__b,__gc,__i,__sx,__sy,__x,__y,__w,__h); \
ASSERT(!__sx && !__sy) /* The SubImage case */ \
ValidateGC(__b, __gc); \
(*__gc->ops->PutImage)(__b, __gc, ((XMesaDrawable)(__b))->depth, \
__x, __y, __w, __h, 0, ZPixmap, \

View File

@@ -118,34 +118,39 @@ extfuncs.h: $(TOP)/progs/util/extfuncs.h
reflect: reflect.o showbuffer.o readtex.o
$(CC) -I$(INCDIR) $(CFLAGS) reflect.o showbuffer.o readtex.o $(APP_LIB_DEPS) -o $@
$(CC) reflect.o showbuffer.o readtex.o $(APP_LIB_DEPS) -o $@
reflect.o: reflect.c showbuffer.h
$(CC) -c -I$(INCDIR) $(CFLAGS) reflect.c
shadowtex: shadowtex.o showbuffer.o
$(CC) -I$(INCDIR) $(CFLAGS) shadowtex.o showbuffer.o $(APP_LIB_DEPS) -o $@
$(CC) shadowtex.o showbuffer.o $(APP_LIB_DEPS) -o $@
shadowtex.o: shadowtex.c showbuffer.h
$(CC) -c -I$(INCDIR) $(CFLAGS) shadowtex.c
gloss: gloss.o trackball.o readtex.o
$(CC) -I$(INCDIR) $(CFLAGS) gloss.o trackball.o readtex.o $(APP_LIB_DEPS) -o $@
$(CC) gloss.o trackball.o readtex.o $(APP_LIB_DEPS) -o $@
gloss.o: gloss.c trackball.h
$(CC) -c -I$(INCDIR) $(CFLAGS) gloss.c
engine: engine.o trackball.o readtex.o
$(CC) -I$(INCDIR) $(CFLAGS) engine.o trackball.o readtex.o $(APP_LIB_DEPS) -o $@
$(CC) engine.o trackball.o readtex.o $(APP_LIB_DEPS) -o $@
engine.o: engine.c trackball.h
$(CC) -c -I$(INCDIR) $(CFLAGS) engine.c
fslight.c: extfuncs.h
fslight: fslight.o
$(CC) fslight.o $(APP_LIB_DEPS) -o $@
fslight.o: fslight.c extfuncs.h
$(CC) -c -I$(INCDIR) $(CFLAGS) fslight.c
clean:

View File

@@ -24,6 +24,7 @@ static GLuint VertProg;
static GLboolean Anim = GL_TRUE;
static GLboolean Wire = GL_FALSE;
static GLboolean PixelLight = GL_TRUE;
static GLint Win;
static GLint T0 = 0;
static GLint Frames = 0;
@@ -148,6 +149,7 @@ static void Key( unsigned char key, int x, int y )
case 27:
glDeleteProgramsARB_func(1, &VertProg);
glDeleteProgramsARB_func(1, &FragProg);
glutDestroyWindow(Win);
exit(0);
break;
}
@@ -382,7 +384,7 @@ int main( int argc, char *argv[] )
glutInitWindowPosition( 0, 0 );
glutInitWindowSize( 200, 200 );
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );
glutCreateWindow(argv[0]);
Win = glutCreateWindow(argv[0]);
glutReshapeFunc( Reshape );
glutKeyboardFunc( Key );
glutSpecialFunc( SpecialKey );

View File

@@ -7,151 +7,136 @@
* Daniel Borca
*/
#define GL_GLEXT_PROTOTYPES
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <GL/glut.h>
#include "readtex.h"
#define DEPTH 5.0f
#define TEXTURE_FILE "../images/bw.rgb"
static PFNGLFOGCOORDFEXTPROC glFogCoordf_ext;
static PFNGLFOGCOORDPOINTEREXTPROC glFogCoordPointer_ext;
#define ARRAYS 0 /* use glDrawElements */
#define VERBOSE 1 /* tell me what happens */
#define DEPTH 15.0f
#if !defined(GLAPIENTRYP)
# define GLAPIENTRYP *
#endif
typedef void (GLAPIENTRYP GLFOGCOORDFEXTPROC) (GLfloat f);
typedef void (GLAPIENTRYP GLFOGCOORDPOINTEREXTPROC) (GLenum, GLsizei, const GLvoid *);
static GLFOGCOORDFEXTPROC glFogCoordf_ext;
#if ARRAYS
static GLFOGCOORDPOINTEREXTPROC glFogCoordPointer_ext;
#endif
static GLboolean have_fog_coord;
static GLfloat camz;
static GLuint texture[1];
static GLint fogMode;
static GLboolean fogCoord;
static GLfloat fogDensity = 0.75;
static GLfloat fogStart = 1.0, fogEnd = 40.0;
static GLfloat fogStart = 1.0, fogEnd = DEPTH;
static GLfloat fogColor[4] = {0.6f, 0.3f, 0.0f, 1.0f};
static const char *ModeStr = NULL;
static GLboolean Arrays = GL_FALSE;
static GLboolean Texture = GL_TRUE;
static void APIENTRY glFogCoordf_nop (GLfloat f)
static void
Reset(void)
{
fogMode = 1;
fogCoord = 1;
fogDensity = 0.75;
fogStart = 1.0;
fogEnd = DEPTH;
Arrays = GL_FALSE;
Texture = GL_TRUE;
}
static void APIENTRY
glFogCoordf_nop (GLfloat f)
{
(void)f;
}
static int BuildTexture (const char *filename, GLuint texid[])
static void
PrintString(const char *s)
{
GLubyte *tex_data;
GLenum tex_format;
GLint tex_width, tex_height;
tex_data = LoadRGBImage(filename, &tex_width, &tex_height, &tex_format);
if (tex_data == NULL) {
return -1;
while (*s) {
glutBitmapCharacter(GLUT_BITMAP_8_BY_13, (int) *s);
s++;
}
{
GLint tex_max;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &tex_max);
if ((tex_width > tex_max) || (tex_height > tex_max)) {
return -1;
}
}
glGenTextures(1, texid);
glBindTexture(GL_TEXTURE_2D, texid[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, tex_format, tex_width, tex_height, 0,
tex_format, GL_UNSIGNED_BYTE, tex_data);
return 0;
}
static int SetFogMode (GLint fogMode)
static void
PrintInfo(void)
{
char s[100];
glDisable(GL_FOG);
glColor3f(0, 1, 1);
sprintf(s, "Mode(m): %s Start(s/S): %g End(e/E): %g Density(d/D): %g",
ModeStr, fogStart, fogEnd, fogDensity);
glWindowPos2iARB(5, 20);
PrintString(s);
sprintf(s, "Arrays(a): %s glFogCoord(c): %s EyeZ(z/z): %g",
(Arrays ? "Yes" : "No"),
(fogCoord ? "Yes" : "No"),
camz);
glWindowPos2iARB(5, 5);
PrintString(s);
}
static int
SetFogMode(GLint fogMode)
{
fogMode &= 3;
switch (fogMode) {
case 0:
ModeStr = "Off";
glDisable(GL_FOG);
#if VERBOSE
printf("fog(disable)\n");
#endif
break;
case 1:
ModeStr = "GL_LINEAR";
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, fogStart);
glFogf(GL_FOG_END, fogEnd);
#if VERBOSE
printf("fog(GL_LINEAR, %.2f, %.2f)\n", fogStart, fogEnd);
#endif
break;
case 2:
ModeStr = "GL_EXP";
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_DENSITY, fogDensity);
#if VERBOSE
printf("fog(GL_EXP, %.2f)\n", fogDensity);
#endif
break;
case 3:
ModeStr = "GL_EXP2";
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_EXP2);
glFogf(GL_FOG_DENSITY, fogDensity);
#if VERBOSE
printf("fog(GL_EXP2, %.2f)\n", fogDensity);
#endif
break;
}
return fogMode;
}
static GLboolean SetFogCoord (GLboolean fogCoord)
static GLboolean
SetFogCoord(GLboolean fogCoord)
{
glFogCoordf_ext = glFogCoordf_nop;
if (!have_fog_coord) {
#if VERBOSE
printf("fog(GL_FRAGMENT_DEPTH_EXT)%s\n", fogCoord ? " EXT_fog_coord not available!" : "");
#endif
return GL_FALSE;
}
if (fogCoord) {
glFogCoordf_ext = (GLFOGCOORDFEXTPROC)glutGetProcAddress("glFogCoordfEXT");
glFogCoordf_ext = (PFNGLFOGCOORDFEXTPROC)glutGetProcAddress("glFogCoordfEXT");
glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
#if VERBOSE
printf("fog(GL_FOG_COORDINATE_EXT)\n");
#endif
} else {
}
else {
glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FRAGMENT_DEPTH_EXT);
#if VERBOSE
printf("fog(GL_FRAGMENT_DEPTH_EXT)\n");
#endif
}
return fogCoord;
}
#if ARRAYS
/* could reuse vertices */
static GLuint vertex_index[] = {
/* Back */
@@ -172,19 +157,19 @@ static GLuint vertex_index[] = {
static GLfloat vertex_pointer[][3] = {
/* Back */
{-2.5f,-2.5f,-DEPTH}, { 2.5f,-2.5f,-DEPTH}, { 2.5f, 2.5f,-DEPTH}, {-2.5f, 2.5f,-DEPTH},
{-1.0f,-1.0f,-DEPTH}, { 1.0f,-1.0f,-DEPTH}, { 1.0f, 1.0f,-DEPTH}, {-1.0f, 1.0f,-DEPTH},
/* Floor */
{-2.5f,-2.5f,-DEPTH}, { 2.5f,-2.5f,-DEPTH}, { 2.5f,-2.5f, DEPTH}, {-2.5f,-2.5f, DEPTH},
{-1.0f,-1.0f,-DEPTH}, { 1.0f,-1.0f,-DEPTH}, { 1.0f,-1.0f, 0.0}, {-1.0f,-1.0f, 0.0},
/* Roof */
{-2.5f, 2.5f,-DEPTH}, { 2.5f, 2.5f,-DEPTH}, { 2.5f, 2.5f, DEPTH}, {-2.5f, 2.5f, DEPTH},
{-1.0f, 1.0f,-DEPTH}, { 1.0f, 1.0f,-DEPTH}, { 1.0f, 1.0f, 0.0}, {-1.0f, 1.0f, 0.0},
/* Right */
{ 2.5f,-2.5f, DEPTH}, { 2.5f, 2.5f, DEPTH}, { 2.5f, 2.5f,-DEPTH}, { 2.5f,-2.5f,-DEPTH},
{ 1.0f,-1.0f, 0.0}, { 1.0f, 1.0f, 0.0}, { 1.0f, 1.0f,-DEPTH}, { 1.0f,-1.0f,-DEPTH},
/* Left */
{-2.5f,-2.5f, DEPTH}, {-2.5f, 2.5f, DEPTH}, {-2.5f, 2.5f,-DEPTH}, {-2.5f,-2.5f,-DEPTH}
{-1.0f,-1.0f, 0.0}, {-1.0f, 1.0f, 0.0}, {-1.0f, 1.0f,-DEPTH}, {-1.0f,-1.0f,-DEPTH}
};
static GLfloat texcoord_pointer[][2] = {
@@ -192,118 +177,139 @@ static GLfloat texcoord_pointer[][2] = {
{0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f}, {0.0f, 1.0f},
/* Floor */
{0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f}, {0.0f, 1.0f},
{0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, DEPTH}, {0.0f, DEPTH},
/* Roof */
{0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f}, {0.0f, 1.0f},
{1.0f, 0.0f}, {0.0f, 0.0f}, {0.0f, DEPTH}, {1.0f, DEPTH},
/* Right */
{0.0f, 0.0f}, {0.0f, 1.0f}, {1.0f, 1.0f}, {1.0f, 0.0f},
{0.0f, 1.0f}, {0.0f, 0.0f}, {DEPTH, 0.0f}, {DEPTH, 1.0f},
/* Left */
{0.0f, 0.0f}, {0.0f, 1.0f}, {1.0f, 1.0f}, {1.0f, 0.0f}
{0.0f, 0.0f}, {0.0f, 1.0f}, {DEPTH, 1.0f}, {DEPTH, 0.0f}
};
static GLfloat fogcoord_pointer[][1] = {
static GLfloat fogcoord_pointer[] = {
/* Back */
{1.0f}, {1.0f}, {1.0f}, {1.0f},
DEPTH, DEPTH, DEPTH, DEPTH,
/* Floor */
{1.0f}, {1.0f}, {0.0f}, {0.0f},
DEPTH, DEPTH, 0.0, 0.0,
/* Roof */
{1.0f}, {1.0f}, {0.0f}, {0.0f},
DEPTH, DEPTH, 0.0, 0.0,
/* Right */
{0.0f}, {0.0f}, {1.0f}, {1.0f},
0.0, 0.0, DEPTH, DEPTH,
/* Left */
{0.0f}, {0.0f}, {1.0f}, {1.0f}
0.0, 0.0, DEPTH, DEPTH
};
#endif
static void Display( void )
static void
Display( void )
{
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity ();
glTranslatef(0.0f, 0.0f, camz);
glTranslatef(0.0f, 0.0f, -camz);
#if ARRAYS
glDrawElements(GL_QUADS, sizeof(vertex_index) / sizeof(vertex_index[0]), GL_UNSIGNED_INT, vertex_index);
#else
/* Back */
glBegin(GL_QUADS);
glFogCoordf_ext(1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-2.5f,-2.5f,-DEPTH);
glFogCoordf_ext(1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f( 2.5f,-2.5f,-DEPTH);
glFogCoordf_ext(1.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f( 2.5f, 2.5f,-DEPTH);
glFogCoordf_ext(1.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-2.5f, 2.5f,-DEPTH);
glEnd();
SetFogMode(fogMode);
/* Floor */
glBegin(GL_QUADS);
glFogCoordf_ext(1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-2.5f,-2.5f,-DEPTH);
glFogCoordf_ext(1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f( 2.5f,-2.5f,-DEPTH);
glFogCoordf_ext(0.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f( 2.5f,-2.5f, DEPTH);
glFogCoordf_ext(0.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-2.5f,-2.5f, DEPTH);
glEnd();
glColor3f(1, 1, 1);
/* Roof */
glBegin(GL_QUADS);
glFogCoordf_ext(1.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-2.5f, 2.5f,-DEPTH);
glFogCoordf_ext(1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f( 2.5f, 2.5f,-DEPTH);
glFogCoordf_ext(0.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f( 2.5f, 2.5f, DEPTH);
glFogCoordf_ext(0.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-2.5f, 2.5f, DEPTH);
glEnd();
if (Texture)
glEnable(GL_TEXTURE_2D);
/* Right */
glBegin(GL_QUADS);
glFogCoordf_ext(0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f( 2.5f,-2.5f, DEPTH);
glFogCoordf_ext(0.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f( 2.5f, 2.5f, DEPTH);
glFogCoordf_ext(1.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f( 2.5f, 2.5f,-DEPTH);
glFogCoordf_ext(1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f( 2.5f,-2.5f,-DEPTH);
glEnd();
if (Arrays) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glDrawElements(GL_QUADS, sizeof(vertex_index) / sizeof(vertex_index[0]),
GL_UNSIGNED_INT, vertex_index);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
else {
/* Back */
glBegin(GL_QUADS);
glFogCoordf_ext(DEPTH); glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,-1.0f,-DEPTH);
glFogCoordf_ext(DEPTH); glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,-1.0f,-DEPTH);
glFogCoordf_ext(DEPTH); glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f,-DEPTH);
glFogCoordf_ext(DEPTH); glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f,-DEPTH);
glEnd();
/* Left */
glBegin(GL_QUADS);
glFogCoordf_ext(0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-2.5f,-2.5f, DEPTH);
glFogCoordf_ext(0.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-2.5f, 2.5f, DEPTH);
glFogCoordf_ext(1.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-2.5f, 2.5f,-DEPTH);
glFogCoordf_ext(1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f(-2.5f,-2.5f,-DEPTH);
glEnd();
#endif
/* Floor */
glBegin(GL_QUADS);
glFogCoordf_ext(DEPTH); glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,-1.0f,-DEPTH);
glFogCoordf_ext(DEPTH); glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,-1.0f,-DEPTH);
glFogCoordf_ext(0.0f); glTexCoord2f(1.0f, DEPTH); glVertex3f( 1.0f,-1.0f,0.0);
glFogCoordf_ext(0.0f); glTexCoord2f(0.0f, DEPTH); glVertex3f(-1.0f,-1.0f,0.0);
glEnd();
/* Roof */
glBegin(GL_QUADS);
glFogCoordf_ext(DEPTH); glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, 1.0f,-DEPTH);
glFogCoordf_ext(DEPTH); glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, 1.0f,-DEPTH);
glFogCoordf_ext(0.0f); glTexCoord2f(0.0f, DEPTH); glVertex3f( 1.0f, 1.0f,0.0);
glFogCoordf_ext(0.0f); glTexCoord2f(1.0f, DEPTH); glVertex3f(-1.0f, 1.0f,0.0);
glEnd();
/* Right */
glBegin(GL_QUADS);
glFogCoordf_ext(0.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,-1.0f,0.0);
glFogCoordf_ext(0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, 1.0f,0.0);
glFogCoordf_ext(DEPTH); glTexCoord2f(DEPTH, 0.0f); glVertex3f( 1.0f, 1.0f,-DEPTH);
glFogCoordf_ext(DEPTH); glTexCoord2f(DEPTH, 1.0f); glVertex3f( 1.0f,-1.0f,-DEPTH);
glEnd();
/* Left */
glBegin(GL_QUADS);
glFogCoordf_ext(0.0f); glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,-1.0f,0.0);
glFogCoordf_ext(0.0f); glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f,0.0);
glFogCoordf_ext(DEPTH); glTexCoord2f(DEPTH, 1.0f); glVertex3f(-1.0f, 1.0f,-DEPTH);
glFogCoordf_ext(DEPTH); glTexCoord2f(DEPTH, 0.0f); glVertex3f(-1.0f,-1.0f,-DEPTH);
glEnd();
}
glDisable(GL_TEXTURE_2D);
PrintInfo();
glutSwapBuffers();
}
static void Reshape( int width, int height )
static void
Reshape( int width, int height )
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, (GLfloat)(width)/(GLfloat)(height), 0.1f, 100.0f);
glFrustum(-1, 1, -1, 1, 1.0, 100);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
static void Key( unsigned char key, int x, int y )
static void
Key( unsigned char key, int x, int y )
{
(void) x;
(void) y;
switch (key) {
case 'a':
Arrays = !Arrays;
break;
case 'f':
case 'm':
fogMode = SetFogMode(fogMode + 1);
break;
case '+':
if (fogDensity < 1.0) {
fogDensity += 0.05;
}
case 'D':
fogDensity += 0.05;
SetFogMode(fogMode);
break;
case '-':
case 'd':
if (fogDensity > 0.0) {
fogDensity -= 0.05;
}
@@ -311,31 +317,43 @@ static void Key( unsigned char key, int x, int y )
break;
case 's':
if (fogStart > 0.0) {
fogStart -= 1.0;
fogStart -= 0.25;
}
SetFogMode(fogMode);
break;
case 'S':
if (fogStart < fogEnd) {
fogStart += 1.0;
if (fogStart < 100.0) {
fogStart += 0.25;
}
SetFogMode(fogMode);
break;
case 'e':
if (fogEnd > fogStart) {
fogEnd -= 1.0;
if (fogEnd > 0.0) {
fogEnd -= 0.25;
}
SetFogMode(fogMode);
break;
case 'E':
if (fogEnd < 100.0) {
fogEnd += 1.0;
fogEnd += 0.25;
}
SetFogMode(fogMode);
break;
case 'c':
fogCoord = SetFogCoord(fogCoord ^ GL_TRUE);
break;
case 't':
Texture = !Texture;
break;
case 'z':
camz -= 0.1;
break;
case 'Z':
camz += 0.1;
break;
case 'r':
Reset();
break;
case 27:
exit(0);
break;
@@ -344,37 +362,28 @@ static void Key( unsigned char key, int x, int y )
}
static void SpecialKey( int key, int x, int y )
static void
Init(void)
{
(void) x;
(void) y;
switch (key) {
case GLUT_KEY_UP:
if (camz < (DEPTH - 1.0)) {
camz += 1.0f;
}
break;
case GLUT_KEY_DOWN:
if (camz > -19.0) {
camz -= 1.0f;
}
break;
}
glutPostRedisplay();
}
static const GLubyte teximage[2][2][4] = {
{ { 255, 255, 255, 255}, { 128, 128, 128, 255} },
{ { 128, 128, 128, 255}, { 255, 255, 255, 255} }
};
printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
static void Init( void )
{
have_fog_coord = glutExtensionSupported("GL_EXT_fog_coord");
if (BuildTexture(TEXTURE_FILE, texture) == -1) {
exit(1);
if (!have_fog_coord) {
printf("GL_EXT_fog_coord not supported!\n");
}
glEnable(GL_TEXTURE_2D);
glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
glClearDepth(1.0f);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0,
GL_RGBA, GL_UNSIGNED_BYTE, teximage);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glClearColor(0.1f, 0.1f, 0.1f, 0.0f);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
@@ -383,11 +392,8 @@ static void Init( void )
glFogfv(GL_FOG_COLOR, fogColor);
glHint(GL_FOG_HINT, GL_NICEST);
fogCoord = SetFogCoord(GL_TRUE); /* try to enable fog_coord */
fogMode = SetFogMode(2); /* GL_EXP */
fogMode = SetFogMode(1);
camz = -19.0f;
#if ARRAYS
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, vertex_pointer);
@@ -395,24 +401,24 @@ static void Init( void )
glTexCoordPointer(2, GL_FLOAT, 0, texcoord_pointer);
if (have_fog_coord) {
glFogCoordPointer_ext = (GLFOGCOORDPOINTEREXTPROC)glutGetProcAddress("glFogCoordPointerEXT");
glFogCoordPointer_ext = (PFNGLFOGCOORDPOINTEREXTPROC)glutGetProcAddress("glFogCoordPointerEXT");
glEnableClientState(GL_FOG_COORDINATE_ARRAY_EXT);
glFogCoordPointer_ext(GL_FLOAT, 0, fogcoord_pointer);
}
#endif
Reset();
}
int main( int argc, char *argv[] )
int
main( int argc, char *argv[] )
{
glutInit( &argc, argv );
glutInitWindowPosition( 0, 0 );
glutInitWindowSize( 640, 480 );
glutInitWindowSize( 600, 600 );
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );
glutCreateWindow(argv[0]);
glutReshapeFunc( Reshape );
glutKeyboardFunc( Key );
glutSpecialFunc( SpecialKey );
glutDisplayFunc( Display );
Init();
glutMainLoop();

View File

@@ -24,7 +24,7 @@ static GLuint VertProg;
static GLboolean Anim = GL_TRUE;
static GLboolean Wire = GL_FALSE;
static GLboolean PixelLight = GL_TRUE;
static GLint Win;
static GLfloat Xrot = 0, Yrot = 0;
@@ -136,8 +136,8 @@ static void Key( unsigned char key, int x, int y )
}
break;
case 27:
glutDestroyWindow(Win);
exit(0);
break;
}
glutPostRedisplay();
}
@@ -272,7 +272,7 @@ int main( int argc, char *argv[] )
glutInitWindowPosition( 0, 0 );
glutInitWindowSize( 200, 200 );
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );
glutCreateWindow(argv[0]);
Win = glutCreateWindow(argv[0]);
glutReshapeFunc( Reshape );
glutKeyboardFunc( Key );
glutSpecialFunc( SpecialKey );

View File

@@ -23,6 +23,8 @@
#include "extfuncs.h"
#define TEXTURE 0
static GLint CoordAttrib = 0;
static char *FragProgFile = NULL;
@@ -43,7 +45,7 @@ static GLint uTexture;
static GLuint SphereList, RectList, CurList;
static GLint win = 0;
static GLboolean anim = GL_FALSE;
static GLboolean anim = GL_TRUE;
static GLboolean wire = GL_FALSE;
static GLboolean pixelLight = GL_TRUE;
@@ -281,11 +283,12 @@ TestFunctions(void)
}
#if TEXTURE
static void
MakeTexture(void)
{
#define SZ0 128
#define SZ1 64
#define SZ0 64
#define SZ1 32
GLubyte image0[SZ0][SZ0][SZ0][4];
GLubyte image1[SZ1][SZ1][SZ1][4];
GLuint i, j, k;
@@ -348,6 +351,7 @@ MakeTexture(void)
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
#endif
static void
@@ -473,8 +477,8 @@ Init(void)
version = (const char *) glGetString(GL_VERSION);
if (version[0] != '2' || version[1] != '.') {
printf("Warning: this program expects OpenGL 2.0\n");
/*exit(1);*/
printf("This program requires OpenGL 2.x, found %s\n", version);
exit(1);
}
GetExtensionFuncs();
@@ -540,7 +544,9 @@ Init(void)
CurList = SphereList;
#if TEXTURE
MakeTexture();
#endif
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
printf("Press p to toggle between per-pixel and per-vertex lighting\n");
@@ -573,6 +579,8 @@ Init(void)
#if 0
TestFunctions();
#else
(void) TestFunctions;
#endif
}
@@ -597,7 +605,7 @@ main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitWindowPosition( 0, 0);
glutInitWindowSize(100, 100);
glutInitWindowSize(200, 200);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
win = glutCreateWindow(argv[0]);
glutReshapeFunc(Reshape);

View File

@@ -296,14 +296,27 @@ RenderShadowMap(void)
0, 1, 0); /* up */
if (UseFBO) {
GLenum fbo_status;
glTexImage2D(GL_TEXTURE_2D, 0, depthFormat,
ShadowTexWidth, ShadowTexHeight, 0,
depthFormat, depthType, NULL);
/* Set the filter mode so that the texture is texture-complete.
* Otherwise it will cause the framebuffer to fail the framebuffer
* completeness test.
*/
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, ShadowFBO);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);
assert(glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT)
== GL_FRAMEBUFFER_COMPLETE_EXT);
fbo_status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (fbo_status != GL_FRAMEBUFFER_COMPLETE_EXT) {
fprintf(stderr, "FBO not complete! status = 0x%04x\n", fbo_status);
assert(fbo_status == GL_FRAMEBUFFER_COMPLETE_EXT);
}
}
assert(!glIsEnabled(GL_TEXTURE_1D));

View File

@@ -1,221 +0,0 @@
LOCAL_LIBRARIES = $(XLIB) $(TOP)\lib\Mesaaux.a $(TOP)\lib\Mesaglu.a $(TOP)\lib\MesaGL.a
INCLUDES = -I$(TOP)\include
SRCS = accanti.c \
accnot.c \
accpersp.c \
accum.c \
aim.c \
alpha.c \
alpha3D.c \
anti.c \
antiindex.c \
antipindex.c \
antipoint.c \
antipoly.c \
bezcurve.c \
bezmesh.c \
bezsurf.c \
checker.c \
checker2.c \
chess.c \
clip.c \
colormat.c \
cone.c \
cube.c \
curve.c \
depthcue.c \
disk.c \
dof.c \
dofnot.c \
double.c \
drawf.c \
feedback.c \
fog.c \
fogindex.c \
font.c \
light.c \
linelist.c \
lines.c \
list.c \
list2.c \
maplight.c \
material.c \
mipmap.c \
model.c \
movelight.c \
nurbs.c \
pickdepth.c \
pickline.c \
picksquare.c \
plane.c \
planet.c \
planetup.c \
polys.c \
robot.c \
sccolorlight.c \
scene.c \
scenebamb.c \
sceneflat.c \
select.c \
simple.c \
smooth.c \
sphere.c \
stencil.c \
stroke.c \
surface.c \
tea.c \
teaambient.c \
teapots.c \
texgen.c \
texturesurf.c \
trim.c \
xfont.c
PROGRAMS = ProgramTargetName(accanti) \
ProgramTargetName(accnot) \
ProgramTargetName(accpersp) \
ProgramTargetName(accum) \
ProgramTargetName(aim) \
ProgramTargetName(alpha) \
ProgramTargetName(alpha3D) \
ProgramTargetName(anti) \
ProgramTargetName(antiindex) \
ProgramTargetName(antipindex) \
ProgramTargetName(antipoint) \
ProgramTargetName(antipoly) \
ProgramTargetName(bezcurve) \
ProgramTargetName(bezmesh) \
ProgramTargetName(bezsurf) \
ProgramTargetName(checker) \
ProgramTargetName(checker2) \
ProgramTargetName(chess) \
ProgramTargetName(clip) \
ProgramTargetName(colormat) \
ProgramTargetName(cone) \
ProgramTargetName(cube) \
ProgramTargetName(curve) \
ProgramTargetName(depthcue) \
ProgramTargetName(disk) \
ProgramTargetName(dof) \
ProgramTargetName(dofnot) \
ProgramTargetName(double) \
ProgramTargetName(drawf) \
ProgramTargetName(feedback) \
ProgramTargetName(fog) \
ProgramTargetName(fogindex) \
ProgramTargetName(font) \
ProgramTargetName(light) \
ProgramTargetName(linelist) \
ProgramTargetName(lines) \
ProgramTargetName(list) \
ProgramTargetName(list2) \
ProgramTargetName(maplight) \
ProgramTargetName(material) \
ProgramTargetName(mipmap) \
ProgramTargetName(model) \
ProgramTargetName(movelight) \
ProgramTargetName(nurbs) \
ProgramTargetName(pickdepth) \
ProgramTargetName(pickline) \
ProgramTargetName(picksquare) \
ProgramTargetName(plane) \
ProgramTargetName(planet) \
ProgramTargetName(planetup) \
ProgramTargetName(polys) \
ProgramTargetName(robot) \
ProgramTargetName(sccolorlight) \
ProgramTargetName(scene) \
ProgramTargetName(scenebamb) \
ProgramTargetName(sceneflat) \
ProgramTargetName(select) \
ProgramTargetName(simple) \
ProgramTargetName(smooth) \
ProgramTargetName(sphere) \
ProgramTargetName(stencil) \
ProgramTargetName(stroke) \
ProgramTargetName(surface) \
ProgramTargetName(tea) \
ProgramTargetName(teaambient) \
ProgramTargetName(teapots) \
ProgramTargetName(texgen) \
ProgramTargetName(texturesurf) \
ProgramTargetName(trim) \
ProgramTargetName(xfont)
AllTarget($(PROGRAMS))
NormalProgramTarget(accanti,accanti.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(accnot,accnot.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(accpersp,accpersp.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(accum,accum.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(aim,aim.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(alpha,alpha.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(alpha3D,alpha3D.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(anti,anti.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(antiindex,antiindex.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(antipindex,antipindex.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(antipoint,antipoint.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(antipoly,antipoly.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(bezcurve,bezcurve.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(bezmesh,bezmesh.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(bezsurf,bezsurf.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(checker,checker.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(checker2,checker2.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(chess,chess.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(clip,clip.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(colormat,colormat.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(cone,cone.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(cube,cube.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(curve,curve.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(depthcue,depthcue.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(disk,disk.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(dof,dof.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(dofnot,dofnot.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(double,double.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(drawf,drawf.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(feedback,feedback.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(fog,fog.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(fogindex,fogindex.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(font,font.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(light,light.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(linelist,linelist.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(lines,lines.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(list,list.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(list2,list2.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(maplight,maplight.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(material,material.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(mipmap,mipmap.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(model,model.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(movelight,movelight.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(nurbs,nurbs.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(pickdepth,pickdepth.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(pickline,pickline.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(picksquare,picksquare.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(plane,plane.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(planet,planet.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(planetup,planetup.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(polys,polys.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(robot,robot.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(sccolorlight,sccolorlight.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(scene,scene.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(scenebamb,scenebamb.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(sceneflat,sceneflat.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(select,select.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(simple,simple.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(smooth,smooth.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(sphere,sphere.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(stencil,stencil.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(stroke,stroke.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(surface,surface.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(tea,tea.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(teaambient,teaambient.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(teapots,teapots.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(texgen,texgen.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(texturesurf,texturesurf.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(trim,trim.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(xfont,xfont.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
DependTarget()

View File

@@ -1,101 +0,0 @@
LOCAL_LIBRARIES = $(XLIB) $(TOP)\lib\glut.a $(TOP)\lib\Mesaglu.a $(TOP)\lib\MesaGL.a
INCLUDES = -I$(TOP)\include
SRCS = accum.c \
bitmap1.c \
bitmap2.c \
blendeq.c \
blendxor.c \
copy.c \
cursor.c \
depth.c \
eval.c \
fog.c \
font.c \
line.c \
logo.c \
nurb.c \
oglinfo.c \
olympic.c \
overlay.c \
point.c \
prim.c \
quad.c \
select.c \
shape.c \
speed.c \
sphere.c \
star.c \
stencil.c \
stretch.c \
texture.c \
tri.c \
wave.c
PROGRAMS = ProgramTargetName(accum) \
ProgramTargetName(bitmap1) \
ProgramTargetName(bitmap2) \
ProgramTargetName(blendeq) \
ProgramTargetName(blendxor) \
ProgramTargetName(copy) \
ProgramTargetName(cursor) \
ProgramTargetName(depth) \
ProgramTargetName(eval) \
ProgramTargetName(fog) \
ProgramTargetName(font) \
ProgramTargetName(line) \
ProgramTargetName(logo) \
ProgramTargetName(nurb) \
ProgramTargetName(oglinfo) \
ProgramTargetName(olympic) \
ProgramTargetName(overlay) \
ProgramTargetName(point) \
ProgramTargetName(prim) \
ProgramTargetName(quad) \
ProgramTargetName(select) \
ProgramTargetName(shape) \
ProgramTargetName(speed) \
ProgramTargetName(sphere) \
ProgramTargetName(star) \
ProgramTargetName(stencil) \
ProgramTargetName(stretch) \
ProgramTargetName(texture) \
ProgramTargetName(tri) \
ProgramTargetName(wave)
AllTarget($(PROGRAMS))
NormalProgramTarget(accum,accum.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(bitmap1,bitmap1.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(bitmap2,bitmap2.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(blendeq,blendeq.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(blendxor,blendxor.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(copy,copy.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(cursor,cursor.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(depth,depth.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(eval,eval.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(fog,fog.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(font,font.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(line,line.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(logo,logo.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(nurb,nurb.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(oglinfo,oglinfo.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(olympic,olympic.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(overlay,overlay.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(point,point.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(prim,prim.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(quad,quad.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(select,select.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(shape,shape.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(speed,speed.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(sphere,sphere.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(star,star.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(stencil,stencil.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(stretch,stretch.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(texture,texture.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(tri,tri.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
NormalProgramTarget(wave,wave.o,NullParameter,$(LOCAL_LIBRARIES),NullParameter)
DependTarget()

View File

@@ -38,6 +38,13 @@ static PFNGLVERTEXATTRIB2FPROC glVertexAttrib2f_func = NULL;
static PFNGLVERTEXATTRIB3FPROC glVertexAttrib3f_func = NULL;
static PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f_func = NULL;
/* OpenGL 2.1 */
static PFNGLUNIFORMMATRIX2X3FVPROC glUniformMatrix2x3fv_func = NULL;
static PFNGLUNIFORMMATRIX3X2FVPROC glUniformMatrix3x2fv_func = NULL;
static PFNGLUNIFORMMATRIX2X4FVPROC glUniformMatrix2x4fv_func = NULL;
static PFNGLUNIFORMMATRIX4X2FVPROC glUniformMatrix4x2fv_func = NULL;
static PFNGLUNIFORMMATRIX3X4FVPROC glUniformMatrix3x4fv_func = NULL;
static PFNGLUNIFORMMATRIX4X3FVPROC glUniformMatrix4x3fv_func = NULL;
/* GL_ARB_vertex/fragment_program */
static PFNGLBINDPROGRAMARBPROC glBindProgramARB_func = NULL;
@@ -56,6 +63,8 @@ static PFNGLDELETEVERTEXARRAYSAPPLEPROC glDeleteVertexArraysAPPLE_func = NULL;
static PFNGLGENVERTEXARRAYSAPPLEPROC glGenVertexArraysAPPLE_func = NULL;
static PFNGLISVERTEXARRAYAPPLEPROC glIsVertexArrayAPPLE_func = NULL;
/* GL_EXT_stencil_two_side */
static PFNGLACTIVESTENCILFACEEXTPROC glActiveStencilFaceEXT_func = NULL;
static void
@@ -96,6 +105,13 @@ GetExtensionFuncs(void)
glVertexAttrib3f_func = (PFNGLVERTEXATTRIB3FPROC) glutGetProcAddress("glVertexAttrib3f");
glVertexAttrib4f_func = (PFNGLVERTEXATTRIB4FPROC) glutGetProcAddress("glVertexAttrib4f");
/* OpenGL 2.1 */
glUniformMatrix2x3fv_func = (PFNGLUNIFORMMATRIX2X3FVPROC) glutGetProcAddress("glUniformMatrix2x3fv");
glUniformMatrix3x2fv_func = (PFNGLUNIFORMMATRIX3X2FVPROC) glutGetProcAddress("glUniformMatrix3x2fv");
glUniformMatrix2x4fv_func = (PFNGLUNIFORMMATRIX2X4FVPROC) glutGetProcAddress("glUniformMatrix2x4fv");
glUniformMatrix4x2fv_func = (PFNGLUNIFORMMATRIX4X2FVPROC) glutGetProcAddress("glUniformMatrix4x2fv");
glUniformMatrix3x4fv_func = (PFNGLUNIFORMMATRIX3X4FVPROC) glutGetProcAddress("glUniformMatrix3x4fv");
glUniformMatrix4x3fv_func = (PFNGLUNIFORMMATRIX4X3FVPROC) glutGetProcAddress("glUniformMatrix4x3fv");
/* GL_ARB_vertex/fragment_program */
glBindProgramARB_func = (PFNGLBINDPROGRAMARBPROC) glutGetProcAddress("glBindProgramARB");
@@ -114,5 +130,7 @@ GetExtensionFuncs(void)
glGenVertexArraysAPPLE_func = (PFNGLGENVERTEXARRAYSAPPLEPROC) glutGetProcAddress("glGenVertexArraysAPPLE");
glIsVertexArrayAPPLE_func = (PFNGLISVERTEXARRAYAPPLEPROC) glutGetProcAddress("glIsVertexArrayAPPLE");
/* GL_EXT_stencil_two_side */
glActiveStencilFaceEXT_func = (PFNGLACTIVESTENCILFACEEXTPROC) glutGetProcAddress("glActiveStencilFaceEXT");
}

View File

@@ -11,7 +11,7 @@ C_SOURCES = \
$(TOP)/src/mesa/main/dispatch.c \
$(TOP)/src/mesa/glapi/glapi.c \
$(TOP)/src/mesa/glapi/glthread.c \
$(TOP)/src/mesa/drivers/dri/common/glcontextmodes.c \
$(TOP)/src/glx/x11/glcontextmodes.c \
miniglx.c \
miniglx_events.c
@@ -27,10 +27,7 @@ INCLUDE_DIRS = \
-I$(TOP)/src/mesa \
-I$(TOP)/src/mesa/main \
-I$(TOP)/src/mesa/glapi \
-I$(TOP)/src/mesa/math \
-I$(TOP)/src/mesa/transform \
-I$(TOP)/src/mesa/swrast \
-I$(TOP)/src/mesa/swrast_setup \
-I$(TOP)/src/glx/x11 \
-I$(TOP)/src/mesa/drivers/dri/common \
`pkg-config --cflags libdrm`

View File

@@ -47,8 +47,6 @@
#ifndef _driver_H_
#define _driver_H_
#define CAPI /* XXX this should be globally defined somewhere */
#include "GL/gl.h"
#include "GL/internal/glcore.h"

View File

@@ -46,7 +46,6 @@ INCLUDES = -I. \
-I$(TOP)/include/GL/internal \
-I$(TOP)/src/mesa/main \
-I$(TOP)/src/mesa/glapi \
-I$(TOP)/src/mesa/drivers/dri/common \
$(LIBDRM_CFLAGS) \
$(X11_INCLUDES)
@@ -63,9 +62,6 @@ INCLUDES = -I. \
default: depend $(TOP)/$(LIB_DIR)/$(GL_LIB_NAME)
glcontextmodes.c:
ln -s $(TOP)/src/mesa/drivers/dri/common/glcontextmodes.c .
# Make libGL
$(TOP)/$(LIB_DIR)/$(GL_LIB_NAME): $(OBJECTS) Makefile
$(TOP)/bin/mklib -o $(GL_LIB) -linker '$(CC)' \
@@ -81,7 +77,7 @@ depend: $(SOURCES) $(MESA_GLAPI_SOURCES) $(MESA_ASM_API) Makefile
# Emacs tags
tags:
etags `find . -name \*.[ch]` `find ../include`
etags `find . -name \*.[ch]` `find $(TOP)/include`
# Dummy install target
install:

View File

@@ -39,6 +39,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include <X11/Xlibint.h>
#include <X11/extensions/Xext.h>
#include <X11/extensions/extutil.h>
#include "glheader.h"
#include "glxclient.h"
#include "xf86dri.h"
#include "sarea.h"
@@ -81,11 +82,15 @@ static void InfoMessageF(const char *f, ...)
}
}
/**
* Print error to stderr, unless LIBGL_DEBUG=="quiet".
*/
static void ErrorMessageF(const char *f, ...)
{
va_list args;
const char *env;
if (getenv("LIBGL_DEBUG")) {
if ((env = getenv("LIBGL_DEBUG")) && !strstr(env, "quiet")) {
fprintf(stderr, "libGL error: ");
va_start(args, f);
vfprintf(stderr, f, args);
@@ -338,7 +343,7 @@ __DRIdriver *driGetDriver(Display *dpy, int scrNum)
* The returned char pointer points to a static array that will be
* overwritten by subsequent calls.
*/
const char *glXGetScreenDriver (Display *dpy, int scrNum) {
PUBLIC const char *glXGetScreenDriver (Display *dpy, int scrNum) {
static char ret[32];
char *driverName;
if (GetDriverName(dpy, scrNum, &driverName)) {
@@ -367,7 +372,7 @@ const char *glXGetScreenDriver (Display *dpy, int scrNum) {
*
* Note: The driver remains opened after this function returns.
*/
const char *glXGetDriverConfig (const char *driverName) {
PUBLIC const char *glXGetDriverConfig (const char *driverName) {
__DRIdriver *driver = OpenDriver (driverName);
if (driver)
return dlsym (driver->handle, "__driConfigOptions");

View File

@@ -31,21 +31,25 @@
* \author Ian Romanick <idr@us.ibm.com>
*/
#if defined(IN_MINI_GLX)
#include <GL/gl.h>
#else
#if defined(HAVE_DIX_CONFIG_H)
# include <dix-config.h>
#endif
#include <X11/X.h>
#include <GL/glx.h>
#include "GL/glxint.h"
#endif
/* Memory macros */
#if defined(IN_MINI_GLX)
# include <stdlib.h>
# include <string.h>
# include <GL/gl.h>
# include "GL/internal/dri_interface.h"
# include "imports.h"
# define _mesa_malloc(b) malloc(b)
# define _mesa_free(m) free(m)
# define _mesa_memset memset
#else
# if defined(HAVE_DIX_CONFIG_H)
# include <dix-config.h>
# endif
# include <X11/X.h>
# include <GL/glx.h>
# include "GL/glxint.h"
# ifdef XFree86Server
# include <os.h>
# include <string.h>

View File

@@ -1246,7 +1246,7 @@ __GLXdisplayPrivate *__glXInitialize(Display* dpy)
__glXUnlock();
return 0;
}
dpyPriv = (__GLXdisplayPrivate *) Xmalloc(sizeof(__GLXdisplayPrivate));
dpyPriv = (__GLXdisplayPrivate *) Xcalloc(1, sizeof(__GLXdisplayPrivate));
if (!dpyPriv) {
__glXUnlock();
Xfree((char*) private);
@@ -1271,12 +1271,7 @@ __GLXdisplayPrivate *__glXInitialize(Display* dpy)
** Note: This _must_ be done before calling any other DRI routines
** (e.g., those called in AllocAndFetchScreenConfigs).
*/
if (getenv("LIBGL_ALWAYS_INDIRECT")) {
/* Assinging zero here assures we'll never go direct */
dpyPriv->driDisplay.private = 0;
dpyPriv->driDisplay.destroyDisplay = 0;
}
else {
if (getenv("LIBGL_ALWAYS_INDIRECT") == NULL) {
dpyPriv->driDisplay.private =
driCreateDisplay(dpy, &dpyPriv->driDisplay);
}
@@ -1488,7 +1483,7 @@ void __glXSendLargeCommand(__GLXcontext *ctx,
/************************************************************************/
GLXContext glXGetCurrentContext(void)
PUBLIC GLXContext glXGetCurrentContext(void)
{
GLXContext cx = __glXGetCurrentContext();
@@ -1499,7 +1494,7 @@ GLXContext glXGetCurrentContext(void)
}
}
GLXDrawable glXGetCurrentDrawable(void)
PUBLIC GLXDrawable glXGetCurrentDrawable(void)
{
GLXContext gc = __glXGetCurrentContext();
return gc->currentDrawable;

View File

@@ -145,9 +145,10 @@ GLenum __indirect_glGetError(void)
* On success \c GL_TRUE is returned. Otherwise, \c GL_FALSE is returned.
*/
static GLboolean
get_client_data( __GLXattribute * state, GLenum cap, GLintptr * data )
get_client_data( __GLXcontext * gc, GLenum cap, GLintptr * data )
{
GLboolean retval = GL_TRUE;
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
const GLint tex_unit = __glXGetActiveTextureUnit( state );
@@ -281,6 +282,9 @@ get_client_data( __GLXattribute * state, GLenum cap, GLintptr * data )
case GL_UNPACK_LSB_FIRST:
*data = (GLintptr)state->storeUnpack.lsbFirst;
break;
case GL_CLIENT_ATTRIB_STACK_DEPTH:
*data = (GLintptr)(gc->attributes.stackPointer - gc->attributes.stack);
break;
case GL_MAX_CLIENT_ATTRIB_STACK_DEPTH:
*data = (GLintptr)__GL_CLIENT_ATTRIB_STACK_DEPTH;
break;
@@ -302,7 +306,6 @@ void __indirect_glGetBooleanv(GLenum val, GLboolean *b)
{
const GLenum origVal = val;
__GLX_SINGLE_DECLARE_VARIABLES();
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
xGLXSingleReply reply;
val = RemapTransposeEnum( val );
@@ -326,7 +329,7 @@ void __indirect_glGetBooleanv(GLenum val, GLboolean *b)
** for example, to call a query between glBegin() and glEnd()).
*/
if ( get_client_data( state, val, & data ) ) {
if ( get_client_data( gc, val, & data ) ) {
*b = (GLboolean) data;
}
else {
@@ -351,7 +354,6 @@ void __indirect_glGetDoublev(GLenum val, GLdouble *d)
{
const GLenum origVal = val;
__GLX_SINGLE_DECLARE_VARIABLES();
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
xGLXSingleReply reply;
val = RemapTransposeEnum( val );
@@ -375,7 +377,7 @@ void __indirect_glGetDoublev(GLenum val, GLdouble *d)
** for example, to call a query between glBegin() and glEnd()).
*/
if ( get_client_data( state, val, & data ) ) {
if ( get_client_data( gc, val, & data ) ) {
*d = (GLdouble) data;
}
else {
@@ -400,7 +402,6 @@ void __indirect_glGetFloatv(GLenum val, GLfloat *f)
{
const GLenum origVal = val;
__GLX_SINGLE_DECLARE_VARIABLES();
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
xGLXSingleReply reply;
val = RemapTransposeEnum( val );
@@ -424,7 +425,7 @@ void __indirect_glGetFloatv(GLenum val, GLfloat *f)
** for example, to call a query between glBegin() and glEnd()).
*/
if ( get_client_data( state, val, & data ) ) {
if ( get_client_data( gc, val, & data ) ) {
*f = (GLfloat) data;
}
else {
@@ -449,7 +450,6 @@ void __indirect_glGetIntegerv(GLenum val, GLint *i)
{
const GLenum origVal = val;
__GLX_SINGLE_DECLARE_VARIABLES();
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
xGLXSingleReply reply;
val = RemapTransposeEnum( val );
@@ -473,7 +473,7 @@ void __indirect_glGetIntegerv(GLenum val, GLint *i)
** for example, to call a query between glBegin() and glEnd()).
*/
if ( get_client_data( state, val, & data ) ) {
if ( get_client_data( gc, val, & data ) ) {
*i = (GLint) data;
}
else {

View File

@@ -89,9 +89,7 @@ fbdev: $(CORE_OBJECTS) $(FBDEV_DRIVER_OBJECTS) $(COMMON_DRIVER_OBJECTS)
# Stand-alone Mesa libGL and libOSMesa
STAND_ALONE_DRIVER_SOURCES = \
$(COMMON_DRIVER_SOURCES) \
$(X11_DRIVER_SOURCES) \
$(GLIDE_DRIVER_SOURCES) \
$(SVGA_DRIVER_SOURCES)
$(X11_DRIVER_SOURCES)
STAND_ALONE_DRIVER_OBJECTS = $(STAND_ALONE_DRIVER_SOURCES:.c=.o)

View File

@@ -28,9 +28,9 @@
#include "buffers.h"
#include "context.h"
#include "framebuffer.h"
#include "occlude.h"
#include "program.h"
#include "prog_execute.h"
#include "queryobj.h"
#include "renderbuffer.h"
#include "texcompress.h"
#include "texformat.h"

View File

@@ -190,11 +190,16 @@ driBOKernel(struct _DriBufferObject *buf)
void
driBOWaitIdle(struct _DriBufferObject *buf, int lazy)
{
assert(buf->private != NULL);
struct _DriBufferPool *pool;
void *priv;
_glthread_LOCK_MUTEX(buf->mutex);
BM_CKFATAL(buf->pool->waitIdle(buf->pool, buf->private, lazy));
pool = buf->pool;
priv = buf->private;
_glthread_UNLOCK_MUTEX(buf->mutex);
assert(priv != NULL);
BM_CKFATAL(buf->pool->waitIdle(pool, priv, lazy));
}
void *
@@ -296,7 +301,8 @@ driBOData(struct _DriBufferObject *buf,
pool->destroy(pool, buf->private);
if (!flags)
flags = buf->flags;
buf->private = pool->create(pool, size, flags, 0, buf->alignment);
buf->private = pool->create(pool, size, flags, DRM_BO_HINT_DONT_FENCE,
buf->alignment);
if (!buf->private)
BM_CKFATAL(-ENOMEM);
BM_CKFATAL(pool->map(pool, buf->private,

View File

@@ -185,7 +185,7 @@ pool_setstatic(struct _DriBufferPool *pool, unsigned long offset,
return NULL;
ret = drmBOCreate(pool->fd, offset, size, 0, NULL, drm_bo_type_fake,
flags, 0, buf);
flags, DRM_BO_HINT_DONT_FENCE, buf);
if (ret) {
free(buf);

View File

@@ -49,8 +49,6 @@
#ifndef _DRI_UTIL_H_
#define _DRI_UTIL_H_
#define CAPI /* XXX this should be globally defined somewhere */
#include <GL/gl.h>
#include "drm.h"
#include "drm_sarea.h"

View File

@@ -208,7 +208,7 @@ driUpdateFramebufferSize(GLcontext *ctx, const __DRIdrawablePrivate *dPriv)
{
struct gl_framebuffer *fb = (struct gl_framebuffer *) dPriv->driverPrivate;
if (fb && (dPriv->w != fb->Width || dPriv->h != fb->Height)) {
_mesa_resize_framebuffer(ctx, fb, dPriv->w, dPriv->h);
ctx->Driver.ResizeBuffers(ctx, fb, dPriv->w, dPriv->h);
assert(fb->Width == dPriv->w);
assert(fb->Height == dPriv->h);
}

View File

@@ -40,6 +40,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "extensions.h"
#include "framebuffer.h"
#include "imports.h"
#include "points.h"
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
@@ -278,6 +279,11 @@ i810CreateContext( const __GLcontextModes *mesaVis,
ctx->Const.MaxPointSizeAA = 3.0;
ctx->Const.PointSizeGranularity = 1.0;
/* reinitialize the context point state.
* It depend on constants in __GLcontextRec::Const
*/
_mesa_init_point(ctx);
ctx->Driver.GetBufferSize = i810BufferSize;
ctx->Driver.GetString = i810GetString;

View File

@@ -168,6 +168,7 @@ GLboolean i915CreateContext( const __GLcontextModes *mesaVis,
ctx->Const.FragmentProgram.MaxNativeTexIndirections = I915_MAX_TEX_INDIRECT;
ctx->Const.FragmentProgram.MaxNativeAddressRegs = 0; /* I don't think we have one */
ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
ctx->FragmentProgram._UseTexEnvProgram = GL_TRUE;
driInitExtensions( ctx, i915_extensions, GL_FALSE );

View File

@@ -531,7 +531,7 @@ void i915_update_fog( GLcontext *ctx )
GLboolean enabled;
GLboolean try_pixel_fog;
if (ctx->FragmentProgram._Enabled) {
if (ctx->FragmentProgram._Active) {
/* Pull in static fog state from program */
mode = ctx->FragmentProgram._Current->FogOption;
@@ -541,17 +541,19 @@ void i915_update_fog( GLcontext *ctx )
else {
enabled = ctx->Fog.Enabled;
mode = ctx->Fog.Mode;
try_pixel_fog = (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT &&
ctx->Hint.Fog == GL_NICEST &&
0); /* XXX - DISABLE -- Need ortho fallback */
#if 0
/* XXX - DISABLED -- Need ortho fallback */
try_pixel_fog = (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT
&&ctx->Hint.Fog == GL_NICEST);
#else
try_pixel_fog = 0;
#endif
}
if (!enabled) {
i915->vertex_fog = I915_FOG_NONE;
}
else if (try_pixel_fog) {
I915_STATECHANGE(i915, I915_UPLOAD_FOG);
i915->state.Fog[I915_FOGREG_MODE1] &= ~FMC1_FOGFUNC_MASK;
i915->vertex_fog = I915_FOG_PIXEL;
@@ -567,8 +569,8 @@ void i915_update_fog( GLcontext *ctx )
i915->vertex_fog = I915_FOG_VERTEX;
}
else {
GLfloat c1 = ctx->Fog.End/(ctx->Fog.End-ctx->Fog.Start);
GLfloat c2 = 1.0/(ctx->Fog.End-ctx->Fog.Start);
GLfloat c2 = 1.0 / (ctx->Fog.End - ctx->Fog.Start);
GLfloat c1 = ctx->Fog.End * c2;
i915->state.Fog[I915_FOGREG_MODE1] &= ~FMC1_C1_MASK;
i915->state.Fog[I915_FOGREG_MODE1] |= FMC1_FOGFUNC_PIXEL_LINEAR;
@@ -576,10 +578,11 @@ void i915_update_fog( GLcontext *ctx )
((GLuint)(c1 * FMC1_C1_ONE)) & FMC1_C1_MASK;
if (i915->state.Fog[I915_FOGREG_MODE1] & FMC1_FOGINDEX_Z) {
i915->state.Fog[I915_FOGREG_MODE2] = (GLuint)(c2 * FMC2_C2_ONE);
i915->state.Fog[I915_FOGREG_MODE2]
= (GLuint)(c2 * FMC2_C2_ONE);
}
else {
union { float f; int i; } fi;
fi_type fi;
fi.f = c2;
i915->state.Fog[I915_FOGREG_MODE2] = fi.i;
}
@@ -602,24 +605,22 @@ void i915_update_fog( GLcontext *ctx )
i915->vertex_fog = I915_FOG_VERTEX;
}
{
I915_STATECHANGE(i915, I915_UPLOAD_CTX);
I915_ACTIVESTATE(i915, I915_UPLOAD_FOG, enabled);
if (enabled)
i915->state.Ctx[I915_CTXREG_LIS5] |= S5_FOG_ENABLE;
else
i915->state.Ctx[I915_CTXREG_LIS5] &= ~S5_FOG_ENABLE;
}
I915_STATECHANGE(i915, I915_UPLOAD_CTX);
I915_ACTIVESTATE(i915, I915_UPLOAD_FOG, enabled);
if (enabled)
i915->state.Ctx[I915_CTXREG_LIS5] |= S5_FOG_ENABLE;
else
i915->state.Ctx[I915_CTXREG_LIS5] &= ~S5_FOG_ENABLE;
/* always enbale pixel fog
* vertex fog use precaculted fog coord will conflict with appended
* fog program
/* Always enable pixel fog. Vertex fog using fog coord will conflict
* with fog code appended onto fragment program.
*/
_tnl_allow_vertex_fog( ctx, 0 );
_tnl_allow_pixel_fog( ctx, 1 );
}
static void i915Fogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
static void
i915Fogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
{
i915ContextPtr i915 = I915_CONTEXT(ctx);
@@ -634,8 +635,8 @@ static void i915Fogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
I915_STATECHANGE(i915, I915_UPLOAD_FOG);
if (i915->state.Fog[I915_FOGREG_MODE1] & FMC1_FOGINDEX_Z) {
i915->state.Fog[I915_FOGREG_MODE3] = (GLuint)(ctx->Fog.Density *
FMC3_D_ONE);
i915->state.Fog[I915_FOGREG_MODE3]
= (GLuint)(ctx->Fog.Density * FMC3_D_ONE);
}
else {
union { float f; int i; } fi;

View File

@@ -46,7 +46,7 @@ static void i915_render_start( intelContextPtr intel )
GLcontext *ctx = &intel->ctx;
i915ContextPtr i915 = I915_CONTEXT(intel);
if (ctx->FragmentProgram._Current)
if (ctx->FragmentProgram._Active)
i915ValidateFragmentProgram( i915 );
else {
assert(!ctx->FragmentProgram._MaintainTexEnvProgram);

View File

@@ -33,6 +33,7 @@
#include "extensions.h"
#include "framebuffer.h"
#include "imports.h"
#include "points.h"
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
@@ -195,7 +196,6 @@ static const struct tnl_pipeline_stage *intel_pipeline[] = {
&_tnl_texgen_stage,
&_tnl_texture_transform_stage,
&_tnl_point_attenuation_stage,
&_tnl_arb_vertex_program_stage,
&_tnl_vertex_program_stage,
#if 1
&_intel_render_stage, /* ADD: unclipped rastersetup-to-dma */
@@ -302,6 +302,11 @@ GLboolean intelInitContext( intelContextPtr intel,
ctx->Const.MaxPointSizeAA = 3.0;
ctx->Const.PointSizeGranularity = 1.0;
/* reinitialize the context point state.
* It depend on constants in __GLcontextRec::Const
*/
_mesa_init_point(ctx);
/* Initialize the software rasterizer and helper modules. */
_swrast_CreateContext( ctx );
_vbo_CreateContext( ctx );
@@ -563,7 +568,7 @@ void intelWindowMoved( intelContextPtr intel )
GLint areaB = driIntersectArea( drw_rect, pipeB_rect );
GLuint flags = intel->vblank_flags;
if (areaB > areaA || (areaA > 0 && areaB > 0)) {
if (areaB > areaA || (areaA == areaB && areaB > 0)) {
flags = intel->vblank_flags | VBLANK_FLAG_SECONDARY;
} else {
flags = intel->vblank_flags & ~VBLANK_FLAG_SECONDARY;

View File

@@ -158,7 +158,7 @@ i915CreateContext(const __GLcontextModes * mesaVis,
ctx->Const.FragmentProgram.MaxNativeAddressRegs = 0; /* I don't think we have one */
ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
/*ctx->_UseTexEnvProgram = 1;*/
ctx->FragmentProgram._UseTexEnvProgram = GL_TRUE;
driInitExtensions(ctx, i915_extensions, GL_FALSE);

View File

@@ -561,9 +561,8 @@ i915_update_fog(GLcontext * ctx)
GLboolean enabled;
GLboolean try_pixel_fog;
if (ctx->FragmentProgram._Enabled) {
if (ctx->FragmentProgram._Active) {
/* Pull in static fog state from program */
mode = ctx->FragmentProgram._Current->FogOption;
enabled = (mode != GL_NONE);
try_pixel_fog = 0;
@@ -571,15 +570,19 @@ i915_update_fog(GLcontext * ctx)
else {
enabled = ctx->Fog.Enabled;
mode = ctx->Fog.Mode;
try_pixel_fog = (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT && ctx->Hint.Fog == GL_NICEST && 0); /* XXX - DISABLE -- Need ortho fallback */
#if 0
/* XXX - DISABLED -- Need ortho fallback */
try_pixel_fog = (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT
&& ctx->Hint.Fog == GL_NICEST);
#else
try_pixel_fog = 0;
#endif
}
if (!enabled) {
i915->vertex_fog = I915_FOG_NONE;
}
else if (try_pixel_fog) {
I915_STATECHANGE(i915, I915_UPLOAD_FOG);
i915->state.Fog[I915_FOGREG_MODE1] &= ~FMC1_FOGFUNC_MASK;
i915->vertex_fog = I915_FOG_PIXEL;
@@ -591,12 +594,13 @@ i915_update_fog(GLcontext * ctx)
* either fallback or append fog instructions to end of
* program in the case of linear fog.
*/
printf("vertex fog!\n");
i915->state.Fog[I915_FOGREG_MODE1] |= FMC1_FOGFUNC_VERTEX;
i915->vertex_fog = I915_FOG_VERTEX;
}
else {
GLfloat c1 = ctx->Fog.End / (ctx->Fog.End - ctx->Fog.Start);
GLfloat c2 = 1.0 / (ctx->Fog.End - ctx->Fog.Start);
GLfloat c1 = ctx->Fog.End * c2;
i915->state.Fog[I915_FOGREG_MODE1] &= ~FMC1_C1_MASK;
i915->state.Fog[I915_FOGREG_MODE1] |= FMC1_FOGFUNC_PIXEL_LINEAR;
@@ -604,15 +608,11 @@ i915_update_fog(GLcontext * ctx)
((GLuint) (c1 * FMC1_C1_ONE)) & FMC1_C1_MASK;
if (i915->state.Fog[I915_FOGREG_MODE1] & FMC1_FOGINDEX_Z) {
i915->state.Fog[I915_FOGREG_MODE2] =
(GLuint) (c2 * FMC2_C2_ONE);
i915->state.Fog[I915_FOGREG_MODE2]
= (GLuint) (c2 * FMC2_C2_ONE);
}
else {
union
{
float f;
int i;
} fi;
fi_type fi;
fi.f = c2;
i915->state.Fog[I915_FOGREG_MODE2] = fi.i;
}
@@ -628,26 +628,22 @@ i915_update_fog(GLcontext * ctx)
break;
}
}
else { /* if (i915->vertex_fog != I915_FOG_VERTEX) */
else { /* if (i915->vertex_fog != I915_FOG_VERTEX) */
I915_STATECHANGE(i915, I915_UPLOAD_FOG);
i915->state.Fog[I915_FOGREG_MODE1] &= ~FMC1_FOGFUNC_MASK;
i915->state.Fog[I915_FOGREG_MODE1] |= FMC1_FOGFUNC_VERTEX;
i915->vertex_fog = I915_FOG_VERTEX;
}
{
I915_STATECHANGE(i915, I915_UPLOAD_CTX);
I915_ACTIVESTATE(i915, I915_UPLOAD_FOG, enabled);
if (enabled)
i915->state.Ctx[I915_CTXREG_LIS5] |= S5_FOG_ENABLE;
else
i915->state.Ctx[I915_CTXREG_LIS5] &= ~S5_FOG_ENABLE;
}
I915_STATECHANGE(i915, I915_UPLOAD_CTX);
I915_ACTIVESTATE(i915, I915_UPLOAD_FOG, enabled);
if (enabled)
i915->state.Ctx[I915_CTXREG_LIS5] |= S5_FOG_ENABLE;
else
i915->state.Ctx[I915_CTXREG_LIS5] &= ~S5_FOG_ENABLE;
/* always enbale pixel fog
* vertex fog use precaculted fog coord will conflict with appended
* fog program
/* Always enable pixel fog. Vertex fog using fog coord will conflict
* with fog code appended onto fragment program.
*/
_tnl_allow_vertex_fog( ctx, 0 );
_tnl_allow_pixel_fog( ctx, 1 );
@@ -669,15 +665,11 @@ i915Fogfv(GLcontext * ctx, GLenum pname, const GLfloat * param)
I915_STATECHANGE(i915, I915_UPLOAD_FOG);
if (i915->state.Fog[I915_FOGREG_MODE1] & FMC1_FOGINDEX_Z) {
i915->state.Fog[I915_FOGREG_MODE3] = (GLuint) (ctx->Fog.Density *
FMC3_D_ONE);
i915->state.Fog[I915_FOGREG_MODE3] =
(GLuint) (ctx->Fog.Density * FMC3_D_ONE);
}
else {
union
{
float f;
int i;
} fi;
fi_type fi;
fi.f = ctx->Fog.Density;
i915->state.Fog[I915_FOGREG_MODE3] = fi.i;
}

View File

@@ -96,7 +96,7 @@ createBPool(int fd, unsigned long bufSize, unsigned numBufs, unsigned flags,
_glthread_INIT_MUTEX(p->mutex);
if (drmBOCreate(fd, 0, numBufs * bufSize, 0, NULL, drm_bo_type_dc,
flags, 0, &p->kernelBO)) {
flags, DRM_BO_HINT_DONT_FENCE, &p->kernelBO)) {
free(p->bufs);
free(p);
return NULL;

View File

@@ -76,7 +76,9 @@ intel_bufferobj_release_region(struct intel_context *intel,
*/
driGenBuffers(intel->intelScreen->regionPool,
"buffer object", 1, &intel_obj->buffer, 64, 0, 0);
LOCK_HARDWARE(intel);
driBOData(intel_obj->buffer, intel_obj->Base.Size, NULL, 0);
UNLOCK_HARDWARE(intel);
}
/* Break the COW tie to the region. Both the pbo and the region end
@@ -137,7 +139,9 @@ intel_bufferobj_data(GLcontext * ctx,
if (intel_obj->region)
intel_bufferobj_release_region(intel, intel_obj);
LOCK_HARDWARE(intel);
driBOData(intel_obj->buffer, size, data, 0);
UNLOCK_HARDWARE(intel);
}

View File

@@ -33,6 +33,7 @@
#include "extensions.h"
#include "framebuffer.h"
#include "imports.h"
#include "points.h"
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
@@ -208,7 +209,6 @@ static const struct tnl_pipeline_stage *intel_pipeline[] = {
&_tnl_texgen_stage,
&_tnl_texture_transform_stage,
&_tnl_point_attenuation_stage,
&_tnl_arb_vertex_program_stage,
&_tnl_vertex_program_stage,
#if 1
&_intel_render_stage, /* ADD: unclipped rastersetup-to-dma */
@@ -346,7 +346,15 @@ intelInitContext(struct intel_context *intel,
drmI830Sarea *saPriv = (drmI830Sarea *)
(((GLubyte *) sPriv->pSAREA) + intelScreen->sarea_priv_offset);
int fthrottle_mode;
GLboolean havePools;
DRM_LIGHT_LOCK(sPriv->fd, &sPriv->pSAREA->lock, driContextPriv->hHWContext);
havePools = intelCreatePools(intelScreen);
DRM_UNLOCK(sPriv->fd, &sPriv->pSAREA->lock, driContextPriv->hHWContext);
if (!havePools)
return GL_FALSE;
if (!_mesa_initialize_context(&intel->ctx,
mesaVis, shareCtx,
functions, (void *) intel))
@@ -390,6 +398,11 @@ intelInitContext(struct intel_context *intel,
ctx->Const.MaxPointSizeAA = 3.0;
ctx->Const.PointSizeGranularity = 1.0;
/* reinitialize the context point state.
* It depend on constants in __GLcontextRec::Const
*/
_mesa_init_point(ctx);
ctx->Const.MaxColorAttachments = 4; /* XXX FBO: review this */
/* Initialize the software rasterizer and helper modules. */
@@ -581,10 +594,11 @@ intelMakeCurrent(__DRIcontextPrivate * driContextPriv,
}
/* set GLframebuffer size to match window, if needed */
if (driReadPriv != driDrawPriv && readFb->Width != driReadPriv->w) {
_mesa_resize_framebuffer(&intel->ctx, readFb,
driReadPriv->w, driReadPriv->h);
}
driUpdateFramebufferSize(&intel->ctx, driDrawPriv);
if (driReadPriv != driDrawPriv) {
driUpdateFramebufferSize(&intel->ctx, driReadPriv);
}
_mesa_make_current(&intel->ctx, &intel_fb->Base, readFb);

View File

@@ -309,27 +309,39 @@ static GLboolean
intel_alloc_window_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
GLenum internalFormat, GLuint width, GLuint height)
{
struct intel_context *intel = intel_context(ctx);
struct intel_framebuffer *intel_fb;
ASSERT(rb->Name == 0);
rb->Width = width;
rb->Height = height;
rb->_ActualFormat = internalFormat;
if (intel && intel->driDrawable &&
(intel_fb = intel->driDrawable->driverPrivate) &&
intel_fb->pf_num_pages == 3 &&
rb == &intel_fb->color_rb[intel_fb->pf_current_page]->Base &&
(rb = &intel_fb->color_rb[(intel_fb->pf_current_page + 2) % 3]->Base)) {
rb->Width = width;
rb->Height = height;
rb->_ActualFormat = internalFormat;
}
return GL_TRUE;
}
static void
intel_resize_buffers(GLcontext *ctx, struct gl_framebuffer *fb,
GLuint width, GLuint height)
{
struct intel_framebuffer *intel_fb = (struct intel_framebuffer*)fb;
int i;
_mesa_resize_framebuffer(ctx, fb, width, height);
fb->Initialized = GL_TRUE; /* XXX remove someday */
if (fb->Name != 0) {
return;
}
/* Make sure all window system renderbuffers are up to date */
for (i = 0; i < 3; i++) {
struct gl_renderbuffer *rb = &intel_fb->color_rb[i]->Base;
/* only resize if size is changing */
if (rb && (rb->Width != width || rb->Height != height)) {
rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height);
}
}
}
static GLboolean
intel_nop_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
@@ -508,7 +520,7 @@ intel_framebuffer_renderbuffer(GLcontext * ctx,
/**
* When glFramebufferTexture[123]D is called this function sets up the
* gl_renderbuffer wrapp around the texture image.
* gl_renderbuffer wrapper around the texture image.
* This will have the region info needed for hardware rendering.
*/
static struct intel_renderbuffer *
@@ -594,7 +606,7 @@ intel_render_texture(GLcontext * ctx,
irb = intel_wrap_texture(ctx, newImage);
if (irb) {
/* bind the wrapper to the attachment point */
att->Renderbuffer = &irb->Base;
_mesa_reference_renderbuffer(&att->Renderbuffer, &irb->Base);
}
else {
/* fallback to software rendering */
@@ -671,4 +683,5 @@ intel_fbo_init(struct intel_context *intel)
intel->ctx.Driver.FramebufferRenderbuffer = intel_framebuffer_renderbuffer;
intel->ctx.Driver.RenderTexture = intel_render_texture;
intel->ctx.Driver.FinishRenderTexture = intel_finish_render_texture;
intel->ctx.Driver.ResizeBuffers = intel_resize_buffers;
}

View File

@@ -317,7 +317,7 @@ intel_miptree_image_data(struct intel_context *intel,
0, 0, /* source x, y */
dst->level[level].width, height); /* width, height */
src += src_image_pitch;
src += src_image_pitch * dst->cpp;
}
}

View File

@@ -90,6 +90,7 @@ intel_region_alloc(intelScreenPrivate *intelScreen,
GLuint cpp, GLuint pitch, GLuint height)
{
struct intel_region *region = calloc(sizeof(*region), 1);
struct intel_context *intel = intelScreenContext(intelScreen);
DBG("%s\n", __FUNCTION__);
@@ -107,7 +108,9 @@ intel_region_alloc(intelScreenPrivate *intelScreen,
0,
#endif
0);
LOCK_HARDWARE(intel);
driBOData(region->buffer, pitch * cpp * height, NULL, 0);
UNLOCK_HARDWARE(intel);
return region;
}
@@ -392,6 +395,8 @@ void
intel_region_release_pbo(intelScreenPrivate *intelScreen,
struct intel_region *region)
{
struct intel_context *intel = intelScreenContext(intelScreen);
assert(region->buffer == region->pbo->buffer);
region->pbo->region = NULL;
region->pbo = NULL;
@@ -400,8 +405,11 @@ intel_region_release_pbo(intelScreenPrivate *intelScreen,
driGenBuffers(intelScreen->regionPool,
"region", 1, &region->buffer, 64, 0, 0);
LOCK_HARDWARE(intel);
driBOData(region->buffer,
region->cpp * region->pitch * region->height, NULL, 0);
UNLOCK_HARDWARE(intel);
}
/* Break the COW tie to the pbo. Both the pbo and the region end up

View File

@@ -386,6 +386,45 @@ intelUpdateScreenFromSAREA(intelScreenPrivate * intelScreen,
intelPrintSAREA(sarea);
}
GLboolean
intelCreatePools(intelScreenPrivate *intelScreen)
{
unsigned batchPoolSize = 1024*1024;
__DRIscreenPrivate * sPriv = intelScreen->driScrnPriv;
if (intelScreen->havePools)
return GL_TRUE;
batchPoolSize /= intelScreen->maxBatchSize;
intelScreen->regionPool = driDRMPoolInit(sPriv->fd);
if (!intelScreen->regionPool)
return GL_FALSE;
intelScreen->staticPool = driDRMStaticPoolInit(sPriv->fd);
if (!intelScreen->staticPool)
return GL_FALSE;
intelScreen->texPool = intelScreen->regionPool;
intelScreen->batchPool = driBatchPoolInit(sPriv->fd,
DRM_BO_FLAG_EXE |
DRM_BO_FLAG_MEM_TT |
DRM_BO_FLAG_MEM_LOCAL,
intelScreen->maxBatchSize,
batchPoolSize, 5);
if (!intelScreen->batchPool) {
fprintf(stderr, "Failed to initialize batch pool - possible incorrect agpgart installed\n");
return GL_FALSE;
}
intel_recreate_static_regions(intelScreen);
intelScreen->havePools = GL_TRUE;
return GL_TRUE;
}
static GLboolean
intelInitDriver(__DRIscreenPrivate * sPriv)
@@ -393,7 +432,6 @@ intelInitDriver(__DRIscreenPrivate * sPriv)
intelScreenPrivate *intelScreen;
I830DRIPtr gDRIPriv = (I830DRIPtr) sPriv->pDevPriv;
drmI830Sarea *sarea;
unsigned batchPoolSize = 1024*1024;
PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
(PFNGLXSCRENABLEEXTENSIONPROC) (*dri_interface->
@@ -426,7 +464,6 @@ intelInitDriver(__DRIscreenPrivate * sPriv)
intelScreen->deviceID = gDRIPriv->deviceID;
if (intelScreen->deviceID == PCI_CHIP_I865_G)
intelScreen->maxBatchSize = 4096;
batchPoolSize /= intelScreen->maxBatchSize;
intelScreen->mem = gDRIPriv->mem;
intelScreen->cpp = gDRIPriv->cpp;
@@ -517,31 +554,6 @@ intelInitDriver(__DRIscreenPrivate * sPriv)
(*glx_enable_extension) (psc, "GLX_SGI_make_current_read");
}
intelScreen->regionPool = driDRMPoolInit(sPriv->fd);
if (!intelScreen->regionPool)
return GL_FALSE;
intelScreen->staticPool = driDRMStaticPoolInit(sPriv->fd);
if (!intelScreen->staticPool)
return GL_FALSE;
intelScreen->texPool = intelScreen->regionPool;
intelScreen->batchPool = driBatchPoolInit(sPriv->fd,
DRM_BO_FLAG_EXE |
DRM_BO_FLAG_MEM_TT |
DRM_BO_FLAG_MEM_LOCAL,
intelScreen->maxBatchSize,
batchPoolSize, 5);
if (!intelScreen->batchPool) {
fprintf(stderr, "Failed to initialize batch pool - possible incorrect agpgart installed\n");
return GL_FALSE;
}
intel_recreate_static_regions(intelScreen);
return GL_TRUE;
}
@@ -553,9 +565,11 @@ intelDestroyScreen(__DRIscreenPrivate * sPriv)
intelUnmapScreenRegions(intelScreen);
driPoolTakeDown(intelScreen->regionPool);
driPoolTakeDown(intelScreen->staticPool);
driPoolTakeDown(intelScreen->batchPool);
if (intelScreen->havePools) {
driPoolTakeDown(intelScreen->regionPool);
driPoolTakeDown(intelScreen->staticPool);
driPoolTakeDown(intelScreen->batchPool);
}
FREE(intelScreen);
sPriv->private = NULL;
}
@@ -892,6 +906,7 @@ __driCreateNewScreen_20050727(__DRInativeDisplay * dpy, int scrn,
ddx_version, dri_version, drm_version,
frame_buffer, pSAREA, fd,
internal_api_version, &intelAPI);
if (psp != NULL) {
I830DRIPtr dri_priv = (I830DRIPtr) psp->pDevPriv;
*driver_modes = intelFillInModes(dri_priv->cpp * 8,

View File

@@ -95,6 +95,7 @@ typedef struct
struct _DriBufferPool *regionPool;
struct _DriBufferPool *staticPool;
unsigned int maxBatchSize;
GLboolean havePools;
} intelScreenPrivate;
@@ -130,5 +131,7 @@ extern struct intel_context *intelScreenContext(intelScreenPrivate *intelScreen)
extern void
intelUpdateScreenRotation(__DRIscreenPrivate * sPriv, drmI830Sarea * sarea);
extern GLboolean
intelCreatePools(intelScreenPrivate *intelScreen);
#endif

View File

@@ -329,25 +329,7 @@ intelTexImage(GLcontext * ctx,
texImage->TexFormat = intelChooseTextureFormat(ctx, internalFormat,
format, type);
assert(texImage->TexFormat);
switch (dims) {
case 1:
texImage->FetchTexelc = texImage->TexFormat->FetchTexel1D;
texImage->FetchTexelf = texImage->TexFormat->FetchTexel1Df;
break;
case 2:
texImage->FetchTexelc = texImage->TexFormat->FetchTexel2D;
texImage->FetchTexelf = texImage->TexFormat->FetchTexel2Df;
break;
case 3:
texImage->FetchTexelc = texImage->TexFormat->FetchTexel3D;
texImage->FetchTexelf = texImage->TexFormat->FetchTexel3Df;
break;
default:
assert(0);
break;
}
_mesa_set_fetch_functions(texImage, dims);
if (texImage->TexFormat->TexelBytes == 0) {
/* must be a compressed format */
@@ -632,6 +614,7 @@ intel_get_tex_image(GLcontext * ctx, GLenum target, GLint level,
intelImage->level,
&intelImage->base.RowStride,
intelImage->base.ImageOffsets);
intelImage->base.RowStride /= intelImage->mt->cpp;
}
else {
/* Otherwise, the image should actually be stored in

View File

@@ -29,7 +29,7 @@
* Keith Whitwell <keith@tungstengraphics.com>
*/
#include "shader/prog_parameter.h"
#include "brw_context.h"
#include "brw_aub.h"
#include "brw_util.h"

View File

@@ -115,6 +115,9 @@ static const GLubyte *intelGetString( GLcontext *ctx, GLenum name )
case PCI_CHIP_I946_GZ:
chipset = "Intel(R) 946GZ"; break;
break;
case PCI_CHIP_I965_GM:
chipset = "Intel(R) 965GM"; break;
break;
default:
chipset = "Unknown Intel Chipset"; break;
}

View File

@@ -384,6 +384,7 @@ extern int INTEL_DEBUG;
#define PCI_CHIP_I965_Q 0x2992
#define PCI_CHIP_I965_G_1 0x2982
#define PCI_CHIP_I946_GZ 0x2972
#define PCI_CHIP_I965_GM 0x2A02
/* ================================================================

View File

@@ -372,7 +372,6 @@ static const struct tnl_pipeline_stage *mga_pipeline[] = {
&_tnl_fog_coordinate_stage,
&_tnl_texgen_stage,
&_tnl_texture_transform_stage,
&_tnl_arb_vertex_program_stage,
&_tnl_vertex_program_stage,
/* REMOVE: point attenuation stage */
@@ -910,6 +909,7 @@ void mgaGetLock( mgaContextPtr mmesa, GLuint flags )
drmGetLock(mmesa->driFd, mmesa->hHWContext, flags);
DRI_VALIDATE_DRAWABLE_INFO( mmesa->driScreen, dPriv );
if (*(dPriv->pStamp) != mmesa->lastStamp) {
mmesa->lastStamp = *(dPriv->pStamp);
mmesa->SetupNewInputs |= VERT_BIT_POS;
@@ -920,7 +920,7 @@ void mgaGetLock( mgaContextPtr mmesa, GLuint flags )
mmesa->dirty |= MGA_UPLOAD_CONTEXT | MGA_UPLOAD_CLIPRECTS;
mmesa->sarea->dirty |= MGA_UPLOAD_CONTEXT;
mmesa->sarea->dirty |= MGA_UPLOAD_CONTEXT;
if (sarea->ctxOwner != me) {
mmesa->dirty |= (MGA_UPLOAD_CONTEXT | MGA_UPLOAD_TEX0 |

View File

@@ -52,8 +52,10 @@ static void
r128UpdatePageFlipping( r128ContextPtr rmesa )
{
rmesa->doPageFlip = rmesa->sarea->pfAllowPageFlip;
driFlipRenderbuffers(rmesa->glCtx->WinSysDrawBuffer,
rmesa->sarea->pfCurrentPage);
if (rmesa->glCtx->WinSysDrawBuffer) {
driFlipRenderbuffers(rmesa->glCtx->WinSysDrawBuffer,
rmesa->sarea->pfCurrentPage);
}
rmesa->new_state |= R128_NEW_WINDOW;
}

View File

@@ -605,9 +605,9 @@ static void r128RenderStart( GLcontext *ctx )
* build up a hardware vertex.
*/
if (RENDERINPUTS_TEST_RANGE( index_bitset, _TNL_FIRST_TEX, _TNL_LAST_TEX ))
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, R128_CCE_VC_FRMT_RHW, 16 );
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_4F_VIEWPORT, R128_CCE_VC_FRMT_RHW, 4 );
else
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F_VIEWPORT, 0, 12 );
EMIT_ATTR( _TNL_ATTRIB_POS, EMIT_3F_VIEWPORT, 0, 3 );
rmesa->coloroffset = offset;
#if MESA_LITTLE_ENDIAN

View File

@@ -192,7 +192,6 @@ static const struct tnl_pipeline_stage *r200_pipeline[] = {
&_tnl_texgen_stage,
&_tnl_texture_transform_stage,
&_tnl_point_attenuation_stage,
&_tnl_arb_vertex_program_stage,
&_tnl_vertex_program_stage,
/* Try again to go to tcl?
* - no good for asymmetric-twoside (do with multipass)

View File

@@ -53,8 +53,10 @@ static void
r200UpdatePageFlipping( r200ContextPtr rmesa )
{
rmesa->doPageFlip = rmesa->sarea->pfState;
driFlipRenderbuffers(rmesa->glCtx->WinSysDrawBuffer,
rmesa->sarea->pfCurrentPage);
if (rmesa->glCtx->WinSysDrawBuffer) {
driFlipRenderbuffers(rmesa->glCtx->WinSysDrawBuffer,
rmesa->sarea->pfCurrentPage);
}
}

View File

@@ -281,7 +281,11 @@ CHECK( vpu, vpu_count(atom->cmd) ? (1 + vpu_count(atom->cmd)*4) : 0 )
void r300InitCmdBuf(r300ContextPtr r300)
{
int size, mtu;
int has_tcl = 1;
if (!(r300->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL))
has_tcl = 0;
r300->hw.max_state_size = 2+2; /* reserve extra space for WAIT_IDLE and tex cache flush */
mtu = r300->radeon.glCtx->Const.MaxTextureUnits;
@@ -291,33 +295,37 @@ void r300InitCmdBuf(r300ContextPtr r300)
/* Initialize state atoms */
ALLOC_STATE( vpt, always, R300_VPT_CMDSIZE, "vpt", 0 );
r300->hw.vpt.cmd[R300_VPT_CMD_0] = cmdpacket0(R300_SE_VPORT_XSCALE, 6);
r300->hw.vpt.cmd[R300_VPT_CMD_0] = cmdpacket0(R300_SE_VPORT_XSCALE, 6);
ALLOC_STATE( vap_cntl, always, 2, "vap_cntl", 0 );
r300->hw.vap_cntl.cmd[0] = cmdpacket0(R300_VAP_CNTL, 1);
r300->hw.vap_cntl.cmd[0] = cmdpacket0(R300_VAP_CNTL, 1);
ALLOC_STATE( vte, always, 3, "vte", 0 );
r300->hw.vte.cmd[0] = cmdpacket0(R300_SE_VTE_CNTL, 2);
r300->hw.vte.cmd[0] = cmdpacket0(R300_SE_VTE_CNTL, 2);
ALLOC_STATE( unk2134, always, 3, "unk2134", 0 );
r300->hw.unk2134.cmd[0] = cmdpacket0(0x2134, 2);
r300->hw.unk2134.cmd[0] = cmdpacket0(0x2134, 2);
ALLOC_STATE( vap_cntl_status, always, 2, "vap_cntl_status", 0 );
r300->hw.vap_cntl_status.cmd[0] = cmdpacket0(R300_VAP_CNTL_STATUS, 1);
r300->hw.vap_cntl_status.cmd[0] = cmdpacket0(R300_VAP_CNTL_STATUS, 1);
ALLOC_STATE( vir[0], variable, R300_VIR_CMDSIZE, "vir/0", 0 );
r300->hw.vir[0].cmd[R300_VIR_CMD_0] = cmdpacket0(R300_VAP_INPUT_ROUTE_0_0, 1);
r300->hw.vir[0].cmd[R300_VIR_CMD_0] = cmdpacket0(R300_VAP_INPUT_ROUTE_0_0, 1);
ALLOC_STATE( vir[1], variable, R300_VIR_CMDSIZE, "vir/1", 1 );
r300->hw.vir[1].cmd[R300_VIR_CMD_0] = cmdpacket0(R300_VAP_INPUT_ROUTE_1_0, 1);
r300->hw.vir[1].cmd[R300_VIR_CMD_0] = cmdpacket0(R300_VAP_INPUT_ROUTE_1_0, 1);
ALLOC_STATE( vic, always, R300_VIC_CMDSIZE, "vic", 0 );
r300->hw.vic.cmd[R300_VIC_CMD_0] = cmdpacket0(R300_VAP_INPUT_CNTL_0, 2);
r300->hw.vic.cmd[R300_VIC_CMD_0] = cmdpacket0(R300_VAP_INPUT_CNTL_0, 2);
ALLOC_STATE( unk21DC, always, 2, "unk21DC", 0 );
r300->hw.unk21DC.cmd[0] = cmdpacket0(0x21DC, 1);
r300->hw.unk21DC.cmd[0] = cmdpacket0(0x21DC, 1);
ALLOC_STATE( unk221C, always, 2, "unk221C", 0 );
r300->hw.unk221C.cmd[0] = cmdpacket0(R300_VAP_UNKNOWN_221C, 1);
r300->hw.unk221C.cmd[0] = cmdpacket0(R300_VAP_UNKNOWN_221C, 1);
ALLOC_STATE( unk2220, always, 5, "unk2220", 0 );
r300->hw.unk2220.cmd[0] = cmdpacket0(0x2220, 4);
r300->hw.unk2220.cmd[0] = cmdpacket0(0x2220, 4);
ALLOC_STATE( unk2288, always, 2, "unk2288", 0 );
r300->hw.unk2288.cmd[0] = cmdpacket0(R300_VAP_UNKNOWN_2288, 1);
r300->hw.unk2288.cmd[0] = cmdpacket0(R300_VAP_UNKNOWN_2288, 1);
ALLOC_STATE( vof, always, R300_VOF_CMDSIZE, "vof", 0 );
r300->hw.vof.cmd[R300_VOF_CMD_0] = cmdpacket0(R300_VAP_OUTPUT_VTX_FMT_0, 2);
ALLOC_STATE( pvs, always, R300_PVS_CMDSIZE, "pvs", 0 );
r300->hw.pvs.cmd[R300_PVS_CMD_0] = cmdpacket0(R300_VAP_PVS_CNTL_1, 3);
r300->hw.vof.cmd[R300_VOF_CMD_0] = cmdpacket0(R300_VAP_OUTPUT_VTX_FMT_0, 2);
if (has_tcl) {
ALLOC_STATE( pvs, always, R300_PVS_CMDSIZE, "pvs", 0 );
r300->hw.pvs.cmd[R300_PVS_CMD_0] = cmdpacket0(R300_VAP_PVS_CNTL_1, 3);
}
ALLOC_STATE( gb_enable, always, 2, "gb_enable", 0 );
r300->hw.gb_enable.cmd[0] = cmdpacket0(R300_GB_ENABLE, 1);
ALLOC_STATE( gb_misc, always, R300_GB_MISC_CMDSIZE, "gb_misc", 0 );
@@ -407,51 +415,54 @@ void r300InitCmdBuf(r300ContextPtr r300)
ALLOC_STATE( zs, always, R300_ZS_CMDSIZE, "zstencil", 0 );
r300->hw.zs.cmd[R300_ZS_CMD_0] = cmdpacket0(R300_RB3D_ZSTENCIL_CNTL_0, 3);
ALLOC_STATE( zstencil_format, always, 5, "zstencil_format", 0 );
r300->hw.zstencil_format.cmd[0] = cmdpacket0(R300_RB3D_ZSTENCIL_FORMAT, 4);
r300->hw.zstencil_format.cmd[0] = cmdpacket0(R300_RB3D_ZSTENCIL_FORMAT, 4);
ALLOC_STATE( zb, always, R300_ZB_CMDSIZE, "zb", 0 );
r300->hw.zb.cmd[R300_ZB_CMD_0] = cmdpacket0(R300_RB3D_DEPTHOFFSET, 2);
r300->hw.zb.cmd[R300_ZB_CMD_0] = cmdpacket0(R300_RB3D_DEPTHOFFSET, 2);
ALLOC_STATE( unk4F28, always, 2, "unk4F28", 0 );
r300->hw.unk4F28.cmd[0] = cmdpacket0(0x4F28, 1);
r300->hw.unk4F28.cmd[0] = cmdpacket0(0x4F28, 1);
ALLOC_STATE( unk4F30, always, 3, "unk4F30", 0 );
r300->hw.unk4F30.cmd[0] = cmdpacket0(0x4F30, 2);
r300->hw.unk4F30.cmd[0] = cmdpacket0(0x4F30, 2);
ALLOC_STATE( unk4F44, always, 2, "unk4F44", 0 );
r300->hw.unk4F44.cmd[0] = cmdpacket0(0x4F44, 1);
r300->hw.unk4F44.cmd[0] = cmdpacket0(0x4F44, 1);
ALLOC_STATE( unk4F54, always, 2, "unk4F54", 0 );
r300->hw.unk4F54.cmd[0] = cmdpacket0(0x4F54, 1);
r300->hw.unk4F54.cmd[0] = cmdpacket0(0x4F54, 1);
ALLOC_STATE( vpi, vpu, R300_VPI_CMDSIZE, "vpi", 0 );
r300->hw.vpi.cmd[R300_VPI_CMD_0] = cmdvpu(R300_PVS_UPLOAD_PROGRAM, 0);
ALLOC_STATE( vpp, vpu, R300_VPP_CMDSIZE, "vpp", 0 );
r300->hw.vpp.cmd[R300_VPP_CMD_0] = cmdvpu(R300_PVS_UPLOAD_PARAMETERS, 0);
ALLOC_STATE( vps, vpu, R300_VPS_CMDSIZE, "vps", 0 );
r300->hw.vps.cmd[R300_VPS_CMD_0] = cmdvpu(R300_PVS_UPLOAD_POINTSIZE, 1);
/* VPU only on TCL */
if (has_tcl) {
ALLOC_STATE( vpi, vpu, R300_VPI_CMDSIZE, "vpi", 0 );
r300->hw.vpi.cmd[R300_VPI_CMD_0] = cmdvpu(R300_PVS_UPLOAD_PROGRAM, 0);
ALLOC_STATE( vpp, vpu, R300_VPP_CMDSIZE, "vpp", 0 );
r300->hw.vpp.cmd[R300_VPP_CMD_0] = cmdvpu(R300_PVS_UPLOAD_PARAMETERS, 0);
ALLOC_STATE( vps, vpu, R300_VPS_CMDSIZE, "vps", 0 );
r300->hw.vps.cmd[R300_VPS_CMD_0] = cmdvpu(R300_PVS_UPLOAD_POINTSIZE, 1);
}
/* Textures */
ALLOC_STATE( tex.filter, variable, mtu+1, "tex_filter", 0 );
r300->hw.tex.filter.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_FILTER_0, 0);
r300->hw.tex.filter.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_FILTER_0, 0);
ALLOC_STATE( tex.filter_1, variable, mtu+1, "tex_filter_1", 0 );
r300->hw.tex.filter_1.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_FILTER1_0, 0);
r300->hw.tex.filter_1.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_FILTER1_0, 0);
ALLOC_STATE( tex.size, variable, mtu+1, "tex_size", 0 );
r300->hw.tex.size.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_SIZE_0, 0);
r300->hw.tex.size.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_SIZE_0, 0);
ALLOC_STATE( tex.format, variable, mtu+1, "tex_format", 0 );
r300->hw.tex.format.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_FORMAT_0, 0);
r300->hw.tex.format.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_FORMAT_0, 0);
ALLOC_STATE( tex.pitch, variable, mtu+1, "tex_pitch", 0 );
r300->hw.tex.pitch.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_PITCH_0, 0);
r300->hw.tex.pitch.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_PITCH_0, 0);
ALLOC_STATE( tex.offset, variable, mtu+1, "tex_offset", 0 );
r300->hw.tex.offset.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_OFFSET_0, 0);
r300->hw.tex.offset.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_OFFSET_0, 0);
ALLOC_STATE( tex.chroma_key, variable, mtu+1, "tex_chroma_key", 0 );
r300->hw.tex.chroma_key.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_CHROMA_KEY_0, 0);
r300->hw.tex.chroma_key.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_CHROMA_KEY_0, 0);
ALLOC_STATE( tex.border_color, variable, mtu+1, "tex_border_color", 0 );
r300->hw.tex.border_color.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_BORDER_COLOR_0, 0);
r300->hw.tex.border_color.cmd[R300_TEX_CMD_0] = cmdpacket0(R300_TX_BORDER_COLOR_0, 0);
/* Setup the atom linked list */
make_empty_list(&r300->hw.atomlist);
r300->hw.atomlist.name = "atom-list";
@@ -469,7 +480,9 @@ void r300InitCmdBuf(r300ContextPtr r300)
insert_at_tail(&r300->hw.atomlist, &r300->hw.unk2220);
insert_at_tail(&r300->hw.atomlist, &r300->hw.unk2288);
insert_at_tail(&r300->hw.atomlist, &r300->hw.vof);
insert_at_tail(&r300->hw.atomlist, &r300->hw.pvs);
if (has_tcl)
insert_at_tail(&r300->hw.atomlist, &r300->hw.pvs);
insert_at_tail(&r300->hw.atomlist, &r300->hw.gb_enable);
insert_at_tail(&r300->hw.atomlist, &r300->hw.gb_misc);
insert_at_tail(&r300->hw.atomlist, &r300->hw.txe);
@@ -520,9 +533,11 @@ void r300InitCmdBuf(r300ContextPtr r300)
insert_at_tail(&r300->hw.atomlist, &r300->hw.unk4F44);
insert_at_tail(&r300->hw.atomlist, &r300->hw.unk4F54);
insert_at_tail(&r300->hw.atomlist, &r300->hw.vpi);
insert_at_tail(&r300->hw.atomlist, &r300->hw.vpp);
insert_at_tail(&r300->hw.atomlist, &r300->hw.vps);
if (has_tcl) {
insert_at_tail(&r300->hw.atomlist, &r300->hw.vpi);
insert_at_tail(&r300->hw.atomlist, &r300->hw.vpp);
insert_at_tail(&r300->hw.atomlist, &r300->hw.vps);
}
insert_at_tail(&r300->hw.atomlist, &r300->hw.tex.filter);
insert_at_tail(&r300->hw.atomlist, &r300->hw.tex.filter_1);

View File

@@ -108,6 +108,7 @@ const struct dri_extension card_extensions[] = {
// {"GL_EXT_fog_coord", GL_EXT_fog_coord_functions },
{"GL_EXT_gpu_program_parameters", GL_EXT_gpu_program_parameters_functions},
{"GL_EXT_secondary_color", GL_EXT_secondary_color_functions},
{"GL_EXT_stencil_two_side", GL_EXT_stencil_two_side_functions},
{"GL_EXT_stencil_wrap", NULL},
{"GL_EXT_texture_edge_clamp", NULL},
{"GL_EXT_texture_env_combine", NULL},
@@ -127,10 +128,6 @@ const struct dri_extension card_extensions[] = {
{NULL, NULL}
};
const struct dri_extension stencil_two_side[] = {
{"GL_EXT_stencil_two_side", GL_EXT_stencil_two_side_functions},
};
extern struct tnl_pipeline_stage _r300_render_stage;
extern const struct tnl_pipeline_stage _r300_tcl_stage;
@@ -148,7 +145,6 @@ static const struct tnl_pipeline_stage *r300_pipeline[] = {
&_tnl_fog_coordinate_stage,
&_tnl_texgen_stage,
&_tnl_texture_transform_stage,
&_tnl_arb_vertex_program_stage,
&_tnl_vertex_program_stage,
/* Try again to go to tcl?
@@ -335,8 +331,8 @@ GLboolean r300CreateContext(const __GLcontextModes * glVisual,
driInitExtensions(ctx, card_extensions, GL_TRUE);
if (driQueryOptionb(&r300->radeon.optionCache, "disable_stencil_two_side") == 0)
driInitSingleExtension(ctx, stencil_two_side);
if (driQueryOptionb(&r300->radeon.optionCache, "disable_stencil_two_side"))
_mesa_disable_extension(ctx, "GL_EXT_stencil_two_side");
if (r300->radeon.glCtx->Mesa_DXTn && !driQueryOptionb (&r300->radeon.optionCache, "disable_s3tc")) {
_mesa_enable_extension( ctx, "GL_EXT_texture_compression_s3tc" );

View File

@@ -162,7 +162,7 @@ static __inline__ uint32_t cmdpacify(void)
cmd_written, cmd_reserved); \
exit(-1); \
} \
} while(0);
} while(0)
#define efloat(f) e32(r300PackFloat32(f))

View File

@@ -949,7 +949,9 @@ static void emit_tex(struct r300_fragment_program *rp,
* \todo Refactor this once we have proper rewriting/optimization
* support for programs.
*/
GLint tokens[6] = { STATE_INTERNAL, STATE_R300_TEXRECT_FACTOR, 0, 0, 0, 0 };
gl_state_index tokens[STATE_LENGTH] = {
STATE_INTERNAL, STATE_R300_TEXRECT_FACTOR, 0, 0, 0
};
int factor_index;
GLuint factorreg;
@@ -2053,7 +2055,9 @@ static GLboolean parse_program(struct r300_fragment_program *rp)
static void insert_wpos(struct gl_program *prog)
{
GLint tokens[6] = { STATE_INTERNAL, STATE_R300_WINDOW_DIMENSION, 0, 0, 0, 0 };
static gl_state_index tokens[STATE_LENGTH] = {
STATE_INTERNAL, STATE_R300_WINDOW_DIMENSION, 0, 0, 0
};
struct prog_instruction *fpi;
GLuint window_index;
int i = 0;

View File

@@ -179,11 +179,17 @@ static void r300EmitClearState(GLcontext * ctx)
int cmd_reserved = 0;
int cmd_written = 0;
drm_radeon_cmd_header_t *cmd = NULL;
int has_tcl = 1;
if (!(r300->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL))
has_tcl = 0;
R300_STATECHANGE(r300, vir[0]);
reg_start(R300_VAP_INPUT_ROUTE_0_0, 0);
e32(0x21030003);
if (!has_tcl)
e32(0x22030003);
else
e32(0x21030003);
/* disable fog */
R300_STATECHANGE(r300, fogs);
@@ -198,7 +204,17 @@ static void r300EmitClearState(GLcontext * ctx)
reg_start(R300_VAP_INPUT_CNTL_0, 1);
e32(0x00000001);
e32(0x00000405);
if (!has_tcl) {
/* comes from fglrx startup of clear */
reg_start(R300_SE_VTE_CNTL, 1);
e32(0x043f);
e32(0x8);
reg_start(0x21dc, 0);
e32(0xaaaaaaaa);
}
R300_STATECHANGE(r300, vof);
reg_start(R300_VAP_OUTPUT_VTX_FMT_0, 1);
e32(R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT | R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT);
@@ -279,26 +295,28 @@ static void r300EmitClearState(GLcontext * ctx)
reg_start(R300_PFS_INSTR3_0, 0);
e32(FP_SELA(0,NO,W,FP_TMP(0),0,0));
if (has_tcl) {
R300_STATECHANGE(r300, pvs);
reg_start(R300_VAP_PVS_CNTL_1, 2);
e32((0 << R300_PVS_CNTL_1_PROGRAM_START_SHIFT) |
(0 << R300_PVS_CNTL_1_POS_END_SHIFT) |
(1 << R300_PVS_CNTL_1_PROGRAM_END_SHIFT));
e32(0);
e32(1 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT);
R300_STATECHANGE(r300, vpi);
vsf_start_fragment(0x0, 8);
e32(VP_OUT(ADD,OUT,0,XYZW));
e32(VP_IN(IN,0));
e32(VP_ZERO());
e32(0);
R300_STATECHANGE(r300, pvs);
reg_start(R300_VAP_PVS_CNTL_1, 2);
e32((0 << R300_PVS_CNTL_1_PROGRAM_START_SHIFT) |
(0 << R300_PVS_CNTL_1_POS_END_SHIFT) |
(1 << R300_PVS_CNTL_1_PROGRAM_END_SHIFT));
e32(0);
e32(1 << R300_PVS_CNTL_3_PROGRAM_UNKNOWN_SHIFT);
R300_STATECHANGE(r300, vpi);
vsf_start_fragment(0x0, 8);
e32(VP_OUT(ADD,OUT,0,XYZW));
e32(VP_IN(IN,0));
e32(VP_ZERO());
e32(0);
e32(VP_OUT(ADD,OUT,1,XYZW));
e32(VP_IN(IN,1));
e32(VP_ZERO());
e32(0);
e32(VP_OUT(ADD,OUT,1,XYZW));
e32(VP_IN(IN,1));
e32(VP_ZERO());
e32(0);
}
/*reg_start(0x4500,0);
e32(2560-1);*/

View File

@@ -145,6 +145,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
# define R300_VC_NO_SWAP (0 << 0)
# define R300_VC_16BIT_SWAP (1 << 0)
# define R300_VC_32BIT_SWAP (2 << 0)
# define R300_VAP_TCL_BYPASS (1 << 8)
/* gap */

View File

@@ -388,7 +388,6 @@ int r300Fallback(GLcontext *ctx)
struct r300_fragment_program *rp =
(struct r300_fragment_program *)
(char *)ctx->FragmentProgram._Current;
int i;
if (rp) {
if (!rp->translated)

View File

@@ -1660,18 +1660,7 @@ void r300SetupVertexShader(r300ContextPtr rmesa)
return ;
}
/* This needs to be replaced by vertex shader generation code */
#if 0
/* textures enabled ? */
if(rmesa->state.texture.tc_count>0){
rmesa->state.vertex_shader=SINGLE_TEXTURE_VERTEX_SHADER;
} else {
rmesa->state.vertex_shader=FLAT_COLOR_VERTEX_SHADER;
}
#endif
/* This needs to be replaced by vertex shader generation code */
r300GenerateSimpleVertexShader(rmesa);
rmesa->state.vertex_shader.matrix[0].length=16;
@@ -1805,7 +1794,8 @@ void r300UpdateShaderStates(r300ContextPtr rmesa)
r300SetupPixelShader(rmesa);
r300_setup_textures(ctx);
r300SetupVertexShader(rmesa);
if ((rmesa->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL))
r300SetupVertexShader(rmesa);
r300_setup_rs_unit(ctx);
}
@@ -1938,6 +1928,10 @@ static void r300InvalidateState(GLcontext * ctx, GLuint new_state)
void r300ResetHwState(r300ContextPtr r300)
{
GLcontext* ctx = r300->radeon.glCtx;
int has_tcl = 1;
if (!(r300->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL))
has_tcl = 0;
if (RADEON_DEBUG & DEBUG_STATE)
fprintf(stderr, "%s\n", __FUNCTION__);
@@ -2005,8 +1999,10 @@ void r300ResetHwState(r300ContextPtr r300)
/* Initialize magic registers
TODO : learn what they really do, or get rid of
those we don't have to touch */
r300->hw.vap_cntl.cmd[1] = 0x0030045A; //0x0030065a /* Dangerous */
if (!has_tcl)
r300->hw.vap_cntl.cmd[1] = 0x0014045a;
else
r300->hw.vap_cntl.cmd[1] = 0x0030045A; //0x0030065a /* Dangerous */
r300->hw.vte.cmd[1] = R300_VPORT_X_SCALE_ENA
| R300_VPORT_X_OFFSET_ENA
| R300_VPORT_Y_SCALE_ENA
@@ -2023,6 +2019,10 @@ void r300ResetHwState(r300ContextPtr r300)
else
r300->hw.vap_cntl_status.cmd[1] = 0x00000002;
/* disable VAP/TCL on non-TCL capable chips */
if (!has_tcl)
r300->hw.vap_cntl_status.cmd[1] |= R300_VAP_TCL_BYPASS;
#if 0 /* Done in setup routing */
((drm_r300_cmd_header_t*)r300->hw.vir[0].cmd)->packet0.count = 1;
r300->hw.vir[0].cmd[1] = 0x21030003;
@@ -2266,10 +2266,12 @@ void r300ResetHwState(r300ContextPtr r300)
r300->hw.vpp.cmd[i] = 0;
#endif
r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
if (has_tcl) {
r300->hw.vps.cmd[R300_VPS_ZERO_0] = 0;
r300->hw.vps.cmd[R300_VPS_ZERO_1] = 0;
r300->hw.vps.cmd[R300_VPS_POINTSIZE] = r300PackFloat32(1.0);
r300->hw.vps.cmd[R300_VPS_ZERO_3] = 0;
}
//END: TODO
r300->hw.all_dirty = GL_TRUE;

View File

@@ -53,7 +53,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
WRITEMASK_W != VSF_FLAG_W
#error Cannot change these!
#endif
#define SCALAR_FLAG (1<<31)
#define FLAG_MASK (1<<31)
#define OP_MASK (0xf) /* we are unlikely to have more than 15 */
@@ -96,17 +96,17 @@ static struct{
OPN(END, 0),
};
#undef OPN
int r300VertexProgUpdateParams(GLcontext *ctx, struct r300_vertex_program_cont *vp, float *dst)
{
int pi;
struct gl_vertex_program *mesa_vp = &vp->mesa_program;
float *dst_o=dst;
struct gl_program_parameter_list *paramList;
if (mesa_vp->IsNVProgram) {
_mesa_load_tracked_matrices(ctx);
for (pi=0; pi < MAX_NV_VERTEX_PROGRAM_PARAMS; pi++) {
*dst++=ctx->VertexProgram.Parameters[pi][0];
*dst++=ctx->VertexProgram.Parameters[pi][1];
@@ -115,19 +115,19 @@ int r300VertexProgUpdateParams(GLcontext *ctx, struct r300_vertex_program_cont *
}
return dst - dst_o;
}
assert(mesa_vp->Base.Parameters);
_mesa_load_state_parameters(ctx, mesa_vp->Base.Parameters);
if(mesa_vp->Base.Parameters->NumParameters * 4 > VSF_MAX_FRAGMENT_LENGTH){
fprintf(stderr, "%s:Params exhausted\n", __FUNCTION__);
exit(-1);
}
paramList = mesa_vp->Base.Parameters;
for(pi=0; pi < paramList->NumParameters; pi++){
switch(paramList->Parameters[pi].Type){
case PROGRAM_STATE_VAR:
case PROGRAM_NAMED_PARAM:
//fprintf(stderr, "%s", vp->Parameters->Parameters[pi].Name);
@@ -137,15 +137,15 @@ int r300VertexProgUpdateParams(GLcontext *ctx, struct r300_vertex_program_cont *
*dst++=paramList->ParameterValues[pi][2];
*dst++=paramList->ParameterValues[pi][3];
break;
default: _mesa_problem(NULL, "Bad param type in %s", __FUNCTION__);
}
}
return dst - dst_o;
}
static unsigned long t_dst_mask(GLuint mask)
{
/* WRITEMASK_* is equivalent to VSF_FLAG_* */
@@ -154,7 +154,7 @@ static unsigned long t_dst_mask(GLuint mask)
static unsigned long t_dst_class(enum register_file file)
{
switch(file){
case PROGRAM_TEMPORARY:
return VSF_OUT_CLASS_TMP;
@@ -162,7 +162,7 @@ static unsigned long t_dst_class(enum register_file file)
return VSF_OUT_CLASS_RESULT;
case PROGRAM_ADDRESS:
return VSF_OUT_CLASS_ADDR;
/*
/*
case PROGRAM_INPUT:
case PROGRAM_LOCAL_PARAM:
case PROGRAM_ENV_PARAM:
@@ -187,20 +187,20 @@ static unsigned long t_dst_index(struct r300_vertex_program *vp, struct prog_dst
static unsigned long t_src_class(enum register_file file)
{
switch(file){
case PROGRAM_TEMPORARY:
return VSF_IN_CLASS_TMP;
case PROGRAM_INPUT:
return VSF_IN_CLASS_ATTR;
case PROGRAM_LOCAL_PARAM:
case PROGRAM_ENV_PARAM:
case PROGRAM_NAMED_PARAM:
case PROGRAM_STATE_VAR:
return VSF_IN_CLASS_PARAM;
/*
/*
case PROGRAM_OUTPUT:
case PROGRAM_WRITE_ONLY:
case PROGRAM_ADDRESS:
@@ -221,17 +221,17 @@ static __inline unsigned long t_swizzle(GLubyte swizzle)
static void vp_dump_inputs(struct r300_vertex_program *vp, char *caller)
{
int i;
if(vp == NULL){
fprintf(stderr, "vp null in call to %s from %s\n", __FUNCTION__, caller);
return ;
}
fprintf(stderr, "%s:<", caller);
for(i=0; i < VERT_ATTRIB_MAX; i++)
fprintf(stderr, "%d ", vp->inputs[i]);
fprintf(stderr, ">\n");
}
#endif
@@ -239,19 +239,19 @@ static unsigned long t_src_index(struct r300_vertex_program *vp, struct prog_src
{
int i;
int max_reg=-1;
if(src->File == PROGRAM_INPUT){
if(vp->inputs[src->Index] != -1)
return vp->inputs[src->Index];
for(i=0; i < VERT_ATTRIB_MAX; i++)
if(vp->inputs[i] > max_reg)
max_reg=vp->inputs[i];
vp->inputs[src->Index]=max_reg+1;
//vp_dump_inputs(vp, __FUNCTION__);
//vp_dump_inputs(vp, __FUNCTION__);
return vp->inputs[src->Index];
}else{
if (src->Index < 0) {
@@ -278,7 +278,7 @@ static unsigned long t_src(struct r300_vertex_program *vp, struct prog_src_regis
static unsigned long t_src_scalar(struct r300_vertex_program *vp, struct prog_src_register *src)
{
return MAKE_VSF_SOURCE(t_src_index(vp, src),
t_swizzle(GET_SWZ(src->Swizzle, 0)),
t_swizzle(GET_SWZ(src->Swizzle, 0)),
@@ -307,8 +307,8 @@ static unsigned long t_opcode(enum prog_opcode opcode)
case OPCODE_SGE: return R300_VPI_OUT_OP_SGE;
case OPCODE_SLT: return R300_VPI_OUT_OP_SLT;
case OPCODE_DP4: return R300_VPI_OUT_OP_DOT;
default:
default:
fprintf(stderr, "%s: Should not be called with opcode %d!", __FUNCTION__, opcode);
}
exit(-1);
@@ -318,12 +318,12 @@ static unsigned long t_opcode(enum prog_opcode opcode)
static unsigned long op_operands(enum prog_opcode opcode)
{
int i;
/* Can we trust mesas opcodes to be in order ? */
for(i=0; i < sizeof(op_names) / sizeof(*op_names); i++)
if(op_names[i].opcode == opcode)
return op_names[i].ip;
fprintf(stderr, "op %d not found in op_names\n", opcode);
exit(-1);
return 0;
@@ -331,13 +331,12 @@ static unsigned long op_operands(enum prog_opcode opcode)
static GLboolean valid_dst(struct r300_vertex_program *vp, struct prog_dst_register *dst)
{
if(dst->File == PROGRAM_OUTPUT && vp->outputs[dst->Index] == -1){
WARN_ONCE("Output %d not used by fragment program\n", dst->Index);
if(dst->File == PROGRAM_OUTPUT && vp->outputs[dst->Index] == -1) {
return GL_FALSE;
}else if(dst->File == PROGRAM_ADDRESS) {
} else if(dst->File == PROGRAM_ADDRESS) {
assert(dst->Index == 0);
}
return GL_TRUE;
}
@@ -347,12 +346,12 @@ static GLboolean valid_dst(struct r300_vertex_program *vp, struct prog_dst_regis
t_src_class(b.File) == VSF_IN_CLASS_PARAM) || \
(t_src_class(a.File) == VSF_IN_CLASS_ATTR && \
t_src_class(b.File) == VSF_IN_CLASS_ATTR)))) \
#define ZERO_SRC_0 (MAKE_VSF_SOURCE(t_src_index(vp, &src[0]), \
SWIZZLE_ZERO, SWIZZLE_ZERO, \
SWIZZLE_ZERO, SWIZZLE_ZERO, \
t_src_class(src[0].File), VSF_FLAG_NONE) | (src[0].RelAddr << 4))
#define ZERO_SRC_1 (MAKE_VSF_SOURCE(t_src_index(vp, &src[1]), \
SWIZZLE_ZERO, SWIZZLE_ZERO, \
SWIZZLE_ZERO, SWIZZLE_ZERO, \
@@ -362,12 +361,12 @@ static GLboolean valid_dst(struct r300_vertex_program *vp, struct prog_dst_regis
SWIZZLE_ZERO, SWIZZLE_ZERO, \
SWIZZLE_ZERO, SWIZZLE_ZERO, \
t_src_class(src[2].File), VSF_FLAG_NONE) | (src[2].RelAddr << 4))
#define ONE_SRC_0 (MAKE_VSF_SOURCE(t_src_index(vp, &src[0]), \
SWIZZLE_ONE, SWIZZLE_ONE, \
SWIZZLE_ONE, SWIZZLE_ONE, \
t_src_class(src[0].File), VSF_FLAG_NONE) | (src[0].RelAddr << 4))
#define ONE_SRC_1 (MAKE_VSF_SOURCE(t_src_index(vp, &src[1]), \
SWIZZLE_ONE, SWIZZLE_ONE, \
SWIZZLE_ONE, SWIZZLE_ONE, \
@@ -377,7 +376,7 @@ static GLboolean valid_dst(struct r300_vertex_program *vp, struct prog_dst_regis
SWIZZLE_ONE, SWIZZLE_ONE, \
SWIZZLE_ONE, SWIZZLE_ONE, \
t_src_class(src[2].File), VSF_FLAG_NONE) | (src[2].RelAddr << 4))
/* DP4 version seems to trigger some hw peculiarity */
//#define PREFER_DP4
@@ -406,46 +405,46 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
vp->pos_end=0; /* Not supported yet */
vp->program.length=0;
/*vp->num_temporaries=mesa_vp->Base.NumTemporaries;*/
for(i=0; i < VERT_ATTRIB_MAX; i++)
vp->inputs[i] = -1;
for(i=0; i < VERT_RESULT_MAX; i++)
vp->outputs[i] = -1;
assert(vp->key.OutputsWritten & (1 << VERT_RESULT_HPOS));
/* Assign outputs */
if(vp->key.OutputsWritten & (1 << VERT_RESULT_HPOS))
vp->outputs[VERT_RESULT_HPOS] = cur_reg++;
if(vp->key.OutputsWritten & (1 << VERT_RESULT_PSIZ))
vp->outputs[VERT_RESULT_PSIZ] = cur_reg++;
if(vp->key.OutputsWritten & (1 << VERT_RESULT_COL0))
vp->outputs[VERT_RESULT_COL0] = cur_reg++;
if(vp->key.OutputsWritten & (1 << VERT_RESULT_COL1))
vp->outputs[VERT_RESULT_COL1] = cur_reg++;
#if 0 /* Not supported yet */
if(vp->key.OutputsWritten & (1 << VERT_RESULT_BFC0))
vp->outputs[VERT_RESULT_BFC0] = cur_reg++;
if(vp->key.OutputsWritten & (1 << VERT_RESULT_BFC1))
vp->outputs[VERT_RESULT_BFC1] = cur_reg++;
if(vp->key.OutputsWritten & (1 << VERT_RESULT_FOGC))
vp->outputs[VERT_RESULT_FOGC] = cur_reg++;
#endif
for(i=VERT_RESULT_TEX0; i <= VERT_RESULT_TEX7; i++)
if(vp->key.OutputsWritten & (1 << i))
vp->outputs[i] = cur_reg++;
vp->translated = GL_TRUE;
vp->native = GL_TRUE;
o_inst=vp->program.body.i;
for(; vpi->Opcode != OPCODE_END; vpi++, o_inst++){
FREE_TEMPS();
@@ -456,19 +455,19 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
vpi->DstReg.File = PROGRAM_TEMPORARY;
vpi->DstReg.Index = u_temp_i;
}
operands=op_operands(vpi->Opcode);
are_srcs_scalar=operands & SCALAR_FLAG;
operands &= OP_MASK;
for(i=0; i < operands; i++)
src[i]=vpi->SrcReg[i];
if(operands == 3){ /* TODO: scalars */
if( CMP_SRCS(src[1], src[2]) || CMP_SRCS(src[0], src[2]) ){
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_ADD, u_temp_i,
VSF_FLAG_ALL, VSF_OUT_CLASS_TMP);
o_inst->src1=MAKE_VSF_SOURCE(t_src_index(vp, &src[2]),
SWIZZLE_X, SWIZZLE_Y,
SWIZZLE_Z, SWIZZLE_W,
@@ -477,20 +476,20 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
o_inst->src2=ZERO_SRC_2;
o_inst->src3=ZERO_SRC_2;
o_inst++;
src[2].File=PROGRAM_TEMPORARY;
src[2].Index=u_temp_i;
src[2].RelAddr=0;
u_temp_i--;
}
}
if(operands >= 2){
if( CMP_SRCS(src[1], src[0]) ){
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_ADD, u_temp_i,
VSF_FLAG_ALL, VSF_OUT_CLASS_TMP);
o_inst->src1=MAKE_VSF_SOURCE(t_src_index(vp, &src[0]),
SWIZZLE_X, SWIZZLE_Y,
SWIZZLE_Z, SWIZZLE_W,
@@ -499,14 +498,14 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
o_inst->src2=ZERO_SRC_0;
o_inst->src3=ZERO_SRC_0;
o_inst++;
src[0].File=PROGRAM_TEMPORARY;
src[0].Index=u_temp_i;
src[0].RelAddr=0;
u_temp_i--;
}
}
/* These ops need special handling. */
switch(vpi->Opcode){
case OPCODE_POW:
@@ -516,8 +515,8 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
o_inst->src2=ZERO_SRC_0;
o_inst->src3=t_src_scalar(vp, &src[1]);
goto next;
case OPCODE_MOV://ADD RESULT 1.X Y Z W PARAM 0{} {X Y Z W} PARAM 0{} {ZERO ZERO ZERO ZERO}
case OPCODE_MOV://ADD RESULT 1.X Y Z W PARAM 0{} {X Y Z W} PARAM 0{} {ZERO ZERO ZERO ZERO}
case OPCODE_SWZ:
#if 1
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_ADD, t_dst_index(vp, &vpi->DstReg),
@@ -527,21 +526,21 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
o_inst->src3=ZERO_SRC_0;
#else
hw_op=(src[0].File == PROGRAM_TEMPORARY) ? R300_VPI_OUT_OP_MAD_2 : R300_VPI_OUT_OP_MAD;
o_inst->op=MAKE_VSF_OP(hw_op, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
o_inst->src1=t_src(vp, &src[0]);
o_inst->src2=ONE_SRC_0;
o_inst->src3=ZERO_SRC_0;
#endif
#endif
goto next;
case OPCODE_ADD:
#if 1
hw_op=(src[0].File == PROGRAM_TEMPORARY &&
src[1].File == PROGRAM_TEMPORARY) ? R300_VPI_OUT_OP_MAD_2 : R300_VPI_OUT_OP_MAD;
o_inst->op=MAKE_VSF_OP(hw_op, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
o_inst->src1=ONE_SRC_0;
@@ -553,26 +552,26 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
o_inst->src1=t_src(vp, &src[0]);
o_inst->src2=t_src(vp, &src[1]);
o_inst->src3=ZERO_SRC_1;
#endif
goto next;
case OPCODE_MAD:
hw_op=(src[0].File == PROGRAM_TEMPORARY &&
src[1].File == PROGRAM_TEMPORARY &&
src[2].File == PROGRAM_TEMPORARY) ? R300_VPI_OUT_OP_MAD_2 : R300_VPI_OUT_OP_MAD;
o_inst->op=MAKE_VSF_OP(hw_op, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
o_inst->src1=t_src(vp, &src[0]);
o_inst->src2=t_src(vp, &src[1]);
o_inst->src3=t_src(vp, &src[2]);
goto next;
case OPCODE_MUL: /* HW mul can take third arg but appears to have some other limitations. */
hw_op=(src[0].File == PROGRAM_TEMPORARY &&
src[1].File == PROGRAM_TEMPORARY) ? R300_VPI_OUT_OP_MAD_2 : R300_VPI_OUT_OP_MAD;
o_inst->op=MAKE_VSF_OP(hw_op, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
o_inst->src1=t_src(vp, &src[0]);
@@ -580,11 +579,11 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
o_inst->src3=ZERO_SRC_1;
goto next;
case OPCODE_DP3://DOT RESULT 1.X Y Z W PARAM 0{} {X Y Z ZERO} PARAM 0{} {X Y Z ZERO}
case OPCODE_DP3://DOT RESULT 1.X Y Z W PARAM 0{} {X Y Z ZERO} PARAM 0{} {X Y Z ZERO}
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_DOT, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
o_inst->src1=MAKE_VSF_SOURCE(t_src_index(vp, &src[0]),
t_swizzle(GET_SWZ(src[0].Swizzle, 0)),
t_swizzle(GET_SWZ(src[0].Swizzle, 1)),
@@ -592,7 +591,7 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
SWIZZLE_ZERO,
t_src_class(src[0].File),
src[0].NegateBase ? VSF_FLAG_XYZ : VSF_FLAG_NONE) | (src[0].RelAddr << 4);
o_inst->src2=MAKE_VSF_SOURCE(t_src_index(vp, &src[1]),
t_swizzle(GET_SWZ(src[1].Swizzle, 0)),
t_swizzle(GET_SWZ(src[1].Swizzle, 1)),
@@ -608,7 +607,7 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
#if 1
hw_op=(src[0].File == PROGRAM_TEMPORARY &&
src[1].File == PROGRAM_TEMPORARY) ? R300_VPI_OUT_OP_MAD_2 : R300_VPI_OUT_OP_MAD;
o_inst->op=MAKE_VSF_OP(hw_op, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
o_inst->src1=t_src(vp, &src[0]);
@@ -623,7 +622,7 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
#else
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_ADD, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
o_inst->src1=t_src(vp, &src[0]);
o_inst->src2=MAKE_VSF_SOURCE(t_src_index(vp, &src[1]),
t_swizzle(GET_SWZ(src[1].Swizzle, 0)),
@@ -635,11 +634,11 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
o_inst->src3=0;
#endif
goto next;
case OPCODE_ABS://MAX RESULT 1.X Y Z W PARAM 0{} {X Y Z W} PARAM 0{X Y Z W } {X Y Z W} neg Xneg Yneg Zneg W
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_MAX, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
o_inst->src1=t_src(vp, &src[0]);
o_inst->src2=MAKE_VSF_SOURCE(t_src_index(vp, &src[0]),
t_swizzle(GET_SWZ(src[0].Swizzle, 0)),
@@ -650,22 +649,22 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
(!src[0].NegateBase) ? VSF_FLAG_ALL : VSF_FLAG_NONE) | (src[0].RelAddr << 4);
o_inst->src3=0;
goto next;
case OPCODE_FLR:
/* FRC TMP 0.X Y Z W PARAM 0{} {X Y Z W}
/* FRC TMP 0.X Y Z W PARAM 0{} {X Y Z W}
ADD RESULT 1.X Y Z W PARAM 0{} {X Y Z W} TMP 0{X Y Z W } {X Y Z W} neg Xneg Yneg Zneg W */
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_FRC, u_temp_i,
t_dst_mask(vpi->DstReg.WriteMask), VSF_OUT_CLASS_TMP);
o_inst->src1=t_src(vp, &src[0]);
o_inst->src2=ZERO_SRC_0;
o_inst->src3=ZERO_SRC_0;
o_inst++;
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_ADD, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
o_inst->src1=t_src(vp, &src[0]);
o_inst->src2=MAKE_VSF_SOURCE(u_temp_i,
VSF_IN_COMPONENT_X,
@@ -679,11 +678,11 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
o_inst->src3=ZERO_SRC_0;
u_temp_i--;
goto next;
case OPCODE_LG2:// LG2 RESULT 1.X Y Z W PARAM 0{} {X X X X}
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_LG2, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
o_inst->src1=MAKE_VSF_SOURCE(t_src_index(vp, &src[0]),
t_swizzle(GET_SWZ(src[0].Swizzle, 0)),
t_swizzle(GET_SWZ(src[0].Swizzle, 0)),
@@ -694,8 +693,8 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
o_inst->src2=ZERO_SRC_0;
o_inst->src3=ZERO_SRC_0;
goto next;
case OPCODE_LIT://LIT TMP 1.Y Z TMP 1{} {X W Z Y} TMP 1{} {Y W Z X} TMP 1{} {Y X Z W}
case OPCODE_LIT://LIT TMP 1.Y Z TMP 1{} {X W Z Y} TMP 1{} {Y W Z X} TMP 1{} {Y X Z W}
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_LIT, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
/* NOTE: Users swizzling might not work. */
@@ -721,11 +720,11 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
t_src_class(src[0].File),
src[0].NegateBase ? VSF_FLAG_ALL : VSF_FLAG_NONE) | (src[0].RelAddr << 4);
goto next;
case OPCODE_DPH://DOT RESULT 1.X Y Z W PARAM 0{} {X Y Z ONE} PARAM 0{} {X Y Z W}
case OPCODE_DPH://DOT RESULT 1.X Y Z W PARAM 0{} {X Y Z ONE} PARAM 0{} {X Y Z W}
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_DOT, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
o_inst->src1=MAKE_VSF_SOURCE(t_src_index(vp, &src[0]),
t_swizzle(GET_SWZ(src[0].Swizzle, 0)),
t_swizzle(GET_SWZ(src[0].Swizzle, 1)),
@@ -736,16 +735,16 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
o_inst->src2=t_src(vp, &src[1]);
o_inst->src3=ZERO_SRC_1;
goto next;
case OPCODE_XPD:
/* mul r0, r1.yzxw, r2.zxyw
mad r0, -r2.yzxw, r1.zxyw, r0
NOTE: might need MAD_2
*/
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_MAD, u_temp_i,
t_dst_mask(vpi->DstReg.WriteMask), VSF_OUT_CLASS_TMP);
o_inst->src1=MAKE_VSF_SOURCE(t_src_index(vp, &src[0]),
t_swizzle(GET_SWZ(src[0].Swizzle, 1)), // y
t_swizzle(GET_SWZ(src[0].Swizzle, 2)), // z
@@ -753,7 +752,7 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
t_swizzle(GET_SWZ(src[0].Swizzle, 3)), // w
t_src_class(src[0].File),
src[0].NegateBase ? VSF_FLAG_ALL : VSF_FLAG_NONE) | (src[0].RelAddr << 4);
o_inst->src2=MAKE_VSF_SOURCE(t_src_index(vp, &src[1]),
t_swizzle(GET_SWZ(src[1].Swizzle, 2)), // z
t_swizzle(GET_SWZ(src[1].Swizzle, 0)), // x
@@ -761,14 +760,14 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
t_swizzle(GET_SWZ(src[1].Swizzle, 3)), // w
t_src_class(src[1].File),
src[1].NegateBase ? VSF_FLAG_ALL : VSF_FLAG_NONE) | (src[1].RelAddr << 4);
o_inst->src3=ZERO_SRC_1;
o_inst++;
u_temp_i--;
o_inst->op=MAKE_VSF_OP(R300_VPI_OUT_OP_MAD, t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
o_inst->src1=MAKE_VSF_SOURCE(t_src_index(vp, &src[1]),
t_swizzle(GET_SWZ(src[1].Swizzle, 1)), // y
t_swizzle(GET_SWZ(src[1].Swizzle, 2)), // z
@@ -776,7 +775,7 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
t_swizzle(GET_SWZ(src[1].Swizzle, 3)), // w
t_src_class(src[1].File),
(!src[1].NegateBase) ? VSF_FLAG_ALL : VSF_FLAG_NONE) | (src[1].RelAddr << 4);
o_inst->src2=MAKE_VSF_SOURCE(t_src_index(vp, &src[0]),
t_swizzle(GET_SWZ(src[0].Swizzle, 2)), // z
t_swizzle(GET_SWZ(src[0].Swizzle, 0)), // x
@@ -784,7 +783,7 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
t_swizzle(GET_SWZ(src[0].Swizzle, 3)), // w
t_src_class(src[0].File),
src[0].NegateBase ? VSF_FLAG_ALL : VSF_FLAG_NONE) | (src[0].RelAddr << 4);
o_inst->src3=MAKE_VSF_SOURCE(u_temp_i+1,
VSF_IN_COMPONENT_X,
VSF_IN_COMPONENT_Y,
@@ -792,7 +791,7 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
VSF_IN_COMPONENT_W,
VSF_IN_CLASS_TMP,
VSF_FLAG_NONE);
goto next;
case OPCODE_RCC:
@@ -804,10 +803,10 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
default:
break;
}
o_inst->op=MAKE_VSF_OP(t_opcode(vpi->Opcode), t_dst_index(vp, &vpi->DstReg),
t_dst_mask(vpi->DstReg.WriteMask), t_dst_class(vpi->DstReg.File));
if(are_srcs_scalar){
switch(operands){
case 1:
@@ -815,19 +814,19 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
o_inst->src2=ZERO_SRC_0;
o_inst->src3=ZERO_SRC_0;
break;
case 2:
o_inst->src1=t_src_scalar(vp, &src[0]);
o_inst->src2=t_src_scalar(vp, &src[1]);
o_inst->src3=ZERO_SRC_1;
break;
case 3:
o_inst->src1=t_src_scalar(vp, &src[0]);
o_inst->src2=t_src_scalar(vp, &src[1]);
o_inst->src3=t_src_scalar(vp, &src[2]);
break;
default:
fprintf(stderr, "scalars and op RCC not handled yet");
exit(-1);
@@ -840,19 +839,19 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
o_inst->src2=ZERO_SRC_0;
o_inst->src3=ZERO_SRC_0;
break;
case 2:
o_inst->src1=t_src(vp, &src[0]);
o_inst->src2=t_src(vp, &src[1]);
o_inst->src3=ZERO_SRC_1;
break;
case 3:
o_inst->src1=t_src(vp, &src[0]);
o_inst->src2=t_src(vp, &src[1]);
o_inst->src3=t_src(vp, &src[2]);
break;
default:
fprintf(stderr, "scalars and op RCC not handled yet");
exit(-1);
@@ -861,7 +860,7 @@ static void r300_translate_vertex_shader(struct r300_vertex_program *vp, struct
}
next: ;
}
/* Will most likely segfault before we get here... fix later. */
if(o_inst - vp->program.body.i >= VSF_MAX_FRAGMENT_LENGTH/4) {
vp->program.length = 0;
@@ -945,7 +944,7 @@ static void position_invariant(struct gl_program *prog)
vpi[i].SrcReg[2].Index = 0;
vpi[i].SrcReg[2].Swizzle = SWIZZLE_XYZW;
}
#endif
#endif
}
_mesa_copy_instructions (&vpi[i], prog->Instructions, prog->NumInstructions);
@@ -967,7 +966,7 @@ static void insert_wpos(struct r300_vertex_program *vp,
struct prog_instruction *vpi;
struct prog_instruction *vpi_insert;
int i = 0;
vpi = _mesa_alloc_instructions (prog->NumInstructions + 2);
_mesa_init_instructions (vpi, prog->NumInstructions + 2);
/* all but END */
@@ -1054,7 +1053,7 @@ static struct r300_vertex_program *build_program(struct r300_vertex_program_key
r300_translate_vertex_shader(vp, mesa_vp->Base.Instructions);
return vp;
return vp;
}
void r300_select_vertex_shader(r300ContextPtr r300)
@@ -1077,7 +1076,7 @@ void r300_select_vertex_shader(r300ContextPtr r300)
for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
if (!(InputsRead & (FRAG_BIT_TEX0 << i)))
break;
if(i == ctx->Const.MaxTextureUnits){
fprintf(stderr, "\tno free texcoord found\n");
exit(0);
@@ -1093,7 +1092,7 @@ void r300_select_vertex_shader(r300ContextPtr r300)
if ((InputsRead & FRAG_BIT_COL1) /*||
(InputsRead & FRAG_BIT_FOGC)*/)
wanted_key.OutputsWritten |= 1 << VERT_RESULT_COL1;
for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
if (InputsRead & (FRAG_BIT_TEX0 << i))
wanted_key.OutputsWritten |= 1 << (VERT_RESULT_TEX0 + i);

View File

@@ -55,8 +55,8 @@ static void radeonUpdatePageFlipping(radeonContextPtr radeon)
int use_back;
radeon->doPageFlip = radeon->sarea->pfState;
if (!radeon->doPageFlip) {
driFlipRenderbuffers(radeon->glCtx->WinSysDrawBuffer, GL_FALSE);
if (radeon->glCtx->WinSysDrawBuffer) {
driFlipRenderbuffers(radeon->glCtx->WinSysDrawBuffer, radeon->sarea->pfCurrentPage);
}
use_back = (radeon->glCtx->DrawBuffer->_ColorDrawBufferMask[0] == BUFFER_BIT_BACK_LEFT);

View File

@@ -56,8 +56,10 @@ static void
radeonUpdatePageFlipping( radeonContextPtr rmesa )
{
rmesa->doPageFlip = rmesa->sarea->pfState;
driFlipRenderbuffers(rmesa->glCtx->WinSysDrawBuffer,
rmesa->sarea->pfCurrentPage);
if (rmesa->glCtx->WinSysDrawBuffer) {
driFlipRenderbuffers(rmesa->glCtx->WinSysDrawBuffer,
rmesa->sarea->pfCurrentPage);
}
}

View File

@@ -656,7 +656,8 @@ radeonCreateScreen( __DRIscreenPrivate *sPriv )
case PCI_CHIP_RC410_5A61:
case PCI_CHIP_RC410_5A62:
screen->chip_family = CHIP_FAMILY_RS400;
fprintf(stderr, "Warning, xpress200 detected. Probably won't work.\n");
fprintf(stderr, "Warning, xpress200 detected. Won't work.\n");
return NULL;
break;
default:

View File

@@ -165,12 +165,6 @@ static const struct tnl_pipeline_stage *tdfx_pipeline[] = {
&_tnl_texgen_stage,
&_tnl_texture_transform_stage,
&_tnl_point_attenuation_stage,
#if 0
#if defined(FEATURE_NV_vertex_program) || defined(FEATURE_ARB_vertex_program)
&_tnl_arb_vertex_program_stage,
&_tnl_vertex_program_stage,
#endif
#endif
&_tnl_render_stage,
0,
};

View File

@@ -802,7 +802,6 @@ glFBDevDestroyContext( GLFBDevContextPtr context )
if (fbdevctx == context) {
/* destroying current context */
_mesa_make_current(NULL, NULL, NULL);
_mesa_notifyDestroy(&context->glcontext);
}
_mesa_free_context_data(&context->glcontext);
_mesa_free(context);

View File

@@ -1663,7 +1663,6 @@ static const struct tnl_pipeline_stage *fx_pipeline[] = {
&_tnl_texture_transform_stage,
&_tnl_point_attenuation_stage,
#if defined(FEATURE_NV_vertex_program) || defined(FEATURE_ARB_vertex_program)
&_tnl_arb_vertex_program_stage,
&_tnl_vertex_program_stage,
#endif
&_tnl_render_stage,

View File

@@ -1,8 +1,8 @@
/*
* Mesa 3-D graphics library
* Version: 6.5.1
* Version: 6.5.3
*
* Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
* Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
@@ -1041,6 +1041,7 @@ new_osmesa_renderbuffer(GLcontext *ctx, GLenum format, GLenum type)
const GLuint name = 0;
struct gl_renderbuffer *rb = _mesa_new_renderbuffer(ctx, name);
if (rb) {
rb->RefCount = 1;
rb->Delete = osmesa_delete_renderbuffer;
rb->AllocStorage = osmesa_renderbuffer_storage;
@@ -1237,6 +1238,7 @@ OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
/* create front color buffer in user-provided memory (no back buffer) */
osmesa->rb = new_osmesa_renderbuffer(&osmesa->mesa, format, type);
_mesa_add_renderbuffer(osmesa->gl_buffer, BUFFER_FRONT_LEFT, osmesa->rb);
assert(osmesa->rb->RefCount == 2);
_mesa_add_soft_renderbuffers(osmesa->gl_buffer,
GL_FALSE, /* color */
@@ -1297,6 +1299,9 @@ GLAPI void GLAPIENTRY
OSMesaDestroyContext( OSMesaContext osmesa )
{
if (osmesa) {
if (osmesa->rb)
_mesa_reference_renderbuffer(&osmesa->rb, NULL);
_swsetup_DestroyContext( &osmesa->mesa );
_tnl_DestroyContext( &osmesa->mesa );
_vbo_DestroyContext( &osmesa->mesa );
@@ -1570,6 +1575,7 @@ static struct name_function functions[] = {
{ "OSMesaGetDepthBuffer", (OSMESAproc) OSMesaGetDepthBuffer },
{ "OSMesaGetColorBuffer", (OSMESAproc) OSMesaGetColorBuffer },
{ "OSMesaGetProcAddress", (OSMESAproc) OSMesaGetProcAddress },
{ "OSMesaColorClamp", (OSMESAproc) OSMesaColorClamp },
{ NULL, NULL }
};

View File

@@ -1440,11 +1440,14 @@ Fake_glXMakeContextCurrent( Display *dpy, GLXDrawable draw,
}
if (!drawBuffer) {
/* drawable must be a new window! */
drawBuffer = XMesaCreateWindowBuffer2( xmctx->xm_visual, draw, xmctx);
drawBuffer = XMesaCreateWindowBuffer( xmctx->xm_visual, draw );
if (!drawBuffer) {
/* Out of memory, or context/drawable depth mismatch */
return False;
}
#ifdef FX
FXcreateContext( xmctx->xm_visual, draw, xmctx, drawBuffer );
#endif
}
/* Find the XMesaBuffer which corresponds to the GLXDrawable 'read' */
@@ -1457,12 +1460,14 @@ Fake_glXMakeContextCurrent( Display *dpy, GLXDrawable draw,
}
if (!readBuffer) {
/* drawable must be a new window! */
readBuffer = XMesaCreateWindowBuffer2(glxCtx->xmesaContext->xm_visual,
read, xmctx);
readBuffer = XMesaCreateWindowBuffer( xmctx->xm_visual, read );
if (!readBuffer) {
/* Out of memory, or context/drawable depth mismatch */
return False;
}
#ifdef FX
FXcreateContext( xmctx->xm_visual, read, xmctx, readBuffer );
#endif
}
MakeCurrent_PrevContext = ctx;
@@ -2107,10 +2112,15 @@ Fake_glXCreateWindow( Display *dpy, GLXFBConfig config, Window win,
if (!xmvis)
return 0;
xmbuf = XMesaCreateWindowBuffer2(xmvis, win, NULL);
xmbuf = XMesaCreateWindowBuffer(xmvis, win);
if (!xmbuf)
return 0;
#ifdef FX
/* XXX this will segfault if actually called */
FXcreateContext(xmvis, win, NULL, xmbuf);
#endif
(void) dpy;
(void) attribList; /* Ignored in GLX 1.3 */

View File

@@ -36,8 +36,6 @@
# include "resource.h"
# include "windowstr.h"
# include "gcstruct.h"
# include "xf86glx_util.h"
#else

View File

@@ -80,10 +80,6 @@
#include "tnl/t_pipeline.h"
#include "drivers/common/driverfuncs.h"
#ifdef XFree86Server
#include <GL/glxtokens.h>
#endif
/**
* Global X driver lock
*/
@@ -179,9 +175,7 @@ static int host_byte_order( void )
*/
static int check_for_xshm( XMesaDisplay *display )
{
#if defined(XFree86Server)
return 0;
#elif defined(USE_XSHM)
#if defined(USE_XSHM) && !defined(XFree86Server)
int major, minor, ignore;
Bool pixmaps;
@@ -976,42 +970,33 @@ setup_truecolor(XMesaVisual v, XMesaBuffer buffer, XMesaColormap cmap)
&& GET_BLUEMASK(v) ==0xff0000
&& CHECK_BYTE_ORDER(v)
&& v->BitsPerPixel==32
&& sizeof(GLuint)==4
&& v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
/* common 32 bpp config used on SGI, Sun */
v->undithered_pf = v->dithered_pf = PF_8A8B8G8R;
v->undithered_pf = v->dithered_pf = PF_8A8B8G8R; /* ABGR */
}
else if (GET_REDMASK(v) ==0xff0000
&& GET_GREENMASK(v)==0x00ff00
&& GET_BLUEMASK(v) ==0x0000ff
&& CHECK_BYTE_ORDER(v)
&& v->BitsPerPixel==32
&& sizeof(GLuint)==4
&& v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
/* common 32 bpp config used on Linux, HP, IBM */
if (GET_VISUAL_DEPTH(v)==32)
v->undithered_pf = v->dithered_pf = PF_8A8R8G8B;
else
v->undithered_pf = v->dithered_pf = PF_8R8G8B;
}
else if (GET_REDMASK(v) ==0xff0000
&& GET_GREENMASK(v)==0x00ff00
&& GET_BLUEMASK(v) ==0x0000ff
&& CHECK_BYTE_ORDER(v)
&& v->BitsPerPixel==24
&& sizeof(GLuint)==4
&& v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
/* common packed 24 bpp config used on Linux */
v->undithered_pf = v->dithered_pf = PF_8R8G8B24;
else if (GET_REDMASK(v) == 0xff0000
&& GET_GREENMASK(v)== 0x00ff00
&& GET_BLUEMASK(v) == 0x0000ff
&& CHECK_BYTE_ORDER(v)
&& v->RedGamma == 1.0 && v->GreenGamma == 1.0 && v->BlueGamma == 1.0){
if (v->BitsPerPixel==32) {
/* if 32 bpp, and visual indicates 8 bpp alpha channel */
if (GET_VISUAL_DEPTH(v) == 32 && v->mesa_visual.alphaBits == 8)
v->undithered_pf = v->dithered_pf = PF_8A8R8G8B; /* ARGB */
else
v->undithered_pf = v->dithered_pf = PF_8R8G8B; /* xRGB */
}
else if (v->BitsPerPixel == 24) {
v->undithered_pf = v->dithered_pf = PF_8R8G8B24; /* RGB */
}
}
else if (GET_REDMASK(v) ==0xf800
&& GET_GREENMASK(v)==0x07e0
&& GET_BLUEMASK(v) ==0x001f
&& CHECK_BYTE_ORDER(v)
&& v->BitsPerPixel==16
&& sizeof(GLushort)==2
&& v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
/* 5-6-5 color weight on common PC VGA boards */
/* 5-6-5 RGB */
v->undithered_pf = PF_5R6G5B;
v->dithered_pf = PF_Dither_5R6G5B;
}
@@ -1019,6 +1004,7 @@ setup_truecolor(XMesaVisual v, XMesaBuffer buffer, XMesaColormap cmap)
&& GET_GREENMASK(v)==0x1c
&& GET_BLUEMASK(v) ==0x03
&& CHECK_FOR_HPCR(v)) {
/* 8-bit HP color recovery */
setup_8bit_hpcr( v );
}
}
@@ -1050,10 +1036,16 @@ setup_monochrome( XMesaVisual v, XMesaBuffer b )
* \return GL_TRUE=success, GL_FALSE=failure
*/
static GLboolean
initialize_visual_and_buffer(int client, XMesaVisual v, XMesaBuffer b,
initialize_visual_and_buffer(XMesaVisual v, XMesaBuffer b,
GLboolean rgb_flag, XMesaDrawable window,
XMesaColormap cmap)
{
int client = 0;
#ifdef XFree86Server
client = (window) ? CLIENT_ID(window->id) : 0;
#endif
ASSERT(!b || b->xm_visual == v);
/* Save true bits/pixel */
@@ -1117,6 +1109,8 @@ initialize_visual_and_buffer(int client, XMesaVisual v, XMesaBuffer b,
}
if (b && window) {
char *data;
/* Do window-specific initializations */
/* these should have been set in create_xmesa_buffer */
@@ -1184,15 +1178,15 @@ initialize_visual_and_buffer(int client, XMesaVisual v, XMesaBuffer b,
}
/* Initialize the row buffer XImage for use in write_color_span() */
data = (char*) MALLOC(MAX_WIDTH*4);
#ifdef XFree86Server
b->rowimage = XMesaCreateImage(GET_VISUAL_DEPTH(v), MAX_WIDTH, 1,
(char *)MALLOC(MAX_WIDTH*4));
b->rowimage = XMesaCreateImage(GET_VISUAL_DEPTH(v), MAX_WIDTH, 1, data);
#else
b->rowimage = XCreateImage( v->display,
v->visinfo->visual,
v->visinfo->depth,
ZPixmap, 0, /*format, offset*/
(char*) MALLOC(MAX_WIDTH*4), /*data*/
data, /*data*/
MAX_WIDTH, 1, /*width, height*/
32, /*bitmap_pad*/
0 /*bytes_per_line*/ );
@@ -1322,6 +1316,7 @@ xmesa_convert_from_x_visual_type( int visualType )
* visualCaveat - ala the GLX extension, usually GLX_NONE
* Return; a new XMesaVisual or 0 if error.
*/
PUBLIC
XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
XMesaVisualInfo visinfo,
GLboolean rgb_flag,
@@ -1359,11 +1354,6 @@ XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
return NULL;
}
/*
* In the X server, NULL is passed in for the display. It will have
* to be set before using this visual. See XMesaSetVisualDisplay()
* below.
*/
v->display = display;
/* Save a copy of the XVisualInfo struct because the user may X_mesa_free()
@@ -1425,7 +1415,10 @@ XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
v->mesa_visual.visualRating = visualCaveat;
(void) initialize_visual_and_buffer( 0, v, NULL, rgb_flag, 0, 0 );
if (alpha_flag)
v->mesa_visual.alphaBits = 8;
(void) initialize_visual_and_buffer( v, NULL, rgb_flag, 0, 0 );
{
const int xclass = v->mesa_visual.visualType;
@@ -1433,7 +1426,6 @@ XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
red_bits = _mesa_bitcount(GET_REDMASK(v));
green_bits = _mesa_bitcount(GET_GREENMASK(v));
blue_bits = _mesa_bitcount(GET_BLUEMASK(v));
alpha_bits = 0;
}
else {
/* this is an approximation */
@@ -1447,11 +1439,9 @@ XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
alpha_bits = 0;
assert( red_bits + green_bits + blue_bits == GET_VISUAL_DEPTH(v) );
}
alpha_bits = v->mesa_visual.alphaBits;
}
if (alpha_flag && alpha_bits == 0)
alpha_bits = 8;
_mesa_initialize_visual( &v->mesa_visual,
rgb_flag, db_flag, stereo_flag,
red_bits, green_bits,
@@ -1469,12 +1459,7 @@ XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
}
void XMesaSetVisualDisplay( XMesaDisplay *dpy, XMesaVisual v )
{
v->display = dpy;
}
PUBLIC
void XMesaDestroyVisual( XMesaVisual v )
{
#ifndef XFree86Server
@@ -1492,6 +1477,7 @@ void XMesaDestroyVisual( XMesaVisual v )
* lists or NULL if no sharing is wanted.
* \return an XMesaContext or NULL if error.
*/
PUBLIC
XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list )
{
static GLboolean firstTime = GL_TRUE;
@@ -1575,15 +1561,15 @@ XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list )
PUBLIC
void XMesaDestroyContext( XMesaContext c )
{
GLcontext *mesaCtx = &c->mesa;
#ifdef FX
XMesaBuffer xmbuf = XMESA_BUFFER(mesaCtx->DrawBuffer);
if (xmbuf && xmbuf->FXctx)
fxMesaDestroyContext(xmbuf->FXctx);
#ifdef FX
FXdestroyContext( XMESA_BUFFER(mesaCtx->DrawBuffer) );
#endif
_swsetup_DestroyContext( mesaCtx );
_swrast_DestroyContext( mesaCtx );
_tnl_DestroyContext( mesaCtx );
@@ -1599,44 +1585,33 @@ void XMesaDestroyContext( XMesaContext c )
* X window or pixmap.
* \param v the window's XMesaVisual
* \param w the window we're wrapping
* \param c context used to initialize the buffer if 3Dfx mode in use.
* \return new XMesaBuffer or NULL if error
*/
XMesaBuffer
XMesaCreateWindowBuffer2(XMesaVisual v, XMesaWindow w, XMesaContext c)
PUBLIC XMesaBuffer
XMesaCreateWindowBuffer(XMesaVisual v, XMesaWindow w)
{
#ifndef XFree86Server
XWindowAttributes attr;
#endif
#ifdef FX
char *fxEnvVar;
#endif
int client = 0;
XMesaBuffer b;
XMesaColormap cmap;
int depth;
assert(v);
assert(w);
(void) c;
/* Check that window depth matches visual depth */
#ifdef XFree86Server
client = CLIENT_ID(((XMesaDrawable)w)->id);
if (GET_VISUAL_DEPTH(v) != ((XMesaDrawable)w)->depth) {
_mesa_warning(NULL, "XMesaCreateWindowBuffer: depth mismatch between visual (%d) and window (%d)!\n",
GET_VISUAL_DEPTH(v), ((XMesaDrawable) w)->depth);
return NULL;
}
depth = ((XMesaDrawable)w)->depth;
#else
XGetWindowAttributes( v->display, w, &attr );
if (GET_VISUAL_DEPTH(v) != attr.depth) {
depth = attr.depth;
#endif
if (GET_VISUAL_DEPTH(v) != depth) {
_mesa_warning(NULL, "XMesaCreateWindowBuffer: depth mismatch between visual (%d) and window (%d)!\n",
GET_VISUAL_DEPTH(v), attr.depth);
GET_VISUAL_DEPTH(v), depth);
return NULL;
}
#endif
/* Find colormap */
#ifdef XFree86Server
@@ -1657,101 +1632,16 @@ XMesaCreateWindowBuffer2(XMesaVisual v, XMesaWindow w, XMesaContext c)
if (!b)
return NULL;
if (!initialize_visual_and_buffer( client, v, b, v->mesa_visual.rgbMode,
if (!initialize_visual_and_buffer( v, b, v->mesa_visual.rgbMode,
(XMesaDrawable) w, cmap )) {
xmesa_free_buffer(b);
return NULL;
}
#ifdef FX
fxEnvVar = _mesa_getenv("MESA_GLX_FX");
if (fxEnvVar) {
if (fxEnvVar[0]!='d') {
int attribs[100];
int numAttribs = 0;
int hw;
if (v->mesa_visual.depthBits > 0) {
attribs[numAttribs++] = FXMESA_DEPTH_SIZE;
attribs[numAttribs++] = v->mesa_visual.depthBits;
}
if (v->mesa_visual.doubleBufferMode) {
attribs[numAttribs++] = FXMESA_DOUBLEBUFFER;
}
if (v->mesa_visual.accumRedBits > 0) {
attribs[numAttribs++] = FXMESA_ACCUM_SIZE;
attribs[numAttribs++] = v->mesa_visual.accumRedBits;
}
if (v->mesa_visual.stencilBits > 0) {
attribs[numAttribs++] = FXMESA_STENCIL_SIZE;
attribs[numAttribs++] = v->mesa_visual.stencilBits;
}
if (v->mesa_visual.alphaBits > 0) {
attribs[numAttribs++] = FXMESA_ALPHA_SIZE;
attribs[numAttribs++] = v->mesa_visual.alphaBits;
}
if (1) {
attribs[numAttribs++] = FXMESA_SHARE_CONTEXT;
attribs[numAttribs++] = (int) &(c->mesa);
}
attribs[numAttribs++] = FXMESA_NONE;
/* [dBorca] we should take an envvar for `fxMesaSelectCurrentBoard'!!! */
hw = fxMesaSelectCurrentBoard(0);
/* if these fail, there's a new bug somewhere */
ASSERT(b->mesa_buffer.Width > 0);
ASSERT(b->mesa_buffer.Height > 0);
if ((hw == GR_SSTTYPE_VOODOO) || (hw == GR_SSTTYPE_Voodoo2)) {
b->FXctx = fxMesaCreateBestContext(0, b->mesa_buffer.Width,
b->mesa_buffer.Height, attribs);
if ((v->undithered_pf!=PF_Index) && (b->backxrb->ximage)) {
b->FXisHackUsable = b->FXctx ? GL_TRUE : GL_FALSE;
if (b->FXctx && (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')) {
b->FXwindowHack = GL_TRUE;
FX_grSstControl(GR_CONTROL_DEACTIVATE);
}
else {
b->FXwindowHack = GL_FALSE;
}
}
}
else {
if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')
b->FXctx = fxMesaCreateContext(w, GR_RESOLUTION_NONE,
GR_REFRESH_75Hz, attribs);
else
b->FXctx = fxMesaCreateBestContext(0, b->mesa_buffer.Width,
b->mesa_buffer.Height, attribs);
b->FXisHackUsable = GL_FALSE;
b->FXwindowHack = GL_FALSE;
}
/*
fprintf(stderr,
"voodoo %d, wid %d height %d hack: usable %d active %d\n",
hw, b->mesa_buffer.Width, b->mesa_buffer.Height,
b->FXisHackUsable, b->FXwindowHack);
*/
}
}
else {
_mesa_warning(NULL, "WARNING: This Mesa Library includes the Glide driver but\n");
_mesa_warning(NULL, " you have not defined the MESA_GLX_FX env. var.\n");
_mesa_warning(NULL, " (check the README.3DFX file for more information).\n\n");
_mesa_warning(NULL, " you can disable this message with a 'export MESA_GLX_FX=disable'.\n");
}
#endif
return b;
}
XMesaBuffer
XMesaCreateWindowBuffer(XMesaVisual v, XMesaWindow w)
{
return XMesaCreateWindowBuffer2( v, w, NULL );
}
/**
* Create a new XMesaBuffer from an X pixmap.
@@ -1762,10 +1652,9 @@ XMesaCreateWindowBuffer(XMesaVisual v, XMesaWindow w)
* \c GLX_DIRECT_COLOR visual for the pixmap
* \returns new XMesaBuffer or NULL if error
*/
XMesaBuffer
PUBLIC XMesaBuffer
XMesaCreatePixmapBuffer(XMesaVisual v, XMesaPixmap p, XMesaColormap cmap)
{
int client = 0;
XMesaBuffer b;
assert(v);
@@ -1774,11 +1663,7 @@ XMesaCreatePixmapBuffer(XMesaVisual v, XMesaPixmap p, XMesaColormap cmap)
if (!b)
return NULL;
#ifdef XFree86Server
client = CLIENT_ID(((XMesaDrawable)p)->id);
#endif
if (!initialize_visual_and_buffer(client, v, b, v->mesa_visual.rgbMode,
if (!initialize_visual_and_buffer(v, b, v->mesa_visual.rgbMode,
(XMesaDrawable) p, cmap)) {
xmesa_free_buffer(b);
return NULL;
@@ -1793,10 +1678,7 @@ XMesaBuffer
XMesaCreatePBuffer(XMesaVisual v, XMesaColormap cmap,
unsigned int width, unsigned int height)
{
#ifdef XFree86Server
return 0;
#else
int client = 0;
#ifndef XFree86Server
XMesaWindow root;
XMesaDrawable drawable; /* X Pixmap Drawable */
XMesaBuffer b;
@@ -1812,13 +1694,15 @@ XMesaCreatePBuffer(XMesaVisual v, XMesaColormap cmap,
if (!b)
return NULL;
if (!initialize_visual_and_buffer(client, v, b, v->mesa_visual.rgbMode,
if (!initialize_visual_and_buffer(v, b, v->mesa_visual.rgbMode,
drawable, cmap)) {
xmesa_free_buffer(b);
return NULL;
}
return b;
#else
return 0;
#endif
}
@@ -1827,7 +1711,7 @@ XMesaCreatePBuffer(XMesaVisual v, XMesaColormap cmap,
/*
* Deallocate an XMesaBuffer structure and all related info.
*/
void
PUBLIC void
XMesaDestroyBuffer(XMesaBuffer b)
{
xmesa_free_buffer(b);
@@ -1870,6 +1754,7 @@ GLboolean XMesaMakeCurrent( XMesaContext c, XMesaBuffer b )
/*
* Bind buffer b to context c and make c the current rendering context.
*/
PUBLIC
GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
XMesaBuffer readBuffer )
{
@@ -1877,15 +1762,6 @@ GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
if (!drawBuffer || !readBuffer)
return GL_FALSE; /* must specify buffers! */
#ifdef FX
if (drawBuffer->FXctx) {
fxMesaMakeCurrent(drawBuffer->FXctx);
c->xm_buffer = drawBuffer;
return GL_TRUE;
}
#endif
if (&(c->mesa) == _mesa_get_current_context()
&& c->mesa.DrawBuffer == &drawBuffer->mesa_buffer
&& c->mesa.ReadBuffer == &readBuffer->mesa_buffer
@@ -1896,6 +1772,11 @@ GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
c->xm_buffer = drawBuffer;
#ifdef FX
if (FXmakeCurrent( drawBuffer ))
return GL_TRUE;
#endif
/* Call this periodically to detect when the user has begun using
* GL rendering from multiple threads.
*/
@@ -1983,9 +1864,13 @@ XMesaBuffer XMesaGetCurrentReadBuffer( void )
}
#ifdef XFree86Server
PUBLIC
GLboolean XMesaForceCurrent(XMesaContext c)
{
if (c) {
_glapi_set_dispatch(c->mesa.CurrentDispatch);
if (&(c->mesa) != _mesa_get_current_context()) {
_mesa_make_current(&c->mesa, c->mesa.DrawBuffer, c->mesa.ReadBuffer);
}
@@ -1997,6 +1882,7 @@ GLboolean XMesaForceCurrent(XMesaContext c)
}
PUBLIC
GLboolean XMesaLoseCurrent(XMesaContext c)
{
(void) c;
@@ -2005,150 +1891,30 @@ GLboolean XMesaLoseCurrent(XMesaContext c)
}
/*
* Switch 3Dfx support hack between window and full-screen mode.
*/
PUBLIC
GLboolean XMesaCopyContext( XMesaContext xm_src, XMesaContext xm_dst, GLuint mask )
{
_mesa_copy_context(&xm_src->mesa, &xm_dst->mesa, mask);
return GL_TRUE;
}
#endif /* XFree86Server */
#ifndef FX
GLboolean XMesaSetFXmode( GLint mode )
{
#ifdef FX
const char *fx = _mesa_getenv("MESA_GLX_FX");
if (fx && fx[0] != 'd') {
GET_CURRENT_CONTEXT(ctx);
GrHwConfiguration hw;
if (!FX_grSstQueryHardware(&hw)) {
/*fprintf(stderr, "!grSstQueryHardware\n");*/
return GL_FALSE;
}
if (hw.num_sst < 1) {
/*fprintf(stderr, "hw.num_sst < 1\n");*/
return GL_FALSE;
}
if (ctx) {
/* [dBorca] Hack alert:
* oh, this is sooo wrong: ctx above is
* really an fxMesaContext, not an XMesaContext
*/
XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
if (mode == XMESA_FX_WINDOW) {
if (xmbuf->FXisHackUsable) {
FX_grSstControl(GR_CONTROL_DEACTIVATE);
xmbuf->FXwindowHack = GL_TRUE;
return GL_TRUE;
}
}
else if (mode == XMESA_FX_FULLSCREEN) {
FX_grSstControl(GR_CONTROL_ACTIVATE);
xmbuf->FXwindowHack = GL_FALSE;
return GL_TRUE;
}
else {
/* Error: Bad mode value */
}
}
}
/*fprintf(stderr, "fallthrough\n");*/
#else
(void) mode;
#endif
return GL_FALSE;
}
#ifdef FX
/*
* Read image from VooDoo frame buffer into X/Mesa's back XImage.
*/
static void FXgetImage( XMesaBuffer b )
{
GET_CURRENT_CONTEXT(ctx);
static unsigned short pixbuf[MAX_WIDTH];
GLuint x, y;
GLuint width, height;
XMesaContext xmesa = XMESA_CONTEXT(ctx);
#ifdef XFree86Server
x = b->frontxrb->pixmap->x;
y = b->frontxrb->pixmap->y;
width = b->frontxrb->pixmap->width;
height = b->frontxrb->pixmap->height;
depth = b->frontxrb->pixmap->depth;
#else
xmesa_get_window_size(b->display, b, &width, &height);
x = y = 0;
#endif
if (b->mesa_buffer.Width != width || b->mesa_buffer.Height != height) {
b->mesa_buffer.Width = MIN2((int)width, b->FXctx->width);
b->mesa_buffer.Height = MIN2((int)height, b->FXctx->height);
if (b->mesa_buffer.Width & 1)
b->mesa_buffer.Width--; /* prevent odd width */
}
/* [dBorca] we're always in the right GR_COLORFORMAT... aren't we? */
/* grLfbWriteColorFormat(GR_COLORFORMAT_ARGB); */
if (b->xm_visual->undithered_pf==PF_5R6G5B) {
/* Special case: 16bpp RGB */
grLfbReadRegion( GR_BUFFER_FRONTBUFFER, /* src buffer */
0, b->FXctx->height - b->mesa_buffer.Height, /*pos*/
b->mesa_buffer.Width, b->mesa_buffer.Height, /* size */
b->mesa_buffer.Width * sizeof(GLushort), /* stride */
b->backxrb->ximage->data); /* dest buffer */
}
else if (b->xm_visual->dithered_pf==PF_Dither
&& GET_VISUAL_DEPTH(b->xm_visual)==8) {
/* Special case: 8bpp RGB */
for (y=0;y<b->mesa_buffer.Height;y++) {
GLubyte *ptr = (GLubyte*) b->backxrb->ximage->data
+ b->backxrb->ximage->bytes_per_line * y;
XDITHER_SETUP(y);
/* read row from 3Dfx frame buffer */
grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
0, b->FXctx->height-(b->mesa_buffer.Height-y),
b->mesa_buffer.Width, 1,
0,
pixbuf );
/* write to XImage back buffer */
for (x=0;x<b->mesa_buffer.Width;x++) {
GLubyte r = (pixbuf[x] & 0xf800) >> 8;
GLubyte g = (pixbuf[x] & 0x07e0) >> 3;
GLubyte b = (pixbuf[x] & 0x001f) << 3;
*ptr++ = XDITHER( x, r, g, b);
}
}
}
else {
/* General case: slow! */
for (y=0;y<b->mesa_buffer.Height;y++) {
/* read row from 3Dfx frame buffer */
grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
0, b->FXctx->height-(b->mesa_buffer.Height-y),
b->mesa_buffer.Width, 1,
0,
pixbuf );
/* write to XImage back buffer */
for (x=0;x<b->mesa_buffer.Width;x++) {
XMesaPutPixel(b->backxrb->ximage,x,y,
xmesa_color_to_pixel(ctx,
(pixbuf[x] & 0xf800) >> 8,
(pixbuf[x] & 0x07e0) >> 3,
(pixbuf[x] & 0x001f) << 3,
0xff,
b->xm_visual->undithered_pf));
}
}
}
/* grLfbWriteColorFormat(GR_COLORFORMAT_ABGR); */
}
#endif
/*
* Copy the back buffer to the front buffer. If there's no back buffer
* this is a no-op.
*/
PUBLIC
void XMesaSwapBuffers( XMesaBuffer b )
{
GET_CURRENT_CONTEXT(ctx);
@@ -2166,16 +1932,10 @@ void XMesaSwapBuffers( XMesaBuffer b )
if (b->db_mode) {
#ifdef FX
if (b->FXctx) {
fxMesaSwapBuffers();
if (b->FXwindowHack)
FXgetImage(b);
else
return;
}
if (FXswapBuffers(b))
return;
#endif
if (b->backxrb->ximage) {
if (b->backxrb->ximage) {
/* Copy Ximage (back buf) from client memory to server window */
#if defined(USE_XSHM) && !defined(XFree86Server)
if (b->shm) {
@@ -2242,13 +2002,8 @@ void XMesaCopySubBuffer( XMesaBuffer b, int x, int y, int width, int height )
if (b->db_mode) {
int yTop = b->mesa_buffer.Height - y - height;
#ifdef FX
if (b->FXctx) {
fxMesaSwapBuffers();
if (b->FXwindowHack)
FXgetImage(b);
else
return;
}
if (FXswapBuffers(b))
return;
#endif
if (b->backxrb->ximage) {
/* Copy Ximage from host's memory to server's window */
@@ -2426,15 +2181,6 @@ void XMesaGarbageCollect( void )
}
void XMesaReset( void )
{
while (XMesaBufferList)
XMesaDestroyBuffer(XMesaBufferList);
XMesaBufferList = NULL;
}
unsigned long XMesaDitherColor( XMesaContext xmesa, GLint x, GLint y,
GLfloat red, GLfloat green,
GLfloat blue, GLfloat alpha )
@@ -2498,7 +2244,7 @@ unsigned long XMesaDitherColor( XMesaContext xmesa, GLint x, GLint y,
* This is typically called when the window size changes and we need
* to reallocate the buffer's back/depth/stencil/accum buffers.
*/
void
PUBLIC void
XMesaResizeBuffers( XMesaBuffer b )
{
GET_CURRENT_CONTEXT(ctx);

View File

@@ -37,7 +37,7 @@
#include "renderbuffer.h"
#ifndef XFree86Server
#if defined(USE_XSHM) && !defined(XFree86Server)
static volatile int mesaXErrorFlag = 0;
/**
@@ -51,18 +51,14 @@ mesaHandleXError(XMesaDisplay *dpy, XErrorEvent *event)
mesaXErrorFlag = 1;
return 0;
}
#endif
/**
* Allocate a shared memory XImage back buffer for the given XMesaBuffer.
* Return: GL_TRUE if success, GL_FALSE if error
*/
#ifndef XFree86Server
static GLboolean
alloc_back_shm_ximage(XMesaBuffer b, GLuint width, GLuint height)
{
#ifdef USE_XSHM
/*
* We have to do a _lot_ of error checking here to be sure we can
* really use the XSHM extension. It seems different servers trigger
@@ -152,10 +148,13 @@ alloc_back_shm_ximage(XMesaBuffer b, GLuint width, GLuint height)
}
return GL_TRUE;
}
#else
static GLboolean
alloc_back_shm_ximage(XMesaBuffer b, GLuint width, GLuint height)
{
/* Can't compile XSHM support */
return GL_FALSE;
#endif
}
#endif
@@ -187,14 +186,12 @@ alloc_back_buffer(XMesaBuffer b, GLuint width, GLuint height)
return;
/* Allocate new back buffer */
#ifdef XFree86Server
/* Allocate a regular XImage for the back buffer. */
b->backxrb->ximage = XMesaCreateImage(b->xm_visual->BitsPerPixel,
width, height, NULL);
{
#else
if (b->shm == 0 || !alloc_back_shm_ximage(b, width, height)) {
/* Allocate a regular XImage for the back buffer. */
#ifdef XFree86Server
b->backxrb->ximage = XMesaCreateImage(b->xm_visual->BitsPerPixel,
width, height, NULL);
#else
b->backxrb->ximage = XCreateImage(b->xm_visual->display,
b->xm_visual->visinfo->visual,
GET_VISUAL_DEPTH(b->xm_visual),
@@ -386,18 +383,18 @@ xmesa_delete_framebuffer(struct gl_framebuffer *fb)
}
if (b->gc)
XMesaFreeGC(b->xm_visual->display, b->gc);
XMesaFreeGC(b->display, b->gc);
if (b->cleargc)
XMesaFreeGC(b->xm_visual->display, b->cleargc);
XMesaFreeGC(b->display, b->cleargc);
if (b->swapgc)
XMesaFreeGC(b->xm_visual->display, b->swapgc);
XMesaFreeGC(b->display, b->swapgc);
if (b->xm_visual->mesa_visual.doubleBufferMode) {
if (fb->Visual.doubleBufferMode) {
/* free back ximage/pixmap/shmregion */
if (b->backxrb->ximage) {
#if defined(USE_XSHM) && !defined(XFree86Server)
if (b->shm) {
XShmDetach( b->xm_visual->display, &b->shminfo );
XShmDetach( b->display, &b->shminfo );
XDestroyImage( b->backxrb->ximage );
shmdt( b->shminfo.shmaddr );
}
@@ -407,9 +404,9 @@ xmesa_delete_framebuffer(struct gl_framebuffer *fb)
b->backxrb->ximage = NULL;
}
if (b->backxrb->pixmap) {
XMesaFreePixmap( b->xm_visual->display, b->backxrb->pixmap );
XMesaFreePixmap( b->display, b->backxrb->pixmap );
if (b->xm_visual->hpcr_clear_flag) {
XMesaFreePixmap( b->xm_visual->display,
XMesaFreePixmap( b->display,
b->xm_visual->hpcr_clear_pixmap );
XMesaDestroyImage( b->xm_visual->hpcr_clear_ximage );
}

View File

@@ -53,10 +53,6 @@
#include "tnl/tnl.h"
#include "tnl/t_context.h"
#ifdef XFree86Server
#include <GL/glxtokens.h>
#endif
/*

View File

@@ -0,0 +1,276 @@
/*
* Mesa 3-D graphics library
* Version: 6.5
*
* Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "glxheader.h"
#include "xmesaP.h"
#ifdef FX
#include "../glide/fxdrv.h"
void
FXcreateContext(XMesaVisual v, XMesaWindow w, XMesaContext c, XMesaBuffer b)
{
char *fxEnvVar = _mesa_getenv("MESA_GLX_FX");
if (fxEnvVar) {
if (fxEnvVar[0]!='d') {
int attribs[100];
int numAttribs = 0;
int hw;
if (v->mesa_visual.depthBits > 0) {
attribs[numAttribs++] = FXMESA_DEPTH_SIZE;
attribs[numAttribs++] = v->mesa_visual.depthBits;
}
if (v->mesa_visual.doubleBufferMode) {
attribs[numAttribs++] = FXMESA_DOUBLEBUFFER;
}
if (v->mesa_visual.accumRedBits > 0) {
attribs[numAttribs++] = FXMESA_ACCUM_SIZE;
attribs[numAttribs++] = v->mesa_visual.accumRedBits;
}
if (v->mesa_visual.stencilBits > 0) {
attribs[numAttribs++] = FXMESA_STENCIL_SIZE;
attribs[numAttribs++] = v->mesa_visual.stencilBits;
}
if (v->mesa_visual.alphaBits > 0) {
attribs[numAttribs++] = FXMESA_ALPHA_SIZE;
attribs[numAttribs++] = v->mesa_visual.alphaBits;
}
if (1) {
attribs[numAttribs++] = FXMESA_SHARE_CONTEXT;
attribs[numAttribs++] = (int) &(c->mesa);
}
attribs[numAttribs++] = FXMESA_NONE;
/* [dBorca] we should take an envvar for `fxMesaSelectCurrentBoard'!!! */
hw = fxMesaSelectCurrentBoard(0);
/* if these fail, there's a new bug somewhere */
ASSERT(b->mesa_buffer.Width > 0);
ASSERT(b->mesa_buffer.Height > 0);
if ((hw == GR_SSTTYPE_VOODOO) || (hw == GR_SSTTYPE_Voodoo2)) {
b->FXctx = fxMesaCreateBestContext(0, b->mesa_buffer.Width,
b->mesa_buffer.Height, attribs);
if ((v->undithered_pf!=PF_Index) && (b->backxrb->ximage)) {
b->FXisHackUsable = b->FXctx ? GL_TRUE : GL_FALSE;
if (b->FXctx && (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')) {
b->FXwindowHack = GL_TRUE;
FX_grSstControl(GR_CONTROL_DEACTIVATE);
}
else {
b->FXwindowHack = GL_FALSE;
}
}
}
else {
if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')
b->FXctx = fxMesaCreateContext(w, GR_RESOLUTION_NONE,
GR_REFRESH_75Hz, attribs);
else
b->FXctx = fxMesaCreateBestContext(0, b->mesa_buffer.Width,
b->mesa_buffer.Height, attribs);
b->FXisHackUsable = GL_FALSE;
b->FXwindowHack = GL_FALSE;
}
/*
fprintf(stderr,
"voodoo %d, wid %d height %d hack: usable %d active %d\n",
hw, b->mesa_buffer.Width, b->mesa_buffer.Height,
b->FXisHackUsable, b->FXwindowHack);
*/
}
}
else {
_mesa_warning(NULL, "WARNING: This Mesa Library includes the Glide driver but\n");
_mesa_warning(NULL, " you have not defined the MESA_GLX_FX env. var.\n");
_mesa_warning(NULL, " (check the README.3DFX file for more information).\n\n");
_mesa_warning(NULL, " you can disable this message with a 'export MESA_GLX_FX=disable'.\n");
}
}
void FXdestroyContext( XMesaBuffer b )
{
if (b && b->FXctx)
fxMesaDestroyContext(b->FXctx);
}
GLboolean FXmakeCurrent( XMesaBuffer b )
{
if (b->FXctx) {
fxMesaMakeCurrent(b->FXctx);
return GL_TRUE;
}
return GL_FALSE;
}
/*
* Read image from VooDoo frame buffer into X/Mesa's back XImage.
*/
static void FXgetImage( XMesaBuffer b )
{
GET_CURRENT_CONTEXT(ctx);
static unsigned short pixbuf[MAX_WIDTH];
GLuint x, y;
GLuint width, height;
#ifdef XFree86Server
x = b->frontxrb->pixmap->x;
y = b->frontxrb->pixmap->y;
width = b->frontxrb->pixmap->width;
height = b->frontxrb->pixmap->height;
depth = b->frontxrb->pixmap->depth;
#else
xmesa_get_window_size(b->display, b, &width, &height);
x = y = 0;
#endif
if (b->mesa_buffer.Width != width || b->mesa_buffer.Height != height) {
b->mesa_buffer.Width = MIN2((int)width, b->FXctx->width);
b->mesa_buffer.Height = MIN2((int)height, b->FXctx->height);
if (b->mesa_buffer.Width & 1)
b->mesa_buffer.Width--; /* prevent odd width */
}
/* [dBorca] we're always in the right GR_COLORFORMAT... aren't we? */
/* grLfbWriteColorFormat(GR_COLORFORMAT_ARGB); */
if (b->xm_visual->undithered_pf==PF_5R6G5B) {
/* Special case: 16bpp RGB */
grLfbReadRegion( GR_BUFFER_FRONTBUFFER, /* src buffer */
0, b->FXctx->height - b->mesa_buffer.Height, /*pos*/
b->mesa_buffer.Width, b->mesa_buffer.Height, /* size */
b->mesa_buffer.Width * sizeof(GLushort), /* stride */
b->backxrb->ximage->data); /* dest buffer */
}
else if (b->xm_visual->dithered_pf==PF_Dither
&& GET_VISUAL_DEPTH(b->xm_visual)==8) {
/* Special case: 8bpp RGB */
for (y=0;y<b->mesa_buffer.Height;y++) {
GLubyte *ptr = (GLubyte*) b->backxrb->ximage->data
+ b->backxrb->ximage->bytes_per_line * y;
XDITHER_SETUP(y);
/* read row from 3Dfx frame buffer */
grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
0, b->FXctx->height-(b->mesa_buffer.Height-y),
b->mesa_buffer.Width, 1,
0,
pixbuf );
/* write to XImage back buffer */
for (x=0;x<b->mesa_buffer.Width;x++) {
GLubyte r = (pixbuf[x] & 0xf800) >> 8;
GLubyte g = (pixbuf[x] & 0x07e0) >> 3;
GLubyte b = (pixbuf[x] & 0x001f) << 3;
*ptr++ = XDITHER( x, r, g, b);
}
}
}
else {
/* General case: slow! */
for (y=0;y<b->mesa_buffer.Height;y++) {
/* read row from 3Dfx frame buffer */
grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
0, b->FXctx->height-(b->mesa_buffer.Height-y),
b->mesa_buffer.Width, 1,
0,
pixbuf );
/* write to XImage back buffer */
for (x=0;x<b->mesa_buffer.Width;x++) {
XMesaPutPixel(b->backxrb->ximage,x,y,
xmesa_color_to_pixel(ctx,
(pixbuf[x] & 0xf800) >> 8,
(pixbuf[x] & 0x07e0) >> 3,
(pixbuf[x] & 0x001f) << 3,
0xff,
b->xm_visual->undithered_pf));
}
}
}
/* grLfbWriteColorFormat(GR_COLORFORMAT_ABGR); */
}
GLboolean FXswapBuffers( XMesaBuffer b )
{
if (b->FXctx) {
fxMesaSwapBuffers();
if (!b->FXwindowHack)
return GL_TRUE;
FXgetImage(b);
}
return GL_FALSE;
}
/*
* Switch 3Dfx support hack between window and full-screen mode.
*/
GLboolean XMesaSetFXmode( GLint mode )
{
const char *fx = _mesa_getenv("MESA_GLX_FX");
if (fx && fx[0] != 'd') {
GET_CURRENT_CONTEXT(ctx);
GrHwConfiguration hw;
if (!FX_grSstQueryHardware(&hw)) {
/*fprintf(stderr, "!grSstQueryHardware\n");*/
return GL_FALSE;
}
if (hw.num_sst < 1) {
/*fprintf(stderr, "hw.num_sst < 1\n");*/
return GL_FALSE;
}
if (ctx) {
/* [dBorca] Hack alert:
* oh, this is sooo wrong: ctx above is
* really an fxMesaContext, not an XMesaContext
*/
XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
if (mode == XMESA_FX_WINDOW) {
if (xmbuf->FXisHackUsable) {
FX_grSstControl(GR_CONTROL_DEACTIVATE);
xmbuf->FXwindowHack = GL_TRUE;
return GL_TRUE;
}
}
else if (mode == XMESA_FX_FULLSCREEN) {
FX_grSstControl(GR_CONTROL_ACTIVATE);
xmbuf->FXwindowHack = GL_FALSE;
return GL_TRUE;
}
else {
/* Error: Bad mode value */
}
}
}
/*fprintf(stderr, "fallthrough\n");*/
return GL_FALSE;
}
#endif

View File

@@ -0,0 +1,40 @@
/*
* Mesa 3-D graphics library
* Version: 6.5
*
* Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef _XM_GLIDE_H_
#define _XM_GLIDE_H_
extern void FXcreateContext( XMesaVisual v,
XMesaWindow w,
XMesaContext c,
XMesaBuffer b );
extern void FXdestroyContext( XMesaBuffer b );
extern GLboolean FXmakeCurrent( XMesaBuffer b );
extern GLboolean FXswapBuffers( XMesaBuffer b );
#endif /* _XM_GLIDE_H_ */

View File

@@ -0,0 +1,133 @@
/**************************************************************************
Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
All Rights Reserved.
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sub license, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice (including the
next paragraph) shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**************************************************************************/
/*
* Authors:
* Kevin E. Martin <kevin@precisioninsight.com>
* Brian Paul <brian@precisioninsight.com>
*/
#include <stdlib.h>
#include <X11/Xmd.h>
#include "glxheader.h"
#include "xmesaP.h"
#ifdef XFree86Server
#ifdef ROUNDUP
#undef ROUNDUP
#endif
#define ROUNDUP(nbytes, pad) ((((nbytes) + ((pad)-1)) / (pad)) * ((pad)>>3))
XMesaImage *XMesaCreateImage(int bitsPerPixel, int width, int height, char *data)
{
XMesaImage *image;
image = (XMesaImage *)xalloc(sizeof(XMesaImage));
if (image) {
image->width = width;
image->height = height;
image->data = data;
/* Always pad to 32 bits */
image->bytes_per_line = ROUNDUP((bitsPerPixel * width), 32);
image->bits_per_pixel = bitsPerPixel;
}
return image;
}
void XMesaDestroyImage(XMesaImage *image)
{
if (image->data)
free(image->data);
xfree(image);
}
unsigned long XMesaGetPixel(XMesaImage *image, int x, int y)
{
CARD8 *row = (CARD8 *)(image->data + y*image->bytes_per_line);
CARD8 *i8;
CARD16 *i16;
CARD32 *i32;
switch (image->bits_per_pixel) {
case 8:
i8 = (CARD8 *)row;
return i8[x];
break;
case 15:
case 16:
i16 = (CARD16 *)row;
return i16[x];
break;
case 24: /* WARNING: architecture specific code */
i8 = (CARD8 *)row;
return (((CARD32)i8[x*3]) |
(((CARD32)i8[x*3+1])<<8) |
(((CARD32)i8[x*3+2])<<16));
break;
case 32:
i32 = (CARD32 *)row;
return i32[x];
break;
}
return 0;
}
#ifndef XMESA_USE_PUTPIXEL_MACRO
void XMesaPutPixel(XMesaImage *image, int x, int y, unsigned long pixel)
{
CARD8 *row = (CARD8 *)(image->data + y*image->bytes_per_line);
CARD8 *i8;
CARD16 *i16;
CARD32 *i32;
switch (image->bits_per_pixel) {
case 8:
i8 = (CARD8 *)row;
i8[x] = (CARD8)pixel;
break;
case 15:
case 16:
i16 = (CARD16 *)row;
i16[x] = (CARD16)pixel;
break;
case 24: /* WARNING: architecture specific code */
i8 = (CARD8 *)__row;
i8[x*3] = (CARD8)(p);
i8[x*3+1] = (CARD8)(p>>8);
i8[x*3+2] = (CARD8)(p>>16);
case 32:
i32 = (CARD32 *)row;
i32[x] = (CARD32)pixel;
break;
}
}
#endif
#endif /* XFree86Server */

View File

@@ -0,0 +1,84 @@
/**************************************************************************
Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
All Rights Reserved.
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sub license, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice (including the
next paragraph) shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
**************************************************************************/
/*
* Authors:
* Kevin E. Martin <kevin@precisioninsight.com>
* Brian Paul <brian@precisioninsight.com>
*/
#ifndef _XM_IMAGE_H_
#define _XM_IMAGE_H_
#define XMESA_USE_PUTPIXEL_MACRO
struct _XMesaImageRec {
int width, height;
char *data;
int bytes_per_line; /* Padded to 32 bits */
int bits_per_pixel;
};
extern XMesaImage *XMesaCreateImage(int bitsPerPixel, int width, int height,
char *data);
extern void XMesaDestroyImage(XMesaImage *image);
extern unsigned long XMesaGetPixel(XMesaImage *image, int x, int y);
#ifdef XMESA_USE_PUTPIXEL_MACRO
#define XMesaPutPixel(__i,__x,__y,__p) \
{ \
CARD8 *__row = (CARD8 *)(__i->data + __y*__i->bytes_per_line); \
CARD8 *__i8; \
CARD16 *__i16; \
CARD32 *__i32; \
switch (__i->bits_per_pixel) { \
case 8: \
__i8 = (CARD8 *)__row; \
__i8[__x] = (CARD8)__p; \
break; \
case 15: \
case 16: \
__i16 = (CARD16 *)__row; \
__i16[__x] = (CARD16)__p; \
break; \
case 24: /* WARNING: architecture specific code */ \
__i8 = (CARD8 *)__row; \
__i8[__x*3] = (CARD8)(__p); \
__i8[__x*3+1] = (CARD8)(__p>>8); \
__i8[__x*3+2] = (CARD8)(__p>>16); \
break; \
case 32: \
__i32 = (CARD32 *)__row; \
__i32[__x] = (CARD32)__p; \
break; \
} \
}
#else
extern void XMesaPutPixel(XMesaImage *image, int x, int y,
unsigned long pixel);
#endif
#endif /* _XM_IMAGE_H_ */

View File

@@ -147,7 +147,7 @@ void xmesa_choose_point( GLcontext *ctx )
#define SETUP_CODE \
GET_XRB(xrb); \
const GLubyte *color = vert1->color; \
GLuint pixel = PACK_8B8G8R( color[0], color[1], color[2] );
GLuint pixel = PACK_8A8B8G8R(color[0], color[1], color[2], color[3]);
#define PIXEL_TYPE GLuint
#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
@@ -164,7 +164,7 @@ void xmesa_choose_point( GLcontext *ctx )
#define SETUP_CODE \
GET_XRB(xrb); \
const GLubyte *color = vert1->color; \
GLuint pixel = PACK_8R8G8B( color[0], color[1], color[2] );
GLuint pixel = PACK_8A8R8G8B(color[0], color[1], color[2], color[3]);
#define PIXEL_TYPE GLuint
#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
@@ -331,7 +331,7 @@ void xmesa_choose_point( GLcontext *ctx )
#define SETUP_CODE \
GET_XRB(xrb); \
const GLubyte *color = vert1->color; \
GLuint pixel = PACK_8B8G8R( color[0], color[1], color[2] );
GLuint pixel = PACK_8A8B8G8R(color[0], color[1], color[2], color[3]);
#define INTERP_Z 1
#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
#define PIXEL_TYPE GLuint
@@ -354,7 +354,7 @@ void xmesa_choose_point( GLcontext *ctx )
#define SETUP_CODE \
GET_XRB(xrb); \
const GLubyte *color = vert1->color; \
GLuint pixel = PACK_8R8G8B( color[0], color[1], color[2] );
GLuint pixel = PACK_8A8R8G8B(color[0], color[1], color[2], color[3]);
#define INTERP_Z 1
#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
#define PIXEL_TYPE GLuint
@@ -581,13 +581,11 @@ static swrast_line_func
get_line_func(GLcontext *ctx)
{
#if CHAN_BITS == 8
XMesaContext xmesa = XMESA_CONTEXT(ctx);
SWcontext *swrast = SWRAST_CONTEXT(ctx);
int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
struct xmesa_renderbuffer *xrb;
if (CHAN_BITS != 8)
return NULL;
XMesaContext xmesa = XMESA_CONTEXT(ctx);
XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
const int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
const struct xmesa_renderbuffer *xrb;
if ((ctx->DrawBuffer->_ColorDrawBufferMask[0]
& (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT)) == 0)
@@ -598,6 +596,7 @@ get_line_func(GLcontext *ctx)
if (ctx->Light.ShadeModel != GL_FLAT) return (swrast_line_func) NULL;
if (ctx->Line.StippleFlag) return (swrast_line_func) NULL;
if (swrast->_RasterMask & MULTI_DRAW_BIT) return (swrast_line_func) NULL;
if (xmbuf->swAlpha) return (swrast_line_func) NULL;
xrb = xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0][0]->Wrapped);

View File

@@ -96,6 +96,7 @@
#define INTERP_Z 1
#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
#define INTERP_RGB 1
#define INTERP_ALPHA 1
#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
#define PIXEL_TYPE GLuint
#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
@@ -106,13 +107,15 @@
for (i = 0; i < span.end; i++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = PACK_8B8G8R(FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue)); \
pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue), \
FixedToInt(span.alpha)); \
zRow[i] = z; \
} \
span.red += span.redStep; \
span.green += span.greenStep; \
span.blue += span.blueStep; \
span.alpha += span.alphaStep; \
span.z += span.zStep; \
}
@@ -127,6 +130,7 @@
#define INTERP_Z 1
#define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
#define INTERP_RGB 1
#define INTERP_ALPHA 1
#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
#define PIXEL_TYPE GLuint
#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
@@ -138,13 +142,15 @@
for (i = 0; i < span.end; i++) { \
const DEPTH_TYPE z = FixedToDepth(span.z); \
if (z < zRow[i]) { \
pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue)); \
pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue), \
FixedToInt(span.alpha)); \
zRow[i] = z; \
} \
span.red += span.redStep; \
span.green += span.greenStep; \
span.blue += span.blueStep; \
span.alpha += span.alphaStep; \
span.z += span.zStep; \
}
@@ -473,7 +479,8 @@
#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
#define SETUP_CODE \
GET_XRB(xrb); \
GLuint p = PACK_8B8G8R( v2->color[0], v2->color[1], v2->color[2] );
GLuint p = PACK_8A8B8G8R( v2->color[0], v2->color[1],\
v2->color[2], v2->color[3]);
#define RENDER_SPAN( span ) \
GLuint i; \
for (i = 0; i < span.end; i++) { \
@@ -499,7 +506,8 @@
#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
#define SETUP_CODE \
GET_XRB(xrb); \
GLuint p = PACK_8R8G8B( v2->color[0], v2->color[1], v2->color[2] );
GLuint p = PACK_8A8R8G8B(v2->color[0], v2->color[1], \
v2->color[2], v2->color[3]);
#define RENDER_SPAN( span ) \
GLuint i; \
for (i = 0; i < span.end; i++) { \
@@ -798,6 +806,7 @@
*/
#define NAME smooth_8A8B8G8R_triangle
#define INTERP_RGB 1
#define INTERP_ALPHA 1
#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
#define PIXEL_TYPE GLuint
#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
@@ -806,11 +815,13 @@
#define RENDER_SPAN( span ) \
GLuint i; \
for (i = 0; i < span.end; i++) { \
pRow[i] = PACK_8B8G8R(FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue) ); \
pRow[i] = PACK_8A8B8G8R(FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue), \
FixedToInt(span.alpha)); \
span.red += span.redStep; \
span.green += span.greenStep; \
span.blue += span.blueStep; \
span.alpha += span.alphaStep; \
}
#include "swrast/s_tritemp.h"
@@ -821,6 +832,7 @@
*/
#define NAME smooth_8A8R8G8B_triangle
#define INTERP_RGB 1
#define INTERP_ALPHA 1
#define PIXEL_ADDRESS(X,Y) PIXEL_ADDR4(xrb, X, Y)
#define PIXEL_TYPE GLuint
#define BYTES_PER_ROW (xrb->ximage->bytes_per_line)
@@ -829,11 +841,13 @@
#define RENDER_SPAN( span ) \
GLuint i; \
for (i = 0; i < span.end; i++) { \
pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue) ); \
pRow[i] = PACK_8A8R8G8B(FixedToInt(span.red), \
FixedToInt(span.green), FixedToInt(span.blue), \
FixedToInt(span.alpha)); \
span.red += span.redStep; \
span.green += span.greenStep; \
span.blue += span.blueStep; \
span.alpha += span.alphaStep; \
}
#include "swrast/s_tritemp.h"
@@ -1436,16 +1450,17 @@ do { \
static swrast_tri_func
get_triangle_func(GLcontext *ctx)
{
#if CHAN_BITS == 8
SWcontext *swrast = SWRAST_CONTEXT(ctx);
XMesaContext xmesa = XMESA_CONTEXT(ctx);
int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
struct xmesa_renderbuffer *xrb;
XMesaBuffer xmbuf = XMESA_BUFFER(ctx->DrawBuffer);
const int depth = GET_VISUAL_DEPTH(xmesa->xm_visual);
const struct xmesa_renderbuffer *xrb;
#ifdef DEBUG
triFuncName = NULL;
#endif
#if CHAN_BITS == 8
/* trivial fallback tests */
if ((ctx->DrawBuffer->_ColorDrawBufferMask[0]
& (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT)) == 0)
@@ -1461,6 +1476,8 @@ get_triangle_func(GLcontext *ctx)
if (ctx->Polygon.CullFlag &&
ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
return (swrast_tri_func) NULL;
if (xmbuf->swAlpha)
return (swrast_tri_func) NULL;
xrb = xmesa_renderbuffer(ctx->DrawBuffer->_ColorDrawBuffers[0][0]->Wrapped);

View File

@@ -27,16 +27,14 @@
#define XMESAP_H
#ifdef XFree86Server
# include "xf86glx_util.h"
#elif defined(USE_XSHM)
# include <X11/extensions/XShm.h>
#endif
#include "GL/xmesa.h"
#include "mtypes.h"
#if defined(FX)
#include "GL/fxmesa.h"
#include "../glide/fxdrv.h"
#include "xm_glide.h"
#endif
#ifdef XFree86Server
#include "xm_image.h"
#endif
@@ -67,17 +65,17 @@ enum pixel_format {
PF_Index, /**< Color Index mode */
PF_Truecolor, /**< TrueColor or DirectColor, any depth */
PF_Dither_True, /**< TrueColor with dithering */
PF_8A8B8G8R, /**< 32-bit TrueColor: 8-A, 8-B, 8-G, 8-R */
PF_8A8R8G8B, /**< 32-bit TrueColor: 8-A, 8-R, 8-G, 8-B bits */
PF_8A8B8G8R, /**< 32-bit TrueColor: 8-A, 8-B, 8-G, 8-R bits */
PF_8R8G8B, /**< 32-bit TrueColor: 8-R, 8-G, 8-B bits */
PF_8R8G8B24, /**< 24-bit TrueColor: 8-R, 8-G, 8-B bits */
PF_5R6G5B, /**< 16-bit TrueColor: 5-R, 6-G, 5-B bits */
PF_Dither, /**< Color-mapped RGB with dither */
PF_Lookup, /**< Color-mapped RGB without dither */
PF_HPCR, /**< HP Color Recovery (ad@lms.be 30/08/95) */
PF_1Bit, /**< monochrome dithering of RGB */
PF_Grayscale, /**< Grayscale or StaticGray */
PF_8R8G8B24, /**< 24-bit TrueColor: 8-R, 8-G, 8-B bits */
PF_Dither_5R6G5B, /**< 16-bit dithered TrueColor: 5-R, 6-G, 5-B */
PF_8A8R8G8B /**< 32-bit TrueColor: 8-A, 8-R, 8-G, 8-B */
PF_Dither_5R6G5B /**< 16-bit dithered TrueColor: 5-R, 6-G, 5-B */
};
@@ -570,21 +568,6 @@ extern void xmesa_register_swrast_functions( GLcontext *ctx );
/* XXX this is a hack to implement shared display lists with 3Dfx */
extern XMesaBuffer XMesaCreateWindowBuffer2( XMesaVisual v,
XMesaWindow w,
XMesaContext c );
/*
* These are the extra routines required for integration with XFree86.
* None of these routines should be user visible. -KEM
*/
extern void XMesaSetVisualDisplay( XMesaDisplay *dpy, XMesaVisual v );
extern GLboolean XMesaForceCurrent(XMesaContext c);
extern GLboolean XMesaLoseCurrent(XMesaContext c);
extern void XMesaReset( void );
#define ENABLE_EXT_texure_compression_s3tc 0 /* SW texture compression */
#ifdef XFree86Server

View File

@@ -317,7 +317,9 @@
<enum name="ATTRIB_STACK_DEPTH" count="1" value="0x0BB0">
<size name="Get" mode="get"/>
</enum>
<enum name="CLIENT_ATTRIB_STACK_DEPTH" value="0x0BB1"/>
<enum name="CLIENT_ATTRIB_STACK_DEPTH" count="1" value="0x0BB1">
<size name="Get" mode="get"/>
</enum>
<enum name="ALPHA_TEST" count="1" value="0x0BC0">
<size name="Get" mode="get"/>
</enum>
@@ -577,7 +579,9 @@
<enum name="MAX_VIEWPORT_DIMS" count="2" value="0x0D3A">
<size name="Get" mode="get"/>
</enum>
<enum name="MAX_CLIENT_ATTRIB_STACK_DEPTH" value="0x0D3B"/>
<enum name="MAX_CLIENT_ATTRIB_STACK_DEPTH" count="1" value="0x0D3B">
<size name="Get" mode="get"/>
</enum>
<enum name="SUBPIXEL_BITS" count="1" value="0x0D50">
<size name="Get" mode="get"/>
</enum>
@@ -7254,10 +7258,10 @@
<size name="GetProgramivARB" mode="get"/>
</enum>
<enum name="MAX_TEXTURE_COORDS_ARB" count="1" value="0x8871">
<size name="GetProgramivARB" mode="get"/>
<size name="Get" mode="get"/>
</enum>
<enum name="MAX_TEXTURE_IMAGE_UNITS_ARB" count="1" value="0x8872">
<size name="GetProgramivARB" mode="get"/>
<size name="Get" mode="get"/>
</enum>
</category>

View File

@@ -240,6 +240,7 @@ _glapi_check_multithread(void)
else if (knownID != _glthread_GetID()) {
ThreadSafe = GL_TRUE;
_glapi_set_dispatch(NULL);
_glapi_set_context(NULL);
}
}
else if (!_glapi_get_dispatch()) {

View File

@@ -1,129 +0,0 @@
#define DoNormalLib NO
#define DoSharedLib YES
#define DoDebugLib NO
#define DoProfileLib NO
#define LibName MESAGL
#define SoRev SOX11REV
#define LibHeaders NO
#include <Threads.tmpl>
REQUIREDLIBS = $(X11ROOT)\\XFree86\\lib\\ Xext X11
BUILDLIBDIR = $(TOP)\\lib
INCLUDES = -I$(TOP)\\include
SRCS = \
accum.c \
alpha.c \
alphabuf.c \
api1.c \
api2.c \
attrib.c \
bitmap.c \
blend.c \
bresenhm.c \
clip.c \
context.c \
copypix.c \
dd.c \
depth.c \
draw.c \
drawpix.c \
enable.c \
eval2.c \
feedback.c \
fog.c \
fortran.c \
get.c \
hash.c \
glx.c \
interp.c \
light.c \
lines.c \
list.c \
logic.c \
masking.c \
misc.c \
osmesa.c \
pb.c \
pixel.c \
points.c \
polygons.c \
readpix.c \
scissor.c \
span.c \
stencil.c \
svgamesa.c \
texture.c \
varray.c \
vb.c \
vertex.c \
xfonts.c \
xform.c \
xm_api.c \
xm_dd.c \
xm_line.c \
xm_span.c \
xm_tri.c
OBJS = \
accum.o \
alpha.o \
alphabuf.o \
api1.o \
api2.o \
attrib.o \
bitmap.o \
blend.o \
bresenhm.o \
clip.o \
context.o \
copypix.o \
dd.o \
depth.o \
draw.o \
drawpix.o \
enable.o \
eval2.o \
feedback.o \
fog.o \
fortran.o \
get.o \
hash.o \
glx.o \
interp.o \
light.o \
lines.o \
list.o \
logic.o \
masking.o \
misc.o \
osmesa.o \
pb.o \
pixel.o \
points.o \
polygons.o \
readpix.o \
scissor.o \
span.o \
stencil.o \
svgamesa.o \
texture.o \
varray.o \
vb.o \
vertex.o \
xfonts.o \
xform.o \
xm_api.o \
xm_dd.o \
xm_line.o \
xm_span.o \
xm_tri.o
LINTLIBS =
#include <Library.tmpl>
DependTarget()

View File

@@ -1,21 +0,0 @@
Performance issues with EXT_point_parameters & quake2
Using glPolygonMode() where the front and back modes aren't the
same causes poor performance on 3Dfx.
Broken drivers: some of the Mesa device drivers (such as BeOS, D3D,
etc) haven't been updated for Mesa 3.3's device driver changes.
glDrawRangeElements() should use vertex array locking to improve performance
but trying to do so causes a rendering error. Reported by Scott McMillan.
Fixed by disabling locking in glDrawRangeElements (varray.c) but that's
really just hiding a bug in array locking.

View File

@@ -765,7 +765,8 @@ pop_texture_group(GLcontext *ctx, const struct gl_texture_attrib *texAttrib)
_mesa_TexParameterf(target, GL_TEXTURE_MIN_LOD, obj->MinLod);
_mesa_TexParameterf(target, GL_TEXTURE_MAX_LOD, obj->MaxLod);
_mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, obj->BaseLevel);
_mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, obj->MaxLevel);
if (target != GL_TEXTURE_RECTANGLE_ARB)
_mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, obj->MaxLevel);
if (ctx->Extensions.EXT_texture_filter_anisotropic) {
_mesa_TexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
obj->MaxAnisotropy);

View File

@@ -300,6 +300,7 @@
#define FEATURE_ARB_fragment_shader _HAVE_FULL_GL
#define FEATURE_ARB_shader_objects (FEATURE_ARB_vertex_shader || FEATURE_ARB_fragment_shader)
#define FEATURE_ARB_shading_language_100 FEATURE_ARB_shader_objects
#define FEATURE_ARB_shading_language_120 FEATURE_ARB_shader_objects
#define FEATURE_EXT_framebuffer_blit _HAVE_FULL_GL
#define FEATURE_EXT_framebuffer_object _HAVE_FULL_GL

Some files were not shown because too many files have changed in this diff Show More