private void Awake()
{
if (!ItemSpinSound)
{
Debug.LogWarning(gameObject.name.ToString() + "is missing an Audio Reference!");
}
if (GetComponent <Valve.VR.InteractionSystem.Interactable>() != null)
{
_interactable = GetComponent <Valve.VR.InteractionSystem.Interactable>();
}
else
{
Debug.LogError("Failed to get Interactable on " + gameObject.name.ToString());
}
if (GetComponent <AudioSource>() != null)
{
_audioSource = GetComponent <AudioSource>();
}
else
{
Debug.LogError("Failed to get AudioSource on" + gameObject.name.ToString());
}
if (GetComponent <MeshRenderer>() == null)
{
Debug.LogError("Failed to get MeshRenderer on " + gameObject.name.ToString());
}
_interactable.onAttachedToHand += ChangeColor;
_interactable.onDetachedFromHand += StopChangeColor;
}
private void OnTriggerStay(Collider other)
{
if (objectCurrentlyHeld == null && other.gameObject.tag == tagToSearchFor)
{
Valve.VR.InteractionSystem.Interactable interactable = other.gameObject.GetComponent <Valve.VR.InteractionSystem.Interactable> ();
if (interactable.attachedToHand == null)
{
objectCurrentlyHeld = other.gameObject;
objectCurrentlyHeld.transform.position = this.transform.position;
objectCurrentlyHeld.transform.rotation = Quaternion.Euler(rotation);
}
}
else if (objectCurrentlyHeld == other.gameObject && other.gameObject.transform.rotation != Quaternion.Euler(rotation))
{
Valve.VR.InteractionSystem.Interactable interactable = other.gameObject.GetComponent <Valve.VR.InteractionSystem.Interactable>();
if (interactable.attachedToHand == null)
{
objectCurrentlyHeld.transform.rotation = Quaternion.Euler(rotation);
}
}
else if (objectCurrentlyHeld == other.gameObject && other.gameObject.transform.position != this.transform.position)
{
Valve.VR.InteractionSystem.Interactable interactable = other.gameObject.GetComponent <Valve.VR.InteractionSystem.Interactable>();
if (interactable.attachedToHand == null)
{
objectCurrentlyHeld.transform.position = this.transform.position;
}
}
}
void Start()
{
outline = GetComponent <Outline>();
outline.OutlineMode = Outline.Mode.Disabled;
interactable = GetComponent <Valve.VR.InteractionSystem.Interactable>();
EventManager.instance.OnItemHighlight += TurnOnHighLight;
}
private void Awake()
{
interactable = GetComponent <Valve.VR.InteractionSystem.Interactable>();
if (DebugTable.PuzzleDebug && targetSpot == null)
{
Debug.LogError($"{this.name}: Target Spot unassigned!");
}
}
void Update()
{
calculateGlobalSliderPosition();
if (m_railGroupGlobalHandle != null && m_IsGlobalHandleGlobal)
{
m_railGroupGlobalHandle.transform.position = getWorldPositionAtGlobalSliderPosition(sliderPosition);
}
if (prevPos != sliderPosition)
{
if (onSliderPositionUpdate != null)
{
onSliderPositionUpdate.Invoke(this);
if (oneshotSound != null)
{
Valve.VR.InteractionSystem.Interactable interactable = children[m_currentRail].slider.child.GetComponent <Valve.VR.InteractionSystem.Interactable>();
if (interactable != null)
{
if (interactable.attachedToHand != null)
{
oneshotSound.thisAudioSource = interactable.attachedToHand.GetComponent <AudioSource>();
oneshotSound.Play((int)AudioClipGroup.SoundTypes_hoverClickSounds.hover);
}
else if (interactable.hoveringHand != null)
{
oneshotSound.thisAudioSource = interactable.hoveringHand.GetComponent <AudioSource>();
oneshotSound.Play((int)AudioClipGroup.SoundTypes_hoverClickSounds.hover);
}
}
}
}
if (sliderPosition >= .25f && prevPos < .25f && onSliderOn_25Percent != null)
{
onSliderOn_25Percent.Invoke();
}
if (sliderPosition >= .75f && prevPos < .75f && onSliderOn_75Percent != null)
{
onSliderOn_75Percent.Invoke();
}
if (onSliderBinaryOn != null && sliderPosition > m_minMechanicalSliderValue && prevPos <= m_minMechanicalSliderValue)
{
onSliderBinaryOn.Invoke();
}
else if (onSliderOnMax != null && sliderPosition > m_maxMechanicalSliderValue && prevPos <= m_maxMechanicalSliderValue)
{
onSliderOnMax.Invoke();
sliderPosition = 1;
}
else if (onSliderBinaryOff != null && sliderPosition <= m_minMechanicalSliderValue && prevPos > m_minMechanicalSliderValue)
{
onSliderBinaryOff.Invoke();
sliderPosition = 0;
}
}
prevPos = sliderPosition;
}
void Start()
{
//Add To Events
EventManager.instance.OnTimeJump += DetectChange;
interactable = GetComponent <Valve.VR.InteractionSystem.Interactable>();
elementHolder = elementZone.GetComponent <ItemHolder>();
element = elementHolder.objectToHold;
elemntCollider = element.GetComponent <BoxCollider>();
elemntCollider.enabled = false;
}
private void Awake()
{
if (objectData == null)
{
objectData = GetComponent <Valve.VR.InteractionSystem.Interactable>();
}
if (saveData == null)
{
saveData = GetComponent <InteractableSaveData>();
}
}
// Start is called before the first frame update
void Awake()
{
m_GLHandleVisuals_Group = GetComponent <GLHandleVisuals_Group>();
if (m_InteractableHoverEvents == null)
{
m_InteractableHoverEvents = GetComponent <Valve.VR.InteractionSystem.InteractableHoverEvents>();
m_interactable = GetComponent <Valve.VR.InteractionSystem.Interactable>();
m_throwable = GetComponent <Valve.VR.InteractionSystem.Throwable>();
targetGO = gameObject;
}
if (m_InteractableHoverEvents == null)
{
Transform tmpTransform = transform;
for (int i = 0; i < 100; i++)
{
tmpTransform = tmpTransform.parent;
if (tmpTransform != null)
{
m_InteractableHoverEvents = tmpTransform.GetComponent <Valve.VR.InteractionSystem.InteractableHoverEvents>();
m_interactable = tmpTransform.GetComponent <Valve.VR.InteractionSystem.Interactable>();
m_throwable = tmpTransform.GetComponent <Valve.VR.InteractionSystem.Throwable>();
targetGO = tmpTransform.gameObject;
}
else
{
break;
}
if (m_InteractableHoverEvents != null)
{
break;
}
}
if (m_InteractableHoverEvents == null)
{
m_InteractableHoverEvents = transform.GetComponentInChildren <Valve.VR.InteractionSystem.InteractableHoverEvents>();
m_interactable = transform.GetComponent <Valve.VR.InteractionSystem.Interactable>();
m_throwable = transform.GetComponent <Valve.VR.InteractionSystem.Throwable>();
targetGO = transform.gameObject;
}
else if (m_InteractableHoverEvents == null)
{
Debug.Log("[" + transform.parent.name + "/" + gameObject.name + "] WARNING: Hovering on these gizmos will not work because the script couldn't auto-find the InteractableHoverEvents it should subscribe to. Assign it manually in the inspector.");
}
}
if (m_interactable == null && m_InteractableHoverEvents != null)
{
m_interactable = m_InteractableHoverEvents.GetComponent <Valve.VR.InteractionSystem.Interactable>();
}
m_GLHandleVisuals_Group.interactableLinkedTo = getInteractable;
}
private void Start()
{
radiation.SetActive(false);
source = GetComponent <AudioSource>();
puffEffect.SetActive(false);
//Get the interactable component
interactable = GetComponentInParent <Valve.VR.InteractionSystem.Interactable>();
//Allows access to material
currentMaterial = GetComponent <Renderer>().material;
//Make sure composition matches what its set to.
currentMaterial.color = currentColor;
//Save what it is currenty/ Wont trigger if they match later
previousColor = currentColor;
//Sets the timeSHift method to only call when time is jumped
EventManager.instance.OnTimeJump += TimeShiftChange;
}
//-------------------------------------------------
private void Awake()
{
interactable = GetComponentInParent <Interactable>();
//
// Create child game object for see thru renderer
//
seeThru = new GameObject("_see_thru");
seeThru.transform.parent = transform;
seeThru.transform.localPosition = Vector3.zero;
seeThru.transform.localRotation = Quaternion.identity;
seeThru.transform.localScale = Vector3.one;
//
// Copy mesh filter
//
var sourceMeshFilter = GetComponent <MeshFilter>();
if (sourceMeshFilter != null)
{
var destMeshFilter = seeThru.AddComponent <MeshFilter>();
destMeshFilter.sharedMesh = sourceMeshFilter.sharedMesh;
}
//
// Copy mesh renderer
//
var sourceMeshRenderer = GetComponent <MeshRenderer>();
if (sourceMeshRenderer != null)
{
sourceRenderer = sourceMeshRenderer;
destRenderer = seeThru.AddComponent <MeshRenderer>();
}
//
// Copy skinned mesh renderer
//
var sourceSkinnedMeshRenderer = GetComponent <SkinnedMeshRenderer>();
if (sourceSkinnedMeshRenderer != null)
{
var destSkinnedMeshRenderer = seeThru.AddComponent <SkinnedMeshRenderer>();
sourceRenderer = sourceSkinnedMeshRenderer;
destRenderer = destSkinnedMeshRenderer;
destSkinnedMeshRenderer.sharedMesh = sourceSkinnedMeshRenderer.sharedMesh;
destSkinnedMeshRenderer.rootBone = sourceSkinnedMeshRenderer.rootBone;
destSkinnedMeshRenderer.bones = sourceSkinnedMeshRenderer.bones;
destSkinnedMeshRenderer.quality = sourceSkinnedMeshRenderer.quality;
destSkinnedMeshRenderer.updateWhenOffscreen = sourceSkinnedMeshRenderer.updateWhenOffscreen;
}
//
// Create see thru materials
//
if (sourceRenderer != null && destRenderer != null)
{
var materialCount = sourceRenderer.sharedMaterials.Length;
var destRendererMaterials = new Material[materialCount];
for (var i = 0; i < materialCount; i++)
{
destRendererMaterials[i] = seeThruMaterial;
}
destRenderer.sharedMaterials = destRendererMaterials;
for (var i = 0; i < destRenderer.materials.Length; i++)
{
destRenderer.materials[i].renderQueue = 2001; // Rendered after geometry
}
for (var i = 0; i < sourceRenderer.materials.Length; i++)
{
if (sourceRenderer.materials[i].renderQueue == 2000)
{
sourceRenderer.materials[i].renderQueue = 2002;
}
}
}
seeThru.gameObject.SetActive(false);
}
//-------------------------------------------------
void Awake()
{
interactable = this.GetComponent <Interactable>();
magicEffect.SetActive(false);
line.positionCount = 0;
}
// Start is called before the first frame update
void Start()
{
effect.SetActive(false);
interactable = GetComponent <Valve.VR.InteractionSystem.Interactable>();
EventManager.instance.OnTimeJump += DetectChange;
}
protected virtual void Awake()
{
interactable = GetComponent <Interactable>();
}
private void Awake()
{
interactable = GetComponent <Valve.VR.InteractionSystem.Interactable>();
rb = GetComponent <Rigidbody>();
}
//-------------------------------------------------
private void OnParentHandHoverEnd(Interactable other)
{
HideHighlight();
}
void Start()
{
interactable = GetComponent <Valve.VR.InteractionSystem.Interactable>();
EventManager.instance.OnItemHighlight += TurnOnHighLight;
}
protected virtual void Awake()
{
mappingChangeSamples = new float[numMappingChangeSamples];
interactable = GetComponent <Interactable>();
}
private void Awake()
{
this.interactable = this.GetComponent <ValveVR.Interactable>();
}
void Start()
{
EventManager.instance.OnItemHighlight += IsHighlighted;
EventManager.instance.OnTimeJump += ItemJump;
interactable = GetComponent <Valve.VR.InteractionSystem.Interactable>();
}
//-------------------------------------------------
// Continue to hover over this object indefinitely, whether or not the Hand moves out of its interaction trigger volume.
//
// interactable - The Interactable to hover over indefinitely.
//-------------------------------------------------
public void HoverLock(Interactable interactable)
{
HandDebugLog("HoverLock " + interactable);
hoverLocked = true;
hoveringInteractable = interactable;
}
//-------------------------------------------------
private void UpdateHovering()
{
if ((noSteamVRFallbackCamera == null) && (controller == null))
{
return;
}
if (hoverLocked)
{
return;
}
if (applicationLostFocusObject.activeSelf)
{
return;
}
var closestDistance = float.MaxValue;
Interactable closestInteractable = null;
// Pick the closest hovering
var flHoverRadiusScale = playerInstance.transform.lossyScale.x;
var flScaledSphereRadius = hoverSphereRadius * flHoverRadiusScale;
// if we're close to the floor, increase the radius to make things easier to pick up
var handDiff = Mathf.Abs(transform.position.y - playerInstance.trackingOriginTransform.position.y);
var boxMult = Util.RemapNumberClamped(handDiff, 0.0f, 0.5f * flHoverRadiusScale, 5.0f, 1.0f) * flHoverRadiusScale;
// null out old vals
for (var i = 0; i < overlappingColliders.Length; ++i)
{
overlappingColliders[i] = null;
}
Physics.OverlapBoxNonAlloc(
hoverSphereTransform.position - new Vector3(0, flScaledSphereRadius * boxMult - flScaledSphereRadius, 0),
new Vector3(flScaledSphereRadius, flScaledSphereRadius * boxMult * 2.0f, flScaledSphereRadius),
overlappingColliders,
Quaternion.identity,
hoverLayerMask.value
);
// DebugVar
var iActualColliderCount = 0;
foreach (var collider in overlappingColliders)
{
if (collider == null)
{
continue;
}
var contacting = collider.GetComponentInParent <Interactable>();
// Yeah, it's null, skip
if (contacting == null)
{
continue;
}
// Ignore this collider for hovering
var ignore = collider.GetComponent <IgnoreHovering>();
if (ignore != null)
{
if (ignore.onlyIgnoreHand == null || ignore.onlyIgnoreHand == this)
{
continue;
}
}
// Can't hover over the object if it's attached
if (attachedObjects.FindIndex(l => l.attachedObject == contacting.gameObject) != -1)
{
continue;
}
// Occupied by another hand, so we can't touch it
if (otherHand && otherHand.hoveringInteractable == contacting)
{
continue;
}
// Best candidate so far...
var distance = Vector3.Distance(contacting.transform.position, hoverSphereTransform.position);
if (distance < closestDistance)
{
closestDistance = distance;
closestInteractable = contacting;
}
iActualColliderCount++;
}
// Hover on this one
hoveringInteractable = closestInteractable;
if (iActualColliderCount > 0 && iActualColliderCount != prevOverlappingColliders)
{
prevOverlappingColliders = iActualColliderCount;
HandDebugLog("Found " + iActualColliderCount + " overlapping colliders.");
}
}
void GetReferences()
{
m_interactable = GetComponent <Valve.VR.InteractionSystem.Interactable>();
m_interactableHE = GetComponent <Valve.VR.InteractionSystem.InteractableHoverEvents>();
m_throwable = GetComponent <Valve.VR.InteractionSystem.Throwable>();
}
//-------------------------------------------------
private void ShowPointer(Hand newPointerHand, Hand oldPointerHand)
{
if (!visible)
{
pointedAtTeleportMarker = null;
pointerShowStartTime = Time.time;
visible = true;
meshFading = true;
teleportPointerObject.SetActive(false);
teleportArc.Show( );
foreach (TeleportMarkerBase teleportMarker in teleportMarkers)
{
if (teleportMarker.markerActive && teleportMarker.ShouldActivate(player.feetPositionGuess))
{
teleportMarker.gameObject.SetActive(true);
teleportMarker.Highlight(false);
}
}
startingFeetOffset = player.trackingOriginTransform.position - player.feetPositionGuess;
movedFeetFarEnough = false;
if (onDeactivateObjectTransform.gameObject.activeSelf)
{
onDeactivateObjectTransform.gameObject.SetActive(false);
}
onActivateObjectTransform.gameObject.SetActive(true);
loopingAudioSource.clip = pointerLoopSound;
loopingAudioSource.loop = true;
loopingAudioSource.Play( );
loopingAudioSource.volume = 0.0f;
}
if (oldPointerHand)
{
if (ShouldOverrideHoverLock( ))
{
//Restore the original hovering interactable on the hand
if (originalHoverLockState == true)
{
oldPointerHand.HoverLock(originalHoveringInteractable);
}
else
{
oldPointerHand.HoverUnlock(null);
}
}
}
pointerHand = newPointerHand;
if (visible && oldPointerHand != pointerHand)
{
PlayAudioClip(pointerAudioSource, pointerStartSound);
}
if (pointerHand)
{
pointerStartTransform = GetPointerStartTransform(pointerHand);
if (pointerHand.currentAttachedObject != null)
{
allowTeleportWhileAttached = pointerHand.currentAttachedObject.GetComponent <AllowTeleportWhileAttachedToHand> ( );
}
//Keep track of any existing hovering interactable on the hand
originalHoverLockState = pointerHand.hoverLocked;
originalHoveringInteractable = pointerHand.hoveringInteractable;
if (ShouldOverrideHoverLock( ))
{
pointerHand.HoverLock(null);
}
pointerAudioSource.transform.SetParent(pointerStartTransform);
pointerAudioSource.transform.localPosition = Vector3.zero;
loopingAudioSource.transform.SetParent(pointerStartTransform);
loopingAudioSource.transform.localPosition = Vector3.zero;
}
}
// Start is called before the first frame update
void OnEnable()
{
m_interactable = GetComponent <Valve.VR.InteractionSystem.Interactable>();
m_interactableHE = GetComponent <Valve.VR.InteractionSystem.InteractableHoverEvents>();
}
private void Awake()
{
interactable = this.GetComponent <Interactable>();
}
private void Start()
{
interactable = this.GetComponent <Interactable>();
}
//-------------------------------------------------
void Awake()
{
mappingChangeSamples = new float[numMappingChangeSamples];
interactable = this.GetComponent <Interactable>();
}
