void Update() { /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ //PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y); //To be deprecated //Update the Workspace as function of camera for (int i = 0; i < workspaceUpdateValue.Length; i++) { workspaceUpdateValue[i] = myHapticCamera.transform.rotation.eulerAngles.y; } PluginImport.UpdateHapticWorkspace(ConverterClass.ConvertFloatArrayToIntPtr(workspaceUpdateValue)); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); //Associate the cursor object with the haptic proxy value myGenericFunctionsClassScript.GetProxyValues(); }
void Update() { /***************************************************************/ //Act on the rigid body of the Manipulated object // if Mode = Manipulation Mode /***************************************************************/ if (PluginImport.GetMode() == 1) { ActivatingGrabbedObjectPropperties(); } /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); myGenericFunctionsClassScript.GetProxyValues(); myGenericFunctionsClassScript.GetTouchedObject(); //Debug.Log ("Button 1: " + PluginImport.GetButton1State()); //Debug.Log ("Button 2: " + PluginImport.GetButton2State()); }
void Update() { /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ //PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y);//To be deprecated //Update the Workspace as function of camera //for (int i = 0; i < workspaceUpdateValue.Length; i++) //workspaceUpdateValue[i] = myHapticCamera.transform.rotation.eulerAngles.y; //PluginImport.UpdateHapticWorkspace(ConverterClass.ConvertFloatArrayToIntPtr(workspaceUpdateValue)); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); //Associate the cursor object with the haptic proxy value myGenericFunctionsClassScript.GetProxyValues(); //myGenericFunctionsClassScript.GetTouchedObject(); //Debug.Log ("Button 1: " + PluginImport.GetButton1State()); // To be deprecated //Debug.Log ("Button 2: " + PluginImport.GetButton2State()); // To be deprecated //Debug.Log("Device 1: Button 1: " + PluginImport.GetButtonState(1, 1)); //Debug.Log("Device 1: Button 2: " + PluginImport.GetButtonState(1, 2)); }
void Update() { /***************************************************************/ //Update forces /***************************************************************/ UpdateForces(); /***************************************************************/ //Update UI /***************************************************************/ UpdateUI(); /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); myGenericFunctionsClassScript.GetProxyValues(); //myGenericFunctionsClassScript.GetTouchedObject(); myGenericFunctionsClassScript.manipulateObject(); }
void Update() { if (cochlea == null) { cochlea = StatsManager.instance.GetActiveCochlea(); } if (PluginImport.GetButtonState(1, 2)) { if (!hasStarted) // user hasn't pressed start { DetachCochlea(); hasStarted = true; } } if (PluginImport.GetButtonState(1, 1) & !hasEnded) { hasEnded = true; StatsManager.instance.SetFullReset(false); simMonitor.IncrementReset(); SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex); } /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ //PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y);//To be deprecated //Update the Workspace as function of camera for (int i = 0; i < workspaceUpdateValue.Length; i++) { workspaceUpdateValue[i] = myHapticCamera.transform.rotation.eulerAngles.y; } PluginImport.UpdateHapticWorkspace(ConverterClass.ConvertFloatArrayToIntPtr(workspaceUpdateValue)); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); //Associate the cursor object with the haptic proxy value myGenericFunctionsClassScript.GetProxyValues(isKinematic); }
void Update() { /***************************************************************/ //Act on the rigid body of the Manipulated object // if Mode = Manipulation Mode /***************************************************************/ if (PluginImport.GetMode() == 1) { ActivatingGrabbedObjectPropperties(); } /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); myGenericFunctionsClassScript.GetProxyValues(); myGenericFunctionsClassScript.GetTouchedObject(); //Debug.Log ("Button 1: " + PluginImport.GetButton1State()); //Debug.Log ("Button 2: " + PluginImport.GetButton2State()); if (PluginImport.GetButton2State()) { makeJengaBlocks(); } const float rotSpeed = 1.0f; if (Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.LeftArrow)) { myHapticCamera.transform.RotateAround(Vector3.zero, new Vector3(0.0f, 1.0f, 0.0f), rotSpeed); } if (Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow)) { myHapticCamera.transform.RotateAround(Vector3.zero, new Vector3(0.0f, 1.0f, 0.0f), -rotSpeed); } }
void Update() { /***************************************************************/ //Update two Workspaces as function of camera for each /***************************************************************/ //PluginImport.UpdateTwoWorkspace(myHapticCamera.transform.rotation.eulerAngles.y, myHapticCamera.transform.rotation.eulerAngles.y); //Update the Workspace as function of camera - Note that two different reference can be used to update each workspace for (int i = 0; i < workspaceUpdateValue.Length; i++) { workspaceUpdateValue[i] = myHapticCamera.transform.rotation.eulerAngles.y; } PluginImport.UpdateHapticWorkspace(ConverterClass.ConvertFloatArrayToIntPtr(workspaceUpdateValue)); /***************************************************************/ //Update 2 cubes workspaces /***************************************************************/ myGenericFunctionsClassScript.UpdateTwoGraphicalWorkspaces(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); /***************************************************************/ //Update Haptic Object Transform /***************************************************************/ myGenericFunctionsClassScript.UpdateHapticObjectMatrixTransform(); //myGenericFunctionsClassScript.GetProxyValues(); myGenericFunctionsClassScript.GetTwoProxyValues(); //myGenericFunctionsClassScript.GetTouchedObject(); /*Debug.Log("Device 1: Button 1: " + PluginImport.GetButtonState(1, 1)); * Debug.Log("Device 1: Button 2: " + PluginImport.GetButtonState(1, 2)); * Debug.Log("Device 2: Button 1: " + PluginImport.GetButtonState(2, 1)); * Debug.Log("Device 2: Button 2: " + PluginImport.GetButtonState(2, 2));*/ /*if(PluginImport.GetHapticContact(1)) * Debug.Log("Device 1 touches: " + PluginImport.GetTouchedObjId(1) + " " + ConverterClass.ConvertIntPtrToByteToString(PluginImport.GetTouchedObjName(1))); * if (PluginImport.GetHapticContact(2)) * Debug.Log("Device 2 touches: " + PluginImport.GetTouchedObjId(2) + " " + ConverterClass.ConvertIntPtrToByteToString(PluginImport.GetTouchedObjName(2)));*/ }
void Update() { /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ //PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y);//To be deprecated //Update the Workspace as function of camera for (int i = 0; i < workspaceUpdateValue.Length; i++) { workspaceUpdateValue[i] = myHapticCamera.transform.rotation.eulerAngles.y; } PluginImport.UpdateHapticWorkspace(ConverterClass.ConvertFloatArrayToIntPtr(workspaceUpdateValue)); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); //Associate the cursor object with the haptic proxy value myGenericFunctionsClassScript.GetProxyValues(); //myGenericFunctionsClassScript.GetTouchedObject(); //Reset the writing on the board //if(ConverterClass.ConvertIntPtrToByteToString( PluginImport.GetTouchedObjectName()) == "reset") // GetTouchedObjectName - To be deprecated if (ConverterClass.ConvertIntPtrToByteToString(PluginImport.GetTouchedObjName(1)) == "reset") { myWritingScript.cleanBoard(); //Change the Color of the button material myResetButton.GetComponent <Renderer>().material.color = buttonResetColors[1]; } else { myResetButton.GetComponent <Renderer>().material.color = buttonResetColors[0]; } }
void Update() { if (PluginImport.GetButtonState(1, 2)) { DetachCochlea(); } if (PluginImport.GetButtonState(1, 1) & !hasEnded) { hasEnded = true; simMonitor.End(); } /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ //PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y);//To be deprecated //Update the Workspace as function of camera for (int i = 0; i < workspaceUpdateValue.Length; i++) { workspaceUpdateValue[i] = myHapticCamera.transform.rotation.eulerAngles.y; } PluginImport.UpdateHapticWorkspace(ConverterClass.ConvertFloatArrayToIntPtr(workspaceUpdateValue)); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); //Associate the cursor object with the haptic proxy value myGenericFunctionsClassScript.GetProxyValues(isKinematic); }
void Update() { /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); myGenericFunctionsClassScript.GetProxyValues(); myGenericFunctionsClassScript.GetTouchedObject(); //Debug.Log ("Button 1: " + PluginImport.GetButton1State()); //Debug.Log ("Button 2: " + PluginImport.GetButton2State()); //Reset the writing on the board if (ConverterClass.ConvertIntPtrToByteToString(PluginImport.GetTouchedObjectName()) == "reset") { myWritingScript.cleanBoard(); //Change the Color of the button material myResetButton.GetComponent <Renderer>().material.color = buttonResetColors[1]; } else { myResetButton.GetComponent <Renderer>().material.color = buttonResetColors[0]; } }
void Update() { /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); myGenericFunctionsClassScript.GetProxyValues(); myGenericFunctionsClassScript.GetTouchedObject(); //Debug.Log ("Button 1: " + PluginImport.GetButton1State()); //Debug.Log ("Button 2: " + PluginImport.GetButton2State()); }
void Update() { /***************************************************************/ //Act on the rigid body of the Manipulated object // if Mode = Manipulation Mode /***************************************************************/ if (PluginImport.GetMode() == 1) { ActivatingGrabbedObjectPropperties(); } /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ //PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y); //To be deprecated //Update the Workspace as function of camera for (int i = 0; i < workspaceUpdateValue.Length; i++) { workspaceUpdateValue[i] = myHapticCamera.transform.rotation.eulerAngles.y; } PluginImport.UpdateHapticWorkspace(ConverterClass.ConvertFloatArrayToIntPtr(workspaceUpdateValue)); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); //Associate the cursor object with the haptic proxy value myGenericFunctionsClassScript.GetProxyValues(); myGenericFunctionsClassScript.GetTouchedObject(); Debug.Log("Button 1: " + PluginImport.GetButton1State()); // To be deprecated Debug.Log("Button 2: " + PluginImport.GetButton2State()); // To be deprecated Debug.Log("Device 1: Button 1: " + PluginImport.GetButtonState(1, 1)); Debug.Log("Device 1: Button 2: " + PluginImport.GetButtonState(1, 2)); // if (PluginImport.GetButtonState(1, 2)) //{ // makeJengaBlocks(); //} if (PluginImport.GetButtonState(1, 1)) { Debug.Log("Device 1 : Button Up Pressed"); } else if (PluginImport.GetButtonState(1, 2)) { Debug.Log("Device 1 : Button Down Pressed"); } if (PluginImport.GetButtonState(2, 1)) { Debug.Log("Device 2 : Button Up Pressed"); } else if (PluginImport.GetButtonState(2, 2)) { Debug.Log("Device 2 : Button Down Pressed"); } const float rotSpeed = 1.0f; if (Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.LeftArrow)) { myHapticCamera.transform.RotateAround(Vector3.zero, new Vector3(0.0f, 1.0f, 0.0f), rotSpeed); } if (Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow)) { myHapticCamera.transform.RotateAround(Vector3.zero, new Vector3(0.0f, 1.0f, 0.0f), -rotSpeed); } }
void Update() { /////////////////////////////////// getting position of Haptic device /////////////////////// double[] pos = ConverterClass.ConvertIntPtrToDouble3(PluginImport.GetProxyPosition()); //Vector3 position1 = new Vector3 ((float)pos [2], (float)pos [1], -(float)pos [0]); // applying rotation as device is rotated 90 degrees to left... swapping coordinates ///////////////////////////////////////////////////////////////////////////////////////////// Vector3 position1 = new Vector3((float)pos [0], (float)pos [1], (float)pos [2]); position1 = rotation * position1; ///////////////////////////////// Instantiation of Targets as Key B is pressed + writing target coordinates to text file ////////////////////////// button1 = PluginImport.GetButton1State(); if (button1 && !previousbutton1stateI) { target [i] = Instantiate(ball); target [i].transform.position = new Vector3(i * 0.1f, j * 1.0f, -1.0f); using (StreamWriter writer = new StreamWriter("D:\\log.txt", true)) { writer.WriteLine(""); writer.Write("Position for Target "); writer.Write(i + 1); writer.Write(" = "); writer.Write(target[i].transform.position); } if (i > 0) { Destroy(target [i - 1]); // destroying previous targets as the next target is displayed } i++; j = j + 0.1f; } previousbutton1stateI = button1; ////////////////////////////////////////////////////////////////////////////////////////////////////////// button1 = PluginImport.GetButton1State(); // getting state of button 1 on phantom ///////////////////////////// routine for writing pointer current position to text file///////////////////////////////////// if (button1 && !previousbutton1state) { if (targetwritecounter > 0) { using (StreamWriter writer = new StreamWriter("D:\\log.txt", true)) { writer.WriteLine(""); writer.Write("Hand position for target "); writer.Write(targetwritecounter); writer.Write(" = "); writer.Write(gameObject.transform.position); } } targetwritecounter++; } previousbutton1state = button1; ////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////// Controlling visibility of haptic sphere ///////////////// if (Input.GetKeyDown(KeyCode.A)) // Controlling invisibility of the pointer object { visibility.GetComponent <MeshRenderer> ().enabled = false; // making object invisible on pressing A } if (Input.GetKeyDown(KeyCode.S)) { visibility.GetComponent <MeshRenderer> ().enabled = true; // Making object visible again on pressing S } ////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////// Recentering of Head Set (Occulus)///////////////////////////////////////// if (Input.GetKeyDown(KeyCode.F12)) { InputTracking.Recenter(); } ////////////////////////////////////////////////////////////////////////////////////////////////////// /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); ///////////// Origin offset for phantom local coordinates///////////////////// position1 [0] = position1 [0] - (-0.2178f); position1 [1] = position1 [1] - (-0.8274f); position1 [2] = position1 [2] - (-0.0001f); /////////////////////////////////////////////////////////////////////////////// Debug.Log("Phantom Coordinates" + position1.ToString("F4")); ////////////////// scaling between real world distance and unity distance /////////////// position1 [0] = position1 [0] * 0.33f; //Real world 10cm = 30cm in unity // scaling factor10/30 position1 [1] = position1 [1] * 0.5882f; //Real world 10cm = 17cm in unity // scaling factor10/17 position1 [2] = position1 [2] * 0.625f; //Real world 10cm = 16cm in unity // scaling factor10/16 ////////////////////////////////////////////////////////////////////////////////////////// //////////////// Linear transformation from phantom origin to occulus origin ///////////////// // position1 [0] = position1 [0] + 0.006f+ 0.08f; position1 [1] = position1 [1] + 0.63f; position1 [2] = position1 [2] + 0.3f; transform.position = position1; //Debug.Log ("Phantom Coordinates" + position1.ToString ("F4")); ////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////// Printing Phantom coordinates to console ////////////////////// //Debug.Log ("Phantom Coordinates" + position1.ToString ("F4")); ////////////////////////////////////////////////////////////////////////////////////////////// //Debug.Log ("Button 1: " + PluginImport.GetButton1State()); //Debug.Log ("Button 2: " + PluginImport.GetButton2State()); }
void Update() { /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ //PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y);//To be deprecated //Update the Workspace as function of camera for (int i = 0; i < workspaceUpdateValue.Length; i++) { workspaceUpdateValue[i] = myHapticCamera.transform.rotation.eulerAngles.y; } PluginImport.UpdateHapticWorkspace(ConverterClass.ConvertFloatArrayToIntPtr(workspaceUpdateValue)); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); //Associate the cursor object with the haptic proxy value myGenericFunctionsClassScript.GetProxyValues(); //For the Puncture Mode effect if (PluginImport.GetMode() == 3) { //Debug.Log ("Contact state is set to " + PluginImport.GetContact()); //Debug.Log ("Penetration State " + PluginImport.GetPenetrationRatio()); double[] myScp = new double[3]; myScp = ConverterClass.ConvertIntPtrToDouble3(PluginImport.GetFirstScpPt()); //Debug.Log (" SCP " + myScp[0] + " " + myScp[1] + " " + myScp[2]); Vector3 posInjectionHole; posInjectionHole = ConverterClass.ConvertDouble3ToVector3(myScp); GameObject.Find("InjectionMarker").transform.position = posInjectionHole; /*double[] myProx = new double[3]; * myProx = ConverterClass.ConvertIntPtrToDouble3(PluginImport.GetProxyPosition()); * * Vector3 posProx; * posProx = ConverterClass.ConvertDouble3ToVector3(myProx); * GameObject.Find ("ProxyTipMarker").transform.position = posProx;*/ /*double[] myDev = new double[3]; * myDev = ConverterClass.ConvertIntPtrToDouble3(PluginImport.GetDevicePosition()); * * Vector3 posDevice; * posDevice = ConverterClass.ConvertDouble3ToVector3(myDev); * GameObject.Find ("DeviceTipMarker").transform.position = posDevice;*/ double[] myPinch = new double[3]; myPinch = ConverterClass.ConvertIntPtrToDouble3(PluginImport.GetPunctureDirection()); Vector3 start = new Vector3(); start = ConverterClass.ConvertDouble3ToVector3(myScp); Vector3 end = new Vector3(); end = ConverterClass.ConvertDouble3ToVector3(myPinch); end.Normalize(); Debug.DrawLine(start, start + end * maxPenetration, Color.green); //Ray Cast so we can determine the limitation of the puncture RaycastHit[] hits; hits = Physics.RaycastAll(start, end, maxPenetration); if (hits.Length != 0) { //Declare a float array to store the tissue layer float[] tissueLayers = new float[hits.Length]; //Declare a string array to store the name of the tissue layer string[] punctObjects = new string[hits.Length]; int nbLayer = 0; for (int i = 0; i < hits.Length; i++) { RaycastHit hit = hits[i]; //Only if the object is declared as touchable if (hit.collider.gameObject.tag == "Touchable") { tissueLayers[nbLayer] = hit.distance; punctObjects[nbLayer] = hit.collider.name; nbLayer++; } } /*Declaration of the Puncture Stack * Additionally, on the basis of the puncture stack components, the plugin setup a penetration restriction * - due to the fact that Proxy Method along such constraint line is not accurate - most probably due to the fact * that device position and proxy position differ because the constraint applies forces onto the device. * So, the plugin impedes the proxy to penetrate in underlying layer when their popthrough values is null */ SetPunctureStack(nbLayer, punctObjects, tissueLayers); } } }
void Update() { /*if (PluginImport.GetButtonState(1, 1) && isKinematic) * { * Debug.Log("Inside button press"); * isKinematic = !isKinematic; * * GameObject[] capsules = GameObject.FindGameObjectsWithTag("ElectrodeCapsule"); * * foreach (GameObject go in capsules) * { * Rigidbody goRB = go.GetComponent<Rigidbody>(); * goRB.isKinematic = false; * } * }*/ if (PluginImport.GetButtonState(1, 2)) { SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex); } /*if (PluginImport.GetButtonState(1, 1)) * { * isKinematic = !isKinematic; * * GameObject[] capsules = GameObject.FindGameObjectsWithTag("ElectrodeCapsule"); * * foreach (GameObject go in capsules) * { * Rigidbody goRB = go.GetComponent<Rigidbody>(); * goRB.isKinematic = false; * } * }*/ /***************************************************************/ //Update Workspace as function of camera /***************************************************************/ //PluginImport.UpdateWorkspace(myHapticCamera.transform.rotation.eulerAngles.y);//To be deprecated //Update the Workspace as function of camera //for (int i = 0; i < workspaceUpdateValue.Length; i++) //workspaceUpdateValue[i] = myHapticCamera.transform.rotation.eulerAngles.y; //PluginImport.UpdateHapticWorkspace(ConverterClass.ConvertFloatArrayToIntPtr(workspaceUpdateValue)); /***************************************************************/ //Update cube workspace /***************************************************************/ myGenericFunctionsClassScript.UpdateGraphicalWorkspace(); /***************************************************************/ //Haptic Rendering Loop /***************************************************************/ PluginImport.RenderHaptic(); //Associate the cursor object with the haptic proxy value myGenericFunctionsClassScript.GetProxyValues(isKinematic); //myGenericFunctionsClassScript.GetProxyValues(); /*if (isKinematic) * { * GameObject[] capsules = GameObject.FindGameObjectsWithTag("ElectrodeCapsule"); * * foreach (GameObject go in capsules) * { * Rigidbody goRB = go.GetComponent<Rigidbody>(); * goRB.constraints = RigidbodyConstraints.None; * } * isKinematic = false; * }*/ //Vector3 pos = ConverterClass.ConvertDouble3ToVector3(ConverterClass.ConvertIntPtrToDouble3(PluginImport.GetProxyPosition())); //Vector3 movement = (rb.position - pos).normalized; //rb.MovePosition(rb.position + movement * Time.deltaTime); //hapticCursor.transform.position = pos; //myGenericFunctionsClassScript.GetTouchedObject(); //Reset the writing on the board //if(ConverterClass.ConvertIntPtrToByteToString( PluginImport.GetTouchedObjectName()) == "reset") // GetTouchedObjectName - To be deprecated //if (ConverterClass.ConvertIntPtrToByteToString(PluginImport.GetTouchedObjName(1)) == "reset") //{ //myWritingScript.cleanBoard(); //Change the Color of the button material //myResetButton.GetComponent<Renderer>().material.color = buttonResetColors[1]; //} //else //myResetButton.GetComponent<Renderer>().material.color = buttonResetColors[0]; }