status
elementVector(Vector v, Int e, Any obj)
{ int n = indexVector(v, e);
if ( n < 0 )
{ int nsize = valInt(v->size)-n;
Any *newElements = alloc(nsize*sizeof(Any));
int m;
if ( v->elements )
{ cpdata(&newElements[-n], v->elements, Any, valInt(v->size));
unalloc(valInt(v->allocated)*sizeof(Any), v->elements);
}
v->elements = newElements;
for( m = 0; m < -n; m++ )
v->elements[m] = NIL;
assignVector(v, 0, obj);
assign(v, size, toInt(nsize));
assign(v, allocated, toInt(nsize));
assign(v, offset, toInt(valInt(e)-1));
succeed;
}
if ( n >= valInt(v->size) )
{ int m;
if ( n >= valInt(v->allocated) )
{ int nalloc = max(valInt(v->allocated)*2, n+1);
Any *newElements = alloc(nalloc * sizeof(Any));
if ( v->elements )
{ cpdata(newElements, v->elements, Any, valInt(v->size));
unalloc(valInt(v->allocated)*sizeof(Any), v->elements);
}
v->elements = newElements;
assign(v, allocated, toInt(nalloc));
}
for( m = valInt(v->size); m <= n ; m++ )
v->elements[m] = NIL;
assignVector(v, n, obj);
assign(v, size, toInt(n+1));
succeed;
}
assignVector(v, n, obj);
succeed;
}
static status
insertVector(Vector v, Int where, Any obj)
{ int size = valInt(v->size);
int offset = valInt(v->offset);
int i;
Any *s, *p;
if ( valInt(where) <= offset+1 )
{ assign(v, offset, toInt(offset+1));
return elementVector(v, where, obj);
}
if ( valInt(where) > size+offset )
return elementVector(v, where, obj);
elementVector(v, toInt(size+offset+1), NIL);
i = indexVector(v, where);
s = &v->elements[i];
p = &v->elements[valInt(v->size)-1]; /* point to last element */
for( ; p>s; p-- )
{ p[0] = p[-1];
}
v->elements[i] = NIL;
assignVector(v, i, obj);
succeed;
}
status
fillVector(Vector v, Any obj, Int from, Int to)
{ int f, t;
f = (isDefault(from) ? valInt(getLowIndexVector(v)) : valInt(from));
t = (isDefault(to) ? valInt(getHighIndexVector(v)) : valInt(to));
if ( t < f )
fail;
if ( v->size == ZERO )
{ int size = t-f+1;
int n;
assign(v, offset, toInt(f - 1));
assign(v, size, toInt(size));
assign(v, allocated, v->size);
if ( v->elements )
unalloc(0, v->elements);
v->elements = alloc(sizeof(Any) * size);
for(n=0; n<size; n++)
{ v->elements[n] = NIL;
if ( notNil(obj) )
assignVector(v, n, obj);
}
} else
{ elementVector(v, toInt(f), obj);
elementVector(v, toInt(t), obj);
while( ++f < t )
elementVector(v, toInt(f), obj);
}
succeed;
}
status
shiftVector(Vector v, Int places)
{ int n = valInt(v->size);
int s = valInt(places);
int i;
if ( s > 0 )
{ for(i=n-s; i < n; i++)
assignVector(v, i, NIL);
for(i = n - 1; i >= s; i--)
v->elements[i] = v->elements[i-s];
for( ; i >= 0; i-- )
v->elements[i] = NIL;
} else
{ for(i = 0; i < -s; i++)
assignVector(v, i, NIL);
for(i = 0; i < n+s; i++)
v->elements[i] = v->elements[i-s];
for( ; i < n; i++ )
v->elements[i] = NIL;
}
succeed;
}
API void updateOpenGLLodMap(OpenGLLodMap *lodmap, Vector *position, bool autoExpand)
{
// update the viewer position
assignVector(lodmap->viewerPosition, position);
if(autoExpand) {
// expand the quadtree to actually cover our position
float *positionData = getVectorData(position);
expandQuadtree(lodmap->quadtree, positionData[0], positionData[2]);
}
double range = getLodMapNodeRange(lodmap, lodmap->quadtree->root);
// free our previous selection list
g_list_free(lodmap->selection);
lodmap->selection = NULL;
// select the LOD map nodes to be rendered
if(lodmapQuadtreeNodeIntersectsSphere(lodmap, lodmap->quadtree->root, position, range)) {
lodmap->selection = selectLodMapNodes(lodmap, position, lodmap->quadtree->root);
// make all selected nodes visible
for(GList *iter = lodmap->selection; iter != NULL; iter = iter->next) {
QuadtreeNode *node = iter->data;
OpenGLLodMapTile *tile = node->data;
// wait until the node is fully loaded
g_mutex_lock(&tile->mutex);
while(tile->status == OPENGL_LODMAP_TILE_LOADING) {
g_cond_wait(&tile->condition, &tile->mutex);
}
g_mutex_unlock(&tile->mutex);
// activate if not active yet
if(tile->status != OPENGL_LODMAP_TILE_ACTIVE) {
activateLodMapTile(lodmap, node);
}
tile->model->visible = true; // make model visible for rendering
tile->model->polygonMode = lodmap->polygonMode; // set the parent's polygon mode
}
QuadtreeAABB box = quadtreeNodeAABB(lodmap->quadtree->root);
logInfo("Updated LOD map for quadtree covering range [%d,%d]x[%d,%d] on %u levels: %d nodes selected", box.minX, box.maxX, box.minY, box.maxY, lodmap->quadtree->root->level, g_list_length(lodmap->selection));
}
}
static status
loadVector(Vector v, IOSTREAM *fd, ClassDef def)
{ int n;
Any obj;
int size;
loadSlotsObject(v, fd, def);
size = valInt(v->size);
v->allocated = v->size;
v->elements = alloc(size * sizeof(Any));
for(n = 0; n < size; n++)
{ TRY( obj = loadObject(fd) );
v->elements[n] = NIL;
assignVector(v, n, obj);
}
succeed;
}
status
initialiseVectorv(Vector v, int argc, Any *argv)
{ int n;
v->offset = ZERO;
v->size = toInt(argc);
v->allocated = v->size;
if ( argc > 0 )
{ v->elements = alloc(argc * sizeof(Any));
for(n=0; n < argc; n++)
{ v->elements[n] = NIL;
assignVector(v, n, argv[n]);
}
} else
v->elements = NULL;
succeed;
}
void State::applyUniformsMappings()
{
if (m_materials.isEmpty()) return;
Material& mat = *m_materials.back();
/// @todo should maybe work without shaders
if (!mat.prog()) return;
GLProgram& prog = *mat.prog();
CameraPtr c = camera();
for (auto it = mat.uniformMap().begin(); it != mat.uniformMap().end(); ++it) {
const MappableValue& map = *it;
bool ok = true;
if (map.src() == "model") {
if (map.var() == "transform")
setUniform(prog, it.key(), model());
else if (map.var() == "modelview" && c) {
glm::mat4 m = (c->view() * model());
prog.setUniform(this, it.key(), m);
} else ok = false;
}
else if (map.src() == "material") {
if (map.var() == "diffuse")
setUniformSel(this, prog, it.key(), mat.colors.diffuse, map.select());
else if (map.var() == "ambient")
setUniformSel(this, prog, it.key(), mat.colors.ambient, map.select());
else if (map.var() == "specular")
setUniformSel(this, prog, it.key(), mat.colors.specular, map.select());
else if (map.var() == "transparent")
setUniformSel(this, prog, it.key(), mat.colors.transparent, map.select());
else if (map.var() == "emissive")
setUniformSel(this, prog, it.key(), mat.colors.emissive, map.select());
else if (map.var() == "wireframe")
prog.setUniform(this, it.key(), mat.style.wireframe);
else if (map.var() == "twosided")
prog.setUniform(this, it.key(), mat.style.twosided);
else if (map.var() == "opacity")
prog.setUniform(this, it.key(), mat.style.opacity);
else if (map.var() == "shininess")
prog.setUniform(this, it.key(), mat.style.shininess);
else if (map.var() == "shininess_strength")
prog.setUniform(this, it.key(), mat.style.shininess_strength);
else if (map.var() == "refracti")
prog.setUniform(this, it.key(), mat.style.refracti);
else ok = false;
}
else if (map.src() == "scene") {
if (map.var() == "size")
setUniformSel(this, prog, it.key(),
glm::vec2(m_scene.width(), m_scene.height()), map.select());
else if (map.var() == "time")
prog.setUniform(this, it.key(), m_time);
else if (map.var() == "dt")
prog.setUniform(this, it.key(), m_dt);
else ok = false;
}
else if (map.src() == "camera" && c) {
if (map.var() == "target")
setUniformSel(this, prog, it.key(), c->target(), map.select());
else if (map.var() == "up")
setUniformSel(this, prog, it.key(), c->up(), map.select());
else if (map.var() == "right")
setUniformSel(this, prog, it.key(), c->right(), map.select());
else if (map.var() == "front")
setUniformSel(this, prog, it.key(), c->front(), map.select());
else if (map.var() == "view")
setUniform(prog, it.key(), c->view());
else if (map.var() == "projection")
prog.setUniform(this, it.key(), c->projection());
else if (map.var() == "dist")
prog.setUniform(this, it.key(), c->dist());
else if (map.var() == "fov")
prog.setUniform(this, it.key(), c->fov());
else if (map.var() == "near")
prog.setUniform(this, it.key(), c->near());
else if (map.var() == "far")
prog.setUniform(this, it.key(), c->far());
else if (map.var() == "size")
setUniformSel(this, prog, it.key(),
glm::vec2(c->width(), c->height()), map.select());
else ok = false;
}
else if (map.src() == "lights" || map.src() == "light") {
if (map.var() == "ambient")
assignVector(this, prog, it.key(), map, m_data.back().m_lights, &Light::ambient);
else if (map.var() == "diffuse")
assignVector(this, prog, it.key(), map, m_data.back().m_lights, &Light::diffuse);
else if (map.var() == "specular")
assignVector(this, prog, it.key(), map, m_data.back().m_lights, &Light::specular);
else if (map.var() == "direction")
assignVector(this, prog, it.key(), map, m_data.back().m_lights, &Light::direction);
else if (map.var() == "location")
assignVector(this, prog, it.key(), map, m_data.back().m_lights, &Light::location);
else if (map.var() == "target")
assignVector(this, prog, it.key(), map, m_data.back().m_lights, &Light::target);
else if (map.var() == "spot_cutoff")
assignVector(this, prog, it.key(), map, m_data.back().m_lights, &Light::spotCutoff);
else ok = false;
}
else if (map.src() == "gui") {
if (map.var() == "mouse")
setUniformSel(this, prog, it.key(), m_scene.lastRenderOpts().hover, map.select());
else if (map.var() == "mousedown")
setUniformSel(this, prog, it.key(), m_scene.lastRenderOpts().mousedown, map.select());
else ok = false;
}
else ok = false;
}
}
