/*
==============================
Layer_CreateTexCoord_projection
==============================
*/
void Layer_CreateTexCoord_projection( layer_t *layer, vec3d_t in, vec2d_t out )
{
vec3d_t v3;
vec2d_t v2;
int j;
int trans_num;
Vec3dCopy( v3, in );
if ( layer->flags & LAYER_FLAGS_PROJECTION_X )
{
v2[0] = v3[2];
v2[1] = v3[1];
}
else if ( layer->flags & LAYER_FLAGS_PROJECTION_Y )
{
v2[0] = v3[0];
v2[1] = v3[2];
}
else if ( layer->flags & LAYER_FLAGS_PROJECTION_Z )
{
v2[0] = v3[0];
v2[1] = v3[1];
}
else
{
__error( "invalid projection plane\n" );
}
U_BeginMemUnpack( layer->packed_info ); // fixme: missing U_EndMemUnpack() ...
U_MemUnpacki32( &trans_num );
for ( j = 0; j < trans_num; j++ )
{
int trans_type;
U_MemUnpacki32( &trans_type );
if ( trans_type & LAYER_FLAGS_TRANSFORMATION_AXIS )
{
vec2d_t x, y;
vec2d_t tmp;
U_MemUnpackf32v2( x );
U_MemUnpackf32v2( y );
Vec2dCopy( tmp, v2 );
v2[0] = tmp[0]*x[0] + tmp[1]*x[1];
v2[1] = tmp[0]*y[0] + tmp[1]*y[1];
}
else if ( trans_type & LAYER_FLAGS_TRANSFORMATION_SCALE )
{
vec2d_t scale;
U_MemUnpackf32v2( scale );
v2[0] *= scale[0];
v2[1] *= scale[1];
}
else if ( trans_type & LAYER_FLAGS_TRANSFORMATION_SHIFT )
{
vec2d_t shift;
U_MemUnpackf32v2( shift );
v2[0] += shift[0];
v2[1] += shift[1];
}
else
{
__error( "invalid projectiv transformation\n" );
}
}
out[0] = v2[0];
out[1] = v2[1];
}
/*
==============================
IC_MgrCacheSubImage
==============================
*/
icMgrCacheRes IC_MgrCacheSubImage( ic_mgr_t *mgr, ic_subimage_t *sub )
{
int num;
u_list_iter_t iter;
ic_image_t *img;
int gap_area;
int best_gap_area;
ic_image_t *best_img;
// printf( "imgcache request\n" );
if ( sub->width > mgr->width || sub->height > mgr->height )
{
__error( "IC_MgrUpdateSubImage: subimage exceed maximum size\n" );
return ICMgrCacheRes_invalid_size;
}
// first search in all already allocated images for empty areas
best_gap_area = 0xffffff;
best_img = NULL;
U_ListIterInit( &iter, mgr->image_list );
for ( num = 0; ( img = (ic_image_t *)U_ListIterNext( &iter ) ) ; num++ )
{
gap_area = IC_ImageTestEmptyRectangles( img, sub->width, sub->height );
if ( gap_area != -1 )
{
if ( gap_area < best_gap_area )
{
best_gap_area = gap_area;
best_img = img;
}
}
}
if ( best_img )
{
IC_ImageTakeEmptyRectangle( best_img, sub->width, sub->height, &sub->xofs, &sub->yofs );
sub->texobj = best_img->texobj;
// IC_SubImageInsertIntoImage( sub, sub->pixels );
return ICMgrCacheRes_ok;
}
// none of the empty areas is up to standard, allocate new ic_image
if ( num >= mgr->maxnum )
{
// reached maximal number of ic_images
// __error( "reached maximal number of ic_images\n" );
return ICMgrCacheRes_cache_full;
}
img = IC_NewImage( mgr->width, mgr->height );
U_ListInsertAtHead( mgr->image_list, img );
IC_ImageTestEmptyRectangles( img, sub->width, sub->height );
IC_ImageTakeEmptyRectangle( img, sub->width, sub->height, &sub->xofs, &sub->yofs );
sub->texobj = img->texobj;
// IC_SubImageInsertIntoImage( sub, sub->pixels );
return ICMgrCacheRes_ok;
}
// In DragonFly __error() is an inline function and as such
// no symbol exists for it.
int *__dfly_error(void) { return __error(); }
/*
==============================
G_ServerRunFrame
==============================
*/
void G_ServerRunFrame( g_server_t *sv )
{
__chkptr( sv );
if ( sv->state != gServerState_is_init )
__error( "state is not init\n" );
if ( sv->mode == gServerMode_local )
{
byte_iter_t bi_in;
byte_iter_t bi_out;
ByteIter_Init( &bi_in, sv->buf_in, sv->buf_in_size );
ByteIter_Init( &bi_out, sv->buf_out, G_SERVER_OUTPUT_BUF_SIZE );
sv->lib.api.SetInputByteIter( &bi_in );
sv->lib.api.SetOutputByteIter( &bi_out );
if ( 1 );
{
char com_call[256];
const char *com_result;
sprintf( com_call, "SV_RunFrame %u", ms_wfbegin );
com_result = sv->lib.api.Com( com_call );
if ( com_result )
{
// printf( "com_result: '%s'\n", com_result );
}
}
sv->buf_out_size = ByteIter_GetOfs( &bi_out );
}
else if ( sv->mode == gServerMode_remote )
{
//
// send sv_in as frags through connected_server
//
// __named_message( "client sends %d bytes of sv_in\n", ByteIter_GetSize( sv->bi_in ) );
#if 1
int i;
buffer_send_t send;
char *send_buf;
int send_num_byte;
static int send_id = 1;
int num_frag;
// int total_udp;
send_num_byte = sv->buf_in_size;
send_buf = sv->buf_in;
// total_udp = 0;
BufferSend_Init( &send, send_buf, send_num_byte, send_id++ );
for ( num_frag = 0; ; num_frag++ )
{
byte_iter_t *bi;
int frag_num_byte;
char frag_buf[128];
if ( BufferSend_IsComplete( &send ) )
break;
bi = GC_NetSendInit( gc_state );
ByteIter_Packi( bi, netEv_cl2sv_buf_frag );
frag_num_byte = 72;
BufferSend_GetFrag( &send, frag_buf, &frag_num_byte );
for ( i = 0; i < frag_num_byte; i++ )
{
ByteIter_Packb( bi, frag_buf[i] );
}
printf( "." );
GC_NetSendFromLocalPort( gc_state, &gc_state->connected_sv.host );
}
// __named_message( "send %d/%d bytes in %d fragments\n", send_num_byte, total_udp, num_frag );
#endif
//
// if connected_server got a complete buffer, put it into sv_out
//
}
else
{
__error( "unknown server mode\n" );
}
//
// init buffer for next server frame
//
G_ServerResetInput( sv );
}
int main( int argc, char *argv[ ] ) {
euca_opts euca_args;
euca_opts *args = &euca_args;
java_home_t *data = NULL;
int status = 0;
pid_t pid = 0;
uid_t uid = 0;
gid_t gid = 0;
if( arguments( argc, argv, args ) != 0 ) exit( 1 );
debug = args->verbose_flag || args->debug_flag;
if( args->stop_flag == 1 ) return stop_child( args );
if( checkuser( GETARG( args, user ), &uid, &gid ) == 0 ) return 1;
char* java_home_user = GETARG(args,java_home);
char* java_home_env = getenv( "JAVA_HOME" );
if( java_home_user != NULL ) {
__debug("Trying user supplied java home: %s", java_home_user);
data = get_java_home(java_home_user);
}
if( data == NULL && java_home_env != NULL ) {
__debug("Trying environment JAVA_HOME: %s", java_home_env);
data = get_java_home(java_home_env);
}
__debug("TODO: loop through common locations for JVMs here.");
if( data == NULL ) {
__error( "Cannot locate Java Home" );
return 1;
}
int x;
if( debug == 1 ) {
__debug( "+-- DUMPING JAVA HOME STRUCTURE ------------------------" );
__debug( "| Java Home: \"%s\"", PRINT_NULL( data->path ) );
__debug( "| Found JVMs: %d", data->jnum );
for( x = 0; x < data->jnum; x++ ) {
jvm_info_t *jvm = data->jvms[ x ];
__debug( "| JVM Name: \"%s\"", PRINT_NULL( jvm->name ) );
__debug( "| \"%s\"", PRINT_NULL( jvm->libjvm_path ) );
}
__debug( "+-------------------------------------------------------" );
}
if( strcmp( argv[ 0 ], "eucalyptus-cloud" ) != 0 ) {
char *oldpath = getenv( "LD_LIBRARY_PATH" ),*libf = java_library( args, data );
char *old = argv[ 0 ],buf[ 32768 ],*tmp = NULL,*p1 = NULL,*p2 = NULL;
p1 = strdup( libf );
tmp = strrchr( p1, '/' );
if( tmp != NULL ) tmp[ 0 ] = '\0';
p2 = strdup( p1 );
tmp = strrchr( p2, '/' );
if( tmp != NULL ) tmp[ 0 ] = '\0';
if( oldpath == NULL ) snprintf( buf, 32768, "%s:%s:%s/bin/linux-x64", p1, p2, GETARG(args,profiler_home) );
else snprintf( buf, 32768, "%s:%s:%s:%s/bin/linux-x64", oldpath, p1, p2, GETARG(args,profiler_home) );
tmp = strdup( buf );
setenv( "LD_LIBRARY_PATH", tmp, 1 );
__debug( "Invoking w/ LD_LIBRARY_PATH=%s", getenv( "LD_LIBRARY_PATH" ) );
argv[ 0 ] = "eucalyptus-cloud";
execve( old, argv, environ );
__error( "Cannot execute process" );
return 1;
}
__debug( "Running w/ LD_LIBRARY_PATH=%s", getenv( "LD_LIBRARY_PATH" ) );
if(args->fork_flag) {
pid = fork( );
__die(( pid == -1 ),"Cannot detach from parent process" );
if( pid != 0 ) return wait_child( args, pid );
setsid( );
}
set_output(GETARG(args,out), GETARG(args,err));
while( ( pid = fork( ) ) != -1 ) {
if( pid == 0 ) exit( child( args, data, uid, gid ) );
child_pid = pid;
signal( SIGHUP, controller );
signal( SIGTERM, controller );
signal( SIGINT, controller );
while( waitpid( pid, &status, 0 ) != pid );
if( WIFEXITED( status ) ) {
status = WEXITSTATUS( status );
__debug( "Eucalyptus exited with status: %d", status );
if( status != 122 ) unlink( GETARG( args, pidfile ) );
if( status == 123 ) {
__debug( "Reloading service" );
continue;
}
if( status == 0 ) {
__debug( "Service shut down" );
return 0;
}
__error( "Service exit with a return value of %d", status );
return 1;
} else {
__error( "Service did not exit cleanly exit value %d", status );
return 1;
}
}
__error( "Cannot decouple controller/child processes" );
return 1;
}
res_vsc_cache_t * Res_CacheInVSC( res_vsc_register_t *reg )
{
tokenstream_t *ts;
int i, num, bytes, size;
int vertexnum;
int vrefnum;
int cmdnum;
vec3d_t vertices[1024];
int vrefs[2048];
int cmds[512];
res_vsc_cache_t *vsc;
ts = BeginTokenStream( reg->path );
if ( !ts )
__error( "load of '%s' failed\n", reg->path );
// get header
GetToken( ts );
if ( strcmp( ts->token, "3DG1" ) )
__error( "missing vsc header\n" );
// get vertexnum
GetToken( ts );
vertexnum = atoi( ts->token );
if ( vertexnum > 1024 )
__error( "too much vertices\n" );
// get vertices
for ( i = 0; i < vertexnum; i++ )
{
GetToken( ts );
vertices[i][0] = atof( ts->token );
GetToken( ts );
vertices[i][1] = atof( ts->token );
GetToken( ts );
vertices[i][2] = atof( ts->token );
}
// get faces
vrefnum = 0;
cmdnum = 0;
for(;;)
{
// get face pointnum
if ( GetToken( ts ) == TOKEN_FAIL )
break;
num = atoi( ts->token );
if ( cmdnum + 2 >= 512 )
__error( "too much commands\n" );
cmds[cmdnum++] = BE_CMD_POLYGON;
cmds[cmdnum++] = num;
// get vertex refs
for ( i = 0; i < num; i++ )
{
if ( vrefnum >= 2048 )
__error( "too much vertex references\n" );
GetToken( ts );
vrefs[vrefnum++] = atoi( ts->token );
}
// get face color
GetToken( ts );
}
// terminate cmd
cmds[cmdnum++] = BE_CMD_END;
cmds[cmdnum++] = 0;
// calc total size
bytes = vertexnum * 3*4 + vrefnum * 4 + cmdnum * 4;
size = (int)(&((res_vsc_cache_t *)0)->data[bytes]);
vsc = NEWBYTES( size );
vsc->vertexnum = vertexnum;
vsc->vrefnum = vrefnum;
vsc->cmdnum = cmdnum;
vsc->vertex_ofs = 0;
vsc->vref_ofs = vertexnum * 3*4;
vsc->cmd_ofs = vertexnum * 3*4 + vrefnum * 4;
memcpy( &vsc->data[vsc->vertex_ofs], vertices, vertexnum * 3*4 );
memcpy( &vsc->data[vsc->vref_ofs], vrefs, vrefnum * 4 );
memcpy( &vsc->data[vsc->cmd_ofs], cmds, cmdnum * 4 );
return vsc;
}
/*
==============================
SV_RunFrame
==============================
*/
const char * SV_RunFrame( const char *in )
{
int num_sleep, num_wakeup, num_dead;
int num_think1, num_think2;
ati_t *ati, *next;
char tkn[256];
const char *tkn_ptr;
TFUNC_ENTER;
//
// get current frame time
//
tkn_ptr = in;
Parse_GetToken( &tkn_ptr, tkn, 256 );
if ( !tkn[0] )
{
__warning( "missing current time in call\n" );
TFUNC_LEAVE;
return "fail";
}
else
{
sv_time_last_frame = sv_time_current_frame;
sv_time_current_frame = atoi( tkn );
if ( sv_time_current_frame <= sv_time_last_frame )
{
__warning( "current time < last time\n" );
TFUNC_LEAVE;
return "fail";
}
else
{
sv_time_delta_frame = sv_time_current_frame-sv_time_last_frame;
sv_delta_sec = sv_time_delta_frame/1000.0;
}
}
#if 0
__named_message( "times: last %d, current %d, delta %d\n",
sv_time_last_frame,
sv_time_current_frame,
sv_time_delta_frame );
#endif
if ( sv_delta_sec > 0.5 )
{
__warning( "clip server frame time delta !!!\n" );
sv_delta_sec = 0.5;
}
sv_time = sv_time_current_frame;
sv_time_delta = sv_delta_sec;
//
// send server frame time info to client
//
{
byte_iter_t frm;
PackFrame_Begin( bi_out, &frm );
ByteIter_Packi( &frm, UNIQUE_INVALIDE );
ByteIter_Packi( &frm, eventType_client_info_time );
ByteIter_Packi( &frm, sv_time_last_frame );
ByteIter_Packi( &frm, sv_time_current_frame );
PackFrame_End( bi_out, &frm );
}
//
// dispatch all events in the input buffer
//
{
int remain;
for(;;)
{
byte_iter_t frm;
unique_t id;
eventType ev_type;
remain = ByteIter_GetSize( bi_in ) - ByteIter_GetOfs( bi_in );
if ( remain == 0 )
break;
/*frm_size = */UnpackFrame_Begin( bi_in, &frm );
id = ByteIter_Unpacki( &frm );
ev_type = (eventType)ByteIter_Unpacki( &frm );
if ( ev_type < eventType_server_first ||
ev_type > eventType_server_last )
{
__error( "not a 'server' event\n" );
}
ati = L_AtiSearchById( id );
if ( !ati )
{
__warning( "no server object for id '#%u' found\n", id );
}
else
{
if ( !ati->ftbl->UnpackEvent )
{
__error( "server object '#%u' has no ability to unpack events\n" );
}
else
{
ati->ftbl->UnpackEvent( ati, id, ev_type, &frm );
}
}
UnpackFrame_End( bi_in, &frm );
}
}
//
// first move all archetypes from the wakeup_list to the run_list
//
num_wakeup = 0;
for ( ; ( ati = L_AtiListRemoveAtHead( &sv_wakeup ) ) ; )
{
L_AtiChangeToRun( ati );
num_wakeup++;
}
//
// all archetypes in the run_list Think1 now
//
// L_BeginCollideMap();
num_think1 = 0;
num_think2 = 0;
L_CollideMapReset();
for ( ati = sv_run.head.next ; ati != &sv_run.tail ; ati = next )
{
// archetypes may change to sleep_list or dead_list
next = ati->next;
if ( ati->ftbl->Run )
{
ati->ftbl->Run( ati, atiRun_think1 );
num_think1++;
}
}
for ( ati = sv_run.head.next ; ati != &sv_run.tail ; ati = next )
{
// archetypes may change to sleep_list or dead_list
next = ati->next;
if ( ati->ftbl->Run )
{
ati->ftbl->Run( ati, atiRun_think2 );
num_think2++;
}
}
//
// finally destroy all archetypes in the dead_list
//
num_dead = 0;
for ( ; ( ati = L_AtiListRemoveAtHead( &sv_dead ) ) ; )
{
ati->ftbl->Destroy( (ati_t*)ati );
num_dead++;
}
//
// count sleeping archetypes
//
num_sleep = 0;
for ( ati = sv_sleep.head.next ; ati != &sv_sleep.tail ; ati=ati->next )
{
num_sleep++;
}
// printf( " life: %d sleeps, %d wakeups, %d t1, %d t2, %d deads\n", num_sleep, num_wakeup, num_think1, num_think2, num_dead );
sv_frame_count++;
TFUNC_LEAVE;
return "ok";
}
/*
==============================
Tess_CreateMesh_curved_face
==============================
*/
void Tess_CreateMesh_curved_face( shape_t *shp )
{
int i;
mesh_t *mesh;
u_list_iter_t iter;
shape_ctrl_point_t *cp;
int pnum;
vec3d_t pts[CURVED_FACE_MAX_POINTS];
int fs[CURVED_FACE_MAX_POINTS];
if ( shp->tess_name != ShapeTesselation_curved_face )
__error( "tess_name invalid\n" );
if ( shp->norm[0] == 0 &&
shp->norm[1] == 0 &&
shp->norm[2] == 0 )
__error( "missing plane hint\n" );
if ( shp->vnum != 1 )
__error( "invalid v order\n" );
if ( shp->unum <= 0 )
__error( "invalid u order\n" );
if ( shp->unum != U_ListLength( shp->cp_list ) )
__error( "control point inconsitancy\n" );
// fixme: lod init
if ( shp->u_lod == 0 )
{
shp->u_lod = 3;
}
pnum = shp->unum;
for ( i = 0; i < pnum; i++ )
fs[i] = CURVED_FACE_FLAGS_NONE;
// setup and check control points
U_ListIterInit( &iter, shp->cp_list );
for ( ; ( cp = (shape_ctrl_point_t *)U_ListIterNext( &iter ) ) ; )
{
if ( cp->u < 0 || cp->u > pnum-1 || cp->v != 0 )
__error( "invalid control point\n" );
if ( fs[cp->u] != CURVED_FACE_FLAGS_NONE )
__error( "dublicated control points\n" );
fs[cp->u] |= CURVED_FACE_FLAGS_USED;
Vec3dCopy( pts[cp->u], cp->p );
}
Trify_BeginGenericPolygon();
Trify_SetPlane( shp->norm, shp->dist );
Tess_CurvedFace_GenCurvedEdge( shp->u_lod, pnum, pts );
mesh = Trify_End();
if ( shp->mesh )
Mesh_Free( shp->mesh );
shp->mesh = mesh;
Tess_CurvedFace_CalcBoundBox( shp );
}
res_gltex_cache_t * Res_CacheInGLTEX_jpg( res_gltex_register_t *reg )
{
struct jpeg_decompress_struct cinfo;
ib_file_t *h;
unsigned char *buffer;
int row_stride;
struct my_error_mgr jerr;
// FILE *b;
int pixels;
unsigned char *image, *ptr;
res_gltex_cache_t *gltex;
h = IB_Open( reg->path );
// b = fopen( "test.jpg", "rb" );
if( !h )
{
__error( "load of '%s' failed\n", reg->path );
}
// memset( &cinfo, 0, sizeof( struct jpeg_decompress_struct ));
cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = jpeg_error_exit;
if (setjmp (jerr.setjmp_buffer))
{
jpeg_destroy_decompress (&cinfo);
if( h )
IB_Close( h );
__error( "XJT: JPEG load error\n");
}
printf( "%p\n", cinfo.err );
// step 1
jpeg_create_decompress(&cinfo);
// cinfo.err = jpeg_std_error (&jerr.pub);
// printf( "%p\n", cinfo.err );
// step 2
jpeg_ibase_src(&cinfo, h);
// jpeg_stdio_src( &cinfo, b );
// printf( "back\n" );
// step 3
jpeg_read_header(&cinfo, TRUE);
/*
if( cinfo.jpeg_color_space != JCS_RGB )
{
__error( "colorspace is not RGB\n" );
}
*/
jpeg_start_decompress( &cinfo );
// printf( "jpeg: %d %d %d\n", cinfo.image_width, cinfo.image_height, cinfo.output_components );
if( cinfo.output_components != 3 )
{
__error( "jpeg file '%s' is not RGB\n", reg->path );
}
pixels = cinfo.output_width * cinfo.output_height;
image = (unsigned char *)MM_Malloc( pixels * 3 );
row_stride = cinfo.output_width * 3;
ptr = image + ( row_stride * (cinfo.output_height - 1) );
std::vector<unsigned char>buffer_data( row_stride );
buffer = buffer_data.data();
//buffer = (unsigned char *)alloca( row_stride );
// printf( "row_stride: %d\n", row_stride );
while( cinfo.output_scanline < cinfo.output_height )
{
// __named_message( "%d\n", cinfo.output_scanline );
jpeg_read_scanlines( &cinfo, &buffer, 1 );
memcpy( ptr, buffer, row_stride );
ptr -= row_stride;
}
// memset( image, 0, pixels *3 );
jpeg_finish_decompress( &cinfo );
jpeg_destroy_decompress( &cinfo );
IB_Close( h );
gltex = NEWTYPE( res_gltex_cache_t );
gltex->width = cinfo.output_width;
gltex->height = cinfo.output_height;
__message( "%s: %d %d\n", reg->path, gltex->width, gltex->height );
gltex->comp = resGltexComponents_rgb;
Res_CreateGLTEX_rgb( cinfo.output_width, cinfo.output_height, image );
// __error( "good\n" );
return gltex;
}
/*
==============================
CL_WorldSpring
==============================
*/
const char * CL_WorldSpring( const char *in )
{
sh_var_t *tmp;
char path[256];
hobj_search_iterator_t iter;
hobj_t *obj;
static struct { const char *key; cl_ati_t *(*func)(hobj_t *); } resolves[] = {
{ "switch", CL_CreateSwitch },
{ "light", CL_CreateLight },
{ "spotlight", CL_CreateLight },
{ "facelight", CL_CreateLight },
{ NULL, NULL }
};
__named_message( "\n" );
tmp = g_api.SH_GetVar( "gc_map" );
g_api.Printf( "gc_map is '%s'\n", tmp->string );
//
// load archetype class
//
sprintf( path, "world/%s.d/ats.hobj", tmp->string );
g_api.Printf( "archetypes come from: '%s'\n", path );
cl_at_root = g_api.GI_ReadClass( path );
if ( !cl_at_root )
{
__error( "can't load class\n" );
}
InitClassSearchIterator( &iter, cl_at_root, "*" );
for ( ; ( obj = SearchGetNextClass( &iter ) ) ; )
{
int i;
// g_api.Printf( "[%s,%s]\n", obj->type, obj->name );
for ( i = 0; resolves[i].key ; i++ )
if ( !strcmp( resolves[i].key, obj->type ) ) break;
if ( !resolves[i].key )
{
// printf( " no func found !\n" );
}
else
{
cl_ati_t *ati;
// printf( " func found !\n" );
ati = resolves[i].func( obj );
U_ListInsertAtHead( &cl_ati_list, ati );
Util_AtiRegisterId( ati );
}
}
return "ok";
}
/*
==============================
Tess_CreateMesh_curved_surface
==============================
*/
void Tess_CreateMesh_curved_surface( shape_t *shp )
{
int u, v;
int u_order, v_order;
u_list_iter_t iter;
shape_ctrl_point_t *cp;
int cpnum;
mesh_t *mesh;
vec3d_t pts[CURVED_SURFACE_MAX_U_ORDER][CURVED_SURFACE_MAX_V_ORDER];
int fs[CURVED_SURFACE_MAX_U_ORDER][CURVED_SURFACE_MAX_V_ORDER];
if ( shp->tess_name != ShapeTesselation_curved_surface )
__error( "tess_name invalid\n" );
u_order = shp->unum;
v_order = shp->vnum;
if ( u_order <= 1 || u_order >= CURVED_SURFACE_MAX_U_ORDER )
__error( "invalid u order\n" );
if ( v_order <= 1 || v_order >= CURVED_SURFACE_MAX_V_ORDER )
__error( "invalid v order\n" );
for ( u = 0; u < u_order; u++ )
{
for ( v = 0; v < v_order; v++ )
{
fs[u][v] = CURVED_SURFACE_FLAGS_NONE;
}
}
// setup and check control points
U_ListIterInit( &iter, shp->cp_list );
for ( cpnum = 0; ( cp = (shape_ctrl_point_t *)U_ListIterNext( &iter ) ); cpnum++ )
{
u = cp->u;
v = cp->v;
if ( u < 0 || u >= u_order )
__error( "invalid control point\n" );
if ( v < 0 || v >= v_order )
__error( "invalid control point\n" );
if ( fs[u][v] != CURVED_SURFACE_FLAGS_NONE )
__error( "dublicated control points\n" );
fs[u][v] |= CURVED_SURFACE_FLAGS_USED;
Vec3dCopy( pts[u][v], cp->p );
}
if ( cpnum != u_order*v_order )
__error( "not enough control points\n" );
// fixme: lod init
if ( shp->u_lod == 0 && shp->v_lod == 0 )
{
Tess_CurvedSurface_ClassifyLOD( &shp->u_lod, &shp->v_lod, u_order, v_order, pts );
}
mesh = Tess_CurvedSurface_GenMesh( shp->u_lod, shp->v_lod, u_order, v_order, pts );
if ( shp->mesh )
Mesh_Free( shp->mesh );
shp->mesh = mesh;
Tess_CurvedSurface_CalcBoundBox( shp );
}
/*
==============================
CL_RunFrame
==============================
*/
const char * CL_RunFrame( const char *in )
{
int num_ev;
int num_wakeup;
int num_run;
int num_die;
u_list_iter_t iter;
cl_ati_t *ati;
char tkn[256];
const char *tkn_ptr;
// __named_message( "\n" );
TFUNC_ENTER;
tkn_ptr = in;
//
// get current frame time
//
Parse_GetToken( &tkn_ptr, tkn, 256 );
if ( !tkn[0] )
{
__warning( "missing current time in call\n" );
TFUNC_LEAVE;
return "fail";
}
else
{
cl_time_begin_frame = cl_time_end_frame;
cl_time_end_frame = atoi( tkn );
if ( cl_time_end_frame <= cl_time_begin_frame )
{
__warning( "time end < time begin\n" );
TFUNC_LEAVE;
return "fail";
}
else
{
cl_time_delta = (cl_time_end_frame-cl_time_begin_frame)/1000.0;
}
}
if ( cl_sv_time >= cl_sv_time_delta )
{
// __warning( "client reached end of current server frame\n" );
}
#if 0
__named_message( "times: last %d, current %d, delta %d\n",
cl_time_last_frame,
cl_time_current_frame,
cl_time_delta_frame );
#endif
//
// client frame prepare
//
cl_time = cl_time_begin_frame;
// for hud
cl_num_hud = 0;
// fixme: proxy killboxes stay only for one client frame,
// should there be a timeout
CL_ProxyKillBoxMapReset();
//
// dispatch all events in the input buffer
//
for( num_ev = 0;; num_ev++ )
{
int remain;
// int frm_size;
byte_iter_t frm;
unique_t id;
eventType ev_type;
remain = ByteIter_GetSize( bi_in ) - ByteIter_GetOfs( bi_in );
if ( remain == 0 )
break;
/*frm_size =*/ UnpackFrame_Begin( bi_in, &frm );
id = ByteIter_Unpacki( &frm );
ev_type = (eventType)ByteIter_Unpacki( &frm );
if ( id == UNIQUE_INVALIDE )
{
if ( ev_type >= eventType_client_info_first &&
ev_type <= eventType_client_info_last )
{
if ( ev_type == eventType_client_info_time )
{
// server frame time info
cl_sv_time_begin_frame = ByteIter_Unpacki( &frm );
cl_sv_time_end_frame = ByteIter_Unpacki( &frm );
cl_sv_time = 0.0;
cl_sv_time_delta = (cl_sv_time_end_frame-cl_sv_time_begin_frame)/1000.0;
}
else
{
__error( "unknown info event" );
}
}
else if ( ev_type >= eventType_client_proxy_first &&
ev_type <= eventType_client_proxy_last )
{
if( ev_type == eventType_client_proxy_killbox )
{
CL_ProxyKillBoxMapAdd( &frm );
}
}
else if ( ev_type >= eventType_client_gfx_first &&
ev_type <= eventType_client_gfx_last )
{
if ( ev_type == eventType_client_gfx_create )
{
CL_CreateGfxFromEvent( &frm );
}
}
else
{
__error( "unknown anonymous event\n" );
}
}
else
{
ati = Util_AtiSearchById( id );
if ( ev_type < eventType_client_first ||
ev_type > eventType_client_last )
{
__error( "not a 'client' event" );
}
if ( !ati )
{
//
// if no client object exists for the event
// only typeinfo events are allowed to create object
//
if ( ev_type > eventType_client_typeinfo_first &&
ev_type < eventType_client_typeinfo_last )
{
switch( ev_type )
{
case eventType_client_typeinfo_player:
{
// __named_message( "'typeinfo_player' event\n" );
ati = CL_CreatePlayer( id, &frm );
break;
}
case eventType_client_typeinfo_view:
{
// __named_message( "'typeinfo_view' event\n" );
ati = CL_CreateView( id, &frm );
break;
}
case eventType_client_typeinfo_item:
{
// __named_message( "'typeinfo_item' event\n" );
ati = CL_CreateItem( id, &frm );
break;
}
case eventType_client_typeinfo_psys:
{
// __named_message( "'typeinfo_psys' event\n" );
ati = CL_CreatePsys( id, &frm );
break;
}
case eventType_client_typeinfo_rocket:
{
// __named_message( "'typeinfo_rocket' event\n" );
ati = CL_CreateRocket( id, &frm );
break;
}
default:
{
__error( "unkown typeinfo\n" );
}
}
ati->state = clAtiState_run;
U_ListInsertAtHead( &cl_ati_list, ati );
Util_AtiRegisterId( ati );
}
else
{
__warning( "ignore event for not existing client object '#%u'\n", id );
}
}
else
{
if ( ev_type > eventType_client_typeinfo_first &&
ev_type < eventType_client_typeinfo_last )
{
// __warning( "ignore typeinfo event for existing client object '#%u'\n", id );
}
else if ( ev_type > eventType_client_obj_update_first &&
ev_type < eventType_client_obj_update_last )
{
if ( !ati->ftbl->UnpackEvent )
{
__error( "object has no unpack ability\n" );
}
else
{
ati->ftbl->UnpackEvent( ati, id, ev_type, &frm );
}
}
else if ( ev_type > eventType_client_obj_destroy_first &&
ev_type < eventType_client_obj_destroy_last )
{
ati->state = clAtiState_dead;
}
else
{
__error( "unknown event for existing client object '#%u'\n", id );
}
}
}
UnpackFrame_End( bi_in, &frm );
}
if ( num_ev > 0 )
{
// a server frame arrived
}
num_wakeup = 0;
num_run = 0;
num_die = 0;
//
// move wakeup objects to run list
//
for ( ; ( ati = (cl_ati_t*)U_ListRemoveAtHead( &cl_ati_wakeup_list ) ) ; )
{
ati->state = clAtiState_run;
U_ListInsertAtHead( &cl_ati_list, ati );
num_wakeup++;
}
//
// run client objects
//
U_ListIterInit( &iter, &cl_ati_list );
for ( ; ( ati = (cl_ati_t*)U_ListIterNext( &iter ) ) ; )
{
if ( ati->ftbl->Run && ( ati->state == clAtiState_none || ati->state == clAtiState_run ) )
{
ati->ftbl->Run( ati );
num_run++;
}
}
//
// do hud frag
//
HUD_DrawFragRanking();
//
// remove dead objects
//
U_ListIterInit( &iter, &cl_ati_list );
for ( ; ( ati = (cl_ati_t*)U_ListIterNext( &iter ) ) ; )
{
if ( ati->state == clAtiState_dead )
{
U_ListIterRemoveGoNext( &iter );
if ( ati->id != UNIQUE_INVALIDE )
{
Util_AtiUnregisterRegisterId( ati );
}
ati->ftbl->Destroy( ati );
num_die++;
}
}
cl_frame_count++;
cl_sv_time += cl_time_delta;
// __named_message( "client: %d wakeup, %d run, %d die\n", num_wakeup, num_run, num_die );
TFUNC_LEAVE;
return "ok";
}
void main( int argc, char* argv[] )
{
char* pal_name;
char* file_name;
char* file_suf;
int file_type = TYPE_UNKNOWN;
int i, i2;
int start_x;
int data_start;
vid_device_t* vid_dev;
char* data;
arr_t* arr;
char* wal_data[4];
wal_header_t wal_header;
FILE* pal_handle;
FILE* in_handle;
/* Signal handler setzen */
signal( SIGSEGV, (void(*) ()) SecureShutDown );
signal( SIGABRT, (void(*) ()) SecureShutDown );
signal( SIGTERM, (void(*) ()) SecureShutDown );
signal( SIGQUIT, (void(*) ()) SecureShutDown );
signal( SIGINT, (void(*) ()) SecureShutDown );
SOS_SetShockHandler( MyShockHandler );
file_name = GetCmdOpt( "-f", argc, argv );
if( file_name == NULL )
{
__message( "no filename given.\n" );
PrintUsage();
exit( 0 );
}
file_suf = strrchr( file_name, '.' );
if( ( file_suf == NULL ) && ( !CheckCmdSwitch( "-t", argc, argv) ))
{
printf( "filename doesn't seem to have a sufix.\n" );
PrintUsage();
exit( 0 );
}
file_suf++;
if( CheckCmdSwitch( "-t", argc, argv ) )
{
file_suf = GetCmdOpt( "-t", argc, argv );
}
printf( "suf: %s\n", file_suf );
if( ! (memcmp( file_suf, "arr", 3 )))
{
file_type = TYPE_ARR;
} else if( ! (memcmp( file_suf, "wal", 3 )))
{
file_type = TYPE_WAL;
}
printf( "type: %d\n", file_type );
CDB_StartUp( 0 );
UI_StartUp( "ui_x11.so" );
vid_dev = VID_StartUp();
VID_SetModeByName( 640, 480, 8 );
KEYB_StartUp();
pal_name = GetCmdOpt( "-p", argc, argv );
if( pal_name == NULL )
{
pal_name = CDB_GetString( "misc/default_pal" );
if( pal_name == NULL )
{
__error( "couldn't find any palname.\n" );
}
}
printf( "\t\tpal: %s\n", pal_name );
pal_handle = fopen( pal_name, "rb" );
VID_LoadPal( pal_handle );
fclose( pal_handle );
data = ( char* )VID_GetVirtualPage() -> data;
in_handle = fopen( file_name, "rb" );
if( in_handle == NULL )
__error( "file not found.\n" );
if( file_type == TYPE_ARR )
{
arr = ARR_Read( in_handle );
ARR_Dump( arr );
if( CheckCmdSwitch( "-d", argc, argv ))
{
ARR_Dump( arr );
}
start_x = 0;
data_start = 0;
for( i = 0; i < arr->mipmap_num; i++ )
{
// printf(" i: %d, x: %d, y %d\n", i, arr->size_x, arr->size_y );
for( i2 = 0; i2 < arr->size_y; i2++ )
{
memcpy( &data[i2*640+start_x], &arr->data[i2*arr->size_x+data_start], arr->size_x);
}
// printf("\n");
start_x+=arr->size_x+1;
data_start += arr->size_x * arr->size_y;
arr->size_x/=2;
arr->size_y/=2;
}
}
if( file_type == TYPE_WAL ) // warning: quick and dirty code! todo: make it better.
{
fread( &wal_header, sizeof( wal_header_t ), 1, in_handle );
//wal_tmp = wal_header->size_x*wal_header->size_y;
//wal_data_size = wal_tmp + wal_tmp/4 + wal_tmp/8 + wal_tmp/16;
start_x = 0;
for( i = 0; i < 4; i++ )
{
wal_data[i] = ( char* )malloc( wal_header.size_x * wal_header.size_y );
fread( wal_data[i], wal_header.size_x * wal_header.size_y, 1, in_handle );
for( i2 = 0; i2 < wal_header.size_y; i2++ )
{
memcpy( &data[i2*640+start_x], &wal_data[i][i2*wal_header.size_x], wal_header.size_x );
}
start_x += wal_header.size_x+1;
wal_header.size_x/=2;
wal_header.size_y/=2;
}
}
if( file_type == TYPE_UNKNOWN )
{
data[6500] = 127;
}
VID_Refresh();
for(;;)
{
usleep( 100000 );
KEYB_Update();
if( KEYB_KeyPressed( KEYID_ENTER ))
break;
}
KEYB_ShutDown();
VID_ShutDown();
UI_ShutDown();
}
/*
==============================
G_ClientRunFrame
==============================
*/
void G_ClientRunFrame( g_client_t *cl )
{
// sh_var_t *tmp;
// unique_t id;
__chkptr( cl );
if ( cl->state != gClientState_is_init )
__error( "state is not init\n" );
// tmp = SHP_GetVar( "gc_id_bind_view" );
// id = tmp->ivalue;
// le.ClientBindView( id );
cl->ri_model_num = 0;
cl->ri_sprite_num = 0;
cl->ri_psys_num = 0;
cl->ri_local_light_num = 0;
cl->ri_halo_num = 0;
cl->di_rect_num = 0;
cl->di_text_num = 0;
cl->ri_view_player = NULL;
cl->ri_view_spectator = NULL;
cl->ri_view_sky = NULL;
// le.L_RunFrame();
{
byte_iter_t bi_in;
byte_iter_t bi_out;
char com_call[256];
const char *com_result;
ByteIter_Init( &bi_in, cl->buf_in, cl->buf_in_size );
ByteIter_Init( &bi_out, cl->buf_out, G_CLIENT_OUTPUT_BUF_SIZE );
cl->lib.api.SetInputByteIter( &bi_in );
cl->lib.api.SetOutputByteIter( &bi_out );
sprintf( com_call, "CL_RunFrame %u", ms_rfbegin );
com_result = cl->lib.api.Com( com_call );
if ( com_result )
{
// printf( "com_result: '%s'\n", com_result );
}
cl->buf_out_size = ByteIter_GetOfs( &bi_out );
}
G_ClientResetInput( cl );
//
// apply lightsource changes
//
// for ( i = 0; i < cl->ri_lightsource_num; i++ )
// {
// G_HandleRenderInfoLightSource( cl->ri_lightsources[i] );
// }
//
// apply shape manipulations
//
// G_ApplyWFShapeInfos( cl );
//
// run field particle systems
//
// for ( i = 0; i < cl->wf_fpsys_num; i++ )
// {
// G_FieldParticleSystemRun( cl->wf_fpsyss[i]->fpsys );
// }
}
/*
==============================
R_SetupSFaceShape
==============================
*/
shape_t * R_SetupSFaceShape( hobj_t *shape, g_map_t *map )
{
hobj_t *plane;
hobj_t *polygon;
vec3d_t norm;
fp_t dist;
int pointnum;
int i;
shape_t *shp;
int multi_flags;
multi_flags = LAYER_STATE_FLAGS_DEPTH_MASK;
polygon = FindClassType( shape, "polygon" );
if ( !polygon )
__error( "missing class 'polygon' in shape '%s'\n", shape->name );
// get control points
EasyFindInt( &pointnum, polygon, "num" );
if ( pointnum < 3 )
{
printf( " shape '%s' is degenerated\n", shape->name );
return NULL;
}
Shape_BeginInstance();
Shape_SetPrimaryKey( StringToUnique( shape->name ) );
Shape_SetTesselation( ShapeTesselation_simple_face );
// get plane
plane = EasyLookupClsref( polygon, "plane", map->planehm );
EasyFindVec3d( norm, plane, "norm" );
EasyFindFloat( &dist, plane, "dist" );
Shape_SetPlaneHint( norm, dist );
Shape_SetCtrlPointNum( pointnum, 1 );
for ( i = 0; i < pointnum; i++ )
{
vec3d_t v;
char str[256];
sprintf( str, "%d", i );
EasyFindVec3d( v, polygon, str );
Shape_AddCtrlPoint( Shape_NewCtrlPointUV3fv( i, 0, v ) );
}
//
// texture layer
//
if ( 1 )
{
// texture proj_texdef0
hobj_t *texdef0;
hobj_t *texdef_real;
hpair_t *pair;
vec2d_t shift;
vec2d_t scale;
fp_t rotate;
// vec2d_t vecs[2];
int projection;
hobj_t *texture;
g_resource_t *gltex_res;
char str[256];
layer_t *layer;
unitex_t *uni;
tf2d_stack_t *tf2d_stack;
texdef0 = FindClassType( shape, "proj_texdef0" );
if ( !texdef0 )
__error( "missing class 'proj_texdef0' in shape '%s'\n", shape->name );
texdef_real = EasyLookupClsref( texdef0, "texdef", map->texdefhm );
EasyFindVec2d( shift, texdef_real, "shift" );
EasyFindVec2d( scale, texdef_real, "scale" );
EasyFindFloat( &rotate, texdef_real, "rotate" );
// EasyFindVec2d( vecs[0], texdef_real, "vec0" );
// EasyFindVec2d( vecs[1], texdef_real, "vec1" );
EasyFindInt( &projection, texdef_real, "flags" );
texture = EasyLookupClsref( texdef_real, "texture", map->texturehm );
pair = FindHPair( texture, "ident" );
if ( !pair )
__error( "missing key 'ident' in texture class '%s'\n", texture->name );
//
// check ident for multilayer definition
//
{
hobj_t *multilayer;
multilayer = HManagerSearchClassName( map->multilayerhm, pair->value );
if ( multilayer )
{
// __named_message( "MULTILAYER DEFINITON !\n" );
R_SetupSFaceMultiLayerFromClass( texdef_real, multilayer );
pair = FindHPair( multilayer, "depthmask" );
if ( !pair )
{
// default is depthmask = true
multi_flags |= LAYER_STATE_FLAGS_DEPTH_MASK;
}
else
{
if ( !strcmp( pair->value, "0" ) )
{
multi_flags &= ~LAYER_STATE_FLAGS_DEPTH_MASK;
multi_flags |= LAYER_STATE_FLAGS_SHADE_P3;
}
else
{
multi_flags |= LAYER_STATE_FLAGS_SHADE_P3;
}
}
pair = FindHPair( multilayer, "pass" );
if ( pair )
{
multi_flags &= ~LAYER_STATE_FLAGS_SHADE_P1;
multi_flags &= ~LAYER_STATE_FLAGS_SHADE_P2;
multi_flags &= ~LAYER_STATE_FLAGS_SHADE_P3;
if ( !strcmp( "1", pair->value ) )
{
multi_flags |= LAYER_STATE_FLAGS_SHADE_P1;
}
else if ( !strcmp( "2", pair->value ) )
{
multi_flags |= LAYER_STATE_FLAGS_SHADE_P2;
}
else if ( !strcmp( "3", pair->value ) )
{
multi_flags |= LAYER_STATE_FLAGS_SHADE_P3;
}
else
{
__error( "unknown pass\n" );
}
}
goto texture_skip;
}
}
// build gltex resource name from ident
sprintf( str, "gltex.%s", pair->value );
strcrpl( str, '/', '.' );
// printf( "gltex: %s\n", str );
gltex_res = G_ResourceSearch( g_rs, str );
uni = UniTex_NewFrom_gltexres( gltex_res );
Layer_BeginInstance( (layerMode)(LayerMode_projection | LayerMode_Texel0N) );
{
// hack: build layer_gl_state_t
layer_gl_state_t *glstate;
glstate = NEWTYPE( layer_gl_state_t );
glstate->sfactor = GL_ONE;
glstate->dfactor = GL_ZERO;
Layer_SetGLstate( glstate );
}
Layer_SetOrdinal( LAYER_TEXTURE_1 );
Layer_SetUniTex( uni );
if ( (projection&3) == ProjectionType_X )
{
Layer_SetProjection( LayerProjection_x );
}
else if ( (projection&3) == ProjectionType_Y )
{
Layer_SetProjection( LayerProjection_y );
}
else if ( (projection&3) == ProjectionType_Z )
{
Layer_SetProjection( LayerProjection_z );
}
else
{
__error( "can't get projection plane\n" );
}
//
// setup layer's transformation stack
//
tf2d_stack = NEWTYPE( tf2d_stack_t );
TF2D_InitStack( tf2d_stack );
Layer_SetTF2DStack( tf2d_stack );
// if ( 1 || projection&ProjectionType_Vecs )
{
tf2d_t *tf2d;
tf2d_matrix_t *tf2d_matrix;
tf2d = TF2D_CreateMatrix();
tf2d_matrix = TF2D_IsMatrix( tf2d );
TF2D_SetupMatrixByAngle( tf2d_matrix, -rotate );
TF2D_StackPush( tf2d_stack, tf2d );
}
{
tf2d_t *tf2d;
tf2d_scale_t *tf2d_scale;
scale[0] = 1.0/scale[0];
scale[1] = 1.0/scale[1];
tf2d = TF2D_CreateScale();
tf2d_scale = TF2D_IsScale( tf2d );
Vec2dCopy( tf2d_scale->scale, scale );
TF2D_StackPush( tf2d_stack, tf2d );
}
// if ( 1 || projection&ProjectionType_Shift )
{
tf2d_t *tf2d;
tf2d_shift_t *tf2d_shift;
shift[0] = -shift[0];
shift[1] = -shift[1];
tf2d = TF2D_CreateShift();
tf2d_shift = TF2D_IsShift( tf2d );
Vec2dCopy( tf2d_shift->shift, shift );
TF2D_StackPush( tf2d_stack, tf2d );
}
layer = Layer_EndInstance();
Shape_AddLayer( layer );
}
texture_skip:
//
// diffuse layer
//
#if 1
{
hobj_t *lightdef;
vec2d_t shift;
int width;
int height;
int projection;
fp_t patchsize;
ic_subimage_t *sub;
unitex_t *uni;
lightmap_t *lightmap_head;
layer_t *layer;
lightdef = FindClassType( shape, "proj_lightdef" );
if ( !lightdef )
{
goto no_lightdef;
}
EasyFindVec2d( shift, lightdef, "shift" );
EasyFindInt( &width, lightdef, "width" );
EasyFindInt( &height, lightdef, "height" );
EasyFindFloat( &patchsize, lightdef, "patchsize" );
EasyFindInt( &projection, lightdef, "projection" );
lightmap_head = LinkLightmaps( a_map->lightmap_db, StringToUnique( shape->name ), 0 );
if ( !lightmap_head && 0 )
goto no_diffuse;
{
int lightmap_bytes;
void *lightmap_pixels;
lightmap_bytes = width*height*4;
lightmap_pixels = NEWBYTES( lightmap_bytes );
sub = IC_NewSubImage( width, height );
IC_SubImageSetPixels( sub, lightmap_pixels );
}
uni = UniTex_NewFrom_subimage( sub );
// create diffuse layer
Layer_BeginInstance( (layerMode)(LayerMode_projection | LayerMode_Texel0N) );
{
// hack: build layer_gl_state_t
layer_gl_state_t *glstate;
glstate = NEWTYPE( layer_gl_state_t );
glstate->sfactor = GL_ZERO;
glstate->dfactor = GL_SRC_COLOR;
Layer_SetGLstate( glstate );
}
Layer_SetOrdinal( LAYER_DIFFUSE_1 );
Layer_SetUniTex( uni );
Layer_SetLightmapHead( lightmap_head );
if ( (projection&3) == ProjectionType_X )
{
Layer_SetProjection( LayerProjection_x );
}
else if ( (projection&3) == ProjectionType_Y )
{
Layer_SetProjection( LayerProjection_y );
}
else if ( (projection&3) == ProjectionType_Z )
{
Layer_SetProjection( LayerProjection_z );
}
else
{
__error( "can't get projection plane\n" );
}
{
shift[0] = -shift[0];
shift[1] = -shift[1];
Layer_AddShift( shift );
}
{
vec2d_t scale;
scale[0] = 1.0 / patchsize;
scale[1] = 1.0 / patchsize;
Layer_AddScale( scale );
}
layer = Layer_EndInstance();
Shape_AddLayer( layer );
no_diffuse:
{}
}
#endif
//
// specular layer
//
#if 1
{
hobj_t *lightdef;
vec2d_t shift;
int width;
int height;
int projection;
fp_t patchsize;
ic_subimage_t *sub;
unitex_t *uni;
layer_t *layer;
lightmap_t *lightmap_head;
lightdef = FindClassType( shape, "proj_lightdef" );
if ( !lightdef )
{
// __error( "missing class 'proj_lightdef' in shape '%s'\n", shape->name );
goto no_lightdef;
}
EasyFindVec2d( shift, lightdef, "shift" );
EasyFindInt( &width, lightdef, "width" );
EasyFindInt( &height, lightdef, "height" );
EasyFindFloat( &patchsize, lightdef, "patchsize" );
EasyFindInt( &projection, lightdef, "projection" );
lightmap_head = LinkLightmaps( a_map->lightmap_db, StringToUnique( shape->name ), 1 );
if ( !lightmap_head )
goto no_specular;
// setup specular lightmap
{
int lightmap_bytes;
void *lightmap_pixels;
// check database for specular lightmaps
if ( !lightmap_head )
goto no_specular;
lightmap_bytes = width*height*4;
lightmap_pixels = NEWBYTES( lightmap_bytes );
sub = IC_NewSubImage( width, height );
IC_SubImageSetPixels( sub, lightmap_pixels );
}
uni = UniTex_NewFrom_subimage( sub );
// create specular layer
Layer_BeginInstance( (layerMode)(LayerMode_projection | LayerMode_Texel0N) );
{
// hack: build layer_gl_state_t
layer_gl_state_t *glstate;
glstate = NEWTYPE( layer_gl_state_t );
glstate->sfactor = GL_ONE;
glstate->dfactor = GL_ONE;
Layer_SetGLstate( glstate );
}
Layer_SetOrdinal( LAYER_SPECULAR_1 );
Layer_SetUniTex( uni );
Layer_SetLightmapHead( lightmap_head );
if ( (projection&3) == ProjectionType_X )
{
Layer_SetProjection( LayerProjection_x );
}
else if ( (projection&3) == ProjectionType_Y )
{
Layer_SetProjection( LayerProjection_y );
}
else if ( (projection&3) == ProjectionType_Z )
{
Layer_SetProjection( LayerProjection_z );
}
else
{
__error( "can't get projection plane\n" );
}
{
shift[0] = -shift[0];
shift[1] = -shift[1];
Layer_AddShift( shift );
}
{
vec2d_t scale;
scale[0] = 1.0 / patchsize;
scale[1] = 1.0 / patchsize;
Layer_AddScale( scale );
}
layer = Layer_EndInstance();
Shape_AddLayer( layer );
no_specular:
{}
}
#endif
no_lightdef:
shp = Shape_EndInstance();
//
// gl state post-setup
//
//
// depth mask
//
{
u_list_iter_t iter;
layer_t *layer;
U_ListIterInit( &iter, shp->layer_list );
for ( ; ( layer = (layer_t *)U_ListIterNext( &iter ) ) ; )
{
layer->glstate->flags = multi_flags;
}
}
return shp;
}
int java_init(euca_opts * args, java_home_t * data)
{
jint(*hotspot_main) (JavaVM **, JNIEnv **, JavaVMInitArgs *);
char *libjvm_path = NULL;
if ((libjvm_path = java_library(args, data)) == NULL)
__fail("Cannot locate JVM library file");
dso_handle libjvm_handle = NULL;
__die((libjvm_handle = dlopen(libjvm_path, RTLD_GLOBAL | RTLD_NOW))
== NULL, "Cannot dynamically link to %s\n%s", libjvm_path, dso_error());
__debug("JVM library %s loaded", libjvm_path);
if ((hotspot_main = dlsym(libjvm_handle, "JNI_CreateJavaVM")) == NULL)
__fail("Cannot find JVM library entry point");
JavaVMInitArgs arg;
arg.ignoreUnrecognized = 0;
#if defined(JNI_VERSION_1_4)
arg.version = JNI_VERSION_1_4;
#else
arg.version = JNI_VERSION_1_2;
#endif
JavaVMOption *opt = NULL;
char *java_class_path = java_library_path(args);
__debug("Using classpath:\n%s", java_class_path);
#define JVM_MAX_OPTS 128
int x = -1, i = 0, encoding_not_defined_flag = 1;
opt = (JavaVMOption *) malloc(JVM_MAX_OPTS * sizeof(JavaVMOption));
for (i = 0; i < JVM_MAX_OPTS; i++)
opt[i].extraInfo = NULL;
i = -1;
while (jvm_default_opts[++i] != NULL)
JVM_ARG(opt[++x], jvm_default_opts[i], GETARG(args, home));
// setting heap size to half of total memory if it was not set by user
char *s, str[16], size_i;
long size;
str[0] = 0;
for (i = 0; i < args->jvm_args_given; i++) {
if ((s = strstr(args->jvm_args_arg[i], "mx"))
&& sscanf(s, "mx%s", str) == 1) {
break;
}
}
if (str[0] != 0) {
sscanf (str,"%ld%c", &size, &size_i);
switch(size_i) {
case 'k' :
case 'K' :
size = size * 1024L;
break;
case 'm' :
case 'M' :
size = size * 1024L * 1024L;
break;
case 'g' :
case 'G' :
size = size * GIG;
break;
default:
size = size * 1L;
}
__debug("User defined heap size is %ld bytes", size);
if (size < GIG) {
__error("User defined heap size of %ld bytes is set too low and system might now work properly", size);
}
} else {
size_t total_memory = getMemoryTotalSize();
double heap_size_gb = 2;
if (total_memory <= 32 * GIG && total_memory >= 4 * GIG)
heap_size_gb = ceil(total_memory/GIG/2.0);
else if (total_memory > 32 * GIG)
heap_size_gb = 16.0;
__info("User did not set heap size. Setting it automatically to %.0lfGB base on total memory of %zu bytes", heap_size_gb, total_memory);
JVM_ARG(opt[++x], "-Xms%.0lfg", heap_size_gb);
JVM_ARG(opt[++x], "-Xmx%.0lfg", heap_size_gb);
}
if (args->exhaustive_flag) {
JVM_ARG(opt[++x], "-Deuca.log.exhaustive=TRACE");
JVM_ARG(opt[++x], "-Deuca.log.exhaustive.db=TRACE");
JVM_ARG(opt[++x], "-Deuca.log.exhaustive.user=TRACE");
JVM_ARG(opt[++x], "-Deuca.log.exhaustive.cc=TRACE");
JVM_ARG(opt[++x], "-Deuca.log.exhaustive.external=TRACE");
} else {
int exhaust = 0;
if (args->exhaustive_db_flag) {
JVM_ARG(opt[++x], "-Deuca.log.exhaustive.db=TRACE");
exhaust++;
} else {
JVM_ARG(opt[++x], "-Deuca.log.exhaustive.db=FATAL");
}
if (args->exhaustive_cc_flag) {
JVM_ARG(opt[++x], "-Deuca.log.exhaustive.cc=TRACE");
exhaust++;
} else {
JVM_ARG(opt[++x], "-Deuca.log.exhaustive.cc=FATAL");
}
if (args->exhaustive_user_flag) {
JVM_ARG(opt[++x], "-Deuca.log.exhaustive.user=TRACE");
exhaust++;
} else {
JVM_ARG(opt[++x], "-Deuca.log.exhaustive.user=FATAL");
}
if (args->exhaustive_external_flag) {
JVM_ARG(opt[++x], "-Deuca.log.exhaustive.external=TRACE");
exhaust++;
} else {
JVM_ARG(opt[++x], "-Deuca.log.exhaustive.external=FATAL");
}
if (exhaust) {
JVM_ARG(opt[++x], "-Deuca.log.exhaustive=TRACE");
} else {
JVM_ARG(opt[++x], "-Deuca.log.exhaustive=FATAL");
}
}
JVM_ARG(opt[++x], "-Deuca.version=%1$s", ARGUMENTS_VERSION);
JVM_ARG(opt[++x], "-Deuca.log.level=%1$s", GETARG(args, log_level));
JVM_ARG(opt[++x], "-Deuca.log.appender=%1$s", GETARG(args, log_appender));
if (strlen(GETARG(args, extra_version)) > 1 && strncmp(GETARG(args, extra_version), "@", 1)) {
JVM_ARG(opt[++x], "-Deuca.extra_version=%1$s", GETARG(args, extra_version));
}
if (args->initialize_flag) {
JVM_ARG(opt[++x], "-Deuca.initialize=true");
JVM_ARG(opt[++x], "-Deuca.remote.dns=true");
} else if (args->upgrade_flag) {
JVM_ARG(opt[++x], "-Deuca.upgrade=true");
if (args->upgrade_force_flag) {
JVM_ARG(opt[++x], "-Deuca.upgrade.force=true");
}
JVM_ARG(opt[++x], "-Deuca.upgrade.old.dir=%1$s", GETARG(args, upgrade_old_dir));
JVM_ARG(opt[++x], "-Deuca.upgrade.old.version=%1$s", GETARG(args, upgrade_old_version));
} else {
if (args->remote_dns_flag) {
JVM_ARG(opt[++x], "-Deuca.remote.dns=true");
}
if (args->disable_iscsi_flag) {
JVM_ARG(opt[++x], "-Deuca.disable.iscsi=true");
}
}
if (args->force_remote_bootstrap_flag || args->disable_cloud_flag) {
JVM_ARG(opt[++x], "-Deuca.force.remote.bootstrap=true");
}
if (args->debug_noha_flag) {
JVM_ARG(opt[++x], "-Deuca.noha.cloud");
}
if (args->db_home_given) {
JVM_ARG(opt[++x], "-Deuca.db.home=%s", GETARG(args, db_home));
}
JVM_ARG(opt[++x], "-XX:+HeapDumpOnOutOfMemoryError");
JVM_ARG(opt[++x], "-XX:HeapDumpPath=%s/var/log/eucalyptus/", GETARG(args, home));
if (args->debug_flag) {
JVM_ARG(opt[++x], "-agentlib:jdwp=transport=dt_socket,server=y,suspend=%2$s,address=%1$d",
GETARG(args, debug_port),
(args->debug_suspend_flag ? "y" : "n"));
}
if (args->jmx_flag) {
JVM_ARG(opt[++x], "-Dcom.sun.management.jmxremote"); //TODO:GRZE:wrapup jmx stuff here.
JVM_ARG(opt[++x], "-Dcom.sun.management.jmxremote.port=8772");
JVM_ARG(opt[++x], "-Dcom.sun.management.jmxremote.authenticate=false"); //TODO:GRZE:RELEASE FIXME to use ssl
JVM_ARG(opt[++x], "-Dcom.sun.management.jmxremote.ssl=false");
}
if (args->verbose_flag) {
JVM_ARG(opt[++x], "-verbose:gc");
JVM_ARG(opt[++x], "-XX:+PrintGCTimeStamps");
JVM_ARG(opt[++x], "-XX:+PrintGCDetails");
}
if (args->profile_flag && args->agentlib_given) {
JVM_ARG(opt[++x], "-agentlib:%s", GETARG(args, agentlib));
} else if (args->profile_flag) {
JVM_ARG(opt[++x], "-agentlib:jprofilerti=port=8849");
JVM_ARG(opt[++x], "-Xbootclasspath/a:%1$s/bin/agent.jar", GETARG(args, profiler_home));
}
if (args->user_given) {
JVM_ARG(opt[++x], "-Deuca.user=%s", GETARG(args, user));
}
for (i = 0; i < args->jvm_args_given; i++)
JVM_ARG(opt[++x], "-X%s", args->jvm_args_arg[i]);
for (i = 0; i < args->define_given; i++) {
JVM_ARG(opt[++x], "-D%s", args->define_arg[i]);
if (strncmp(args->define_arg[i], "file.encoding", 13) == 0)
encoding_not_defined_flag = 0;
}
for (i = 0; i < args->bootstrap_host_given; i++)
JVM_ARG(opt[++x], "-Deuca.bootstrap.host.%d=%s", i, args->bootstrap_host_arg[i]);
for (i = 0; i < args->bind_addr_given; i++)
JVM_ARG(opt[++x], "-Deuca.bind.addr.%d=%s", i, args->bind_addr_arg[i]);
if (args->mcast_addr_given) {
JVM_ARG(opt[++x], "-Deuca.mcast.addr=%s", GETARG(args, mcast_addr));
}
if (encoding_not_defined_flag)
JVM_ARG(opt[++x], "-Dfile.encoding=UTF-8");
opt[++x].optionString = java_class_path;
opt[x].extraInfo = NULL;
opt[++x].optionString = "abort";
opt[x].extraInfo = java_fail;
arg.nOptions = x + 1;
arg.options = opt;
if (debug) {
__debug("+-------------------------------------------------------");
if (strlen(GETARG(args, extra_version)) > 1 && strncmp(GETARG(args, extra_version), "@", 1))
__debug("| Eucalyptus version: %s-%s", ARGUMENTS_VERSION, GETARG(args, extra_version));
else
__debug("| Eucalyptus version: %s", ARGUMENTS_VERSION);
__debug("| JNI version: %x", arg.version);
__debug("| Ignore Unrecognized Arguments: %d", arg.ignoreUnrecognized);
__debug("| Extra options: %d", arg.nOptions);
for (x = 0; x < arg.nOptions; x++)
__debug("| \"%-80.80s\" (0x%p)", opt[x].optionString, opt[x].extraInfo);
__debug("+-------------------------------------------------------");
}
__debug("Starting JVM.");
jint ret = 0;
while ((ret = (*hotspot_main) (&jvm, &env, &arg) == EUCA_RET_RELOAD)) ;
__die(ret < 0, "Failed to create JVM");
java_load_bootstrapper();
dlclose(libjvm_handle);
return 1;
}
/*
==============================
R_SetupCFaceShape
==============================
*/
shape_t * R_SetupCFaceShape( hobj_t *shape, g_map_t *map )
{
#if 1
hobj_t *plane;
hobj_t *cface;
vec3d_t norm;
fp_t dist;
int pointnum;
int i;
shape_t *shp;
cface = FindClassType( shape, "cface" );
if ( !cface )
__error( "missing class 'cface' in shape '%s'\n", shape->name );
// get control pointnum
EasyFindInt( &pointnum, cface, "pointnum" );
if ( pointnum < 6 )
{
printf( " shape '%s' is degenerated\n", shape->name );
return NULL;
}
Shape_BeginInstance();
Shape_SetPrimaryKey( StringToUnique( shape->name ) );
Shape_SetTesselation( ShapeTesselation_curved_face );
// get plane
plane = EasyLookupClsref( cface, "plane", map->planehm );
EasyFindVec3d( norm, plane, "norm" );
EasyFindFloat( &dist, plane, "dist" );
Shape_SetPlaneHint( norm, dist );
// set control points
Shape_SetCtrlPointNum( pointnum, 1 );
for ( i = 0; i < pointnum; i++ )
{
vec3d_t v;
char str[256];
sprintf( str, "u%d_v0", i );
EasyFindVec3d( v, cface, str );
Shape_AddCtrlPoint( Shape_NewCtrlPointUV3fv( i, 0, v ) );
}
//
// texture layer
//
if ( 1 )
{
// texture proj_texdef0
hobj_t *texdef0;
hpair_t *pair;
fp_t rotate;
vec2d_t shift;
vec2d_t scale;
int projection;
g_resource_t *gltex_res;
char str[256];
layer_t *layer;
unitex_t *uni;
tf2d_stack_t *tf2d_stack;
texdef0 = FindClassType( shape, "proj_texdef0" );
if ( !texdef0 )
__error( "missing class 'proj_texdef0' in shape '%s'\n", shape->name );
EasyFindVec2d( shift, texdef0, "shift" );
EasyFindVec2d( scale, texdef0, "scale" );
EasyFindFloat( &rotate, texdef0, "rotate" );
// EasyFindInt( &projection, texdef_real, "flags" );
projection = ProjectionTypeFromNorm( norm );
pair = FindHPair( texdef0, "ident" );
if ( !pair )
__error( "missing key 'ident' in texdef class '%s'\n", texdef0->name );
// build gltex resource name from ident
sprintf( str, "gltex.%s", pair->value );
strcrpl( str, '/', '.' );
gltex_res = G_ResourceSearch( g_rs, str );
uni = UniTex_NewFrom_gltexres( gltex_res );
Layer_BeginInstance( (layerMode)(LayerMode_projection | LayerMode_Texel0N) );
{
// hack: build layer_gl_state_t
layer_gl_state_t *glstate;
glstate = NEWTYPE( layer_gl_state_t );
glstate->flags |= LAYER_STATE_FLAGS_DEPTH_MASK;
glstate->sfactor = GL_ONE;
glstate->dfactor = GL_ZERO;
Layer_SetGLstate( glstate );
}
Layer_SetOrdinal( LAYER_TEXTURE_1 );
Layer_SetUniTex( uni );
if ( (projection&3) == ProjectionType_X )
{
Layer_SetProjection( LayerProjection_x );
}
else if ( (projection&3) == ProjectionType_Y )
{
Layer_SetProjection( LayerProjection_y );
}
else if ( (projection&3) == ProjectionType_Z )
{
Layer_SetProjection( LayerProjection_z );
}
else
{
__error( "can't get projection plane\n" );
}
//
// setup layer's transformation stack
//
tf2d_stack = NEWTYPE( tf2d_stack_t );
TF2D_InitStack( tf2d_stack );
Layer_SetTF2DStack( tf2d_stack );
{
tf2d_t *tf2d;
tf2d_matrix_t *tf2d_matrix;
tf2d = TF2D_CreateMatrix();
tf2d_matrix = TF2D_IsMatrix( tf2d );
TF2D_SetupMatrixByAngle( tf2d_matrix, -rotate );
TF2D_StackPush( tf2d_stack, tf2d );
}
{
tf2d_t *tf2d;
tf2d_scale_t *tf2d_scale;
scale[0] = 1.0/scale[0];
scale[1] = 1.0/scale[1];
tf2d = TF2D_CreateScale();
tf2d_scale = TF2D_IsScale( tf2d );
Vec2dCopy( tf2d_scale->scale, scale );
TF2D_StackPush( tf2d_stack, tf2d );
}
{
tf2d_t *tf2d;
tf2d_shift_t *tf2d_shift;
shift[0] = -shift[0];
shift[1] = -shift[1];
tf2d = TF2D_CreateShift();
tf2d_shift = TF2D_IsShift( tf2d );
Vec2dCopy( tf2d_shift->shift, shift );
TF2D_StackPush( tf2d_stack, tf2d );
}
layer = Layer_EndInstance();
Shape_AddLayer( layer );
}
//
// diffuse layer
//
#if 1
{
hobj_t *lightdef;
vec2d_t shift;
int width;
int height;
int projection;
fp_t patchsize;
ic_subimage_t *sub;
unitex_t *uni;
layer_t *layer;
lightmap_t *lightmap_head;
lightdef = FindClassType( shape, "proj_lightdef" );
if ( !lightdef )
{
// __error( "missing class 'proj_lightdef' in shape '%s'\n", shape->name );
goto no_lightdef;
}
EasyFindVec2d( shift, lightdef, "shift" );
EasyFindInt( &width, lightdef, "width" );
EasyFindInt( &height, lightdef, "height" );
EasyFindFloat( &patchsize, lightdef, "patchsize" );
EasyFindInt( &projection, lightdef, "projection" );
lightmap_head = LinkLightmaps( a_map->lightmap_db, StringToUnique( shape->name ), 0 );
if ( !lightmap_head && 0 )
goto no_diffuse;
// setup diffuse lightmap
{
int lightmap_bytes;
void *lightmap_pixels;
lightmap_bytes = width*height*4;
lightmap_pixels = NEWBYTES( lightmap_bytes );
sub = IC_NewSubImage( width, height );
IC_SubImageSetPixels( sub, lightmap_pixels );
}
uni = UniTex_NewFrom_subimage( sub );
// create diffuse layer
Layer_BeginInstance( (layerMode)(LayerMode_projection | LayerMode_Texel0N) );
{
// hack: build layer_gl_state_t
layer_gl_state_t *glstate;
glstate = NEWTYPE( layer_gl_state_t );
glstate->flags |= LAYER_STATE_FLAGS_DEPTH_MASK;
glstate->sfactor = GL_ZERO;
glstate->dfactor = GL_SRC_COLOR;
Layer_SetGLstate( glstate );
}
Layer_SetOrdinal( LAYER_DIFFUSE_1 );
Layer_SetUniTex( uni );
Layer_SetLightmapHead( lightmap_head );
if ( (projection&3) == ProjectionType_X )
{
Layer_SetProjection( LayerProjection_x );
}
else if ( (projection&3) == ProjectionType_Y )
{
Layer_SetProjection( LayerProjection_y );
}
else if ( (projection&3) == ProjectionType_Z )
{
Layer_SetProjection( LayerProjection_z );
}
else
{
__error( "can't get projection plane\n" );
}
{
shift[0] = -shift[0];
shift[1] = -shift[1];
Layer_AddShift( shift );
}
{
vec2d_t scale;
scale[0] = 1.0 / patchsize;
scale[1] = 1.0 / patchsize;
Layer_AddScale( scale );
}
layer = Layer_EndInstance();
Shape_AddLayer( layer );
no_diffuse:
{}
}
#endif
//
// specular layer
//
#if 0
{
hobj_t *lightdef;
hpair_t *pair;
vec2d_t shift;
int width;
int height;
int projection;
fp_t patchsize;
ic_subimage_t *sub;
unitex_t *uni;
layer_t *layer;
lightmap_t *lightmap_head;
lightdef = FindClassType( shape, "proj_lightdef" );
if ( !lightdef )
{
// __error( "missing class 'proj_lightdef' in shape '%s'\n", shape->name );
goto no_lightdef;
}
EasyFindVec2d( shift, lightdef, "shift" );
EasyFindInt( &width, lightdef, "width" );
EasyFindInt( &height, lightdef, "height" );
EasyFindFloat( &patchsize, lightdef, "patchsize" );
EasyFindInt( &projection, lightdef, "projection" );
lightmap_head = LinkLightmaps( a_map->lightmap_db, StringToUnique( shape->name ), 1 );
if ( !lightmap_head )
goto no_specular;
// setup specular lightmap
{
int lightmap_bytes;
void *lightmap_pixels;
lightmap_bytes = width*height*4;
lightmap_pixels = NEWBYTES( lightmap_bytes );
sub = IC_NewSubImage( width, height );
IC_SubImageSetPixels( sub, lightmap_pixels );
}
uni = UniTex_NewFrom_subimage( sub );
// create specular layer
Layer_BeginInstance( LayerMode_projection | LayerMode_Texel0N );
{
// hack: build layer_gl_state_t
layer_gl_state_t *glstate;
glstate = NEWTYPE( layer_gl_state_t );
glstate->flags |= LAYER_STATE_FLAGS_DEPTH_MASK;
glstate->sfactor = GL_ONE;
glstate->dfactor = GL_ONE;
Layer_SetGLstate( glstate );
}
Layer_SetOrdinal( LAYER_SPECULAR_1 );
Layer_SetUniTex( uni );
Layer_SetLightmapHead( lightmap_head );
if ( (projection&3) == ProjectionType_X )
{
Layer_SetProjection( LayerProjection_x );
}
else if ( (projection&3) == ProjectionType_Y )
{
Layer_SetProjection( LayerProjection_y );
}
else if ( (projection&3) == ProjectionType_Z )
{
Layer_SetProjection( LayerProjection_z );
}
else
{
__error( "can't get projection plane\n" );
}
{
shift[0] = -shift[0];
shift[1] = -shift[1];
Layer_AddShift( shift );
}
{
vec2d_t scale;
scale[0] = 1.0 / patchsize;
scale[1] = 1.0 / patchsize;
Layer_AddScale( scale );
}
layer = Layer_EndInstance();
Shape_AddLayer( layer );
no_specular:
}
#endif
no_lightdef:
shp = Shape_EndInstance();
return shp;
#else
return NULL;
#endif
}
/*
==============================
R_SetupCSurfMultiLayerFromClass
==============================
*/
void R_SetupCSurfLayer( hobj_t *texdef, hobj_t *layer )
{
int i;
vec2d_t vecs[4];
vec2d_t scale;
g_resource_t *gltex_res;
layer_t *l;
layer_gl_state_t *glstate;
unitex_t *uni;
hpair_t *pair;
color_rgba_t color;
EasyFindVec2d( vecs[0], texdef, "shift" );
EasyFindVec2d( vecs[1], texdef, "vec2" );
EasyFindVec2d( vecs[2], texdef, "vec0" );
EasyFindVec2d( vecs[3], texdef, "vec1" );
EasyFindVec2d( scale, texdef, "scale" );
for ( i = 1; i < 4; i++ )
{
vecs[i][0] *= scale[0];
vecs[i][1] *= scale[1];
}
Vec2dAdd( vecs[1], vecs[1], vecs[0] );
Vec2dAdd( vecs[2], vecs[2], vecs[0] );
Vec2dAdd( vecs[3], vecs[3], vecs[0] );
// get layer ambient color
color[0] = 255;
color[1] = 255;
color[2] = 255;
color[3] = 255;
pair = FindHPair( layer, "color" );
if ( pair )
{
int i;
vec3d_t v;
HPairCastToVec3d( v, pair );
for ( i = 0; i < 3; i++ )
{
if ( v[i] < 0.0 )
v[i] = 0.0;
if ( v[i] > 1.0 )
v[i] = 1.0;
color[i] = (unsigned char) (v[i]*255.0);
}
}
pair = FindHPair( layer, "alpha" );
if ( pair )
{
fp_t a;
HPairCastToFloat( &a, pair );
if ( a < 0.0 )
a = 0.0;
if ( a > 1.0 )
a = 1.0;
color[3] = (unsigned char) (a*255.0);
}
pair = FindHPair( layer, "gltex_res" );
if ( !pair )
__error( "missing key 'gltex_res'\n" );
gltex_res = G_ResourceSearch( g_rs, pair->value );
if ( !gltex_res )
__error( "can't find gltex resource '%s'\n", pair->value );
uni = UniTex_NewFrom_gltexres( gltex_res );
// layer gl state
glstate = NEWTYPE( layer_gl_state_t );
//
// blend sfactor
//
pair = FindHPair( layer, "sfactor" );
if ( !pair )
__error( "missing key 'sfactor'\n" );
if ( !strcmp( pair->value, "GL_ONE" ) )
{
glstate->sfactor = GL_ONE;
}
else if ( !strcmp( pair->value, "GL_ZERO" ) )
{
glstate->sfactor = GL_ZERO;
}
else if ( !strcmp( pair->value, "GL_SRC_COLOR" ) )
{
glstate->sfactor = GL_SRC_COLOR;
}
else if ( !strcmp( pair->value, "GL_SRC_ALPHA" ) )
{
glstate->sfactor = GL_SRC_ALPHA;
}
else
{
__error( "unknown sfactor '%s'\n", pair->value );
}
//
// blend dfactor
//
pair = FindHPair( layer, "dfactor" );
if ( !pair )
__error( "missing key 'dfactor'\n" );
if ( !strcmp( pair->value, "GL_ONE" ) )
{
glstate->dfactor = GL_ONE;
}
else if ( !strcmp( pair->value, "GL_ZERO" ) )
{
glstate->dfactor = GL_ZERO;
}
else if ( !strcmp( pair->value, "GL_ONE_MINUS_SRC_ALPHA" ) )
{
glstate->dfactor = GL_ONE_MINUS_SRC_ALPHA;
}
else
{
__error( "unknown dfactor '%s'\n", pair->value );
}
Layer_BeginInstance( (layerMode)(LayerMode_uv | LayerMode_Texel0N) );
Layer_SetGLstate( glstate );
Layer_SetOrdinal( atoi( layer->name ) );
Layer_SetUniTex( uni );
Layer_SetUVCtrl( vecs );
Layer_SetAmbientColor( color );
l = Layer_EndInstance();
Shape_AddLayer( l );
}
void R_BE_ProcessCMDBuffer( void )
{
int i, j;
int num;
int cmd, *ptr, *end;
vec4d_t *va;
static int glflush_hack = 0;
#if 0
if ( be_va_locked == false )
{
__warning( "vertex array not locked\n" );
return;
}
if ( !be_cmds )
{
__warning( "null command buffer\n" );
return;
}
if ( be_cmdnum == 0 )
{
__warning( "empty command buffer\n" );
return;
}
if ( !be_vrefs )
{
__warning( "null vertex reference buffer\n" );
return;
}
if ( be_vrefnum == 0 )
{
__warning( "empty vertex reference buffer\n" );
return;
}
if ( be_colors && ( be_colornum != be_vrefnum ) )
{
__warning( "colornum != vrefnum\n" );
return;
}
if ( be_texcoords && ( be_texcoordnum != be_vrefnum ) )
{
__warning( "texcoordnum != vrefnum\n" );
return;
}
// if ( be_vertexnum > 0 )
{
glVertexPointer( 4, GL_FLOAT, 0, be_va );
// glEnableClientState( GL_VERTEX_ARRAY );
}
// else
// {
// return;
// }
if ( be_colors )
{
glColorPointer( 3, GL_FLOAT, 0, be_colors );
// glEnableClientState( GL_COLOR_ARRAY );
}
if ( be_texcoords )
{
glTexCoordPointer( 2, GL_FLOAT, 0, be_texcoords );
// glEnableClientState( GL_TEXTURE_COORD_ARRAY );
}
#endif
va = &be_va[be_vofs];
i = 0;
ptr = be_cmds;
end = &be_cmds[be_cmdnum];
for(;;)
{
if ( ptr >= end )
__error( "reached command buffer end\n" );
cmd = *ptr++;
#if 1
if ( cmd != BE_CMD_END )
{
num = *ptr++;
if ( glcmd_lut[cmd] == GL_TRIANGLE_FAN )
{
COUNT_ADD( count_be_num_tri, num-2 );
}
else if ( glcmd_lut[cmd] == GL_TRIANGLE_STRIP )
{
COUNT_ADD( count_be_num_tri, num-2 );
}
else if ( glcmd_lut[cmd] == GL_TRIANGLES )
{
COUNT_ADD( count_be_num_tri, num/3 );
}
else if ( glcmd_lut[cmd] == GL_POLYGON )
{
COUNT_ADD( count_be_num_tri, num-2 );
}
glBegin( glcmd_lut[cmd] );
COUNT_INCR( count_be_num_begin );
for ( j = 0; j < num; j++, i++ )
{
if ( be_colors )
glColor3fv( be_colors[i] );
if ( be_texcoords )
glTexCoord2fv( be_texcoords[i] );
glVertex4fv( va[be_vrefs[i]] );
// glArrayElement( i+be_vofs );
}
glEnd();
if ( glflush_hack >= r_glinfo->flushinterval )
{
// printf( "%d\n", r_glinfo->flushinterval );
glFlush();
COUNT_INCR( count_be_num_flush );
glflush_hack = 0;
}
else
glflush_hack++;
}
else
{
break;
}
#else
#endif
}
#if 0
if ( glflush_hack >= r_glinfo->flushinterval )
{
glFlush();
glflush_hack = 0;
}
else
glflush_hack++;
#endif
// glDisableClientState( GL_VERTEX_ARRAY );
// glDisableClientState( GL_COLOR_ARRAY );
// glDisableClientState( GL_TEXTURE_COORD_ARRAY );
}
void cthread_set_errno_self(int err)
{
int* ep = __error();
*ep = err;
}
int cthread_errno(void) {
return *__error();
}
int main(int argc, char *argv[]) {
euca_opts euca_args;
euca_opts *args = &euca_args;
java_home_t *data = NULL;
int status = 0;
pid_t pid = 0;
uid_t uid = 0;
gid_t gid = 0;
int i;
if (arguments(argc, argv, args) != 0)
exit(1);
debug = args->debug_flag;
set_output(GETARG(args, out), GETARG(args, err));
if (args->kill_flag == 1)
return stop_child(args);
if (checkuser(GETARG(args, user), &uid, &gid) == 0)
return 1;
for (i = 0; i < args->java_home_given; ++i) {
__debug("Trying user supplied java home: %s", args->java_home_arg[i]);
data = get_java_home(args->java_home_arg[i]);
if (data != NULL) {
break;
}
}
char* java_home_env = getenv("JAVA_HOME");
if (data == NULL && java_home_env != NULL) {
__debug("Trying environment JAVA_HOME: %s", java_home_env);
data = get_java_home(java_home_env);
}
if (data == NULL && !args->java_home_given &&
args->java_home_arg[0] != NULL && CHECK_ISDIR(args->java_home_arg[0])) {
__debug("Trying built-in java home: %s", args->java_home_arg[0]);
data = get_java_home(args->java_home_arg[0]);
}
if (data == NULL && CHECK_ISREG("/usr/bin/java")) {
char * javapath = (char *) calloc(PATH_MAX, sizeof(char));
javapath = realpath("/usr/bin/java", javapath);
if (javapath != NULL) {
javapath[strlen(javapath)-strlen("jre/bin/java")] = '\0';
__debug("Trying system java home: %s", javapath);
data = get_java_home(javapath);
}
}
if (data == NULL) {
__error("Cannot locate Java Home");
return 1;
}
int x;
if (debug == 1) {
__debug("+-- DUMPING JAVA HOME STRUCTURE ------------------------");
__debug("| Java Home: \"%s\"", PRINT_NULL(data->path));
__debug("| Found JVMs: %d", data->jnum);
for (x = 0; x < data->jnum; x++) {
jvm_info_t *jvm = data->jvms[x];
__debug("| JVM Name: \"%s\"", PRINT_NULL(jvm->name));
__debug("| \"%s\"", PRINT_NULL(jvm->libjvm_path));
}
__debug("+-------------------------------------------------------");
}
if (strcmp(argv[0], "eucalyptus-cloud") != 0) {
char *oldpath = getenv("LD_LIBRARY_PATH"), *libf = java_library(args,
data);
char *old = argv[0], buf[32768], *tmp = NULL, *p1 = NULL, *p2 = NULL;
p1 = strdup(libf);
tmp = strrchr(p1, '/');
if (tmp != NULL)
tmp[0] = '\0';
p2 = strdup(p1);
tmp = strrchr(p2, '/');
if (tmp != NULL)
tmp[0] = '\0';
if (oldpath == NULL)
snprintf(buf, 32768, "%s:%s:%s/bin/linux-x64", p1, p2, GETARG(args,
profiler_home));
else
snprintf(buf, 32768, "%s:%s:%s:%s/bin/linux-x64", oldpath, p1, p2,
GETARG(args, profiler_home));
tmp = strdup(buf);
setenv("LD_LIBRARY_PATH", tmp, 1);
__debug("Invoking w/ LD_LIBRARY_PATH=%s", getenv("LD_LIBRARY_PATH"));
argv[0] = "eucalyptus-cloud";
execve(old, argv, environ);
__error("Cannot execute process");
return 1;
}
__debug("Running w/ LD_LIBRARY_PATH=%s", getenv("LD_LIBRARY_PATH"));
if (args->fork_flag) {
pid = fork();
__die((pid == -1), "Cannot detach from parent process");
if (pid != 0)
return wait_child(args, pid);
setsid();
}
while ((pid = fork()) != -1) {
if (pid == 0)
exit(child(args, data, uid, gid));
child_pid = pid;
signal(SIGHUP, controller);
signal(SIGTERM, controller);
signal(SIGINT, controller);
while (waitpid(-1, &status, 0) != pid)
;
if (WIFEXITED(status)) {
status = WEXITSTATUS(status);
__debug("Eucalyptus exited with status: %d", status);
unlink(GETARG(args, pidfile));
if (status == EUCA_RET_RELOAD) {
__debug("Reloading service.");
continue;
} else if (status == 0) {
__debug("Service shut down cleanly.");
return 0;
}
__error("Service exit with a return value of %d.", status);
return 1;
} else {
perror("Service did not exit cleanly.");
__error("Service did not exit cleanly: exit value=%d.", status);
return 1;
}
}
__error("Cannot decouple controller/child processes");
return 1;
}
void R_SetupSFaceLayer( hobj_t *texdef, hobj_t *layer )
{
// from texdef
vec2d_t shift;
vec2d_t scale;
fp_t rotate;
int projection;
g_resource_t *gltex_res;
unitex_t *uni;
tf2d_stack_t *tf2d_stack;
hpair_t *pair;
layer_gl_state_t *glstate;
layer_t *l;
hobj_search_iterator_t iter;
hobj_t *job;
// from layer
vec2d_t scale2; // additional scale
color_rgba_t color;
// get texdef transform
EasyFindVec2d( shift, texdef, "shift" );
EasyFindVec2d( scale, texdef, "scale" );
EasyFindFloat( &rotate, texdef, "rotate" );
EasyFindInt( &projection, texdef, "flags" );
// get layer transform
pair = FindHPair( layer, "scale" );
if ( pair )
{
HPairCastToVec2d( scale2, pair );
}
else
{
scale2[0] = 1.0;
scale2[1] = 1.0;
}
// get layer ambient color
color[0] = 255;
color[1] = 255;
color[2] = 255;
color[3] = 255;
pair = FindHPair( layer, "color" );
if ( pair )
{
int i;
vec3d_t v;
HPairCastToVec3d( v, pair );
for ( i = 0; i < 3; i++ )
{
if ( v[i] < 0.0 )
v[i] = 0.0;
if ( v[i] > 1.0 )
v[i] = 1.0;
color[i] = (unsigned char) (v[i]*255.0);
}
}
pair = FindHPair( layer, "alpha" );
if ( pair )
{
fp_t a;
HPairCastToFloat( &a, pair );
if ( a < 0.0 )
a = 0.0;
if ( a > 1.0 )
a = 1.0;
color[3] = (unsigned char) (a*255.0);
}
pair = FindHPair( layer, "gltex_res" );
if ( !pair )
__error( "missing key 'gltex_res'\n" );
gltex_res = G_ResourceSearch( g_rs, pair->value );
if ( !gltex_res )
__error( "can't find gltex resource '%s'\n", pair->value );
uni = UniTex_NewFrom_gltexres( gltex_res );
// layer gl state
glstate = NEWTYPE( layer_gl_state_t );
//
// blend sfactor
//
pair = FindHPair( layer, "sfactor" );
if ( !pair )
__error( "missing key 'sfactor'\n" );
if ( !strcmp( pair->value, "GL_ONE" ) )
{
glstate->sfactor = GL_ONE;
}
else if ( !strcmp( pair->value, "GL_ZERO" ) )
{
glstate->sfactor = GL_ZERO;
}
else if ( !strcmp( pair->value, "GL_SRC_COLOR" ) )
{
glstate->sfactor = GL_SRC_COLOR;
}
else if ( !strcmp( pair->value, "GL_SRC_ALPHA" ) )
{
glstate->sfactor = GL_SRC_ALPHA;
}
else
{
__error( "unknown sfactor '%s'\n", pair->value );
}
//
// blend dfactor
//
pair = FindHPair( layer, "dfactor" );
if ( !pair )
__error( "missing key 'dfactor'\n" );
if ( !strcmp( pair->value, "GL_ONE" ) )
{
glstate->dfactor = GL_ONE;
}
else if ( !strcmp( pair->value, "GL_ZERO" ) )
{
glstate->dfactor = GL_ZERO;
}
else if ( !strcmp( pair->value, "GL_ONE_MINUS_SRC_ALPHA" ) )
{
glstate->dfactor = GL_ONE_MINUS_SRC_ALPHA;
}
else
{
__error( "unknown dfactor '%s'\n", pair->value );
}
Layer_BeginInstance( (layerMode)(LayerMode_projection | LayerMode_Texel0N) );
Layer_SetGLstate( glstate );
Layer_SetOrdinal( atoi( layer->name ) );
Layer_SetUniTex( uni );
Layer_SetAmbientColor( color );
if ( (projection&3) == ProjectionType_X )
{
Layer_SetProjection( LayerProjection_x );
}
else if ( (projection&3) == ProjectionType_Y )
{
Layer_SetProjection( LayerProjection_y );
}
else if ( (projection&3) == ProjectionType_Z )
{
Layer_SetProjection( LayerProjection_z );
}
else
{
__error( "can't get projection plane\n" );
}
//
// setup layer's transformation stack
//
tf2d_stack = NEWTYPE( tf2d_stack_t );
TF2D_InitStack( tf2d_stack );
Layer_SetTF2DStack( tf2d_stack );
{
tf2d_t *tf2d;
tf2d_matrix_t *tf2d_matrix;
tf2d = TF2D_CreateMatrix();
tf2d_matrix = TF2D_IsMatrix( tf2d );
TF2D_SetupMatrixByAngle( tf2d_matrix, -rotate );
TF2D_StackPush( tf2d_stack, tf2d );
}
{
tf2d_t *tf2d;
tf2d_scale_t *tf2d_scale;
scale[0] *= scale2[0];
scale[1] *= scale2[1];
scale[0] = 1.0/scale[0];
scale[1] = 1.0/scale[1];
tf2d = TF2D_CreateScale();
tf2d_scale = TF2D_IsScale( tf2d );
Vec2dCopy( tf2d_scale->scale, scale );
TF2D_StackPush( tf2d_stack, tf2d );
}
{
tf2d_t *tf2d;
tf2d_shift_t *tf2d_shift;
shift[0] = -shift[0];
shift[1] = -shift[1];
tf2d = TF2D_CreateShift();
tf2d_shift = TF2D_IsShift( tf2d );
Vec2dCopy( tf2d_shift->shift, shift );
TF2D_StackPush( tf2d_stack, tf2d );
}
l = Layer_EndInstance();
Shape_AddLayer( l );
//
// Spawn ShapeCtrlJobs
//
InitClassSearchIterator( &iter, layer, "job" );
for ( ; ( job = SearchGetNextClass( &iter ) ) ; )
{
if ( !strcmp( job->name, "ModulateAlpha" ) )
{
R_RegisterShapeCtrlJob( ShapeCtrlJob_Create_ModulateAlpha( job, l ) );
}
else if ( !strcmp( job->name, "ModulateColor" ) )
{
R_RegisterShapeCtrlJob( ShapeCtrlJob_Create_ModulateColor( job, l ) );
}
else if ( !strcmp( job->name, "ShiftTexCoord" ) )
{
R_RegisterShapeCtrlJob( ShapeCtrlJob_Create_ShiftTexCoord( job, l ) );
}
else if ( !strcmp( job->name, "EnvMap" ) )
{
R_RegisterShapeCtrlJob( ShapeCtrlJob_Create_EnvMap( job, l ) );
}
else if ( !strcmp( job->name, "DetailMap" ) )
{
R_RegisterShapeCtrlJob( ShapeCtrlJob_Create_DetailMap( job, l ) );
}
else
{
__warning( "unknown ShapeCtrlJob '%s', ignore it\n", job->name );
}
}
}
void main( int argc, char* argv[] )
{
u_int32_t i, i2, arrcount;
int x, y, xs, ys, xh, yh;
char dumpheaders = 0;
char* tganame;
char* arrname;
char* palname;
char* arrident;
char* arrnext;
char* arrmode;
int reducemode;
int mm;
int ts, td;
int pixels;
int rsum, gsum, bsum;
int x2, y2;
int blur;
FILE* tgahandle;
FILE* arrhandle;
FILE* palhandle;
pal_t* pal = NULL;
tga_t* tga[2];
arr_t* arr;
rgb_t rgb;
dumpheaders = CheckCmdSwitch( "-d", argc, argv );
palname = GetCmdOpt( "-p", argc, argv );
tganame = GetCmdOpt( "-t", argc, argv );
if( tganame == NULL )
{
printf( "no tga given.\n" );
PrintUsage();
exit( 0 );
}
if ( CheckCmdSwitch( "--rgb565", argc, argv ) )
{
reducemode = ARR_F_RGB565;
}
else
{
reducemode = ARR_F_P8;
}
arrident = GetCmdOpt( "-i", argc, argv );
if( arrident == NULL )
__warning( "no arr ident given.\n" );
else if( strlen( arrident ) >= 32 )
arrident[31] = '\0';
printf( "tga: %s\n", tganame );
tgahandle = fopen( tganame, "rb" );
CHKPTR( tgahandle );
tga[0] = TGA_Read( tgahandle );
CHKPTR( tga[0] );
// TGA_Dump( tga[0] );
fclose( tgahandle );
if( dumpheaders )
TGA_Dump( tga[0] );
tga[1] = TGA_Create( tga[0]->image_width/*/2*/, tga[0]->image_height/*/2*/, TGA_TYPE_TRUECOLOR );
__chkptr( tga[1] );
arrname = GetCmdOpt( "-a", argc, argv );
if( arrname == NULL )
{
printf( "no arr given.\n" );
PrintUsage();
exit( 0 );
}
printf( "arr: %s\n", arrname );
switch( tga[0]->image_type )
{
case TGA_TYPE_TRUECOLOR:
printf( "tga is 24bit.\n" );
if( palname == NULL )
{
CDB_StartUp( 0 );
palname = CDB_GetString( "misc/default_pal" );
if( palname == NULL )
{
PrintUsage();
__error( "no pal found.\n" );
}
}
printf( "pal: %s\n", palname );
palhandle = fopen( palname, "rb" );
CHKPTR( palhandle );
pal = PAL_Read( palhandle );
CHKPTR( pal );
fclose( palhandle );
arr = ARR_Create( tga[0]->image_width, tga[0]->image_height, 4, 1, arrident, reducemode );
CHKPTR( arr );
printf( "reducing color. " );
xs = tga[0]->image_width;
ys = tga[0]->image_height;
arrcount = 0;
for ( mm = 0; mm < 4; mm++ ) {
ts = mm & 1;
td = (mm+1) & 1;
// printf("%d->%d\n",ts,td);
// reduce
// printf(" i: %d, x: %d, y: %d\n", mm, xs, ys );
pixels = xs * ys;
for( i = 0; i < pixels; i++ )
{
rgb.red = tga[ts]->image.red[i];
rgb.green = tga[ts]->image.green[i];
rgb.blue = tga[ts]->image.blue[i];
if ( reducemode == ARR_F_P8 )
arr->data[arrcount++] = PAL_ReduceColor( pal, &rgb );
else
{
*((unsigned short*)(&arr->data[arrcount])) = RGB888ToRGB565( &rgb );
arrcount+=2;
}
if( (i & 0xff) == 0 )
{
printf( "." );
fflush( stdout );
}
}
if ( mm == 3 )
break;
// mipmap
xh = xs / 2;
yh = ys / 2;
if ( xh < 4 || yh < 4 )
blur = 0;
else
blur = 1;
for ( y = 0; y < yh; y++ ) {
for ( x = 0; x < xh; x++ ) {
x2 = x*2;
y2 = y*2;
if ( blur )
{
rsum = tga[ts]->image.red[ y2*xs + x2 ];
gsum = tga[ts]->image.green[ y2*xs + x2 ];
bsum = tga[ts]->image.blue[ y2*xs + x2 ];
rsum += tga[ts]->image.red[ y2*xs + (x2+1) ];
gsum += tga[ts]->image.green[ y2*xs + (x2+1) ];
bsum += tga[ts]->image.blue[ y2*xs + (x2+1) ];
rsum += tga[ts]->image.red[ (y2+1)*xs + x2 ];
gsum += tga[ts]->image.green[ (y2+1)*xs + x2 ];
bsum += tga[ts]->image.blue[ (y2+1)*xs + x2 ];
rsum += tga[ts]->image.red[ (y2+1)*xs + (x2+1) ];
gsum += tga[ts]->image.green[ (y2+1)*xs + (x2+1) ];
bsum += tga[ts]->image.blue[ (y2+1)*xs + (x2+1) ];
tga[td]->image.red[ y*xh + x ] = rsum / 4;
tga[td]->image.green[ y*xh + x ] = gsum / 4;
tga[td]->image.blue[ y*xh + x ] = bsum / 4;
}
else
{
rsum = tga[ts]->image.red[ y2*xs + x2 ];
gsum = tga[ts]->image.green[ y2*xs + x2 ];
bsum = tga[ts]->image.blue[ y2*xs + x2 ];
tga[td]->image.red[ y*xh + x ] = 255; //rsum;
tga[td]->image.green[ y*xh + x ] = 0;//gsum;
tga[td]->image.blue[ y*xh + x ] = 0; //bsum;
}
}
}
xs = xh;
ys = yh;
}
printf( "\n" );
break;
/*
case TGA_TYPE_INDEXED:
printf( "tga is indexed./n" );
arr = ARR_Create( tga->image_width, tga->image_height, 1, arr_ident, NULL );
CHKPTR( arr );
printf( "copying ...\n" );
memcpy( arr->data, tga->image_indexed.data, tga->image_indexed.bytes );
break;
*/
default:
__error( "we need an uncompressed 24(/8)bit tga.\n" );
ARR_Free( arr );
break;
}
arrhandle = fopen( arrname, "wb" );
CHKPTR( arrhandle );
ARR_Write( arrhandle, arr );
fclose( arrhandle );
}
shape_t * R_SetupCSurfShape( hobj_t *shape, g_map_t *map )
{
#if 1
int i, u, v;
hobj_t *multilayer;
hobj_t *csurf;
hpair_t *pair;
shape_t *shp;
int upointnum;
int vpointnum;
multilayer = NULL;
csurf = FindClassType( shape, "csurf" );
if ( !csurf )
__error( "missing class 'csurf' in shape '%s'\n", shape->name );
// get control points
EasyFindInt( &upointnum, csurf, "upointnum" );
EasyFindInt( &vpointnum, csurf, "vpointnum" );
Shape_BeginInstance();
Shape_SetPrimaryKey( StringToUnique( shape->name ) );
Shape_SetTesselation( ShapeTesselation_curved_surface );
Shape_SetCtrlPointNum( upointnum, vpointnum );
for ( u = 0; u < upointnum; u++ )
{
for ( v = 0; v < vpointnum; v++ )
{
vec3d_t p;
char str[256];
sprintf( str, "u%d_v%d", u, v );
EasyFindVec3d( p, csurf, str );
Shape_AddCtrlPoint( Shape_NewCtrlPointUV3fv( u, v, p ) );
}
}
//
// texture layer
//
if ( 1 )
{
hobj_t *texdef0;
vec2d_t vecs[4];
vec2d_t scale;
g_resource_t *gltex_res;
char str[256];
layer_t *layer;
unitex_t *uni;
texdef0 = FindClassType( shape, "uv_texdef0" );
if ( !texdef0 )
__error( "missing class 'uv_texdef0' in shape '%s'\n", shape->name );
EasyFindVec2d( vecs[0], texdef0, "shift" );
EasyFindVec2d( vecs[1], texdef0, "vec2" );
EasyFindVec2d( vecs[2], texdef0, "vec0" );
EasyFindVec2d( vecs[3], texdef0, "vec1" );
EasyFindVec2d( scale, texdef0, "scale" );
for ( i = 1; i < 4; i++ )
{
vecs[i][0] *= scale[0];
vecs[i][1] *= scale[1];
}
Vec2dAdd( vecs[1], vecs[1], vecs[0] );
Vec2dAdd( vecs[2], vecs[2], vecs[0] );
Vec2dAdd( vecs[3], vecs[3], vecs[0] );
pair = FindHPair( texdef0, "ident" );
if ( !pair )
__error( "missing key 'ident' in texdef class '%s'\n", texdef0->name );
//
// check ident for multilayer definition
//
{
multilayer = HManagerSearchClassName( map->multilayerhm, pair->value );
if ( multilayer )
{
__named_message( "MULTILAYER DEFINITON !\n" );
R_SetupCSurfMultiLayerFromClass( texdef0, multilayer );
goto skip_texture;
}
}
// build gltex resource name from ident
sprintf( str, "gltex.%s", pair->value );
strcrpl( str, '/', '.' );
gltex_res = G_ResourceSearch( g_rs, str );
uni = UniTex_NewFrom_gltexres( gltex_res );
Layer_BeginInstance( (layerMode)(LayerMode_uv | LayerMode_Texel0N) );
{
// hack: build layer_gl_state_t
layer_gl_state_t *glstate;
glstate = NEWTYPE( layer_gl_state_t );
glstate->flags |= LAYER_STATE_FLAGS_DEPTH_MASK;
glstate->sfactor = GL_ONE;
glstate->dfactor = GL_ZERO;
Layer_SetGLstate( glstate );
}
Layer_SetOrdinal( LAYER_TEXTURE_1 );
Layer_SetUniTex( uni );
Layer_SetUVCtrl( vecs );
layer = Layer_EndInstance();
Shape_AddLayer( layer );
}
skip_texture:
//
// diffuse layer
//
#if 1
{
hobj_t *lightdef;
int width;
int height;
ic_subimage_t *sub;
unitex_t *uni;
lightmap_t *lightmap_head;
layer_t *layer;
lightdef = FindClassType( shape, "uv_lightdef" );
if ( !lightdef )
{
goto no_lightdef;
}
EasyFindInt( &width, lightdef, "width" );
EasyFindInt( &height, lightdef, "height" );
lightmap_head = LinkLightmaps( a_map->lightmap_db, StringToUnique( shape->name ), 0 );
if ( !lightmap_head && 0 )
goto no_diffuse;
// setup diffuse lightmap
{
int lightmap_bytes;
void *lightmap_pixels;
lightmap_bytes = width*height*4;
lightmap_pixels = NEWBYTES( lightmap_bytes );
sub = IC_NewSubImage( width, height );
IC_SubImageSetPixels( sub, lightmap_pixels );
}
uni = UniTex_NewFrom_subimage( sub );
// create diffuse layer
Layer_BeginInstance( (layerMode)(LayerMode_uv | LayerMode_Texel01) );
{
// hack: build layer_gl_state_t
layer_gl_state_t *glstate;
glstate = NEWTYPE( layer_gl_state_t );
glstate->flags |= LAYER_STATE_FLAGS_DEPTH_MASK;
glstate->sfactor = GL_ZERO;
glstate->dfactor = GL_SRC_COLOR;
Layer_SetGLstate( glstate );
}
Layer_SetOrdinal( LAYER_DIFFUSE_1 );
Layer_SetUniTex( uni );
Layer_SetLightmapHead( lightmap_head );
{
int i;
vec2d_t vecs[4] = { {0,0},{1,0},{0,1},{1,1} };
// shrink and shift for lightmap boarders
for ( i = 0; i < 4; i++ )
{
vecs[i][0] *= (width*1.0)/(width+1.0);
vecs[i][1] *= (height*1.0)/(height+1.0);
vecs[i][0] += 0.5/(width*1.0);
vecs[i][1] += 0.5/(height*1.0);
}
Layer_SetUVCtrl( vecs );
}
layer = Layer_EndInstance();
Shape_AddLayer( layer );
no_diffuse:
{}
}
#endif
//
// specular layer
//
#if 1
{
hobj_t *lightdef;
int width;
int height;
ic_subimage_t *sub;
unitex_t *uni;
layer_t *layer;
lightmap_t *lightmap_head;
lightdef = FindClassType( shape, "uv_lightdef" );
if ( !lightdef )
{
goto no_lightdef;
}
EasyFindInt( &width, lightdef, "width" );
EasyFindInt( &height, lightdef, "height" );
lightmap_head = LinkLightmaps( a_map->lightmap_db, StringToUnique( shape->name ), 1 );
if ( !lightmap_head )
goto no_specular;
// setup specular lightmap
{
int lightmap_bytes;
void *lightmap_pixels;
lightmap_bytes = width*height*4;
lightmap_pixels = NEWBYTES( lightmap_bytes );
sub = IC_NewSubImage( width, height );
IC_SubImageSetPixels( sub, lightmap_pixels );
}
uni = UniTex_NewFrom_subimage( sub );
// create specular layer
Layer_BeginInstance( (layerMode)(LayerMode_uv | LayerMode_Texel01) );
{
// hack: build layer_gl_state_t
layer_gl_state_t *glstate;
glstate = NEWTYPE( layer_gl_state_t );
glstate->flags |= LAYER_STATE_FLAGS_DEPTH_MASK;
glstate->sfactor = GL_ONE;
glstate->dfactor = GL_ONE;
Layer_SetGLstate( glstate );
}
Layer_SetOrdinal( LAYER_SPECULAR_1 );
Layer_SetUniTex( uni );
Layer_SetLightmapHead( lightmap_head );
{
int i;
vec2d_t vecs[4] = { {0,0},{1,0},{0,1},{1,1} };
// shrink and shift for lightmap boarders
for ( i = 0; i < 4; i++ )
{
vecs[i][0] *= (width*1.0)/(width+1.0);
vecs[i][1] *= (height*1.0)/(height+1.0);
vecs[i][0] += 0.5/(width*1.0);
vecs[i][1] += 0.5/(height*1.0);
}
Layer_SetUVCtrl( vecs );
}
layer = Layer_EndInstance();
Shape_AddLayer( layer );
no_specular:
{}
}
#endif
no_lightdef:
shp = Shape_EndInstance();
if ( multilayer )
{
hobj_t *mesh_obj;
hobj_search_iterator_t iter;
hobj_t *job;
int multi_flags;
mesh_obj = FindClassType( multilayer, "mesh" );
if ( mesh_obj )
{
InitClassSearchIterator( &iter, mesh_obj, "job" );
for ( ; ( job = SearchGetNextClass( &iter ) ) ; )
{
if ( !strcmp( job->name, "SurfaceDeform" ) )
{
R_RegisterShapeCtrlJob( ShapeCtrlJob_Create_SurfaceDeform( job, shp ) );
}
else
{
__warning( "unknown ShapeCtrlJob '%s', ignore it\n", job->name );
}
}
}
multi_flags = LAYER_STATE_FLAGS_DEPTH_MASK;
pair = FindHPair( multilayer, "depthmask" );
if ( !pair )
{
// default is depthmask = true
multi_flags |= LAYER_STATE_FLAGS_DEPTH_MASK;
}
else
{
if ( !strcmp( pair->value, "0" ) )
{
multi_flags &= ~LAYER_STATE_FLAGS_DEPTH_MASK;
multi_flags |= LAYER_STATE_FLAGS_SHADE_P3;
}
else
{
multi_flags |= LAYER_STATE_FLAGS_DEPTH_MASK;
}
}
{
u_list_iter_t iter;
layer_t *layer;
U_ListIterInit( &iter, shp->layer_list );
for ( ; ( layer = (layer_t *)U_ListIterNext( &iter ) ) ; )
{
layer->glstate->flags = multi_flags;
}
}
}
return shp;
#else
return NULL;
#endif
}
static void hello(JNIEnv *env, jobject source) {
__error("uid=%d,euid=%d,gid=%d,egid=%d",getuid(),geteuid(),getgid(),getegid());
}
shape_t * R_SetupMeshTileShape( hobj_t *shape, g_map_t *map )
{
hobj_t *polygon;
hobj_t *plane;
hobj_t *glmesh_obj;
vec3d_t norm;
fp_t dist;
hobj_t *texdef0;
hobj_t *texdef_real;
vec2d_t shift;
vec2d_t scale;
fp_t rotate;
int projection;
hobj_t *texture;
hpair_t *pair;
char str[256];
g_resource_t *gltex_res;
unitex_t *uni;
tf2d_stack_t *tf2d_stack;
layer_t *layer;
shape_t *shp;
polygon = FindClassType( shape, "polygon" );
if ( !polygon )
__error( "missing class 'polygon' in shape '%s'\n", shape->name );
Shape_BeginInstance();
Shape_SetPrimaryKey( StringToUnique( shape->name ) );
Shape_SetTesselation( ShapeTesselation_glmesh );
// get plane
plane = EasyLookupClsref( polygon, "plane", map->planehm );
EasyFindVec3d( norm, plane, "norm" );
EasyFindFloat( &dist, plane, "dist" );
Shape_SetPlaneHint( norm, dist );
glmesh_obj = FindClassType( shape, "glmesh" );
if ( !glmesh_obj )
__error( "missing class 'glmesh' in shape '%s'\n", shape->name );
Shape_SetGLMesh( glmesh_obj, a_map->glmesh );
#if 0
meshtile = FindClassType( shape, "meshtile" );
if ( !meshtile )
__error( "missing class 'meshtile' in shape '%s'\n", shape->name );
EasyFindInt( &trinum, meshtile, "polynum" );
Shape_SetCtrlPointNum( trinum*3, 1 );
InitClassSearchIterator( &iter, meshtile, "*" );
for ( i = 0; ( tri = SearchGetNextClass( &iter ) ) ; )
{
EasyFindVec3d( v, tri, "0" );
Shape_AddCtrlPoint( Shape_NewCtrlPointUV3fv( i, 0, v ) );
i++;
EasyFindVec3d( v, tri, "1" );
Shape_AddCtrlPoint( Shape_NewCtrlPointUV3fv( i, 0, v ) );
i++;
EasyFindVec3d( v, tri, "2" );
Shape_AddCtrlPoint( Shape_NewCtrlPointUV3fv( i, 0, v ) );
i++;
}
#endif
//
// texture layer
//
texdef0 = FindClassType( shape, "proj_texdef0" );
if ( !texdef0 )
__error( "missing class 'proj_texdef0' in shape '%s'\n", shape->name );
texdef_real = EasyLookupClsref( texdef0, "texdef", map->texdefhm );
EasyFindVec2d( shift, texdef_real, "shift" );
EasyFindVec2d( scale, texdef_real, "scale" );
EasyFindFloat( &rotate, texdef_real, "rotate" );
EasyFindInt( &projection, texdef_real, "flags" );
texture = EasyLookupClsref( texdef_real, "texture", map->texturehm );
pair = FindHPair( texture, "ident" );
if ( !pair )
__error( "missing key 'ident' in texture class '%s'\n", texture->name );
// build gltex resource name from ident
sprintf( str, "gltex.%s", pair->value );
strcrpl( str, '/', '.' );
gltex_res = G_ResourceSearch( g_rs, str );
uni = UniTex_NewFrom_gltexres( gltex_res );
Layer_BeginInstance( (layerMode)(LayerMode_projection | LayerMode_Texel0N) );
{
// hack: build layer_gl_state_t
layer_gl_state_t *glstate;
glstate = NEWTYPE( layer_gl_state_t );
glstate->sfactor = GL_ONE;
glstate->dfactor = GL_ZERO;
glstate->flags = LAYER_STATE_FLAGS_DEPTH_MASK;
Layer_SetGLstate( glstate );
}
Layer_SetOrdinal( LAYER_TEXTURE_1 );
Layer_SetUniTex( uni );
if ( (projection&3) == ProjectionType_X )
{
Layer_SetProjection( LayerProjection_x );
}
else if ( (projection&3) == ProjectionType_Y )
{
Layer_SetProjection( LayerProjection_y );
}
else if ( (projection&3) == ProjectionType_Z )
{
Layer_SetProjection( LayerProjection_z );
}
else
{
__error( "can't get projection plane\n" );
}
//
// setup layer's transformation stack
//
tf2d_stack = NEWTYPE( tf2d_stack_t );
TF2D_InitStack( tf2d_stack );
Layer_SetTF2DStack( tf2d_stack );
{
tf2d_t *tf2d;
tf2d_matrix_t *tf2d_matrix;
tf2d = TF2D_CreateMatrix();
tf2d_matrix = TF2D_IsMatrix( tf2d );
TF2D_SetupMatrixByAngle( tf2d_matrix, -rotate );
TF2D_StackPush( tf2d_stack, tf2d );
}
{
tf2d_t *tf2d;
tf2d_scale_t *tf2d_scale;
scale[0] = 1.0/scale[0];
scale[1] = 1.0/scale[1];
tf2d = TF2D_CreateScale();
tf2d_scale = TF2D_IsScale( tf2d );
Vec2dCopy( tf2d_scale->scale, scale );
TF2D_StackPush( tf2d_stack, tf2d );
}
{
tf2d_t *tf2d;
tf2d_shift_t *tf2d_shift;
shift[0] = -shift[0];
shift[1] = -shift[1];
tf2d = TF2D_CreateShift();
tf2d_shift = TF2D_IsShift( tf2d );
Vec2dCopy( tf2d_shift->shift, shift );
TF2D_StackPush( tf2d_stack, tf2d );
}
layer = Layer_EndInstance();
Shape_AddLayer( layer );
//
// diffuse layer
//
#if 1
{
hobj_t *lightdef;
vec2d_t shift;
int width;
int height;
int projection;
fp_t patchsize;
ic_subimage_t *sub;
unitex_t *uni;
layer_t *layer;
lightmap_t *lightmap_head;
lightdef = FindClassType( shape, "proj_lightdef" );
if ( !lightdef )
{
goto no_lightdef;
}
EasyFindVec2d( shift, lightdef, "shift" );
EasyFindInt( &width, lightdef, "width" );
EasyFindInt( &height, lightdef, "height" );
EasyFindFloat( &patchsize, lightdef, "patchsize" );
EasyFindInt( &projection, lightdef, "projection" );
lightmap_head = LinkLightmaps( a_map->lightmap_db, StringToUnique( shape->name ), 0 );
if ( !lightmap_head && 0 )
goto no_diffuse;
{
int lightmap_bytes;
void *lightmap_pixels;
lightmap_bytes = width*height*4;
lightmap_pixels = NEWBYTES( lightmap_bytes );
sub = IC_NewSubImage( width, height );
IC_SubImageSetPixels( sub, lightmap_pixels );
}
uni = UniTex_NewFrom_subimage( sub );
// create diffuse layer
Layer_BeginInstance( (layerMode)(LayerMode_projection | LayerMode_Texel0N) );
{
// hack: build layer_gl_state_t
layer_gl_state_t *glstate;
glstate = NEWTYPE( layer_gl_state_t );
glstate->flags = LAYER_STATE_FLAGS_DEPTH_MASK;
glstate->sfactor = GL_ZERO;
glstate->dfactor = GL_SRC_COLOR;
Layer_SetGLstate( glstate );
}
Layer_SetOrdinal( LAYER_DIFFUSE_1 );
Layer_SetUniTex( uni );
Layer_SetLightmapHead( lightmap_head );
if ( (projection&3) == ProjectionType_X )
{
Layer_SetProjection( LayerProjection_x );
}
else if ( (projection&3) == ProjectionType_Y )
{
Layer_SetProjection( LayerProjection_y );
}
else if ( (projection&3) == ProjectionType_Z )
{
Layer_SetProjection( LayerProjection_z );
}
else
{
__error( "can't get projection plane\n" );
}
{
shift[0] = -shift[0];
shift[1] = -shift[1];
Layer_AddShift( shift );
}
{
vec2d_t scale;
scale[0] = 1.0 / patchsize;
scale[1] = 1.0 / patchsize;
Layer_AddScale( scale );
}
layer = Layer_EndInstance();
Shape_AddLayer( layer );
no_diffuse:
{}
}
#endif
//
// specular layer
//
#if 1
{
hobj_t *lightdef;
vec2d_t shift;
int width;
int height;
int projection;
fp_t patchsize;
ic_subimage_t *sub;
unitex_t *uni;
layer_t *layer;
lightmap_t *lightmap_head;
lightdef = FindClassType( shape, "proj_lightdef" );
if ( !lightdef )
{
// __error( "missing class 'proj_lightdef' in shape '%s'\n", shape->name );
goto no_lightdef;
}
EasyFindVec2d( shift, lightdef, "shift" );
EasyFindInt( &width, lightdef, "width" );
EasyFindInt( &height, lightdef, "height" );
EasyFindFloat( &patchsize, lightdef, "patchsize" );
EasyFindInt( &projection, lightdef, "projection" );
lightmap_head = LinkLightmaps( a_map->lightmap_db, StringToUnique( shape->name ), 1 );
if ( !lightmap_head )
goto no_specular;
// setup specular lightmap
{
int lightmap_bytes;
void *lightmap_pixels;
lightmap_bytes = width*height*4;
lightmap_pixels = NEWBYTES( lightmap_bytes );
sub = IC_NewSubImage( width, height );
IC_SubImageSetPixels( sub, lightmap_pixels );
}
uni = UniTex_NewFrom_subimage( sub );
// create specular layer
Layer_BeginInstance( (layerMode)(LayerMode_projection | LayerMode_Texel0N) );
{
// hack: build layer_gl_state_t
layer_gl_state_t *glstate;
glstate = NEWTYPE( layer_gl_state_t );
glstate->flags = LAYER_STATE_FLAGS_DEPTH_MASK;
glstate->sfactor = GL_ONE;
glstate->dfactor = GL_ONE;
Layer_SetGLstate( glstate );
}
Layer_SetOrdinal( LAYER_SPECULAR_1 );
Layer_SetLightmapHead( lightmap_head );
Layer_SetUniTex( uni );
if ( (projection&3) == ProjectionType_X )
{
Layer_SetProjection( LayerProjection_x );
}
else if ( (projection&3) == ProjectionType_Y )
{
Layer_SetProjection( LayerProjection_y );
}
else if ( (projection&3) == ProjectionType_Z )
{
Layer_SetProjection( LayerProjection_z );
}
else
{
__error( "can't get projection plane\n" );
}
{
shift[0] = -shift[0];
shift[1] = -shift[1];
Layer_AddShift( shift );
}
{
vec2d_t scale;
scale[0] = 1.0 / patchsize;
scale[1] = 1.0 / patchsize;
Layer_AddScale( scale );
}
layer = Layer_EndInstance();
Shape_AddLayer( layer );
no_specular:
{}
}
#endif
no_lightdef:
shp = Shape_EndInstance();
return shp;
}
/*
==============================
IC_ImageTakeEmptyRectangle
==============================
*/
void IC_ImageTakeEmptyRectangle( ic_image_t *img, int width, int height, int *xofs, int *yofs )
{
int gapw;
int gaph;
ic_rect_t *split;
ic_rect_t *rect;
u_list_iter_t iter;
if ( !img->best_last_rect )
__error( "IC_ImageTakeEmptyRectangle: best_last_rect is (null)\n" );
gapw = img->best_last_rect->width - width;
gaph = img->best_last_rect->height - height;
if ( gapw < 0 || gaph < 0 )
__error( "IC_ImageTakeEmptyRectangle: best_last_rect doesn't fit the requested size\n" );
*xofs = img->best_last_rect->xofs;
*yofs = img->best_last_rect->yofs;
// remove best_last rectangle from empty_rect list ...
U_ListIterInit( &iter, img->empty_rect_list );
for ( ; ( rect = (ic_rect_t *)U_ListIterNext( &iter ) ) ; )
{
if ( rect == img->best_last_rect )
break;
}
if ( !rect )
__error( "IC_ImageTakeEmptyRectangle: odd, can't find best_last_rect in list\n" );
U_ListIterRemoveGoNext( &iter );
// ... and split it up, if necessary
// upper left is the requested rectangle
if ( gapw > 0 )
{
// upper right
split = IC_NewRectangle( gapw, height,
img->best_last_rect->xofs + width,
img->best_last_rect->yofs );
U_ListInsertAtHead( img->empty_rect_list, split );
}
if ( gaph > 0 )
{
// lower left
split = IC_NewRectangle( width, gaph,
img->best_last_rect->xofs,
img->best_last_rect->yofs + height );
U_ListInsertAtHead( img->empty_rect_list, split );
}
if ( gapw > 0 && gaph > 0 )
{
// lower right
split = IC_NewRectangle( gapw, gaph,
img->best_last_rect->xofs + width,
img->best_last_rect->yofs + height );
U_ListInsertAtHead( img->empty_rect_list, split );
}
// the requested rectangle is not needed any more
IC_FreeRectangle( img->best_last_rect );
img->best_last_rect = NULL;
}
/*
==============================
R_SetupShapes
==============================
*/
void R_SetupShapes( g_map_t *map )
{
hobj_search_iterator_t iter;
hobj_t *shape_root;
hobj_t *shape;
hpair_t *pair;
shape_t *shp;
r_cfaceshapenum = 0;
r_csurfshapenum = 0;
r_sfaceshapenum = 0;
r_meshtileshapenum = 0;
shp = NULL;
shape_root = HManagerGetRootClass( map->shapehm );
InitClassSearchIterator( &iter, shape_root, "shape" );
for ( ; ( shape = SearchGetNextClass( &iter ) ) ; )
{
pair = FindHPair( shape, "tess_name" );
if ( !pair )
__error( "missing key 'tess_name' in shape '%s'\n", shape->name );
if ( !strcmp( pair->value, "sface" ) )
{
// simple face shape
if ( r_sfaceshapenum >= MAX_SFACE_SHAPES )
__error( "reached MAX_SFACE_SHAPES\n" );
shp = R_SetupSFaceShape( shape, map );
if ( !shp )
continue;
ShapeDB_InsertShape( a_map->shape_db, shp );
r_sfaceshapes[r_sfaceshapenum] = shp;
r_sfaceshapenum++;
}
else if ( !strcmp( pair->value, "cface" ) )
{
// curved face shape
if ( r_cfaceshapenum >= MAX_CFACE_SHAPES )
__error( "reached MAX_CFACE_SHAPES\n" );
shp = R_SetupCFaceShape( shape, map );
if ( !shp )
continue;
ShapeDB_InsertShape( a_map->shape_db, shp );
r_cfaceshapes[r_cfaceshapenum] = shp;
r_cfaceshapenum++;
}
else if ( !strcmp( pair->value, "csurf" ) )
{
// curved surface
if ( r_csurfshapenum >= MAX_CSURF_SHAPES )
__error( "reached MAX_CSURF_SHAPES\n" );
shp = R_SetupCSurfShape( shape, map );
if ( !shp )
continue;
ShapeDB_InsertShape( a_map->shape_db, shp );
r_csurfshapes[r_csurfshapenum] = shp;
r_csurfshapenum++;
}
else if ( !strcmp( pair->value, "meshtile" ) )
{
// meshtile shape
if ( r_meshtileshapenum >= MAX_MESHTILE_SHAPES )
__error( "reached MAX_MESHTILE_SHAPES\n" );
shp = R_SetupMeshTileShape( shape, map );
if ( !shp )
continue;
ShapeDB_InsertShape( a_map->shape_db, shp );
r_meshtileshapes[r_meshtileshapenum] = shp;
r_meshtileshapenum++;
}
else
{
__error( "unkown tesselation methode in shape '%s'\n", shape->name );
}
}
printf( " %d simple face shapes\n", r_sfaceshapenum );
printf( " %d curved face shapes\n", r_cfaceshapenum );
printf( " %d curved surface shapes\n", r_csurfshapenum );
printf( " %d meshtile shapes\n", r_meshtileshapenum );
}
int SND_AddJob( g_resource_t *res, int type, int pri, vec3d_t origin )
{
res_sound_cache_t *s;
int i;
ALuint src;
if( !sst_isup )
{
return 0;
}
s = res->res_cache;
if( !s )
{
__warning( "snd->res_cache == NULL\n" );
return 0;
}
if( !pri )
{
__warning( "no priority. failed\n" );
return 0;
}
// search for free source
for( i = 0; i < al_srcnum; i++ )
{
if( !srcs[i].inuse )
break;
}
if( i >= al_srcnum ) // none free => drop less priority sound
{
for( i = 0; i < al_srcnum; i++ )
{
if( srcs[i].pri < pri )
break;
}
}
if( i >= al_srcnum ) // even none => drop equal priority
{
for( i = 0; i < al_srcnum; i++ )
{
if( srcs[i].pri == pri )
break;
}
}
if( i >= al_srcnum ) // even none => drop equal priority
{
__warning( "no free source\n" );
return 0;
}
snd_num++; // must be > 0
srcs[i].inuse = 1;
srcs[i].id = snd_num;
srcs[i].pri = pri;
src = srcs[i].al_source;
// alSourcefv( src, AL_POSITION, origin );
alSource3f( src, AL_POSITION, -5.0, 0.0, 0.0 );
alSourcefv( src, AL_VELOCITY, zeroes );
alSourcefv( src, AL_ORIENTATION, back );
// alSourcef( src, AL_GAIN, 1.0 );
#if 0
if( s->al_buf == 0 )
{
__error( "al_buf == 0, %s\n", (char * )res->res_register );
}
#endif
// SHV_Printf( "playing %d\n", s->al_buf );
alSourcei( src, AL_BUFFER, s->al_buf );
alSourcei( src, AL_LOOPING, AL_FALSE );
alSourcePlay( src );
return snd_num;
}
/*
==============================
Layer_CreateTexCoords_uv
==============================
*/
void Layer_CreateTexCoords_uv( layer_t *layer, mesh_t *mesh )
{
int i;
surface_ctrl_t *sc;
vec2d_t v;
vec2d_t *m_uvs;
int *m_vrefs;
int m_vertexnum;
int m_vrefnum;
mesh_t *tc_mesh;
vec2d_t *m_tc;
int tmp_int;
sc = NewBezierSurface( 2, 2 );
U_BeginMemUnpack( layer->packed_info );
// fixme: move insane cotrol point order to the caller
U_MemUnpackf32v2( v );
SetSurfaceCtrlPoint3f( sc, 0, 0, v[0], v[1], 0 );
U_MemUnpackf32v2( v );
SetSurfaceCtrlPoint3f( sc, 0, 1, v[0], v[1], 0 );
U_MemUnpackf32v2( v );
SetSurfaceCtrlPoint3f( sc, 1, 0, v[0], v[1], 0 );
U_MemUnpackf32v2( v );
SetSurfaceCtrlPoint3f( sc, 1, 1, v[0], v[1], 0 );
U_EndMemUnpack();
Mesh_GetIntBase( mesh, 1, &m_vrefnum, &m_vrefs );
Mesh_GetVec2dBase( mesh, 3, &m_vertexnum, &m_uvs );
Mesh_BeginInstance();
Mesh_AddVec2dArray( m_vrefnum );
tc_mesh = Mesh_EndInstance();
Mesh_GetVec2dBase( tc_mesh, 0, &tmp_int, &m_tc );
for ( i = 0; i < m_vrefnum; i++ )
{
vec3d_t v3;
EvalSurfacePoint( sc, m_uvs[m_vrefs[i]][0], m_uvs[m_vrefs[i]][1], v3 );
v[0] = v3[0];
v[1] = v3[1];
if ( layer->flags & LAYER_FLAGS_MODE_TEXEL0N )
UniTex_RealTexCoord_0N( layer->real_source, m_tc[i], v );
else if ( layer->flags & LAYER_FLAGS_MODE_TEXEL01 )
UniTex_RealTexCoord_01( layer->real_source, m_tc[i], v );
else
__error( "unknown texcoord access type\n" );
}
if ( layer->tc )
Mesh_Free( layer->tc );
layer->tc = tc_mesh;
}
