//// Listener settings ////
void setupListener()
{
auto listener_node = *m_dev->emplace(m_dev->children().cend(), "listener");
auto listener_pos_node = *listener_node->emplace(listener_node->children().cend(), "pos");
add_position(listener_pos_node,
make_parameter(
[&] () { return m_scene.listener().Position(); },
[&] (const auto& elt) { m_scene.listener().Position(elt); }));
auto listener_orient_node = *listener_node->emplace(listener_node->children().cend(), "orientation");
auto listener_orient_addr = listener_orient_node->createAddress(OSSIA::Value::Type::TUPLE); // [ at_x at_y at_z up_x at_y at_z ]
auto tupl = new OSSIA::Tuple;
const auto& orient = m_scene.listener().Orientation();
tupl->value.push_back(new OSSIA::Float(orient.At()[0]));
tupl->value.push_back(new OSSIA::Float(orient.At()[1]));
tupl->value.push_back(new OSSIA::Float(orient.At()[2]));
tupl->value.push_back(new OSSIA::Float(orient.Up()[0]));
tupl->value.push_back(new OSSIA::Float(orient.Up()[1]));
tupl->value.push_back(new OSSIA::Float(orient.Up()[2]));
listener_orient_addr->pushValue(tupl);
listener_orient_addr->addCallback([&] (const OSSIA::Value* val) {
auto tpl = dynamic_cast<const OSSIA::Tuple*>(val);
if(tpl->value.size() != 6)
return;
auto at_x = dynamic_cast<const OSSIA::Float*>(tpl->value[0]);
auto at_y = dynamic_cast<const OSSIA::Float*>(tpl->value[1]);
auto at_z = dynamic_cast<const OSSIA::Float*>(tpl->value[2]);
auto up_x = dynamic_cast<const OSSIA::Float*>(tpl->value[3]);
auto up_y = dynamic_cast<const OSSIA::Float*>(tpl->value[4]);
auto up_z = dynamic_cast<const OSSIA::Float*>(tpl->value[5]);
if(!at_x || !at_y || !at_z || !up_x || !up_y || !up_z)
return;
m_scene.listener().Orientation(at_x->value, at_y->value, at_z->value, up_x->value, up_y->value, up_z->value);
});
auto listener_orient_at_node = *listener_orient_node->emplace(listener_orient_node->children().cend(), "at");
add_position(listener_orient_at_node,
make_parameter(
[&] () { return m_scene.listener().OrientationAt(); },
[&] (const auto& elt) { m_scene.listener().Orientation(elt, m_scene.listener().OrientationUp()); }
));
auto listener_orient_up_node = *listener_orient_node->emplace(listener_orient_node->children().cend(), "up");
add_position(listener_orient_up_node,
make_parameter(
[&] () { return m_scene.listener().OrientationUp(); },
[&] (const auto& elt) { m_scene.listener().Orientation(m_scene.listener().OrientationAt(), elt); }
));
}
void StorageReserveWidget::connects(){
QObject::connect(ui->plus_button, SIGNAL(clicked()), SLOT(add_position()));
QObject::connect(ui->minus_button, SIGNAL(clicked()), SLOT(remove_position()));
QObject::connect(ui->clear_button, SIGNAL(clicked()), SLOT(clear()));
QObject::connect(ui->close_button, SIGNAL(clicked()), SIGNAL(switch_pipes()));
QObject::connect(ui->tobase_button, SIGNAL(clicked()), SLOT(to_base()));
}
void on_sourceAdded(const OSSIA::Value* val)
{
auto str_val = dynamic_cast<const OSSIA::String*>(val);
if(!str_val)
return;
// Create the sound
auto sound_obj = new SoundObj{str_val->value};
sound_obj->setParent(&m_scene);
m_scene.sounds().insert(sound_obj);
auto& sound = sound_obj->sound;
// Create the callbacks and OSC device commands
auto src_node = *m_sourcesListNode->emplace(m_sourcesListNode->children().cend(), str_val->value);
// Position
auto src_pos_node = *src_node->emplace(src_node->children().cend(), "pos");
add_position(src_pos_node,
make_parameter(
[&] () { return sound.source().Position(); },
[&] (const auto& elt) { sound.source().Position(elt); }
));
// Enablement
add_child(src_node, "enabled", OSSIA::Value::Type::BOOL,
[&,sound_obj] (const OSSIA::Value* val) {
auto enablement_val = dynamic_cast<const OSSIA::Bool*>(val);
if(!enablement_val)
return;
sound_obj->enablementChanged(enablement_val->value);
});
// Audio file
add_child(src_node, "file", OSSIA::Value::Type::STRING,
[&,sound_obj] (const OSSIA::Value* val) {
auto filename_val = dynamic_cast<const OSSIA::String*>(val);
if(!filename_val)
return;
sound_obj->fileChanged(QString::fromStdString(filename_val->value));
});
}
struct model *load_obj_model(char *filename)
{
char dirname[1024];
char line[200];
struct model *model;
struct mesh *curmesh = NULL;
int fvp[20], fvt[20], fvn[20];
char *p, *s;
int i, n;
FILE *fp;
strlcpy(dirname, filename, sizeof dirname);
p = strrchr(dirname, '/');
if (!p) p = strrchr(dirname, '\\');
if (p) *p = 0;
else strlcpy(dirname, ".", sizeof dirname);
printf("loading obj model: %s\n", filename);
fp = fopen(filename, "r");
if (!fp) {
fprintf(stderr, "error: cannot load model '%s'\n", filename);
return NULL;
}
model = malloc(sizeof(struct model));
memset(model, 0, sizeof(struct model));
model->min[0] = model->min[1] = model->min[2] = 1e10;
model->max[0] = model->max[1] = model->max[2] = -1e10;
model->radius = 0;
while (1) {
if (!fgets(line, sizeof line, fp))
break;
s = strtok(line, SEP);
if (!s) {
continue;
} else if (!strcmp(s, "v")) {
char *x = strtok(NULL, SEP);
char *y = strtok(NULL, SEP);
char *z = strtok(NULL, SEP);
add_position(model, atof(x), atof(y), atof(z));
} else if (!strcmp(s, "vt")) {
char *u = strtok(NULL, SEP);
char *v = strtok(NULL, SEP);
add_texcoord(model, atof(u), atof(v));
} else if (!strcmp(s, "vn")) {
char *x = strtok(NULL, SEP);
char *y = strtok(NULL, SEP);
char *z = strtok(NULL, SEP);
add_normal(model, atof(x), atof(y), atof(z));
} else if (!strcmp(s, "f")) {
n = 0;
s = strtok(NULL, SEP);
while (s) {
if (*s) {
splitfv(s, fvp+n, fvt+n, fvn+n);
n++;
}
s = strtok(NULL, SEP);
}
for (i = 1; i < n - 1; i++) {
add_triangle(curmesh,
fvp[0], fvt[0], fvn[0],
fvp[i], fvt[i], fvn[i],
fvp[i+1], fvt[i+1], fvn[i+1]);
}
} else if (!strcmp(s, "mtllib")) {
s = strtok(NULL, SEP);
model->material = load_material(dirname, s);
} else if (!strcmp(s, "usemtl")) {
s = strtok(NULL, SEP);
curmesh = find_mesh(model, s);
}
}
model->radius = sqrtf(model->radius);
fclose(fp);
return model;
}
struct model *load_obj_from_memory(const char *filename, unsigned char *data, int len)
{
char dirname[1024];
char *line, *next, *p, *s;
struct model *model;
struct mesh *mesh;
int fvp[20], fvt[20], fvn[20];
int first, material;
int i, n;
printf("loading obj model '%s'\n", filename);
strlcpy(dirname, filename, sizeof dirname);
p = strrchr(dirname, '/');
if (!p) p = strrchr(dirname, '\\');
if (p) *p = 0;
else strlcpy(dirname, "", sizeof dirname);
mtl_count = 0;
position.len = 0;
texcoord.len = 0;
normal.len = 0;
element.len = 0;
part.len = 0;
first = 0;
material = 0;
data[len-1] = 0; /* over-write final newline to zero-terminate */
for (line = (char*)data; line; line = next) {
next = strchr(line, '\n');
if (next)
*next++ = 0;
s = strtok(line, SEP);
if (!s) {
continue;
} else if (!strcmp(s, "v")) {
char *x = strtok(NULL, SEP);
char *y = strtok(NULL, SEP);
char *z = strtok(NULL, SEP);
add_position(atof(x), atof(y), atof(z));
} else if (!strcmp(s, "vt")) {
char *u = strtok(NULL, SEP);
char *v = strtok(NULL, SEP);
add_texcoord(atof(u), atof(v));
} else if (!strcmp(s, "vn")) {
char *x = strtok(NULL, SEP);
char *y = strtok(NULL, SEP);
char *z = strtok(NULL, SEP);
add_normal(atof(x), atof(y), atof(z));
} else if (!strcmp(s, "f")) {
n = 0;
s = strtok(NULL, SEP);
while (s) {
if (*s) {
splitfv(s, fvp+n, fvn+n, fvt+n);
n++;
}
s = strtok(NULL, SEP);
}
for (i = 1; i < n - 1; i++) {
add_triangle(fvp[0], fvn[0], fvt[0],
fvp[i], fvn[i], fvt[i],
fvp[i+1], fvn[i+1], fvt[i+1]);
}
} else if (!strcmp(s, "mtllib")) {
s = strtok(NULL, SEP);
mtllib(dirname, s);
} else if (!strcmp(s, "usemtl")) {
if (element.len > first)
push_part(&part, first, element.len, material);
s = strtok(NULL, SEP);
material = usemtl(s);
first = element.len;
}
}
if (element.len > first)
push_part(&part, first, element.len, material);
printf("\t%d parts; %d vertices; %d triangles", part.len, vertex.len/8, element.len/3);
mesh = malloc(sizeof(struct mesh));
mesh->tag = TAG_MESH;
mesh->enabled = 1<<ATT_POSITION | 1<<ATT_NORMAL | 1<<ATT_TEXCOORD;
mesh->skel = NULL;
mesh->inv_bind_matrix = NULL;
mesh->count = part.len;
mesh->part = malloc(part.len * sizeof(struct part));
memcpy(mesh->part, part.data, part.len * sizeof(struct part));
glGenVertexArrays(1, &mesh->vao);
glGenBuffers(1, &mesh->vbo);
glGenBuffers(1, &mesh->ibo);
glBindVertexArray(mesh->vao);
glBindBuffer(GL_ARRAY_BUFFER, mesh->vbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh->ibo);
glBufferData(GL_ARRAY_BUFFER, vertex.len * 4, vertex.data, GL_STATIC_DRAW);
glEnableVertexAttribArray(ATT_POSITION);
glEnableVertexAttribArray(ATT_NORMAL);
glEnableVertexAttribArray(ATT_TEXCOORD);
glVertexAttribPointer(ATT_POSITION, 3, GL_FLOAT, 0, 32, (void*)0);
glVertexAttribPointer(ATT_NORMAL, 3, GL_FLOAT, 0, 32, (void*)20);
glVertexAttribPointer(ATT_TEXCOORD, 2, GL_FLOAT, 0, 32, (void*)12);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, element.len * 2, element.data, GL_STATIC_DRAW);
model = malloc(sizeof *model);
model->skel = NULL;
model->mesh = mesh;
model->anim = NULL;
return model;
}
