Example #1
0
DVector<Vector3> _Geometry::segment_intersects_convex(const Vector3& p_from, const Vector3& p_to,const Vector<Plane>& p_planes) {

    DVector<Vector3> r;
    Vector3 res,norm;
    if (!Geometry::segment_intersects_convex(p_from,p_to,p_planes.ptr(),p_planes.size(),&res,&norm))
        return r;

    r.resize(2);
    r.set(0,res);
    r.set(1,norm);
    return r;
}
Example #2
0
DVector<Vector3> _Geometry::segment_intersects_sphere( const Vector3& p_from, const Vector3& p_to, const Vector3& p_sphere_pos,real_t p_sphere_radius) {

    DVector<Vector3> r;
    Vector3 res,norm;
    if (!Geometry::segment_intersects_sphere(p_from,p_to,p_sphere_pos,p_sphere_radius,&res,&norm))
        return r;

    r.resize(2);
    r.set(0,res);
    r.set(1,norm);
    return r;
}
Example #3
0
DVector<Vector3> _Geometry::segment_intersects_cylinder( const Vector3& p_from, const Vector3& p_to, float p_height,float p_radius) {

    DVector<Vector3> r;
    Vector3 res,norm;
    if (!Geometry::segment_intersects_cylinder(p_from,p_to,p_height,p_radius,&res,&norm))
        return r;

    r.resize(2);
    r.set(0,res);
    r.set(1,norm);
    return r;

}
Example #4
0
Array ResourcePreloader::_get_resources() const {

	DVector<String> names;
	Array arr;
	arr.resize(resources.size());
	names.resize(resources.size());

	Set<String> sorted_names;

	for(Map<StringName,RES >::Element *E=resources.front();E;E=E->next()) {
		sorted_names.insert(E->key());
	}

	int i=0;
	for(Set<String>::Element *E=sorted_names.front();E;E=E->next()) {

		names.set(i,E->get());
		arr[i]=resources[E->get()];
		i++;
	}

	Array res;
	res.push_back(names);
	res.push_back(arr);
	return res;
}
Example #5
0
Variant::Variant(const Vector<Color>& p_array) {

	type=NIL;
	DVector<Color> v;
	int len=p_array.size();
	v.resize(len);
	for (int i=0;i<len;i++)
		v.set(i,p_array[i]);
	*this=v;
}
Example #6
0
DVector<Vector2> _Geometry::get_closest_points_between_segments_2d( const Vector2& p1,const Vector2& q1, const Vector2& p2,const Vector2& q2) {

    Vector2 r1, r2;
    Geometry::get_closest_points_between_segments(p1,q1,p2,q2,r1,r2);
    DVector<Vector2> r;
    r.resize(2);
    r.set(0,r1);
    r.set(1,r2);
    return r;
}
Example #7
0
DVector<String> ResourcePreloader::_get_resource_list() const {

	DVector<String> res;
	res.resize(resources.size());
	int i=0;
	for(Map<StringName,RES >::Element *E=resources.front();E;E=E->next(),i++) {
		res.set(i,E->key());
	}

	return res;
}
Example #8
0
Variant ConvexPolygonShape2DSW::get_data() const {

	DVector<Vector2> dvr;

	dvr.resize(point_count);

	for(int i=0;i<point_count;i++) {	
		dvr.set(i,points[i].pos);
	}

	return dvr;
}
Example #9
0
DVector<String> AnimationTreePlayer::_get_node_list() {

	List<StringName> nl;
	get_node_list(&nl);
	DVector<String> ret;
	ret.resize(nl.size());
	int idx=0;
	for(List<StringName>::Element *E=nl.front();E;E=E->next()) {
		ret.set(idx++,E->get());
	}

	return ret;
}
Example #10
0
DVector<String> Translation::_get_message_list() const {

	DVector<String> msgs;
	msgs.resize(translation_map.size());
	int idx=0;
	for (const Map<StringName, StringName>::Element *E=translation_map.front();E;E=E->next()) {

		msgs.set(idx,E->key());
		idx+=1;
	}

	return msgs;

}
Example #11
0
DVector<Vector3> ConcavePolygonShapeSW::get_faces() const {


	DVector<Vector3> rfaces;
	rfaces.resize(faces.size()*3);

	for(int i=0;i<faces.size();i++) {

		Face f=faces.get(i);

		for(int j=0;j<3;j++) {

			rfaces.set(i*3+j, vertices.get( f.indices[j] ) );
		}
	}

	return rfaces;
}
Example #12
0
	void _create_body_shape_data() {
		VisualServer *vs = VisualServer::get_singleton();
		Physics2DServer *ps = Physics2DServer::get_singleton();

		// SEGMENT

		{

			DVector<uint8_t> pixels;
			pixels.resize(32*2*2);
			for(int i=0;i<2;i++) {

				for(int j=0;j<32;j++) {

					pixels.set(i*32*2+j*2+0,(j==0)?255:0);
					pixels.set(i*32*2+j*2+1,255);
				}
			}

			Image image(32,2,0,Image::FORMAT_LA8,pixels);

			body_shape_data[Physics2DServer::SHAPE_SEGMENT].image=vs->texture_create_from_image(image);

			RID segment_shape = ps->shape_create(Physics2DServer::SHAPE_SEGMENT);
			Rect2 sg(Point2(-16,0),Point2(16,0));
			ps->shape_set_data(segment_shape,sg);

			body_shape_data[Physics2DServer::SHAPE_SEGMENT].shape = segment_shape;

		}
		// CIRCLE

		{

			DVector<uint8_t> pixels;
			pixels.resize(32*32*2);
			for(int i=0;i<32;i++) {

				for(int j=0;j<32;j++) {

					bool black=Vector2(i-16,j-16).length_squared() < 16*16;

					pixels.set(i*32*2+j*2+0,(i==16 || j==16)?255:0);
					pixels.set(i*32*2+j*2+1,black?255:0);
				}
			}

			Image image(32,32,0,Image::FORMAT_LA8,pixels);

			body_shape_data[Physics2DServer::SHAPE_CIRCLE].image=vs->texture_create_from_image(image);

			RID circle_shape = ps->shape_create(Physics2DServer::SHAPE_CIRCLE);
			ps->shape_set_data(circle_shape,16);

			body_shape_data[Physics2DServer::SHAPE_CIRCLE].shape = circle_shape;

		}

		// BOX

		{

			DVector<uint8_t> pixels;
			pixels.resize(32*32*2);
			for(int i=0;i<32;i++) {

				for(int j=0;j<32;j++) {

					bool black=i>0 && i<31 && j>0 && j<31;

					pixels.set(i*32*2+j*2+0,black?0:255);
					pixels.set(i*32*2+j*2+1,255);
				}
			}

			Image image(32,32,0,Image::FORMAT_LA8,pixels);

			body_shape_data[Physics2DServer::SHAPE_RECTANGLE].image=vs->texture_create_from_image(image);

			RID rectangle_shape = ps->shape_create(Physics2DServer::SHAPE_RECTANGLE);
			ps->shape_set_data(rectangle_shape,Vector2(16,16));

			body_shape_data[Physics2DServer::SHAPE_RECTANGLE].shape = rectangle_shape;

		}


		// CAPSULE

		{

			DVector<uint8_t> pixels;
			pixels.resize(32*64*2);
			for(int i=0;i<64;i++) {

				for(int j=0;j<32;j++) {


					int si = i>48 ? i - 32 : (i<16 ? i : 16);
					bool black=Vector2(si-16,j-16).length_squared() < 16*16;

					pixels.set(i*32*2+j*2+0,(i==16 || j==16 || i==48)?255:0);
					pixels.set(i*32*2+j*2+1,black?255:0);

				}
			}

			Image image(32,64,0,Image::FORMAT_LA8,pixels);

			body_shape_data[Physics2DServer::SHAPE_CAPSULE].image=vs->texture_create_from_image(image);

			RID capsule_shape = ps->shape_create(Physics2DServer::SHAPE_CAPSULE);
			ps->shape_set_data(capsule_shape,Vector2(16,32));

			body_shape_data[Physics2DServer::SHAPE_CAPSULE].shape = capsule_shape;

		}

		// CONVEX

		{


			Image image(convex_png);

			body_shape_data[Physics2DServer::SHAPE_CUSTOM+1].image=vs->texture_create_from_image(image);

			RID convex_polygon_shape = ps->shape_create(Physics2DServer::SHAPE_CONVEX_POLYGON);

			DVector<Vector2> arr;
			Point2 sb(32,32);
			arr.push_back(Point2(20,3)-sb);
			arr.push_back(Point2(58,23)-sb);
			arr.push_back(Point2(55,54)-sb);
			arr.push_back(Point2(27,60)-sb);
			arr.push_back(Point2(5,56)-sb);
			arr.push_back(Point2(4,20)-sb);
			arr.push_back(Point2(11,7)-sb);
			ps->shape_set_data(convex_polygon_shape,arr);

			body_shape_data[Physics2DServer::SHAPE_CUSTOM+1].shape = convex_polygon_shape;

		}


	}
bool NavigationPolygonEditor::forward_input_event(const InputEvent& p_event) {


	if (!node)
		return false;

	if (node->get_navigation_polygon().is_null()) {
		if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
			create_nav->set_text("No NavigationPolygon resource on this node.\nCreate and assign one?");
			create_nav->popup_centered_minsize();
		}
		return (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1);;
	}


	switch(p_event.type) {

		case InputEvent::MOUSE_BUTTON: {

			const InputEventMouseButton &mb=p_event.mouse_button;

			Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform();


			Vector2 gpoint = Point2(mb.x,mb.y);
			Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint);
			cpoint=canvas_item_editor->snap_point(cpoint);
			cpoint = node->get_global_transform().affine_inverse().xform(cpoint);



			//first check if a point is to be added (segment split)
			real_t grab_treshold=EDITOR_DEF("poly_editor/point_grab_radius",8);

			switch(mode) {


				case MODE_CREATE: {

					if (mb.button_index==BUTTON_LEFT && mb.pressed) {


						if (!wip_active) {

							wip.clear();
							wip.push_back( cpoint );
							wip_active=true;
							edited_point_pos=cpoint;
							edited_outline=-1;
							canvas_item_editor->get_viewport_control()->update();
							edited_point=1;
							return true;
						} else {


							if (wip.size()>1 && xform.xform(wip[0]).distance_to(gpoint)<grab_treshold) {
								//wip closed
								_wip_close();

								return true;
							} else {

								wip.push_back( cpoint );
								edited_point=wip.size();
								canvas_item_editor->get_viewport_control()->update();
								return true;

								//add wip point
							}
						}
					} else if (mb.button_index==BUTTON_RIGHT && mb.pressed && wip_active) {
						_wip_close();
					}



				} break;

				case MODE_EDIT: {

					if (mb.button_index==BUTTON_LEFT) {
						if (mb.pressed) {

							if (mb.mod.control) {


								//search edges
								int closest_outline=-1;
								int closest_idx=-1;
								Vector2 closest_pos;
								real_t closest_dist=1e10;

								for(int j=0;j<node->get_navigation_polygon()->get_outline_count();j++) {


									DVector<Vector2> points=node->get_navigation_polygon()->get_outline(j);

									int pc=points.size();
									DVector<Vector2>::Read poly=points.read();

									for(int i=0;i<pc;i++) {

										Vector2 points[2] ={ xform.xform(poly[i]),
											xform.xform(poly[(i+1)%pc]) };

										Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint,points);
										if (cp.distance_squared_to(points[0])<CMP_EPSILON2 || cp.distance_squared_to(points[1])<CMP_EPSILON2)
											continue; //not valid to reuse point

										real_t d = cp.distance_to(gpoint);
										if (d<closest_dist && d<grab_treshold) {
											closest_dist=d;
											closest_outline=j;
											closest_pos=cp;
											closest_idx=i;
										}


									}
								}

								if (closest_idx>=0) {

									pre_move_edit=node->get_navigation_polygon()->get_outline(closest_outline);
									DVector<Point2> poly = pre_move_edit;
									poly.insert(closest_idx+1,xform.affine_inverse().xform(closest_pos));
									edited_point=closest_idx+1;
									edited_outline=closest_outline;
									edited_point_pos=xform.affine_inverse().xform(closest_pos);
									node->get_navigation_polygon()->set_outline(closest_outline,poly);
									canvas_item_editor->get_viewport_control()->update();
									return true;
								}
							} else {

								//look for points to move
								int closest_outline=-1;
								int closest_idx=-1;
								Vector2 closest_pos;
								real_t closest_dist=1e10;

								for(int j=0;j<node->get_navigation_polygon()->get_outline_count();j++) {


									DVector<Vector2> points=node->get_navigation_polygon()->get_outline(j);

									int pc=points.size();
									DVector<Vector2>::Read poly=points.read();

									for(int i=0;i<pc;i++) {


										Vector2 cp =xform.xform(poly[i]);

										real_t d = cp.distance_to(gpoint);
										if (d<closest_dist && d<grab_treshold) {
											closest_dist=d;
											closest_pos=cp;
											closest_outline=j;
											closest_idx=i;
										}
									}
								}

								if (closest_idx>=0) {

									pre_move_edit=node->get_navigation_polygon()->get_outline(closest_outline);
									edited_point=closest_idx;
									edited_outline=closest_outline;
									edited_point_pos=xform.affine_inverse().xform(closest_pos);
									canvas_item_editor->get_viewport_control()->update();
									return true;
								}
							}
						} else {

							if (edited_point!=-1) {

								//apply

								DVector<Vector2> poly = node->get_navigation_polygon()->get_outline(edited_outline);
								ERR_FAIL_INDEX_V(edited_point,poly.size(),false);
								poly.set(edited_point,edited_point_pos);
								undo_redo->create_action(TTR("Edit Poly"));
								undo_redo->add_do_method(node->get_navigation_polygon().ptr(),"set_outline",edited_outline,poly);
								undo_redo->add_undo_method(node->get_navigation_polygon().ptr(),"set_outline",edited_outline,pre_move_edit);
								undo_redo->add_do_method(node->get_navigation_polygon().ptr(),"make_polygons_from_outlines");
								undo_redo->add_undo_method(node->get_navigation_polygon().ptr(),"make_polygons_from_outlines");
								undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
								undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
								undo_redo->commit_action();

								edited_point=-1;
								return true;
							}
						}
					} if (mb.button_index==BUTTON_RIGHT && mb.pressed && edited_point==-1) {

						int closest_outline=-1;
						int closest_idx=-1;
						Vector2 closest_pos;
						real_t closest_dist=1e10;

						for(int j=0;j<node->get_navigation_polygon()->get_outline_count();j++) {


							DVector<Vector2> points=node->get_navigation_polygon()->get_outline(j);

							int pc=points.size();
							DVector<Vector2>::Read poly=points.read();

							for(int i=0;i<pc;i++) {


								Vector2 cp =xform.xform(poly[i]);

								real_t d = cp.distance_to(gpoint);
								if (d<closest_dist && d<grab_treshold) {
									closest_dist=d;
									closest_pos=cp;
									closest_outline=j;
									closest_idx=i;
								}
							}
						}

						if (closest_idx>=0) {


							DVector<Vector2> poly = node->get_navigation_polygon()->get_outline(closest_outline);

							if (poly.size()>3) {
								undo_redo->create_action(TTR("Edit Poly (Remove Point)"));
								undo_redo->add_undo_method(node->get_navigation_polygon().ptr(),"set_outline",closest_outline,poly);
								poly.remove(closest_idx);
								undo_redo->add_do_method(node->get_navigation_polygon().ptr(),"set_outline",closest_outline,poly);
								undo_redo->add_do_method(node->get_navigation_polygon().ptr(),"make_polygons_from_outlines");
								undo_redo->add_undo_method(node->get_navigation_polygon().ptr(),"make_polygons_from_outlines");
								undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
								undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
								undo_redo->commit_action();
							} else {

								undo_redo->create_action(TTR("Remove Poly And Point"));
								undo_redo->add_undo_method(node->get_navigation_polygon().ptr(),"add_outline_at_index",poly,closest_outline);
								poly.remove(closest_idx);
								undo_redo->add_do_method(node->get_navigation_polygon().ptr(),"remove_outline",closest_outline);
								undo_redo->add_do_method(node->get_navigation_polygon().ptr(),"make_polygons_from_outlines");
								undo_redo->add_undo_method(node->get_navigation_polygon().ptr(),"make_polygons_from_outlines");
								undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
								undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
								undo_redo->commit_action();

							}
							return true;
						}
					}



				} break;
			}



		} break;
		case InputEvent::MOUSE_MOTION: {

			const InputEventMouseMotion &mm=p_event.mouse_motion;

			if (edited_point!=-1 && (wip_active || mm.button_mask&BUTTON_MASK_LEFT)) {

				Vector2 gpoint = Point2(mm.x,mm.y);
				Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint);
				cpoint=canvas_item_editor->snap_point(cpoint);
				edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint);

				canvas_item_editor->get_viewport_control()->update();

			}

		} break;
	}

	return false;
}
Example #14
0
RID VisualServer::_make_test_cube() {

	DVector<Vector3> vertices;
	DVector<Vector3> normals;
	DVector<float> tangents;	
	DVector<Vector3> uvs;
							
	int vtx_idx=0;
#define ADD_VTX(m_idx);\
	vertices.push_back( face_points[m_idx] );\
	normals.push_back( normal_points[m_idx] );\
	tangents.push_back( normal_points[m_idx][1] );\
	tangents.push_back( normal_points[m_idx][2] );\
	tangents.push_back( normal_points[m_idx][0] );\
	tangents.push_back( 1.0 );\
	uvs.push_back( Vector3(uv_points[m_idx*2+0],uv_points[m_idx*2+1],0) );\
	vtx_idx++;\

	for (int i=0;i<6;i++) {

	
		Vector3 face_points[4];
		Vector3 normal_points[4];
		float uv_points[8]={0,0,0,1,1,1,1,0};
	
		for (int j=0;j<4;j++) {
		
			float v[3];
			v[0]=1.0;
			v[1]=1-2*((j>>1)&1);
			v[2]=v[1]*(1-2*(j&1));
		
			for (int k=0;k<3;k++) {
			
				if (i<3)
					face_points[j][(i+k)%3]=v[k]*(i>=3?-1:1);
				else
					face_points[3-j][(i+k)%3]=v[k]*(i>=3?-1:1);
			}
			normal_points[j]=Vector3();
			normal_points[j][i%3]=(i>=3?-1:1);
		}

	//tri 1
		ADD_VTX(0);
		ADD_VTX(1);
		ADD_VTX(2);
	//tri 2
		ADD_VTX(2);
		ADD_VTX(3);
		ADD_VTX(0);

	}

	RID test_cube = mesh_create();

	Array d;
	d.resize(VS::ARRAY_MAX);
	d[VisualServer::ARRAY_NORMAL]= normals ;
	d[VisualServer::ARRAY_TANGENT]= tangents ;
	d[VisualServer::ARRAY_TEX_UV]= uvs ;
	d[VisualServer::ARRAY_VERTEX]= vertices ;

	DVector<int> indices;
	indices.resize(vertices.size());
	for(int i=0;i<vertices.size();i++)
		indices.set(i,i);
	d[VisualServer::ARRAY_INDEX]=indices;

	mesh_add_surface( test_cube, PRIMITIVE_TRIANGLES,d );
	

	RID material = fixed_material_create();
	//material_set_flag(material, MATERIAL_FLAG_BILLBOARD_TOGGLE,true);
	fixed_material_set_texture( material, FIXED_MATERIAL_PARAM_DIFFUSE, get_test_texture() );
	fixed_material_set_param( material, FIXED_MATERIAL_PARAM_SPECULAR_EXP, 70 );
	fixed_material_set_param( material, FIXED_MATERIAL_PARAM_EMISSION, Vector3(0.2,0.2,0.2) );

	fixed_material_set_param( material, FIXED_MATERIAL_PARAM_DIFFUSE, Color(1, 1, 1) );
	fixed_material_set_param( material, FIXED_MATERIAL_PARAM_SPECULAR, Color(1,1,1) );

	mesh_surface_set_material(test_cube, 0, material );
	
	return test_cube;
}