Merge pull request #90 from BastiaanOlij/sensors

Sensor example

Author: akien-mga

misc/sensors/cube_6.png

@@ -0,0 +1,104 @@
+[gd_resource type="Environment" load_steps=2 format=2]
+
+[sub_resource type="ProceduralSky" id=1]
+
+radiance_size = 4
+sky_top_color = Color( 0.0470588, 0.454902, 0.976471, 1 )
+sky_horizon_color = Color( 0.556863, 0.823529, 0.909804, 1 )
+sky_curve = 0.25
+sky_energy = 1.0
+ground_bottom_color = Color( 0.101961, 0.145098, 0.188235, 1 )
+ground_horizon_color = Color( 0.482353, 0.788235, 0.952941, 1 )
+ground_curve = 0.01
+ground_energy = 1.0
+sun_color = Color( 1, 1, 1, 1 )
+sun_latitude = 35.0
+sun_longitude = 0.0
+sun_angle_min = 1.0
+sun_angle_max = 100.0
+sun_curve = 0.05
+sun_energy = 16.0
+texture_size = 2
+
+[resource]
+
+background_mode = 2
+background_sky = SubResource( 1 )
+background_sky_custom_fov = 0.0
+background_color = Color( 0, 0, 0, 1 )
+background_energy = 1.0
+background_canvas_max_layer = 0
+background_camera_feed_id = 1
+background_camera_feed_h_flip = false
+background_camera_feed_v_flip = true
+ambient_light_color = Color( 0, 0, 0, 1 )
+ambient_light_energy = 1.0
+ambient_light_sky_contribution = 1.0
+fog_enabled = false
+fog_color = Color( 0.5, 0.6, 0.7, 1 )
+fog_sun_color = Color( 1, 0.9, 0.7, 1 )
+fog_sun_amount = 0.0
+fog_depth_enabled = true
+fog_depth_begin = 10.0
+fog_depth_curve = 1.0
+fog_transmit_enabled = false
+fog_transmit_curve = 1.0
+fog_height_enabled = false
+fog_height_min = 0.0
+fog_height_max = 100.0
+fog_height_curve = 1.0
+tonemap_mode = 0
+tonemap_exposure = 1.0
+tonemap_white = 1.0
+auto_exposure_enabled = false
+auto_exposure_scale = 0.4
+auto_exposure_min_luma = 0.05
+auto_exposure_max_luma = 8.0
+auto_exposure_speed = 0.5
+ss_reflections_enabled = false
+ss_reflections_max_steps = 64
+ss_reflections_fade_in = 0.15
+ss_reflections_fade_out = 2.0
+ss_reflections_depth_tolerance = 0.2
+ss_reflections_roughness = true
+ssao_enabled = false
+ssao_radius = 1.0
+ssao_intensity = 1.0
+ssao_radius2 = 0.0
+ssao_intensity2 = 1.0
+ssao_bias = 0.01
+ssao_light_affect = 0.0
+ssao_color = Color( 0, 0, 0, 1 )
+ssao_quality = 0
+ssao_blur = 3
+ssao_edge_sharpness = 4.0
+dof_blur_far_enabled = false
+dof_blur_far_distance = 10.0
+dof_blur_far_transition = 5.0
+dof_blur_far_amount = 0.1
+dof_blur_far_quality = 1
+dof_blur_near_enabled = false
+dof_blur_near_distance = 2.0
+dof_blur_near_transition = 1.0
+dof_blur_near_amount = 0.1
+dof_blur_near_quality = 1
+glow_enabled = false
+glow_levels/1 = false
+glow_levels/2 = false
+glow_levels/3 = true
+glow_levels/4 = false
+glow_levels/5 = true
+glow_levels/6 = false
+glow_levels/7 = false
+glow_intensity = 0.8
+glow_strength = 1.0
+glow_bloom = 0.0
+glow_blend_mode = 2
+glow_hdr_threshold = 1.0
+glow_hdr_scale = 2.0
+glow_bicubic_upscale = false
+adjustment_enabled = false
+adjustment_brightness = 1.0
+adjustment_contrast = 1.0
+adjustment_saturation = 1.0
+

misc/sensors/default_env.tres

@@ -0,0 +1,141 @@
+extends Node
+
+# Below are a number of helper functions that show how you can use the raw sensor data to determine the orientation 
+# of your phone/device. The cheapest phones only have an accelerometer only the most expensive phones have all three.
+# Note that none of this logic filters data. Filters introduce lag but also provide stability. There are plenty
+# of examples on the internet on how to implement these. I wanted to keep this straight forward.
+
+# We draw a few arrow objects to visualize the vectors and two cubes to show two implementation for orientating 
+# these cubes to our phones orientation.
+# This is a 3D example however reading the phones orientation is also invaluable for 2D
+
+# This function calculates a rotation matrix based on a direction vector. As our arrows are cylindrical we don't
+# care about the rotation around this axis.
+func get_basis_for_arrow(p_vector):
+	var rotate = Basis()
+	
+	# as our arrow points up, Y = our direction vector
+	rotate.y = p_vector.normalized()
+	
+	# get an arbitrary vector we can use to calculate our other two vectors
+	var v = Vector3(1.0, 0.0, 0.0)
+	if (abs(v.dot(rotate.y)) > 0.9):
+		v = Vector3(0.0, 1.0, 0.0)
+	
+	# use our vector to get a vector perpendicular to our two vectors
+	rotate.x = rotate.y.cross(v).normalized()
+	
+	# and the cross product again gives us our final vector perpendicular to our previous two vectors
+	rotate.z = rotate.x.cross(rotate.y).normalized()
+	
+	return rotate
+
+# This function combines the magnetometer reading with the gravity vector to get a vector that points due north
+func calc_north(p_grav, p_mag):
+	# Always use normalized vectors!
+	p_grav = p_grav.normalized()
+	
+	# Calculate east (or is it west) by getting our cross product.
+	# The cross product of two normalized vectors returns a vector that
+	# is perpendicular to our two vectors
+	var east = p_grav.cross(p_mag.normalized()).normalized()
+	
+	# Cross again to get our horizon aligned north
+	return east.cross(p_grav).normalized()
+
+# This function creates an orientation matrix using the magnetometer and gravity vector as inputs.
+func orientate_by_mag_and_grav(p_mag, p_grav):
+	var rotate = Basis()
+	
+	# as always, normalize!
+	p_mag = p_mag.normalized()
+	
+	# gravity points down, so - gravity points up!
+	rotate.y = -p_grav.normalized()
+	
+	# Cross products with our magnetic north gives an aligned east (or west, I always forget)
+	rotate.x = rotate.y.cross(p_mag)
+	
+	# And cross product again and we get our aligned north completing our matrix
+	rotate.z = rotate.x.cross(rotate.y)
+	
+	return rotate
+
+# This function takes our gyro input and update an orientation matrix accordingly
+# The gyro is special as this vector does not contain a direction but rather a
+# rotational velocity. This is why we multiply our values with delta.
+func rotate_by_gyro(p_gyro, p_basis, p_delta):
+	var rotate = Basis()
+	
+	rotate = rotate.rotated(p_basis.x, -p_gyro.x * p_delta)
+	rotate = rotate.rotated(p_basis.y, -p_gyro.y * p_delta)
+	rotate = rotate.rotated(p_basis.z, -p_gyro.z * p_delta)
+	
+	return rotate * p_basis
+
+# This function corrects the drift in our matrix by our gravity vector 
+func drift_correction(p_basis, p_grav):
+	# as always, make sure our vector is normalized but also invert as our gravity points down
+	var real_up = -p_grav.normalized()
+	
+	# start by calculating the dot product, this gives us the cosine angle between our two vectors
+	var dot = p_basis.y.dot(real_up)
+	
+	# if our dot is 1.0 we're good
+	if (dot < 1.0):
+		# the cross between our two vectors gives us a vector perpendicular to our two vectors
+		var axis = p_basis.y.cross(real_up).normalized()
+		var correction = Basis(axis, acos(dot))
+		p_basis = correction * p_basis
+	
+	return p_basis
+
+func _process(delta):
+	# Get our data
+	var acc = Input.get_accelerometer()
+	var grav = Input.get_gravity()
+	var mag = Input.get_magnetometer()
+	var gyro = Input.get_gyroscope()
+	
+	# Show our base values
+	get_node("Control/Accelerometer").text = 'Accelerometer: ' + str(acc) + ', gravity: ' + str(grav)
+	get_node("Control/Magnetometer").text = 'Magnetometer: ' + str(mag)
+	get_node("Control/Gyroscope").text = 'Gyroscope: ' + str(gyro)
+	
+	# Check if we have all needed data
+	if grav.length() < 0.1:
+		if acc.length() < 0.1:
+			# we don't have either...
+			grav = Vector3(0.0, -1.0, 0.0)
+		else:
+			# The gravity vector is calculated by the OS by combining the other sensor inputs.
+			# If we don't have a gravity vector, from now on, use accelerometer...
+			grav = acc 
+	
+	if mag.length() < 0.1:
+		mag = Vector3(1.0, 0.0, 0.0)
+	
+	# Update our arrow showing gravity
+	get_node("Arrows/AccelerometerArrow").transform.basis = get_basis_for_arrow(grav)
+	
+	# Update our arrow showing our magnetometer
+	# Note that in absense of other strong magnetic forces this will point to magnetic north, which is not horizontal thanks to the earth being, uhm, round
+	get_node("Arrows/MagnetoArrow").transform.basis = get_basis_for_arrow(mag)
+	
+	# Calculate our north vector and show that
+	var north = calc_north(grav,mag)
+	get_node("Arrows/NorthArrow").transform.basis = get_basis_for_arrow(north)
+		
+	# Combine our magnetometer and gravity vector to position our box. This will be fairly accurate
+	# but our magnetometer can be easily influenced by magnets. Cheaper phones often don't have gyros
+	# so it is a good backup.
+	var mag_and_grav = get_node("Boxes/MagAndGrav")
+	mag_and_grav.transform.basis = orientate_by_mag_and_grav(mag, grav).orthonormalized()
+	
+	# Using our gyro and do a drift correction using our gravity vector gives the best result
+	var gyro_and_grav = get_node("Boxes/GyroAndGrav")
+	var new_basis = rotate_by_gyro(gyro, gyro_and_grav.transform.basis, delta).orthonormalized()
+	gyro_and_grav.transform.basis = drift_correction(new_basis, grav)
+	
+	
+