void run() {
if (p_updates != param_updates) {
p_updates = param_updates;
if (directory_path->get() != "") {
if (old_path != directory_path->get()) {
old_path = directory_path->get();
std::list<vsx_string> files;
//vsxfst tt;
vsx_string engine_resources_base_path = engine->filesystem->get_base_path();
get_files_recursive(engine_resources_base_path + DIRECTORY_SEPARATOR + directory_path->get(), &files);
files_list.reset_used(0);
for (std::list<vsx_string>::iterator it = files.begin(); it != files.end(); ++it) {
if ((*it).find(".svn/") == -1)
{
files_list.push_back( (*it).substr(engine_resources_base_path.size()+1));
}
}
}
}
if (files_list.size()) {
filename_count->set((float)files_list.size());
unsigned long fid = (unsigned long)floor(file_id->get());
if (fid >= files_list.size()) fid = files_list.size()-1;
filename_result->set(files_list[fid]);
}
}
}
void setup_font()
{
if
(
(cur_font != font_in->get()) ||
(cur_render_type !=render_type->get()) ||
(cur_glyph_size != glyph_size->get())
)
{
vsx::file *fp;
if ((fp = engine_state->filesystem->f_open(font_in->get().c_str())) == NULL)
{
printf("font not found: %s\n",cur_font.c_str());
return;
}
cur_font = font_in->get();
cur_render_type = render_type->get();
cur_glyph_size = glyph_size->get();
if (ftfont) {
delete ftfont;
ftfont = 0;
}
if (ftfont2) {
delete ftfont2;
ftfont2 = 0;
}
unsigned long size = engine_state->filesystem->f_get_size(fp);
char* fdata = (char*)malloc(size);
unsigned long bread = engine_state->filesystem->f_read((void*)fdata, size, fp);
if (bread == size)
{
switch (cur_render_type)
{
case 0:
ftfont = new FTGLTextureFont((unsigned char*)fdata, size);
break;
case 1:
ftfont = new FTGLPolygonFont((unsigned char*)fdata, size);
ftfont2 = new FTGLOutlineFont((unsigned char*)fdata, size);
break;
}
ftfont->FaceSize((unsigned int)round(cur_glyph_size));
ftfont->CharMap(ft_encoding_unicode);
if (ftfont2) {
ftfont2->FaceSize((unsigned int)round(cur_glyph_size));
ftfont2->CharMap(ft_encoding_unicode);
}
loading_done = true;
}
engine_state->filesystem->f_close(fp);
}
}
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters)
{
directory_path = (vsx_module_param_resource*)in_parameters.create(VSX_MODULE_PARAM_ID_RESOURCE,"directory_path");
directory_path->set("resources");
filename_result = (vsx_module_param_resource*)out_parameters.create(VSX_MODULE_PARAM_ID_RESOURCE,"filename_result");
filename_result->set("");
filename_count = (vsx_module_param_float*)out_parameters.create(VSX_MODULE_PARAM_ID_FLOAT,"filename_count");
filename_count->set(0.0f);
file_id = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT,"file_id");
file_id->set(0.0f);
p_updates = 0;
loading_done = true;
}
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters)
{
resource_in = (vsx_module_param_resource*)in_parameters.create(VSX_MODULE_PARAM_ID_RESOURCE,"resource_in");
resource_in->set("");
string_out = (vsx_module_param_string*)out_parameters.create(VSX_MODULE_PARAM_ID_STRING,"string_out");
string_out->set("");
loading_done = true;
}
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters)
{
loading_done = false;
filename = (vsx_module_param_resource*)in_parameters.create(VSX_MODULE_PARAM_ID_RESOURCE,"filename");
filename->set("");
current_filename = "";
result = (vsx_module_param_mesh*)out_parameters.create(VSX_MODULE_PARAM_ID_MESH,"mesh");
result->set_p(mesh);
first_run = true;
}
void run() {
string_out->set(resource_in->get());
}
void declare_params(vsx_module_param_list& in_parameters, vsx_module_param_list& out_parameters)
{
declare_run = false;
size = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "size");
size->set(1.0f);
angle = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "angle");
angle->set(0.0f);
text_in = (vsx_module_param_string*)in_parameters.create(VSX_MODULE_PARAM_ID_STRING, "text_in");
text_in->set("Vovoid VSX Ultra");
text_in->updates = 1;
font_in = (vsx_module_param_resource*)in_parameters.create(VSX_MODULE_PARAM_ID_RESOURCE, "font_in");
font_in->set("resources/fonts/pala.ttf");
cur_font = "";
limit_line = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "limit_line");
limit_line->set(-1.0f);
leading = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "leading");
leading->set(1.0f);
glyph_size = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "glyph_size");
glyph_size->set(24.0f);
cur_glyph_size = 24.0f;
render_type = (vsx_module_param_int*)in_parameters.create(VSX_MODULE_PARAM_ID_INT,"render_type");
render_type->set(0);
align = (vsx_module_param_int*)in_parameters.create(VSX_MODULE_PARAM_ID_INT,"align");
align->set(0);
cur_render_type = 0;
ftfont = 0;
ftfont2 = 0;
rotation_axis = (vsx_module_param_float3*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT3, "rotation_axis");
rotation_axis->set(0.0f, 0);
rotation_axis->set(1.0f, 1);
rotation_axis->set(0.0f, 2);
red = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "red");
red->set(1.0f);
green = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "green");
green->set(1.0f);
blue = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "blue");
blue->set(1.0f);
text_alpha = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "text_alpha");
text_alpha->set(1.0);
outline_alpha = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "outline_alpha");
outline_alpha->set(0.5);
outline_thickness = (vsx_module_param_float*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT, "outline_thickness");
outline_thickness->set(3.0);
outline_color = (vsx_module_param_float4*)in_parameters.create(VSX_MODULE_PARAM_ID_FLOAT4, "outline_color");
outline_color->set(0.0f, 0);
outline_color->set(0.0f, 1);
outline_color->set(0.0f, 2);
outline_color->set(0.0f, 3);
render_result = (vsx_module_param_render*)out_parameters.create(VSX_MODULE_PARAM_ID_RENDER,"render_out");
render_result->set(0);
declare_run = true;
gl_state = vsx_gl_state::get();
}
void run() {
if (filename->get() != current_filename) {
if (!verify_filesuffix(filename->get(),"obj")) {
filename->set(current_filename);
message = "module||ERROR! This is not a OBJ mesh file!";
return;
} else message = "module||ok";
current_filename = filename->get();
vsxf_handle *fp;
//printf("a\n");
if ((fp = engine->filesystem->f_open(current_filename.c_str(), "r")) == NULL)
{
return;
}
char buf[65535];
vsx_string line;
vsx_array<vsx_vector> vertices; //vertices.set_allocation_increment(15000);
vsx_array<vsx_vector> normals; //normals.set_allocation_increment(15000);
vsx_array<vsx_tex_coord> texcoords; //texcoords.set_allocation_increment(15000);
//mesh->data->vertex_tex_coords.reset_used();
mesh->data->clear();
//mesh->data->vertices.set_allocation_increment(15000);
//mesh->data->vertex_normals.set_allocation_increment(15000);
//mesh->data->vertex_tex_coords.set_allocation_increment(15000);
//mesh->data->faces.set_allocation_increment(15000);
int face_cur = 0;
//printf("b\n");
bool found_normals = false;
bool found_texcoords = false;
if (preserve_uv_coords->get()) {
mesh->data->vertices.reset_used();
mesh->data->vertex_tex_coords.reset_used();
mesh->data->vertex_normals.reset_used();
mesh->data->faces.reset_used();
while (engine->filesystem->f_gets(buf,65535,fp)) {
line = buf;
if (line[line.size()-1] == 0x0A) line.pop_back();
if (line[line.size()-1] == 0x0D) line.pop_back();
//printf("reading line: %s\n",line.c_str());
//printf("c\n");
if (line.size()) {
vsx_avector<vsx_string> parts;
vsx_string deli = " ";
explode(line, deli, parts);
if (parts[0] == "v") {
//printf("v\n");
//mesh->data->vertices.push_back(vsx_vector(s2f(parts[1]),s2f(parts[2]),s2f(parts[3])));
vertices.push_back(vsx_vector(s2f(parts[1]),s2f(parts[2]),s2f(parts[3])));
} else
if (parts[0] == "vt") {
//printf("vt\n");
vsx_tex_coord a;
a.s = (s2f(parts[1]));
a.t = (s2f(parts[2]));
//printf("%f :: %f\n",a.s,a.t);
texcoords.push_back(a);
//vsx_vector__(s2f(parts[1]),s2f(parts[2]),s2f(parts[3])));
found_texcoords = true;
} else
if (parts[0] == "vn") {
//printf("vn\n");
//printf("normal\n");
normals.push_back(vsx_vector(s2f(parts[1]),s2f(parts[2]),s2f(parts[3])));
found_normals = true;
//mesh->data->vertex_normals.push_back(vsx_vector__(s2f(parts[1]),s2f(parts[2]),s2f(parts[3])));
} else
if (parts[0] == "f") {
//printf("f1\n");
//printf("face\n");
//if (parts.size() == 4) {
//printf("num texcoords %d\n",texcoords.size());
vsx_face ff;
// vsx_avector<vsx_string> parts2;
vsx_string deli2 = "/";
/* explode(parts[1], deli2, parts2);
ff.c = s2i(parts2[0])-1;
mesh->data->vertex_normals[ff.c] = normals[s2i(parts2[1])-1];
mesh->data->vertex_tex_coords[ff.c] = texcoords[s2i(parts2[1])-1];
explode(parts[2], deli2, parts2);
ff.b = s2i(parts2[0])-1;
mesh->data->vertex_normals[ff.b] = normals[s2i(parts2[1])-1];
mesh->data->vertex_tex_coords[ff.b] = texcoords[s2i(parts2[1])-1];
explode(parts[3], deli2, parts2);
ff.a = s2i(parts2[0])-1;
mesh->data->vertex_normals[ff.a] = normals[s2i(parts2[1])-1];
mesh->data->vertex_tex_coords[ff.a] = texcoords[s2i(parts2[1])-1];*/
vsx_avector<vsx_string> parts2;
explode(parts[1], deli2, parts2);
vsx_avector<vsx_string> parts3;
explode(parts[2], deli2, parts3);
vsx_avector<vsx_string> parts4;
explode(parts[3], deli2, parts4);
ff.c = face_cur; //s2i(parts2[0])-1;
ff.b = face_cur+1; //s2i(parts3[0])-1;
ff.a = face_cur+2; //s2i(parts4[0])-1;
//printf("f2\n");
//printf("reading line: %s\n",line.c_str());
int id;
id = s2i(parts2[0])-1; if (id < 0) id=0;
mesh->data->vertices[ff.a] = vertices[id];
id = s2i(parts3[0])-1; if (id < 0) id=0;
mesh->data->vertices[ff.b] = vertices[id];
id = s2i(parts4[0])-1; if (id < 0) id=0;
mesh->data->vertices[ff.c] = vertices[id];
if (found_texcoords && found_normals) {
if (parts2[1] != "") {
mesh->data->vertex_tex_coords[ff.a] = texcoords[s2i(parts2[1])-1];
mesh->data->vertex_tex_coords[ff.b] = texcoords[s2i(parts3[1])-1];
mesh->data->vertex_tex_coords[ff.c] = texcoords[s2i(parts4[1])-1];
}
if (parts2[2] != "") {
mesh->data->vertex_normals[ff.a] = normals[s2i(parts2[2])-1];
mesh->data->vertex_normals[ff.b] = normals[s2i(parts3[2])-1];
mesh->data->vertex_normals[ff.c] = normals[s2i(parts4[2])-1];
}
} else
if (found_normals) {
if (parts2[2] != "") {
mesh->data->vertex_normals[ff.a] = normals[s2i(parts2[2])-1];
mesh->data->vertex_normals[ff.b] = normals[s2i(parts3[2])-1];
mesh->data->vertex_normals[ff.c] = normals[s2i(parts4[2])-1];
}
} else
if (found_texcoords) {
if (parts2[1] != "") {
mesh->data->vertex_tex_coords[ff.a] = texcoords[s2i(parts2[1])-1];
mesh->data->vertex_tex_coords[ff.b] = texcoords[s2i(parts3[1])-1];
mesh->data->vertex_tex_coords[ff.c] = texcoords[s2i(parts4[1])-1];
}
}
//printf("%d ",s2i(parts2[1]));
//printf("%d ",s2i(parts3[1]));
//printf("%d\n",s2i(parts4[1]));
//printf("f3\n");
/*printf("ida: %d\n",s2i(parts2[1]));
printf("orig coords: %f %f\n",texcoords[s2i(parts2[1])-1].s,texcoords[s2i(parts2[1])-1].t);
printf("texcoord s: %f %f\n",mesh->data->vertex_tex_coords[ff.a].s,mesh->data->vertex_tex_coords[ff.a].t);
printf("idb: %d\n",s2i(parts3[1]));
printf("orig coords: %f %f\n",texcoords[s2i(parts3[1])-1].s,texcoords[s2i(parts3[1])-1].t);
printf("texcoord s: %f %f\n",mesh->data->vertex_tex_coords[ff.a].s,mesh->data->vertex_tex_coords[ff.a].t);
printf("idc: %d\n",s2i(parts4[1]));
printf("orig coords: %f %f\n",texcoords[s2i(parts4[1])-1].s,texcoords[s2i(parts4[1])-1].t);
printf("texcoord s: %f %f\n",mesh->data->vertex_tex_coords[ff.a].s,mesh->data->vertex_tex_coords[ff.a].t);
*/
face_cur += 3;
mesh->data->faces.push_back(ff);
//printf("f4\n");
//}
}
}
}
} else {
while (engine->filesystem->f_gets(buf,65535,fp)) {
line = buf;
if (line[line.size()-1] == 0x0A) line.pop_back();
if (line[line.size()-1] == 0x0D) line.pop_back();
if (line.size()) {
vsx_avector<vsx_string> parts;
vsx_string deli = " ";
explode(line, deli, parts);
if (parts[0] == "v") {
mesh->data->vertices.push_back(vsx_vector(s2f(parts[1]),s2f(parts[2]),s2f(parts[3])));
} else
if (parts[0] == "f") {
vsx_face ff;
vsx_string deli2 = "/";
vsx_avector<vsx_string> parts2;
explode(parts[1], deli2, parts2);
vsx_avector<vsx_string> parts3;
explode(parts[2], deli2, parts3);
vsx_avector<vsx_string> parts4;
explode(parts[3], deli2, parts4);
ff.c = s2i(parts2[0])-1;
ff.b = s2i(parts3[0])-1;
ff.a = s2i(parts4[0])-1;
//printf("face %d %d %d %d\n", mesh->data->faces.size(), ff.a, ff.b, ff.c);
mesh->data->faces.push_back(ff);
}
}
}
}
engine->filesystem->f_close(fp);
loading_done = true;
mesh->timestamp = (int)(engine->real_vtime*1000.0f);
#ifdef VSXU_DEBUG
//printf("mesh timestamp: %d\n", (int)mesh->timestamp);
#endif
}
result->set_p(mesh);
}
void run() {
if (filename->get() != current_filename) {
if (!verify_filesuffix(filename->get(),"vxm")) {
filename->set(current_filename);
message = "module||ERROR! This is not a OBJ mesh file!";
return;
} else message = "module||ok";
current_filename = filename->get();
vsxf_handle *fp;
//printf("a\n");
if ((fp = engine->filesystem->f_open(current_filename.c_str(), "r")) == NULL)
return;
char tag[4];
engine->filesystem->f_read((void*)&tag,sizeof(char) * 4,fp);
vsx_string line;
line = tag;
//printf("vxm line read: %s\n",line.c_str());
if (line == "vxm")
{
//printf("found vxm file\n");
size_t vert_size;
engine->filesystem->f_read((void*)&vert_size,sizeof(size_t) * 1,fp);
if (vert_size)
{
//printf("vertex bytes: %d\n",vert_size);
void* vert_p = malloc(vert_size);
engine->filesystem->f_read(vert_p,vert_size,fp);
mesh->data->vertices.set_data((vsx_vector*)vert_p,vert_size / sizeof(vsx_vector));
}
size_t normals_size;
engine->filesystem->f_read((void*)&normals_size,sizeof(size_t) * 1,fp);
if (normals_size)
{
//printf("normals bytes: %d\n",normals_size);
void* norm_p = malloc( normals_size);
engine->filesystem->f_read(norm_p,normals_size,fp);
mesh->data->vertex_normals.set_data((vsx_vector*)norm_p,normals_size / sizeof(vsx_vector));
}
size_t tex_coords_size;
engine->filesystem->f_read((void*)&tex_coords_size,sizeof(size_t) * 1,fp);
if (tex_coords_size)
{
//printf("texcoord count: %d\n",tex_coords_size);
void* texcoords_p = malloc(tex_coords_size);
engine->filesystem->f_read(texcoords_p,tex_coords_size,fp);
mesh->data->vertex_tex_coords.set_data((vsx_tex_coord*)texcoords_p,tex_coords_size / sizeof(vsx_tex_coord));
}
size_t faces_size;
engine->filesystem->f_read((void*)&faces_size,sizeof(size_t) * 1,fp);
if (faces_size)
{
//printf("face count: %d\n",faces_size);
void* faces_p = malloc(faces_size);
engine->filesystem->f_read(faces_p,faces_size,fp);
mesh->data->faces.set_data((vsx_face*)faces_p,faces_size / sizeof(vsx_face));
}
}
engine->filesystem->f_close(fp);
loading_done = true;
mesh->timestamp++;
}
//result->set_p(mesh);
// mesh->data->vertices[0] = vsx_vector__(0,0,0);
// mesh->data->vertex_colors[0] = vsx_color__(center_color->get(0),center_color->get(1),center_color->get(2),center_color->get(3));
//balls.Update(engine->real_dtime);
// a += 0.02;
//balls.Render();
// if (first_run || n_rays != (int)num_rays->get()) {
// mesh->data->vertex_tex_coords[0] = vsx_vector__(0,0,0);
// mesh->data->vertices.reset_used();
// mesh->data->faces.reset_used();
//printf("generating random points\n");
/* for (int i = 1; i < (int)num_rays->get(); ++i) {
mesh->data->vertices[i*2].x = (rand()%10000)*0.0001-0.5;
mesh->data->vertices[i*2].y = (rand()%10000)*0.0001-0.5;
mesh->data->vertices[i*2].z = (rand()%10000)*0.0001-0.5;
mesh->data->vertex_colors[i*2] = vsx_color__(0,0,0,0);
mesh->data->vertex_tex_coords[i*2] = vsx_vector__(0,1,0);
mesh->data->vertices[i*2+1].x = (rand()%10000)*0.0001-0.5;
mesh->data->vertices[i*2+1].y = (rand()%10000)*0.0001-0.5;
mesh->data->vertices[i*2+1].z = (rand()%10000)*0.0001-0.5;
mesh->data->vertex_colors[i*2+1] = vsx_color__(0,0,0,0);
mesh->data->vertex_tex_coords[i*2+1] = vsx_vector__(1,0,0);
mesh->data->faces[i-1].a = 0;
mesh->data->faces[i-1].b = i*2;
mesh->data->faces[i-1].c = i*2+1;
n_rays = (int)num_rays->get();
}
first_run = false;
} */
/*mesh->data->vertices = balls.vertices;
mesh->data->vertex_normals = balls.vertex_normals;
mesh->data->vertex_tex_coords = balls.vertex_tex_coords;
mesh->data->faces = balls.faces;
result->set_p(mesh);*/
/*else {
if (num_points->get() < mesh->data->vertices.size()) {
mesh->data->vertices.reset_used((int)num_points->get());
} else
if (num_points->get() > mesh->data->vertices.size()) {
for (int i = mesh->data->vertices.size(); i < (int)num_points->get(); ++i) {
mesh->data->vertices[i].x = (rand()%10000)*0.0001*scaling->get(0);
mesh->data->vertices[i].y = (rand()%10000)*0.0001*scaling->get(1);
mesh->data->vertices[i].z = (rand()%10000)*0.0001*scaling->get(2);
}
}
}
printf("randMesh done %d\n",mesh->data->vertices.size());*/
// }
}
