protected virtual void Start()
{
if (controller == null)
{
controller = this.GetComponent <VRTK_ControllerEvents>();
}
if (controller == null)
{
Debug.LogError("VRTK_WorldPointer requires a SteamVR Controller that has the VRTK_ControllerEvents script attached to it");
return;
}
Utilities.SetPlayerObject(this.gameObject, VRTK_PlayerObject.ObjectTypes.Controller);
//Setup controller event listeners
controller.AliasPointerOn += new ControllerInteractionEventHandler(EnablePointerBeam);
controller.AliasPointerOff += new ControllerInteractionEventHandler(DisablePointerBeam);
eventsRegistered = true;
headset = DeviceFinder.HeadsetTransform();
playArea = GameObject.FindObjectOfType <SteamVR_PlayArea>();
playAreaCursorBoundaries = new GameObject[4];
var tmpMaterial = Resources.Load("WorldPointer") as Material;
if (pointerMaterial != null)
{
tmpMaterial = pointerMaterial;
}
pointerMaterial = new Material(tmpMaterial);
pointerMaterial.color = pointerMissColor;
}
/**
* Funkcia pre vypocet faktoru - ak nieje build premenna USE_STEAMVR definovana, vrati 1 (bez zmeny scale)
* pre build so SteamVR vypocita scale faktor nasledovne:
* spocita 4 body pre x a pre z suradnice z hracej plochy hraca a vydeli 2 (pretoze obdlznik ma 4 vrcholi a pre zistenie
* velkosti steny nam staci spocitat 2 (len nevieme ktore))
*
* nasledne vezme minimum z velkosti x a z suradnice a to je nas faktor (aby sa scena zmestila na hraciu plochu)
*
*/
public static float GetFactor()
{
#if USE_STEAMVR
var rect = new HmdQuad_t();
if (SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect))
{
float countx = Mathf.Abs(convertValveVector(rect.vCorners0).x)
+ Mathf.Abs(convertValveVector(rect.vCorners1).x)
+ Mathf.Abs(convertValveVector(rect.vCorners2).x)
+ Mathf.Abs(convertValveVector(rect.vCorners3).x);
float countz = Mathf.Abs(convertValveVector(rect.vCorners0).z)
+ Mathf.Abs(convertValveVector(rect.vCorners1).z)
+ Mathf.Abs(convertValveVector(rect.vCorners2).z)
+ Mathf.Abs(convertValveVector(rect.vCorners3).z);
// Debug.Log("Counting scaleFactor; sum: x=" + (countx / 2) / optimalPlayAreaSize.x + ", y=" + (countz / 2) / optimalPlayAreaSize.z);
return(Mathf.Min((countx / 2) / optimalPlayAreaSize.x, (countz / 2) / optimalPlayAreaSize.z));
}
else
{
return(1f);
}
#else
return(1f);
#endif
}
private void Start()
{
playArea = GetComponent <SteamVR_PlayArea>();
if (movementTransform == null)
{
if (VRTK.DeviceFinder.HeadsetTransform() != null)
{
movementTransform = VRTK.DeviceFinder.HeadsetTransform();
}
else
{
Debug.LogWarning("This 'VRTK_RoomExtender' script needs a movementTransform to work.The default 'SteamVR_Camera' or 'SteamVR_GameView' was not found.");
}
}
cameraRig = GameObject.FindObjectOfType <SteamVR_PlayArea>().gameObject.transform;
//headCirclePosition = new Vector3(movementTransform.localPosition.x, 0, movementTransform.localPosition.z);
additionalMovementEnabled = !additionalMovementEnabledOnButtonPress;
if (debugTransform)
{
debugTransform.localScale = new Vector3(headZoneRadius * 2, 0.01f, headZoneRadius * 2);
//debugTransform.localPosition = headCirclePosition;
}
MoveHeadCircleNonLinearDrift();
lastPosition = movementTransform.localPosition;
lastRotation = movementTransform.localRotation.eulerAngles.y;
}
void SetupVive2Controllers()
{
if (null == steamVRPlayArea)
{
steamVRPlayArea = FindObjectOfType <SteamVR_PlayArea>();
}
if (null != steamVRPlayArea)
{
foreach (SteamVR_Behaviour_Pose pose in steamVRPlayArea.GetComponentsInChildren <SteamVR_Behaviour_Pose>(true))
{
if (pose.inputSource == SteamVR_Input_Sources.RightHand)
{
controllerRight = pose.transform;
}
else if (pose.inputSource == SteamVR_Input_Sources.LeftHand)
{
controllerLeft = pose.transform;
}
}
centerEye = steamVRPlayArea.GetComponentInChildren <Camera>(true).transform;
}
else
{
Debug.LogError("Please import SteamVR Plugin and put [CameraRig] prefab into your scene");
}
}
//Handles scaling of UI tools for different room sizes
void Position3DUI()
{
ToolContainer = GameObject.Find("ToolContainer").transform;
foreach (var wc in FindObjectsOfType <WandController>())
{
wc.DrawingControlContainer = ToolContainer;
}
//Shelves = GameObject.Find("ControlContainer").transform;
Valve.VR.HmdQuad_t roomDims = new Valve.VR.HmdQuad_t();
SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref roomDims);
RoomScale = new Vector3(Mathf.Abs(roomDims.vCorners0.v0 - roomDims.vCorners2.v0), Mathf.Abs(roomDims.vCorners0.v2 - roomDims.vCorners2.v2), 1);
if (false)//RoomScale.x < 0.1f && RoomScale.y < 0.1f)
{
// Destroy(GameObject.Find("ToolContainer"));
//Destroy(GameObject.Find("ControlContainer"));
ToolContainer.Translate(-0.5f * 3, 0, 0);
Shelves.Translate(0, 0, 0.5f * 3);
}
else
{
ToolContainer.Translate(-0.5f * RoomScale.x, 0, 0);
//Shelves.Translate(0, 0, 0.5f * RoomScale.y);
}
}
void pointToPoint(SteamVR_PlayArea playArea, GainsZone gainsZone, Transform player, Direction direction)
{
switch (direction)
{
case Direction.PosX:
float posXVirtual = (gainsZone.Trans.position.x - player.position.x) + gainsZone.Size.x / 2;
float posXReal = gainsZone.Size.x / 2 - player.localPosition.x;
PosX = posXVirtual / posXReal;
break;
case Direction.NegX:
float negXVirtual = (gainsZone.Trans.position.x - player.position.x) * -1 + gainsZone.Size.x / 2;
float negXReal = gainsZone.Size.x / 2 + player.localPosition.x;
NegX = negXVirtual / negXReal;
break;
case Direction.PosZ:
float posZVirtual = (gainsZone.Trans.position.z - player.position.z) + gainsZone.Size.z / 2;
float posZReal = gainsZone.Size.z / 2 - player.localPosition.z;
PosZ = posZVirtual / posZReal;
break;
case Direction.NegZ:
float negZVirtual = (gainsZone.Trans.position.z - player.position.z) * -1 + gainsZone.Size.z / 2;
float negZReal = gainsZone.Size.z / 2 + player.localPosition.z;
NegZ = negZVirtual / negZReal;
break;
default:
break;
}
}
void pointToPoint(SteamVR_PlayArea playArea, GainsZone gainsZone, Transform player)
{
pointToPoint(playArea, gainsZone, player, Direction.PosX);
pointToPoint(playArea, gainsZone, player, Direction.NegX);
pointToPoint(playArea, gainsZone, player, Direction.PosZ);
pointToPoint(playArea, gainsZone, player, Direction.NegZ);
}
bool CheckDespawn()
{
if (myState == RespawnObjectState.Valid)
{
//Turn off myself.
Valve.VR.HmdQuad_t quad = new Valve.VR.HmdQuad_t();
SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref quad);
//Debug.DrawLine(GetPoint(quad.vCorners0), Vector3.one, Color.red, 5.0f);
//Debug.DrawLine(GetPoint(quad.vCorners1), Vector3.one, Color.green, 5.0f);
//Debug.DrawLine(GetPoint(quad.vCorners2), Vector3.one, Color.grey, 5.0f);
//Debug.DrawLine(GetPoint(quad.vCorners3), Vector3.one, Color.yellow, 5.0f);
bool[] FarFromCorner = new bool[4];
float flatDistAway = 0;
flatDistAway += FlatDistFrom(GetPoint(quad.vCorners0));
flatDistAway += FlatDistFrom(GetPoint(quad.vCorners1));
flatDistAway += FlatDistFrom(GetPoint(quad.vCorners2));
flatDistAway += FlatDistFrom(GetPoint(quad.vCorners3));
//failCount += Convert.ToInt32(FlatDistFrom(GetPoint(quad.vCorners0)) > ResetAtDistFromBounds);
//failCount += Convert.ToInt32(FlatDistFrom(GetPoint(quad.vCorners1)) > ResetAtDistFromBounds);
//failCount += Convert.ToInt32(FlatDistFrom(GetPoint(quad.vCorners2)) > ResetAtDistFromBounds);
//failCount += Convert.ToInt32(FlatDistFrom(GetPoint(quad.vCorners3)) > ResetAtDistFromBounds);
//Debug.Log(failCount + "\n");
if (flatDistAway >= 13)
{
return(true);
}
}
return(false);
}
// Use this for initialization
void Start()
{
SteamVR_PlayArea playAreaScript = VRCamera.GetComponent <SteamVR_PlayArea>();
Valve.VR.HmdQuad_t quad = new Valve.VR.HmdQuad_t();
SteamVR_PlayArea.GetBounds(playAreaScript.size, ref quad);
// Calc width of room
float sizeX = quad.vCorners0.v0 - quad.vCorners3.v0;
float sizeZ = quad.vCorners0.v2 - quad.vCorners2.v2;
Debug.Log(sizeX);
Debug.Log(sizeZ);
//Instantiate(box, new Vector3(quad.vCorners0.v0, quad.vCorners0.v1, quad.vCorners0.v2), Quaternion.identity);
//Instantiate(box, new Vector3(quad.vCorners1.v0, quad.vCorners1.v1, quad.vCorners1.v2), Quaternion.identity);
//Instantiate(box, new Vector3(quad.vCorners2.v0, quad.vCorners2.v1, quad.vCorners2.v2), Quaternion.identity);
//Instantiate(box, new Vector3(quad.vCorners3.v0, quad.vCorners3.v1, quad.vCorners3.v2), Quaternion.identity);
Vector3 center = VRCamera.transform.position;
/// Create the walls
// Horizontal (along x axis), which means z varies
Instantiate(Wall, new Vector3(0, 0, sizeZ), new Quaternion());
Instantiate(Wall, new Vector3(0, 0, -sizeZ), new Quaternion());
// Vertical (along z axis), which means 90 degree rotation and x varies
//Instantiate(Wall, new Vector3(sizeX, 0, 0), new Quaternion());
//Instantiate(Wall, new Vector3(-sizeX, 0, 0), new Quaternion());
Instantiate(Wall, new Vector3(sizeX, 0, 0), Quaternion.Euler(0, 90, 0));
Instantiate(Wall, new Vector3(-sizeX, 0, 0), Quaternion.Euler(0, 90, 0));
//Vector3 FrontWallPosition = ;
}
// Use this for initialization
void Start()
{
playArea = GetComponent <SteamVR_PlayArea> ();
//Teleporting Play Area
teleportPlayArea = new GameObject("TeleportPlayArea");
teleportPlayArea.transform.SetParent(transform);
MeshRenderer mR = teleportPlayArea.AddComponent <MeshRenderer> ();
MeshFilter mF = teleportPlayArea.AddComponent <MeshFilter> ();
mF.mesh = playArea.GetComponent <MeshFilter> ().sharedMesh;
mR.material = playArea.GetComponent <MeshRenderer> ().sharedMaterial;
SteamVR_TrackedObject[] trackedObjects = transform.GetComponentsInChildren <SteamVR_TrackedObject> (true);
for (int i = 0; i < trackedObjects.Length; i++)
{
if (trackedObjects [i].index == SteamVR_TrackedObject.EIndex.Hmd)
{
hmd = trackedObjects [i].transform.parent;
}
}
playerTeleportLocation = GameObject.Instantiate(playerTeleportLocationPrefab).transform;
playerTeleportLocation.SetParent(teleportPlayArea.transform);
teleportPlayArea.SetActive(false);
}
private void Awake()
{
scFSM = suspect.GetComponent <SuspectControllerFSM>();
scFSM.setScenarioController(this);
timer = 0f;
transitioning = false;
GRS = CC.GetComponent <GrammarRecognizerScript>();
DM = CC.GetComponent <DialogueManager>();
CM = CC.GetComponent <CameraMove>();
Audio1 = Officer.GetComponent <AudioSource>();
Audio2 = car.GetComponent <AudioSource>();
playArea = CC.GetComponentInChildren <SteamVR_PlayArea>();
copAnim = Officer.GetComponent <Animator>();
JimAnim = suspect.GetComponent <Animator>();
GuardAnim = guard.GetComponent <Animator>();
BossAnim = boss.GetComponent <Animator>();
JimAC = suspect.GetComponent <AnimController_Jim>();
VRS = CC.GetComponent <VoiceRecognizer_Scenario>();
currentScene = SCENE.INTRO;
interrupt = false;
shot = new int[4];
suspectGun.SetActive(false);
BuildingInside.SetActive(false);
BuildingOutside.SetActive(false);
results_cg.alpha = 0;
}
void SetupSteamVR2Controllers()
{
if (steamVRPlayArea == null)
{
steamVRPlayArea = FindObjectOfType <SteamVR_PlayArea>();
}
if (steamVRPlayArea != null)
{
foreach (SteamVR_Behaviour_Pose poseComp in steamVRPlayArea.GetComponentsInChildren <SteamVR_Behaviour_Pose>(true))
{
if (poseComp.inputSource == SteamVR_Input_Sources.RightHand)
{
m_rightController = poseComp.gameObject;
}
else if (poseComp.inputSource == SteamVR_Input_Sources.LeftHand)
{
m_leftController = poseComp.gameObject;
}
}
}
else
{
Valve.VR.InteractionSystem.Player PlayerComponent = FindObjectOfType <Valve.VR.InteractionSystem.Player>();
m_rightController = PlayerComponent.rightHand.gameObject;
m_leftController = PlayerComponent.leftHand.gameObject;
}
if (m_steamVRClickAction == null)
{
Debug.LogError("CURVEDUI: No SteamVR action to use for button interactions. Choose the action you want to use to click the buttons on CurvedUISettings component.");
}
}
void Start()
{
var rect = new HmdQuad_t();
SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect);
corner1.x = rect.vCorners0.v0;
corner1.y = rect.vCorners0.v1;
corner1.z = rect.vCorners0.v2;
corner2.x = rect.vCorners1.v0;
corner2.y = rect.vCorners1.v1;
corner2.z = rect.vCorners1.v2;
corner3.x = rect.vCorners2.v0;
corner3.y = rect.vCorners2.v1;
corner3.z = rect.vCorners2.v2;
corner4.x = rect.vCorners3.v0;
corner4.y = rect.vCorners3.v1;
corner4.z = rect.vCorners3.v2;
bot = getmidPoint(corner1, corner2);
top = getmidPoint(corner3, corner4);
left = getmidPoint(corner2, corner3);
right = getmidPoint(corner1, corner4);
roomInitialization();
//creates the first room, namely the starter room
createRoom("1");
}
void SetupSteamVR2Controllers()
{
if (steamVRPlayArea == null)
{
steamVRPlayArea = FindObjectOfType <SteamVR_PlayArea>();
}
if (steamVRPlayArea != null)
{
foreach (SteamVR_Behaviour_Pose poseComp in steamVRPlayArea.GetComponentsInChildren <SteamVR_Behaviour_Pose>(true))
{
if (poseComp.inputSource == SteamVR_Input_Sources.RightHand)
{
m_rightController = poseComp.gameObject;
}
else if (poseComp.inputSource == SteamVR_Input_Sources.LeftHand)
{
m_leftController = poseComp.gameObject;
}
}
}
else
{
Debug.LogError("CURVEDUI: Can't find SteamVR_PlayArea component on the scene. Add a reference to it manually to CurvedUIInputModule on EventSystem gameobject.", this.gameObject);
}
if (m_steamVRClickAction == null)
{
Debug.LogError("CURVEDUI: No SteamVR action to use for button interactions. Choose the action you want to use to click the buttons on CurvedUISettings component.");
}
}
void ScaleToPlayArea()
{
var rect = new Valve.VR.HmdQuad_t();
SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect);
transform.localScale = new Vector3(Mathf.Abs(rect.vCorners0.v0 - rect.vCorners2.v0), transform.localScale.y, transform.localScale.z);
}
// Use this for initialization
void Start()
{
playArea = GameObject.Find("[CameraRig]").GetComponent <SteamVR_PlayArea>();
headHeight = GameObject.Find("HeadHeight");
cameraEye = GameObject.Find("Camera (eye)");
timeRemainingGO = GameObject.Find("TimeRemaining");
levelContainer = new GameObject("LevelContainer");
rotationContainer = new GameObject("RotationContainer");
restartButton.GetComponent <UIImageButton>().Hide(0f);
//levelScreen.SetActive(true);
scoreScreen.SetActive(false);
//GameObject.Find("3DButtonUSA").GetComponent<Button3D>().OnHover();
//GameObject.Find("3DButtonUSA").GetComponent<Button3D>().OnTrigger();
GameObject.Find("Level Sections").SetActive(false);
DOTween.Init(false, true, LogBehaviour.ErrorsOnly);
SaveGame.LoadGame();
initTime = Time.time;
//GameObject.Find("3DButtonUSA").GetComponent<Button3D>().OnHover();
//GameObject.Find("3DButtonUSA").GetComponent<Button3D>().OnTrigger();
if (!debugging)
{
GameObject.Find("Computer").SetActive(false);
GameObject.Find("Prefabs").SetActive(false);
}
//StartCoroutine(Wait());
}
// Use this for initialization
void Start()
{
playArea = GameObject.FindObjectOfType <SteamVR_PlayArea> ();
BuildAllWalls();
// playAreaVertices = GetVector3VerticesOfPlayArea();
}
private void Awake()
{
playArea = GetComponentInParent <SteamVR_PlayArea>();
originalPosition = playArea.transform.position;
originalRotation = playArea.transform.rotation;
originalScale = playArea.transform.localScale;
}
// Use this for initialization
private void Start()
{
_playArea = FindObjectOfType <SteamVR_PlayArea>();
_verts = _playArea.vertices;
float xExtent = Mathf.Abs(_verts[0].x - _verts[1].x);
float zExtent = Mathf.Abs(_verts[1].z - _verts[2].z);
int xChunksNeeded = (int)Math.Ceiling(xExtent / _floorVoxel.transform.localScale.x);
int zChunksNeeded = (int)Math.Ceiling(zExtent / _floorVoxel.transform.localScale.z);
for (int x = 0; x < xChunksNeeded; x++)
{
for (int z = 0; z < zChunksNeeded; z++)
{
GameObject voxel = Instantiate(_floorVoxel, new Vector3(
x * _floorVoxel.transform.localScale.x - xExtent / 2,
0f,
z * _floorVoxel.transform.localScale.z - zExtent / 2),
Quaternion.identity) as GameObject;
voxel.transform.SetParent(transform);
voxel.layer = SceneManager.Instance.geometryLayer;
}
}
}
void Awake()
{
SteamVR_Camera steamCamera = this.transform.parent.gameObject.GetComponentInChildren <SteamVR_Camera>();
if (steamCamera == null)
{
vrCamera = Camera.main.transform;
}
else
{
vrCamera = steamCamera.transform;
}
if (vrCamera == null)
{
Debug.LogError("vrCamera is null");
enabled = false;
return;
}
SteamVR_PlayArea steamPlayArea = this.transform.parent.gameObject.GetComponent <SteamVR_PlayArea>();
if (steamPlayArea == null)
{
vrPlayArea = transform.parent;
}
else
{
vrPlayArea = steamPlayArea.transform;
}
if (vrPlayArea == null)
{
Debug.LogError("vrplayarea is null");
enabled = false;
return;
}
}
// Use this for initialization
void Start()
{
var rect = new HmdQuad_t();
if (!SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect))
{
return;
}
// Could do without that
var cornersVR = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
corners = new Vector3[cornersVR.Length];
for (int i = 0; i < cornersVR.Length; i++)
{
var c = cornersVR[i];
corners[i] = new Vector3(c.v0, 0.01f, c.v2);
}
// Make sure this is always the case
minX = -Mathf.Abs(corners[0].x);
maxX = Mathf.Abs(corners[0].x);
minZ = -Mathf.Abs(corners[0].z);
maxZ = Mathf.Abs(corners[0].z);
music = transform.GetComponent <AudioSource>();
mixer = music.outputAudioMixerGroup.audioMixer;
// Debugging
text = GetComponentInChildren <TextMesh>();
}
// Use this for initialization
void Start()
{
rect = new Valve.VR.HmdQuad_t();
SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref rect);
transform.localScale = new Vector3(Mathf.Abs(rect.vCorners0.v0 - rect.vCorners2.v0), floorThickness, Mathf.Abs(rect.vCorners0.v2 - rect.vCorners2.v2));
transform.position = new Vector3(0f, -floorThickness / 2f, 0f);
}
// Use this for initialization
void Start()
{
playArea = GetComponent <SteamVR_PlayArea>();
for (int i = 0; i < playArea.vertices.Length; i++)
{
print("element " + i + " is " + playArea.vertices[i]);
}
}
// Start is called before the first frame update
void Start()
{
playArea = GetComponent <SteamVR_PlayArea>();
rightViveController = GameObject.Find("Controller (right)").transform;
//set Leap Player to center of PlaySpace
viveParamsAuthorityManager.SetPosition(transform.position);
}
void Start()
{
trans = GetComponent <Transform>();
Player = trans.Find("Camera (eye)");
physicsPlayer = GetComponent <VRRigidbodyPlayer>();
playArea = GetComponent <SteamVR_PlayArea>();
gains = new Gain();
lastPlayerPos = Player.localPosition;
}
// Token: 0x06001314 RID: 4884 RVA: 0x0006B258 File Offset: 0x00069458
public override void InitBoundaries()
{
SteamVR_PlayArea steamVR_PlayArea = this.GetCachedSteamVRPlayArea();
if (steamVR_PlayArea != null)
{
steamVR_PlayArea.BuildMesh();
}
}
public void Set(VrDebug debug, Transform eyeTransform, SteamVR_PlayArea playArea, float offset)
{
gameObject.SetActive(false);
vrDebug = debug;
this.eyeTransform = eyeTransform;
this.playArea = playArea;
this.offset = offset;
VrDebug.ConsoleLines.ForEach(Write);
VrDebug.OnNewConsoleLine += (s, args) => Write(args.Content);
Application.logMessageReceived += (condition, trace, type) =>
{
string log = "";
switch (type)
{
case LogType.Assert:
log += "[Assert] " + condition;
break;
case LogType.Error:
log += "[Error] " + condition;
break;
case LogType.Warning:
log += "[Warn] " + condition;
break;
case LogType.Log:
log += "[Log] " + condition;
break;
case LogType.Exception:
log += "[Exception] " + condition;
break;
default:
log += "[Unknown] " + condition;
break;
}
VrDebug.WriteLine(log);
};
keepAreaVisibleToggle.onValueChanged.AddListener(value => debug.IsPlayAreaAlwaysVisible = value);
closeButton.onClick.AddListener(vrDebug.CloseDebugWindow);
quitButton.onClick.AddListener(() =>
{
Application.Quit();
#if UNITY_EDITOR
UnityEditor.EditorApplication.isPlaying = false;
#endif
});
}
protected virtual void CreateArea()
{
PlayArea = new GameObject("PlayArea").AddComponent <SteamVR_PlayArea>();
PlayArea.drawInGame = true;
PlayArea.size = SteamVR_PlayArea.Size.Calibrated;
PlayArea.transform.SetParent(transform, false);
DirectionIndicator = CreateClone();
}
// Token: 0x06001317 RID: 4887 RVA: 0x0006B2F8 File Offset: 0x000694F8
public override float GetPlayAreaBorderThickness()
{
SteamVR_PlayArea steamVR_PlayArea = this.GetCachedSteamVRPlayArea();
if (steamVR_PlayArea != null)
{
return(steamVR_PlayArea.borderThickness);
}
return(0f);
}
// Token: 0x0600131A RID: 4890 RVA: 0x0006B374 File Offset: 0x00069574
public override void SetDrawAtRuntime(bool value)
{
SteamVR_PlayArea steamVR_PlayArea = this.GetCachedSteamVRPlayArea();
if (steamVR_PlayArea != null)
{
steamVR_PlayArea.drawInGame = value;
steamVR_PlayArea.enabled = true;
}
}
public static bool GetBounds(SteamVR_PlayArea.Size size, ref HmdQuad_t pRect)
{
if (size == SteamVR_PlayArea.Size.Calibrated)
{
bool flag = !SteamVR.active && !SteamVR.usingNativeSupport;
if (flag)
{
EVRInitError eVRInitError = EVRInitError.None;
OpenVR.Init(ref eVRInitError, EVRApplicationType.VRApplication_Other);
}
CVRChaperone chaperone = OpenVR.Chaperone;
bool flag2 = chaperone != null && chaperone.GetPlayAreaRect(ref pRect);
if (!flag2)
{
UnityEngine.Debug.LogWarning("Failed to get Calibrated Play Area bounds! Make sure you have tracking first, and that your space is calibrated.");
}
if (flag)
{
OpenVR.Shutdown();
}
return flag2;
}
try
{
string text = size.ToString().Substring(1);
string[] array = text.Split(new char[]
{
'x'
}, 2);
float num = float.Parse(array[0]) / 200f;
float num2 = float.Parse(array[1]) / 200f;
pRect.vCorners0.v0 = num;
pRect.vCorners0.v1 = 0f;
pRect.vCorners0.v2 = num2;
pRect.vCorners1.v0 = num;
pRect.vCorners1.v1 = 0f;
pRect.vCorners1.v2 = -num2;
pRect.vCorners2.v0 = -num;
pRect.vCorners2.v1 = 0f;
pRect.vCorners2.v2 = -num2;
pRect.vCorners3.v0 = -num;
pRect.vCorners3.v1 = 0f;
pRect.vCorners3.v2 = num2;
return true;
}
catch
{
}
return false;
}
void OnEnable()
{
steamVR_PlayArea = GameObject.FindObjectOfType<SteamVR_PlayArea>();
vrtk_RoomExtender = GameObject.FindObjectOfType<VRTK_RoomExtender>();
if (steamVR_PlayArea == null || vrtk_RoomExtender == null)
{
Debug.LogWarning("Could not find 'SteamVR_PlayArea' or 'VRTK_RoomExtender'. Please check if they are attached to the 'CameraRig'");
return;
}
bool success = SteamVR_PlayArea.GetBounds(steamVR_PlayArea.size, ref steamVrBounds);
if (success)
{
lastSize = steamVR_PlayArea.size;
BuildMesh();
}
else
{
Debug.LogWarning("Could not get the Calibrated Play Area bounds. This script 'RoomExtender_PlayArea' tries to get the size when SteamVR is running.");
}
}
// Use this for initialization
void Start () {
SaveLoad.Load();
if( Game.current == null){
Game.current = new Game();
}
EventManager.OnTriggerDown += OnTriggerDown;
EventManager.OnTriggerUp += OnTriggerUp;
//EventManager.StayTrigger += StayTrigger;
restartSound = gameObject.AddComponent<AudioSource>();
blarpSound = gameObject.AddComponent<AudioSource>();
restartSound.clip = restartClip;
blarpSound.clip = blarpClip;
empty = new GameObject();
PlayArea = CameraRig.GetComponent<SteamVR_PlayArea>();
Vector3 v = PlayArea.vertices[0];
Platform = GameObject.CreatePrimitive(PrimitiveType.Cube);
Platform.transform.localScale = new Vector3( Mathf.Abs( v.x ) * 1.5f ,1.0f , Mathf.Abs( v.z ) * 1.5f);
Platform.transform.position = new Vector3( 0f , -0.49f , 0f );
Material m = PlatformMat; //new Material( PlatformShader );
Platform.GetComponent<MeshRenderer>().material = m ;
//m = PlatformMat;
Platform.GetComponent<MeshRenderer>().material.SetVector("_Size" , Platform.transform.localScale );
Platform.GetComponent<MeshRenderer>().material.SetFloat("_Learning" , 0 );
Vector3 tPos = new Vector3( 0f , 1.5f , -3f );
Title = (GameObject) Instantiate( TitlePrefab, tPos , new Quaternion());
Title.transform.localEulerAngles = new Vector3(0,180,0);
//m = TitleMat;
Title.GetComponent<MeshRenderer>().material.SetVector("_Scale" , Title.transform.localScale );
AudioList = new AudioClip[]{ (AudioClip)Resources.Load("Audio/hydra/TipHit1"),
(AudioClip)Resources.Load("Audio/hydra/TipHit2"),
(AudioClip)Resources.Load("Audio/hydra/TipHit3"),
(AudioClip)Resources.Load("Audio/hydra/TipHit4"), };
HighScoreAudioList = new AudioClip[]{ (AudioClip)Resources.Load("Audio/hydra/BaseHit"),
//(AudioClip)Resources.Load("Audio/hydra/ArmStroke2"),
//(AudioClip)Resources.Load("Audio/hydra/ArmStroke3"),
};
MommaHitAudioList = new AudioClip[]{ (AudioClip)Resources.Load("Audio/hydra/ArmStroke1"),
(AudioClip)Resources.Load("Audio/hydra/ArmStroke2"),
(AudioClip)Resources.Load("Audio/hydra/ArmStroke3"),
};
MommaHitSound = gameObject.AddComponent<AudioSource>();
for( var i = 0; i < AudioList.Length; i ++ ){
print(AudioList[i]);
AudioSource audioSource = gameObject.AddComponent<AudioSource>();
audioSource.clip = AudioList[i];
audioSource.Play();
audioSource.volume = 0;
AudioSources.Add( audioSource );
}
highScoreBalls = new GameObject[10];
for( int i = 0; i < 10; i++){
float rad = Random.Range( 4 , 10 );
Vector3 p = Random.onUnitSphere * rad;
highScoreBalls[i] = (GameObject) Instantiate( HighScorePrefab, p , new Quaternion());
highScoreBalls[i].transform.localScale = new Vector3( rad/4 , rad / 4 , rad /4);
int rand = Random.Range( 0 , 1 );
highScoreBalls[i].GetComponent<AudioSource>().clip = HighScoreAudioList[ rand ];
highScoreBalls[i].GetComponent<AudioSource>().pitch = .5f;
}
setHighScoreBalls( Game.current.highScore );
Momma = (GameObject) Instantiate( MommaPrefab, new Vector3() , new Quaternion());
Momma.GetComponent<Momma>().BallGameObj = transform.gameObject;
Momma.transform.position = new Vector3( 0 , 3 , 0 );
StartButton = (GameObject) Instantiate( StartButtonPrefab, new Vector3() , new Quaternion());
StartButton.GetComponent<StartButton>().BallGameObj = transform.gameObject;
StartButton.transform.position = new Vector3(0 , 1 , -Platform.transform.localScale.z * .55f );
//HandL.GetComponent<HandScript>().BallGameObj = transform.gameObject;
//HandR.GetComponent<HandScript>().BallGameObj = transform.gameObject;
ScoreText = Momma.transform.Find("Score").gameObject;//.GetComponent<TextMesh>();
score = 0;
// Make a new object
LearningBlarp = (GameObject) Instantiate( BabyPrefab, new Vector3() , new Quaternion());
LearningBlarp.transform.position = new Vector3( 0 , 1 , -2);
LearningBlarp.GetComponent<SpringJoint>().connectedBody = Hand.GetComponent<Rigidbody>();
//AudioSource audioSource = LearningBlarp.GetComponent<AudioSource>();
LearningBlarp.GetComponent<Rigidbody>().drag = .7f - (score / 100);
LearningBlarp.GetComponent<Rigidbody>().mass = .2f - (score / 340);
LearningBlarp.GetComponent<Rigidbody>().angularDrag = 200;
LearningBlarp.GetComponent<Rigidbody>().freezeRotation = true;
//LearningBlarp.GetComponent<Collider>().enabled = false;
LearningBlarp.transform.localScale = LearningBlarp.transform.localScale * (2.0f - (score/30));
LearningBlarp.GetComponent<MeshRenderer>().material.SetFloat("_Score" , (float)score );
LearningBlarp.GetComponent<MeshRenderer>().material.SetFloat("_Learning" , 0 );
LearningBlarp.GetComponent<TrailRenderer>().enabled = false;
setTutorialObjects();
if( tutorialFinished == false ){
startTutorial();
}else{
addTutorialButton();
}
restart( transform.gameObject );
}
protected virtual void Start()
{
if (GetComponent<VRTK_ControllerEvents>() == null)
{
Debug.LogError("VRTK_WorldPointer is required to be attached to a SteamVR Controller that has the VRTK_ControllerEvents script attached to it");
return;
}
this.name = "PlayerObject_" + this.name;
//Setup controller event listeners
GetComponent<VRTK_ControllerEvents>().AliasPointerOn += new ControllerInteractionEventHandler(EnablePointerBeam);
GetComponent<VRTK_ControllerEvents>().AliasPointerOff += new ControllerInteractionEventHandler(DisablePointerBeam);
headset = DeviceFinder.HeadsetTransform();
playArea = GameObject.FindObjectOfType<SteamVR_PlayArea>();
playAreaCursorBoundaries = new GameObject[4];
pointerMaterial = new Material(Shader.Find("Unlit/TransparentColor"));
pointerMaterial.color = pointerMissColor;
}
protected virtual void Start()
{
if (controller == null)
{
controller = this.GetComponent<VRTK_ControllerEvents>();
}
if (controller == null)
{
Debug.LogError("VRTK_WorldPointer requires a SteamVR Controller that has the VRTK_ControllerEvents script attached to it");
return;
}
Utilities.SetPlayerObject(this.gameObject, VRTK_PlayerObject.ObjectTypes.Controller);
//Setup controller event listeners
controller.AliasPointerOn += new ControllerInteractionEventHandler(EnablePointerBeam);
controller.AliasPointerOff += new ControllerInteractionEventHandler(DisablePointerBeam);
controller.AliasPointerSet += new ControllerInteractionEventHandler(SetPointerDestination);
eventsRegistered = true;
headset = DeviceFinder.HeadsetTransform();
playArea = GameObject.FindObjectOfType<SteamVR_PlayArea>();
playAreaCursorBoundaries = new GameObject[4];
var tmpMaterial = Resources.Load("WorldPointer") as Material;
if (pointerMaterial != null)
{
tmpMaterial = pointerMaterial;
}
pointerMaterial = new Material(tmpMaterial);
pointerMaterial.color = pointerMissColor;
}
