/**
* Clear the screen, then render the mesh using the given camera.
* @param camera The logical camera to use.
* @see math/camera.hpp
*/
void OpenglProject::render( const Camera* camera )
{
// TODO render code
glLoadIdentity();
Vector3 c_pos = camera->get_position();
Vector3 c_dir = camera->get_direction();
Vector3 c_up = camera->get_up();
gluLookAt(
c_pos.x, c_pos.y, c_pos.z,
c_pos.x + c_dir.x, c_pos.y + c_dir.y, c_pos.z + c_dir.z,
c_up.x, c_up.y, c_up.z);
GLfloat red[] = { 0.7, 0.2, 0.4, 1.0 };
GLfloat blue[] = { 0.1, 0.3, 1.0, 1.0 };
GLfloat white[] = { 0.5, 0.5, 0.5, 1.0 };
GLfloat shine[] = { 100.0 };
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_NORMAL_ARRAY );
glVertexPointer( 3, GL_DOUBLE, 0, scene.mesh.vertices );
glNormalPointer( GL_DOUBLE, 0, scene.mesh.normals );
// Give the pool mesh a orange-ish material
glMaterialfv( GL_FRONT, GL_DIFFUSE, red );
glMaterialfv( GL_FRONT, GL_SPECULAR, white );
// Pool transformations
glPushMatrix();
apply_transforms(scene.mesh_position);
glDrawElements( GL_TRIANGLES, scene.mesh.num_triangles*3, GL_UNSIGNED_INT, scene.mesh.triangles );
glPopMatrix();
glVertexPointer( 3, GL_DOUBLE, 0, scene.wave.vertices );
glNormalPointer( GL_DOUBLE, 0, scene.wave.normals );
// Give it a bluish material
glMaterialfv( GL_FRONT, GL_DIFFUSE, blue );
glMaterialfv( GL_FRONT, GL_SPECULAR, white );
glMaterialfv( GL_FRONT, GL_SHININESS, shine );
// Transform the wave mesh to fit properly in the pool
// No need to save modelview matrix since this is the
// last draw call for the frame
apply_transforms(scene.heightmap_position);
glDrawElements( GL_TRIANGLES, scene.wave.num_triangles*3, GL_UNSIGNED_INT, scene.wave.triangles );
glDisableClientState( GL_VERTEX_ARRAY );
glDisableClientState( GL_NORMAL_ARRAY );
}
void voxel_model::calculate_transforms()
{
if(!invalidated_) {
return;
}
reset_geometry();
apply_transforms();
}
static mate_pdu* new_pdu(mate_cfg_pdu* cfg, guint32 framenum, field_info* proto, proto_tree* tree) {
mate_pdu* pdu = (mate_pdu*)g_slice_new(mate_max_size);
field_info* cfi;
GPtrArray* ptrs;
mate_range* range;
mate_range* proto_range;
tmp_pdu_data data;
guint i,j;
gint min_dist;
field_info* range_fi;
gint32 last_start;
gint32 first_end;
gint32 curr_end;
int hfid;
dbg_print (dbg_pdu,1,dbg_facility,"new_pdu: type=%s framenum=%i",cfg->name,framenum);
pdu->id = ++(cfg->last_id);
pdu->cfg = cfg;
pdu->avpl = new_avpl(cfg->name);
pdu->frame = framenum;
pdu->next_in_frame = NULL;
pdu->rel_time = rd->now;
pdu->gop = NULL;
pdu->next = NULL;
pdu->time_in_gop = -1.0;
pdu->first = FALSE;
pdu->is_start = FALSE;
pdu->is_stop = FALSE;
pdu->after_release = FALSE;
data.ranges = g_ptr_array_new();
data.pdu = pdu;
data.tree = tree;
/* first we create the proto range */
proto_range = g_malloc(sizeof(mate_range));
proto_range->start = proto->start;
proto_range->end = proto->start + proto->length;
g_ptr_array_add(data.ranges,proto_range);
dbg_print(dbg_pdu,3,dbg_facility,"new_pdu: proto range %u-%u",proto_range->start,proto_range->end);
last_start = proto_range->start;
/* we move forward in the tranport */
for (i = cfg->transport_ranges->len; i--; ) {
hfid = *((int*)g_ptr_array_index(cfg->transport_ranges,i));
ptrs = proto_get_finfo_ptr_array(tree, hfid);
min_dist = 99999;
range_fi = NULL;
if (ptrs) {
for (j=0; j < ptrs->len; j++) {
cfi = (field_info*) g_ptr_array_index(ptrs,j);
if (cfi->start < last_start && min_dist >= (last_start - cfi->start) ) {
range_fi = cfi;
min_dist = last_start - cfi->start;
}
}
if ( range_fi ) {
range = g_malloc(sizeof(*range));
range->start = range_fi->start;
range->end = range_fi->start + range_fi->length;
g_ptr_array_add(data.ranges,range);
last_start = range_fi->start;
dbg_print(dbg_pdu,3,dbg_facility,"new_pdu: transport(%i) range %i-%i",hfid,range->start,range->end);
} else {
/* we missed a range */
dbg_print(dbg_pdu,6,dbg_facility,"new_pdu: transport(%i) missed",hfid);
}
}
}
if (cfg->payload_ranges) {
first_end = proto_range->end;
for (i = 0 ; i < cfg->payload_ranges->len; i++) {
hfid = *((int*)g_ptr_array_index(cfg->payload_ranges,i));
ptrs = proto_get_finfo_ptr_array(tree, hfid);
min_dist = 99999;
range_fi = NULL;
if (ptrs) {
for (j=0; j < ptrs->len; j++) {
cfi = (field_info*) g_ptr_array_index(ptrs,j);
curr_end = cfi->start + cfi->length;
if (curr_end > first_end && min_dist >= (curr_end - first_end) ) {
range_fi = cfi;
min_dist = curr_end - first_end;
}
}
if ( range_fi ) {
range = g_malloc(sizeof(*range));
range->start = range_fi->start;
range->end = range_fi->start + range_fi->length;
g_ptr_array_add(data.ranges,range);
last_start = range_fi->start;
dbg_print(dbg_pdu,3,dbg_facility,"new_pdu: payload(%i) range %i-%i",hfid,range->start,range->end);
} else {
/* we missed a range */
dbg_print(dbg_pdu,5,dbg_facility,"new_pdu: payload(%i) missed",hfid);
}
}
}
}
g_hash_table_foreach(cfg->hfids_attr,get_pdu_fields,&data);
apply_transforms(pdu->cfg->transforms,pdu->avpl);
g_ptr_array_free(data.ranges,TRUE);
return pdu;
}
static void analyze_pdu(mate_pdu* pdu) {
/* TODO:
return a g_boolean to tell we've destroyed the pdu when the pdu is unnassigned
destroy the unassigned pdu
*/
mate_cfg_gop* cfg = NULL;
mate_gop* gop = NULL;
gchar* gop_key;
gchar* orig_gop_key = NULL;
AVPL* candidate_start = NULL;
AVPL* candidate_stop = NULL;
AVPL* is_start = NULL;
AVPL* is_stop = NULL;
AVPL* gopkey_match = NULL;
LoAL* gog_keys = NULL;
AVPL* curr_gogkey = NULL;
void* cookie = NULL;
AVPL* gogkey_match = NULL;
gchar* gogkey_str = NULL;
dbg_print (dbg_gop,1,dbg_facility,"analyze_pdu: %s",pdu->cfg->name);
if (! (cfg = g_hash_table_lookup(mc->gops_by_pduname,pdu->cfg->name)) )
return;
if ((gopkey_match = new_avpl_exact_match("gop_key_match",pdu->avpl,cfg->key, TRUE))) {
gop_key = avpl_to_str(gopkey_match);
g_hash_table_lookup_extended(cfg->gop_index,(gconstpointer)gop_key,(gpointer)&orig_gop_key,(gpointer)&gop);
if ( gop ) {
g_free(gop_key);
/* is the gop dead ? */
if ( ! gop->released &&
( ( gop->cfg->lifetime > 0.0 && gop->time_to_die >= rd->now) ||
( gop->cfg->idle_timeout > 0.0 && gop->time_to_timeout >= rd->now) ) ) {
dbg_print (dbg_gop,4,dbg_facility,"analyze_pdu: expiring released gop");
gop->released = TRUE;
if (gop->gog && gop->cfg->start) gop->gog->num_of_released_gops++;
}
/* TODO: is the gop expired? */
gop_key = orig_gop_key;
dbg_print (dbg_gop,2,dbg_facility,"analyze_pdu: got gop: %s",gop_key);
if (( candidate_start = cfg->start )) {
dbg_print (dbg_gop,2,dbg_facility,"analyze_pdu: got candidate start");
if (( is_start = new_avpl_exact_match("",pdu->avpl, candidate_start, FALSE) )) {
delete_avpl(is_start,FALSE);
if ( gop->released ) {
dbg_print (dbg_gop,3,dbg_facility,"analyze_pdu: start on released gop, let's create a new gop");
g_hash_table_remove(cfg->gop_index,gop_key);
gop->gop_key = NULL;
gop = new_gop(cfg,pdu,gop_key);
g_hash_table_insert(cfg->gop_index,gop_key,gop);
} else {
dbg_print (dbg_gop,1,dbg_facility,"analyze_pdu: duplicate start on gop");
}
}
}
pdu->gop = gop;
if (gop->last_pdu) gop->last_pdu->next = pdu;
gop->last_pdu = pdu;
pdu->next = NULL;
pdu->time_in_gop = rd->now - gop->start_time;
if (gop->released) pdu->after_release = TRUE;
} else {
dbg_print (dbg_gop,1,dbg_facility,"analyze_pdu: no gop already");
if ( ! cfg->start ) {
/* there is no GopStart, we'll check for matching GogKeys
if we have one we'll create the Gop */
apply_extras(pdu->avpl,gopkey_match,cfg->extra);
gog_keys = g_hash_table_lookup(mc->gogs_by_gopname,cfg->name);
if (gog_keys) {
while (( curr_gogkey = get_next_avpl(gog_keys,&cookie) )) {
if (( gogkey_match = new_avpl_exact_match(cfg->name,gopkey_match,curr_gogkey,FALSE) )) {
gogkey_str = avpl_to_str(gogkey_match);
if (g_hash_table_lookup(cfg->gog_index,gogkey_str)) {
gop = new_gop(cfg,pdu,gop_key);
g_hash_table_insert(cfg->gop_index,gop_key,gop);
delete_avpl(gogkey_match,FALSE);
g_free(gogkey_str);
break;
} else {
delete_avpl(gogkey_match,FALSE);
g_free(gogkey_str);
}
}
}
if ( ! gop ) {
g_free(gop_key);
delete_avpl(gopkey_match,TRUE);
return;
}
} else {
g_free(gop_key);
delete_avpl(gopkey_match,TRUE);
return;
}
} else {
candidate_start = cfg->start;
if (( is_start = new_avpl_exact_match("",pdu->avpl, candidate_start, FALSE) )) {
delete_avpl(is_start,FALSE);
gop = new_gop(cfg,pdu,gop_key);
} else {
g_free(gop_key);
return;
}
pdu->gop = gop;
}
}
if (gop->last_pdu) gop->last_pdu->next = pdu;
gop->last_pdu = pdu;
pdu->next = NULL;
pdu->time_in_gop = rd->now - gop->start_time;
gop->num_of_pdus++;
gop->time_to_timeout = cfg->idle_timeout > 0.0 ? cfg->idle_timeout + rd->now : (float) -1.0 ;
dbg_print (dbg_gop,4,dbg_facility,"analyze_pdu: merge with key");
merge_avpl(gop->avpl,gopkey_match,TRUE);
delete_avpl(gopkey_match,TRUE);
dbg_print (dbg_gop,4,dbg_facility,"analyze_pdu: apply extras");
apply_extras(pdu->avpl,gop->avpl,gop->cfg->extra);
gop->last_time = pdu->rel_time;
if ( ! gop->released) {
candidate_stop = cfg->stop;
if (candidate_stop) {
is_stop = new_avpl_exact_match("",pdu->avpl, candidate_stop,FALSE);
} else {
is_stop = new_avpl("");
}
if(is_stop) {
dbg_print (dbg_gop,1,dbg_facility,"analyze_pdu: is a `stop");
delete_avpl(is_stop,FALSE);
if (! gop->released) {
gop->released = TRUE;
gop->release_time = pdu->rel_time;
if (gop->gog && gop->cfg->start) gop->gog->num_of_released_gops++;
}
pdu->is_stop = TRUE;
}
}
if (gop->last_n != gop->avpl->len) apply_transforms(gop->cfg->transforms,gop->avpl);
gop->last_n = gop->avpl->len;
if (gop->gog) {
reanalyze_gop(gop);
} else {
analyze_gop(gop);
}
} else {
dbg_print (dbg_gop,4,dbg_facility,"analyze_pdu: no match for this pdu");
pdu->gop = NULL;
}
}
