manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
vcglib/apps/nexus/nexusmt.cpp

552 lines
15 KiB
C++
Raw Blame History

#include <GL/glew.h>
#include "nexusmt.h"
#include <map>
#include <queue>
using namespace nxs;
using namespace vcg;
using namespace std;
/*void Policy::Visit(Node *node, std::queue<Node *> &qnode) {
std::vector<Node *>::iterator n;
for(n = node->in.begin(); n != node->in.end(); n++)
if(!(*n)->visited)
Visit(*n, qnode);
node->visited = true;
qnode.push(node);
}
bool FrustumPolicy::Expand(unsigned int patch, Nexus::PatchInfo &entry) {
if(entry.error == 0) return false;
float dist = Distance(entry.sphere, frustum.ViewPoint());
if(dist < 0) return true;
// dist = pow(dist, 1.2);
return entry.error > error * frustum.Resolution(dist);
} */
float Metric::GetError(Node *node) {
float max_error = 0;
vector<Frag>::iterator frag;
for(frag = node->frags.begin(); frag != node->frags.end(); frag++) {
float error = GetError(*frag);
if(max_error < error) max_error = error;
}
return max_error;
}
float Metric::GetError(Frag &frag) {
float max_error = 0;
vector<unsigned int>::iterator cell;
for(cell = frag.begin(); cell != frag.end(); cell++) {
float error = GetError(*cell);
if(max_error < error) max_error = error;
}
return max_error;
}
float FrustumMetric::GetError(unsigned int cell) {
float max_error = 0;
Nexus::PatchInfo &entry = (*index)[cell];
Sphere3f &sphere = entry.sphere;
float dist = Distance(sphere, frustum.ViewPoint());
if(dist < 0) return 1e20f;
float error = entry.error/frustum.Resolution(dist);
if(frustum.IsOutside(sphere.Center(), sphere.Radius()))
error /= 4;
return error;
}
void Policy::Init() {
ram_used = 0;
}
bool Policy::Expand(TNode &node) {
//expand if node error > target error
if(ram_used >= ram_size) return false;
//cerr << "Error: " << error << " node.error: " << node.error << endl;
return node.error > error;
}
void Policy::NodeVisited(Node *node) {
//TODO write this a bit more elegant.
//first we process arcs removed:
for(unsigned int i = 0; i < node->out.size(); i++) {
assert(!(node->out[i]->visited));
Frag &frag = node->frags[i];
for(unsigned int k = 0; k < frag.size(); k++) {
PatchEntry &entry = (*entries)[frag[k]];
ram_used += entry.ram_size;
}
}
vector<Node *>::iterator from;
for(from = node->in.begin(); from != node->in.end(); from++) {
assert((*from)->visited);
vector<Frag> &frags = (*from)->frags;
for(unsigned int i = 0; i < frags.size(); i++) {
if((*from)->out[i] == node) {
vector<unsigned int> &frag = frags[i];
for(unsigned int k = 0; k < frag.size(); k++) {
PatchEntry &entry = (*entries)[frag[k]];
ram_used -= entry.ram_size;
}
}
}
}
}
Prefetch::Prefetch(): thread(true), nexus(NULL) {}
Prefetch::~Prefetch() { signal(); waitfor(); }
void Prefetch::execute() {
assert(nexus != NULL);
while(1) {
if(get_signaled()) return;
if(cells.size() == 0 ||
nexus->patches.ram_used > nexus->patches.ram_size) {
relax(100);
continue;
}
cells_mx.lock();
pop_heap(cells.begin(), cells.end());
unsigned int cell = cells.back();
cells.pop_back();
patch_mx.lock();
Patch &patch = nexus->GetPatch(cell, false);
patch_mx.unlock();
cells_mx.unlock();
}
}
NexusMt::NexusMt(): vbo_mode(VBO_AUTO),
metric(NULL), mode(SMOOTH), prefetching(true) {
metric = new FrustumMetric();
metric->index = &index;
policy.error = 4;
policy.ram_size = 64000000;
prefetch.nexus = this;
}
NexusMt::~NexusMt() {}
bool NexusMt::Load(const string &filename, bool readonly) {
if(!Nexus::Load(filename, readonly)) return false;
LoadHistory();
policy.entries = &patches.patches;
use_colors = false;
use_normals = false;
use_textures = false;
use_data = false;
SetComponent(COLOR, true);
SetComponent(NORMAL, true);
SetComponent(TEXTURE, true);
SetComponent(DATA, true);
SetPrefetching(prefetching);
return true;
}
bool NexusMt::InitGL(Vbo mode, unsigned int vbosize) {
GLenum ret = glewInit();
if(ret != GLEW_OK) return false;
if(!GLEW_ARB_vertex_buffer_object) {
cerr << "No vbo available!" << endl;
vbo_mode = VBO_OFF;
}
patches.vbo_size = vbosize / patches.chunk_size;
if(vbo_mode == VBO_OFF)
patches.vbo_size = 0;
return true;
}
void NexusMt::Render() {
patches.Flush();
vector<unsigned int> cells;
metric->GetView();
policy.Init();
tri_total = 0;
tri_rendered = 0;
Extract(cells);
Draw(cells);
}
void NexusMt::Draw(vector<unsigned int> &cells) {
Frustumf frustum;
frustum.GetView();
glEnableClientState(GL_VERTEX_ARRAY);
if(use_colors)
glEnableClientState(GL_COLOR_ARRAY);
if(use_normals)
glEnableClientState(GL_NORMAL_ARRAY);
//TODO textures and data.
for(unsigned int i = 0; i < cells.size(); i++) {
unsigned int cell = cells[i];
Nexus::PatchInfo &entry = index[cell];
tri_total += entry.nface;
//frustum culling
if(frustum.IsOutside(entry.sphere.Center(), entry.sphere.Radius()))
continue;
tri_rendered += entry.nface;
Patch &patch = GetPatch(cell, false);
char *fstart;
char *vstart;
char *cstart;
char *nstart;
if(vbo_mode != VBO_OFF) {
unsigned int vbo_array;
unsigned int vbo_element;
patches.GetVbo(cell, vbo_element, vbo_array);
assert(vbo_element);
assert(vbo_array);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo_array);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, vbo_element);
fstart = NULL;
vstart = NULL;
cstart = (char *)(sizeof(float) * patch.cstart);
nstart = (char *)(sizeof(float) * patch.nstart);
} else {
fstart = (char *)patch.FaceBegin();
vstart = (char *)patch.VertBegin();
cstart = (char *)patch.ColorBegin();
nstart = (char *)patch.Norm16Begin();
}
glVertexPointer(3, GL_FLOAT, 0, vstart);
if(use_colors)
glColorPointer(4, GL_UNSIGNED_BYTE, 0, cstart);
if(use_normals)
glNormalPointer(GL_SHORT, 8, nstart);
switch(mode) {
case POINTS:
glDrawArrays(GL_POINTS, 0, patch.nv); break;
case PATCHES:
glColor3ub((cell * 27)%255, (cell * 37)%255, (cell * 87)%255);
case SMOOTH:
if(signature & NXS_FACES)
glDrawElements(GL_TRIANGLES, patch.nf * 3,
GL_UNSIGNED_SHORT, fstart);
else if(signature & NXS_STRIP)
glDrawElements(GL_TRIANGLE_STRIP, patch.nf,
GL_UNSIGNED_SHORT, fstart);
break;
case FLAT:
if(signature & NXS_FACES) {
glBegin(GL_TRIANGLES);
for(int i = 0; i < patch.nf; i++) {
unsigned short *f = patch.Face(i);
Point3f &p0 = patch.Vert(f[0]);
Point3f &p1 = patch.Vert(f[1]);
Point3f &p2 = patch.Vert(f[2]);
Point3f n = ((p1 - p0) ^ (p2 - p0));
glNormal3f(n[0], n[1], n[2]);
glVertex3f(p0[0], p0[1], p0[2]);
glVertex3f(p1[0], p1[1], p1[2]);
glVertex3f(p2[0], p2[1], p2[2]);
}
glEnd();
} else if(signature & NXS_STRIP) {
cerr << "Unsupported rendering mode sorry\n";
exit(0);
}
break;
default:
cerr << "Unsupported rendering mode sorry\n";
exit(0);
break;
}
}
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
}
void NexusMt::SetRamExtractionSize(unsigned int r_size) {
policy.ram_size = r_size/patches.chunk_size;
}
void NexusMt::SetMetric(NexusMt::MetricKind kind) {
//do nothing at the moment.
}
void NexusMt::SetError(float error) {
policy.error = error;
}
void NexusMt::SetVboSize(unsigned int _vbo_size) {
patches.vbo_size = _vbo_size;
}
void NexusMt::SetPrefetching(bool on) {
if(on && prefetch.Running()) return;
if(!on && !prefetch.Running()) return;
if(on) {
prefetch.cells.clear();
prefetch.start();
} else {
prefetch.signal();
prefetch.waitfor();
}
prefetching = on;
}
bool NexusMt::SetMode(Mode _mode) {
mode = _mode;
return true;
}
bool NexusMt::SetComponent(Component c, bool on) {
if(c == COLOR && (signature & NXS_COLORS))
use_colors = on;
if(c == NORMAL && (signature & NXS_NORMALS_SHORT))
use_normals = on;
if(c == TEXTURE && (signature & NXS_TEXTURES_SHORT))
use_textures = on;
if(c == DATA && (signature & NXS_DATA32))
use_data = on;
components = COLOR * use_colors + NORMAL * use_normals +
TEXTURE * use_textures + DATA * use_data;
return true;
}
bool NexusMt::SetComponents(unsigned int mask) {
SetComponent(COLOR, (mask & COLOR) != 0);
SetComponent(NORMAL, (mask & NORMAL) != 0);
SetComponent(TEXTURE, (mask & TEXTURE) != 0);
SetComponent(DATA, (mask & DATA) != 0);
components = mask;
if( ((mask & COLOR) && !(signature & NXS_COLORS)) ||
((mask & NORMAL) && !(signature & NXS_NORMALS_SHORT)) ||
((mask & TEXTURE) && !(signature & NXS_TEXTURES_SHORT)) ||
((mask & DATA) && !(signature & NXS_DATA32)) )
return false;
return true;
}
//TODO: nodes and fragment sholuld be kept in another way,
// so we can save that structure instead of the history!
void NexusMt::LoadHistory() {
//The last update erases everything.
assert(history[0].erased.size() == 0);
//maps cell -> node containing it
map<unsigned int, unsigned int> cell_node;
nodes.resize(history.size());
//building fragments and nodes.
unsigned int current_node = 0;
vector<Update>::iterator u;
for(u = history.begin(); u != history.end(); u++) {
Node &node = nodes[current_node];
node.error = 0;
//created cells belong to this node, we look also for max error.
for(unsigned int i = 0; i < (*u).created.size(); i++) {
unsigned int cell = (*u).created[i];
if(index[cell].error > node.error)
node.error = index[cell].error;
cell_node[cell] = current_node;
}
//Every erased cell already belonged to a node.
//we record for each node its cells.
map<unsigned int, vector<unsigned int> > node_erased;
for(unsigned int i = 0; i < (*u).erased.size(); i++) {
unsigned int cell = (*u).erased[i];
assert(cell_node.count(cell));
node_erased[cell_node[cell]].push_back(cell);
}
//for every node with erased cells we build a frag and
//put the corresponding cells in it.
map<unsigned int, vector<unsigned int> >::iterator e;
for(e = node_erased.begin(); e != node_erased.end(); e++) {
//Build a new Frag.
Frag fr;
float max_err = -1;
//Fill it with erased cells.
vector<unsigned int> &cells = (*e).second;
vector<unsigned int>::iterator k;
for(k = cells.begin(); k != cells.end(); k++) {
unsigned int cell = (*k);
assert(cell < index.size());
fr.push_back(cell);
if(index[cell].error > max_err)
max_err = index[cell].error;
}
//Add the new Frag to the node.
unsigned int floor_node = (*e).first;
Node &oldnode = nodes[floor_node];
oldnode.frags.push_back(fr);
if(node.error < max_err)
node.error = max_err;
//Update in and out of the nodes.
node.in.push_back(&oldnode);
oldnode.out.push_back(&node);
}
current_node++;
}
}
void NexusMt::ClearHistory() {
nodes.clear();
}
/*void NexusMt::ExtractFixed(vector<unsigned int> &selected, float error) {
std::vector<Node>::iterator n;
for(n = nodes.begin(); n != nodes.end(); n++)
(*n).visited = false;
std::queue<Node *> qnodo;
qnodo.push(&nodes[0]);
nodes[0].visited = true;
for( ; !qnodo.empty(); qnodo.pop()) {
Node &node = *qnodo.front();
std::vector<Frag>::iterator fragment;
std::vector<Node *>::iterator on;
for(on = node.out.begin(), fragment = node.frags.begin();
on != node.out.end(); ++on, ++fragment) {
if((*on)->visited) continue;
if(error < (*on)->error) { //need to expand this node.
qnodo.push(*on);
(*on)->visited = 1;
} else {
vector<unsigned int>::iterator cell;
for(cell=(*fragment).begin(); cell != (*fragment).end(); ++cell)
selected.push_back(*cell);
}
}
}
} */
void NexusMt::Extract(std::vector<unsigned int> &selected) {
std::vector<Node>::iterator n;
for(n = nodes.begin(); n != nodes.end(); n++) {
(*n).visited = false;
(*n).pushed = false;
}
std::vector<TNode> heap;
Node *root = &nodes[0];
VisitNode(root, heap);
while(heap.size()) {
pop_heap(heap.begin(), heap.end());
TNode tnode = heap.back();
heap.pop_back();
Node *node = tnode.node;
if(node->visited) continue;
bool expand = policy.Expand(tnode);
if(expand)
VisitNode(node, heap);
}
Select(selected);
}
/*void NexusMt::Extract(std::vector<unsigned int> &selected, Policy *policy) {
std::vector<Node>::iterator n;
for(n = nodes.begin(); n != nodes.end(); n++)
(*n).visited = false;
std::queue<Node *> qnodo;
qnodo.push(&nodes[0]);
nodes[0].visited = true;
for( ; !qnodo.empty(); qnodo.pop()) {
Node &node = *qnodo.front();
std::vector<Frag>::iterator i;
std::vector<Node *>::iterator on;
for(i = node.frags.begin(), on = node.out.begin();
i != node.frags.end(); i++, on++) {
if((*on)->visited) continue;
Frag &frag = (*i);
std::vector<unsigned int>::iterator cell;
for(cell = frag.begin(); cell != frag.end(); cell++) {
if(policy->Expand(*cell, index[*cell]))
policy->Visit(*on, qnodo);
}
}
}
Select(selected);
}*/
void NexusMt::Select(vector<unsigned int> &selected) {
selected.clear();
std::vector<Node>::iterator i;
for(i = nodes.begin(); i != nodes.end(); i++) {
Node &node = *i;
if(!node.visited)
continue;
std::vector<Node *>::iterator n;
std::vector<Frag>::iterator f;
for(n = node.out.begin(), f = node.frags.begin();
n != node.out.end(); n++, f++) {
if(!(*n)->visited || (*n)->error == 0) {
vector<unsigned int>::iterator c;
Frag &frag = (*f);
for(c = frag.begin(); c != frag.end(); c++)
selected.push_back(*c);
}
}
}
}
void NexusMt::VisitNode(Node *node, vector<TNode> &heap) {
if(node->visited) return;
vector<Node *>::iterator i;
for(i = node->in.begin(); i != node->in.end(); i++)
VisitNode(*i, heap);
for(unsigned int k = 0; k < node->out.size(); k++) {
Node *outnode = node->out[k];
float error = metric->GetError(node->frags[k]);
// if(node->pushed) continue
heap.push_back(TNode(outnode, error));
push_heap(heap.begin(), heap.end());
}
node->visited = true;
policy.NodeVisited(node);
}
Reference in New Issue View Git Blame Copy Permalink