tree builds
This commit is contained in:
Alan Hourihane
parent
47ad296a18
commit
5835d7e573
|
|
@ -50,23 +50,7 @@
|
|||
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
|
||||
#include <dix-config.h>
|
||||
#define PUBLIC
|
||||
|
||||
#else
|
||||
|
||||
#include "main/glheader.h"
|
||||
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifdef DEBUG
|
||||
#include <assert.h>
|
||||
#endif
|
||||
|
||||
#include "glapi.h"
|
||||
#include "glapioffsets.h"
|
||||
#include "glapitable.h"
|
||||
|
|
@ -388,450 +372,6 @@ _glapi_get_dispatch(void)
|
|||
#define DISPATCH_TABLE_SIZE (sizeof(struct _glapi_table) / sizeof(void *) + MAX_EXTENSION_FUNCS)
|
||||
|
||||
|
||||
/**
|
||||
* Track information about a function added to the GL API.
|
||||
*/
|
||||
struct _glapi_function {
|
||||
/**
|
||||
* Name of the function.
|
||||
*/
|
||||
const char * name;
|
||||
|
||||
|
||||
/**
|
||||
* Text string that describes the types of the parameters passed to the
|
||||
* named function. Parameter types are converted to characters using the
|
||||
* following rules:
|
||||
* - 'i' for \c GLint, \c GLuint, and \c GLenum
|
||||
* - 'p' for any pointer type
|
||||
* - 'f' for \c GLfloat and \c GLclampf
|
||||
* - 'd' for \c GLdouble and \c GLclampd
|
||||
*/
|
||||
const char * parameter_signature;
|
||||
|
||||
|
||||
/**
|
||||
* Offset in the dispatch table where the pointer to the real function is
|
||||
* located. If the driver has not requested that the named function be
|
||||
* added to the dispatch table, this will have the value ~0.
|
||||
*/
|
||||
unsigned dispatch_offset;
|
||||
|
||||
|
||||
/**
|
||||
* Pointer to the dispatch stub for the named function.
|
||||
*
|
||||
* \todo
|
||||
* The semantic of this field should be changed slightly. Currently, it
|
||||
* is always expected to be non-\c NULL. However, it would be better to
|
||||
* only allocate the entry-point stub when the application requests the
|
||||
* function via \c glXGetProcAddress. This would save memory for all the
|
||||
* functions that the driver exports but that the application never wants
|
||||
* to call.
|
||||
*/
|
||||
_glapi_proc dispatch_stub;
|
||||
};
|
||||
|
||||
|
||||
static struct _glapi_function ExtEntryTable[MAX_EXTENSION_FUNCS];
|
||||
static GLuint NumExtEntryPoints = 0;
|
||||
|
||||
#ifdef USE_SPARC_ASM
|
||||
extern void __glapi_sparc_icache_flush(unsigned int *);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Generate a dispatch function (entrypoint) which jumps through
|
||||
* the given slot number (offset) in the current dispatch table.
|
||||
* We need assembly language in order to accomplish this.
|
||||
*/
|
||||
static _glapi_proc
|
||||
generate_entrypoint(GLuint functionOffset)
|
||||
{
|
||||
#if defined(USE_X86_ASM)
|
||||
/* 32 is chosen as something of a magic offset. For x86, the dispatch
|
||||
* at offset 32 is the first one where the offset in the
|
||||
* "jmp OFFSET*4(%eax)" can't be encoded in a single byte.
|
||||
*/
|
||||
const GLubyte * const template_func = gl_dispatch_functions_start
|
||||
+ (DISPATCH_FUNCTION_SIZE * 32);
|
||||
GLubyte * const code = (GLubyte *) malloc(DISPATCH_FUNCTION_SIZE);
|
||||
|
||||
|
||||
if ( code != NULL ) {
|
||||
(void) memcpy(code, template_func, DISPATCH_FUNCTION_SIZE);
|
||||
fill_in_entrypoint_offset( (_glapi_proc) code, functionOffset );
|
||||
}
|
||||
|
||||
return (_glapi_proc) code;
|
||||
#elif defined(USE_SPARC_ASM)
|
||||
|
||||
#ifdef __arch64__
|
||||
static const unsigned int insn_template[] = {
|
||||
0x05000000, /* sethi %uhi(_glapi_Dispatch), %g2 */
|
||||
0x03000000, /* sethi %hi(_glapi_Dispatch), %g1 */
|
||||
0x8410a000, /* or %g2, %ulo(_glapi_Dispatch), %g2 */
|
||||
0x82106000, /* or %g1, %lo(_glapi_Dispatch), %g1 */
|
||||
0x8528b020, /* sllx %g2, 32, %g2 */
|
||||
0xc2584002, /* ldx [%g1 + %g2], %g1 */
|
||||
0x05000000, /* sethi %hi(8 * glapioffset), %g2 */
|
||||
0x8410a000, /* or %g2, %lo(8 * glapioffset), %g2 */
|
||||
0xc6584002, /* ldx [%g1 + %g2], %g3 */
|
||||
0x81c0c000, /* jmpl %g3, %g0 */
|
||||
0x01000000 /* nop */
|
||||
};
|
||||
#else
|
||||
static const unsigned int insn_template[] = {
|
||||
0x03000000, /* sethi %hi(_glapi_Dispatch), %g1 */
|
||||
0xc2006000, /* ld [%g1 + %lo(_glapi_Dispatch)], %g1 */
|
||||
0xc6006000, /* ld [%g1 + %lo(4*glapioffset)], %g3 */
|
||||
0x81c0c000, /* jmpl %g3, %g0 */
|
||||
0x01000000 /* nop */
|
||||
};
|
||||
#endif /* __arch64__ */
|
||||
unsigned int *code = (unsigned int *) malloc(sizeof(insn_template));
|
||||
unsigned long glapi_addr = (unsigned long) &_glapi_Dispatch;
|
||||
if (code) {
|
||||
memcpy(code, insn_template, sizeof(insn_template));
|
||||
|
||||
#ifdef __arch64__
|
||||
code[0] |= (glapi_addr >> (32 + 10));
|
||||
code[1] |= ((glapi_addr & 0xffffffff) >> 10);
|
||||
__glapi_sparc_icache_flush(&code[0]);
|
||||
code[2] |= ((glapi_addr >> 32) & ((1 << 10) - 1));
|
||||
code[3] |= (glapi_addr & ((1 << 10) - 1));
|
||||
__glapi_sparc_icache_flush(&code[2]);
|
||||
code[6] |= ((functionOffset * 8) >> 10);
|
||||
code[7] |= ((functionOffset * 8) & ((1 << 10) - 1));
|
||||
__glapi_sparc_icache_flush(&code[6]);
|
||||
#else
|
||||
code[0] |= (glapi_addr >> 10);
|
||||
code[1] |= (glapi_addr & ((1 << 10) - 1));
|
||||
__glapi_sparc_icache_flush(&code[0]);
|
||||
code[2] |= (functionOffset * 4);
|
||||
__glapi_sparc_icache_flush(&code[2]);
|
||||
#endif /* __arch64__ */
|
||||
}
|
||||
return (_glapi_proc) code;
|
||||
#else
|
||||
(void) functionOffset;
|
||||
return NULL;
|
||||
#endif /* USE_*_ASM */
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* This function inserts a new dispatch offset into the assembly language
|
||||
* stub that was generated with the preceeding function.
|
||||
*/
|
||||
static void
|
||||
fill_in_entrypoint_offset(_glapi_proc entrypoint, GLuint offset)
|
||||
{
|
||||
#if defined(USE_X86_ASM)
|
||||
GLubyte * const code = (GLubyte *) entrypoint;
|
||||
|
||||
#if DISPATCH_FUNCTION_SIZE == 32
|
||||
*((unsigned int *)(code + 11)) = 4 * offset;
|
||||
*((unsigned int *)(code + 22)) = 4 * offset;
|
||||
#elif DISPATCH_FUNCTION_SIZE == 16 && defined( GLX_USE_TLS )
|
||||
*((unsigned int *)(code + 8)) = 4 * offset;
|
||||
#elif DISPATCH_FUNCTION_SIZE == 16
|
||||
*((unsigned int *)(code + 7)) = 4 * offset;
|
||||
#else
|
||||
# error Invalid DISPATCH_FUNCTION_SIZE!
|
||||
#endif
|
||||
|
||||
#elif defined(USE_SPARC_ASM)
|
||||
|
||||
/* XXX this hasn't been tested! */
|
||||
unsigned int *code = (unsigned int *) entrypoint;
|
||||
#ifdef __arch64__
|
||||
code[6] = 0x05000000; /* sethi %hi(8 * glapioffset), %g2 */
|
||||
code[7] = 0x8410a000; /* or %g2, %lo(8 * glapioffset), %g2 */
|
||||
code[6] |= ((offset * 8) >> 10);
|
||||
code[7] |= ((offset * 8) & ((1 << 10) - 1));
|
||||
__glapi_sparc_icache_flush(&code[6]);
|
||||
#else /* __arch64__ */
|
||||
code[2] = 0xc6006000; /* ld [%g1 + %lo(4*glapioffset)], %g3 */
|
||||
code[2] |= (offset * 4);
|
||||
__glapi_sparc_icache_flush(&code[2]);
|
||||
#endif /* __arch64__ */
|
||||
|
||||
#else
|
||||
|
||||
/* an unimplemented architecture */
|
||||
(void) entrypoint;
|
||||
(void) offset;
|
||||
|
||||
#endif /* USE_*_ASM */
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Generate new entrypoint
|
||||
*
|
||||
* Use a temporary dispatch offset of ~0 (i.e. -1). Later, when the driver
|
||||
* calls \c _glapi_add_dispatch we'll put in the proper offset. If that
|
||||
* never happens, and the user calls this function, he'll segfault. That's
|
||||
* what you get when you try calling a GL function that doesn't really exist.
|
||||
*
|
||||
* \param funcName Name of the function to create an entry-point for.
|
||||
*
|
||||
* \sa _glapi_add_entrypoint
|
||||
*/
|
||||
|
||||
static struct _glapi_function *
|
||||
add_function_name( const char * funcName )
|
||||
{
|
||||
struct _glapi_function * entry = NULL;
|
||||
|
||||
if (NumExtEntryPoints < MAX_EXTENSION_FUNCS) {
|
||||
_glapi_proc entrypoint = generate_entrypoint(~0);
|
||||
if (entrypoint != NULL) {
|
||||
entry = & ExtEntryTable[NumExtEntryPoints];
|
||||
|
||||
ExtEntryTable[NumExtEntryPoints].name = str_dup(funcName);
|
||||
ExtEntryTable[NumExtEntryPoints].parameter_signature = NULL;
|
||||
ExtEntryTable[NumExtEntryPoints].dispatch_offset = ~0;
|
||||
ExtEntryTable[NumExtEntryPoints].dispatch_stub = entrypoint;
|
||||
NumExtEntryPoints++;
|
||||
}
|
||||
}
|
||||
|
||||
return entry;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Fill-in the dispatch stub for the named function.
|
||||
*
|
||||
* This function is intended to be called by a hardware driver. When called,
|
||||
* a dispatch stub may be created created for the function. A pointer to this
|
||||
* dispatch function will be returned by glXGetProcAddress.
|
||||
*
|
||||
* \param function_names Array of pointers to function names that should
|
||||
* share a common dispatch offset.
|
||||
* \param parameter_signature String representing the types of the parameters
|
||||
* passed to the named function. Parameter types
|
||||
* are converted to characters using the following
|
||||
* rules:
|
||||
* - 'i' for \c GLint, \c GLuint, and \c GLenum
|
||||
* - 'p' for any pointer type
|
||||
* - 'f' for \c GLfloat and \c GLclampf
|
||||
* - 'd' for \c GLdouble and \c GLclampd
|
||||
*
|
||||
* \returns
|
||||
* The offset in the dispatch table of the named function. A pointer to the
|
||||
* driver's implementation of the named function should be stored at
|
||||
* \c dispatch_table[\c offset]. Return -1 if error/problem.
|
||||
*
|
||||
* \sa glXGetProcAddress
|
||||
*
|
||||
* \warning
|
||||
* This function can only handle up to 8 names at a time. As far as I know,
|
||||
* the maximum number of names ever associated with an existing GL function is
|
||||
* 4 (\c glPointParameterfSGIS, \c glPointParameterfEXT,
|
||||
* \c glPointParameterfARB, and \c glPointParameterf), so this should not be
|
||||
* too painful of a limitation.
|
||||
*
|
||||
* \todo
|
||||
* Determine whether or not \c parameter_signature should be allowed to be
|
||||
* \c NULL. It doesn't seem like much of a hardship for drivers to have to
|
||||
* pass in an empty string.
|
||||
*
|
||||
* \todo
|
||||
* Determine if code should be added to reject function names that start with
|
||||
* 'glX'.
|
||||
*
|
||||
* \bug
|
||||
* Add code to compare \c parameter_signature with the parameter signature of
|
||||
* a static function. In order to do that, we need to find a way to \b get
|
||||
* the parameter signature of a static function.
|
||||
*/
|
||||
|
||||
PUBLIC int
|
||||
_glapi_add_dispatch( const char * const * function_names,
|
||||
const char * parameter_signature )
|
||||
{
|
||||
static int next_dynamic_offset = _gloffset_FIRST_DYNAMIC;
|
||||
const char * const real_sig = (parameter_signature != NULL)
|
||||
? parameter_signature : "";
|
||||
struct _glapi_function * entry[8];
|
||||
GLboolean is_static[8];
|
||||
unsigned i;
|
||||
unsigned j;
|
||||
int offset = ~0;
|
||||
int new_offset;
|
||||
|
||||
|
||||
(void) memset( is_static, 0, sizeof( is_static ) );
|
||||
(void) memset( entry, 0, sizeof( entry ) );
|
||||
|
||||
for ( i = 0 ; function_names[i] != NULL ; i++ ) {
|
||||
/* Do some trivial validation on the name of the function.
|
||||
*/
|
||||
|
||||
if (!function_names[i] || function_names[i][0] != 'g' || function_names[i][1] != 'l')
|
||||
return -1;
|
||||
|
||||
/* Determine if the named function already exists. If the function does
|
||||
* exist, it must have the same parameter signature as the function
|
||||
* being added.
|
||||
*/
|
||||
|
||||
new_offset = get_static_proc_offset(function_names[i]);
|
||||
if (new_offset >= 0) {
|
||||
/* FIXME: Make sure the parameter signatures match! How do we get
|
||||
* FIXME: the parameter signature for static functions?
|
||||
*/
|
||||
|
||||
if ( (offset != ~0) && (new_offset != offset) ) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
is_static[i] = GL_TRUE;
|
||||
offset = new_offset;
|
||||
}
|
||||
|
||||
|
||||
for ( j = 0 ; j < NumExtEntryPoints ; j++ ) {
|
||||
if (strcmp(ExtEntryTable[j].name, function_names[i]) == 0) {
|
||||
/* The offset may be ~0 if the function name was added by
|
||||
* glXGetProcAddress but never filled in by the driver.
|
||||
*/
|
||||
|
||||
if (ExtEntryTable[j].dispatch_offset != ~0) {
|
||||
if (strcmp(real_sig, ExtEntryTable[j].parameter_signature)
|
||||
!= 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ( (offset != ~0) && (ExtEntryTable[j].dispatch_offset != offset) ) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
offset = ExtEntryTable[j].dispatch_offset;
|
||||
}
|
||||
|
||||
entry[i] = & ExtEntryTable[j];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (offset == ~0) {
|
||||
offset = next_dynamic_offset;
|
||||
next_dynamic_offset++;
|
||||
}
|
||||
|
||||
for ( i = 0 ; function_names[i] != NULL ; i++ ) {
|
||||
if (! is_static[i] ) {
|
||||
if (entry[i] == NULL) {
|
||||
entry[i] = add_function_name( function_names[i] );
|
||||
if (entry[i] == NULL) {
|
||||
/* FIXME: Possible memory leak here.
|
||||
*/
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
entry[i]->parameter_signature = str_dup(real_sig);
|
||||
fill_in_entrypoint_offset(entry[i]->dispatch_stub, offset);
|
||||
entry[i]->dispatch_offset = offset;
|
||||
}
|
||||
}
|
||||
|
||||
return offset;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Return offset of entrypoint for named function within dispatch table.
|
||||
*/
|
||||
PUBLIC GLint
|
||||
_glapi_get_proc_offset(const char *funcName)
|
||||
{
|
||||
/* search extension functions first */
|
||||
GLuint i;
|
||||
for (i = 0; i < NumExtEntryPoints; i++) {
|
||||
if (strcmp(ExtEntryTable[i].name, funcName) == 0) {
|
||||
return ExtEntryTable[i].dispatch_offset;
|
||||
}
|
||||
}
|
||||
/* search static functions */
|
||||
return get_static_proc_offset(funcName);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Return pointer to the named function. If the function name isn't found
|
||||
* in the name of static functions, try generating a new API entrypoint on
|
||||
* the fly with assembly language.
|
||||
*/
|
||||
_glapi_proc
|
||||
_glapi_get_proc_address(const char *funcName)
|
||||
{
|
||||
struct _glapi_function * entry;
|
||||
GLuint i;
|
||||
|
||||
#ifdef MANGLE
|
||||
if (funcName[0] != 'm' || funcName[1] != 'g' || funcName[2] != 'l')
|
||||
return NULL;
|
||||
#else
|
||||
if (funcName[0] != 'g' || funcName[1] != 'l')
|
||||
return NULL;
|
||||
#endif
|
||||
|
||||
/* search extension functions first */
|
||||
for (i = 0; i < NumExtEntryPoints; i++) {
|
||||
if (strcmp(ExtEntryTable[i].name, funcName) == 0) {
|
||||
return ExtEntryTable[i].dispatch_stub;
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined( XFree86Server ) && !defined( XGLServer )
|
||||
/* search static functions */
|
||||
{
|
||||
const _glapi_proc func = get_static_proc_address(funcName);
|
||||
if (func)
|
||||
return func;
|
||||
}
|
||||
#endif /* !defined( XFree86Server ) */
|
||||
|
||||
entry = add_function_name(funcName);
|
||||
return (entry == NULL) ? NULL : entry->dispatch_stub;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Return the name of the function at the given dispatch offset.
|
||||
* This is only intended for debugging.
|
||||
*/
|
||||
const char *
|
||||
_glapi_get_proc_name(GLuint offset)
|
||||
{
|
||||
GLuint i;
|
||||
const char * n;
|
||||
|
||||
/* search built-in functions */
|
||||
n = get_static_proc_name(offset);
|
||||
if ( n != NULL ) {
|
||||
return n;
|
||||
}
|
||||
|
||||
/* search added extension functions */
|
||||
for (i = 0; i < NumExtEntryPoints; i++) {
|
||||
if (ExtEntryTable[i].dispatch_offset == offset) {
|
||||
return ExtEntryTable[i].name;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Return size of dispatch table struct as number of functions (or
|
||||
* slots).
|
||||
|
|
|
|||
|
|
@ -25,15 +25,11 @@
|
|||
|
||||
/*
|
||||
* XXX There's probably some work to do in order to make this file
|
||||
* truly reusable outside of Mesa.
|
||||
* truly reusable outside of Mesa. First, the glheader.h include must go.
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "main/glheader.h"
|
||||
#include "glthread.h"
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -299,11 +299,11 @@ typedef benaphore _glthread_Mutex;
|
|||
* THREADS not defined
|
||||
*/
|
||||
|
||||
typedef int _glthread_TSD;
|
||||
typedef GLuint _glthread_TSD;
|
||||
|
||||
typedef int _glthread_Thread;
|
||||
typedef GLuint _glthread_Thread;
|
||||
|
||||
typedef int _glthread_Mutex;
|
||||
typedef GLuint _glthread_Mutex;
|
||||
|
||||
#define _glthread_DECLARE_STATIC_MUTEX(name) static _glthread_Mutex name = 0
|
||||
|
||||
|
|
|
|||
|
|
@ -35,437 +35,6 @@
|
|||
#include "t_vp_build.h"
|
||||
|
||||
|
||||
struct state_key {
|
||||
unsigned light_global_enabled:1;
|
||||
unsigned light_local_viewer:1;
|
||||
unsigned light_twoside:1;
|
||||
unsigned light_color_material:1;
|
||||
unsigned light_color_material_mask:12;
|
||||
unsigned light_material_mask:12;
|
||||
|
||||
unsigned normalize:1;
|
||||
unsigned rescale_normals:1;
|
||||
unsigned fog_source_is_depth:1;
|
||||
unsigned tnl_do_vertex_fog:1;
|
||||
unsigned separate_specular:1;
|
||||
unsigned fog_mode:2;
|
||||
unsigned point_attenuated:1;
|
||||
unsigned texture_enabled_global:1;
|
||||
unsigned fragprog_inputs_read:12;
|
||||
|
||||
struct {
|
||||
unsigned light_enabled:1;
|
||||
unsigned light_eyepos3_is_zero:1;
|
||||
unsigned light_spotcutoff_is_180:1;
|
||||
unsigned light_attenuated:1;
|
||||
unsigned texunit_really_enabled:1;
|
||||
unsigned texmat_enabled:1;
|
||||
unsigned texgen_enabled:4;
|
||||
unsigned texgen_mode0:4;
|
||||
unsigned texgen_mode1:4;
|
||||
unsigned texgen_mode2:4;
|
||||
unsigned texgen_mode3:4;
|
||||
} unit[8];
|
||||
};
|
||||
|
||||
|
||||
|
||||
#define FOG_NONE 0
|
||||
#define FOG_LINEAR 1
|
||||
#define FOG_EXP 2
|
||||
#define FOG_EXP2 3
|
||||
|
||||
static GLuint translate_fog_mode( GLenum mode )
|
||||
{
|
||||
switch (mode) {
|
||||
case GL_LINEAR: return FOG_LINEAR;
|
||||
case GL_EXP: return FOG_EXP;
|
||||
case GL_EXP2: return FOG_EXP2;
|
||||
default: return FOG_NONE;
|
||||
}
|
||||
}
|
||||
|
||||
#define TXG_NONE 0
|
||||
#define TXG_OBJ_LINEAR 1
|
||||
#define TXG_EYE_LINEAR 2
|
||||
#define TXG_SPHERE_MAP 3
|
||||
#define TXG_REFLECTION_MAP 4
|
||||
#define TXG_NORMAL_MAP 5
|
||||
|
||||
static GLuint translate_texgen( GLboolean enabled, GLenum mode )
|
||||
{
|
||||
if (!enabled)
|
||||
return TXG_NONE;
|
||||
|
||||
switch (mode) {
|
||||
case GL_OBJECT_LINEAR: return TXG_OBJ_LINEAR;
|
||||
case GL_EYE_LINEAR: return TXG_EYE_LINEAR;
|
||||
case GL_SPHERE_MAP: return TXG_SPHERE_MAP;
|
||||
case GL_REFLECTION_MAP_NV: return TXG_REFLECTION_MAP;
|
||||
case GL_NORMAL_MAP_NV: return TXG_NORMAL_MAP;
|
||||
default: return TXG_NONE;
|
||||
}
|
||||
}
|
||||
|
||||
static struct state_key *make_state_key( GLcontext *ctx )
|
||||
{
|
||||
TNLcontext *tnl = TNL_CONTEXT(ctx);
|
||||
struct vertex_buffer *VB = &tnl->vb;
|
||||
const struct gl_fragment_program *fp = ctx->FragmentProgram._Current;
|
||||
struct state_key *key = CALLOC_STRUCT(state_key);
|
||||
GLuint i;
|
||||
|
||||
/* This now relies on texenvprogram.c being active:
|
||||
*/
|
||||
assert(fp);
|
||||
|
||||
key->fragprog_inputs_read = fp->Base.InputsRead;
|
||||
|
||||
key->separate_specular = (ctx->Light.Model.ColorControl ==
|
||||
GL_SEPARATE_SPECULAR_COLOR);
|
||||
|
||||
if (ctx->Light.Enabled) {
|
||||
key->light_global_enabled = 1;
|
||||
|
||||
if (ctx->Light.Model.LocalViewer)
|
||||
key->light_local_viewer = 1;
|
||||
|
||||
if (ctx->Light.Model.TwoSide)
|
||||
key->light_twoside = 1;
|
||||
|
||||
if (ctx->Light.ColorMaterialEnabled) {
|
||||
key->light_color_material = 1;
|
||||
key->light_color_material_mask = ctx->Light.ColorMaterialBitmask;
|
||||
}
|
||||
|
||||
for (i = _TNL_FIRST_MAT; i <= _TNL_LAST_MAT; i++)
|
||||
if (VB->AttribPtr[i]->stride)
|
||||
key->light_material_mask |= 1<<(i-_TNL_ATTRIB_MAT_FRONT_AMBIENT);
|
||||
|
||||
for (i = 0; i < MAX_LIGHTS; i++) {
|
||||
struct gl_light *light = &ctx->Light.Light[i];
|
||||
|
||||
if (light->Enabled) {
|
||||
key->unit[i].light_enabled = 1;
|
||||
|
||||
if (light->EyePosition[3] == 0.0)
|
||||
key->unit[i].light_eyepos3_is_zero = 1;
|
||||
|
||||
if (light->SpotCutoff == 180.0)
|
||||
key->unit[i].light_spotcutoff_is_180 = 1;
|
||||
|
||||
if (light->ConstantAttenuation != 1.0 ||
|
||||
light->LinearAttenuation != 0.0 ||
|
||||
light->QuadraticAttenuation != 0.0)
|
||||
key->unit[i].light_attenuated = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (ctx->Transform.Normalize)
|
||||
key->normalize = 1;
|
||||
|
||||
if (ctx->Transform.RescaleNormals)
|
||||
key->rescale_normals = 1;
|
||||
|
||||
key->fog_mode = translate_fog_mode(fp->FogOption);
|
||||
|
||||
if (ctx->Fog.FogCoordinateSource == GL_FRAGMENT_DEPTH_EXT)
|
||||
key->fog_source_is_depth = 1;
|
||||
|
||||
if (tnl->_DoVertexFog)
|
||||
key->tnl_do_vertex_fog = 1;
|
||||
|
||||
if (ctx->Point._Attenuated)
|
||||
key->point_attenuated = 1;
|
||||
|
||||
if (ctx->Texture._TexGenEnabled ||
|
||||
ctx->Texture._TexMatEnabled ||
|
||||
ctx->Texture._EnabledUnits)
|
||||
key->texture_enabled_global = 1;
|
||||
|
||||
for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
|
||||
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
|
||||
|
||||
if (texUnit->_ReallyEnabled)
|
||||
key->unit[i].texunit_really_enabled = 1;
|
||||
|
||||
if (ctx->Texture._TexMatEnabled & ENABLE_TEXMAT(i))
|
||||
key->unit[i].texmat_enabled = 1;
|
||||
|
||||
if (texUnit->TexGenEnabled) {
|
||||
key->unit[i].texgen_enabled = 1;
|
||||
|
||||
key->unit[i].texgen_mode0 =
|
||||
translate_texgen( texUnit->TexGenEnabled & (1<<0),
|
||||
texUnit->GenModeS );
|
||||
key->unit[i].texgen_mode1 =
|
||||
translate_texgen( texUnit->TexGenEnabled & (1<<1),
|
||||
texUnit->GenModeT );
|
||||
key->unit[i].texgen_mode2 =
|
||||
translate_texgen( texUnit->TexGenEnabled & (1<<2),
|
||||
texUnit->GenModeR );
|
||||
key->unit[i].texgen_mode3 =
|
||||
translate_texgen( texUnit->TexGenEnabled & (1<<3),
|
||||
texUnit->GenModeQ );
|
||||
}
|
||||
}
|
||||
|
||||
return key;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Very useful debugging tool - produces annotated listing of
|
||||
* generated program with line/function references for each
|
||||
* instruction back into this file:
|
||||
*/
|
||||
#define DISASSEM (MESA_VERBOSE&VERBOSE_DISASSEM)
|
||||
|
||||
/* Should be tunable by the driver - do we want to do matrix
|
||||
* multiplications with DP4's or with MUL/MAD's? SSE works better
|
||||
* with the latter, drivers may differ.
|
||||
*/
|
||||
#define PREFER_DP4 0
|
||||
|
||||
#define MAX_INSN 350
|
||||
|
||||
/* Use uregs to represent registers internally, translate to Mesa's
|
||||
* expected formats on emit.
|
||||
*
|
||||
* NOTE: These are passed by value extensively in this file rather
|
||||
* than as usual by pointer reference. If this disturbs you, try
|
||||
* remembering they are just 32bits in size.
|
||||
*
|
||||
* GCC is smart enough to deal with these dword-sized structures in
|
||||
* much the same way as if I had defined them as dwords and was using
|
||||
* macros to access and set the fields. This is much nicer and easier
|
||||
* to evolve.
|
||||
*/
|
||||
struct ureg {
|
||||
GLuint file:4;
|
||||
GLint idx:8; /* relative addressing may be negative */
|
||||
GLuint negate:1;
|
||||
GLuint swz:12;
|
||||
GLuint pad:7;
|
||||
};
|
||||
|
||||
|
||||
struct tnl_program {
|
||||
const struct state_key *state;
|
||||
struct gl_vertex_program *program;
|
||||
|
||||
GLuint temp_in_use;
|
||||
GLuint temp_reserved;
|
||||
|
||||
struct ureg eye_position;
|
||||
struct ureg eye_position_normalized;
|
||||
struct ureg eye_normal;
|
||||
struct ureg identity;
|
||||
|
||||
GLuint materials;
|
||||
GLuint color_materials;
|
||||
};
|
||||
|
||||
|
||||
static const struct ureg undef = {
|
||||
PROGRAM_UNDEFINED,
|
||||
~0,
|
||||
0,
|
||||
0,
|
||||
0
|
||||
};
|
||||
|
||||
/* Local shorthand:
|
||||
*/
|
||||
#define X SWIZZLE_X
|
||||
#define Y SWIZZLE_Y
|
||||
#define Z SWIZZLE_Z
|
||||
#define W SWIZZLE_W
|
||||
|
||||
|
||||
/* Construct a ureg:
|
||||
*/
|
||||
static struct ureg make_ureg(GLuint file, GLint idx)
|
||||
{
|
||||
struct ureg reg;
|
||||
reg.file = file;
|
||||
reg.idx = idx;
|
||||
reg.negate = 0;
|
||||
reg.swz = SWIZZLE_NOOP;
|
||||
reg.pad = 0;
|
||||
return reg;
|
||||
}
|
||||
|
||||
|
||||
|
||||
static struct ureg negate( struct ureg reg )
|
||||
{
|
||||
reg.negate ^= 1;
|
||||
return reg;
|
||||
}
|
||||
|
||||
|
||||
static struct ureg swizzle( struct ureg reg, int x, int y, int z, int w )
|
||||
{
|
||||
reg.swz = MAKE_SWIZZLE4(GET_SWZ(reg.swz, x),
|
||||
GET_SWZ(reg.swz, y),
|
||||
GET_SWZ(reg.swz, z),
|
||||
GET_SWZ(reg.swz, w));
|
||||
|
||||
return reg;
|
||||
}
|
||||
|
||||
static struct ureg swizzle1( struct ureg reg, int x )
|
||||
{
|
||||
return swizzle(reg, x, x, x, x);
|
||||
}
|
||||
|
||||
static struct ureg get_temp( struct tnl_program *p )
|
||||
{
|
||||
int bit = _mesa_ffs( ~p->temp_in_use );
|
||||
if (!bit) {
|
||||
_mesa_problem(NULL, "%s: out of temporaries\n", __FILE__);
|
||||
_mesa_exit(1);
|
||||
}
|
||||
|
||||
if ((GLuint) bit > p->program->Base.NumTemporaries)
|
||||
p->program->Base.NumTemporaries = bit;
|
||||
|
||||
p->temp_in_use |= 1<<(bit-1);
|
||||
return make_ureg(PROGRAM_TEMPORARY, bit-1);
|
||||
}
|
||||
|
||||
static struct ureg reserve_temp( struct tnl_program *p )
|
||||
{
|
||||
struct ureg temp = get_temp( p );
|
||||
p->temp_reserved |= 1<<temp.idx;
|
||||
return temp;
|
||||
}
|
||||
|
||||
static void release_temp( struct tnl_program *p, struct ureg reg )
|
||||
{
|
||||
if (reg.file == PROGRAM_TEMPORARY) {
|
||||
p->temp_in_use &= ~(1<<reg.idx);
|
||||
p->temp_in_use |= p->temp_reserved; /* can't release reserved temps */
|
||||
}
|
||||
}
|
||||
|
||||
static void release_temps( struct tnl_program *p )
|
||||
{
|
||||
p->temp_in_use = p->temp_reserved;
|
||||
}
|
||||
|
||||
|
||||
|
||||
static struct ureg register_input( struct tnl_program *p, GLuint input )
|
||||
{
|
||||
p->program->Base.InputsRead |= (1<<input);
|
||||
return make_ureg(PROGRAM_INPUT, input);
|
||||
}
|
||||
|
||||
static struct ureg register_output( struct tnl_program *p, GLuint output )
|
||||
{
|
||||
p->program->Base.OutputsWritten |= (1<<output);
|
||||
return make_ureg(PROGRAM_OUTPUT, output);
|
||||
}
|
||||
|
||||
static struct ureg register_const4f( struct tnl_program *p,
|
||||
GLfloat s0,
|
||||
GLfloat s1,
|
||||
GLfloat s2,
|
||||
GLfloat s3)
|
||||
{
|
||||
GLfloat values[4];
|
||||
GLint idx;
|
||||
GLuint swizzle;
|
||||
values[0] = s0;
|
||||
values[1] = s1;
|
||||
values[2] = s2;
|
||||
values[3] = s3;
|
||||
idx = _mesa_add_unnamed_constant( p->program->Base.Parameters, values, 4,
|
||||
&swizzle );
|
||||
ASSERT(swizzle == SWIZZLE_NOOP);
|
||||
return make_ureg(PROGRAM_STATE_VAR, idx);
|
||||
}
|
||||
|
||||
#define register_const1f(p, s0) register_const4f(p, s0, 0, 0, 1)
|
||||
#define register_scalar_const(p, s0) register_const4f(p, s0, s0, s0, s0)
|
||||
#define register_const2f(p, s0, s1) register_const4f(p, s0, s1, 0, 1)
|
||||
#define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)
|
||||
|
||||
static GLboolean is_undef( struct ureg reg )
|
||||
{
|
||||
return reg.file == PROGRAM_UNDEFINED;
|
||||
}
|
||||
|
||||
static struct ureg get_identity_param( struct tnl_program *p )
|
||||
{
|
||||
if (is_undef(p->identity))
|
||||
p->identity = register_const4f(p, 0,0,0,1);
|
||||
|
||||
return p->identity;
|
||||
}
|
||||
|
||||
static struct ureg register_param5(struct tnl_program *p,
|
||||
GLint s0,
|
||||
GLint s1,
|
||||
GLint s2,
|
||||
GLint s3,
|
||||
GLint s4)
|
||||
{
|
||||
gl_state_index tokens[STATE_LENGTH];
|
||||
GLint idx;
|
||||
tokens[0] = s0;
|
||||
tokens[1] = s1;
|
||||
tokens[2] = s2;
|
||||
tokens[3] = s3;
|
||||
tokens[4] = s4;
|
||||
idx = _mesa_add_state_reference( p->program->Base.Parameters, tokens );
|
||||
return make_ureg(PROGRAM_STATE_VAR, idx);
|
||||
}
|
||||
|
||||
|
||||
#define register_param1(p,s0) register_param5(p,s0,0,0,0,0)
|
||||
#define register_param2(p,s0,s1) register_param5(p,s0,s1,0,0,0)
|
||||
#define register_param3(p,s0,s1,s2) register_param5(p,s0,s1,s2,0,0)
|
||||
#define register_param4(p,s0,s1,s2,s3) register_param5(p,s0,s1,s2,s3,0)
|
||||
|
||||
|
||||
static void register_matrix_param5( struct tnl_program *p,
|
||||
GLint s0, /* modelview, projection, etc */
|
||||
GLint s1, /* texture matrix number */
|
||||
GLint s2, /* first row */
|
||||
GLint s3, /* last row */
|
||||
GLint s4, /* inverse, transpose, etc */
|
||||
struct ureg *matrix )
|
||||
{
|
||||
GLint i;
|
||||
|
||||
/* This is a bit sad as the support is there to pull the whole
|
||||
* matrix out in one go:
|
||||
*/
|
||||
for (i = 0; i <= s3 - s2; i++)
|
||||
matrix[i] = register_param5( p, s0, s1, i, i, s4 );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Convert a ureg source register to a prog_src_register.
|
||||
*/
|
||||
static void emit_arg( struct prog_src_register *src,
|
||||
struct ureg reg )
|
||||
{
|
||||
assert(reg.file != PROGRAM_OUTPUT);
|
||||
src->File = reg.file;
|
||||
src->Index = reg.idx;
|
||||
src->Swizzle = reg.swz;
|
||||
src->NegateBase = reg.negate ? NEGATE_XYZW : 0;
|
||||
src->Abs = 0;
|
||||
src->NegateAbs = 0;
|
||||
src->RelAddr = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* XXX This should go away someday, but still referenced by some drivers...
|
||||
*/
|
||||
|
|
@ -475,12 +44,9 @@ void _tnl_UpdateFixedFunctionProgram( GLcontext *ctx )
|
|||
|
||||
if (!ctx->VertexProgram._Current ||
|
||||
ctx->VertexProgram._Current == ctx->VertexProgram._TnlProgram) {
|
||||
struct gl_vertex_program *newProg;
|
||||
|
||||
newProg = _mesa_get_fixed_func_vertex_program(ctx);
|
||||
|
||||
_mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, newProg);
|
||||
_mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, newProg);
|
||||
ctx->VertexProgram._Current
|
||||
= ctx->VertexProgram._TnlProgram
|
||||
= _mesa_get_fixed_func_vertex_program(ctx);
|
||||
}
|
||||
|
||||
/* Tell the driver about the change. Could define a new target for
|
||||
|
|
|
|||
Loading…
Reference in New Issue