More GLSL code:
- add x86 code generator; - add full support for uniforms in ARB_shader_objects; - add assembly instruction: global_addr; - reorganize #includes; - built-in uniforms accessed by index, rather than by name; - add some entries to x86sse rtasm; - add configurations to VC6 projects: 'Release x86' and 'Debug x86'; - #define SLANG_X86 active only on VC6 x86 builds; - introduce code export table for a shader; - remove GNU license from the noise library;
This commit is contained in:
parent
c56f2c49a5
commit
9ac9605de1
|
@ -295,6 +295,17 @@ _mesa_sin(double a)
|
|||
#else
|
||||
return sin(a);
|
||||
#endif
|
||||
}
|
||||
|
||||
/** Single precision wrapper around either sin() or xf86sin() */
|
||||
float
|
||||
_mesa_sinf(float a)
|
||||
{
|
||||
#if defined(XFree86LOADER) && defined(IN_MODULE)
|
||||
return (float) xf86sin((double) a);
|
||||
#else
|
||||
return (float) sin((double) a);
|
||||
#endif
|
||||
}
|
||||
|
||||
/** Wrapper around either cos() or xf86cos() */
|
||||
|
|
|
@ -572,7 +572,29 @@ do { \
|
|||
_watcom_start_fast_math(&x,&mask); \
|
||||
} while (0)
|
||||
#endif
|
||||
#define END_FAST_MATH(x) _watcom_end_fast_math(&x)
|
||||
#define END_FAST_MATH(x) _watcom_end_fast_math(&x)
|
||||
|
||||
#elif defined(_MSC_VER) && defined(_M_IX86)
|
||||
#define DEFAULT_X86_FPU 0x037f /* See GCC comments above */
|
||||
#define FAST_X86_FPU 0x003f /* See GCC comments above */
|
||||
#if defined(NO_FAST_MATH)
|
||||
#define START_FAST_MATH(x) do {\
|
||||
static GLuint mask = DEFAULT_X86_FPU;\
|
||||
__asm fnstcw word ptr [x]\
|
||||
__asm fldcw word ptr [mask]\
|
||||
} while(0)
|
||||
#else
|
||||
#define START_FAST_MATH(x) do {\
|
||||
static GLuint mask = FAST_X86_FPU;\
|
||||
__asm fnstcw word ptr [x]\
|
||||
__asm fldcw word ptr [mask]\
|
||||
} while(0)
|
||||
#endif
|
||||
#define END_FAST_MATH(x) do {\
|
||||
__asm fnclex\
|
||||
__asm fldcw word ptr [x]\
|
||||
} while(0)
|
||||
|
||||
#else
|
||||
#define START_FAST_MATH(x) x = 0
|
||||
#define END_FAST_MATH(x) (void)(x)
|
||||
|
@ -627,7 +649,10 @@ extern int
|
|||
_mesa_memcmp( const void *s1, const void *s2, size_t n );
|
||||
|
||||
extern double
|
||||
_mesa_sin(double a);
|
||||
_mesa_sin(double a);
|
||||
|
||||
extern float
|
||||
_mesa_sinf(float a);
|
||||
|
||||
extern double
|
||||
_mesa_cos(double a);
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -25,7 +25,7 @@
|
|||
#ifndef SHADEROBJECTS_H
|
||||
#define SHADEROBJECTS_H
|
||||
|
||||
#include "mtypes.h"
|
||||
#include "context.h"
|
||||
|
||||
/**
|
||||
* gl2 unique interface identifier.
|
||||
|
@ -85,7 +85,12 @@ struct gl2_program_intf
|
|||
GLboolean (* GetLinkStatus) (struct gl2_program_intf **);
|
||||
GLboolean (* GetValidateStatus) (struct gl2_program_intf **);
|
||||
GLvoid (* Link) (struct gl2_program_intf **);
|
||||
GLvoid (* Validate) (struct gl2_program_intf **);
|
||||
GLvoid (* Validate) (struct gl2_program_intf **);
|
||||
GLvoid (* UpdateFixedUniforms) (struct gl2_program_intf **);
|
||||
GLvoid (* UpdateFixedAttribute) (struct gl2_program_intf **, GLuint, GLvoid *, GLuint, GLuint,
|
||||
GLboolean);
|
||||
GLvoid (* UpdateFixedVarying) (struct gl2_program_intf **, GLuint, GLvoid *, GLuint, GLuint,
|
||||
GLboolean);
|
||||
};
|
||||
|
||||
struct gl2_fragment_shader_intf
|
||||
|
|
|
@ -31,19 +31,14 @@
|
|||
/* Set this to 1 when we are ready to use 3dlabs' front-end */
|
||||
#define USE_3DLABS_FRONTEND 0
|
||||
|
||||
#include "glheader.h"
|
||||
#include "shaderobjects.h"
|
||||
#include "shaderobjects_3dlabs.h"
|
||||
#include "context.h"
|
||||
#include "macros.h"
|
||||
#include "imports.h"
|
||||
#include "hash.h"
|
||||
#include "shaderobjects.h"
|
||||
|
||||
#if USE_3DLABS_FRONTEND
|
||||
#include "slang_mesa.h"
|
||||
#include "Public/ShaderLang.h"
|
||||
#else
|
||||
#include "slang_utility.h"
|
||||
#include "slang_compile.h"
|
||||
#include "slang_link.h"
|
||||
#endif
|
||||
|
||||
|
@ -840,6 +835,164 @@ _program_Validate (struct gl2_program_intf **intf)
|
|||
/* TODO validate */
|
||||
}
|
||||
|
||||
static GLvoid
|
||||
write_common_fixed (slang_program *pro, GLuint index, const GLvoid *src, GLuint off, GLuint size)
|
||||
{
|
||||
GLuint i;
|
||||
|
||||
for (i = 0; i < SLANG_UNIFORM_BINDING_MAX; i++)
|
||||
{
|
||||
GLuint addr;
|
||||
|
||||
addr = pro->common_fixed_entries[i][index];
|
||||
if (addr != ~0)
|
||||
{
|
||||
GLubyte *dst;
|
||||
|
||||
dst = (GLubyte *) pro->machines[i]->mem + addr + off * size;
|
||||
_mesa_memcpy (dst, src, size);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static GLvoid
|
||||
write_common_fixed_mat4 (slang_program *pro, GLmatrix *matrix, GLuint off, GLuint i, GLuint ii,
|
||||
GLuint it, GLuint iit)
|
||||
{
|
||||
GLfloat mat[16];
|
||||
|
||||
/* we want inverse matrix */
|
||||
if (!matrix->inv)
|
||||
{
|
||||
/* allocate inverse matrix and make it dirty */
|
||||
_math_matrix_alloc_inv (matrix);
|
||||
_math_matrix_loadf (matrix, matrix->m);
|
||||
}
|
||||
_math_matrix_analyse (matrix);
|
||||
|
||||
write_common_fixed (pro, i, matrix->m, off, 16 * sizeof (GLfloat));
|
||||
|
||||
/* inverse */
|
||||
write_common_fixed (pro, ii, matrix->inv, off, 16 * sizeof (GLfloat));
|
||||
|
||||
/* transpose */
|
||||
_math_transposef (mat, matrix->m);
|
||||
write_common_fixed (pro, it, mat, off, 16 * sizeof (GLfloat));
|
||||
|
||||
/* inverse transpose */
|
||||
_math_transposef (mat, matrix->inv);
|
||||
write_common_fixed (pro, iit, mat, off, 16 * sizeof (GLfloat));
|
||||
}
|
||||
|
||||
static GLvoid
|
||||
_program_UpdateFixedUniforms (struct gl2_program_intf **intf)
|
||||
{
|
||||
GET_CURRENT_CONTEXT(ctx);
|
||||
struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
|
||||
slang_program *pro = &impl->_obj.prog;
|
||||
GLuint i;
|
||||
GLfloat v[9];
|
||||
GLfloat *p;
|
||||
|
||||
/* MODELVIEW matrix */
|
||||
write_common_fixed_mat4 (pro, ctx->ModelviewMatrixStack.Top, 0,
|
||||
SLANG_COMMON_FIXED_MODELVIEWMATRIX,
|
||||
SLANG_COMMON_FIXED_MODELVIEWMATRIXINVERSE,
|
||||
SLANG_COMMON_FIXED_MODELVIEWMATRIXTRANSPOSE,
|
||||
SLANG_COMMON_FIXED_MODELVIEWMATRIXINVERSETRANSPOSE);
|
||||
|
||||
/* PROJECTION matrix */
|
||||
write_common_fixed_mat4 (pro, ctx->ProjectionMatrixStack.Top, 0,
|
||||
SLANG_COMMON_FIXED_PROJECTIONMATRIX,
|
||||
SLANG_COMMON_FIXED_PROJECTIONMATRIXINVERSE,
|
||||
SLANG_COMMON_FIXED_PROJECTIONMATRIXTRANSPOSE,
|
||||
SLANG_COMMON_FIXED_PROJECTIONMATRIXINVERSETRANSPOSE);
|
||||
|
||||
/* MVP matrix */
|
||||
write_common_fixed_mat4 (pro, &ctx->_ModelProjectMatrix, 0,
|
||||
SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIX,
|
||||
SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXINVERSE,
|
||||
SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXTRANSPOSE,
|
||||
SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXINVERSETRANSPOSE);
|
||||
|
||||
/* TEXTURE matrix */
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
write_common_fixed_mat4 (pro, ctx->TextureMatrixStack[i].Top, i,
|
||||
SLANG_COMMON_FIXED_TEXTUREMATRIX,
|
||||
SLANG_COMMON_FIXED_TEXTUREMATRIXINVERSE,
|
||||
SLANG_COMMON_FIXED_TEXTUREMATRIXTRANSPOSE,
|
||||
SLANG_COMMON_FIXED_TEXTUREMATRIXINVERSETRANSPOSE);
|
||||
}
|
||||
|
||||
/* NORMAL matrix - upper 3x3 inverse transpose of MODELVIEW matrix */
|
||||
p = ctx->ModelviewMatrixStack.Top->inv;
|
||||
v[0] = p[0];
|
||||
v[1] = p[4];
|
||||
v[2] = p[8];
|
||||
v[3] = p[1];
|
||||
v[4] = p[5];
|
||||
v[5] = p[9];
|
||||
v[6] = p[2];
|
||||
v[7] = p[6];
|
||||
v[8] = p[10];
|
||||
write_common_fixed (pro, SLANG_COMMON_FIXED_NORMALMATRIX, v, 0, 9 * sizeof (GLfloat));
|
||||
|
||||
/* XXX: fetch uniform float gl_NormalScale */
|
||||
/* XXX: fetch uniform mat4 gl_ClipPlane */
|
||||
/* XXX: fetch uniform mat4 gl_TextureEnvColor */
|
||||
/* XXX: fetch uniform mat4 gl_EyePlaneS */
|
||||
/* XXX: fetch uniform mat4 gl_EyePlaneT */
|
||||
/* XXX: fetch uniform mat4 gl_EyePlaneR */
|
||||
/* XXX: fetch uniform mat4 gl_EyePlaneQ */
|
||||
/* XXX: fetch uniform mat4 gl_ObjectPlaneS */
|
||||
/* XXX: fetch uniform mat4 gl_ObjectPlaneT */
|
||||
/* XXX: fetch uniform mat4 gl_ObjectPlaneR */
|
||||
/* XXX: fetch uniform mat4 gl_ObjectPlaneQ */
|
||||
}
|
||||
|
||||
static GLvoid
|
||||
_program_UpdateFixedAttribute (struct gl2_program_intf **intf, GLuint index, GLvoid *data,
|
||||
GLuint offset, GLuint size, GLboolean write)
|
||||
{
|
||||
struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
|
||||
slang_program *pro = &impl->_obj.prog;
|
||||
GLuint addr;
|
||||
|
||||
addr = pro->vertex_fixed_entries[index];
|
||||
if (addr != ~0)
|
||||
{
|
||||
GLubyte *mem;
|
||||
|
||||
mem = (GLubyte *) pro->machines[SLANG_UNIFORM_BINDING_VERTEX]->mem + addr + offset * size;
|
||||
if (write)
|
||||
_mesa_memcpy (mem, data, size);
|
||||
else
|
||||
_mesa_memcpy (data, mem, size);
|
||||
}
|
||||
}
|
||||
|
||||
static GLvoid
|
||||
_program_UpdateFixedVarying (struct gl2_program_intf **intf, GLuint index, GLvoid *data,
|
||||
GLuint offset, GLuint size, GLboolean write)
|
||||
{
|
||||
struct gl2_program_impl *impl = (struct gl2_program_impl *) intf;
|
||||
slang_program *pro = &impl->_obj.prog;
|
||||
GLuint addr;
|
||||
|
||||
addr = pro->fragment_fixed_entries[index];
|
||||
if (addr != ~0)
|
||||
{
|
||||
GLubyte *mem;
|
||||
|
||||
mem = (GLubyte *) pro->machines[SLANG_UNIFORM_BINDING_FRAGMENT]->mem + addr + offset * size;
|
||||
if (write)
|
||||
_mesa_memcpy (mem, data, size);
|
||||
else
|
||||
_mesa_memcpy (data, mem, size);
|
||||
}
|
||||
}
|
||||
|
||||
static struct gl2_program_intf _program_vftbl = {
|
||||
{
|
||||
{
|
||||
|
@ -862,7 +1015,10 @@ static struct gl2_program_intf _program_vftbl = {
|
|||
_program_GetLinkStatus,
|
||||
_program_GetValidateStatus,
|
||||
_program_Link,
|
||||
_program_Validate
|
||||
_program_Validate,
|
||||
_program_UpdateFixedUniforms,
|
||||
_program_UpdateFixedAttribute,
|
||||
_program_UpdateFixedVarying
|
||||
};
|
||||
|
||||
static void
|
||||
|
@ -1076,195 +1232,37 @@ _mesa_3dlabs_create_program_object (void)
|
|||
#include "slang_assemble.h"
|
||||
#include "slang_execute.h"
|
||||
|
||||
static GLubyte *get_address_of (struct gl2_vertex_shader_intf **vs, const char *name)
|
||||
int _slang_fetch_discard (struct gl2_program_intf **pro, GLboolean *val)
|
||||
{
|
||||
struct gl2_vertex_shader_impl *impl;
|
||||
slang_translation_unit *unit;
|
||||
slang_atom atom;
|
||||
slang_variable *var;
|
||||
struct gl2_program_impl *impl;
|
||||
|
||||
impl = (struct gl2_vertex_shader_impl *) vs;
|
||||
unit = &impl->_obj._shader.unit;
|
||||
atom = slang_atom_pool_atom (unit->atom_pool, name);
|
||||
var = _slang_locate_variable (&unit->globals, atom, 1);
|
||||
if (var == NULL || var->address == ~0)
|
||||
return NULL;
|
||||
return (GLubyte *) unit->machine->mem + var->address;
|
||||
}
|
||||
|
||||
static GLubyte *get_address_of_f (struct gl2_fragment_shader_intf **fs, const char *name)
|
||||
{
|
||||
struct gl2_fragment_shader_impl *impl;
|
||||
slang_translation_unit *unit;
|
||||
slang_atom atom;
|
||||
slang_variable *var;
|
||||
|
||||
impl = (struct gl2_fragment_shader_impl *) fs;
|
||||
unit = &impl->_obj._shader.unit;
|
||||
atom = slang_atom_pool_atom (unit->atom_pool, name);
|
||||
var = _slang_locate_variable (&unit->globals, atom, 1);
|
||||
if (var == NULL || var->address == ~0)
|
||||
return NULL;
|
||||
return (GLubyte *) unit->machine->mem + var->address;
|
||||
}
|
||||
|
||||
static int fetch_mem (struct gl2_vertex_shader_intf **vs, const char *name, GLvoid *val,
|
||||
GLuint size, GLuint index, int write)
|
||||
{
|
||||
GLubyte *data;
|
||||
|
||||
data = get_address_of (vs, name);
|
||||
if (data == NULL)
|
||||
return 0;
|
||||
if (write)
|
||||
_mesa_memcpy (data + index * size, val, size);
|
||||
else
|
||||
_mesa_memcpy (val, data + index * size, size);
|
||||
impl = (struct gl2_program_impl *) pro;
|
||||
*val = impl->_obj.prog.machines[SLANG_UNIFORM_BINDING_FRAGMENT]->kill ? GL_TRUE : GL_FALSE;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int fetch_mem_f (struct gl2_fragment_shader_intf **fs, const char *name, GLvoid *val,
|
||||
GLuint size, GLuint index, int write)
|
||||
static GLvoid exec_shader (struct gl2_program_intf **pro, GLuint i)
|
||||
{
|
||||
GLubyte *data;
|
||||
struct gl2_program_impl *impl;
|
||||
slang_program *p;
|
||||
|
||||
data = get_address_of_f (fs, name);
|
||||
if (data == NULL)
|
||||
return 0;
|
||||
if (write)
|
||||
_mesa_memcpy (data + index * size, val, size);
|
||||
else
|
||||
_mesa_memcpy (val, data + index * size, size);
|
||||
return 1;
|
||||
impl = (struct gl2_program_impl *) pro;
|
||||
p = &impl->_obj.prog;
|
||||
|
||||
slang_machine_init (p->machines[i]);
|
||||
p->machines[i]->ip = p->code[i];
|
||||
|
||||
_slang_execute2 (p->assemblies[i], p->machines[i]);
|
||||
}
|
||||
|
||||
int _slang_fetch_float (struct gl2_vertex_shader_intf **vs, const char *name, GLfloat *val, int write)
|
||||
GLvoid _slang_exec_fragment_shader (struct gl2_program_intf **pro)
|
||||
{
|
||||
return fetch_mem (vs, name, val, 4, 0, write);
|
||||
exec_shader (pro, SLANG_UNIFORM_BINDING_FRAGMENT);
|
||||
}
|
||||
|
||||
int _slang_fetch_vec3 (struct gl2_vertex_shader_intf **vs, const char *name, GLfloat *val, int write)
|
||||
GLvoid _slang_exec_vertex_shader (struct gl2_program_intf **pro)
|
||||
{
|
||||
return fetch_mem (vs, name, val, 12, 0, write);
|
||||
}
|
||||
|
||||
int _slang_fetch_vec4 (struct gl2_vertex_shader_intf **vs, const char *name, GLfloat *val,
|
||||
GLuint index, int write)
|
||||
{
|
||||
return fetch_mem (vs, name, val, 16, index, write);
|
||||
}
|
||||
|
||||
int _slang_fetch_vec4_f (struct gl2_fragment_shader_intf **fs, const char *name, GLfloat *val,
|
||||
GLuint index, int write)
|
||||
{
|
||||
return fetch_mem_f (fs, name, val, 16, index, write);
|
||||
}
|
||||
|
||||
int _slang_fetch_mat3 (struct gl2_vertex_shader_intf **vs, const char *name, GLfloat *val,
|
||||
GLuint index, int write)
|
||||
{
|
||||
return fetch_mem (vs, name, val, 36, index, write);
|
||||
}
|
||||
|
||||
int _slang_fetch_mat4 (struct gl2_vertex_shader_intf **vs, const char *name, GLfloat *val,
|
||||
GLuint index, int write)
|
||||
{
|
||||
return fetch_mem (vs, name, val, 64, index, write);
|
||||
}
|
||||
|
||||
int _slang_fetch_discard (struct gl2_fragment_shader_intf **fs, GLboolean *val)
|
||||
{
|
||||
struct gl2_fragment_shader_impl *impl;
|
||||
slang_translation_unit *unit;
|
||||
|
||||
impl = (struct gl2_fragment_shader_impl *) fs;
|
||||
unit = &impl->_obj._shader.unit;
|
||||
*val = unit->machine->kill ? GL_TRUE : GL_FALSE;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void _slang_exec_vertex_shader (struct gl2_vertex_shader_intf **vs)
|
||||
{
|
||||
struct gl2_vertex_shader_impl *impl;
|
||||
slang_translation_unit *unit;
|
||||
slang_atom atom;
|
||||
unsigned int i;
|
||||
|
||||
impl = (struct gl2_vertex_shader_impl *) vs;
|
||||
unit = &impl->_obj._shader.unit;
|
||||
atom = slang_atom_pool_atom (unit->atom_pool, "main");
|
||||
for (i = 0; i < unit->functions.num_functions; i++)
|
||||
if (atom == unit->functions.functions[i].header.a_name)
|
||||
break;
|
||||
if (i < unit->functions.num_functions)
|
||||
{
|
||||
slang_function *f;
|
||||
slang_assembly_file_restore_point point;
|
||||
slang_assemble_ctx A;
|
||||
|
||||
f = &unit->functions.functions[i];
|
||||
slang_assembly_file_restore_point_save (unit->assembly, &point);
|
||||
|
||||
slang_machine_init (unit->machine);
|
||||
unit->machine->ip = unit->assembly->count;
|
||||
|
||||
A.file = unit->assembly;
|
||||
A.mach = unit->machine;
|
||||
A.atoms = unit->atom_pool;
|
||||
A.space.funcs = &unit->functions;
|
||||
A.space.structs = &unit->structs;
|
||||
A.space.vars = &unit->globals;
|
||||
slang_assembly_file_push_label (unit->assembly, slang_asm_local_alloc, 20);
|
||||
slang_assembly_file_push_label (unit->assembly, slang_asm_enter, 20);
|
||||
_slang_assemble_function_call (&A, f, NULL, 0, GL_FALSE);
|
||||
slang_assembly_file_push (unit->assembly, slang_asm_exit);
|
||||
|
||||
_slang_execute2 (unit->assembly, unit->machine);
|
||||
|
||||
slang_assembly_file_restore_point_load (unit->assembly, &point);
|
||||
}
|
||||
}
|
||||
|
||||
void _slang_exec_fragment_shader (struct gl2_fragment_shader_intf **fs)
|
||||
{
|
||||
struct gl2_fragment_shader_impl *impl;
|
||||
slang_translation_unit *unit;
|
||||
slang_atom atom;
|
||||
unsigned int i;
|
||||
|
||||
impl = (struct gl2_fragment_shader_impl *) fs;
|
||||
unit = &impl->_obj._shader.unit;
|
||||
atom = slang_atom_pool_atom (unit->atom_pool, "main");
|
||||
for (i = 0; i < unit->functions.num_functions; i++)
|
||||
if (atom == unit->functions.functions[i].header.a_name)
|
||||
break;
|
||||
if (i < unit->functions.num_functions)
|
||||
{
|
||||
slang_function *f;
|
||||
slang_assembly_file_restore_point point;
|
||||
slang_assemble_ctx A;
|
||||
|
||||
f = &unit->functions.functions[i];
|
||||
slang_assembly_file_restore_point_save (unit->assembly, &point);
|
||||
|
||||
slang_machine_init (unit->machine);
|
||||
unit->machine->ip = unit->assembly->count;
|
||||
|
||||
A.file = unit->assembly;
|
||||
A.mach = unit->machine;
|
||||
A.atoms = unit->atom_pool;
|
||||
A.space.funcs = &unit->functions;
|
||||
A.space.structs = &unit->structs;
|
||||
A.space.vars = &unit->globals;
|
||||
slang_assembly_file_push_label (unit->assembly, slang_asm_local_alloc, 20);
|
||||
slang_assembly_file_push_label (unit->assembly, slang_asm_enter, 20);
|
||||
_slang_assemble_function_call (&A, f, NULL, 0, GL_FALSE);
|
||||
slang_assembly_file_push (unit->assembly, slang_asm_exit);
|
||||
|
||||
_slang_execute2 (unit->assembly, unit->machine);
|
||||
|
||||
slang_assembly_file_restore_point_load (unit->assembly, &point);
|
||||
}
|
||||
exec_shader (pro, SLANG_UNIFORM_BINDING_VERTEX);
|
||||
}
|
||||
|
||||
GLint _slang_get_uniform_location (struct gl2_program_intf **pro, const char *name)
|
||||
|
@ -1312,6 +1310,53 @@ GLboolean _slang_write_uniform (struct gl2_program_intf **pro, GLint loc, GLsize
|
|||
return GL_TRUE;
|
||||
}
|
||||
|
||||
GLuint _slang_get_active_uniform_count (struct gl2_program_intf **pro)
|
||||
{
|
||||
struct gl2_program_impl *impl;
|
||||
|
||||
impl = (struct gl2_program_impl *) pro;
|
||||
return impl->_obj.prog.active_uniforms.count;
|
||||
}
|
||||
|
||||
GLuint _slang_get_active_uniform_max_length (struct gl2_program_intf **pro)
|
||||
{
|
||||
struct gl2_program_impl *impl;
|
||||
GLuint i, len = 0;
|
||||
|
||||
impl = (struct gl2_program_impl *) pro;
|
||||
for (i = 0; i < impl->_obj.prog.active_uniforms.count; i++)
|
||||
{
|
||||
GLuint n = _mesa_strlen (impl->_obj.prog.active_uniforms.table[i].name);
|
||||
if (n > len)
|
||||
len = n;
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
GLvoid _slang_get_active_uniform (struct gl2_program_intf **pro, GLuint index, GLsizei maxLength,
|
||||
GLsizei *length, GLint *size, GLenum *type, char *name)
|
||||
{
|
||||
struct gl2_program_impl *impl;
|
||||
slang_active_uniform *u;
|
||||
GLsizei len;
|
||||
|
||||
impl = (struct gl2_program_impl *) pro;
|
||||
u = &impl->_obj.prog.active_uniforms.table[index];
|
||||
|
||||
len = _mesa_strlen (u->name);
|
||||
if (len >= maxLength)
|
||||
len = maxLength - 1;
|
||||
_mesa_memcpy (name, u->name, len);
|
||||
name[len] = '\0';
|
||||
if (length != NULL)
|
||||
*length = len;
|
||||
*type = u->quant->u.basic_type;
|
||||
if (u->quant->array_len == 0)
|
||||
*size = 1;
|
||||
else
|
||||
*size = u->quant->array_len;
|
||||
}
|
||||
|
||||
void
|
||||
_mesa_init_shaderobjects_3dlabs (GLcontext *ctx)
|
||||
{
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
* Mesa 3-D graphics library
|
||||
* Version: 6.5
|
||||
*
|
||||
* Copyright (C) 2006 Brian Paul All Rights Reserved.
|
||||
* Copyright (C) 2005-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"),
|
||||
|
@ -25,37 +25,29 @@
|
|||
#ifndef SHADEROBJECTS_3DLABS_H
|
||||
#define SHADEROBJECTS_3DLABS_H
|
||||
|
||||
#include "mtypes.h"
|
||||
extern int _slang_fetch_discard (struct gl2_program_intf **pro, GLboolean *val);
|
||||
|
||||
extern GLvoid _slang_exec_fragment_shader (struct gl2_program_intf **pro);
|
||||
|
||||
extern int _slang_fetch_float(struct gl2_vertex_shader_intf **vs, const char *name, GLfloat *val, int write);
|
||||
extern GLvoid _slang_exec_vertex_shader (struct gl2_program_intf **pro);
|
||||
|
||||
extern int _slang_fetch_vec3(struct gl2_vertex_shader_intf **vs, const char *name, GLfloat *val, int write);
|
||||
extern GLint _slang_get_uniform_location (struct gl2_program_intf **pro, const char *name);
|
||||
|
||||
extern int _slang_fetch_vec4(struct gl2_vertex_shader_intf **vs, const char *name, GLfloat *val, GLuint index, int write);
|
||||
extern GLboolean _slang_write_uniform (struct gl2_program_intf **pro, GLint loc, GLsizei count,
|
||||
const GLvoid *data, GLenum type);
|
||||
|
||||
extern int _slang_fetch_vec4_f(struct gl2_fragment_shader_intf **fs, const char *name, GLfloat *val, GLuint index, int write);
|
||||
extern GLuint _slang_get_active_uniform_count (struct gl2_program_intf **pro);
|
||||
|
||||
extern int _slang_fetch_mat3(struct gl2_vertex_shader_intf **vs, const char *name, GLfloat *val, GLuint index, int write);
|
||||
|
||||
extern int _slang_fetch_mat4(struct gl2_vertex_shader_intf **vs, const char *name, GLfloat *val, GLuint index, int write);
|
||||
|
||||
extern int _slang_fetch_discard(struct gl2_fragment_shader_intf **fs, GLboolean *val);
|
||||
|
||||
extern GLint _slang_get_uniform_location(struct gl2_program_intf **pro, const char *name);
|
||||
|
||||
extern GLboolean _slang_write_uniform(struct gl2_program_intf **pro, GLint loc, GLsizei count, const GLvoid *data, GLenum type);
|
||||
|
||||
extern void _slang_exec_vertex_shader(struct gl2_vertex_shader_intf **vs);
|
||||
|
||||
extern void _slang_exec_fragment_shader(struct gl2_fragment_shader_intf **fs);
|
||||
extern GLuint _slang_get_active_uniform_max_length (struct gl2_program_intf **pro);
|
||||
|
||||
extern GLvoid _slang_get_active_uniform (struct gl2_program_intf **pro, GLuint index, GLsizei maxLength,
|
||||
GLsizei *length, GLint *size, GLenum *type, char *name);
|
||||
|
||||
extern GLhandleARB
|
||||
_mesa_3dlabs_create_shader_object (GLenum);
|
||||
|
||||
extern GLhandleARB
|
||||
_mesa_3dlabs_create_program_object (void);
|
||||
_mesa_3dlabs_create_program_object (GLvoid);
|
||||
|
||||
extern void
|
||||
_mesa_init_shaderobjects_3dlabs (GLcontext *ctx);
|
||||
|
|
|
@ -29,13 +29,9 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_assemble.h"
|
||||
#include "slang_compile.h"
|
||||
#include "slang_storage.h"
|
||||
#include "slang_assemble_typeinfo.h"
|
||||
#include "slang_assemble_conditional.h"
|
||||
#include "slang_assemble_assignment.h"
|
||||
#include "slang_execute.h"
|
||||
|
||||
/* slang_assembly */
|
||||
|
||||
|
@ -1138,7 +1134,7 @@ GLboolean _slang_assemble_operation (slang_assemble_ctx *A, slang_operation *op,
|
|||
/* push the variable's address */
|
||||
if (var->global)
|
||||
{
|
||||
if (!PLAB (A->file, slang_asm_addr_push, var->address))
|
||||
if (!PLAB (A->file, slang_asm_global_addr, var->address))
|
||||
return GL_FALSE;
|
||||
}
|
||||
else
|
||||
|
|
|
@ -25,7 +25,7 @@
|
|||
#if !defined SLANG_ASSEMBLE_H
|
||||
#define SLANG_ASSEMBLE_H
|
||||
|
||||
#include "slang_compile.h"
|
||||
#include "slang_utility.h"
|
||||
|
||||
#if defined __cplusplus
|
||||
extern "C" {
|
||||
|
@ -81,6 +81,7 @@ typedef enum slang_assembly_type_
|
|||
slang_asm_local_alloc,
|
||||
slang_asm_local_free,
|
||||
slang_asm_local_addr,
|
||||
slang_asm_global_addr,
|
||||
slang_asm_call,
|
||||
slang_asm_return,
|
||||
slang_asm_discard,
|
||||
|
@ -174,27 +175,33 @@ typedef struct slang_assemble_ctx_
|
|||
slang_swizzle swz;
|
||||
} slang_assemble_ctx;
|
||||
|
||||
slang_function *_slang_locate_function (slang_function_scope *funcs, slang_atom a_name,
|
||||
slang_operation *params, GLuint num_params, slang_assembly_name_space *space,
|
||||
struct slang_function_ *_slang_locate_function (struct slang_function_scope_ *funcs, slang_atom name,
|
||||
struct slang_operation_ *params, GLuint num_params, slang_assembly_name_space *space,
|
||||
slang_atom_pool *);
|
||||
|
||||
GLboolean _slang_assemble_function (slang_assemble_ctx *, struct slang_function_ *);
|
||||
|
||||
GLboolean _slang_cleanup_stack (slang_assemble_ctx *, slang_operation *);
|
||||
GLboolean _slang_cleanup_stack (slang_assemble_ctx *, struct slang_operation_ *);
|
||||
|
||||
GLboolean _slang_dereference (slang_assemble_ctx *, slang_operation *);
|
||||
GLboolean _slang_dereference (slang_assemble_ctx *, struct slang_operation_ *);
|
||||
|
||||
GLboolean _slang_assemble_function_call (slang_assemble_ctx *, slang_function *, slang_operation *,
|
||||
GLuint, GLboolean);
|
||||
GLboolean _slang_assemble_function_call (slang_assemble_ctx *, struct slang_function_ *,
|
||||
struct slang_operation_ *, GLuint, GLboolean);
|
||||
|
||||
GLboolean _slang_assemble_function_call_name (slang_assemble_ctx *, const char *, slang_operation *,
|
||||
GLuint, GLboolean);
|
||||
GLboolean _slang_assemble_function_call_name (slang_assemble_ctx *, const char *,
|
||||
struct slang_operation_ *, GLuint, GLboolean);
|
||||
|
||||
GLboolean _slang_assemble_operation (slang_assemble_ctx *, struct slang_operation_ *, slang_ref_type);
|
||||
GLboolean _slang_assemble_operation (slang_assemble_ctx *, struct slang_operation_ *,
|
||||
slang_ref_type);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include "slang_assemble_assignment.h"
|
||||
#include "slang_assemble_typeinfo.h"
|
||||
#include "slang_assemble_constructor.h"
|
||||
#include "slang_assemble_conditional.h"
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
@ -29,11 +29,8 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_assemble_assignment.h"
|
||||
#include "slang_assemble_typeinfo.h"
|
||||
#include "slang_assemble.h"
|
||||
#include "slang_storage.h"
|
||||
#include "slang_execute.h"
|
||||
|
||||
/*
|
||||
* _slang_assemble_assignment()
|
||||
|
|
|
@ -25,15 +25,13 @@
|
|||
#if !defined SLANG_ASSEMBLE_ASSIGNMENT_H
|
||||
#define SLANG_ASSEMBLE_ASSIGNMENT_H
|
||||
|
||||
#include "slang_assemble.h"
|
||||
|
||||
#if defined __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
GLboolean _slang_assemble_assignment (slang_assemble_ctx *, slang_operation *);
|
||||
GLboolean _slang_assemble_assignment (slang_assemble_ctx *, struct slang_operation_ *);
|
||||
|
||||
GLboolean _slang_assemble_assign (slang_assemble_ctx *, slang_operation *, const char *,
|
||||
GLboolean _slang_assemble_assign (slang_assemble_ctx *, struct slang_operation_ *, const char *,
|
||||
slang_ref_type);
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
|
|
@ -29,10 +29,8 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_assemble_conditional.h"
|
||||
#include "slang_assemble.h"
|
||||
#include "slang_execute.h"
|
||||
#include "slang_compile.h"
|
||||
|
||||
/*
|
||||
* _slang_assemble_logicaland()
|
||||
|
|
|
@ -25,25 +25,23 @@
|
|||
#if !defined SLANG_ASSEMBLE_CONDITIONAL_H
|
||||
#define SLANG_ASSEMBLE_CONDITIONAL_H
|
||||
|
||||
#include "slang_assemble.h"
|
||||
|
||||
#if defined __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
GLboolean _slang_assemble_logicaland (slang_assemble_ctx *, slang_operation *);
|
||||
GLboolean _slang_assemble_logicaland (slang_assemble_ctx *, struct slang_operation_ *);
|
||||
|
||||
GLboolean _slang_assemble_logicalor (slang_assemble_ctx *, slang_operation *);
|
||||
GLboolean _slang_assemble_logicalor (slang_assemble_ctx *, struct slang_operation_ *);
|
||||
|
||||
GLboolean _slang_assemble_select (slang_assemble_ctx *, slang_operation *);
|
||||
GLboolean _slang_assemble_select (slang_assemble_ctx *, struct slang_operation_ *);
|
||||
|
||||
GLboolean _slang_assemble_for (slang_assemble_ctx *, slang_operation *);
|
||||
GLboolean _slang_assemble_for (slang_assemble_ctx *, struct slang_operation_ *);
|
||||
|
||||
GLboolean _slang_assemble_do (slang_assemble_ctx *, slang_operation *);
|
||||
GLboolean _slang_assemble_do (slang_assemble_ctx *, struct slang_operation_ *);
|
||||
|
||||
GLboolean _slang_assemble_while (slang_assemble_ctx *, slang_operation *);
|
||||
GLboolean _slang_assemble_while (slang_assemble_ctx *, struct slang_operation_ *);
|
||||
|
||||
GLboolean _slang_assemble_if (slang_assemble_ctx *, slang_operation *);
|
||||
GLboolean _slang_assemble_if (slang_assemble_ctx *, struct slang_operation_ *);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
@ -29,9 +29,7 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_assemble_constructor.h"
|
||||
#include "slang_assemble_typeinfo.h"
|
||||
#include "slang_assemble.h"
|
||||
#include "slang_storage.h"
|
||||
|
||||
/* _slang_is_swizzle() */
|
||||
|
|
|
@ -25,9 +25,6 @@
|
|||
#if !defined SLANG_ASSEMBLE_CONSTRUCTOR_H
|
||||
#define SLANG_ASSEMBLE_CONSTRUCTOR_H
|
||||
|
||||
#include "slang_assemble.h"
|
||||
#include "slang_compile.h"
|
||||
|
||||
#if defined __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
@ -54,7 +51,7 @@ GLboolean _slang_is_swizzle_mask (const slang_swizzle *swz, GLuint rows);
|
|||
*/
|
||||
GLvoid _slang_multiply_swizzles (slang_swizzle *, const slang_swizzle *, const slang_swizzle *);
|
||||
|
||||
GLboolean _slang_assemble_constructor (slang_assemble_ctx *, slang_operation *);
|
||||
GLboolean _slang_assemble_constructor (slang_assemble_ctx *, struct slang_operation_ *);
|
||||
|
||||
GLboolean _slang_assemble_constructor_from_swizzle (slang_assemble_ctx *, const slang_swizzle *,
|
||||
slang_type_specifier *, slang_type_specifier *);
|
||||
|
|
|
@ -29,22 +29,103 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_assemble_typeinfo.h"
|
||||
#include "slang_assemble.h"
|
||||
#include "slang_compile.h"
|
||||
|
||||
/*
|
||||
* slang_type_specifier
|
||||
*/
|
||||
|
||||
GLvoid slang_type_specifier_ctr (slang_type_specifier *self)
|
||||
{
|
||||
self->type = slang_spec_void;
|
||||
self->_struct = NULL;
|
||||
self->_array = NULL;
|
||||
}
|
||||
|
||||
GLvoid slang_type_specifier_dtr (slang_type_specifier *self)
|
||||
{
|
||||
if (self->_struct != NULL)
|
||||
{
|
||||
slang_struct_destruct (self->_struct);
|
||||
slang_alloc_free (self->_struct);
|
||||
}
|
||||
if (self->_array != NULL)
|
||||
{
|
||||
slang_type_specifier_dtr (self->_array);
|
||||
slang_alloc_free (self->_array);
|
||||
}
|
||||
}
|
||||
|
||||
GLboolean slang_type_specifier_copy (slang_type_specifier *x, const slang_type_specifier *y)
|
||||
{
|
||||
slang_type_specifier z;
|
||||
|
||||
slang_type_specifier_ctr (&z);
|
||||
z.type = y->type;
|
||||
if (z.type == slang_spec_struct)
|
||||
{
|
||||
z._struct = (slang_struct *) slang_alloc_malloc (sizeof (slang_struct));
|
||||
if (z._struct == NULL)
|
||||
{
|
||||
slang_type_specifier_dtr (&z);
|
||||
return GL_FALSE;
|
||||
}
|
||||
if (!slang_struct_construct (z._struct))
|
||||
{
|
||||
slang_alloc_free (z._struct);
|
||||
slang_type_specifier_dtr (&z);
|
||||
return GL_FALSE;
|
||||
}
|
||||
if (!slang_struct_copy (z._struct, y->_struct))
|
||||
{
|
||||
slang_type_specifier_dtr (&z);
|
||||
return GL_FALSE;
|
||||
}
|
||||
}
|
||||
else if (z.type == slang_spec_array)
|
||||
{
|
||||
z._array = (slang_type_specifier *) slang_alloc_malloc (sizeof (slang_type_specifier));
|
||||
if (z._array == NULL)
|
||||
{
|
||||
slang_type_specifier_dtr (&z);
|
||||
return GL_FALSE;
|
||||
}
|
||||
slang_type_specifier_ctr (z._array);
|
||||
if (!slang_type_specifier_copy (z._array, y->_array))
|
||||
{
|
||||
slang_type_specifier_dtr (&z);
|
||||
return GL_FALSE;
|
||||
}
|
||||
}
|
||||
slang_type_specifier_dtr (x);
|
||||
*x = z;
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
GLboolean slang_type_specifier_equal (const slang_type_specifier *x, const slang_type_specifier *y)
|
||||
{
|
||||
if (x->type != y->type)
|
||||
return 0;
|
||||
if (x->type == slang_spec_struct)
|
||||
return slang_struct_equal (x->_struct, y->_struct);
|
||||
if (x->type == slang_spec_array)
|
||||
return slang_type_specifier_equal (x->_array, y->_array);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* slang_assembly_typeinfo */
|
||||
|
||||
GLboolean slang_assembly_typeinfo_construct (slang_assembly_typeinfo *ti)
|
||||
{
|
||||
if (!slang_type_specifier_construct (&ti->spec))
|
||||
return GL_FALSE;
|
||||
slang_type_specifier_ctr (&ti->spec);
|
||||
ti->array_len = 0;
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
GLvoid slang_assembly_typeinfo_destruct (slang_assembly_typeinfo *ti)
|
||||
{
|
||||
slang_type_specifier_destruct (&ti->spec);
|
||||
slang_type_specifier_dtr (&ti->spec);
|
||||
}
|
||||
|
||||
/* _slang_typeof_operation() */
|
||||
|
|
|
@ -25,13 +25,50 @@
|
|||
#if !defined SLANG_ASSEMBLE_TYPEINFO_H
|
||||
#define SLANG_ASSEMBLE_TYPEINFO_H
|
||||
|
||||
#include "slang_assemble_constructor.h"
|
||||
#include "slang_compile.h"
|
||||
|
||||
#if defined __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum slang_type_specifier_type_
|
||||
{
|
||||
slang_spec_void,
|
||||
slang_spec_bool,
|
||||
slang_spec_bvec2,
|
||||
slang_spec_bvec3,
|
||||
slang_spec_bvec4,
|
||||
slang_spec_int,
|
||||
slang_spec_ivec2,
|
||||
slang_spec_ivec3,
|
||||
slang_spec_ivec4,
|
||||
slang_spec_float,
|
||||
slang_spec_vec2,
|
||||
slang_spec_vec3,
|
||||
slang_spec_vec4,
|
||||
slang_spec_mat2,
|
||||
slang_spec_mat3,
|
||||
slang_spec_mat4,
|
||||
slang_spec_sampler1D,
|
||||
slang_spec_sampler2D,
|
||||
slang_spec_sampler3D,
|
||||
slang_spec_samplerCube,
|
||||
slang_spec_sampler1DShadow,
|
||||
slang_spec_sampler2DShadow,
|
||||
slang_spec_struct,
|
||||
slang_spec_array
|
||||
} slang_type_specifier_type;
|
||||
|
||||
typedef struct slang_type_specifier_
|
||||
{
|
||||
slang_type_specifier_type type;
|
||||
struct slang_struct_ *_struct; /* type: spec_struct */
|
||||
struct slang_type_specifier_ *_array; /* type: spec_array */
|
||||
} slang_type_specifier;
|
||||
|
||||
GLvoid slang_type_specifier_ctr (slang_type_specifier *);
|
||||
GLvoid slang_type_specifier_dtr (slang_type_specifier *);
|
||||
GLboolean slang_type_specifier_copy (slang_type_specifier *, const slang_type_specifier *);
|
||||
GLboolean slang_type_specifier_equal (const slang_type_specifier *, const slang_type_specifier *);
|
||||
|
||||
typedef struct slang_assembly_typeinfo_
|
||||
{
|
||||
GLboolean can_be_referenced;
|
||||
|
@ -49,8 +86,9 @@ GLvoid slang_assembly_typeinfo_destruct (slang_assembly_typeinfo *);
|
|||
* Returns GL_TRUE on success.
|
||||
* Returns GL_FALSE otherwise.
|
||||
*/
|
||||
GLboolean _slang_typeof_operation (slang_assemble_ctx *, slang_operation *, slang_assembly_typeinfo *);
|
||||
GLboolean _slang_typeof_operation_ (slang_operation *, slang_assembly_name_space *,
|
||||
GLboolean _slang_typeof_operation (slang_assemble_ctx *, struct slang_operation_ *,
|
||||
slang_assembly_typeinfo *);
|
||||
GLboolean _slang_typeof_operation_ (struct slang_operation_ *, slang_assembly_name_space *,
|
||||
slang_assembly_typeinfo *, slang_atom_pool *);
|
||||
|
||||
/*
|
||||
|
@ -58,8 +96,9 @@ GLboolean _slang_typeof_operation_ (slang_operation *, slang_assembly_name_space
|
|||
* Returns GL_TRUE on success, even if the function was not found.
|
||||
* Returns GL_FALSE otherwise.
|
||||
*/
|
||||
GLboolean _slang_typeof_function (slang_atom a_name, slang_operation *params, GLuint num_params,
|
||||
slang_assembly_name_space *, slang_type_specifier *spec, GLboolean *exists, slang_atom_pool *);
|
||||
GLboolean _slang_typeof_function (slang_atom a_name, struct slang_operation_ *params,
|
||||
GLuint num_params, slang_assembly_name_space *, slang_type_specifier *spec, GLboolean *exists,
|
||||
slang_atom_pool *);
|
||||
|
||||
GLboolean _slang_type_is_matrix (slang_type_specifier_type);
|
||||
|
||||
|
|
|
@ -29,13 +29,10 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "grammar_mesa.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_compile.h"
|
||||
#include "slang_preprocess.h"
|
||||
#include "slang_storage.h"
|
||||
#include "slang_assemble.h"
|
||||
#include "slang_execute.h"
|
||||
#include "grammar_mesa.h"
|
||||
#include "slang_compile.h"
|
||||
#include "slang_preprocess.h"
|
||||
#include "slang_storage.h"
|
||||
|
||||
/*
|
||||
* This is a straightforward implementation of the slang front-end compiler.
|
||||
|
@ -83,7 +80,7 @@ int slang_translation_unit_construct (slang_translation_unit *unit)
|
|||
slang_alloc_free (unit->assembly);
|
||||
return 0;
|
||||
}
|
||||
slang_machine_init (unit->machine);
|
||||
slang_machine_ctr (unit->machine);
|
||||
unit->atom_pool = (slang_atom_pool *) slang_alloc_malloc (sizeof (slang_atom_pool));
|
||||
if (unit->atom_pool == NULL)
|
||||
{
|
||||
|
@ -136,7 +133,7 @@ int slang_translation_unit_construct2 (slang_translation_unit *unit, slang_assem
|
|||
unit->atom_pool = atoms;
|
||||
unit->free_atom_pool = 0;
|
||||
slang_export_data_table_ctr (&unit->exp_data);
|
||||
slang_active_uniforms_ctr (&unit->uniforms);
|
||||
slang_export_code_table_ctr (&unit->exp_code);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
@ -152,15 +149,18 @@ void slang_translation_unit_destruct (slang_translation_unit *unit)
|
|||
}
|
||||
if (unit->free_global_pool)
|
||||
slang_alloc_free (unit->global_pool);
|
||||
if (unit->free_machine)
|
||||
slang_alloc_free (unit->machine);
|
||||
if (unit->free_machine)
|
||||
{
|
||||
slang_machine_dtr (unit->machine);
|
||||
slang_alloc_free (unit->machine);
|
||||
}
|
||||
if (unit->free_atom_pool)
|
||||
{
|
||||
slang_atom_pool_destruct (unit->atom_pool);
|
||||
slang_alloc_free (unit->atom_pool);
|
||||
}
|
||||
slang_active_uniforms_dtr (&unit->uniforms);
|
||||
slang_export_data_table_dtr (&unit->exp_data);
|
||||
slang_export_data_table_dtr (&unit->exp_data);
|
||||
slang_export_code_table_ctr (&unit->exp_code);
|
||||
}
|
||||
|
||||
/* slang_info_log */
|
||||
|
@ -407,13 +407,7 @@ static GLboolean convert_to_array (slang_parse_ctx *C, slang_variable *var,
|
|||
slang_info_log_memory (C->L);
|
||||
return GL_FALSE;
|
||||
}
|
||||
if (!slang_type_specifier_construct (var->type.specifier._array))
|
||||
{
|
||||
slang_alloc_free (var->type.specifier._array);
|
||||
var->type.specifier._array = NULL;
|
||||
slang_info_log_memory (C->L);
|
||||
return GL_FALSE;
|
||||
}
|
||||
slang_type_specifier_ctr (var->type.specifier._array);
|
||||
return slang_type_specifier_copy (var->type.specifier._array, sp);
|
||||
}
|
||||
|
||||
|
@ -518,14 +512,13 @@ static int parse_struct (slang_parse_ctx *C, slang_output_ctx *O, slang_struct *
|
|||
{
|
||||
slang_type_specifier sp;
|
||||
|
||||
if (!slang_type_specifier_construct (&sp))
|
||||
return 0;
|
||||
slang_type_specifier_ctr (&sp);
|
||||
if (!parse_struct_field (C, O, *st, &sp))
|
||||
{
|
||||
slang_type_specifier_destruct (&sp);
|
||||
slang_type_specifier_dtr (&sp);
|
||||
return 0;
|
||||
}
|
||||
slang_type_specifier_destruct (&sp);
|
||||
slang_type_specifier_dtr (&sp);
|
||||
}
|
||||
while (*C->I++ != FIELD_NONE);
|
||||
|
||||
|
@ -1320,19 +1313,18 @@ static int parse_parameter_declaration (slang_parse_ctx *C, slang_output_ctx *O,
|
|||
{
|
||||
slang_type_specifier p;
|
||||
|
||||
if (!slang_type_specifier_construct (&p))
|
||||
return GL_FALSE;
|
||||
slang_type_specifier_ctr (&p);
|
||||
if (!slang_type_specifier_copy (&p, ¶m->type.specifier))
|
||||
{
|
||||
slang_type_specifier_destruct (&p);
|
||||
slang_type_specifier_dtr (&p);
|
||||
return GL_FALSE;
|
||||
}
|
||||
if (!convert_to_array (C, param, &p))
|
||||
{
|
||||
slang_type_specifier_destruct (&p);
|
||||
slang_type_specifier_dtr (&p);
|
||||
return GL_FALSE;
|
||||
}
|
||||
slang_type_specifier_destruct (&p);
|
||||
slang_type_specifier_dtr (&p);
|
||||
if (!parse_array_len (C, O, ¶m->array_len))
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
@ -2102,7 +2094,12 @@ static int compile (grammar *id, slang_translation_unit *builtin_units, int *com
|
|||
return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(USE_X86_ASM) || defined(SLANG_X86)
|
||||
/* XXX */
|
||||
GLboolean _slang_x86_codegen (slang_machine *, slang_assembly_file *, GLuint);
|
||||
#endif
|
||||
|
||||
int _slang_compile (const char *source, slang_translation_unit *unit, slang_unit_type type,
|
||||
slang_info_log *log)
|
||||
|
@ -2136,11 +2133,20 @@ int _slang_compile (const char *source, slang_translation_unit *unit, slang_unit
|
|||
|
||||
if (!success)
|
||||
return 0;
|
||||
|
||||
unit->exp_data.atoms = unit->atom_pool;
|
||||
if (!_slang_build_export_data_table (&unit->exp_data, &unit->globals))
|
||||
return 0;
|
||||
if (!_slang_gather_active_uniforms (&unit->uniforms, &unit->exp_data))
|
||||
return 0;
|
||||
|
||||
unit->exp_code.atoms = unit->atom_pool;
|
||||
if (!_slang_build_export_code_table (&unit->exp_code, &unit->functions, unit))
|
||||
return 0;
|
||||
|
||||
#if defined(USE_X86_ASM) || defined(SLANG_X86)
|
||||
/* XXX: lookup the @main label */
|
||||
if (!_slang_x86_codegen (unit->machine, unit->assembly, unit->exp_code.entries[0].address))
|
||||
return 0;
|
||||
#endif
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
|
|
@ -25,6 +25,8 @@
|
|||
#if !defined SLANG_COMPILE_H
|
||||
#define SLANG_COMPILE_H
|
||||
|
||||
#include "slang_export.h"
|
||||
#include "slang_execute.h"
|
||||
#include "slang_compile_variable.h"
|
||||
#include "slang_compile_struct.h"
|
||||
#include "slang_compile_operation.h"
|
||||
|
@ -53,21 +55,21 @@ typedef struct slang_translation_unit_
|
|||
slang_function_scope functions;
|
||||
slang_struct_scope structs;
|
||||
slang_unit_type type;
|
||||
struct slang_assembly_file_ *assembly;
|
||||
slang_assembly_file *assembly;
|
||||
int free_assembly;
|
||||
slang_var_pool *global_pool;
|
||||
int free_global_pool;
|
||||
struct slang_machine_ *machine;
|
||||
slang_machine *machine;
|
||||
int free_machine;
|
||||
slang_atom_pool *atom_pool;
|
||||
int free_atom_pool;
|
||||
slang_export_data_table exp_data;
|
||||
slang_active_uniforms uniforms;
|
||||
slang_export_code_table exp_code;
|
||||
} slang_translation_unit;
|
||||
|
||||
int slang_translation_unit_construct (slang_translation_unit *);
|
||||
int slang_translation_unit_construct2 (slang_translation_unit *, struct slang_assembly_file_ *,
|
||||
slang_var_pool *, struct slang_machine_ *, slang_atom_pool *);
|
||||
int slang_translation_unit_construct2 (slang_translation_unit *, slang_assembly_file *,
|
||||
slang_var_pool *, slang_machine *, slang_atom_pool *);
|
||||
void slang_translation_unit_destruct (slang_translation_unit *);
|
||||
|
||||
typedef struct slang_info_log_
|
||||
|
|
|
@ -29,10 +29,7 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_compile_variable.h"
|
||||
#include "slang_compile_operation.h"
|
||||
#include "slang_compile_function.h"
|
||||
#include "slang_compile.h"
|
||||
|
||||
/* slang_fixup_table */
|
||||
|
||||
|
@ -146,3 +143,48 @@ slang_function *slang_function_scope_find (slang_function_scope *funcs, slang_fu
|
|||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* _slang_build_export_code_table()
|
||||
*/
|
||||
|
||||
GLboolean _slang_build_export_code_table (slang_export_code_table *tbl, slang_function_scope *funs,
|
||||
slang_translation_unit *unit)
|
||||
{
|
||||
slang_atom main;
|
||||
GLuint i;
|
||||
|
||||
main = slang_atom_pool_atom (tbl->atoms, "main");
|
||||
if (main == SLANG_ATOM_NULL)
|
||||
return GL_FALSE;
|
||||
|
||||
for (i = 0; i < funs->num_functions; i++)
|
||||
{
|
||||
if (funs->functions[i].header.a_name == main)
|
||||
{
|
||||
slang_function *fun = &funs->functions[i];
|
||||
slang_export_code_entry *e;
|
||||
slang_assemble_ctx A;
|
||||
|
||||
e = slang_export_code_table_add (tbl);
|
||||
if (e == NULL)
|
||||
return GL_FALSE;
|
||||
e->address = unit->assembly->count;
|
||||
e->name = slang_atom_pool_atom (tbl->atoms, "@main");
|
||||
if (e->name == SLANG_ATOM_NULL)
|
||||
return GL_FALSE;
|
||||
|
||||
A.file = unit->assembly;
|
||||
A.mach = unit->machine;
|
||||
A.atoms = unit->atom_pool;
|
||||
A.space.funcs = &unit->functions;
|
||||
A.space.structs = &unit->structs;
|
||||
A.space.vars = &unit->globals;
|
||||
slang_assembly_file_push_label (unit->assembly, slang_asm_local_alloc, 20);
|
||||
slang_assembly_file_push_label (unit->assembly, slang_asm_enter, 20);
|
||||
_slang_assemble_function_call (&A, fun, NULL, 0, GL_FALSE);
|
||||
slang_assembly_file_push (unit->assembly, slang_asm_exit);
|
||||
}
|
||||
}
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
|
|
|
@ -71,6 +71,9 @@ void slang_function_scope_destruct (slang_function_scope *);
|
|||
int slang_function_scope_find_by_name (slang_function_scope *, slang_atom, int);
|
||||
slang_function *slang_function_scope_find (slang_function_scope *, slang_function *, int);
|
||||
|
||||
GLboolean _slang_build_export_code_table (slang_export_code_table *, slang_function_scope *,
|
||||
struct slang_translation_unit_ *);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -29,9 +29,7 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_compile_variable.h"
|
||||
#include "slang_compile_operation.h"
|
||||
#include "slang_compile.h"
|
||||
|
||||
/* slang_operation */
|
||||
|
||||
|
|
|
@ -29,9 +29,7 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_compile_variable.h"
|
||||
#include "slang_compile_struct.h"
|
||||
#include "slang_compile.h"
|
||||
|
||||
/* slang_struct_scope */
|
||||
|
||||
|
|
|
@ -29,10 +29,7 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_compile_variable.h"
|
||||
#include "slang_compile_struct.h"
|
||||
#include "slang_compile_operation.h"
|
||||
#include "slang_compile.h"
|
||||
|
||||
/* slang_type_specifier_type */
|
||||
|
||||
|
@ -92,106 +89,18 @@ const char *slang_type_specifier_type_to_string (slang_type_specifier_type type)
|
|||
return p->name;
|
||||
}
|
||||
|
||||
/* slang_type_specifier */
|
||||
|
||||
int slang_type_specifier_construct (slang_type_specifier *spec)
|
||||
{
|
||||
spec->type = slang_spec_void;
|
||||
spec->_struct = NULL;
|
||||
spec->_array = NULL;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void slang_type_specifier_destruct (slang_type_specifier *spec)
|
||||
{
|
||||
if (spec->_struct != NULL)
|
||||
{
|
||||
slang_struct_destruct (spec->_struct);
|
||||
slang_alloc_free (spec->_struct);
|
||||
}
|
||||
if (spec->_array != NULL)
|
||||
{
|
||||
slang_type_specifier_destruct (spec->_array);
|
||||
slang_alloc_free (spec->_array);
|
||||
}
|
||||
}
|
||||
|
||||
int slang_type_specifier_copy (slang_type_specifier *x, const slang_type_specifier *y)
|
||||
{
|
||||
slang_type_specifier z;
|
||||
|
||||
if (!slang_type_specifier_construct (&z))
|
||||
return 0;
|
||||
z.type = y->type;
|
||||
if (z.type == slang_spec_struct)
|
||||
{
|
||||
z._struct = (slang_struct *) slang_alloc_malloc (sizeof (slang_struct));
|
||||
if (z._struct == NULL)
|
||||
{
|
||||
slang_type_specifier_destruct (&z);
|
||||
return 0;
|
||||
}
|
||||
if (!slang_struct_construct (z._struct))
|
||||
{
|
||||
slang_alloc_free (z._struct);
|
||||
slang_type_specifier_destruct (&z);
|
||||
return 0;
|
||||
}
|
||||
if (!slang_struct_copy (z._struct, y->_struct))
|
||||
{
|
||||
slang_type_specifier_destruct (&z);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else if (z.type == slang_spec_array)
|
||||
{
|
||||
z._array = (slang_type_specifier *) slang_alloc_malloc (sizeof (slang_type_specifier));
|
||||
if (z._array == NULL)
|
||||
{
|
||||
slang_type_specifier_destruct (&z);
|
||||
return 0;
|
||||
}
|
||||
if (!slang_type_specifier_construct (z._array))
|
||||
{
|
||||
slang_alloc_free (z._array);
|
||||
slang_type_specifier_destruct (&z);
|
||||
return 0;
|
||||
}
|
||||
if (!slang_type_specifier_copy (z._array, y->_array))
|
||||
{
|
||||
slang_type_specifier_destruct (&z);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
slang_type_specifier_destruct (x);
|
||||
*x = z;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int slang_type_specifier_equal (const slang_type_specifier *x, const slang_type_specifier *y)
|
||||
{
|
||||
if (x->type != y->type)
|
||||
return 0;
|
||||
if (x->type == slang_spec_struct)
|
||||
return slang_struct_equal (x->_struct, y->_struct);
|
||||
if (x->type == slang_spec_array)
|
||||
return slang_type_specifier_equal (x->_array, y->_array);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* slang_fully_specified_type */
|
||||
|
||||
int slang_fully_specified_type_construct (slang_fully_specified_type *type)
|
||||
{
|
||||
type->qualifier = slang_qual_none;
|
||||
if (!slang_type_specifier_construct (&type->specifier))
|
||||
return 0;
|
||||
slang_type_specifier_ctr (&type->specifier);
|
||||
return 1;
|
||||
}
|
||||
|
||||
void slang_fully_specified_type_destruct (slang_fully_specified_type *type)
|
||||
{
|
||||
slang_type_specifier_destruct (&type->specifier);
|
||||
slang_type_specifier_dtr (&type->specifier);
|
||||
}
|
||||
|
||||
int slang_fully_specified_type_copy (slang_fully_specified_type *x, const slang_fully_specified_type *y)
|
||||
|
@ -341,41 +250,9 @@ slang_variable *_slang_locate_variable (slang_variable_scope *scope, slang_atom
|
|||
}
|
||||
|
||||
/*
|
||||
* slang_active_uniforms
|
||||
* _slang_build_export_data_table()
|
||||
*/
|
||||
|
||||
GLvoid slang_active_uniforms_ctr (slang_active_uniforms *self)
|
||||
{
|
||||
self->table = NULL;
|
||||
self->count = 0;
|
||||
}
|
||||
|
||||
GLvoid slang_active_uniforms_dtr (slang_active_uniforms *self)
|
||||
{
|
||||
GLuint i;
|
||||
|
||||
for (i = 0; i < self->count; i++)
|
||||
slang_alloc_free (self->table[i].name);
|
||||
slang_alloc_free (self->table);
|
||||
}
|
||||
|
||||
GLboolean slang_active_uniforms_add (slang_active_uniforms *self, slang_export_data_quant *q,
|
||||
const char *name)
|
||||
{
|
||||
const GLuint n = self->count;
|
||||
|
||||
self->table = (slang_active_uniform *) slang_alloc_realloc (self->table,
|
||||
n * sizeof (slang_active_uniform), (n + 1) * sizeof (slang_active_uniform));
|
||||
if (self->table == NULL)
|
||||
return GL_FALSE;
|
||||
self->table[n].quant = q;
|
||||
self->table[n].name = slang_string_duplicate (name);
|
||||
if (self->table[n].name == NULL)
|
||||
return GL_FALSE;
|
||||
self->count++;
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
static GLenum gl_type_from_specifier (const slang_type_specifier *type)
|
||||
{
|
||||
switch (type->type)
|
||||
|
@ -469,17 +346,20 @@ GLboolean _slang_build_export_data_table (slang_export_data_table *tbl, slang_va
|
|||
for (i = 0; i < vars->num_variables; i++)
|
||||
{
|
||||
slang_variable *var = &vars->variables[i];
|
||||
|
||||
slang_export_data_entry *e;
|
||||
|
||||
e = slang_export_data_table_add (tbl);
|
||||
if (e == NULL)
|
||||
return GL_FALSE;
|
||||
if (!build_quant (&e->quant, var))
|
||||
return GL_FALSE;
|
||||
if (var->type.qualifier == slang_qual_uniform)
|
||||
{
|
||||
slang_export_data_entry *e = slang_export_data_table_add (tbl);
|
||||
if (e == NULL)
|
||||
return GL_FALSE;
|
||||
if (!build_quant (&e->quant, var))
|
||||
return GL_FALSE;
|
||||
e->access = slang_exp_uniform;
|
||||
e->address = var->address;
|
||||
}
|
||||
else if (var->type.qualifier == slang_qual_attribute)
|
||||
e->access = slang_exp_attribute;
|
||||
else
|
||||
e->access = slang_exp_varying;
|
||||
e->address = var->address;
|
||||
}
|
||||
|
||||
if (vars->outer_scope != NULL)
|
||||
|
@ -487,45 +367,3 @@ GLboolean _slang_build_export_data_table (slang_export_data_table *tbl, slang_va
|
|||
return GL_TRUE;
|
||||
}
|
||||
|
||||
static GLboolean insert_uniform (slang_active_uniforms *u, slang_export_data_quant *q, char *name,
|
||||
slang_atom_pool *atoms)
|
||||
{
|
||||
slang_string_concat (name, slang_atom_pool_id (atoms, q->name));
|
||||
if (q->array_len != 0)
|
||||
slang_string_concat (name, "[0]");
|
||||
|
||||
if (q->structure != NULL)
|
||||
{
|
||||
GLuint save, i;
|
||||
|
||||
slang_string_concat (name, ".");
|
||||
save = slang_string_length (name);
|
||||
|
||||
for (i = 0; i < q->u.field_count; i++)
|
||||
{
|
||||
if (!insert_uniform (u, &q->structure[i], name, atoms))
|
||||
return GL_FALSE;
|
||||
name[save] = '\0';
|
||||
}
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
return slang_active_uniforms_add (u, q, name);
|
||||
}
|
||||
|
||||
GLboolean _slang_gather_active_uniforms (slang_active_uniforms *u, slang_export_data_table *tbl)
|
||||
{
|
||||
GLuint i;
|
||||
|
||||
for (i = 0; i < tbl->count; i++)
|
||||
{
|
||||
char name[1024] = "";
|
||||
|
||||
if (!insert_uniform (u, &tbl->entries[i].quant, name, tbl->atoms))
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
|
|
|
@ -25,8 +25,6 @@
|
|||
#if !defined SLANG_COMPILE_VARIABLE_H
|
||||
#define SLANG_COMPILE_VARIABLE_H
|
||||
|
||||
#include "slang_export.h"
|
||||
|
||||
#if defined __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
@ -44,49 +42,9 @@ typedef enum slang_type_qualifier_
|
|||
slang_qual_fixedinput /* internal */
|
||||
} slang_type_qualifier;
|
||||
|
||||
typedef enum slang_type_specifier_type_
|
||||
{
|
||||
slang_spec_void,
|
||||
slang_spec_bool,
|
||||
slang_spec_bvec2,
|
||||
slang_spec_bvec3,
|
||||
slang_spec_bvec4,
|
||||
slang_spec_int,
|
||||
slang_spec_ivec2,
|
||||
slang_spec_ivec3,
|
||||
slang_spec_ivec4,
|
||||
slang_spec_float,
|
||||
slang_spec_vec2,
|
||||
slang_spec_vec3,
|
||||
slang_spec_vec4,
|
||||
slang_spec_mat2,
|
||||
slang_spec_mat3,
|
||||
slang_spec_mat4,
|
||||
slang_spec_sampler1D,
|
||||
slang_spec_sampler2D,
|
||||
slang_spec_sampler3D,
|
||||
slang_spec_samplerCube,
|
||||
slang_spec_sampler1DShadow,
|
||||
slang_spec_sampler2DShadow,
|
||||
slang_spec_struct,
|
||||
slang_spec_array
|
||||
} slang_type_specifier_type;
|
||||
|
||||
slang_type_specifier_type slang_type_specifier_type_from_string (const char *);
|
||||
const char *slang_type_specifier_type_to_string (slang_type_specifier_type);
|
||||
|
||||
typedef struct slang_type_specifier_
|
||||
{
|
||||
slang_type_specifier_type type;
|
||||
struct slang_struct_ *_struct; /* type: spec_struct */
|
||||
struct slang_type_specifier_ *_array; /* type: spec_array */
|
||||
} slang_type_specifier;
|
||||
|
||||
int slang_type_specifier_construct (slang_type_specifier *);
|
||||
void slang_type_specifier_destruct (slang_type_specifier *);
|
||||
int slang_type_specifier_copy (slang_type_specifier *, const slang_type_specifier *);
|
||||
int slang_type_specifier_equal (const slang_type_specifier *, const slang_type_specifier *);
|
||||
|
||||
typedef struct slang_fully_specified_type_
|
||||
{
|
||||
slang_type_qualifier qualifier;
|
||||
|
@ -125,27 +83,8 @@ int slang_variable_copy (slang_variable *, const slang_variable *);
|
|||
|
||||
slang_variable *_slang_locate_variable (slang_variable_scope *, slang_atom a_name, GLboolean all);
|
||||
|
||||
typedef struct
|
||||
{
|
||||
slang_export_data_quant *quant;
|
||||
char *name;
|
||||
} slang_active_uniform;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
slang_active_uniform *table;
|
||||
GLuint count;
|
||||
} slang_active_uniforms;
|
||||
|
||||
GLvoid slang_active_uniforms_ctr (slang_active_uniforms *);
|
||||
GLvoid slang_active_uniforms_dtr (slang_active_uniforms *);
|
||||
GLboolean slang_active_uniforms_add (slang_active_uniforms *, slang_export_data_quant *,
|
||||
const char *);
|
||||
|
||||
GLboolean _slang_build_export_data_table (slang_export_data_table *, slang_variable_scope *);
|
||||
|
||||
GLboolean _slang_gather_active_uniforms (slang_active_uniforms *, slang_export_data_table *);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -32,14 +32,26 @@
|
|||
#include "context.h"
|
||||
#include "swrast/s_context.h"
|
||||
#include "colormac.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_assemble.h"
|
||||
#include "slang_storage.h"
|
||||
#include "slang_execute.h"
|
||||
#include "slang_library_noise.h"
|
||||
|
||||
#define DEBUG_SLANG 0
|
||||
|
||||
GLvoid slang_machine_ctr (slang_machine *self)
|
||||
{
|
||||
slang_machine_init (self);
|
||||
#if defined(USE_X86_ASM) || defined(SLANG_X86)
|
||||
self->x86.compiled_func = NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
GLvoid slang_machine_dtr (slang_machine *self)
|
||||
{
|
||||
#if defined(USE_X86_ASM) || defined(SLANG_X86)
|
||||
/* TODO: free self->x86.compiled_func */
|
||||
#endif
|
||||
}
|
||||
|
||||
void slang_machine_init (slang_machine *mach)
|
||||
{
|
||||
mach->ip = 0;
|
||||
|
@ -53,7 +65,7 @@ int _slang_execute (const slang_assembly_file *file)
|
|||
{
|
||||
slang_machine mach;
|
||||
|
||||
slang_machine_init (&mach);
|
||||
slang_machine_ctr (&mach);
|
||||
return _slang_execute2 (file, &mach);
|
||||
}
|
||||
|
||||
|
@ -207,6 +219,9 @@ static void dump_instruction (FILE *f, slang_assembly *a, unsigned int i)
|
|||
case slang_asm_local_addr:
|
||||
fprintf (f, "local_addr\t%u, %u", a->param[0], a->param[1]);
|
||||
break;
|
||||
case slang_asm_global_addr:
|
||||
fprintf (f, "global_addr\t%u", a->param[0]);
|
||||
break;
|
||||
case slang_asm_call:
|
||||
fprintf (f, "call\t%u", a->param[0]);
|
||||
break;
|
||||
|
@ -293,6 +308,14 @@ int _slang_execute2 (const slang_assembly_file *file, slang_machine *mach)
|
|||
f = fopen (filename, "w");
|
||||
#endif
|
||||
|
||||
#if defined(USE_X86_ASM) || defined(SLANG_X86)
|
||||
if (mach->x86.compiled_func != NULL)
|
||||
{
|
||||
mach->x86.compiled_func (mach);
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
stack = mach->mem + SLANG_MACHINE_GLOBAL_SIZE;
|
||||
|
||||
while (!mach->exit)
|
||||
|
@ -427,6 +450,7 @@ int _slang_execute2 (const slang_assembly_file *file, slang_machine *mach)
|
|||
mach->sp++;
|
||||
break;
|
||||
case slang_asm_addr_push:
|
||||
case slang_asm_global_addr:
|
||||
mach->sp--;
|
||||
stack[mach->sp]._addr = a->param[0];
|
||||
break;
|
||||
|
|
|
@ -25,6 +25,8 @@
|
|||
#if !defined SLANG_EXECUTE_H
|
||||
#define SLANG_EXECUTE_H
|
||||
|
||||
#include "slang_assemble.h"
|
||||
|
||||
#if defined __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
@ -39,6 +41,16 @@ typedef union slang_machine_slot_
|
|||
#define SLANG_MACHINE_STACK_SIZE 1024
|
||||
#define SLANG_MACHINE_MEMORY_SIZE (SLANG_MACHINE_GLOBAL_SIZE + SLANG_MACHINE_STACK_SIZE)
|
||||
|
||||
#if defined(USE_X86_ASM) || defined(SLANG_X86)
|
||||
typedef struct
|
||||
{
|
||||
GLvoid (* compiled_func) (struct slang_machine_ *);
|
||||
GLuint esp_restore;
|
||||
GLshort fpucntl_rnd_neg;
|
||||
GLshort fpucntl_restore;
|
||||
} slang_machine_x86;
|
||||
#endif
|
||||
|
||||
typedef struct slang_machine_
|
||||
{
|
||||
GLuint ip; /* instruction pointer, for flow control */
|
||||
|
@ -47,8 +59,14 @@ typedef struct slang_machine_
|
|||
GLuint kill; /* discard the fragment */
|
||||
GLuint exit; /* terminate the shader */
|
||||
slang_machine_slot mem[SLANG_MACHINE_MEMORY_SIZE];
|
||||
#if defined(USE_X86_ASM) || defined(SLANG_X86)
|
||||
slang_machine_x86 x86;
|
||||
#endif
|
||||
} slang_machine;
|
||||
|
||||
GLvoid slang_machine_ctr (slang_machine *);
|
||||
GLvoid slang_machine_dtr (slang_machine *);
|
||||
|
||||
void slang_machine_init (slang_machine *);
|
||||
|
||||
int _slang_execute (const slang_assembly_file *);
|
||||
|
|
|
@ -0,0 +1,536 @@
|
|||
/*
|
||||
* Mesa 3-D graphics library
|
||||
* Version: 6.5
|
||||
*
|
||||
* Copyright (C) 2005-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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* \file slang_execute_x86.c
|
||||
* x86 back end compiler
|
||||
* \author Michal Krol, Keith Whitwell
|
||||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "context.h"
|
||||
#include "colormac.h"
|
||||
#include "swrast/s_context.h"
|
||||
#include "slang_execute.h"
|
||||
#include "slang_library_noise.h"
|
||||
|
||||
#if defined(USE_X86_ASM) || defined(SLANG_X86)
|
||||
|
||||
#include "x86/rtasm/x86sse.h"
|
||||
|
||||
typedef struct
|
||||
{
|
||||
GLuint index;
|
||||
GLubyte *csr;
|
||||
} fixup;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
struct x86_function f;
|
||||
struct x86_reg r_eax;
|
||||
struct x86_reg r_ecx;
|
||||
struct x86_reg r_edx;
|
||||
struct x86_reg r_esp;
|
||||
struct x86_reg r_ebp;
|
||||
struct x86_reg r_st0;
|
||||
struct x86_reg r_st1;
|
||||
struct x86_reg r_st2;
|
||||
struct x86_reg r_st3;
|
||||
fixup *fixups;
|
||||
GLuint fixup_count;
|
||||
GLubyte **labels;
|
||||
slang_machine *mach;
|
||||
GLubyte *l_discard;
|
||||
GLubyte *l_exit;
|
||||
GLshort fpucntl;
|
||||
} codegen_ctx;
|
||||
|
||||
static GLvoid add_fixup (codegen_ctx *G, GLuint index, GLubyte *csr)
|
||||
{
|
||||
G->fixups = (fixup *) slang_alloc_realloc (G->fixups, G->fixup_count * sizeof (fixup),
|
||||
(G->fixup_count + 1) * sizeof (fixup));
|
||||
G->fixups[G->fixup_count].index = index;
|
||||
G->fixups[G->fixup_count].csr = csr;
|
||||
G->fixup_count++;
|
||||
}
|
||||
|
||||
#ifdef NO_FAST_MATH
|
||||
#define RESTORE_FPU (DEFAULT_X86_FPU)
|
||||
#define RND_NEG_FPU (DEFAULT_X86_FPU | 0x400)
|
||||
#else
|
||||
#define RESTORE_FPU (FAST_X86_FPU)
|
||||
#define RND_NEG_FPU (FAST_X86_FPU | 0x400)
|
||||
#endif
|
||||
|
||||
static void set_fpu_round_neg_inf (codegen_ctx *G)
|
||||
{
|
||||
if (G->fpucntl != RND_NEG_FPU)
|
||||
{
|
||||
G->fpucntl = RND_NEG_FPU;
|
||||
x87_fnclex (&G->f);
|
||||
x86_mov_reg_imm (&G->f, G->r_eax, (GLint) &G->mach->x86.fpucntl_rnd_neg);
|
||||
x87_fldcw (&G->f, x86_deref (G->r_eax));
|
||||
}
|
||||
}
|
||||
|
||||
static void emit_x87_ex2 (codegen_ctx *G)
|
||||
{
|
||||
set_fpu_round_neg_inf (G);
|
||||
|
||||
x87_fld (&G->f, G->r_st0); /* a a */
|
||||
x87_fprndint (&G->f); /* int(a) a */
|
||||
x87_fld (&G->f, G->r_st0); /* int(a) int(a) a */
|
||||
x87_fstp (&G->f, G->r_st3); /* int(a) a int(a)*/
|
||||
x87_fsubp (&G->f, G->r_st1);/* frac(a) int(a) */
|
||||
x87_f2xm1 (&G->f); /* (2^frac(a))-1 int(a)*/
|
||||
x87_fld1 (&G->f); /* 1 (2^frac(a))-1 int(a)*/
|
||||
x87_faddp (&G->f, G->r_st1);/* 2^frac(a) int(a) */
|
||||
x87_fscale (&G->f); /* 2^a */
|
||||
}
|
||||
|
||||
static GLfloat do_ceilf (GLfloat x)
|
||||
{
|
||||
return CEILF (x);
|
||||
}
|
||||
|
||||
static void fetch_texel (GLuint sampler, const GLfloat texcoord[4], GLfloat lambda, GLfloat color[4])
|
||||
{
|
||||
GET_CURRENT_CONTEXT(ctx);
|
||||
SWcontext *swrast = SWRAST_CONTEXT(ctx);
|
||||
GLchan rgba[4];
|
||||
|
||||
/* XXX: the function pointer is NULL! */
|
||||
swrast->TextureSample[sampler] (ctx, ctx->Texture.Unit[sampler]._Current, 1,
|
||||
(const GLfloat (*)[4]) texcoord, &lambda, &rgba);
|
||||
color[0] = CHAN_TO_FLOAT(rgba[0]);
|
||||
color[1] = CHAN_TO_FLOAT(rgba[1]);
|
||||
color[2] = CHAN_TO_FLOAT(rgba[2]);
|
||||
color[3] = CHAN_TO_FLOAT(rgba[3]);
|
||||
}
|
||||
|
||||
static GLvoid do_vec4_tex2d (GLfloat s, GLfloat t, GLuint sampler, GLfloat *rgba)
|
||||
{
|
||||
GLfloat st[4] = { s, t, 0.0f, 1.0f };
|
||||
|
||||
fetch_texel (sampler, st, 0.0f, rgba);
|
||||
}
|
||||
|
||||
static GLvoid do_print_float (GLfloat x)
|
||||
{
|
||||
_mesa_printf ("slang print: %f\n", x);
|
||||
}
|
||||
|
||||
static GLvoid do_print_int (GLfloat x)
|
||||
{
|
||||
_mesa_printf ("slang print: %d\n", (GLint) x);
|
||||
}
|
||||
|
||||
static GLvoid do_print_bool (GLfloat x)
|
||||
{
|
||||
_mesa_printf ("slang print: %s\n", (GLint) x ? "true" : "false");
|
||||
}
|
||||
|
||||
static GLvoid codegen_assem (codegen_ctx *G, slang_assembly *a)
|
||||
{
|
||||
GLint disp;
|
||||
|
||||
switch (a->type)
|
||||
{
|
||||
case slang_asm_none:
|
||||
break;
|
||||
case slang_asm_float_copy:
|
||||
case slang_asm_int_copy:
|
||||
case slang_asm_bool_copy:
|
||||
x86_mov (&G->f, G->r_eax, x86_make_disp (G->r_esp, a->param[0]));
|
||||
x86_pop (&G->f, G->r_ecx);
|
||||
x86_mov (&G->f, x86_make_disp (G->r_eax, a->param[1]), G->r_ecx);
|
||||
break;
|
||||
case slang_asm_float_move:
|
||||
case slang_asm_int_move:
|
||||
case slang_asm_bool_move:
|
||||
x86_lea (&G->f, G->r_eax, x86_make_disp (G->r_esp, a->param[1]));
|
||||
x86_add (&G->f, G->r_eax, x86_deref (G->r_esp));
|
||||
x86_mov (&G->f, G->r_eax, x86_deref (G->r_eax));
|
||||
x86_mov (&G->f, x86_make_disp (G->r_esp, a->param[0]), G->r_eax);
|
||||
break;
|
||||
case slang_asm_float_push:
|
||||
case slang_asm_int_push:
|
||||
case slang_asm_bool_push:
|
||||
/* TODO: use push imm32 */
|
||||
x86_mov_reg_imm (&G->f, G->r_eax, *((GLint *) &a->literal));
|
||||
x86_push (&G->f, G->r_eax);
|
||||
break;
|
||||
case slang_asm_float_deref:
|
||||
case slang_asm_int_deref:
|
||||
case slang_asm_bool_deref:
|
||||
case slang_asm_addr_deref:
|
||||
x86_mov (&G->f, G->r_eax, x86_deref (G->r_esp));
|
||||
x86_mov (&G->f, G->r_eax, x86_deref (G->r_eax));
|
||||
x86_mov (&G->f, x86_deref (G->r_esp), G->r_eax);
|
||||
break;
|
||||
case slang_asm_float_add:
|
||||
x87_fld (&G->f, x86_make_disp (G->r_esp, 4));
|
||||
x87_fld (&G->f, x86_deref (G->r_esp));
|
||||
x87_faddp (&G->f, G->r_st1);
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, 4));
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_multiply:
|
||||
x87_fld (&G->f, x86_make_disp (G->r_esp, 4));
|
||||
x87_fld (&G->f, x86_deref (G->r_esp));
|
||||
x87_fmulp (&G->f, G->r_st1);
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, 4));
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_divide:
|
||||
x87_fld (&G->f, x86_make_disp (G->r_esp, 4));
|
||||
x87_fld (&G->f, x86_deref (G->r_esp));
|
||||
x87_fdivp (&G->f, G->r_st1);
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, 4));
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_negate:
|
||||
x87_fld (&G->f, x86_deref (G->r_esp));
|
||||
x87_fchs (&G->f);
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_less:
|
||||
x87_fld (&G->f, x86_make_disp (G->r_esp, 4));
|
||||
x87_fcomp (&G->f, x86_deref (G->r_esp));
|
||||
x87_fnstsw (&G->f, G->r_eax);
|
||||
/* TODO: use test r8,imm8 */
|
||||
x86_mov_reg_imm (&G->f, G->r_ecx, 0x100);
|
||||
x86_test (&G->f, G->r_eax, G->r_ecx);
|
||||
{
|
||||
GLfloat one = 1.0f, zero = 0.0f;
|
||||
GLubyte *lab0, *lab1;
|
||||
|
||||
/* TODO: use jcc rel8 */
|
||||
lab0 = x86_jcc_forward (&G->f, cc_E);
|
||||
x86_mov_reg_imm (&G->f, G->r_ecx, *((GLint *) &one));
|
||||
/* TODO: use jmp rel8 */
|
||||
lab1 = x86_jmp_forward (&G->f);
|
||||
x86_fixup_fwd_jump (&G->f, lab0);
|
||||
x86_mov_reg_imm (&G->f, G->r_ecx, *((GLint *) &zero));
|
||||
x86_fixup_fwd_jump (&G->f, lab1);
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, 4));
|
||||
x86_mov (&G->f, x86_deref (G->r_esp), G->r_ecx);
|
||||
}
|
||||
break;
|
||||
case slang_asm_float_equal_exp:
|
||||
x87_fld (&G->f, x86_make_disp (G->r_esp, 4));
|
||||
x87_fcomp (&G->f, x86_deref (G->r_esp));
|
||||
x87_fnstsw (&G->f, G->r_eax);
|
||||
/* TODO: use test r8,imm8 */
|
||||
x86_mov_reg_imm (&G->f, G->r_ecx, 0x4000);
|
||||
x86_test (&G->f, G->r_eax, G->r_ecx);
|
||||
{
|
||||
GLfloat one = 1.0f, zero = 0.0f;
|
||||
GLubyte *lab0, *lab1;
|
||||
|
||||
/* TODO: use jcc rel8 */
|
||||
lab0 = x86_jcc_forward (&G->f, cc_E);
|
||||
x86_mov_reg_imm (&G->f, G->r_ecx, *((GLint *) &one));
|
||||
/* TODO: use jmp rel8 */
|
||||
lab1 = x86_jmp_forward (&G->f);
|
||||
x86_fixup_fwd_jump (&G->f, lab0);
|
||||
x86_mov_reg_imm (&G->f, G->r_ecx, *((GLint *) &zero));
|
||||
x86_fixup_fwd_jump (&G->f, lab1);
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, 4));
|
||||
x86_mov (&G->f, x86_deref (G->r_esp), G->r_ecx);
|
||||
}
|
||||
break;
|
||||
case slang_asm_float_equal_int:
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, -4));
|
||||
x87_fld (&G->f, x86_make_disp (G->r_esp, a->param[0] + 4));
|
||||
x87_fcomp (&G->f, x86_make_disp (G->r_esp, a->param[1] + 4));
|
||||
x87_fnstsw (&G->f, G->r_eax);
|
||||
/* TODO: use test r8,imm8 */
|
||||
x86_mov_reg_imm (&G->f, G->r_ecx, 0x4000);
|
||||
x86_test (&G->f, G->r_eax, G->r_ecx);
|
||||
{
|
||||
GLfloat one = 1.0f, zero = 0.0f;
|
||||
GLubyte *lab0, *lab1;
|
||||
|
||||
/* TODO: use jcc rel8 */
|
||||
lab0 = x86_jcc_forward (&G->f, cc_E);
|
||||
x86_mov_reg_imm (&G->f, G->r_ecx, *((GLint *) &one));
|
||||
/* TODO: use jmp rel8 */
|
||||
lab1 = x86_jmp_forward (&G->f);
|
||||
x86_fixup_fwd_jump (&G->f, lab0);
|
||||
x86_mov_reg_imm (&G->f, G->r_ecx, *((GLint *) &zero));
|
||||
x86_fixup_fwd_jump (&G->f, lab1);
|
||||
x86_mov (&G->f, x86_deref (G->r_esp), G->r_ecx);
|
||||
}
|
||||
break;
|
||||
case slang_asm_float_to_int:
|
||||
x87_fld (&G->f, x86_deref (G->r_esp));
|
||||
x87_fistp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_sine:
|
||||
/* TODO: use fsin */
|
||||
x86_call (&G->f, (GLubyte *) _mesa_sinf);
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_arcsine:
|
||||
/* TODO: use fpatan (?) */
|
||||
x86_call (&G->f, (GLubyte *) _mesa_asinf);
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_arctan:
|
||||
/* TODO: use fpatan */
|
||||
x86_call (&G->f, (GLubyte *) _mesa_atanf);
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_power:
|
||||
x87_fld (&G->f, x86_deref (G->r_esp));
|
||||
x87_fld (&G->f, x86_make_disp (G->r_esp, 4));
|
||||
x87_fyl2x (&G->f);
|
||||
emit_x87_ex2 (G);
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, 4));
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_log2:
|
||||
x87_fld1 (&G->f);
|
||||
x87_fld (&G->f, x86_deref (G->r_esp));
|
||||
x87_fyl2x (&G->f);
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_floor:
|
||||
set_fpu_round_neg_inf (G);
|
||||
x87_fld (&G->f, x86_deref (G->r_esp));
|
||||
x87_fprndint (&G->f);
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_ceil:
|
||||
/* TODO: use frndint */
|
||||
x86_call (&G->f, (GLubyte *) do_ceilf);
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_noise1:
|
||||
x86_call (&G->f, (GLubyte *) _slang_library_noise1);
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_noise2:
|
||||
x86_call (&G->f, (GLubyte *) _slang_library_noise2);
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, 4));
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_noise3:
|
||||
x86_call (&G->f, (GLubyte *) _slang_library_noise4);
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, 8));
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_float_noise4:
|
||||
x86_call (&G->f, (GLubyte *) _slang_library_noise4);
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, 12));
|
||||
x87_fstp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_int_to_float:
|
||||
break;
|
||||
case slang_asm_int_to_addr:
|
||||
x87_fld (&G->f, x86_deref (G->r_esp));
|
||||
x87_fistp (&G->f, x86_deref (G->r_esp));
|
||||
break;
|
||||
case slang_asm_addr_copy:
|
||||
x86_pop (&G->f, G->r_eax);
|
||||
x86_mov (&G->f, G->r_ecx, x86_deref (G->r_esp));
|
||||
x86_mov (&G->f, x86_deref (G->r_ecx), G->r_eax);
|
||||
break;
|
||||
case slang_asm_addr_push:
|
||||
/* TODO: use push imm32 */
|
||||
x86_mov_reg_imm (&G->f, G->r_eax, (GLint) a->param[0]);
|
||||
x86_push (&G->f, G->r_eax);
|
||||
break;
|
||||
case slang_asm_addr_add:
|
||||
x86_pop (&G->f, G->r_eax);
|
||||
x86_add (&G->f, x86_deref (G->r_esp), G->r_eax);
|
||||
break;
|
||||
case slang_asm_addr_multiply:
|
||||
x86_pop (&G->f, G->r_ecx);
|
||||
x86_mov (&G->f, G->r_eax, x86_deref (G->r_esp));
|
||||
x86_mul (&G->f, G->r_ecx);
|
||||
x86_mov (&G->f, x86_deref (G->r_esp), G->r_eax);
|
||||
break;
|
||||
case slang_asm_vec4_tex2d:
|
||||
x86_call (&G->f, (GLubyte *) do_vec4_tex2d);
|
||||
x86_lea (&G->f, G->r_ebp, x86_make_disp (G->r_esp, 12));
|
||||
break;
|
||||
case slang_asm_jump:
|
||||
add_fixup (G, a->param[0], x86_jmp_forward (&G->f));
|
||||
break;
|
||||
case slang_asm_jump_if_zero:
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, 4));
|
||||
x86_xor (&G->f, G->r_eax, G->r_eax);
|
||||
x86_cmp (&G->f, G->r_eax, x86_make_disp (G->r_esp, -4));
|
||||
{
|
||||
GLubyte *lab0;
|
||||
|
||||
/* TODO: use jcc rel8 */
|
||||
lab0 = x86_jcc_forward (&G->f, cc_NE);
|
||||
add_fixup (G, a->param[0], x86_jmp_forward (&G->f));
|
||||
x86_fixup_fwd_jump (&G->f, lab0);
|
||||
}
|
||||
break;
|
||||
case slang_asm_enter:
|
||||
/* FIXME: x86_make_disp(esp, 0) + x86_lea() generates bogus code */
|
||||
assert (a->param[0] != 0);
|
||||
x86_push (&G->f, G->r_ebp);
|
||||
x86_lea (&G->f, G->r_ebp, x86_make_disp (G->r_esp, (GLint) a->param[0]));
|
||||
break;
|
||||
case slang_asm_leave:
|
||||
x86_pop (&G->f, G->r_ebp);
|
||||
break;
|
||||
case slang_asm_local_alloc:
|
||||
/* FIXME: x86_make_disp(esp, 0) + x86_lea() generates bogus code */
|
||||
assert (a->param[0] != 0);
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, -(GLint) a->param[0]));
|
||||
break;
|
||||
case slang_asm_local_free:
|
||||
/* FIXME: x86_make_disp(esp, 0) + x86_lea() generates bogus code */
|
||||
assert (a->param[0] != 0);
|
||||
x86_lea (&G->f, G->r_esp, x86_make_disp (G->r_esp, (GLint) a->param[0]));
|
||||
break;
|
||||
case slang_asm_local_addr:
|
||||
disp = -(GLint) (a->param[0] + a->param[1]) + 4;
|
||||
if (disp != 0)
|
||||
{
|
||||
x86_lea (&G->f, G->r_eax, x86_make_disp (G->r_ebp, disp));
|
||||
x86_push (&G->f, G->r_eax);
|
||||
}
|
||||
else
|
||||
x86_push (&G->f, G->r_ebp);
|
||||
break;
|
||||
case slang_asm_global_addr:
|
||||
/* TODO: use push imm32 */
|
||||
x86_mov_reg_imm (&G->f, G->r_eax, (GLint) &G->mach->mem + a->param[0]);
|
||||
x86_push (&G->f, G->r_eax);
|
||||
break;
|
||||
case slang_asm_call:
|
||||
add_fixup (G, a->param[0], x86_call_forward (&G->f));
|
||||
break;
|
||||
case slang_asm_return:
|
||||
x86_ret (&G->f);
|
||||
break;
|
||||
case slang_asm_discard:
|
||||
x86_jmp (&G->f, G->l_discard);
|
||||
break;
|
||||
case slang_asm_exit:
|
||||
x86_jmp (&G->f, G->l_exit);
|
||||
break;
|
||||
/* mesa-specific extensions */
|
||||
case slang_asm_float_print:
|
||||
x86_call (&G->f, (GLubyte *) do_print_float);
|
||||
break;
|
||||
case slang_asm_int_print:
|
||||
x86_call (&G->f, (GLubyte *) do_print_int);
|
||||
break;
|
||||
case slang_asm_bool_print:
|
||||
x86_call (&G->f, (GLubyte *) do_print_bool);
|
||||
break;
|
||||
default:
|
||||
assert (0);
|
||||
}
|
||||
}
|
||||
|
||||
GLboolean _slang_x86_codegen (slang_machine *mach, slang_assembly_file *file, GLuint start)
|
||||
{
|
||||
codegen_ctx G;
|
||||
GLubyte *j_body, *j_exit;
|
||||
GLuint i;
|
||||
|
||||
x86_init_func_size (&G.f, 4*1048576);
|
||||
G.r_eax = x86_make_reg (file_REG32, reg_AX);
|
||||
G.r_ecx = x86_make_reg (file_REG32, reg_CX);
|
||||
G.r_edx = x86_make_reg (file_REG32, reg_DX);
|
||||
G.r_esp = x86_make_reg (file_REG32, reg_SP);
|
||||
G.r_ebp = x86_make_reg (file_REG32, reg_BP);
|
||||
G.r_st0 = x86_make_reg (file_x87, 0);
|
||||
G.r_st1 = x86_make_reg (file_x87, 1);
|
||||
G.r_st2 = x86_make_reg (file_x87, 2);
|
||||
G.r_st3 = x86_make_reg (file_x87, 3);
|
||||
G.fixups = NULL;
|
||||
G.fixup_count = 0;
|
||||
G.labels = (GLubyte **) slang_alloc_malloc (file->count * sizeof (GLubyte *));
|
||||
G.mach = mach;
|
||||
G.fpucntl = RESTORE_FPU;
|
||||
|
||||
mach->x86.fpucntl_rnd_neg = RND_NEG_FPU;
|
||||
mach->x86.fpucntl_restore = RESTORE_FPU;
|
||||
|
||||
/* prepare stack and jump to start */
|
||||
x86_push (&G.f, G.r_ebp);
|
||||
x86_mov_reg_imm (&G.f, G.r_eax, (GLint) &mach->x86.esp_restore);
|
||||
x86_push (&G.f, G.r_esp);
|
||||
x86_pop (&G.f, G.r_ecx);
|
||||
x86_mov (&G.f, x86_deref (G.r_eax), G.r_ecx);
|
||||
j_body = x86_jmp_forward (&G.f);
|
||||
|
||||
/* discard keywords go here */
|
||||
G.l_discard = x86_get_label (&G.f);
|
||||
x86_mov_reg_imm (&G.f, G.r_eax, (GLint) &G.mach->kill);
|
||||
x86_mov_reg_imm (&G.f, G.r_ecx, 1);
|
||||
x86_mov (&G.f, x86_deref (G.r_eax), G.r_ecx);
|
||||
G.l_exit = x86_get_label (&G.f);
|
||||
j_exit = x86_jmp_forward (&G.f);
|
||||
|
||||
for (i = 0; i < file->count; i++)
|
||||
{
|
||||
G.labels[i] = x86_get_label (&G.f);
|
||||
if (i == start)
|
||||
x86_fixup_fwd_jump (&G.f, j_body);
|
||||
codegen_assem (&G, &file->code[i]);
|
||||
}
|
||||
|
||||
/* restore stack and return */
|
||||
x86_fixup_fwd_jump (&G.f, j_exit);
|
||||
x86_mov_reg_imm (&G.f, G.r_eax, (GLint) &mach->x86.esp_restore);
|
||||
x86_mov (&G.f, G.r_esp, x86_deref (G.r_eax));
|
||||
x86_pop (&G.f, G.r_ebp);
|
||||
if (G.fpucntl != RESTORE_FPU)
|
||||
{
|
||||
x87_fnclex (&G.f);
|
||||
x86_mov_reg_imm (&G.f, G.r_eax, (GLint) &G.mach->x86.fpucntl_restore);
|
||||
x87_fldcw (&G.f, x86_deref (G.r_eax));
|
||||
}
|
||||
x86_ret (&G.f);
|
||||
|
||||
/* fixup forward labels */
|
||||
for (i = 0; i < G.fixup_count; i++)
|
||||
{
|
||||
G.f.csr = G.labels[G.fixups[i].index];
|
||||
x86_fixup_fwd_jump (&G.f, G.fixups[i].csr);
|
||||
}
|
||||
|
||||
slang_alloc_free (G.fixups);
|
||||
slang_alloc_free (G.labels);
|
||||
|
||||
/* TODO: free previous instance, if not NULL */
|
||||
mach->x86.compiled_func = (GLvoid (*) (slang_machine *)) x86_get_func (&G.f);
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -29,7 +29,6 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_export.h"
|
||||
|
||||
/*
|
||||
|
@ -122,6 +121,56 @@ slang_export_data_entry *slang_export_data_table_add (slang_export_data_table *s
|
|||
return &self->entries[n];
|
||||
}
|
||||
|
||||
/*
|
||||
* slang_export_code_entry
|
||||
*/
|
||||
|
||||
GLvoid slang_export_code_entry_ctr (slang_export_code_entry *self)
|
||||
{
|
||||
self->name = SLANG_ATOM_NULL;
|
||||
self->address = ~0;
|
||||
}
|
||||
|
||||
GLvoid slang_export_code_entry_dtr (slang_export_code_entry *self)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
* slang_export_code_table
|
||||
*/
|
||||
|
||||
GLvoid slang_export_code_table_ctr (slang_export_code_table *self)
|
||||
{
|
||||
self->entries = NULL;
|
||||
self->count = 0;
|
||||
self->atoms = NULL;
|
||||
}
|
||||
|
||||
GLvoid slang_export_code_table_dtr (slang_export_code_table *self)
|
||||
{
|
||||
if (self->entries != NULL)
|
||||
{
|
||||
GLuint i;
|
||||
|
||||
for (i = 0; i < self->count; i++)
|
||||
slang_export_code_entry_dtr (&self->entries[i]);
|
||||
slang_alloc_free (self->entries);
|
||||
}
|
||||
}
|
||||
|
||||
slang_export_code_entry *slang_export_code_table_add (slang_export_code_table *self)
|
||||
{
|
||||
const GLuint n = self->count;
|
||||
|
||||
self->entries = (slang_export_code_entry *) slang_alloc_realloc (self->entries,
|
||||
n * sizeof (slang_export_code_entry), (n + 1) * sizeof (slang_export_code_entry));
|
||||
if (self->entries == NULL)
|
||||
return NULL;
|
||||
slang_export_code_entry_ctr (&self->entries[n]);
|
||||
self->count++;
|
||||
return &self->entries[n];
|
||||
}
|
||||
|
||||
/*
|
||||
* _slang_find_exported_data()
|
||||
*/
|
||||
|
|
|
@ -25,6 +25,8 @@
|
|||
#if !defined SLANG_EXPORT_H
|
||||
#define SLANG_EXPORT_H
|
||||
|
||||
#include "slang_utility.h"
|
||||
|
||||
#if defined __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
@ -82,7 +84,7 @@ GLvoid slang_export_data_entry_ctr (slang_export_data_entry *);
|
|||
GLvoid slang_export_data_entry_dtr (slang_export_data_entry *);
|
||||
|
||||
/*
|
||||
* Data export table. Holds <count> elements in <entries> array.
|
||||
* Data export table.
|
||||
*/
|
||||
|
||||
typedef struct
|
||||
|
@ -96,6 +98,31 @@ GLvoid slang_export_data_table_ctr (slang_export_data_table *);
|
|||
GLvoid slang_export_data_table_dtr (slang_export_data_table *);
|
||||
slang_export_data_entry *slang_export_data_table_add (slang_export_data_table *);
|
||||
|
||||
/*
|
||||
* Code export entry. Contains label name and its entry point (label, address).
|
||||
*/
|
||||
|
||||
typedef struct
|
||||
{
|
||||
slang_atom name;
|
||||
GLuint address;
|
||||
} slang_export_code_entry;
|
||||
|
||||
/*
|
||||
* Code export table.
|
||||
*/
|
||||
|
||||
typedef struct
|
||||
{
|
||||
slang_export_code_entry *entries;
|
||||
GLuint count;
|
||||
slang_atom_pool *atoms;
|
||||
} slang_export_code_table;
|
||||
|
||||
GLvoid slang_export_code_table_ctr (slang_export_code_table *);
|
||||
GLvoid slang_export_code_table_dtr (slang_export_code_table *);
|
||||
slang_export_code_entry *slang_export_code_table_add (slang_export_code_table *);
|
||||
|
||||
/*
|
||||
* _slang_find_exported_data()
|
||||
*
|
||||
|
|
|
@ -22,28 +22,11 @@
|
|||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_library_noise.h"
|
||||
|
||||
/*
|
||||
* SimplexNoise1234
|
||||
* Copyright © 2003-2005, Stefan Gustavson
|
||||
*
|
||||
* Contact: stegu@itn.liu.se
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
/** \file
|
||||
|
@ -66,6 +49,9 @@
|
|||
*/
|
||||
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_library_noise.h"
|
||||
|
||||
#define FASTFLOOR(x) ( ((x)>0) ? ((int)x) : (((int)x)-1) )
|
||||
|
||||
/*
|
||||
|
|
|
@ -29,9 +29,6 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_compile.h"
|
||||
#include "slang_export.h"
|
||||
#include "slang_link.h"
|
||||
|
||||
/*
|
||||
|
@ -134,14 +131,94 @@ static GLboolean gather_uniform_bindings (slang_uniform_bindings *bind, slang_ex
|
|||
GLuint i;
|
||||
|
||||
for (i = 0; i < tbl->count; i++)
|
||||
{
|
||||
char name[1024] = "";
|
||||
if (tbl->entries[i].access == slang_exp_uniform)
|
||||
{
|
||||
char name[1024] = "";
|
||||
|
||||
if (!insert_binding (bind, &tbl->entries[i].quant, name, tbl->atoms, index,
|
||||
tbl->entries[i].address))
|
||||
return GL_FALSE;
|
||||
if (!insert_binding (bind, &tbl->entries[i].quant, name, tbl->atoms, index,
|
||||
tbl->entries[i].address))
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* slang_active_uniforms
|
||||
*/
|
||||
|
||||
static GLvoid slang_active_uniforms_ctr (slang_active_uniforms *self)
|
||||
{
|
||||
self->table = NULL;
|
||||
self->count = 0;
|
||||
}
|
||||
|
||||
static GLvoid slang_active_uniforms_dtr (slang_active_uniforms *self)
|
||||
{
|
||||
GLuint i;
|
||||
|
||||
for (i = 0; i < self->count; i++)
|
||||
slang_alloc_free (self->table[i].name);
|
||||
slang_alloc_free (self->table);
|
||||
}
|
||||
|
||||
static GLboolean slang_active_uniforms_add (slang_active_uniforms *self, slang_export_data_quant *q,
|
||||
const char *name)
|
||||
{
|
||||
const GLuint n = self->count;
|
||||
|
||||
self->table = (slang_active_uniform *) slang_alloc_realloc (self->table,
|
||||
n * sizeof (slang_active_uniform), (n + 1) * sizeof (slang_active_uniform));
|
||||
if (self->table == NULL)
|
||||
return GL_FALSE;
|
||||
self->table[n].quant = q;
|
||||
self->table[n].name = slang_string_duplicate (name);
|
||||
if (self->table[n].name == NULL)
|
||||
return GL_FALSE;
|
||||
self->count++;
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
static GLboolean insert_uniform (slang_active_uniforms *u, slang_export_data_quant *q, char *name,
|
||||
slang_atom_pool *atoms)
|
||||
{
|
||||
slang_string_concat (name, slang_atom_pool_id (atoms, q->name));
|
||||
if (q->array_len != 0)
|
||||
slang_string_concat (name, "[0]");
|
||||
|
||||
if (q->structure != NULL)
|
||||
{
|
||||
GLuint save, i;
|
||||
|
||||
slang_string_concat (name, ".");
|
||||
save = slang_string_length (name);
|
||||
|
||||
for (i = 0; i < q->u.field_count; i++)
|
||||
{
|
||||
if (!insert_uniform (u, &q->structure[i], name, atoms))
|
||||
return GL_FALSE;
|
||||
name[save] = '\0';
|
||||
}
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
return slang_active_uniforms_add (u, q, name);
|
||||
}
|
||||
|
||||
static GLboolean gather_active_uniforms (slang_active_uniforms *u, slang_export_data_table *tbl)
|
||||
{
|
||||
GLuint i;
|
||||
|
||||
for (i = 0; i < tbl->count; i++)
|
||||
if (tbl->entries[i].access == slang_exp_uniform)
|
||||
{
|
||||
char name[1024] = "";
|
||||
|
||||
if (!insert_uniform (u, &tbl->entries[i].quant, name, tbl->atoms))
|
||||
return GL_FALSE;
|
||||
}
|
||||
|
||||
return GL_TRUE;
|
||||
}
|
||||
|
||||
|
@ -151,18 +228,159 @@ static GLboolean gather_uniform_bindings (slang_uniform_bindings *bind, slang_ex
|
|||
|
||||
GLvoid slang_program_ctr (slang_program *self)
|
||||
{
|
||||
GLuint i;
|
||||
|
||||
slang_uniform_bindings_ctr (&self->uniforms);
|
||||
slang_active_uniforms_ctr (&self->active_uniforms);
|
||||
for (i = 0; i < SLANG_UNIFORM_BINDING_MAX; i++)
|
||||
{
|
||||
GLuint j;
|
||||
|
||||
for (j = 0; j < SLANG_COMMON_FIXED_MAX; j++)
|
||||
self->common_fixed_entries[i][j] = ~0;
|
||||
self->code[i] = ~0;
|
||||
self->machines[i] = NULL;
|
||||
self->assemblies[i] = NULL;
|
||||
}
|
||||
for (i = 0; i < SLANG_VERTEX_FIXED_MAX; i++)
|
||||
self->vertex_fixed_entries[i] = ~0;
|
||||
for (i = 0; i < SLANG_FRAGMENT_FIXED_MAX; i++)
|
||||
self->fragment_fixed_entries[i] = ~0;
|
||||
}
|
||||
|
||||
GLvoid slang_program_dtr (slang_program *self)
|
||||
{
|
||||
slang_uniform_bindings_dtr (&self->uniforms);
|
||||
slang_active_uniforms_dtr (&self->active_uniforms);
|
||||
}
|
||||
|
||||
/*
|
||||
* _slang_link()
|
||||
*/
|
||||
|
||||
static GLuint gd (slang_export_data_table *tbl, const char *name)
|
||||
{
|
||||
slang_atom atom;
|
||||
GLuint i;
|
||||
|
||||
atom = slang_atom_pool_atom (tbl->atoms, name);
|
||||
if (atom == SLANG_ATOM_NULL)
|
||||
return ~0;
|
||||
|
||||
for (i = 0; i < tbl->count; i++)
|
||||
if (atom == tbl->entries[i].quant.name)
|
||||
return tbl->entries[i].address;
|
||||
return ~0;
|
||||
}
|
||||
|
||||
static GLvoid fill_common_fixed_entries (GLuint e[], slang_export_data_table *tbl)
|
||||
{
|
||||
e[SLANG_COMMON_FIXED_MODELVIEWMATRIX] = gd (tbl, "gl_ModelViewMatrix");
|
||||
e[SLANG_COMMON_FIXED_PROJECTIONMATRIX] = gd (tbl, "gl_ProjectionMatrix");
|
||||
e[SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIX] = gd (tbl, "gl_ModelViewProjectionMatrix");
|
||||
e[SLANG_COMMON_FIXED_TEXTUREMATRIX] = gd (tbl, "gl_TextureMatrix");
|
||||
e[SLANG_COMMON_FIXED_NORMALMATRIX] = gd (tbl, "gl_NormalMatrix");
|
||||
e[SLANG_COMMON_FIXED_MODELVIEWMATRIXINVERSE] = gd (tbl, "gl_ModelViewMatrixInverse");
|
||||
e[SLANG_COMMON_FIXED_PROJECTIONMATRIXINVERSE] = gd (tbl, "gl_ProjectionMatrixInverse");
|
||||
e[SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXINVERSE] =
|
||||
gd (tbl, "gl_ModelViewProjectionMatrixInverse");
|
||||
e[SLANG_COMMON_FIXED_TEXTUREMATRIXINVERSE] = gd (tbl, "gl_TextureMatrixInverse");
|
||||
e[SLANG_COMMON_FIXED_MODELVIEWMATRIXTRANSPOSE] = gd (tbl, "gl_ModelViewMatrixTranspose");
|
||||
e[SLANG_COMMON_FIXED_PROJECTIONMATRIXTRANSPOSE] = gd (tbl, "gl_ProjectionMatrixTranspose");
|
||||
e[SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXTRANSPOSE] =
|
||||
gd (tbl, "gl_ModelViewProjectionMatrixTranspose");
|
||||
e[SLANG_COMMON_FIXED_TEXTUREMATRIXTRANSPOSE] = gd (tbl, "gl_TextureMatrixTranspose");
|
||||
e[SLANG_COMMON_FIXED_MODELVIEWMATRIXINVERSETRANSPOSE] =
|
||||
gd (tbl, "gl_ModelViewMatrixInverseTranspose");
|
||||
e[SLANG_COMMON_FIXED_PROJECTIONMATRIXINVERSETRANSPOSE] =
|
||||
gd (tbl, "gl_ProjectionMatrixInverseTranspose");
|
||||
e[SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXINVERSETRANSPOSE] =
|
||||
gd (tbl, "gl_ModelViewProjectionMatrixInverseTranspose");
|
||||
e[SLANG_COMMON_FIXED_TEXTUREMATRIXINVERSETRANSPOSE] =
|
||||
gd (tbl, "gl_TextureMatrixInverseTranspose");
|
||||
e[SLANG_COMMON_FIXED_NORMALSCALE] = gd (tbl, "gl_NormalScale");
|
||||
e[SLANG_COMMON_FIXED_DEPTHRANGE] = gd (tbl, "gl_DepthRange");
|
||||
e[SLANG_COMMON_FIXED_CLIPPLANE] = gd (tbl, "gl_ClipPlane");
|
||||
e[SLANG_COMMON_FIXED_POINT] = gd (tbl, "gl_Point");
|
||||
e[SLANG_COMMON_FIXED_FRONTMATERIAL] = gd (tbl, "gl_FrontMaterial");
|
||||
e[SLANG_COMMON_FIXED_BACKMATERIAL] = gd (tbl, "gl_BackMaterial");
|
||||
e[SLANG_COMMON_FIXED_LIGHTSOURCE] = gd (tbl, "gl_LightSource");
|
||||
e[SLANG_COMMON_FIXED_LIGHTMODEL] = gd (tbl, "gl_LightModel");
|
||||
e[SLANG_COMMON_FIXED_FRONTLIGHTMODELPRODUCT] = gd (tbl, "gl_FrontLightModelProduct");
|
||||
e[SLANG_COMMON_FIXED_BACKLIGHTMODELPRODUCT] = gd (tbl, "gl_BackLightModelProduct");
|
||||
e[SLANG_COMMON_FIXED_FRONTLIGHTPRODUCT] = gd (tbl, "gl_FrontLightProduct");
|
||||
e[SLANG_COMMON_FIXED_BACKLIGHTPRODUCT] = gd (tbl, "gl_BackLightProduct");
|
||||
e[SLANG_COMMON_FIXED_TEXTUREENVCOLOR] = gd (tbl, "gl_TextureEnvColor");
|
||||
e[SLANG_COMMON_FIXED_EYEPLANES] = gd (tbl, "gl_EyePlaneS");
|
||||
e[SLANG_COMMON_FIXED_EYEPLANET] = gd (tbl, "gl_EyePlaneT");
|
||||
e[SLANG_COMMON_FIXED_EYEPLANER] = gd (tbl, "gl_EyePlaneR");
|
||||
e[SLANG_COMMON_FIXED_EYEPLANEQ] = gd (tbl, "gl_EyePlaneQ");
|
||||
e[SLANG_COMMON_FIXED_OBJECTPLANES] = gd (tbl, "gl_ObjectPlaneS");
|
||||
e[SLANG_COMMON_FIXED_OBJECTPLANET] = gd (tbl, "gl_ObjectPlaneT");
|
||||
e[SLANG_COMMON_FIXED_OBJECTPLANER] = gd (tbl, "gl_ObjectPlaneR");
|
||||
e[SLANG_COMMON_FIXED_OBJECTPLANEQ] = gd (tbl, "gl_ObjectPlaneQ");
|
||||
e[SLANG_COMMON_FIXED_FOG] = gd (tbl, "gl_Fog");
|
||||
}
|
||||
|
||||
static GLvoid fill_vertex_fixed_entries (GLuint e[], slang_export_data_table *tbl)
|
||||
{
|
||||
e[SLANG_VERTEX_FIXED_POSITION] = gd (tbl, "gl_Position");
|
||||
e[SLANG_VERTEX_FIXED_POINTSIZE] = gd (tbl, "gl_PointSize");
|
||||
e[SLANG_VERTEX_FIXED_CLIPVERTEX] = gd (tbl, "gl_ClipVertex");
|
||||
e[SLANG_VERTEX_FIXED_COLOR] = gd (tbl, "gl_Color");
|
||||
e[SLANG_VERTEX_FIXED_SECONDARYCOLOR] = gd (tbl, "gl_SecondaryColor");
|
||||
e[SLANG_VERTEX_FIXED_NORMAL] = gd (tbl, "gl_Normal");
|
||||
e[SLANG_VERTEX_FIXED_VERTEX] = gd (tbl, "gl_Vertex");
|
||||
e[SLANG_VERTEX_FIXED_MULTITEXCOORD0] = gd (tbl, "gl_MultiTexCoord0");
|
||||
e[SLANG_VERTEX_FIXED_MULTITEXCOORD1] = gd (tbl, "gl_MultiTexCoord1");
|
||||
e[SLANG_VERTEX_FIXED_MULTITEXCOORD2] = gd (tbl, "gl_MultiTexCoord2");
|
||||
e[SLANG_VERTEX_FIXED_MULTITEXCOORD3] = gd (tbl, "gl_MultiTexCoord3");
|
||||
e[SLANG_VERTEX_FIXED_MULTITEXCOORD4] = gd (tbl, "gl_MultiTexCoord4");
|
||||
e[SLANG_VERTEX_FIXED_MULTITEXCOORD5] = gd (tbl, "gl_MultiTexCoord5");
|
||||
e[SLANG_VERTEX_FIXED_MULTITEXCOORD6] = gd (tbl, "gl_MultiTexCoord6");
|
||||
e[SLANG_VERTEX_FIXED_MULTITEXCOORD7] = gd (tbl, "gl_MultiTexCoord7");
|
||||
e[SLANG_VERTEX_FIXED_FOGCOORD] = gd (tbl, "gl_FogCoord");
|
||||
e[SLANG_VERTEX_FIXED_FRONTCOLOR] = gd (tbl, "gl_FrontColor");
|
||||
e[SLANG_VERTEX_FIXED_BACKCOLOR] = gd (tbl, "gl_BackColor");
|
||||
e[SLANG_VERTEX_FIXED_FRONTSECONDARYCOLOR] = gd (tbl, "gl_FrontSecondaryColor");
|
||||
e[SLANG_VERTEX_FIXED_BACKSECONDARYCOLOR] = gd (tbl, "gl_BackSecondaryColor");
|
||||
e[SLANG_VERTEX_FIXED_TEXCOORD] = gd (tbl, "gl_TexCoord");
|
||||
e[SLANG_VERTEX_FIXED_FOGFRAGCOORD] = gd (tbl, "gl_FogFragCoord");
|
||||
}
|
||||
|
||||
static GLvoid fill_fragment_fixed_entries (GLuint e[], slang_export_data_table *tbl)
|
||||
{
|
||||
e[SLANG_FRAGMENT_FIXED_FRAGCOORD] = gd (tbl, "gl_FragCoord");
|
||||
e[SLANG_FRAGMENT_FIXED_FRONTFACING] = gd (tbl, "gl_FrontFacing");
|
||||
e[SLANG_FRAGMENT_FIXED_FRAGCOLOR] = gd (tbl, "gl_FragColor");
|
||||
e[SLANG_FRAGMENT_FIXED_FRAGDATA] = gd (tbl, "gl_FragData");
|
||||
e[SLANG_FRAGMENT_FIXED_FRAGDEPTH] = gd (tbl, "gl_FragDepth");
|
||||
e[SLANG_FRAGMENT_FIXED_COLOR] = gd (tbl, "gl_Color");
|
||||
e[SLANG_FRAGMENT_FIXED_SECONDARYCOLOR] = gd (tbl, "gl_SecondaryColor");
|
||||
e[SLANG_FRAGMENT_FIXED_TEXCOORD] = gd (tbl, "gl_TexCoord");
|
||||
e[SLANG_FRAGMENT_FIXED_FOGFRAGCOORD] = gd (tbl, "gl_FogFragCoord");
|
||||
}
|
||||
|
||||
static GLuint gc (slang_export_code_table *tbl, const char *name)
|
||||
{
|
||||
slang_atom atom;
|
||||
GLuint i;
|
||||
|
||||
atom = slang_atom_pool_atom (tbl->atoms, name);
|
||||
if (atom == SLANG_ATOM_NULL)
|
||||
return ~0;
|
||||
|
||||
for (i = 0; i < tbl->count; i++)
|
||||
if (atom == tbl->entries[i].name)
|
||||
return tbl->entries[i].address;
|
||||
return ~0;
|
||||
}
|
||||
|
||||
static GLvoid resolve_code (GLuint code[], slang_export_code_table *tbl)
|
||||
{
|
||||
code[0] = gc (tbl, "@main");
|
||||
}
|
||||
|
||||
GLboolean _slang_link (slang_program *prog, slang_translation_unit **units, GLuint count)
|
||||
{
|
||||
GLuint i;
|
||||
|
@ -172,13 +390,24 @@ GLboolean _slang_link (slang_program *prog, slang_translation_unit **units, GLui
|
|||
GLuint index;
|
||||
|
||||
if (units[i]->type == slang_unit_fragment_shader)
|
||||
{
|
||||
index = SLANG_UNIFORM_BINDING_FRAGMENT;
|
||||
fill_fragment_fixed_entries (prog->fragment_fixed_entries, &units[i]->exp_data);
|
||||
}
|
||||
else
|
||||
{
|
||||
index = SLANG_UNIFORM_BINDING_VERTEX;
|
||||
fill_vertex_fixed_entries (prog->vertex_fixed_entries, &units[i]->exp_data);
|
||||
}
|
||||
|
||||
if (!gather_uniform_bindings (&prog->uniforms, &units[i]->exp_data, index))
|
||||
return GL_FALSE;
|
||||
if (!gather_active_uniforms (&prog->active_uniforms, &units[i]->exp_data))
|
||||
return GL_FALSE;
|
||||
fill_common_fixed_entries (prog->common_fixed_entries[index], &units[i]->exp_data);
|
||||
resolve_code (&prog->code[index], &units[i]->exp_code);
|
||||
prog->machines[index] = units[i]->machine;
|
||||
prog->assemblies[index] = units[i]->assembly;
|
||||
}
|
||||
|
||||
return GL_TRUE;
|
||||
|
|
|
@ -25,16 +25,18 @@
|
|||
#if !defined SLANG_LINK_H
|
||||
#define SLANG_LINK_H
|
||||
|
||||
#include "slang_assemble.h"
|
||||
#include "slang_execute.h"
|
||||
#include "slang_compile.h"
|
||||
|
||||
#if defined __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define SLANG_UNIFORM_BINDING_VERTEX 0
|
||||
#define SLANG_UNIFORM_BINDING_FRAGMENT 1
|
||||
#define SLANG_UNIFORM_BINDING_MAX 2
|
||||
typedef enum
|
||||
{
|
||||
SLANG_UNIFORM_BINDING_VERTEX,
|
||||
SLANG_UNIFORM_BINDING_FRAGMENT,
|
||||
SLANG_UNIFORM_BINDING_MAX
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
|
@ -49,10 +51,113 @@ typedef struct
|
|||
GLuint count;
|
||||
} slang_uniform_bindings;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
slang_export_data_quant *quant;
|
||||
char *name;
|
||||
} slang_active_uniform;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
slang_active_uniform *table;
|
||||
GLuint count;
|
||||
} slang_active_uniforms;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
SLANG_COMMON_FIXED_MODELVIEWMATRIX,
|
||||
SLANG_COMMON_FIXED_PROJECTIONMATRIX,
|
||||
SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIX,
|
||||
SLANG_COMMON_FIXED_TEXTUREMATRIX,
|
||||
SLANG_COMMON_FIXED_NORMALMATRIX,
|
||||
SLANG_COMMON_FIXED_MODELVIEWMATRIXINVERSE,
|
||||
SLANG_COMMON_FIXED_PROJECTIONMATRIXINVERSE,
|
||||
SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXINVERSE,
|
||||
SLANG_COMMON_FIXED_TEXTUREMATRIXINVERSE,
|
||||
SLANG_COMMON_FIXED_MODELVIEWMATRIXTRANSPOSE,
|
||||
SLANG_COMMON_FIXED_PROJECTIONMATRIXTRANSPOSE,
|
||||
SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXTRANSPOSE,
|
||||
SLANG_COMMON_FIXED_TEXTUREMATRIXTRANSPOSE,
|
||||
SLANG_COMMON_FIXED_MODELVIEWMATRIXINVERSETRANSPOSE,
|
||||
SLANG_COMMON_FIXED_PROJECTIONMATRIXINVERSETRANSPOSE,
|
||||
SLANG_COMMON_FIXED_MODELVIEWPROJECTIONMATRIXINVERSETRANSPOSE,
|
||||
SLANG_COMMON_FIXED_TEXTUREMATRIXINVERSETRANSPOSE,
|
||||
SLANG_COMMON_FIXED_NORMALSCALE,
|
||||
SLANG_COMMON_FIXED_DEPTHRANGE,
|
||||
SLANG_COMMON_FIXED_CLIPPLANE,
|
||||
SLANG_COMMON_FIXED_POINT,
|
||||
SLANG_COMMON_FIXED_FRONTMATERIAL,
|
||||
SLANG_COMMON_FIXED_BACKMATERIAL,
|
||||
SLANG_COMMON_FIXED_LIGHTSOURCE,
|
||||
SLANG_COMMON_FIXED_LIGHTMODEL,
|
||||
SLANG_COMMON_FIXED_FRONTLIGHTMODELPRODUCT,
|
||||
SLANG_COMMON_FIXED_BACKLIGHTMODELPRODUCT,
|
||||
SLANG_COMMON_FIXED_FRONTLIGHTPRODUCT,
|
||||
SLANG_COMMON_FIXED_BACKLIGHTPRODUCT,
|
||||
SLANG_COMMON_FIXED_TEXTUREENVCOLOR,
|
||||
SLANG_COMMON_FIXED_EYEPLANES,
|
||||
SLANG_COMMON_FIXED_EYEPLANET,
|
||||
SLANG_COMMON_FIXED_EYEPLANER,
|
||||
SLANG_COMMON_FIXED_EYEPLANEQ,
|
||||
SLANG_COMMON_FIXED_OBJECTPLANES,
|
||||
SLANG_COMMON_FIXED_OBJECTPLANET,
|
||||
SLANG_COMMON_FIXED_OBJECTPLANER,
|
||||
SLANG_COMMON_FIXED_OBJECTPLANEQ,
|
||||
SLANG_COMMON_FIXED_FOG,
|
||||
SLANG_COMMON_FIXED_MAX
|
||||
};
|
||||
|
||||
typedef enum
|
||||
{
|
||||
SLANG_VERTEX_FIXED_POSITION,
|
||||
SLANG_VERTEX_FIXED_POINTSIZE,
|
||||
SLANG_VERTEX_FIXED_CLIPVERTEX,
|
||||
SLANG_VERTEX_FIXED_COLOR,
|
||||
SLANG_VERTEX_FIXED_SECONDARYCOLOR,
|
||||
SLANG_VERTEX_FIXED_NORMAL,
|
||||
SLANG_VERTEX_FIXED_VERTEX,
|
||||
SLANG_VERTEX_FIXED_MULTITEXCOORD0,
|
||||
SLANG_VERTEX_FIXED_MULTITEXCOORD1,
|
||||
SLANG_VERTEX_FIXED_MULTITEXCOORD2,
|
||||
SLANG_VERTEX_FIXED_MULTITEXCOORD3,
|
||||
SLANG_VERTEX_FIXED_MULTITEXCOORD4,
|
||||
SLANG_VERTEX_FIXED_MULTITEXCOORD5,
|
||||
SLANG_VERTEX_FIXED_MULTITEXCOORD6,
|
||||
SLANG_VERTEX_FIXED_MULTITEXCOORD7,
|
||||
SLANG_VERTEX_FIXED_FOGCOORD,
|
||||
SLANG_VERTEX_FIXED_FRONTCOLOR,
|
||||
SLANG_VERTEX_FIXED_BACKCOLOR,
|
||||
SLANG_VERTEX_FIXED_FRONTSECONDARYCOLOR,
|
||||
SLANG_VERTEX_FIXED_BACKSECONDARYCOLOR,
|
||||
SLANG_VERTEX_FIXED_TEXCOORD,
|
||||
SLANG_VERTEX_FIXED_FOGFRAGCOORD,
|
||||
SLANG_VERTEX_FIXED_MAX
|
||||
};
|
||||
|
||||
typedef enum
|
||||
{
|
||||
SLANG_FRAGMENT_FIXED_FRAGCOORD,
|
||||
SLANG_FRAGMENT_FIXED_FRONTFACING,
|
||||
SLANG_FRAGMENT_FIXED_FRAGCOLOR,
|
||||
SLANG_FRAGMENT_FIXED_FRAGDATA,
|
||||
SLANG_FRAGMENT_FIXED_FRAGDEPTH,
|
||||
SLANG_FRAGMENT_FIXED_COLOR,
|
||||
SLANG_FRAGMENT_FIXED_SECONDARYCOLOR,
|
||||
SLANG_FRAGMENT_FIXED_TEXCOORD,
|
||||
SLANG_FRAGMENT_FIXED_FOGFRAGCOORD,
|
||||
SLANG_FRAGMENT_FIXED_MAX
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
slang_uniform_bindings uniforms;
|
||||
slang_active_uniforms active_uniforms;
|
||||
GLuint common_fixed_entries[SLANG_UNIFORM_BINDING_MAX][SLANG_COMMON_FIXED_MAX];
|
||||
GLuint vertex_fixed_entries[SLANG_VERTEX_FIXED_MAX];
|
||||
GLuint fragment_fixed_entries[SLANG_FRAGMENT_FIXED_MAX];
|
||||
GLuint code[SLANG_UNIFORM_BINDING_MAX];
|
||||
slang_machine *machines[SLANG_UNIFORM_BINDING_MAX];
|
||||
slang_assembly_file *assemblies[SLANG_UNIFORM_BINDING_MAX];
|
||||
} slang_program;
|
||||
|
||||
GLvoid slang_program_ctr (slang_program *);
|
||||
|
|
|
@ -30,8 +30,6 @@
|
|||
|
||||
#include "imports.h"
|
||||
#include "grammar_mesa.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_compile.h"
|
||||
#include "slang_preprocess.h"
|
||||
|
||||
static const char *slang_version_syn =
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
/*
|
||||
* Mesa 3-D graphics library
|
||||
* Version: 6.3
|
||||
* Version: 6.5
|
||||
*
|
||||
* Copyright (C) 2005 Brian Paul All Rights Reserved.
|
||||
* Copyright (C) 2005-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"),
|
||||
|
@ -25,6 +25,8 @@
|
|||
#if !defined SLANG_PREPROCESS_H
|
||||
#define SLANG_PREPROCESS_H
|
||||
|
||||
#include "slang_compile.h"
|
||||
|
||||
#if defined __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
|
|
@ -29,10 +29,7 @@
|
|||
*/
|
||||
|
||||
#include "imports.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_storage.h"
|
||||
#include "slang_assemble.h"
|
||||
#include "slang_execute.h"
|
||||
|
||||
/* slang_storage_array */
|
||||
|
||||
|
|
|
@ -56,7 +56,7 @@ typedef enum slang_storage_type_
|
|||
* elements. They are also required to support indirect addressing. That is, if B references
|
||||
* first data slot in the array, S is the size of the data slot and I is the integral index that
|
||||
* is not known at compile time, B+I*S references I-th data slot.
|
||||
*
|
||||
*
|
||||
* This structure is also used to break down built-in data types that are not supported directly.
|
||||
* Vectors, like vec3, are constructed from arrays of their basic types. Matrices are formed of
|
||||
* an array of column vectors, which are in turn processed as other vectors.
|
||||
|
|
|
@ -61,8 +61,8 @@ typedef struct slang_atom_pool_
|
|||
slang_atom_entry *entries[SLANG_ATOM_POOL_SIZE];
|
||||
} slang_atom_pool;
|
||||
|
||||
void slang_atom_pool_construct (slang_atom_pool *);
|
||||
void slang_atom_pool_destruct (slang_atom_pool *);
|
||||
GLvoid slang_atom_pool_construct (slang_atom_pool *);
|
||||
GLvoid slang_atom_pool_destruct (slang_atom_pool *);
|
||||
slang_atom slang_atom_pool_atom (slang_atom_pool *, const char *);
|
||||
const char *slang_atom_pool_id (slang_atom_pool *, slang_atom);
|
||||
|
||||
|
|
|
@ -215,7 +215,8 @@ ASM_C_SOURCES = \
|
|||
x86/rtasm/x86sse.c \
|
||||
sparc/sparc.c \
|
||||
ppc/common_ppc.c \
|
||||
x86-64/x86-64.c
|
||||
x86-64/x86-64.c \
|
||||
shader/slang/slang_execute_x86.c
|
||||
|
||||
X86_SOURCES = \
|
||||
x86/common_x86_asm.S \
|
||||
|
|
|
@ -32,83 +32,63 @@
|
|||
#include "s_context.h"
|
||||
#include "shaderobjects.h"
|
||||
#include "shaderobjects_3dlabs.h"
|
||||
|
||||
|
||||
static void fetch_input_vec4 (const char *name, GLfloat *vec, GLuint index,
|
||||
struct gl2_fragment_shader_intf **fs)
|
||||
{
|
||||
_slang_fetch_vec4_f (fs, name, vec, index, 1);
|
||||
}
|
||||
|
||||
static void fetch_output_vec4 (const char *name, GLfloat *vec, GLuint index,
|
||||
struct gl2_fragment_shader_intf **fs)
|
||||
{
|
||||
_slang_fetch_vec4_f (fs, name, vec, index, 0);
|
||||
}
|
||||
#include "slang_utility.h"
|
||||
#include "slang_link.h"
|
||||
|
||||
void _swrast_exec_arbshader (GLcontext *ctx, struct sw_span *span)
|
||||
{
|
||||
struct gl2_program_intf **prog;
|
||||
struct gl2_fragment_shader_intf **fs = NULL;
|
||||
GLuint count, i;
|
||||
struct gl2_program_intf **pro;
|
||||
GLuint i;
|
||||
|
||||
prog = ctx->ShaderObjects.CurrentProgram;
|
||||
count = (**prog)._container.GetAttachedCount ((struct gl2_container_intf **) prog);
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
struct gl2_generic_intf **obj;
|
||||
struct gl2_unknown_intf **unk;
|
||||
|
||||
obj = (**prog)._container.GetAttached ((struct gl2_container_intf **) prog, i);
|
||||
unk = (**obj)._unknown.QueryInterface ((struct gl2_unknown_intf **) obj, UIID_FRAGMENT_SHADER);
|
||||
(**obj)._unknown.Release ((struct gl2_unknown_intf **) obj);
|
||||
if (unk != NULL)
|
||||
{
|
||||
fs = (struct gl2_fragment_shader_intf **) unk;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (fs == NULL)
|
||||
pro = ctx->ShaderObjects.CurrentProgram;
|
||||
if (pro == NULL)
|
||||
return;
|
||||
|
||||
for (i = span->start; i < span->end; i++)
|
||||
{
|
||||
GLfloat vec[4];
|
||||
GLuint j;
|
||||
GLboolean kill;
|
||||
GLboolean discard;
|
||||
|
||||
vec[0] = (GLfloat) span->x + i;
|
||||
vec[1] = (GLfloat) span->y;
|
||||
vec[2] = (GLfloat) span->array->z[i] / ctx->DrawBuffer->_DepthMaxF;
|
||||
vec[3] = span->w + span->dwdx * i;
|
||||
fetch_input_vec4 ("gl_FragCoord", vec, 0, fs);
|
||||
(**pro).UpdateFixedVarying (pro, SLANG_FRAGMENT_FIXED_FRAGCOORD, vec, 0,
|
||||
4 * sizeof (GLfloat), GL_TRUE);
|
||||
vec[0] = CHAN_TO_FLOAT(span->array->rgba[i][RCOMP]);
|
||||
vec[1] = CHAN_TO_FLOAT(span->array->rgba[i][GCOMP]);
|
||||
vec[2] = CHAN_TO_FLOAT(span->array->rgba[i][BCOMP]);
|
||||
vec[3] = CHAN_TO_FLOAT(span->array->rgba[i][ACOMP]);
|
||||
fetch_input_vec4 ("gl_Color", vec, 0, fs);
|
||||
(**pro).UpdateFixedVarying (pro, SLANG_FRAGMENT_FIXED_COLOR, vec, 0, 4 * sizeof (GLfloat),
|
||||
GL_TRUE);
|
||||
for (j = 0; j < ctx->Const.MaxTextureCoordUnits; j++)
|
||||
{
|
||||
vec[0] = span->array->texcoords[j][i][0];
|
||||
vec[1] = span->array->texcoords[j][i][1];
|
||||
vec[2] = span->array->texcoords[j][i][2];
|
||||
vec[3] = span->array->texcoords[j][i][3];
|
||||
fetch_input_vec4 ("gl_TexCoord", vec, j, fs);
|
||||
(**pro).UpdateFixedVarying (pro, SLANG_FRAGMENT_FIXED_TEXCOORD, vec, j,
|
||||
4 * sizeof (GLfloat), GL_TRUE);
|
||||
}
|
||||
|
||||
_slang_exec_fragment_shader (fs);
|
||||
_slang_exec_fragment_shader (pro);
|
||||
|
||||
_slang_fetch_discard (fs, &kill);
|
||||
if (kill)
|
||||
_slang_fetch_discard (pro, &discard);
|
||||
if (discard)
|
||||
{
|
||||
span->array->mask[i] = GL_FALSE;
|
||||
span->writeAll = GL_FALSE;
|
||||
}
|
||||
fetch_output_vec4 ("gl_FragColor", vec, 0, fs);
|
||||
UNCLAMPED_FLOAT_TO_CHAN(span->array->rgba[i][RCOMP], vec[0]);
|
||||
UNCLAMPED_FLOAT_TO_CHAN(span->array->rgba[i][GCOMP], vec[1]);
|
||||
UNCLAMPED_FLOAT_TO_CHAN(span->array->rgba[i][BCOMP], vec[2]);
|
||||
UNCLAMPED_FLOAT_TO_CHAN(span->array->rgba[i][ACOMP], vec[3]);
|
||||
else
|
||||
{
|
||||
(**pro).UpdateFixedVarying (pro, SLANG_FRAGMENT_FIXED_FRAGCOLOR, vec, 0,
|
||||
4 * sizeof (GLfloat), GL_FALSE);
|
||||
UNCLAMPED_FLOAT_TO_CHAN(span->array->rgba[i][RCOMP], vec[0]);
|
||||
UNCLAMPED_FLOAT_TO_CHAN(span->array->rgba[i][GCOMP], vec[1]);
|
||||
UNCLAMPED_FLOAT_TO_CHAN(span->array->rgba[i][BCOMP], vec[2]);
|
||||
UNCLAMPED_FLOAT_TO_CHAN(span->array->rgba[i][ACOMP], vec[3]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -32,6 +32,7 @@
|
|||
#include "shaderobjects_3dlabs.h"
|
||||
#include "t_pipeline.h"
|
||||
#include "slang_utility.h"
|
||||
#include "slang_link.h"
|
||||
|
||||
typedef struct
|
||||
{
|
||||
|
@ -90,42 +91,40 @@ static void validate_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stag
|
|||
{
|
||||
}
|
||||
|
||||
static void fetch_input_float (const char *name, GLuint attr, GLuint i, struct vertex_buffer *vb,
|
||||
struct gl2_vertex_shader_intf **vs)
|
||||
static GLvoid fetch_input_float (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
|
||||
struct vertex_buffer *vb)
|
||||
{
|
||||
const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
|
||||
/*const GLuint size = vb->AttribPtr[attr]->size;*/
|
||||
const GLuint stride = vb->AttribPtr[attr]->stride;
|
||||
const GLfloat *data = (const GLfloat *) (ptr + stride * i);
|
||||
float vec[1];
|
||||
GLfloat vec[1];
|
||||
|
||||
vec[0] = data[0];
|
||||
_slang_fetch_float (vs, name, vec, 1);
|
||||
(**pro).UpdateFixedAttribute (pro, index, vec, 0, sizeof (GLfloat), GL_TRUE);
|
||||
}
|
||||
|
||||
static void fetch_input_vec3 (const char *name, GLuint attr, GLuint i, struct vertex_buffer *vb,
|
||||
struct gl2_vertex_shader_intf **vs)
|
||||
static GLvoid fetch_input_vec3 (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
|
||||
struct vertex_buffer *vb)
|
||||
{
|
||||
const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
|
||||
/*const GLuint size = vb->AttribPtr[attr]->size;*/
|
||||
const GLuint stride = vb->AttribPtr[attr]->stride;
|
||||
const GLfloat *data = (const GLfloat *) (ptr + stride * i);
|
||||
float vec[3];
|
||||
GLfloat vec[3];
|
||||
|
||||
vec[0] = data[0];
|
||||
vec[1] = data[1];
|
||||
vec[2] = data[2];
|
||||
_slang_fetch_vec3 (vs, name, vec, 1);
|
||||
(**pro).UpdateFixedAttribute (pro, index, vec, 0, 3 * sizeof (GLfloat), GL_TRUE);
|
||||
}
|
||||
|
||||
static void fetch_input_vec4 (const char *name, GLuint attr, GLuint i, struct vertex_buffer *vb,
|
||||
struct gl2_vertex_shader_intf **vs)
|
||||
static void fetch_input_vec4 (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
|
||||
struct vertex_buffer *vb)
|
||||
{
|
||||
const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
|
||||
const GLuint size = vb->AttribPtr[attr]->size;
|
||||
const GLuint stride = vb->AttribPtr[attr]->stride;
|
||||
const GLfloat *data = (const GLfloat *) (ptr + stride * i);
|
||||
float vec[4];
|
||||
GLfloat vec[4];
|
||||
|
||||
switch (size)
|
||||
{
|
||||
|
@ -148,82 +147,21 @@ static void fetch_input_vec4 (const char *name, GLuint attr, GLuint i, struct ve
|
|||
vec[3] = data[3];
|
||||
break;
|
||||
}
|
||||
_slang_fetch_vec4 (vs, name, vec, 0, 1);
|
||||
(**pro).UpdateFixedAttribute (pro, index, vec, 0, 4 * sizeof (GLfloat), GL_TRUE);
|
||||
}
|
||||
|
||||
static void fetch_output_float (const char *name, GLuint attr, GLuint i, arbvs_stage_data *store,
|
||||
struct gl2_vertex_shader_intf **vs)
|
||||
static GLvoid fetch_output_float (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
|
||||
arbvs_stage_data *store)
|
||||
{
|
||||
float vec[1];
|
||||
|
||||
_slang_fetch_float (vs, name, vec, 0);
|
||||
_mesa_memcpy (&store->outputs[attr].data[i], vec, 4);
|
||||
(**pro).UpdateFixedAttribute (pro, index, &store->outputs[attr].data[i], 0, sizeof (GLfloat),
|
||||
GL_FALSE);
|
||||
}
|
||||
|
||||
static void fetch_output_vec4 (const char *name, GLuint attr, GLuint i, GLuint index,
|
||||
arbvs_stage_data *store, struct gl2_vertex_shader_intf **vs)
|
||||
static void fetch_output_vec4 (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
|
||||
GLuint offset, arbvs_stage_data *store)
|
||||
{
|
||||
float vec[4];
|
||||
|
||||
_slang_fetch_vec4 (vs, name, vec, index, 0);
|
||||
_mesa_memcpy (&store->outputs[attr].data[i], vec, 16);
|
||||
}
|
||||
|
||||
static void fetch_uniform_mat4 (const char *name, GLmatrix *matrix, GLuint index,
|
||||
struct gl2_vertex_shader_intf **vs)
|
||||
{
|
||||
GLuint len;
|
||||
GLfloat mat[16];
|
||||
char buffer[64];
|
||||
|
||||
_mesa_strcpy (buffer, name);
|
||||
len = _mesa_strlen (name);
|
||||
|
||||
/* we want inverse matrix */
|
||||
if (!matrix->inv)
|
||||
{
|
||||
/* allocate inverse matrix and make it dirty */
|
||||
_math_matrix_alloc_inv (matrix);
|
||||
_math_matrix_loadf (matrix, matrix->m);
|
||||
}
|
||||
_math_matrix_analyse (matrix);
|
||||
|
||||
/* identity */
|
||||
_slang_fetch_mat4 (vs, name, matrix->m, index, 1);
|
||||
|
||||
/* transpose */
|
||||
_mesa_strcpy (buffer + len, "Transpose");
|
||||
_math_transposef (mat, matrix->m);
|
||||
_slang_fetch_mat4 (vs, buffer, mat, index, 1);
|
||||
|
||||
/* inverse */
|
||||
_mesa_strcpy (buffer + len, "Inverse");
|
||||
_slang_fetch_mat4 (vs, buffer, matrix->inv, index, 1);
|
||||
|
||||
/* inverse transpose */
|
||||
_mesa_strcpy (buffer + len, "InverseTranspose");
|
||||
_math_transposef (mat, matrix->inv);
|
||||
_slang_fetch_mat4 (vs, buffer, mat, index, 1);
|
||||
}
|
||||
|
||||
static void fetch_normal_matrix (const char *name, GLmatrix *matrix,
|
||||
struct gl2_vertex_shader_intf **vs)
|
||||
{
|
||||
GLfloat mat[9];
|
||||
|
||||
_math_matrix_analyse (matrix);
|
||||
|
||||
/* inverse transpose */
|
||||
mat[0] = matrix->inv[0];
|
||||
mat[1] = matrix->inv[4];
|
||||
mat[2] = matrix->inv[8];
|
||||
mat[3] = matrix->inv[1];
|
||||
mat[4] = matrix->inv[5];
|
||||
mat[5] = matrix->inv[9];
|
||||
mat[6] = matrix->inv[2];
|
||||
mat[7] = matrix->inv[6];
|
||||
mat[8] = matrix->inv[10];
|
||||
_slang_fetch_mat3 (vs, name, mat, 0, 1);
|
||||
(**pro).UpdateFixedAttribute (pro, index, &store->outputs[attr].data[i], offset,
|
||||
4 * sizeof (GLfloat), GL_FALSE);
|
||||
}
|
||||
|
||||
static GLboolean run_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stage *stage)
|
||||
|
@ -231,82 +169,45 @@ static GLboolean run_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stag
|
|||
TNLcontext *tnl = TNL_CONTEXT(ctx);
|
||||
struct vertex_buffer *vb = &tnl->vb;
|
||||
arbvs_stage_data *store = ARBVS_STAGE_DATA(stage);
|
||||
struct gl2_program_intf **prog;
|
||||
struct gl2_vertex_shader_intf **vs = NULL;
|
||||
GLsizei count, i, j;
|
||||
struct gl2_program_intf **pro;
|
||||
GLsizei i, j;
|
||||
|
||||
prog = ctx->ShaderObjects.CurrentProgram;
|
||||
if (prog == NULL)
|
||||
pro = ctx->ShaderObjects.CurrentProgram;
|
||||
if (pro == NULL)
|
||||
return GL_TRUE;
|
||||
|
||||
count = (**prog)._container.GetAttachedCount ((struct gl2_container_intf **) prog);
|
||||
for (i = 0; i < count; i++)
|
||||
{
|
||||
struct gl2_generic_intf **obj;
|
||||
struct gl2_unknown_intf **unk;
|
||||
|
||||
obj = (**prog)._container.GetAttached ((struct gl2_container_intf **) prog, i);
|
||||
unk = (**obj)._unknown.QueryInterface ((struct gl2_unknown_intf **) obj, UIID_VERTEX_SHADER);
|
||||
(**obj)._unknown.Release ((struct gl2_unknown_intf **) obj);
|
||||
if (unk != NULL)
|
||||
{
|
||||
vs = (struct gl2_vertex_shader_intf **) unk;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (vs == NULL)
|
||||
return GL_TRUE;
|
||||
|
||||
fetch_uniform_mat4 ("gl_ModelViewMatrix", ctx->ModelviewMatrixStack.Top, 0, vs);
|
||||
fetch_uniform_mat4 ("gl_ProjectionMatrix", ctx->ProjectionMatrixStack.Top, 0, vs);
|
||||
fetch_uniform_mat4 ("gl_ModelViewProjectionMatrix", &ctx->_ModelProjectMatrix, 0, vs);
|
||||
for (j = 0; j < 8; j++)
|
||||
fetch_uniform_mat4 ("gl_TextureMatrix", ctx->TextureMatrixStack[j].Top, j, vs);
|
||||
fetch_normal_matrix ("gl_NormalMatrix", ctx->ModelviewMatrixStack.Top, vs);
|
||||
/* XXX: fetch uniform float gl_NormalScale */
|
||||
/* XXX: fetch uniform mat4 gl_ClipPlane */
|
||||
/* XXX: fetch uniform mat4 gl_TextureEnvColor */
|
||||
/* XXX: fetch uniform mat4 gl_EyePlaneS */
|
||||
/* XXX: fetch uniform mat4 gl_EyePlaneT */
|
||||
/* XXX: fetch uniform mat4 gl_EyePlaneR */
|
||||
/* XXX: fetch uniform mat4 gl_EyePlaneQ */
|
||||
/* XXX: fetch uniform mat4 gl_ObjectPlaneS */
|
||||
/* XXX: fetch uniform mat4 gl_ObjectPlaneT */
|
||||
/* XXX: fetch uniform mat4 gl_ObjectPlaneR */
|
||||
/* XXX: fetch uniform mat4 gl_ObjectPlaneQ */
|
||||
(**pro).UpdateFixedUniforms (pro);
|
||||
|
||||
for (i = 0; i < vb->Count; i++)
|
||||
{
|
||||
fetch_input_vec4 ("gl_Vertex", _TNL_ATTRIB_POS, i, vb, vs);
|
||||
fetch_input_vec3 ("gl_Normal", _TNL_ATTRIB_NORMAL, i, vb, vs);
|
||||
fetch_input_vec4 ("gl_Color", _TNL_ATTRIB_COLOR0, i, vb, vs);
|
||||
fetch_input_vec4 ("gl_SecondaryColor", _TNL_ATTRIB_COLOR1, i, vb, vs);
|
||||
fetch_input_float ("gl_FogCoord", _TNL_ATTRIB_FOG, i, vb, vs);
|
||||
fetch_input_vec4 ("gl_MultiTexCoord0", _TNL_ATTRIB_TEX0, i, vb, vs);
|
||||
fetch_input_vec4 ("gl_MultiTexCoord1", _TNL_ATTRIB_TEX1, i, vb, vs);
|
||||
fetch_input_vec4 ("gl_MultiTexCoord2", _TNL_ATTRIB_TEX2, i, vb, vs);
|
||||
fetch_input_vec4 ("gl_MultiTexCoord3", _TNL_ATTRIB_TEX3, i, vb, vs);
|
||||
fetch_input_vec4 ("gl_MultiTexCoord4", _TNL_ATTRIB_TEX4, i, vb, vs);
|
||||
fetch_input_vec4 ("gl_MultiTexCoord5", _TNL_ATTRIB_TEX5, i, vb, vs);
|
||||
fetch_input_vec4 ("gl_MultiTexCoord6", _TNL_ATTRIB_TEX6, i, vb, vs);
|
||||
fetch_input_vec4 ("gl_MultiTexCoord7", _TNL_ATTRIB_TEX7, i, vb, vs);
|
||||
fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_VERTEX, _TNL_ATTRIB_POS, i, vb);
|
||||
fetch_input_vec3 (pro, SLANG_VERTEX_FIXED_NORMAL, _TNL_ATTRIB_NORMAL, i, vb);
|
||||
fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_COLOR, _TNL_ATTRIB_COLOR0, i, vb);
|
||||
fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_SECONDARYCOLOR, _TNL_ATTRIB_COLOR1, i, vb);
|
||||
fetch_input_float (pro, SLANG_VERTEX_FIXED_FOGCOORD, _TNL_ATTRIB_FOG, i, vb);
|
||||
fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD0, _TNL_ATTRIB_TEX0, i, vb);
|
||||
fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD1, _TNL_ATTRIB_TEX1, i, vb);
|
||||
fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD2, _TNL_ATTRIB_TEX2, i, vb);
|
||||
fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD3, _TNL_ATTRIB_TEX3, i, vb);
|
||||
fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD4, _TNL_ATTRIB_TEX4, i, vb);
|
||||
fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD5, _TNL_ATTRIB_TEX5, i, vb);
|
||||
fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD6, _TNL_ATTRIB_TEX6, i, vb);
|
||||
fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD7, _TNL_ATTRIB_TEX7, i, vb);
|
||||
|
||||
_slang_exec_vertex_shader (vs);
|
||||
_slang_exec_vertex_shader (pro);
|
||||
|
||||
fetch_output_vec4 ("gl_Position", VERT_RESULT_HPOS, i, 0, store, vs);
|
||||
fetch_output_vec4 ("gl_FrontColor", VERT_RESULT_COL0, i, 0, store, vs);
|
||||
fetch_output_vec4 ("gl_FrontSecondaryColor", VERT_RESULT_COL1, i, 0, store, vs);
|
||||
fetch_output_float ("gl_FogFragCoord", VERT_RESULT_FOGC, i, store, vs);
|
||||
fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_POSITION, VERT_RESULT_HPOS, i, 0, store);
|
||||
fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_FRONTCOLOR, VERT_RESULT_COL0, i, 0, store);
|
||||
fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_FRONTSECONDARYCOLOR, VERT_RESULT_COL1, i, 0, store);
|
||||
fetch_output_float (pro, SLANG_VERTEX_FIXED_FOGFRAGCOORD, VERT_RESULT_FOGC, i, store);
|
||||
for (j = 0; j < 8; j++)
|
||||
fetch_output_vec4 ("gl_TexCoord", VERT_RESULT_TEX0 + j, i, j, store, vs);
|
||||
fetch_output_float ("gl_PointSize", VERT_RESULT_PSIZ, i, store, vs);
|
||||
fetch_output_vec4 ("gl_BackColor", VERT_RESULT_BFC0, i, 0, store, vs);
|
||||
fetch_output_vec4 ("gl_BackSecondaryColor", VERT_RESULT_BFC1, i, 0, store, vs);
|
||||
/* XXX: fetch output gl_ClipVertex */
|
||||
fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_TEXCOORD, VERT_RESULT_TEX0 + j, i, j, store);
|
||||
fetch_output_float (pro, SLANG_VERTEX_FIXED_POINTSIZE, VERT_RESULT_PSIZ, i, store);
|
||||
fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_BACKCOLOR, VERT_RESULT_BFC0, i, 0, store);
|
||||
fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_BACKSECONDARYCOLOR, VERT_RESULT_BFC1, i, 0, store);
|
||||
/* XXX: fetch output SLANG_VERTEX_FIXED_CLIPVERTEX */
|
||||
}
|
||||
|
||||
(**vs)._shader._generic._unknown.Release ((struct gl2_unknown_intf **) vs);
|
||||
|
||||
vb->ClipPtr = &store->outputs[VERT_RESULT_HPOS];
|
||||
vb->ClipPtr->count = vb->Count;
|
||||
vb->ColorPtr[0] = &store->outputs[VERT_RESULT_COL0];
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
#if defined(USE_X86_ASM)
|
||||
#if defined(USE_X86_ASM) || defined(SLANG_X86)
|
||||
|
||||
#include "imports.h"
|
||||
#include "x86sse.h"
|
||||
|
@ -85,10 +85,10 @@ static void emit_modrm( struct x86_function *p,
|
|||
case mod_INDIRECT:
|
||||
break;
|
||||
case mod_DISP8:
|
||||
emit_1b(p, regmem.disp);
|
||||
emit_1b(p, regmem.disp);
|
||||
break;
|
||||
case mod_DISP32:
|
||||
emit_1i(p, regmem.disp);
|
||||
emit_1i(p, regmem.disp);
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
|
@ -142,8 +142,8 @@ static void emit_op_modrm( struct x86_function *p,
|
|||
|
||||
/* Create and manipulate registers and regmem values:
|
||||
*/
|
||||
struct x86_reg x86_make_reg( GLuint file,
|
||||
GLuint idx )
|
||||
struct x86_reg x86_make_reg( enum x86_reg_file file,
|
||||
enum x86_reg_name idx )
|
||||
{
|
||||
struct x86_reg reg;
|
||||
|
||||
|
@ -198,7 +198,7 @@ GLubyte *x86_get_label( struct x86_function *p )
|
|||
|
||||
|
||||
void x86_jcc( struct x86_function *p,
|
||||
GLuint cc,
|
||||
enum x86_cc cc,
|
||||
GLubyte *label )
|
||||
{
|
||||
GLint offset = label - (x86_get_label(p) + 2);
|
||||
|
@ -217,11 +217,25 @@ void x86_jcc( struct x86_function *p,
|
|||
/* Always use a 32bit offset for forward jumps:
|
||||
*/
|
||||
GLubyte *x86_jcc_forward( struct x86_function *p,
|
||||
GLuint cc )
|
||||
enum x86_cc cc )
|
||||
{
|
||||
emit_2ub(p, 0x0f, 0x80 + cc);
|
||||
emit_1i(p, 0);
|
||||
return x86_get_label(p);
|
||||
}
|
||||
|
||||
GLubyte *x86_jmp_forward( struct x86_function *p)
|
||||
{
|
||||
emit_1ub(p, 0xe9);
|
||||
emit_1i(p, 0);
|
||||
return x86_get_label(p);
|
||||
}
|
||||
|
||||
GLubyte *x86_call_forward( struct x86_function *p)
|
||||
{
|
||||
emit_1ub(p, 0xe8);
|
||||
emit_1i(p, 0);
|
||||
return x86_get_label(p);
|
||||
}
|
||||
|
||||
/* Fixup offset from forward jump:
|
||||
|
@ -230,6 +244,29 @@ void x86_fixup_fwd_jump( struct x86_function *p,
|
|||
GLubyte *fixup )
|
||||
{
|
||||
*(int *)(fixup - 4) = x86_get_label(p) - fixup;
|
||||
}
|
||||
|
||||
void x86_jmp( struct x86_function *p, GLubyte *label)
|
||||
{
|
||||
emit_1ub(p, 0xe9);
|
||||
emit_1i(p, label - x86_get_label(p) - 4);
|
||||
}
|
||||
|
||||
void x86_call( struct x86_function *p, GLubyte *label)
|
||||
{
|
||||
emit_1ub(p, 0xe8);
|
||||
emit_1i(p, label - x86_get_label(p) - 4);
|
||||
}
|
||||
|
||||
/* michal:
|
||||
* Temporary. As I need immediate operands, and dont want to mess with the codegen,
|
||||
* I load the immediate into general purpose register and use it.
|
||||
*/
|
||||
void x86_mov_reg_imm( struct x86_function *p, struct x86_reg dst, GLint imm )
|
||||
{
|
||||
assert(dst.mod == mod_REG);
|
||||
emit_1ub(p, 0xb8 + dst.idx);
|
||||
emit_1i(p, imm);
|
||||
}
|
||||
|
||||
void x86_push( struct x86_function *p,
|
||||
|
@ -307,6 +344,27 @@ void x86_test( struct x86_function *p,
|
|||
{
|
||||
emit_1ub(p, 0x85);
|
||||
emit_modrm( p, dst, src );
|
||||
}
|
||||
|
||||
void x86_add( struct x86_function *p,
|
||||
struct x86_reg dst,
|
||||
struct x86_reg src )
|
||||
{
|
||||
emit_op_modrm(p, 0x03, 0x01, dst, src );
|
||||
}
|
||||
|
||||
void x86_mul( struct x86_function *p,
|
||||
struct x86_reg src )
|
||||
{
|
||||
assert (src.file == file_REG32 && src.mod == mod_REG);
|
||||
emit_op_modrm(p, 0xf7, 0, x86_make_reg (file_REG32, reg_SP), src );
|
||||
}
|
||||
|
||||
void x86_sub( struct x86_function *p,
|
||||
struct x86_reg dst,
|
||||
struct x86_reg src )
|
||||
{
|
||||
emit_op_modrm(p, 0x2b, 0x29, dst, src );
|
||||
}
|
||||
|
||||
|
||||
|
@ -971,8 +1029,13 @@ struct x86_reg x86_fn_arg( struct x86_function *p,
|
|||
|
||||
void x86_init_func( struct x86_function *p )
|
||||
{
|
||||
p->store = _mesa_exec_malloc(1024);
|
||||
p->csr = p->store;
|
||||
x86_init_func_size(p, 1024);
|
||||
}
|
||||
|
||||
void x86_init_func_size( struct x86_function *p, GLuint code_size )
|
||||
{
|
||||
p->store = _mesa_exec_malloc(code_size);
|
||||
p->csr = p->store;
|
||||
}
|
||||
|
||||
void x86_release_func( struct x86_function *p )
|
||||
|
@ -985,7 +1048,7 @@ void (*x86_get_func( struct x86_function *p ))(void)
|
|||
{
|
||||
if (DISASSEM)
|
||||
_mesa_printf("disassemble %p %p\n", p->store, p->csr);
|
||||
return (void (*)())p->store;
|
||||
return (void (*)(void))p->store;
|
||||
}
|
||||
|
||||
#else
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
#ifndef _X86SSE_H_
|
||||
#define _X86SSE_H_
|
||||
|
||||
#if defined(USE_X86_ASM)
|
||||
#if defined(USE_X86_ASM) || defined(SLANG_X86)
|
||||
|
||||
#include "glheader.h"
|
||||
|
||||
|
@ -80,7 +80,8 @@ enum sse_cc {
|
|||
*/
|
||||
|
||||
|
||||
void x86_init_func( struct x86_function *p );
|
||||
void x86_init_func( struct x86_function *p );
|
||||
void x86_init_func_size( struct x86_function *p, GLuint code_size );
|
||||
void x86_release_func( struct x86_function *p );
|
||||
void (*x86_get_func( struct x86_function *p ))( void );
|
||||
|
||||
|
@ -108,10 +109,24 @@ void x86_jcc( struct x86_function *p,
|
|||
GLubyte *label );
|
||||
|
||||
GLubyte *x86_jcc_forward( struct x86_function *p,
|
||||
enum x86_cc cc );
|
||||
enum x86_cc cc );
|
||||
|
||||
GLubyte *x86_jmp_forward( struct x86_function *p);
|
||||
|
||||
GLubyte *x86_call_forward( struct x86_function *p);
|
||||
|
||||
void x86_fixup_fwd_jump( struct x86_function *p,
|
||||
GLubyte *fixup );
|
||||
GLubyte *fixup );
|
||||
|
||||
void x86_jmp( struct x86_function *p, GLubyte *label );
|
||||
|
||||
void x86_call( struct x86_function *p, GLubyte *label );
|
||||
|
||||
/* michal:
|
||||
* Temporary. As I need immediate operands, and dont want to mess with the codegen,
|
||||
* I load the immediate into general purpose register and use it.
|
||||
*/
|
||||
void x86_mov_reg_imm( struct x86_function *p, struct x86_reg dst, GLint imm );
|
||||
|
||||
|
||||
/* Macro for sse_shufps() and sse2_pshufd():
|
||||
|
@ -153,15 +168,18 @@ void sse_mulps( struct x86_function *p, struct x86_reg dst, struct x86_reg src )
|
|||
void sse_subps( struct x86_function *p, struct x86_reg dst, struct x86_reg src );
|
||||
void sse_rsqrtss( struct x86_function *p, struct x86_reg dst, struct x86_reg src );
|
||||
void sse_shufps( struct x86_function *p, struct x86_reg dest, struct x86_reg arg0, GLubyte shuf );
|
||||
|
||||
|
||||
void x86_add( struct x86_function *p, struct x86_reg dst, struct x86_reg src );
|
||||
void x86_cmp( struct x86_function *p, struct x86_reg dst, struct x86_reg src );
|
||||
void x86_dec( struct x86_function *p, struct x86_reg reg );
|
||||
void x86_inc( struct x86_function *p, struct x86_reg reg );
|
||||
void x86_lea( struct x86_function *p, struct x86_reg dst, struct x86_reg src );
|
||||
void x86_mov( struct x86_function *p, struct x86_reg dst, struct x86_reg src );
|
||||
void x86_mov( struct x86_function *p, struct x86_reg dst, struct x86_reg src );
|
||||
void x86_mul( struct x86_function *p, struct x86_reg src );
|
||||
void x86_pop( struct x86_function *p, struct x86_reg reg );
|
||||
void x86_push( struct x86_function *p, struct x86_reg reg );
|
||||
void x86_ret( struct x86_function *p );
|
||||
void x86_ret( struct x86_function *p );
|
||||
void x86_sub( struct x86_function *p, struct x86_reg dst, struct x86_reg src );
|
||||
void x86_test( struct x86_function *p, struct x86_reg dst, struct x86_reg src );
|
||||
void x86_xor( struct x86_function *p, struct x86_reg dst, struct x86_reg src );
|
||||
void x86_sahf( struct x86_function *p );
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
|
||||
|
||||
CFG=gdi - Win32 Debug
|
||||
CFG=gdi - Win32 Debug x86
|
||||
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
|
||||
!MESSAGE use the Export Makefile command and run
|
||||
!MESSAGE
|
||||
|
@ -13,12 +13,14 @@ CFG=gdi - Win32 Debug
|
|||
!MESSAGE You can specify a configuration when running NMAKE
|
||||
!MESSAGE by defining the macro CFG on the command line. For example:
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "gdi.mak" CFG="gdi - Win32 Debug"
|
||||
!MESSAGE NMAKE /f "gdi.mak" CFG="gdi - Win32 Debug x86"
|
||||
!MESSAGE
|
||||
!MESSAGE Possible choices for configuration are:
|
||||
!MESSAGE
|
||||
!MESSAGE "gdi - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE "gdi - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE "gdi - Win32 Release x86" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE "gdi - Win32 Debug x86" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE
|
||||
|
||||
# Begin Project
|
||||
|
@ -91,12 +93,80 @@ SOURCE="$(InputPath)"
|
|||
PostBuild_Cmds=if not exist ..\..\..\..\lib md ..\..\..\..\lib copy Debug\OPENGL32.LIB ..\..\..\..\lib copy Debug\OPENGL32.DLL ..\..\..\..\lib if exist ..\..\..\..\progs\demos copy Debug\OPENGL32.DLL ..\..\..\..\progs\demos
|
||||
# End Special Build Tool
|
||||
|
||||
!ELSEIF "$(CFG)" == "gdi - Win32 Release x86"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir "gdi___Win32_Release_x86"
|
||||
# PROP BASE Intermediate_Dir "gdi___Win32_Release_x86"
|
||||
# PROP BASE Ignore_Export_Lib 0
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir "Release_x86"
|
||||
# PROP Intermediate_Dir "Release_x86"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /I "../../main" /I "../../../../include" /I "../../../../src/mesa" /I "../../../../src/mesa/main" /I "../../../../src/mesa/glapi" /I "../../../../src/mesa/swrast" /I "../../../../src/mesa/shader" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "GDI_EXPORTS" /D "_DLL" /D "BUILD_GL32" /D "MESA_MINWARN" /FD /c
|
||||
# SUBTRACT BASE CPP /YX
|
||||
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../main" /I "../../../../include" /I "../../../../src/mesa" /I "../../../../src/mesa/main" /I "../../../../src/mesa/glapi" /I "../../../../src/mesa/swrast" /I "../../../../src/mesa/shader" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "GDI_EXPORTS" /D "_DLL" /D "BUILD_GL32" /D "MESA_MINWARN" /FD /c
|
||||
# SUBTRACT CPP /YX
|
||||
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
|
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
|
||||
# ADD BASE RSC /l 0x409 /d "NDEBUG"
|
||||
# ADD RSC /l 0x409 /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 mesa.lib winmm.lib msvcrt.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /nodefaultlib /out:"Release/OPENGL32.DLL" /libpath:"../mesa/Release"
|
||||
# ADD LINK32 mesa.lib winmm.lib msvcrt.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /nodefaultlib /out:"Release_x86/OPENGL32.DLL" /libpath:"../mesa/Release_x86"
|
||||
# Begin Special Build Tool
|
||||
SOURCE="$(InputPath)"
|
||||
PostBuild_Cmds=if not exist ..\..\..\..\lib md ..\..\..\..\lib copy Release_x86\OPENGL32.LIB ..\..\..\..\lib copy Release_x86\OPENGL32.DLL ..\..\..\..\lib if exist ..\..\..\..\progs\demos copy Release_x86\OPENGL32.DLL ..\..\..\..\progs\demos
|
||||
# End Special Build Tool
|
||||
|
||||
!ELSEIF "$(CFG)" == "gdi - Win32 Debug x86"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 1
|
||||
# PROP BASE Output_Dir "gdi___Win32_Debug_x86"
|
||||
# PROP BASE Intermediate_Dir "gdi___Win32_Debug_x86"
|
||||
# PROP BASE Ignore_Export_Lib 0
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 1
|
||||
# PROP Output_Dir "Debug_x86"
|
||||
# PROP Intermediate_Dir "Debug_x86"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I "../../../../include" /I "../../../../src/mesa" /I "../../../../src/mesa/main" /I "../../../../src/mesa/glapi" /I "../../../../src/mesa/swrast" /I "../../../../src/mesa/shader" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "GDI_EXPORTS" /D "_DLL" /D "BUILD_GL32" /D "MESA_MINWARN" /FR /FD /GZ /c
|
||||
# SUBTRACT BASE CPP /YX /Yc /Yu
|
||||
# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I "../../../../include" /I "../../../../src/mesa" /I "../../../../src/mesa/main" /I "../../../../src/mesa/glapi" /I "../../../../src/mesa/swrast" /I "../../../../src/mesa/shader" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "GDI_EXPORTS" /D "_DLL" /D "BUILD_GL32" /D "MESA_MINWARN" /FR /FD /GZ /c
|
||||
# SUBTRACT CPP /YX /Yc /Yu
|
||||
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
|
||||
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
|
||||
# ADD BASE RSC /l 0x409 /d "_DEBUG"
|
||||
# ADD RSC /l 0x409 /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 mesa.lib winmm.lib msvcrtd.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /nodefaultlib /out:"Debug/OPENGL32.DLL" /pdbtype:sept /libpath:"../mesa/Debug"
|
||||
# ADD LINK32 mesa.lib winmm.lib msvcrtd.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /nodefaultlib /out:"Debug_x86/OPENGL32.DLL" /pdbtype:sept /libpath:"../mesa/Debug_x86"
|
||||
# Begin Special Build Tool
|
||||
SOURCE="$(InputPath)"
|
||||
PostBuild_Cmds=if not exist ..\..\..\..\lib md ..\..\..\..\lib copy Debug_x86\OPENGL32.LIB ..\..\..\..\lib copy Debug_x86\OPENGL32.DLL ..\..\..\..\lib if exist ..\..\..\..\progs\demos copy Debug_x86\OPENGL32.DLL ..\..\..\..\progs\demos
|
||||
# End Special Build Tool
|
||||
|
||||
!ENDIF
|
||||
|
||||
# Begin Target
|
||||
|
||||
# Name "gdi - Win32 Release"
|
||||
# Name "gdi - Win32 Debug"
|
||||
# Name "gdi - Win32 Release x86"
|
||||
# Name "gdi - Win32 Debug x86"
|
||||
# Begin Group "Source Files"
|
||||
|
||||
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -3,7 +3,7 @@ Microsoft Developer Studio Workspace File, Format Version 6.00
|
|||
|
||||
###############################################################################
|
||||
|
||||
Project: "gdi"=.\gdi\gdi.dsp - Package Owner=<4>
|
||||
Project: "gdi"=".\gdi\gdi.dsp" - Package Owner=<4>
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
|
@ -18,7 +18,7 @@ Package=<4>
|
|||
|
||||
###############################################################################
|
||||
|
||||
Project: "glu"=.\glu\glu.dsp - Package Owner=<4>
|
||||
Project: "glu"=".\glu\glu.dsp" - Package Owner=<4>
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
|
@ -33,7 +33,7 @@ Package=<4>
|
|||
|
||||
###############################################################################
|
||||
|
||||
Project: "mesa"=.\mesa\mesa.dsp - Package Owner=<4>
|
||||
Project: "mesa"=".\mesa\mesa.dsp" - Package Owner=<4>
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
|
@ -45,7 +45,22 @@ Package=<4>
|
|||
|
||||
###############################################################################
|
||||
|
||||
Project: "osmesa"=.\osmesa\osmesa.dsp - Package Owner=<4>
|
||||
Project: "osmesa"=".\osmesa\osmesa.dsp" - Package Owner=<4>
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
}}}
|
||||
|
||||
Package=<4>
|
||||
{{{
|
||||
Begin Project Dependency
|
||||
Project_Dep_Name gdi
|
||||
End Project Dependency
|
||||
}}}
|
||||
|
||||
###############################################################################
|
||||
|
||||
Project: "test"=".\test\test.dsp" - Package Owner=<4>
|
||||
|
||||
Package=<5>
|
||||
{{{
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
# TARGTYPE "Win32 (x86) Static Library" 0x0104
|
||||
|
||||
CFG=mesa - Win32 Debug
|
||||
CFG=mesa - Win32 Debug x86
|
||||
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
|
||||
!MESSAGE use the Export Makefile command and run
|
||||
!MESSAGE
|
||||
|
@ -13,12 +13,14 @@ CFG=mesa - Win32 Debug
|
|||
!MESSAGE You can specify a configuration when running NMAKE
|
||||
!MESSAGE by defining the macro CFG on the command line. For example:
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "mesa.mak" CFG="mesa - Win32 Debug"
|
||||
!MESSAGE NMAKE /f "mesa.mak" CFG="mesa - Win32 Debug x86"
|
||||
!MESSAGE
|
||||
!MESSAGE Possible choices for configuration are:
|
||||
!MESSAGE
|
||||
!MESSAGE "mesa - Win32 Release" (based on "Win32 (x86) Static Library")
|
||||
!MESSAGE "mesa - Win32 Debug" (based on "Win32 (x86) Static Library")
|
||||
!MESSAGE "mesa - Win32 Release x86" (based on "Win32 (x86) Static Library")
|
||||
!MESSAGE "mesa - Win32 Debug x86" (based on "Win32 (x86) Static Library")
|
||||
!MESSAGE
|
||||
|
||||
# Begin Project
|
||||
|
@ -74,12 +76,60 @@ LIB32=link.exe -lib
|
|||
# ADD BASE LIB32 /nologo
|
||||
# ADD LIB32 /nologo
|
||||
|
||||
!ELSEIF "$(CFG)" == "mesa - Win32 Release x86"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir "mesa___Win32_Release_x86"
|
||||
# PROP BASE Intermediate_Dir "mesa___Win32_Release_x86"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir "Release_x86"
|
||||
# PROP Intermediate_Dir "Release_x86"
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /W3 /GX /O2 /I "../../../../include" /I "../../../../src/mesa" /I "../../../../src/mesa/glapi" /I "../../../../src/mesa/main" /I "../../../../src/mesa/shader" /I "../../../../src/mesa/shader/slang" /I "../../../../src/mesa/shader/grammar" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "_DLL" /D "BUILD_GL32" /D "MESA_MINWARN" /YX /FD /Zm1000 /c
|
||||
# ADD CPP /nologo /W3 /GX /O2 /I "../../../../include" /I "../../../../src/mesa" /I "../../../../src/mesa/glapi" /I "../../../../src/mesa/main" /I "../../../../src/mesa/shader" /I "../../../../src/mesa/shader/slang" /I "../../../../src/mesa/shader/grammar" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "_DLL" /D "BUILD_GL32" /D "MESA_MINWARN" /D "SLANG_X86" /YX /FD /Zm1000 /c
|
||||
# ADD BASE RSC /l 0x409 /d "NDEBUG"
|
||||
# ADD RSC /l 0x409 /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LIB32=link.exe -lib
|
||||
# ADD BASE LIB32 /nologo
|
||||
# ADD LIB32 /nologo
|
||||
|
||||
!ELSEIF "$(CFG)" == "mesa - Win32 Debug x86"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 1
|
||||
# PROP BASE Output_Dir "mesa___Win32_Debug_x86"
|
||||
# PROP BASE Intermediate_Dir "mesa___Win32_Debug_x86"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 1
|
||||
# PROP Output_Dir "Debug_x86"
|
||||
# PROP Intermediate_Dir "Debug_x86"
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /I "../../../../include" /I "../../../../src/mesa" /I "../../../../src/mesa/glapi" /I "../../../../src/mesa/main" /I "../../../../src/mesa/shader" /I "../../../../src/mesa/shader/slang" /I "../../../../src/mesa/shader/grammar" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "_DLL" /D "BUILD_GL32" /D "MESA_MINWARN" /Fr /FD /GZ /Zm1000 /c
|
||||
# ADD CPP /nologo /W3 /Gm /GX /Zi /Od /I "../../../../include" /I "../../../../src/mesa" /I "../../../../src/mesa/glapi" /I "../../../../src/mesa/main" /I "../../../../src/mesa/shader" /I "../../../../src/mesa/shader/slang" /I "../../../../src/mesa/shader/grammar" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "_DLL" /D "BUILD_GL32" /D "MESA_MINWARN" /D "SLANG_X86" /Fr /FD /GZ /Zm1000 /c
|
||||
# ADD BASE RSC /l 0x409 /d "_DEBUG"
|
||||
# ADD RSC /l 0x409 /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LIB32=link.exe -lib
|
||||
# ADD BASE LIB32 /nologo
|
||||
# ADD LIB32 /nologo
|
||||
|
||||
!ENDIF
|
||||
|
||||
# Begin Target
|
||||
|
||||
# Name "mesa - Win32 Release"
|
||||
# Name "mesa - Win32 Debug"
|
||||
# Name "mesa - Win32 Release x86"
|
||||
# Name "mesa - Win32 Debug x86"
|
||||
# Begin Group "Source Files"
|
||||
|
||||
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
|
||||
|
@ -234,7 +284,27 @@ SOURCE=..\..\..\..\src\mesa\glapi\glthread.c
|
|||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\..\..\src\mesa\shader\grammar\grammar.c
|
||||
|
||||
!IF "$(CFG)" == "mesa - Win32 Release"
|
||||
|
||||
# PROP Exclude_From_Build 1
|
||||
|
||||
!ELSEIF "$(CFG)" == "mesa - Win32 Debug"
|
||||
|
||||
# PROP Exclude_From_Build 1
|
||||
|
||||
!ELSEIF "$(CFG)" == "mesa - Win32 Release x86"
|
||||
|
||||
# PROP BASE Exclude_From_Build 1
|
||||
# PROP Exclude_From_Build 1
|
||||
|
||||
!ELSEIF "$(CFG)" == "mesa - Win32 Debug x86"
|
||||
|
||||
# PROP BASE Exclude_From_Build 1
|
||||
# PROP Exclude_From_Build 1
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
|
@ -522,6 +592,10 @@ SOURCE=..\..\..\..\src\mesa\shader\slang\slang_execute.c
|
|||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\..\..\src\mesa\shader\slang\slang_execute_x86.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\..\..\src\mesa\shader\slang\slang_export.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
@ -711,11 +785,52 @@ SOURCE=..\..\..\..\src\mesa\main\varray.c
|
|||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\..\..\src\mesa\main\vsnprintf.c
|
||||
|
||||
!IF "$(CFG)" == "mesa - Win32 Release"
|
||||
|
||||
# PROP Exclude_From_Build 1
|
||||
|
||||
!ELSEIF "$(CFG)" == "mesa - Win32 Debug"
|
||||
|
||||
# PROP Exclude_From_Build 1
|
||||
|
||||
!ELSEIF "$(CFG)" == "mesa - Win32 Release x86"
|
||||
|
||||
# PROP BASE Exclude_From_Build 1
|
||||
# PROP Exclude_From_Build 1
|
||||
|
||||
!ELSEIF "$(CFG)" == "mesa - Win32 Debug x86"
|
||||
|
||||
# PROP BASE Exclude_From_Build 1
|
||||
# PROP Exclude_From_Build 1
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\..\..\src\mesa\main\vtxfmt.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=..\..\..\..\src\mesa\x86\rtasm\x86sse.c
|
||||
|
||||
!IF "$(CFG)" == "mesa - Win32 Release"
|
||||
|
||||
# PROP Exclude_From_Build 1
|
||||
|
||||
!ELSEIF "$(CFG)" == "mesa - Win32 Debug"
|
||||
|
||||
# PROP Exclude_From_Build 1
|
||||
|
||||
!ELSEIF "$(CFG)" == "mesa - Win32 Release x86"
|
||||
|
||||
!ELSEIF "$(CFG)" == "mesa - Win32 Debug x86"
|
||||
|
||||
# PROP BASE Exclude_From_Build 1
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "Header Files"
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
|
||||
|
||||
CFG=osmesa - Win32 Debug
|
||||
CFG=osmesa - Win32 Debug x86
|
||||
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
|
||||
!MESSAGE use the Export Makefile command and run
|
||||
!MESSAGE
|
||||
|
@ -13,12 +13,14 @@ CFG=osmesa - Win32 Debug
|
|||
!MESSAGE You can specify a configuration when running NMAKE
|
||||
!MESSAGE by defining the macro CFG on the command line. For example:
|
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "osmesa.mak" CFG="osmesa - Win32 Debug"
|
||||
!MESSAGE NMAKE /f "osmesa.mak" CFG="osmesa - Win32 Debug x86"
|
||||
!MESSAGE
|
||||
!MESSAGE Possible choices for configuration are:
|
||||
!MESSAGE
|
||||
!MESSAGE "osmesa - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE "osmesa - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE "osmesa - Win32 Release x86" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE "osmesa - Win32 Debug x86" (based on "Win32 (x86) Dynamic-Link Library")
|
||||
!MESSAGE
|
||||
|
||||
# Begin Project
|
||||
|
@ -91,12 +93,80 @@ SOURCE="$(InputPath)"
|
|||
PostBuild_Cmds=if not exist ..\..\..\..\lib md ..\..\..\..\lib copy Debug\OSMESA32.LIB ..\..\..\..\lib copy Debug\OSMESA32.DLL ..\..\..\..\lib if exist ..\..\..\..\progs\demos copy Debug\OSMESA32.DLL ..\..\..\..\progs\demos
|
||||
# End Special Build Tool
|
||||
|
||||
!ELSEIF "$(CFG)" == "osmesa - Win32 Release x86"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir "osmesa___Win32_Release_x86"
|
||||
# PROP BASE Intermediate_Dir "osmesa___Win32_Release_x86"
|
||||
# PROP BASE Ignore_Export_Lib 0
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir "Release_x86"
|
||||
# PROP Intermediate_Dir "Release_x86"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /I "../../../../include" /I "../../../../src/mesa" /I "../../../../src/mesa/main" /I "../../../../src/mesa/glapi" /I "../../../../src/mesa/swrast" /I "../../../../src/mesa/shader" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "OSMESA_EXPORTS" /FD /c
|
||||
# SUBTRACT BASE CPP /YX
|
||||
# ADD CPP /nologo /MT /W3 /GX /O2 /I "../../../../include" /I "../../../../src/mesa" /I "../../../../src/mesa/main" /I "../../../../src/mesa/glapi" /I "../../../../src/mesa/swrast" /I "../../../../src/mesa/shader" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "OSMESA_EXPORTS" /FD /c
|
||||
# SUBTRACT CPP /YX
|
||||
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
|
||||
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
|
||||
# ADD BASE RSC /l 0x409 /d "NDEBUG"
|
||||
# ADD RSC /l 0x409 /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 opengl32.lib winmm.lib msvcrt.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /nodefaultlib /out:"Release/OSMESA32.DLL" /libpath:"../gdi/Release"
|
||||
# ADD LINK32 opengl32.lib winmm.lib msvcrt.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /nodefaultlib /out:"Release_x86/OSMESA32.DLL" /libpath:"../gdi/Release_x86"
|
||||
# Begin Special Build Tool
|
||||
SOURCE="$(InputPath)"
|
||||
PostBuild_Cmds=if not exist ..\..\..\..\lib md ..\..\..\..\lib copy Release_x86\OSMESA32.LIB ..\..\..\..\lib copy Release_x86\OSMESA32.DLL ..\..\..\..\lib if exist ..\..\..\..\progs\demos copy Release_x86\OSMESA32.DLL ..\..\..\..\progs\demos
|
||||
# End Special Build Tool
|
||||
|
||||
!ELSEIF "$(CFG)" == "osmesa - Win32 Debug x86"
|
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 1
|
||||
# PROP BASE Output_Dir "osmesa___Win32_Debug_x86"
|
||||
# PROP BASE Intermediate_Dir "osmesa___Win32_Debug_x86"
|
||||
# PROP BASE Ignore_Export_Lib 0
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 1
|
||||
# PROP Output_Dir "Debug_x86"
|
||||
# PROP Intermediate_Dir "Debug_x86"
|
||||
# PROP Ignore_Export_Lib 0
|
||||
# PROP Target_Dir ""
|
||||
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I "../../../../include" /I "../../../../src/mesa" /I "../../../../src/mesa/main" /I "../../../../src/mesa/glapi" /I "../../../../src/mesa/swrast" /I "../../../../src/mesa/shader" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "OSMESA_EXPORTS" /FD /GZ /c
|
||||
# SUBTRACT BASE CPP /YX
|
||||
# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I "../../../../include" /I "../../../../src/mesa" /I "../../../../src/mesa/main" /I "../../../../src/mesa/glapi" /I "../../../../src/mesa/swrast" /I "../../../../src/mesa/shader" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "OSMESA_EXPORTS" /FD /GZ /c
|
||||
# SUBTRACT CPP /YX
|
||||
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
|
||||
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
|
||||
# ADD BASE RSC /l 0x409 /d "_DEBUG"
|
||||
# ADD RSC /l 0x409 /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 opengl32.lib winmm.lib msvcrtd.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /nodefaultlib /out:"Debug/OSMESA32.DLL" /pdbtype:sept /libpath:"../gdi/Debug"
|
||||
# ADD LINK32 opengl32.lib winmm.lib msvcrtd.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /nodefaultlib /out:"Debug/OSMESA32.DLL" /pdbtype:sept /libpath:"../gdi/Debug_x86"
|
||||
# Begin Special Build Tool
|
||||
SOURCE="$(InputPath)"
|
||||
PostBuild_Cmds=if not exist ..\..\..\..\lib md ..\..\..\..\lib copy Debug_x86\OSMESA32.LIB ..\..\..\..\lib copy Debug_x86\OSMESA32.DLL ..\..\..\..\lib if exist ..\..\..\..\progs\demos copy Debug_x86\OSMESA32.DLL ..\..\..\..\progs\demos
|
||||
# End Special Build Tool
|
||||
|
||||
!ENDIF
|
||||
|
||||
# Begin Target
|
||||
|
||||
# Name "osmesa - Win32 Release"
|
||||
# Name "osmesa - Win32 Debug"
|
||||
# Name "osmesa - Win32 Release x86"
|
||||
# Name "osmesa - Win32 Debug x86"
|
||||
# Begin Group "Source Files"
|
||||
|
||||
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
|
||||
|
|
Loading…
Reference in New Issue