void vbo_exec_vtx_destroy( struct vbo_exec_context *exec )
{
/* using a real VBO for vertex data */
GLcontext *ctx = exec->ctx;
unsigned i;
/* True VBOs should already be unmapped
*/
if (exec->vtx.buffer_map) {
ASSERT(exec->vtx.bufferobj->Name == 0 ||
exec->vtx.bufferobj->Name == IMM_BUFFER_NAME);
if (exec->vtx.bufferobj->Name == 0) {
ALIGN_FREE(exec->vtx.buffer_map);
exec->vtx.buffer_map = NULL;
exec->vtx.buffer_ptr = NULL;
}
}
/* Drop any outstanding reference to the vertex buffer
*/
for (i = 0; i < Elements(exec->vtx.arrays); i++) {
_mesa_reference_buffer_object(ctx,
&exec->vtx.arrays[i].BufferObj,
NULL);
}
/* Free the vertex buffer:
*/
_mesa_reference_buffer_object(ctx, &exec->vtx.bufferobj, NULL);
}
void _tnl_free_vertices( GLcontext *ctx )
{
struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
struct tnl_clipspace_fastpath *fp, *tmp;
if (vtx->vertex_buf) {
ALIGN_FREE(vtx->vertex_buf);
vtx->vertex_buf = NULL;
}
for (fp = vtx->fastpath ; fp ; fp = tmp) {
tmp = fp->next;
FREE(fp->attr);
/* KW: At the moment, fp->func is constrained to be allocated by
* _mesa_exec_alloc(), as the hardwired fastpaths in
* t_vertex_generic.c are handled specially. It would be nice
* to unify them, but this probably won't change until this
* module gets another overhaul.
*/
_mesa_exec_free((void *) fp->func);
FREE(fp);
}
vtx->fastpath = NULL;
}
static void free_funcs( struct _tnl_dynfn *l )
{
struct _tnl_dynfn *f, *tmp;
foreach_s (f, tmp, l) {
remove_from_list( f );
ALIGN_FREE( f->code );
FREE( f );
}
void ffbFreeVB( GLcontext *ctx )
{
ffbContextPtr fmesa = FFB_CONTEXT(ctx);
if (fmesa->verts) {
ALIGN_FREE(fmesa->verts);
fmesa->verts = 0;
}
}
void i810FreeVB( GLcontext *ctx )
{
i810ContextPtr imesa = I810_CONTEXT(ctx);
if (imesa->verts) {
ALIGN_FREE(imesa->verts);
imesa->verts = 0;
}
}
void mach64FreeVB( GLcontext *ctx )
{
mach64ContextPtr mmesa = MACH64_CONTEXT(ctx);
if (mmesa->verts) {
ALIGN_FREE(mmesa->verts);
mmesa->verts = 0;
}
}
void _tnl_free_vertices( GLcontext *ctx )
{
struct tnl_clipspace *vtx = GET_VERTEX_STATE(ctx);
if (vtx->vertex_buf) {
ALIGN_FREE(vtx->vertex_buf);
vtx->vertex_buf = 0;
}
}
void tdfxFreeVB( GLcontext *ctx )
{
tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
if (fxMesa->verts) {
ALIGN_FREE(fxMesa->verts);
fxMesa->verts = 0;
}
}
void gammaFreeVB( GLcontext *ctx )
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
if (gmesa->verts) {
ALIGN_FREE(gmesa->verts);
gmesa->verts = 0;
}
}
void fxFreeVB( GLcontext *ctx )
{
fxMesaContext fxMesa = FX_CONTEXT(ctx);
if (fxMesa->verts) {
ALIGN_FREE(fxMesa->verts);
fxMesa->verts = 0;
}
}
void s3vFreeVB( GLcontext *ctx )
{
s3vContextPtr vmesa = S3V_CONTEXT(ctx);
if (vmesa->verts) {
ALIGN_FREE(vmesa->verts);
vmesa->verts = 0;
}
if (vmesa->UbyteSecondaryColor.Ptr) {
ALIGN_FREE((void *)vmesa->UbyteSecondaryColor.Ptr);
vmesa->UbyteSecondaryColor.Ptr = 0;
}
if (vmesa->UbyteColor.Ptr) {
ALIGN_FREE((void *)vmesa->UbyteColor.Ptr);
vmesa->UbyteColor.Ptr = 0;
}
}
void gammaFreeVB( GLcontext *ctx )
{
gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
if (gmesa->verts) {
ALIGN_FREE(gmesa->verts);
gmesa->verts = 0;
}
if (gmesa->UbyteSecondaryColor.Ptr) {
ALIGN_FREE(gmesa->UbyteSecondaryColor.Ptr);
gmesa->UbyteSecondaryColor.Ptr = 0;
}
if (gmesa->UbyteColor.Ptr) {
ALIGN_FREE(gmesa->UbyteColor.Ptr);
gmesa->UbyteColor.Ptr = 0;
}
}
void i830FreeVB( GLcontext *ctx )
{
i830ContextPtr imesa = I830_CONTEXT(ctx);
if (imesa->verts) {
ALIGN_FREE(imesa->verts);
imesa->verts = 0;
}
if (imesa->UbyteSecondaryColor.Ptr) {
ALIGN_FREE(imesa->UbyteSecondaryColor.Ptr);
imesa->UbyteSecondaryColor.Ptr = 0;
}
if (imesa->UbyteColor.Ptr) {
ALIGN_FREE(imesa->UbyteColor.Ptr);
imesa->UbyteColor.Ptr = 0;
}
}
void mgaFreeVB( GLcontext *ctx )
{
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
if (mmesa->verts) {
ALIGN_FREE(mmesa->verts);
mmesa->verts = 0;
}
if (mmesa->UbyteSecondaryColor.Ptr) {
ALIGN_FREE(mmesa->UbyteSecondaryColor.Ptr);
mmesa->UbyteSecondaryColor.Ptr = 0;
}
if (mmesa->UbyteColor.Ptr) {
ALIGN_FREE(mmesa->UbyteColor.Ptr);
mmesa->UbyteColor.Ptr = 0;
}
}
void
_swsetup_DestroyContext( GLcontext *ctx )
{
SScontext *swsetup = SWSETUP_CONTEXT(ctx);
if (swsetup) {
if (swsetup->verts)
ALIGN_FREE(swsetup->verts);
if (swsetup->ChanSecondaryColor.Ptr)
ALIGN_FREE(swsetup->ChanSecondaryColor.Ptr);
if (swsetup->ChanColor.Ptr)
ALIGN_FREE(swsetup->ChanColor.Ptr);
FREE(swsetup);
ctx->swsetup_context = 0;
}
}
static void real_free_immediate( struct immediate *IM )
{
static int freed = 0;
GLuint j;
if (IM->Material) {
FREE( IM->Material );
FREE( IM->MaterialMask );
IM->Material = 0;
IM->MaterialMask = 0;
}
for (j = 1; j < IM->MaxTextureUnits; j++)
ALIGN_FREE( IM->TexCoord[j] );
if (IM->NormalLengthPtr)
ALIGN_FREE( IM->NormalLengthPtr );
ALIGN_FREE( IM );
freed++;
/* printf("outstanding %d\n", id - freed); */
}
/**
* Destructor for this pipeline stage.
*/
static void dtr( struct tnl_pipeline_stage *stage )
{
struct vp_stage_data *store = VP_STAGE_DATA(stage);
if (store) {
GLuint i;
/* free the vertex program result arrays */
for (i = 0; i < VERT_RESULT_MAX; i++)
_mesa_vector4f_free( &store->attribs[i] );
/* free misc arrays */
_mesa_vector4f_free( &store->ndcCoords );
ALIGN_FREE( store->clipmask );
FREE( store );
stage->privatePtr = NULL;
}
}
/* Destroy the device specific context.
*/
void mach64DestroyContext( __DRIcontextPrivate *driContextPriv )
{
mach64ContextPtr mmesa = (mach64ContextPtr) driContextPriv->driverPrivate;
assert(mmesa); /* should never be null */
if ( mmesa ) {
GLboolean release_texture_heaps;
release_texture_heaps = (mmesa->glCtx->Shared->RefCount == 1);
_swsetup_DestroyContext( mmesa->glCtx );
_tnl_DestroyContext( mmesa->glCtx );
_vbo_DestroyContext( mmesa->glCtx );
_swrast_DestroyContext( mmesa->glCtx );
if (release_texture_heaps) {
/* This share group is about to go away, free our private
* texture object data.
*/
int i;
for ( i = mmesa->firstTexHeap ; i < mmesa->lastTexHeap ; i++ ) {
driDestroyTextureHeap( mmesa->texture_heaps[i] );
mmesa->texture_heaps[i] = NULL;
}
assert( is_empty_list( & mmesa->swapped ) );
}
mach64FreeVB( mmesa->glCtx );
/* Free the vertex buffer */
if ( mmesa->vert_buf )
ALIGN_FREE( mmesa->vert_buf );
/* free the Mesa context */
mmesa->glCtx->DriverCtx = NULL;
_mesa_destroy_context(mmesa->glCtx);
FREE( mmesa );
}
}
/* May be called after tnl is destroyed.
*/
void _tnl_free_immediate( GLcontext *ctx, struct immediate *IM )
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
ASSERT(IM->ref_count == 0);
if (IM->NormalLengthPtr) {
ALIGN_FREE(IM->NormalLengthPtr);
IM->NormalLengthPtr = NULL;
}
if (!tnl) {
real_free_immediate( IM );
}
else {
if (tnl->freed_immediate)
real_free_immediate( tnl->freed_immediate );
tnl->freed_immediate = IM;
}
}
static int test_norm_function( normal_func func, int mtype,
int masked, long *cycles )
{
GLvector3f source[1], dest[1], dest2[1], ref[1], ref2[1];
GLmatrix mat[1];
GLfloat s[TEST_COUNT][5], d[TEST_COUNT][3], r[TEST_COUNT][3];
GLfloat d2[TEST_COUNT][3], r2[TEST_COUNT][3], length[TEST_COUNT];
GLfloat scale;
GLfloat *m;
GLubyte mask[TEST_COUNT];
int i, j;
#ifdef RUN_XFORM_BENCHMARK
int cycle_i; /* the counter for the benchmarks we run */
#endif
(void) cycles;
mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
mat->inv = m = mat->m;
m[0] = 63.0; m[4] = 43.0; m[ 8] = 29.0; m[12] = 43.0;
m[1] = 55.0; m[5] = 17.0; m[ 9] = 31.0; m[13] = 7.0;
m[2] = 44.0; m[6] = 9.0; m[10] = 7.0; m[14] = 3.0;
m[3] = 11.0; m[7] = 23.0; m[11] = 91.0; m[15] = 9.0;
scale = 1.0F + rnd () * norm_scale_types[mtype];
for ( i = 0 ; i < 4 ; i++ ) {
for ( j = 0 ; j < 4 ; j++ ) {
switch ( norm_templates[mtype][i * 4 + j] ) {
case NIL:
m[j * 4 + i] = 0.0;
break;
case ONE:
m[j * 4 + i] = 1.0;
break;
case NEG:
m[j * 4 + i] = -1.0;
break;
case VAR:
break;
default:
abort();
}
}
}
for ( i = 0 ; i < TEST_COUNT ; i++ ) {
mask[i] = i % 2; /* mask every 2nd element */
d[i][0] = s[i][0] = d2[i][0] = 0.0;
d[i][1] = s[i][1] = d2[i][1] = 0.0;
d[i][2] = s[i][2] = d2[i][2] = 0.0;
for ( j = 0 ; j < 3 ; j++ )
s[i][j] = rnd();
length[i] = 1 / sqrt( s[i][0]*s[i][0] +
s[i][1]*s[i][1] +
s[i][2]*s[i][2] );
}
source->data = (GLfloat(*)[3])s;
source->start = (GLfloat *)s;
source->count = TEST_COUNT;
source->stride = sizeof(s[0]);
source->flags = 0;
dest->data = (GLfloat(*)[3])d;
dest->start = (GLfloat *)d;
dest->count = TEST_COUNT;
dest->stride = sizeof(float[3]);
dest->flags = 0;
dest2->data = (GLfloat(*)[3])d2;
dest2->start = (GLfloat *)d2;
dest2->count = TEST_COUNT;
dest2->stride = sizeof(float[3]);
dest2->flags = 0;
ref->data = (GLfloat(*)[3])r;
ref->start = (GLfloat *)r;
ref->count = TEST_COUNT;
ref->stride = sizeof(float[3]);
ref->flags = 0;
ref2->data = (GLfloat(*)[3])r2;
ref2->start = (GLfloat *)r2;
ref2->count = TEST_COUNT;
ref2->stride = sizeof(float[3]);
ref2->flags = 0;
if ( norm_normalize_types[mtype] == 0 ) {
ref_norm_transform_rescale( mat, scale, source, NULL, NULL, ref );
} else {
ref_norm_transform_normalize( mat, scale, source, NULL, NULL, ref );
ref_norm_transform_normalize( mat, scale, source, length, NULL, ref2 );
}
if ( mesa_profile ) {
if ( masked ) {
BEGIN_RACE( *cycles );
func( mat, scale, source, NULL, mask, dest );
END_RACE( *cycles );
func( mat, scale, source, length, mask, dest2 );
} else {
BEGIN_RACE( *cycles );
func( mat, scale, source, NULL, NULL, dest );
END_RACE( *cycles );
func( mat, scale, source, length, NULL, dest2 );
}
} else {
if ( masked ) {
func( mat, scale, source, NULL, mask, dest );
func( mat, scale, source, length, mask, dest2 );
} else {
func( mat, scale, source, NULL, NULL, dest );
func( mat, scale, source, length, NULL, dest2 );
}
}
for ( i = 0 ; i < TEST_COUNT ; i++ ) {
if ( masked && !(mask[i] & 1) )
continue;
for ( j = 0 ; j < 3 ; j++ ) {
if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
printf( "-----------------------------\n" );
printf( "(i = %i, j = %i)\n", i, j );
printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d[i][0], r[i][0], r[i][0]/d[i][0],
MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d[i][1], r[i][1], r[i][1]/d[i][1],
MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d[i][2], r[i][2], r[i][2]/d[i][2],
MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
return 0;
}
if ( norm_normalize_types[mtype] != 0 ) {
if ( significand_match( d2[i][j], r2[i][j] ) < REQUIRED_PRECISION ) {
printf( "------------------- precalculated length case ------\n" );
printf( "(i = %i, j = %i)\n", i, j );
printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d2[i][0], r2[i][0], r2[i][0]/d2[i][0],
MAX_PRECISION - significand_match( d2[i][0], r2[i][0] ) );
printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d2[i][1], r2[i][1], r2[i][1]/d2[i][1],
MAX_PRECISION - significand_match( d2[i][1], r2[i][1] ) );
printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d2[i][2], r2[i][2], r2[i][2]/d2[i][2],
MAX_PRECISION - significand_match( d2[i][2], r2[i][2] ) );
return 0;
}
}
}
}
ALIGN_FREE( mat->m );
return 1;
}
static int test_transform_function( transform_func func, int psize, int mtype,
int masked, long *cycles )
{
GLvector4f source[1], dest[1], ref[1];
GLmatrix mat[1];
GLfloat *m;
GLubyte mask[TEST_COUNT];
int i, j;
#ifdef RUN_XFORM_BENCHMARK
int cycle_i; /* the counter for the benchmarks we run */
#endif
(void) cycles;
if ( psize > 4 ) {
gl_problem( NULL, "test_transform_function called with psize > 4\n" );
return 0;
}
mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
mat->type = mtypes[mtype];
m = mat->m;
m[0] = 63.0; m[4] = 43.0; m[ 8] = 29.0; m[12] = 43.0;
m[1] = 55.0; m[5] = 17.0; m[ 9] = 31.0; m[13] = 7.0;
m[2] = 44.0; m[6] = 9.0; m[10] = 7.0; m[14] = 3.0;
m[3] = 11.0; m[7] = 23.0; m[11] = 91.0; m[15] = 9.0;
for ( i = 0 ; i < 4 ; i++ ) {
for ( j = 0 ; j < 4 ; j++ ) {
switch ( templates[mtype][i * 4 + j] ) {
case NIL:
m[j * 4 + i] = 0.0;
break;
case ONE:
m[j * 4 + i] = 1.0;
break;
case NEG:
m[j * 4 + i] = -1.0;
break;
case VAR:
break;
default:
abort();
}
}
}
for ( i = 0 ; i < TEST_COUNT ; i++) {
mask[i] = i % 2; /* mask every 2nd element */
d[i][0] = s[i][0] = 0.0;
d[i][1] = s[i][1] = 0.0;
d[i][2] = s[i][2] = 0.0;
d[i][3] = s[i][3] = 1.0;
for ( j = 0 ; j < psize ; j++ )
s[i][j] = rnd();
}
source->data = (GLfloat(*)[4])s;
source->start = (GLfloat *)s;
source->count = TEST_COUNT;
source->stride = sizeof(s[0]);
source->size = 4;
source->flags = 0;
dest->data = (GLfloat(*)[4])d;
dest->start = (GLfloat *)d;
dest->count = TEST_COUNT;
dest->stride = sizeof(float[4]);
dest->size = 0;
dest->flags = 0;
ref->data = (GLfloat(*)[4])r;
ref->start = (GLfloat *)r;
ref->count = TEST_COUNT;
ref->stride = sizeof(float[4]);
ref->size = 0;
ref->flags = 0;
ref_transform( ref, mat, source, NULL, 0 );
if ( mesa_profile ) {
if ( masked ) {
BEGIN_RACE( *cycles );
func( dest, mat->m, source, mask, 1 );
END_RACE( *cycles );
} else {
BEGIN_RACE( *cycles );
func( dest, mat->m, source, NULL, 0 );
END_RACE( *cycles );
}
}
else {
if ( masked ) {
func( dest, mat->m, source, mask, 1 );
} else {
func( dest, mat->m, source, NULL, 0 );
}
}
for ( i = 0 ; i < TEST_COUNT ; i++ ) {
if ( masked && (mask[i] & 1) )
continue;
for ( j = 0 ; j < 4 ; j++ ) {
if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
printf( "-----------------------------\n" );
printf( "(i = %i, j = %i)\n", i, j );
printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][0], r[i][0], r[i][0]-d[i][0],
MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][1], r[i][1], r[i][1]-d[i][1],
MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][2], r[i][2], r[i][2]-d[i][2],
MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
printf( "%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][3], r[i][3], r[i][3]-d[i][3],
MAX_PRECISION - significand_match( d[i][3], r[i][3] ) );
return 0;
}
}
}
ALIGN_FREE( mat->m );
return 1;
}
static int test_transform_function( transform_func func, int psize,
int mtype, unsigned long *cycles )
{
GLvector4f source[1], dest[1], ref[1];
GLmatrix mat[1];
GLfloat *m;
int i, j;
#ifdef RUN_DEBUG_BENCHMARK
int cycle_i; /* the counter for the benchmarks we run */
#endif
(void) cycles;
if ( psize > 4 ) {
_mesa_problem( NULL, "test_transform_function called with psize > 4\n" );
return 0;
}
mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
mat->type = mtypes[mtype];
m = mat->m;
ASSERT( ((long)m & 15) == 0 );
init_matrix( m );
for ( i = 0 ; i < 4 ; i++ ) {
for ( j = 0 ; j < 4 ; j++ ) {
switch ( templates[mtype][i * 4 + j] ) {
case NIL:
m[j * 4 + i] = 0.0;
break;
case ONE:
m[j * 4 + i] = 1.0;
break;
case NEG:
m[j * 4 + i] = -1.0;
break;
case VAR:
break;
default:
ASSERT(0);
return 0;
}
}
}
for ( i = 0 ; i < TEST_COUNT ; i++) {
ASSIGN_4V( d[i], 0.0, 0.0, 0.0, 1.0 );
ASSIGN_4V( s[i], 0.0, 0.0, 0.0, 1.0 );
for ( j = 0 ; j < psize ; j++ )
s[i][j] = rnd();
}
source->data = (GLfloat(*)[4])s;
source->start = (GLfloat *)s;
source->count = TEST_COUNT;
source->stride = sizeof(s[0]);
source->size = 4;
source->flags = 0;
dest->data = (GLfloat(*)[4])d;
dest->start = (GLfloat *)d;
dest->count = TEST_COUNT;
dest->stride = sizeof(float[4]);
dest->size = 0;
dest->flags = 0;
ref->data = (GLfloat(*)[4])r;
ref->start = (GLfloat *)r;
ref->count = TEST_COUNT;
ref->stride = sizeof(float[4]);
ref->size = 0;
ref->flags = 0;
ref_transform( ref, mat, source );
if ( mesa_profile ) {
BEGIN_RACE( *cycles );
func( dest, mat->m, source );
END_RACE( *cycles );
}
else {
func( dest, mat->m, source );
}
for ( i = 0 ; i < TEST_COUNT ; i++ ) {
for ( j = 0 ; j < 4 ; j++ ) {
if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
_mesa_printf("-----------------------------\n" );
_mesa_printf("(i = %i, j = %i)\n", i, j );
_mesa_printf("%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][0], r[i][0], r[i][0]-d[i][0],
MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
_mesa_printf("%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][1], r[i][1], r[i][1]-d[i][1],
MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
_mesa_printf("%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][2], r[i][2], r[i][2]-d[i][2],
MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
_mesa_printf("%f \t %f \t [diff = %e - %i bit missed]\n",
d[i][3], r[i][3], r[i][3]-d[i][3],
MAX_PRECISION - significand_match( d[i][3], r[i][3] ) );
return 0;
}
}
}
ALIGN_FREE( mat->m );
return 1;
}
static int test_norm_function( normal_func func, int mtype, long *cycles )
{
GLvector4f source[1], dest[1], dest2[1], ref[1], ref2[1];
GLmatrix mat[1];
GLfloat s[TEST_COUNT][5], d[TEST_COUNT][4], r[TEST_COUNT][4];
GLfloat d2[TEST_COUNT][4], r2[TEST_COUNT][4], length[TEST_COUNT];
GLfloat scale;
GLfloat *m;
int i, j;
#ifdef RUN_DEBUG_BENCHMARK
int cycle_i; /* the counter for the benchmarks we run */
#endif
(void) cycles;
mat->m = (GLfloat *) ALIGN_MALLOC( 16 * sizeof(GLfloat), 16 );
mat->inv = m = mat->m;
init_matrix( m );
scale = 1.0F + rnd () * norm_scale_types[mtype];
for ( i = 0 ; i < 4 ; i++ ) {
for ( j = 0 ; j < 4 ; j++ ) {
switch ( norm_templates[mtype][i * 4 + j] ) {
case NIL:
m[j * 4 + i] = 0.0;
break;
case ONE:
m[j * 4 + i] = 1.0;
break;
case NEG:
m[j * 4 + i] = -1.0;
break;
case VAR:
break;
default:
_mesa_exit(1);
}
}
}
for ( i = 0 ; i < TEST_COUNT ; i++ ) {
ASSIGN_3V( d[i], 0.0, 0.0, 0.0 );
ASSIGN_3V( s[i], 0.0, 0.0, 0.0 );
ASSIGN_3V( d2[i], 0.0, 0.0, 0.0 );
for ( j = 0 ; j < 3 ; j++ )
s[i][j] = rnd();
length[i] = 1 / SQRTF( LEN_SQUARED_3FV( s[i] ) );
}
source->data = (GLfloat(*)[4]) s;
source->start = (GLfloat *) s;
source->count = TEST_COUNT;
source->stride = sizeof(s[0]);
source->flags = 0;
dest->data = d;
dest->start = (GLfloat *) d;
dest->count = TEST_COUNT;
dest->stride = sizeof(float[4]);
dest->flags = 0;
dest2->data = d2;
dest2->start = (GLfloat *) d2;
dest2->count = TEST_COUNT;
dest2->stride = sizeof(float[4]);
dest2->flags = 0;
ref->data = r;
ref->start = (GLfloat *) r;
ref->count = TEST_COUNT;
ref->stride = sizeof(float[4]);
ref->flags = 0;
ref2->data = r2;
ref2->start = (GLfloat *) r2;
ref2->count = TEST_COUNT;
ref2->stride = sizeof(float[4]);
ref2->flags = 0;
if ( norm_normalize_types[mtype] == 0 ) {
ref_norm_transform_rescale( mat, scale, source, NULL, ref );
} else {
ref_norm_transform_normalize( mat, scale, source, NULL, ref );
ref_norm_transform_normalize( mat, scale, source, length, ref2 );
}
if ( mesa_profile ) {
BEGIN_RACE( *cycles );
func( mat, scale, source, NULL, dest );
END_RACE( *cycles );
func( mat, scale, source, length, dest2 );
} else {
func( mat, scale, source, NULL, dest );
func( mat, scale, source, length, dest2 );
}
for ( i = 0 ; i < TEST_COUNT ; i++ ) {
for ( j = 0 ; j < 3 ; j++ ) {
if ( significand_match( d[i][j], r[i][j] ) < REQUIRED_PRECISION ) {
_mesa_printf( "-----------------------------\n" );
_mesa_printf( "(i = %i, j = %i)\n", i, j );
_mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d[i][0], r[i][0], r[i][0]/d[i][0],
MAX_PRECISION - significand_match( d[i][0], r[i][0] ) );
_mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d[i][1], r[i][1], r[i][1]/d[i][1],
MAX_PRECISION - significand_match( d[i][1], r[i][1] ) );
_mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d[i][2], r[i][2], r[i][2]/d[i][2],
MAX_PRECISION - significand_match( d[i][2], r[i][2] ) );
return 0;
}
if ( norm_normalize_types[mtype] != 0 ) {
if ( significand_match( d2[i][j], r2[i][j] ) < REQUIRED_PRECISION ) {
_mesa_printf( "------------------- precalculated length case ------\n" );
_mesa_printf( "(i = %i, j = %i)\n", i, j );
_mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d2[i][0], r2[i][0], r2[i][0]/d2[i][0],
MAX_PRECISION - significand_match( d2[i][0], r2[i][0] ) );
_mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d2[i][1], r2[i][1], r2[i][1]/d2[i][1],
MAX_PRECISION - significand_match( d2[i][1], r2[i][1] ) );
_mesa_printf( "%f \t %f \t [ratio = %e - %i bit missed]\n",
d2[i][2], r2[i][2], r2[i][2]/d2[i][2],
MAX_PRECISION - significand_match( d2[i][2], r2[i][2] ) );
return 0;
}
}
}
}
ALIGN_FREE( mat->m );
return 1;
}
