Initialer Upload neues Unity-Projekt

Assets/SteamVR/Extras/SteamVR_GazeTracker.cs

@@ -0,0 +1,88 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+using UnityEngine;
+using System.Collections;
+
+public struct GazeEventArgs
+{
+    public float distance;
+}
+
+public delegate void GazeEventHandler(object sender, GazeEventArgs e);
+
+public class SteamVR_GazeTracker : MonoBehaviour
+{
+    public bool isInGaze = false;
+    public event GazeEventHandler GazeOn;
+    public event GazeEventHandler GazeOff;
+    public float gazeInCutoff = 0.15f;
+    public float gazeOutCutoff = 0.4f;
+
+    // Contains a HMD tracked object that we can use to find the user's gaze
+    Transform hmdTrackedObject = null;
+
+	// Use this for initialization
+	void Start ()
+    {
+	
+	}
+
+    public virtual void OnGazeOn(GazeEventArgs e)
+    {
+        if (GazeOn != null)
+            GazeOn(this, e);
+    }
+
+    public virtual void OnGazeOff(GazeEventArgs e)
+    {
+        if (GazeOff != null)
+            GazeOff(this, e);
+    }
+
+    // Update is called once per frame
+	void Update ()
+    {
+        // If we haven't set up hmdTrackedObject find what the user is looking at
+        if (hmdTrackedObject == null)
+        {
+            SteamVR_TrackedObject[] trackedObjects = FindObjectsOfType<SteamVR_TrackedObject>();
+            foreach (SteamVR_TrackedObject tracked in trackedObjects)
+            {
+                if (tracked.index == SteamVR_TrackedObject.EIndex.Hmd)
+                {
+                    hmdTrackedObject = tracked.transform;
+                    break;
+                }
+            }
+        }
+
+        if (hmdTrackedObject)
+        {
+            Ray r = new Ray(hmdTrackedObject.position, hmdTrackedObject.forward);
+            Plane p = new Plane(hmdTrackedObject.forward, transform.position);
+
+            float enter = 0.0f;
+            if (p.Raycast(r, out enter))
+            {
+                Vector3 intersect = hmdTrackedObject.position + hmdTrackedObject.forward * enter;
+                float dist = Vector3.Distance(intersect, transform.position);
+                //Debug.Log("Gaze dist = " + dist);
+                if (dist < gazeInCutoff && !isInGaze)
+                {
+                    isInGaze = true;
+                    GazeEventArgs e;
+                    e.distance = dist;
+                    OnGazeOn(e);
+                }
+                else if (dist >= gazeOutCutoff && isInGaze)
+                {
+                    isInGaze = false;
+                    GazeEventArgs e;
+                    e.distance = dist;
+                    OnGazeOff(e);
+                }
+            }
+
+        }
+
+    }
+}

Assets/SteamVR/Extras/SteamVR_GazeTracker.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 501eb8b744f73714fbe7dbdd5e3ef66e
+timeCreated: 1426193800
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/SteamVR/Extras/SteamVR_LaserPointer.cs

@@ -0,0 +1,141 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+using UnityEngine;
+using System.Collections;
+
+public struct PointerEventArgs
+{
+    public uint controllerIndex;
+    public uint flags;
+    public float distance;
+    public Transform target;
+}
+
+public delegate void PointerEventHandler(object sender, PointerEventArgs e);
+
+
+public class SteamVR_LaserPointer : MonoBehaviour
+{
+    public bool active = true;
+    public Color color;
+    public float thickness = 0.002f;
+    public GameObject holder;
+    public GameObject pointer;
+    bool isActive = false;
+    public bool addRigidBody = false;
+    public Transform reference;
+    public event PointerEventHandler PointerIn;
+    public event PointerEventHandler PointerOut;
+
+    Transform previousContact = null;
+
+	// Use this for initialization
+	void Start ()
+    {
+        holder = new GameObject();
+        holder.transform.parent = this.transform;
+        holder.transform.localPosition = Vector3.zero;
+		holder.transform.localRotation = Quaternion.identity;
+
+		pointer = GameObject.CreatePrimitive(PrimitiveType.Cube);
+        pointer.transform.parent = holder.transform;
+        pointer.transform.localScale = new Vector3(thickness, thickness, 100f);
+        pointer.transform.localPosition = new Vector3(0f, 0f, 50f);
+		pointer.transform.localRotation = Quaternion.identity;
+		BoxCollider collider = pointer.GetComponent<BoxCollider>();
+        if (addRigidBody)
+        {
+            if (collider)
+            {
+                collider.isTrigger = true;
+            }
+            Rigidbody rigidBody = pointer.AddComponent<Rigidbody>();
+            rigidBody.isKinematic = true;
+        }
+        else
+        {
+            if(collider)
+            {
+                Object.Destroy(collider);
+            }
+        }
+        Material newMaterial = new Material(Shader.Find("Unlit/Color"));
+        newMaterial.SetColor("_Color", color);
+        pointer.GetComponent<MeshRenderer>().material = newMaterial;
+	}
+
+    public virtual void OnPointerIn(PointerEventArgs e)
+    {
+        if (PointerIn != null)
+            PointerIn(this, e);
+    }
+
+    public virtual void OnPointerOut(PointerEventArgs e)
+    {
+        if (PointerOut != null)
+            PointerOut(this, e);
+    }
+
+
+    // Update is called once per frame
+	void Update ()
+    {
+        if (!isActive)
+        {
+            isActive = true;
+            this.transform.GetChild(0).gameObject.SetActive(true);
+        }
+
+        float dist = 100f;
+
+        SteamVR_TrackedController controller = GetComponent<SteamVR_TrackedController>();
+
+        Ray raycast = new Ray(transform.position, transform.forward);
+        RaycastHit hit;
+        bool bHit = Physics.Raycast(raycast, out hit);
+
+        if(previousContact && previousContact != hit.transform)
+        {
+            PointerEventArgs args = new PointerEventArgs();
+            if (controller != null)
+            {
+                args.controllerIndex = controller.controllerIndex;
+            }
+            args.distance = 0f;
+            args.flags = 0;
+            args.target = previousContact;
+            OnPointerOut(args);
+            previousContact = null;
+        }
+        if(bHit && previousContact != hit.transform)
+        {
+            PointerEventArgs argsIn = new PointerEventArgs();
+            if (controller != null)
+            {
+                argsIn.controllerIndex = controller.controllerIndex;
+            }
+            argsIn.distance = hit.distance;
+            argsIn.flags = 0;
+            argsIn.target = hit.transform;
+            OnPointerIn(argsIn);
+            previousContact = hit.transform;
+        }
+        if(!bHit)
+        {
+            previousContact = null;
+        }
+        if (bHit && hit.distance < 100f)
+        {
+            dist = hit.distance;
+        }
+
+        if (controller != null && controller.triggerPressed)
+        {
+            pointer.transform.localScale = new Vector3(thickness * 5f, thickness * 5f, dist);
+        }
+        else
+        {
+            pointer.transform.localScale = new Vector3(thickness, thickness, dist);
+        }
+        pointer.transform.localPosition = new Vector3(0f, 0f, dist/2f);
+    }
+}

Assets/SteamVR/Extras/SteamVR_LaserPointer.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d4e8a839a7c5b7e4580c59e305fb5f01
+timeCreated: 1430337756
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/SteamVR/Extras/SteamVR_Teleporter.cs

@@ -0,0 +1,98 @@
+using UnityEngine;
+using System.Collections;
+
+public class SteamVR_Teleporter : MonoBehaviour
+{
+	public enum TeleportType
+	{
+		TeleportTypeUseTerrain,
+		TeleportTypeUseCollider,
+		TeleportTypeUseZeroY
+	}
+
+	public bool teleportOnClick = false;
+	public TeleportType teleportType = TeleportType.TeleportTypeUseZeroY;
+
+	Transform reference
+	{
+		get
+		{
+			var top = SteamVR_Render.Top();
+			return (top != null) ? top.origin : null;
+		}
+	}
+
+	void Start()
+	{
+		var trackedController = GetComponent<SteamVR_TrackedController>();
+		if (trackedController == null)
+		{
+			trackedController = gameObject.AddComponent<SteamVR_TrackedController>();
+		}
+
+		trackedController.TriggerClicked += new ClickedEventHandler(DoClick);
+
+		if (teleportType == TeleportType.TeleportTypeUseTerrain)
+		{
+			// Start the player at the level of the terrain
+			var t = reference;
+			if (t != null)
+				t.position = new Vector3(t.position.x, Terrain.activeTerrain.SampleHeight(t.position), t.position.z);
+		}
+	}
+
+	void DoClick(object sender, ClickedEventArgs e)
+	{
+		if (teleportOnClick)
+		{
+			// First get the current Transform of the the reference space (i.e. the Play Area, e.g. CameraRig prefab)
+			var t = reference;
+			if (t == null)
+				return;
+
+			// Get the current Y position of the reference space
+			float refY = t.position.y;
+
+			// Create a plane at the Y position of the Play Area
+			// Then create a Ray from the origin of the controller in the direction that the controller is pointing
+			Plane plane = new Plane(Vector3.up, -refY);
+			Ray ray = new Ray(this.transform.position, transform.forward);
+
+			// Set defaults
+			bool hasGroundTarget = false;
+			float dist = 0f;
+			if (teleportType == TeleportType.TeleportTypeUseTerrain) // If we picked to use the terrain
+			{
+				RaycastHit hitInfo;
+				TerrainCollider tc = Terrain.activeTerrain.GetComponent<TerrainCollider>();
+				hasGroundTarget = tc.Raycast(ray, out hitInfo, 1000f);
+				dist = hitInfo.distance;
+			}
+			else if (teleportType == TeleportType.TeleportTypeUseCollider) // If we picked to use the collider
+			{
+				RaycastHit hitInfo;
+				hasGroundTarget = Physics.Raycast(ray, out hitInfo);
+				dist = hitInfo.distance;
+			}
+			else // If we're just staying flat on the current Y axis
+			{
+				// Intersect a ray with the plane that was created earlier
+				// and output the distance along the ray that it intersects
+				hasGroundTarget = plane.Raycast(ray, out dist);
+			}
+
+			if (hasGroundTarget)
+			{
+				// Get the current Camera (head) position on the ground relative to the world
+				Vector3 headPosOnGround = new Vector3(SteamVR_Render.Top().head.position.x, refY, SteamVR_Render.Top().head.position.z);
+
+				// We need to translate the reference space along the same vector
+				// that is between the head's position on the ground and the intersection point on the ground
+				// i.e. intersectionPoint - headPosOnGround = translateVector
+				// currentReferencePosition + translateVector = finalPosition
+				t.position = t.position + (ray.origin + (ray.direction * dist)) - headPosOnGround;
+			}
+		}
+	}
+}
+

Assets/SteamVR/Extras/SteamVR_Teleporter.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 24c7d7d77dd0d2a4b8e1ad129b170ee3
+timeCreated: 1430337756
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/SteamVR/Extras/SteamVR_TestIK.unity.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4b6669fb4e4df9c48926f02b694be9d1
+timeCreated: 1437433018
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/SteamVR/Extras/SteamVR_TestThrow.cs

@@ -0,0 +1,58 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+using UnityEngine;
+using System.Collections;
+
+[RequireComponent(typeof(SteamVR_TrackedObject))]
+public class SteamVR_TestThrow : MonoBehaviour
+{
+	public GameObject prefab;
+	public Rigidbody attachPoint;
+
+	SteamVR_TrackedObject trackedObj;
+	FixedJoint joint;
+
+	void Awake()
+	{
+		trackedObj = GetComponent<SteamVR_TrackedObject>();
+	}
+
+	void FixedUpdate()
+	{
+		var device = SteamVR_Controller.Input((int)trackedObj.index);
+		if (joint == null && device.GetTouchDown(SteamVR_Controller.ButtonMask.Trigger))
+		{
+			var go = GameObject.Instantiate(prefab);
+			go.transform.position = attachPoint.transform.position;
+
+			joint = go.AddComponent<FixedJoint>();
+			joint.connectedBody = attachPoint;
+		}
+		else if (joint != null && device.GetTouchUp(SteamVR_Controller.ButtonMask.Trigger))
+		{
+			var go = joint.gameObject;
+			var rigidbody = go.GetComponent<Rigidbody>();
+			Object.DestroyImmediate(joint);
+			joint = null;
+			Object.Destroy(go, 15.0f);
+
+			// We should probably apply the offset between trackedObj.transform.position
+			// and device.transform.pos to insert into the physics sim at the correct
+			// location, however, we would then want to predict ahead the visual representation
+			// by the same amount we are predicting our render poses.
+
+			var origin = trackedObj.origin ? trackedObj.origin : trackedObj.transform.parent;
+			if (origin != null)
+			{
+				rigidbody.velocity = origin.TransformVector(device.velocity);
+				rigidbody.angularVelocity = origin.TransformVector(device.angularVelocity);
+			}
+			else
+			{
+				rigidbody.velocity = device.velocity;
+				rigidbody.angularVelocity = device.angularVelocity;
+			}
+
+			rigidbody.maxAngularVelocity = rigidbody.angularVelocity.magnitude;
+		}
+	}
+}

Assets/SteamVR/Extras/SteamVR_TestThrow.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ff4f36585e15b1942827390ff1a92502
+timeCreated: 1437513988
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/SteamVR/Extras/SteamVR_TestThrow.unity.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0d936163b5e9a5047b5e4ba5afaf5126
+timeCreated: 1437513966
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/SteamVR/Extras/SteamVR_TestTrackedCamera.cs

@@ -0,0 +1,84 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+using UnityEngine;
+
+public class SteamVR_TestTrackedCamera : MonoBehaviour
+{
+	public Material material;
+	public Transform target;
+	public bool undistorted = true;
+	public bool cropped = true;
+
+	void OnEnable()
+	{
+		// The video stream must be symmetrically acquired and released in
+		// order to properly disable the stream once there are no consumers.
+		var source = SteamVR_TrackedCamera.Source(undistorted);
+		source.Acquire();
+
+		// Auto-disable if no camera is present.
+		if (!source.hasCamera)
+			enabled = false;
+	}
+
+	void OnDisable()
+	{
+		// Clear the texture when no longer active.
+		material.mainTexture = null;
+
+		// The video stream must be symmetrically acquired and released in
+		// order to properly disable the stream once there are no consumers.
+		var source = SteamVR_TrackedCamera.Source(undistorted);
+		source.Release();
+	}
+
+	void Update()
+	{
+		var source = SteamVR_TrackedCamera.Source(undistorted);
+		var texture = source.texture;
+		if (texture == null)
+		{
+			return;
+		}
+
+		// Apply the latest texture to the material.  This must be performed
+		// every frame since the underlying texture is actually part of a ring
+		// buffer which is updated in lock-step with its associated pose.
+		// (You actually really only need to call any of the accessors which
+		// internally call Update on the SteamVR_TrackedCamera.VideoStreamTexture).
+		material.mainTexture = texture;
+
+		// Adjust the height of the quad based on the aspect to keep the texels square.
+		var aspect = (float)texture.width / texture.height;
+
+		// The undistorted video feed has 'bad' areas near the edges where the original
+		// square texture feed is stretched to undo the fisheye from the lens.
+		// Therefore, you'll want to crop it to the specified frameBounds to remove this.
+		if (cropped)
+		{
+			var bounds = source.frameBounds;
+			material.mainTextureOffset = new Vector2(bounds.uMin, bounds.vMin);
+
+			var du = bounds.uMax - bounds.uMin;
+			var dv = bounds.vMax - bounds.vMin;
+			material.mainTextureScale = new Vector2(du, dv);
+
+			aspect *= Mathf.Abs(du / dv);
+        }
+		else
+		{
+			material.mainTextureOffset = Vector2.zero;
+			material.mainTextureScale = new Vector2(1, -1);
+		}
+
+		target.localScale = new Vector3(1, 1.0f / aspect, 1);
+
+		// Apply the pose that this frame was recorded at.
+		if (source.hasTracking)
+		{
+			var t = source.transform;
+			target.localPosition = t.pos;
+			target.localRotation = t.rot;
+		}
+	}
+}
+

Assets/SteamVR/Extras/SteamVR_TestTrackedCamera.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8b18b36a995ecb04599f35c2741be8d5
+timeCreated: 1465946679
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/SteamVR/Extras/SteamVR_TestTrackedCamera.mat

@@ -0,0 +1,127 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: SteamVR_TestTrackedCamera
+  m_Shader: {fileID: 10752, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 2
+    m_TexEnvs:
+    - first:
+        name: _BumpMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _DetailAlbedoMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _DetailMask
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _DetailNormalMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _EmissionMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _MainTex
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 0.5, y: -0.49999994}
+        m_Offset: {x: 0.25, y: 0.75}
+    - first:
+        name: _MetallicGlossMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _OcclusionMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _ParallaxMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - first:
+        name: _BumpScale
+      second: 1
+    - first:
+        name: _Cutoff
+      second: 0.5
+    - first:
+        name: _DetailNormalMapScale
+      second: 1
+    - first:
+        name: _DstBlend
+      second: 0
+    - first:
+        name: _GlossMapScale
+      second: 1
+    - first:
+        name: _Glossiness
+      second: 0.5
+    - first:
+        name: _GlossyReflections
+      second: 1
+    - first:
+        name: _Metallic
+      second: 0
+    - first:
+        name: _Mode
+      second: 0
+    - first:
+        name: _OcclusionStrength
+      second: 1
+    - first:
+        name: _Parallax
+      second: 0.02
+    - first:
+        name: _SmoothnessTextureChannel
+      second: 0
+    - first:
+        name: _SpecularHighlights
+      second: 1
+    - first:
+        name: _SrcBlend
+      second: 1
+    - first:
+        name: _UVSec
+      second: 0
+    - first:
+        name: _ZWrite
+      second: 1
+    m_Colors:
+    - first:
+        name: _Color
+      second: {r: 1, g: 1, b: 1, a: 1}
+    - first:
+        name: _EmissionColor
+      second: {r: 0, g: 0, b: 0, a: 1}

Assets/SteamVR/Extras/SteamVR_TestTrackedCamera.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 99ee8d48ccf36264e9d9a72baa681249
+timeCreated: 1465950289
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/SteamVR/Extras/SteamVR_TestTrackedCamera.unity.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7fb811b0ffe615b4dbf1d5e6ced385fd
+timeCreated: 1464227836
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/SteamVR/Extras/SteamVR_TrackedController.cs

@@ -0,0 +1,250 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+using UnityEngine;
+using Valve.VR;
+
+public struct ClickedEventArgs
+{
+	public uint controllerIndex;
+	public uint flags;
+	public float padX, padY;
+}
+
+public delegate void ClickedEventHandler(object sender, ClickedEventArgs e);
+
+public class SteamVR_TrackedController : MonoBehaviour
+{
+	public uint controllerIndex;
+	public VRControllerState_t controllerState;
+	public bool triggerPressed = false;
+	public bool steamPressed = false;
+	public bool menuPressed = false;
+	public bool padPressed = false;
+	public bool padTouched = false;
+	public bool gripped = false;
+
+	public event ClickedEventHandler MenuButtonClicked;
+	public event ClickedEventHandler MenuButtonUnclicked;
+	public event ClickedEventHandler TriggerClicked;
+	public event ClickedEventHandler TriggerUnclicked;
+	public event ClickedEventHandler SteamClicked;
+	public event ClickedEventHandler PadClicked;
+	public event ClickedEventHandler PadUnclicked;
+	public event ClickedEventHandler PadTouched;
+	public event ClickedEventHandler PadUntouched;
+	public event ClickedEventHandler Gripped;
+	public event ClickedEventHandler Ungripped;
+
+	// Use this for initialization
+	protected virtual void Start()
+	{
+		if (this.GetComponent<SteamVR_TrackedObject>() == null)
+		{
+			gameObject.AddComponent<SteamVR_TrackedObject>();
+		}
+
+		if (controllerIndex != 0)
+		{
+			this.GetComponent<SteamVR_TrackedObject>().index = (SteamVR_TrackedObject.EIndex)controllerIndex;
+			if (this.GetComponent<SteamVR_RenderModel>() != null)
+			{
+				this.GetComponent<SteamVR_RenderModel>().index = (SteamVR_TrackedObject.EIndex)controllerIndex;
+			}
+		}
+		else
+		{
+			controllerIndex = (uint)this.GetComponent<SteamVR_TrackedObject>().index;
+		}
+	}
+
+	public void SetDeviceIndex(int index)
+	{
+		this.controllerIndex = (uint)index;
+	}
+
+	public virtual void OnTriggerClicked(ClickedEventArgs e)
+	{
+		if (TriggerClicked != null)
+			TriggerClicked(this, e);
+	}
+
+	public virtual void OnTriggerUnclicked(ClickedEventArgs e)
+	{
+		if (TriggerUnclicked != null)
+			TriggerUnclicked(this, e);
+	}
+
+	public virtual void OnMenuClicked(ClickedEventArgs e)
+	{
+		if (MenuButtonClicked != null)
+			MenuButtonClicked(this, e);
+	}
+
+	public virtual void OnMenuUnclicked(ClickedEventArgs e)
+	{
+		if (MenuButtonUnclicked != null)
+			MenuButtonUnclicked(this, e);
+	}
+
+	public virtual void OnSteamClicked(ClickedEventArgs e)
+	{
+		if (SteamClicked != null)
+			SteamClicked(this, e);
+	}
+
+	public virtual void OnPadClicked(ClickedEventArgs e)
+	{
+		if (PadClicked != null)
+			PadClicked(this, e);
+	}
+
+	public virtual void OnPadUnclicked(ClickedEventArgs e)
+	{
+		if (PadUnclicked != null)
+			PadUnclicked(this, e);
+	}
+
+	public virtual void OnPadTouched(ClickedEventArgs e)
+	{
+		if (PadTouched != null)
+			PadTouched(this, e);
+	}
+
+	public virtual void OnPadUntouched(ClickedEventArgs e)
+	{
+		if (PadUntouched != null)
+			PadUntouched(this, e);
+	}
+
+	public virtual void OnGripped(ClickedEventArgs e)
+	{
+		if (Gripped != null)
+			Gripped(this, e);
+	}
+
+	public virtual void OnUngripped(ClickedEventArgs e)
+	{
+		if (Ungripped != null)
+			Ungripped(this, e);
+	}
+
+	// Update is called once per frame
+	protected virtual void Update()
+	{
+		var system = OpenVR.System;
+		if (system != null && system.GetControllerState(controllerIndex, ref controllerState, (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t))))
+		{
+			ulong trigger = controllerState.ulButtonPressed & (1UL << ((int)EVRButtonId.k_EButton_SteamVR_Trigger));
+			if (trigger > 0L && !triggerPressed)
+			{
+				triggerPressed = true;
+				ClickedEventArgs e;
+				e.controllerIndex = controllerIndex;
+				e.flags = (uint)controllerState.ulButtonPressed;
+				e.padX = controllerState.rAxis0.x;
+				e.padY = controllerState.rAxis0.y;
+				OnTriggerClicked(e);
+
+			}
+			else if (trigger == 0L && triggerPressed)
+			{
+				triggerPressed = false;
+				ClickedEventArgs e;
+				e.controllerIndex = controllerIndex;
+				e.flags = (uint)controllerState.ulButtonPressed;
+				e.padX = controllerState.rAxis0.x;
+				e.padY = controllerState.rAxis0.y;
+				OnTriggerUnclicked(e);
+			}
+
+			ulong grip = controllerState.ulButtonPressed & (1UL << ((int)EVRButtonId.k_EButton_Grip));
+			if (grip > 0L && !gripped)
+			{
+				gripped = true;
+				ClickedEventArgs e;
+				e.controllerIndex = controllerIndex;
+				e.flags = (uint)controllerState.ulButtonPressed;
+				e.padX = controllerState.rAxis0.x;
+				e.padY = controllerState.rAxis0.y;
+				OnGripped(e);
+
+			}
+			else if (grip == 0L && gripped)
+			{
+				gripped = false;
+				ClickedEventArgs e;
+				e.controllerIndex = controllerIndex;
+				e.flags = (uint)controllerState.ulButtonPressed;
+				e.padX = controllerState.rAxis0.x;
+				e.padY = controllerState.rAxis0.y;
+				OnUngripped(e);
+			}
+
+			ulong pad = controllerState.ulButtonPressed & (1UL << ((int)EVRButtonId.k_EButton_SteamVR_Touchpad));
+			if (pad > 0L && !padPressed)
+			{
+				padPressed = true;
+				ClickedEventArgs e;
+				e.controllerIndex = controllerIndex;
+				e.flags = (uint)controllerState.ulButtonPressed;
+				e.padX = controllerState.rAxis0.x;
+				e.padY = controllerState.rAxis0.y;
+				OnPadClicked(e);
+			}
+			else if (pad == 0L && padPressed)
+			{
+				padPressed = false;
+				ClickedEventArgs e;
+				e.controllerIndex = controllerIndex;
+				e.flags = (uint)controllerState.ulButtonPressed;
+				e.padX = controllerState.rAxis0.x;
+				e.padY = controllerState.rAxis0.y;
+				OnPadUnclicked(e);
+			}
+
+			ulong menu = controllerState.ulButtonPressed & (1UL << ((int)EVRButtonId.k_EButton_ApplicationMenu));
+			if (menu > 0L && !menuPressed)
+			{
+				menuPressed = true;
+				ClickedEventArgs e;
+				e.controllerIndex = controllerIndex;
+				e.flags = (uint)controllerState.ulButtonPressed;
+				e.padX = controllerState.rAxis0.x;
+				e.padY = controllerState.rAxis0.y;
+				OnMenuClicked(e);
+			}
+			else if (menu == 0L && menuPressed)
+			{
+				menuPressed = false;
+				ClickedEventArgs e;
+				e.controllerIndex = controllerIndex;
+				e.flags = (uint)controllerState.ulButtonPressed;
+				e.padX = controllerState.rAxis0.x;
+				e.padY = controllerState.rAxis0.y;
+				OnMenuUnclicked(e);
+			}
+
+			pad = controllerState.ulButtonTouched & (1UL << ((int)EVRButtonId.k_EButton_SteamVR_Touchpad));
+			if (pad > 0L && !padTouched)
+			{
+				padTouched = true;
+				ClickedEventArgs e;
+				e.controllerIndex = controllerIndex;
+				e.flags = (uint)controllerState.ulButtonPressed;
+				e.padX = controllerState.rAxis0.x;
+				e.padY = controllerState.rAxis0.y;
+				OnPadTouched(e);
+
+			}
+			else if (pad == 0L && padTouched)
+			{
+				padTouched = false;
+				ClickedEventArgs e;
+				e.controllerIndex = controllerIndex;
+				e.flags = (uint)controllerState.ulButtonPressed;
+				e.padX = controllerState.rAxis0.x;
+				e.padY = controllerState.rAxis0.y;
+				OnPadUntouched(e);
+			}
+		}
+	}
+}

Assets/SteamVR/Extras/SteamVR_TrackedController.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 7346a42905a29b347b1f492e8ad7b49f
+timeCreated: 1430337756
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: