/**
Generate and initialize a single binary buffer.
If you need multiple buffers then ur_genBuffers() should be used.
The caller must create a UCell for this block in a held block before the
next ur_recycle() or else it will be garbage collected.
\param size Number of bytes to reserve.
\return Buffer id of binary.
*/
UIndex ur_makeBinary( UThread* ut, int size )
{
UIndex bufN;
ur_genBuffers( ut, 1, &bufN );
ur_binInit( ur_buffer( bufN ), size );
return bufN;
}
static int thread_read( UThread* ut, UBuffer* port, UCell* dest, int part )
{
UBuffer tbuf;
ThreadExt* ext = (ThreadExt*) port->ptr.v;
ThreadQueue* queue;
(void) part;
tbuf.type = 0;
queue = (port->SIDE == SIDE_A) ? &ext->B : &ext->A;
if( ! queue->readIt )
readEvent( queue ); // Waits until data is available.
mutexLock( queue->mutex );
while( queue->readIt >= queue->buf.used )
{
if( condWaitF( queue->cond, queue->mutex ) )
{
mutexUnlock( queue->mutex );
goto waitError;
}
}
queue->readIt = thread_dequeue( &queue->buf, queue->readIt, dest, &tbuf );
mutexUnlock( queue->mutex );
if( tbuf.type )
{
UIndex bufN;
dest->series.buf = UR_INVALID_BUF;
ur_genBuffers( ut, 1, &bufN );
dest->series.buf = bufN;
memCpy( ur_buffer( bufN ), &tbuf, sizeof(UBuffer) );
}
else
{
int type = ur_type(dest);
if( ur_isWordType(type) )
{
if( ur_binding(dest) == UR_BIND_THREAD )
ur_unbind(dest);
}
}
return UR_OK;
waitError:
return ur_error( ut, UR_ERR_INTERNAL, "thread_read condWait failed" );
}
/**
Generate a single binary and set cell to reference it.
If you need multiple buffers then ur_genBuffers() should be used.
\param size Number of bytes to reserve.
\param cell Cell to initialize.
\return Pointer to binary buffer.
*/
UBuffer* ur_makeBinaryCell( UThread* ut, int size, UCell* cell )
{
UBuffer* buf;
UIndex bufN;
ur_genBuffers( ut, 1, &bufN );
buf = ur_buffer( bufN );
ur_binInit( buf, size );
ur_setId( cell, UT_BINARY );
ur_setSeries( cell, bufN, 0 );
return buf;
}
/*
Sets res to either a shader! or a context! whose first value is a shader!.
Returns UR_OK/UR_THROW.
*/
int ur_makeShader( UThread* ut, const char* vert, const char* frag, UCell* res )
{
#define MAX_SHADER_PARAM 16 // LIMIT: User parameters per shader.
Shader shad;
Shader* sh;
UIndex bufN;
UBuffer* buf;
int i;
char name[ 128 ];
ShaderParam param[ MAX_SHADER_PARAM ];
ShaderParam* pi;
GLsizei length;
GLint size;
GLenum type;
GLint count = 0;
if( ! createShader( ut, &shad, vert, frag ) )
return UR_THROW;
glGetProgramiv( shad.program, GL_ACTIVE_UNIFORMS, &count );
// Collect non-gl parameters.
pi = param;
for( i = 0; i < count; ++i )
{
glGetActiveUniform( shad.program, i, 128, &length, &size, &type,
name );
if( name[0] == 'g' && name[1] == 'l' && name[2] == '_' )
continue;
pi->type = type;
pi->location = glGetUniformLocation( shad.program, name );
pi->name = ur_internAtom( ut, name, name + length );
if( pi->name == UR_INVALID_ATOM )
return UR_THROW;
++pi;
}
count = pi - param;
if( count )
{
ShaderParam* pend;
UBuffer* ctx;
UCell* cval;
// We have parameters - make context to hold shader & params.
ctx = ur_makeContextCell( ut, count + 1, res );
cval = ur_ctxAddWord( ctx, UR_ATOM_SHADER );
pi = param;
pend = param + count;
while( pi != pend )
{
cval = ur_ctxAddWord( ctx, pi->name );
#if 0
printf( "KR Shader Param %d is type %d\n",
(int) (pi - param), pi->type );
#endif
switch( pi->type )
{
case GL_FLOAT:
ur_setId( cval, UT_DECIMAL );
ur_decimal( cval ) = 0.0;
break;
case GL_FLOAT_VEC2:
case GL_FLOAT_VEC3:
//case GL_FLOAT_VEC4:
ur_setId( cval, UT_VEC3 );
cval->vec3.xyz[0] =
cval->vec3.xyz[1] =
cval->vec3.xyz[2] = 0.0f;
break;
case GL_INT:
ur_setId( cval, UT_INT );
ur_int( cval ) = 0;
break;
case GL_INT_VEC2:
case GL_INT_VEC3:
//case GL_INT_VEC4:
ur_setId( cval, UT_COORD );
break;
case GL_BOOL:
ur_setId( cval, UT_LOGIC );
ur_int( cval ) = 0;
break;
case GL_SAMPLER_2D:
case GL_SAMPLER_CUBE:
#ifndef GL_ES_VERSION_2_0
case GL_SAMPLER_1D:
case GL_SAMPLER_3D:
case GL_SAMPLER_1D_SHADOW:
case GL_SAMPLER_2D_SHADOW:
#endif
ur_setId( cval, UT_NONE );
ur_texId(cval) = 0; // Expecting texture!.
break;
#ifdef GL_ES_VERSION_2_0
case GL_FLOAT_MAT4:
ur_setId( cval, UT_NONE );
break;
#endif
default:
ur_setId( cval, UT_NONE );
break;
/*
GL_BOOL_VEC2:
GL_BOOL_VEC3:
GL_BOOL_VEC4:
GL_FLOAT_MAT2:
GL_FLOAT_MAT3:
GL_FLOAT_MAT4:
GL_SAMPLER_2D_RECT:
GL_SAMPLER_2D_RECT_SHADOW:
*/
}
++pi;
}
ur_ctxSort( ctx );
}
ur_genBuffers( ut, 1, &bufN );
buf = ur_buffer( bufN );
buf->type = UT_SHADER;
buf->ptr.v = memAlloc( sizeof(Shader) +
sizeof(ShaderParam) * (count - 1) );
sh = (Shader*) buf->ptr.v;
sh->program = shad.program;
sh->paramCount = count;
if( count )
{
memCpy( sh->param, param, sizeof(ShaderParam) * count );
// First context value will be set to shader!.
res = ur_buffer( res->series.buf )->ptr.cell;
}
ur_setId( res, UT_SHADER );
ur_setSeries( res, bufN, 0 );
return UR_OK;
}
