Ejemplo n.º 1
0
Archivo: dos.c Proyecto: prophile/dim3
void redraw_windows(void)
{
        // center
        
	select_clear();
	main_wind_center_position_in_map();

        // some defaults
        
	magnify_factor=magnify_factor_default;
	main_wind_set_view(vw_3_panel);
	main_wind_set_perspective(ps_perspective);
	
		// redraw
	
    main_wind_tool_default();
	
	menu_fix_enable();
	main_wind_tool_fix_enable();
	
    SelectWindow(mainwind);
    
	main_wind_draw();
	texture_palette_reset();
}
Ejemplo n.º 2
0
void piece_mesh_invert_normals(bool poly_only)
{
	int				n,k,sel_count,type,mesh_idx,poly_idx;
	map_mesh_type	*mesh;
	
	sel_count=select_count();
	
	for (n=0;n!=sel_count;n++) {
		select_get(n,&type,&mesh_idx,&poly_idx);
		if (type!=item_map_mesh) continue;
		
			// invert the poly
			
		mesh=&map.mesh.meshes[mesh_idx];
		
		if (poly_only) {
			piece_mesh_poly_invert_normals(&mesh->polys[poly_idx]);
		}
		else {
			for (k=0;k!=mesh->npoly;k++) {
				piece_mesh_poly_invert_normals(&mesh->polys[k]);
			}
		}
	}
	
	main_wind_draw();
}
Ejemplo n.º 3
0
void piece_tesselate(bool mesh)
{
	int				n,sel_count,type,mesh_idx,poly_idx;
	
	map_undo_push();
	
	sel_count=select_count();
	
	for (n=0;n!=sel_count;n++) {
		select_get(n,&type,&mesh_idx,&poly_idx);
		if (type==item_map_mesh) {
			if (mesh) {
				map_mesh_tesselate(&map,mesh_idx);
			}
			else {
				map_mesh_poly_tesselate(&map,mesh_idx,poly_idx);
			}
			view_vbo_mesh_rebuild(mesh_idx);
		}
	}

	select_clear();
	
	main_wind_draw();
}
Ejemplo n.º 4
0
void palette_node_save(void)
{
    int						type,main_idx,poly_idx;
    node_type				*node;

    // get node

    select_get(0,&type,&main_idx,&poly_idx);
    node=&map.nodes[main_idx];

    // set controls

    dialog_get_text(palette_node_wind,kNodeName,0,node->name,name_str_len);
    node->event_id=dialog_get_int(palette_node_wind,kNodeEventID,0);
    node->ang.x=dialog_get_float(palette_node_wind,kNodeAngleX,0);
    node->ang.y=dialog_get_float(palette_node_wind,kNodeAngleY,0);
    node->ang.z=dialog_get_float(palette_node_wind,kNodeAngleZ,0);
    node->follow_camera=dialog_get_boolean(palette_node_wind,kNodeFollowCamera,0);

    // need to reset node combo

    main_wind_tool_fill_node_combo();

    main_wind_draw();
}
Ejemplo n.º 5
0
void piece_select_more(void)
{
	int					n,t,t2,sel_count,type,mesh_idx,poly_idx;
	d3pnt				*pt1,*pt2;
	map_mesh_type		*mesh;
	map_mesh_poly_type	*poly;

		// select more polygons
		
	sel_count=select_count();
	
	for (n=0;n!=sel_count;n++) {
	
		select_get(n,&type,&mesh_idx,&poly_idx);
		if (type!=item_map_mesh) continue;
		
		mesh=&map.mesh.meshes[mesh_idx];
		poly=&mesh->polys[poly_idx];
		
		for (t=0;t!=poly->ptsz;t++) {
			t2=t+1;
			if (t2==poly->ptsz) t2=0;
			
			pt1=&mesh->vertexes[poly->v[t]];
			pt2=&mesh->vertexes[poly->v[t2]];
			
			piece_select_more_check_edge(pt1,pt2);
		}
	}
	
	main_wind_draw();
}
Ejemplo n.º 6
0
void texture_edit_switch(int texture_idx)
{
		// clicking again leaves

	if (state.mode==app_mode_map) {
		if ((state.map.texture_edit_idx!=-1) && (state.map.texture_edit_idx==texture_idx)) {
			state.map.texture_edit_idx=-1;
		}
		else {
			state.map.texture_edit_idx=texture_idx;
		}
		map_palette_reset();
		list_palette_set_level(&map_palette,0);
	}
	else {
		if ((state.model.texture_edit_idx!=-1) && (state.model.texture_edit_idx==texture_idx)) {
			state.model.texture_edit_idx=-1;
		}
		else {
			state.model.texture_edit_idx=texture_idx;
		}
		list_palette_set_level(&model_palette,0);
	}
	
	texture_edit_frame_click_idx=-1;

	main_wind_draw();
}
Ejemplo n.º 7
0
void piece_move(int move_x,int move_y,int move_z)
{
	int				n,sel_count,type,mesh_idx,poly_idx;
	d3pnt			mov_pnt;
	
	map_undo_push();
	
	sel_count=select_count();
	
	mov_pnt.x=move_x;
	mov_pnt.y=move_y;
	mov_pnt.z=move_z;
	
	for (n=0;n!=sel_count;n++) {
		select_get(n,&type,&mesh_idx,&poly_idx);
		if (type==item_map_mesh) {
			if (!map.mesh.meshes[mesh_idx].flag.lock_move) {
				map_mesh_move(&map,mesh_idx,&mov_pnt);
				view_force_grid(mesh_idx,TRUE);
				view_vbo_mesh_rebuild(mesh_idx);
			}
		}
	}
	
	main_wind_draw();
}
Ejemplo n.º 8
0
void model_file_import_mesh_obj(bool replace)
{
	char			path[1024],err_str[256];
	bool			found_normals;
    
	os_set_arrow_cursor();
	if (!os_load_file("Select an OBJ to Import",path,"obj")) return;
	
	if (state.model.cur_mesh_idx==-1) state.model.cur_mesh_idx=0;
	
	if (!model_import_obj(path,replace,&found_normals,err_str)) {
		os_dialog_alert("OBJ Import",err_str);
		return;
	}

		// finish setup
		
	model_vertex_mask_clear_sel(state.model.cur_mesh_idx);
	model_vertex_mask_clear_hide(state.model.cur_mesh_idx);

	model_poly_mask_clear_sel(state.model.cur_mesh_idx);
	model_poly_mask_clear_hide(state.model.cur_mesh_idx);
	
	main_wind_draw();
}
Ejemplo n.º 9
0
void model_palette_click_mesh(int mesh_idx,bool double_click)
{
	int						n;
	d3pnt					move_pnt;
	model_vertex_type		*vtx;
	model_bone_type			*bone;
	model_mesh_type			*mesh;

	mesh=&model.meshes[mesh_idx];
	
	if (!double_click) return;

		// regular clicks

	switch (model_palette.item_pane.click.id) {

		case kMeshPropertyMovement:
		
				// get change
				
			move_pnt.x=mesh->import_move.x-mesh->org_import_move.x;
			move_pnt.y=mesh->import_move.y-mesh->org_import_move.y;
			move_pnt.z=mesh->import_move.z-mesh->org_import_move.z;
			memmove(&mesh->org_import_move,&mesh->import_move,sizeof(d3pnt));
			
				// now set the vertexes
				
			vtx=mesh->vertexes;

			for (n=0;n!=mesh->nvertex;n++) {
				vtx->pnt.x+=move_pnt.x;
				vtx->pnt.y+=move_pnt.y;
				vtx->pnt.z+=move_pnt.z;

				vtx++;
			}

				// if this is mesh 0, then move the
				// bones

			if (mesh_idx==0) {

				bone=model.bones;

				for (n=0;n!=model.nbone;n++) {
					bone->pnt.x+=move_pnt.x;
					bone->pnt.y+=move_pnt.y;
					bone->pnt.z+=move_pnt.z;

					bone++;
				}
			}

			main_wind_draw();
				
			break;
			
	}
}
Ejemplo n.º 10
0
bool liquid_reflection_maps_create_process(int nliq,char *err_str)
{
	int				n,txt_idx;
	char			base_path[1024],dir_path[1024],
					map_name[256],str[256];
	
		// base path
		
	file_paths_data_default(&file_path_setup,base_path,"Bitmaps/Textures",NULL,NULL);
	
		// create folders if they don't exist
		
	sprintf(dir_path,"%s/ReflectionMaps",base_path);
	os_create_directory(dir_path);
	
	light_map_texture_map_folder_name(map_name);
	
	sprintf(dir_path,"%s/ReflectionMaps/%s",base_path,map_name);
	os_create_directory(dir_path);
		
		// clear the textures and
		// start mesh-poly and/or liquid setup
		
	progress_next_title("Liquid Reflection Map: Setup");
		
	map_delete_texture(&map,liquid_reflection_texture_start_idx,(liquid_reflection_texture_start_idx+max_liquid_reflection_map_textures));
	
	liquid_reflection_map_setup();
	liquid_reflection_map_bitmap_pixel_start();
	
		// create a ray traced light map
		// for all the polys

	txt_idx=liquid_reflection_texture_start_idx;
		
	for (n=0;n!=map.liquid.nliquid;n++) {

		sprintf(str,"Liquid Reflection Map: Rendering Liquid %d/%d",(n+1),nliq);
		progress_next_title(str);
			
		if (!liquid_reflection_map_run_for_liquid(txt_idx,n,base_path,map_name,err_str)) {
			liquid_reflection_map_bitmap_pixel_free();
			return(FALSE);
		}
		
		txt_idx++;
	}
	
		// free textures and polys
		
	progress_next_title("Liquid Reflection Map: Finishing");

	liquid_reflection_map_bitmap_pixel_free();

	main_wind_draw();
	
	return(TRUE);
}
Ejemplo n.º 11
0
void change_model_wind(d3pnt *start_pnt,bool shift_on,bool rotate_on,bool size_on)
{
	int						old_magnify_z;
	d3rect					mbox;
	d3pnt					pnt,last_pnt,old_shift;
	d3ang					old_ang;
	
		// rotate, shift, or size the model

	last_pnt.x=last_pnt.y=-1;
	
	old_shift.x=state.model.shift.x;
	old_shift.y=state.model.shift.y;
	
	old_ang.x=state.model.ang.x;
	old_ang.y=state.model.ang.y;
	
	old_magnify_z=state.model.magnify_z;

	model_wind_get_box(&mbox);
	
	while (!os_track_mouse_location(&pnt,&mbox)) {
		
		if ((last_pnt.x==pnt.x) && (last_pnt.y==pnt.y)) continue;
		memmove(&last_pnt,&pnt,sizeof(d3pnt));
			
		if (shift_on) {
			state.model.shift.x=old_shift.x+((last_pnt.x-start_pnt->x)*4);
			state.model.shift.y=old_shift.y-((last_pnt.y-start_pnt->y)*4);
		}
		if (rotate_on) {
			state.model.ang.x=old_ang.x-(float)((last_pnt.y-start_pnt->y)/5);
			state.model.ang.y=old_ang.y+(float)((last_pnt.x-start_pnt->x)/5);
		}
		if (size_on) {
			state.model.magnify_z=old_magnify_z+((last_pnt.y-start_pnt->y)*2);
		}
		
		if (state.model.play_mode==model_play_mode_stop) main_wind_draw();
	
	}
	
	if (state.model.play_mode==model_play_mode_stop) main_wind_draw();
}
Ejemplo n.º 12
0
void map_palette_click(d3pnt *pnt,bool double_click)
{
	bool				old_open;
	
		// check if open changes
	
	old_open=list_palette_is_open(&map_palette);

		// click

	if (!list_palette_click(&map_palette,pnt,double_click)) {
		if (old_open!=list_palette_is_open(&map_palette)) main_wind_draw();
		return;
	}

		// can't do anything if no map

	if (!state.map.map_open) return;
		
		// if texture window is up, texture properties

	if (state.map.texture_edit_idx!=-1) {
		map_palette_click_texture(state.map.texture_edit_idx,map_palette.item_pane.click.id,double_click);
		main_wind_draw();
		return;
	}
	
		// click by level
		
	switch (list_palette_get_level(&map_palette)) {
		case 0:
			map_palette_click_level_0(double_click);
			break;
		case 1:
			map_palette_click_level_1(double_click);
			break;
		case 2:
			map_palette_click_level_2(double_click);
			break;
	}
	
	main_wind_draw();
}
Ejemplo n.º 13
0
void texture_palette_click(d3pnt *pnt,bool dblclick)
{
	int				nsel,page,page_cnt,yadd;
	
		// move within palette
		
	pnt->y-=txt_palette_y;
	
		// texture page change
		
	if (pnt->x<16) {
		page_cnt=max_map_texture/txt_wind_per_page;
		yadd=(txt_wind_row_count*txt_pixel_sz)/page_cnt;
		page=pnt->y/yadd;
		if (txt_page!=page) {
			txt_page=page;
			main_wind_draw();
		}
		return;
	}
	
		// find clicked texture
	
	nsel=((pnt->y/txt_pixel_sz)*txt_wind_column_count)+((pnt->x-16)/txt_pixel_sz);
	nsel+=(txt_page*txt_wind_per_page);
		
		// double clicks
		
	if (dblclick) {
		dialog_texture_setting_run(nsel);
		main_wind_draw();
		return;
	}
    
		// single clicks
		
	if (map.textures[nsel].frames[0].bitmap.gl_id==-1) return;
	
	texture_palette_put_selected_texture(nsel);
	texture_palette_reset();
	main_wind_draw();
}
Ejemplo n.º 14
0
void tool_wind_magnify_scroll(int delta)
{
	magnify_factor-=delta;
	if (magnify_factor<5) magnify_factor=5;
	if (magnify_factor>210) magnify_factor=210;
	
	SetControlValue(magnify_slider,magnify_factor);

	top_view_reset();
    main_wind_draw();
}
Ejemplo n.º 15
0
void map_palette_scroll_into_view(int item_id,int item_idx)
{
		// can only scroll into view
		// on map items page

	if (!list_palette_get_level(&map_palette)!=0) return;

	map_palette_fill_level_0();
	list_palette_scroll_item_into_view(&map_palette,item_id,item_idx);

	main_wind_draw();
}
Ejemplo n.º 16
0
void model_view_draw_play(void)
{
	int					n,cur_tick,
						old_pose_move_idx;
	
		// if no current animation, just do no pose for animated textures
		
	if ((state.model.cur_animate_idx==-1) && (state.model.play_mode!=model_play_mode_blend)) {
		main_wind_draw();
		return;
	}
	
		// clear the draw setup
		
	model_draw_setup_clear(&model,&draw_setup);
	
		// get the current animation tick
		// and divide by 4 if we are in slow play
		
	cur_tick=time_get();
	if (state.model.play_mode==model_play_mode_slow) cur_tick=cur_tick>>2;
	
		// calculate the animation

	old_pose_move_idx=state.model.blend[0].pose_move_idx;

	if (state.model.play_mode!=model_play_mode_blend) {
		model_play_draw_calc_animation(cur_tick,state.model.cur_animate_idx,0,TRUE);
	}
	else {
		for (n=0;n!=max_model_blend_animation;n++) {
			if (state.model.blend[n].animate_idx!=-1) {
				model_play_draw_calc_animation(cur_tick,state.model.blend[n].animate_idx,n,(n==0));
			}
		}
	}

		// if prev/next animation type
		// stop if pose has changed

	if ((state.model.play_mode==model_play_mode_prev) || (state.model.play_mode==model_play_mode_next)) {
		if (old_pose_move_idx!=state.model.blend[0].pose_move_idx) {
			model_play(model_play_mode_stop);
		}
	}

		// global draw setup
	
	model_draw_wind(state.model.cur_mesh_idx);
}
Ejemplo n.º 17
0
void model_play(int play_mode)
{
	int					n,tick,pose_move_idx;
	
		// good animation?
		
	if (play_mode!=model_play_mode_stop) {
		if (state.model.cur_animate_idx==-1) return;
		if (model.animates[state.model.cur_animate_idx].npose_move==0) return;
	}
	
		// always turn off animation until setup is complete
		// as animation is on a timer
		
	state.model.play_mode=model_play_mode_stop;

		// if it's next or previous, we
		// need to start on current selection

	pose_move_idx=0;

	switch (play_mode) {

		case model_play_mode_prev:
			pose_move_idx=state.model.cur_animate_pose_move_idx-1;
			if (pose_move_idx<0) pose_move_idx=model.animates[state.model.cur_animate_idx].npose_move-1;
			break;

		case model_play_mode_next:
			pose_move_idx=state.model.cur_animate_pose_move_idx;
			break;
	}
	
		// setup animation
		
	time_start();
	tick=time_get();

	for (n=0;n!=max_model_blend_animation;n++) {
		state.model.blend[n].pose_move_idx=pose_move_idx;
		state.model.blend[n].tick=tick;
	}
	
		// turn on/off animation
		
	state.model.play_mode=play_mode;
	
	if (state.model.model_open) main_wind_draw();
}
Ejemplo n.º 18
0
void tool_wind_magnify_action(ControlRef ctrl,ControlPartCode code)
{
	int				s;
	
	s=GetControlValue(ctrl);
	if (s==magnify_factor) return;
	
	magnify_factor=s;
	
	top_view_reset();
	portal_view_reset();
	site_path_view_reset();
	
    main_wind_draw();
}
Ejemplo n.º 19
0
void texture_edit_click_scroll(void)
{
	int				org_y;
	d3pnt			pt;
	d3rect			box;

	org_y=-1;
	texture_edit_get_box(&box);

	main_wind_draw();

	while (!os_track_mouse_location(&pt,&box)) {

		if (org_y==-1) org_y=pt.y;

		if (pt.y!=org_y) {
			texture_edit_scroll(pt.y-org_y);
			main_wind_draw();
			org_y=pt.y;
		}
		
		usleep(10000);
	}
}
Ejemplo n.º 20
0
void texture_edit_scroll(int y_move)
{
	int			high;
	d3rect		box;

	texture_edit_scroll_pos-=y_move;

	if (texture_edit_scroll_pos<0) texture_edit_scroll_pos=0;
	
	texture_edit_get_box(&box);
	high=(texture_edit_item_high*max_texture_frame)-(box.by-box.ty);
	if (texture_edit_scroll_pos>high) texture_edit_scroll_pos=high;

	main_wind_draw();
}
Ejemplo n.º 21
0
void palette_polygon_save(void)
{
	int						type,main_idx,poly_idx;
	float					x_txtoff,y_txtoff,x_txtfact,y_txtfact;
	map_mesh_poly_type		*poly;
	map_liquid_type			*liq;
	
		// get polygon
		
	select_get(0,&type,&main_idx,&poly_idx);
	
		// save data
		
	if (type==mesh_piece) {
		poly=&map.mesh.meshes[main_idx].polys[poly_idx];

		x_txtoff=dialog_get_float(palette_poly_wind,kMeshPolySettingOffX,0);
		y_txtoff=dialog_get_float(palette_poly_wind,kMeshPolySettingOffY,0);
		x_txtfact=dialog_get_float(palette_poly_wind,kMeshPolySettingSizeX,0);
		y_txtfact=dialog_get_float(palette_poly_wind,kMeshPolySettingSizeY,0);

		if ((x_txtfact>0.0f) && (y_txtfact>0.0f)) map_mesh_set_poly_uv_as_box(&map,main_idx,poly_idx,x_txtoff,y_txtoff,x_txtfact,y_txtfact);

		poly->dark_factor=dialog_get_float(palette_poly_wind,kMeshPolySettingDark,0);
		poly->alpha=dialog_get_float(palette_poly_wind,kMeshPolySettingAlpha,0);
		poly->x_shift=dialog_get_float(palette_poly_wind,kMeshPolySettingShiftX,0);
		poly->y_shift=dialog_get_float(palette_poly_wind,kMeshPolySettingShiftY,0);
		
		dialog_special_combo_get_node(palette_poly_wind,kMeshPolySettingCamera,0,poly->camera,name_str_len);
	}
	
		// liquid data
		
	else {
		liq=&map.liquid.liquids[main_idx];

		liq->x_txtoff=dialog_get_float(palette_poly_wind,kMeshPolySettingOffX,0);
		liq->y_txtoff=dialog_get_float(palette_poly_wind,kMeshPolySettingOffY,0);
		liq->x_txtfact=dialog_get_float(palette_poly_wind,kMeshPolySettingSizeX,0);
		liq->y_txtfact=dialog_get_float(palette_poly_wind,kMeshPolySettingSizeY,0);
		
		liq->alpha=dialog_get_float(palette_poly_wind,kMeshPolySettingAlpha,0);
		liq->x_shift=dialog_get_float(palette_poly_wind,kMeshPolySettingShiftX,0);
		liq->y_shift=dialog_get_float(palette_poly_wind,kMeshPolySettingShiftY,0);
	}
	
	main_wind_draw();
}
Ejemplo n.º 22
0
void piece_force_grid(void)
{
	int				n,sel_count,type,mesh_idx,poly_idx;
	
	map_undo_push();
		
	sel_count=select_count();
	
	for (n=0;n!=sel_count;n++) {
		select_get(n,&type,&mesh_idx,&poly_idx);
		if (type==item_map_mesh) {
			view_force_grid(mesh_idx,FALSE);
			view_vbo_mesh_rebuild(mesh_idx);
		}
	}
	
	main_wind_draw();
}
Ejemplo n.º 23
0
void palette_sound_save(void)
{
	int						type,main_idx,poly_idx;
	map_sound_type			*sound;
	
		// get sound
		
	select_get(0,&type,&main_idx,&poly_idx);
	sound=&map.sounds[main_idx];
	
		// set controls
	
	dialog_special_combo_get_sound(palette_sound_wind,kSoundName,0,sound->name,name_str_len);
	sound->pitch=dialog_get_float(palette_sound_wind,kSoundPitch,0);
	sound->on=dialog_get_boolean(palette_sound_wind,kSoundOn,0);
	
	main_wind_draw();
}
Ejemplo n.º 24
0
void piece_flip(bool flip_x,bool flip_y,bool flip_z)
{
	int				n,sel_count,type,mesh_idx,poly_idx;
	
	map_undo_push();
	
	sel_count=select_count();
	
	for (n=0;n!=sel_count;n++) {
		select_get(n,&type,&mesh_idx,&poly_idx);
		if (type==item_map_mesh) {
			map_mesh_flip(&map,mesh_idx,flip_x,flip_y,flip_z);
			view_vbo_mesh_rebuild(mesh_idx);
		}
	}
	
	main_wind_draw();
}
Ejemplo n.º 25
0
void piece_poly_hole(void)
{
	int				n,sel_count,type,mesh_idx,poly_idx;
	
	sel_count=select_count();
	
	for (n=0;n!=sel_count;n++) {
		select_get(n,&type,&mesh_idx,&poly_idx);
		if (type==item_map_mesh) {
			map_mesh_poly_punch_hole(&map,mesh_idx,poly_idx,NULL,FALSE,normal_mode_in);
			view_vbo_mesh_rebuild(mesh_idx);
		}
	}
	
	select_clear();
	
	main_wind_draw();
}
Ejemplo n.º 26
0
void model_file_import_animations(void)
{
	char			file_name[256];
	
	os_set_arrow_cursor();

    if (!dialog_file_open_run("Open a Model","Models",NULL,"Mesh.xml;Model.xml",file_name)) return;
	
	os_set_wait_cursor();
	
	model_insert_animations(file_name);
	
    model_calculate_parents(&model);
	
	os_set_arrow_cursor();
	
	main_wind_draw();
}
Ejemplo n.º 27
0
void piece_mesh_recalc_normals(bool poly_only)
{
	int				n,sel_count,type,mesh_idx,poly_idx;
	
	sel_count=select_count();
	
	for (n=0;n!=sel_count;n++) {
		select_get(n,&type,&mesh_idx,&poly_idx);
		if (type!=item_map_mesh) continue;
		
		if (poly_only) {
			map_recalc_normals_mesh_poly(&map,&map.mesh.meshes[mesh_idx],poly_idx,normal_mode_none,FALSE);
		}
		else {
			map_recalc_normals_mesh(&map,&map.mesh.meshes[mesh_idx],normal_mode_none,FALSE);
		}
	}
	
	main_wind_draw();
}
Ejemplo n.º 28
0
void piece_rotate(d3ang *ang)
{
	int				n,sel_count,type,mesh_idx,poly_idx;
	d3pnt			center_pnt;
	
	map_undo_push();
	
	sel_count=select_count();
	
	for (n=0;n!=sel_count;n++) {
		select_get(n,&type,&mesh_idx,&poly_idx);
		if (type!=item_map_mesh) continue;
		
		map_mesh_calculate_center(&map,mesh_idx,&center_pnt);
		map_mesh_rotate(&map,mesh_idx,&center_pnt,ang);
		view_vbo_mesh_rebuild(mesh_idx);
	}
	
	main_wind_draw();
}
Ejemplo n.º 29
0
void model_file_insert_mesh_dim3_model(void)
{
	char			file_name[256];
	
	os_set_arrow_cursor();

    if (!dialog_file_open_run("Open a Model","Models",NULL,"Mesh.xml;Model.xml",file_name)) return;
	
	if (state.model.cur_mesh_idx==-1) state.model.cur_mesh_idx=0;
	
	os_set_wait_cursor();
	
	model_insert_mesh(file_name);
	
    model_calculate_parents(&model);
    model_center_xz(&model,state.model.cur_mesh_idx);
    model_floor(&model,state.model.cur_mesh_idx);
    model_recalc_boxes(&model);
	
	os_set_arrow_cursor();
	
	main_wind_draw();
}
Ejemplo n.º 30
0
void model_auto_generate_textures(void)
{
	char			base_path[1024],dir_path[1024];

	os_set_wait_cursor();

		// texture directory

	file_paths_data_default(&file_path_setup,base_path,"Models",NULL,NULL);
		
	strcat(base_path,"/");
	strcat(base_path,state.model.model_file_name);
	
	sprintf(dir_path,"%s/Textures",base_path);

		// run bitmap generation for model

	auto_generate_model_create_texture_set(&model,dir_path);

	os_set_arrow_cursor();

	main_wind_draw();
}