public abstract void SetWorkingHardBoundsInfo(HmdQuad_t [] pQuadsBuffer);
public override void SetWorkingHardBoundsInfo(HmdQuad_t [] pQuadsBuffer)
{
CheckIfUsable();
VRNativeEntrypoints.VR_IVRChaperoneSetup_SetWorkingHardBoundsInfo(m_pVRChaperoneSetup,pQuadsBuffer,(uint) pQuadsBuffer.Length);
}
public abstract bool GetWorkingHardBoundsInfo(out HmdQuad_t [] pQuadsBuffer);
public abstract bool SetWorkingPhysicalBoundsInfo(HmdQuad_t [] pQuadsBuffer);
public override bool GetWorkingHardBoundsInfo(out HmdQuad_t [] pQuadsBuffer)
{
CheckIfUsable();
uint punQuadsCount = 0;
bool result = VRNativeEntrypoints.VR_IVRChaperoneSetup_GetWorkingHardBoundsInfo(m_pVRChaperoneSetup,null,ref punQuadsCount);
pQuadsBuffer= new HmdQuad_t[punQuadsCount];
result = VRNativeEntrypoints.VR_IVRChaperoneSetup_GetWorkingHardBoundsInfo(m_pVRChaperoneSetup,pQuadsBuffer,ref punQuadsCount);
return result;
}
public abstract bool GetWorkingPlayAreaRect(ref HmdQuad_t rect);
public abstract void SetWorkingCollisionBoundsInfo(HmdQuad_t [] pQuadsBuffer);
public abstract bool GetLivePhysicalBoundsInfo(out HmdQuad_t [] pQuadsBuffer);
public abstract bool GetWorkingCollisionBoundsInfo(out HmdQuad_t [] pQuadsBuffer);
public override bool SetWorkingPhysicalBoundsInfo(HmdQuad_t [] pQuadsBuffer)
{
CheckIfUsable();
bool result = VRNativeEntrypoints.VR_IVRChaperoneSetup_SetWorkingPhysicalBoundsInfo(m_pVRChaperoneSetup,pQuadsBuffer,(uint) pQuadsBuffer.Length);
return result;
}
public override bool GetWorkingPlayAreaRect(ref HmdQuad_t rect)
{
CheckIfUsable();
bool result = VRNativeEntrypoints.VR_IVRChaperoneSetup_GetWorkingPlayAreaRect(m_pVRChaperoneSetup,ref rect);
return result;
}
public void BuildMesh()
{
var rect = new HmdQuad_t();
if (!GetBounds(size, ref rect))
{
return;
}
var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
vertices = new Vector3[corners.Length * 2];
for (int i = 0; i < corners.Length; i++)
{
var c = corners[i];
vertices[i] = new Vector3(c.v0, 0.01f, c.v2);
}
if (borderThickness == 0.0f)
{
GetComponent <MeshFilter>().mesh = null;
return;
}
for (int i = 0; i < corners.Length; i++)
{
int next = (i + 1) % corners.Length;
int prev = (i + corners.Length - 1) % corners.Length;
var nextSegment = (vertices[next] - vertices[i]).normalized;
var prevSegment = (vertices[prev] - vertices[i]).normalized;
var vert = vertices[i];
vert += Vector3.Cross(nextSegment, Vector3.up) * borderThickness;
vert += Vector3.Cross(prevSegment, Vector3.down) * borderThickness;
vertices[corners.Length + i] = vert;
}
var triangles = new int[]
{
0, 1, 4,
1, 5, 4,
1, 2, 5,
2, 6, 5,
2, 3, 6,
3, 7, 6,
3, 0, 7,
0, 4, 7
};
var uv = new Vector2[]
{
new Vector2(0.0f, 0.0f),
new Vector2(1.0f, 0.0f),
new Vector2(0.0f, 0.0f),
new Vector2(1.0f, 0.0f),
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 1.0f),
new Vector2(0.0f, 1.0f),
new Vector2(1.0f, 1.0f)
};
var colors = new Color[]
{
color,
color,
color,
color,
new Color(color.r, color.g, color.b, 0.0f),
new Color(color.r, color.g, color.b, 0.0f),
new Color(color.r, color.g, color.b, 0.0f),
new Color(color.r, color.g, color.b, 0.0f)
};
var mesh = new Mesh();
GetComponent <MeshFilter>().mesh = mesh;
mesh.vertices = vertices;
mesh.uv = uv;
mesh.colors = colors;
mesh.triangles = triangles;
var renderer = GetComponent <MeshRenderer>();
#if UNITY_EDITOR
renderer.material = UnityEditor.AssetDatabase.GetBuiltinExtraResource <Material>("Sprites-Default.mat");
#else
renderer.material = Resources.GetBuiltinResource <Material>("Sprites-Default.mat");
#endif
renderer.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off;
renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
renderer.receiveShadows = false;
renderer.lightProbeUsage = LightProbeUsage.Off;
}
// Update is called once per frame
void Update()
{
var cam = SteamVR_Render.Top();
HmdQuad_t areaRect = new HmdQuad_t();
if (cam && SteamVR_PlayArea.GetBounds(SteamVR_PlayArea.Size.Calibrated, ref areaRect))
{
float xNorm = cam.transform.localPosition.x / Mathf.Abs(areaRect.vCorners0.v0) / 2f;
float zNorm = cam.transform.localPosition.z / Mathf.Abs(areaRect.vCorners0.v2) / 2f;
//Debug.Log("NORMALIZED POS " + xNorm + "," + zNorm);
//Debug.Log("Cam pos " + cam.transform.localPosition);
//Debug.Log("Rect " + PV(areaRect.vCorners0) + " " + PV(areaRect.vCorners1) + " " + PV(areaRect.vCorners2) + " " + PV(areaRect.vCorners3));
Vector3 camLookFlat = cam.transform.forward;
camLookFlat.y = 0f;
camLookFlat = camLookFlat.normalized * (flipped ? -1f : 1f);
bool outsideNormalArea = Mathf.Abs(xNorm) > EDGE_THRESHOLD || Mathf.Abs(zNorm) > EDGE_THRESHOLD;
if (outsideNormalArea)
{
if (!startedFade && returnedToCenter)
{
startedFade = true;
fadeStarted = Time.time;
SteamVR_Fade.Start(Color.black, FADE_OUT_TIME);
initialTurnLookDir = camLookFlat;
returnedToCenter = false;
Debug.Log("FADE OUT");
}
}
bool lookingOpposite = Vector3.Dot(initialTurnLookDir, camLookFlat) < -TURN_DOT_THRESH;
bool lookingOppositeIsh = Vector3.Dot(initialTurnLookDir, camLookFlat) < 0f;
if (!outsideNormalArea || lookingOpposite) // looking away
{
if (finishedFade)
{
startedFade = false;
finishedFade = false;
SteamVR_Fade.Start(Color.clear, FADE_IN_TIME);
Debug.Log("FADE IN AND MAYBE FLIP");
// don't flip if youre still looking the same way
if (lookingOppositeIsh)
{
Debug.Log("Flipitt");
Vector3 localXZ = cam.transform.localPosition * (flipped ? -1f : 1f);
localXZ.y = 0f;
transform.position += 2f * localXZ;
transform.Rotate(new Vector3(0f, 180f, 0f));
flipped = !flipped;
}
}
}
if (!outsideNormalArea)
{
returnedToCenter = true;
}
Debug.Log("camdir " + camLookFlat + " initdir " + initialTurnLookDir + " lookingopp " + lookingOpposite + " ish " + lookingOppositeIsh);
if (startedFade && Time.time > fadeStarted + FADE_OUT_TIME && !finishedFade)
{
finishedFade = true;
}
}
else
{
Debug.Log("No area I guess :O cam: " + cam);
}
}
//Construct the cyPIPES tiles
public void BuildTiles(){
//OpenVR: Gather actual corners of floor room setup
var rect = new HmdQuad_t ();
if (!GetBounds (size, ref rect))
return;
var corners = new HmdVector3_t[] { rect.vCorners0, rect.vCorners1, rect.vCorners2, rect.vCorners3 };
vertices = new Vector3[corners.Length * 2];
for (int i = 0; i < corners.Length; i++) {
var c = corners [i];
vertices [i] = new Vector3 (c.v0, 0.01f, c.v2);
}
//Construct new tiles
if (vertices.Length > 2) {
//destroy any previous tiles if they exsist
if (inwardTiles.Count > 2) {
foreach (string key in inwardTiles.Keys) {
Destroy (inwardTiles [key]);
}
foreach (string key in outwardTiles.Keys) {
Destroy (outwardTiles [key]);
}
}
//Calculate vertices (just the 8 for now)
List<Vector3> spaceVerts = new List<Vector3> ();
spaceVerts.Add (vertices [0]);//back bottom right
spaceVerts.Add (vertices [1]);//back bottom left
spaceVerts.Add (vertices [2]);//front bottom left
spaceVerts.Add (vertices [3]);//front bottom right
spaceVerts.Add (new Vector3 (vertices [0].x, vertices [0].y + volumeHeight, vertices [0].z));//top bottom right
spaceVerts.Add (new Vector3 (vertices [1].x, vertices [1].y + volumeHeight, vertices [1].z));//top bottom left
spaceVerts.Add (new Vector3 (vertices [2].x, vertices [2].y + volumeHeight, vertices [2].z));//top bottom left
spaceVerts.Add (new Vector3 (vertices [3].x, vertices [3].y + volumeHeight, vertices [3].z));//top bottom right
//Calulate tile sizes
//For now this will be simply 6 sided and in this order bk,lft,ft,rht,top,btm
List<float> widths = new List<float> ();
List<float> heights = new List<float> ();
widths.Add (Vector3.Distance (spaceVerts [0], spaceVerts [1]));//back
heights.Add (Vector3.Distance (spaceVerts [0], spaceVerts [4]));//back
widths.Add (Vector3.Distance (spaceVerts [1], spaceVerts [2]));//left
heights.Add (Vector3.Distance (spaceVerts [1], spaceVerts [5]));//left
widths.Add (Vector3.Distance (spaceVerts [2], spaceVerts [3]));//front
heights.Add (Vector3.Distance (spaceVerts [2], spaceVerts [6]));//front
widths.Add (Vector3.Distance (spaceVerts [3], spaceVerts [0]));//right
heights.Add (Vector3.Distance (spaceVerts [3], spaceVerts [7]));//right
widths.Add (Vector3.Distance (spaceVerts [4], spaceVerts [5]));//top
heights.Add (Vector3.Distance (spaceVerts [4], spaceVerts [7]));//top
widths.Add (Vector3.Distance (spaceVerts [0], spaceVerts [1]));//bottom
heights.Add (Vector3.Distance (spaceVerts [0], spaceVerts [3]));//bottom
//Calcuateing the center of tracked space
centerOfTrackedSpace = spaceVerts [0];
centerOfTrackedSpace = new Vector3 (centerOfTrackedSpace.x - widths [0] / 2, centerOfTrackedSpace.y, centerOfTrackedSpace.z);
centerOfTrackedSpace = new Vector3 (centerOfTrackedSpace.x, centerOfTrackedSpace.y, centerOfTrackedSpace.z + heights [0] / 2);
centerOfTrackedSpace = new Vector3 (centerOfTrackedSpace.x, centerOfTrackedSpace.y + volumeHeight / 2, centerOfTrackedSpace.z);
//GameObject tester = cyPIPEStileBuild.CreateTile (0.2f, 0.2f, "tester", false);
//tester.transform.parent = gameObject.transform;
//tester.transform.position = centerOfTrackedSpace;
//build tiles and place/oriente them and add to active tile list
//back normal inward
GameObject backTile = cyPIPEStileBuild.CreateTile (widths [0], heights [0], "backTile", true);
backTile.transform.parent = gameObject.transform;
inwardTiles.Add ("backTile", backTile);
backTile.transform.position = new Vector3 (spaceVerts [0].x - widths [0], spaceVerts [0].y, spaceVerts [0].z);
//back normal outward
GameObject backTileOut = cyPIPEStileBuild.CreateTile (widths [0], heights [0], "backTileOut", true);
backTileOut.transform.parent = gameObject.transform;
outwardTiles.Add ("backTileOut", backTileOut);
backTileOut.transform.position = new Vector3 (spaceVerts [0].x, spaceVerts [0].y, spaceVerts [0].z);
backTileOut.transform.eulerAngles = new Vector3 (0.0f, 180.0f, 0.0f);
//left normal inward
GameObject leftTile = cyPIPEStileBuild.CreateTile (widths [1], heights [1], "leftTile", true);
leftTile.transform.parent = gameObject.transform;
inwardTiles.Add ("leftTile", leftTile);
leftTile.transform.position = new Vector3 (spaceVerts [1].x, spaceVerts [1].y, spaceVerts [1].z + widths [1]);
leftTile.transform.eulerAngles = new Vector3 (0.0f, 90.0f, 0.0f);
//left normal outward
GameObject leftTileOut = cyPIPEStileBuild.CreateTile (widths [1], heights [1], "leftTileOut", true);
leftTileOut.transform.parent = gameObject.transform;
outwardTiles.Add ("leftTileOut", leftTileOut);
leftTileOut.transform.position = new Vector3 (spaceVerts [1].x, spaceVerts [1].y, spaceVerts [1].z);
leftTileOut.transform.eulerAngles = new Vector3 (0.0f, -90.0f, 0.0f);
//Front normal inward
GameObject frontTile = cyPIPEStileBuild.CreateTile (widths [2], heights [2], "frontTile", true);
frontTile.transform.parent = gameObject.transform;
inwardTiles.Add ("frontTile", frontTile);
frontTile.transform.position = new Vector3 (spaceVerts [2].x + widths [2], spaceVerts [2].y, spaceVerts [2].z);
frontTile.transform.eulerAngles = new Vector3 (0.0f, 180.0f, 0.0f);
//Front normal outward
GameObject frontTileOut = cyPIPEStileBuild.CreateTile (widths [2], heights [2], "frontTileOut", true);
frontTileOut.transform.parent = gameObject.transform;
outwardTiles.Add ("frontTileOut", frontTileOut);
frontTileOut.transform.position = new Vector3 (spaceVerts [2].x, spaceVerts [2].y, spaceVerts [2].z);
frontTileOut.transform.eulerAngles = new Vector3 (0.0f, 0.0f, 0.0f);
//Right normal inward
GameObject rightTile = cyPIPEStileBuild.CreateTile (widths [3], heights [3], "rightTile", true);
rightTile.transform.parent = gameObject.transform;
inwardTiles.Add ("rightTile", rightTile);
rightTile.transform.position = new Vector3 (spaceVerts [3].x, spaceVerts [3].y, spaceVerts [3].z - widths [3]);
rightTile.transform.eulerAngles = new Vector3 (0.0f, -90.0f, 0.0f);
//Right normal outward
GameObject rightTileOut = cyPIPEStileBuild.CreateTile (widths [3], heights [3], "rightTileOut", true);
rightTileOut.transform.parent = gameObject.transform;
outwardTiles.Add ("rightTileOut", rightTileOut);
rightTileOut.transform.position = new Vector3 (spaceVerts [3].x, spaceVerts [3].y, spaceVerts [3].z);
rightTileOut.transform.eulerAngles = new Vector3 (0.0f, 90.0f, 0.0f);
//top normal inward
GameObject topTile = cyPIPEStileBuild.CreateTile (widths [4], heights [4], "topTile", true);
topTile.transform.parent = gameObject.transform;
inwardTiles.Add ("topTile", topTile);
topTile.transform.position = new Vector3 (spaceVerts [4].x - widths [4], spaceVerts [4].y, spaceVerts [4].z);
topTile.transform.eulerAngles = new Vector3 (90.0f, 0.0f, 0.0f);
//top normal outward
GameObject topTileOut = cyPIPEStileBuild.CreateTile (widths [4], heights [4], "topTileOut", true);
topTileOut.transform.parent = gameObject.transform;
outwardTiles.Add ("topTileOut", topTileOut);
topTileOut.transform.position = new Vector3 (spaceVerts [4].x - widths [4], spaceVerts [4].y, spaceVerts [4].z + heights [4]);
topTileOut.transform.eulerAngles = new Vector3 (-90.0f, 0.0f, 0.0f);
//bottom normal inward
GameObject bottomTile = cyPIPEStileBuild.CreateTile (widths [5], heights [5], "bottomTile", true);
bottomTile.transform.parent = gameObject.transform;
inwardTiles.Add ("bottomTile", bottomTile);
bottomTile.transform.position = new Vector3 (spaceVerts [5].x, spaceVerts [5].y - volumeHeight, spaceVerts [5].z * -1);
bottomTile.transform.eulerAngles = new Vector3 (-90.0f, 0.0f, 0.0f);
//bottom normal outward
GameObject bottomTileOut = cyPIPEStileBuild.CreateTile (widths [5], heights [5], "bottomTileOut", true);
bottomTileOut.transform.parent = gameObject.transform;
outwardTiles.Add ("bottomTileOut", bottomTileOut);
bottomTileOut.transform.position = new Vector3 (spaceVerts [5].x, spaceVerts [5].y - volumeHeight, spaceVerts [5].z);
bottomTileOut.transform.eulerAngles = new Vector3 (90.0f, 0.0f, 0.0f);
//Signal that all tiles are parsed
tilesParsed = true;
}
}
