예제 #1
0
void vsx_engine_param::dump_aliases_and_connections(vsx_string base_macro, vsx_command_list* command_result) {
  for (std::vector<vsx_engine_param_connection*>::reverse_iterator it = connections.rbegin(); it != connections.rend(); ++it) {
    if ((*it)->alias_connection && (*it)->dest->owner->component->name.find(base_macro) == 0)
    {
      //        0          1           2            3           4              5                 6
      //   param_alias [p_def] [-1=in / 1=out] [component] [parameter] [source_component] [source_parameter]
      (*it)->dest->dump_aliases_and_connections(base_macro, command_result);
      command_result->add_raw("param_alias "+
      (*it)->dest->name+":"+(*it)->dest->spec+" "+
      vsx_string_helper::i2s(owner->io)+" "+
      str_replace(base_macro,"$$name",str_replace(base_macro+".","$$name.",(*it)->dest->owner->component->name,1,0),1,0)+" "+
      (*it)->dest->name+" "+
      str_replace(base_macro,"$$name",str_replace(base_macro+".","$$name.",(*it)->src->owner->component->name,1,0),1,0)+" "+
      (*it)->src->name
      );
    } else
    if (((*it)->src->owner->component->name.find(base_macro+".") == 0
    || ((*it)->src->owner->component->name.find(base_macro) == 0
    && base_macro.size() == (*it)->src->owner->component->name.size())) ||
      base_macro.size() == 0)
    {
      //       0            1          2          3          4
      //  param_connect [in-comp] [in-param] [out-comp] [out-param]
      command_result->add_raw("param_connect "+
      str_replace(base_macro,"$$name",str_replace(base_macro+".","$$name.",(*it)->dest->owner->component->name,1,0),1,0)+" "+
      (*it)->dest->name+" "+
      str_replace(base_macro,"$$name",str_replace(base_macro+".","$$name.",(*it)->src->owner->component->name,1,0),1,0)+" "+
      (*it)->src->name
      );
    }
  }
}
예제 #2
0
void vsx_engine_param::set_string(vsx_string data)
{
  if (!data.size()) return;
  switch (module_param->type) {
    case VSX_MODULE_PARAM_ID_INT:
    case VSX_MODULE_PARAM_ID_FLOAT:
    case VSX_MODULE_PARAM_ID_DOUBLE:
    case VSX_MODULE_PARAM_ID_STRING:
    case VSX_MODULE_PARAM_ID_RESOURCE:
    case VSX_MODULE_PARAM_ID_SEQUENCE:
    case VSX_MODULE_PARAM_ID_FLOAT_ARRAY:
    set_string_index(data);
    return;
    case VSX_MODULE_PARAM_ID_FLOAT3:
    case VSX_MODULE_PARAM_ID_FLOAT4:
    case VSX_MODULE_PARAM_ID_QUATERNION:
    break;
  }
  vsx_string deli = ",";
  std::vector<vsx_string> data_parts;
  explode(data,deli,data_parts);
  for (size_t i = 0; i < data_parts.size(); i++)
  {
    set_string_index(data_parts[i],i);
  }

}
예제 #3
0
int count_whitespaces(vsx_string& s)
{
  size_t i = 0;
  while (i < s.size() && s[i] == ' ')
  {
    //printf("line: %d\n",__LINE__);
    i++;
  }
  return i;
}
예제 #4
0
  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);
    }
  }
예제 #5
0
파일: vsx_log.cpp 프로젝트: vovoid/vsxu
void log(vsx_string<>message, int level)
{
  #if PLATFORM_FAMILY == PLATFORM_FAMILY_UNIX
    openlog ("vsx_engine", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1);
    syslog(LOG_ERR,"%d: %s", level, message.c_str());
  #else
    vsx_printf(L"VSX_LOG: %hs\n", message.c_str() );
    /*
    if (log_level < level) return;
    printf("%s\n",message.c_str());
    FILE* fpo = 0;
    if (first) {
      fpo = fopen((log_dir+"vsx_engine.debug.log").c_str(),"w");
      first = 0;
    } else
      fpo = fopen((log_dir+"vsx_engine.debug.log").c_str(),"a");
    if (!fpo) return;
    fprintf(fpo, "%s\n", message.c_str() );
    fclose(fpo);*/
  #endif
}
void vsx_window_object_inspector::load_file(vsx_string filename) {
  //cout << "trying to load " << filename << endl;
  filename = vsx_get_data_path()+filename;
#ifdef VSXU_DEBUG
  printf("filename: %s\n", filename.c_str());
#endif
  std::vector<vsx_string> parts;
  vsx_string deli = ".";
  explode(filename, deli, parts);
  if (filename_loaded != filename)
  {
    if (parts[parts.size()-1] == "jpg") {
      view_type = 1; // image viewer
      texture_loaded = false;
#ifndef VSXU_PLAYER
      texture.texture_info.size_y = 0;
//      if (texture.valid)
      texture.unload();
      texture.init_opengl_texture();
      texture.load_jpeg(filename,false);
      //float screenaspect = screen_x/screen_y;
      //printf("%f, %f\n",texture.texture_info.size_x,texture.texture_info.size_y);
#endif
      filename_loaded = filename;
    } else
    if (parts[parts.size()-1] == "png") {
      //printf("png");
      //texture.unload();
      view_type = 1; // image viewer
      texture_loaded = false;
#ifndef VSXU_PLAYER
      texture.texture_info.size_y = 0;
//      if (texture.valid)
      texture.unload();
      texture.load_png(filename,false);
      //float screenaspect = screen_x/screen_y;

      //printf("%f, %f\n",texture.texture_info.size_x,texture.texture_info.size_y);
#endif
      filename_loaded = filename;

      //vsx_vector aa;
      //aa.x = 0.4/screenaspect*(texture.size_x/texture.size_y);
      //aa.y = 0.4;
      //aa.z = 0;
      //resize_to(aa);
      //move(1-0.4/screenaspect*(texture.size_x/texture.size_y),1,0);
      //resize_to(vsx_vector(0.1,0.1,0));
      //move(0.9,1,0);
    }
  }
}
예제 #7
0
파일: vsx_log_a.cpp 프로젝트: CJFocke/vsxu
void log_a(vsx_string message, int level)
{
	if (log_level < level) return;
	FILE* fpo = 0;
	if (a_first) {
		fpo = fopen((log_dir+"vsxu_artiste.debug.log").c_str(),"w");
		a_first = 0;
	} else
		fpo = fopen((log_dir+"vsxu_artiste.debug.log").c_str(),"a");
	if (!fpo) return;
	fprintf(fpo, "%s\n", message.c_str() );
	fclose(fpo);	
}
예제 #8
0
void vsx_widget_base_edit::set_filter_string(vsx_string &filter_string)
{
  if (filter_string.size() == 0) {
    if (filter_string_enabled) lines_visible = lines_visible_stack;
    filter_string_enabled = false;
    return;
  }

  if (!filter_string_enabled) lines_visible_stack = lines_visible;

  for (unsigned long i = 0; i < lines.size(); ++i) {
    if (lines[i].find(filter_string) != -1) lines_visible[i] = 0;
    else lines_visible[i] = 1;
  }
  scroll_y = 0;
  scrollbar_pos_y = 0;
  filter_string_enabled = true;
}
예제 #9
0
void vsx_statelist::add_visual_path(vsx_string new_visual_path)
{
  get_files_recursive(new_visual_path, &state_file_list,"","");

  #ifdef VSXU_DEBUG
  printf("getting files recursive: %s\n", (new_visual_path).c_str() );
  #endif

  for (std::list<vsx_string>::iterator it = state_file_list.begin(); it != state_file_list.end(); ++it) {
      state_info state;
      state.state_name = *it;
      state.state_name_suffix = state.state_name.substr(new_visual_path.size(),state.state_name.size() - new_visual_path.size() );
  #ifdef VSXU_DEBUG
      printf("adding state %s\n",(*it).c_str());
  #endif
      statelist.push_back(state);
  }
}
예제 #10
0
void vsx_engine_param::set_string_index(vsx_string data, int index) {
  if (alias) {
    alias_owner->set_string_index(data,index);
    return;
  }
  ++module->param_updates;
  ++module_param->updates;
  switch (module_param->type) {
    case VSX_MODULE_PARAM_ID_INT: {
      ((vsx_module_param_int*)module_param)->set_internal(atoi(data.c_str()));
      return;
    }
    case VSX_MODULE_PARAM_ID_FLOAT: {
      ((vsx_module_param_float*)module_param)->set_internal((float)atof(data.c_str()));
      return;
    }
    case VSX_MODULE_PARAM_ID_DOUBLE: {
      ((vsx_module_param_double*)module_param)->set_internal(atof(data.c_str()));
      return;
    }
    case VSX_MODULE_PARAM_ID_FLOAT3: {
      ((vsx_module_param_float3*)module_param)->set_internal((float)atof(data.c_str()),index);
      return;
    }
    case VSX_MODULE_PARAM_ID_FLOAT4: {
      ((vsx_module_param_float4*)module_param)->set_internal((float)atof(data.c_str()),index);
      return;
    }
    case VSX_MODULE_PARAM_ID_QUATERNION: {
      ((vsx_module_param_quaternion*)module_param)->set_internal((float)atof(data.c_str()),index);
      return;
    }
    case VSX_MODULE_PARAM_ID_STRING: {
      ((vsx_module_param_string*)module_param)->check_free();
      ((vsx_module_param_string*)module_param)->param_data[0] = data;
      return;
    }
    case VSX_MODULE_PARAM_ID_RESOURCE: {
      ((vsx_module_param_resource*)module_param)->check_free();
      data = str_replace("//", "/", data);
      ((vsx_module_param_resource*)module_param)->param_data[0] = data;
      return;
    }
    case VSX_MODULE_PARAM_ID_SEQUENCE: {
      ((vsx_module_param_sequence*)module_param)->param_data[index].set_string(data);
      return;
    }
    case VSX_MODULE_PARAM_ID_FLOAT_ARRAY: {
      clean_up_module_param(module_param);
      if (!((vsx_module_param_float_array*)module_param)->valid) {
        // data in our param is most likely pointing at invalid memory.
        vsx_float_array nn;
        nn.data = new vsx_array<float>;
        ((vsx_module_param_float_array*)module_param)->param_data[0] = nn;
      }

      vsx_string deli = ";";
      vsx_avector<vsx_string> parts;
      explode(data,deli,parts);
      ((vsx_module_param_float_array*)module_param)->param_data[0].data->clear();
      for (unsigned long i = 0; i < parts.size(); ++i) {
        (*((vsx_module_param_float_array*)module_param)->param_data[0].data).push_back(vsx_string_helper::s2f(parts[i]));
      }
      ((vsx_module_param_float_array*)module_param)->valid = true;
      return;
    }
  }
}
예제 #11
0
파일: main.cpp 프로젝트: Spartan190/vsxu
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);
}
예제 #12
0
파일: main.cpp 프로젝트: Spartan190/vsxu
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());*/

  //  }
}