[Unity]19.오큘러스 퀘스트 응용 슈팅게임 #2 - 총 쏘기 구현
- 게임 개발 - Unity3d
- 2019. 9. 8. 12:03
안녕하세요 유랑입니다.
지난 시간에 이어서 오큘러스 퀘스트를 이용한 슈팅게임을 만들어 보겠습니다.
총 쏘기 구현에 대해 알아볼게요^^
1. 총 쏘기 구현
1-1) 총 쏘기 - ㉠에셋 추가
저번에 총을 추가하긴 했지만,
스크립트랑 맵이 허전해 보이기 때문에 새로 추가해 주겠습니다.
1-2) 총 쏘기 - ㉡Distance Grabbable
두 총을 맵에 추가한 후 위치와 크기를 조정해 주세요.
충돌처리를 위해 Rigidbody와
멀리있는 총을 잡기 위해서 Distance Grabbable 스크립트를 추가해 주겠습니다.
SimpleShoot은 총을 쏘는 스크립트입니다.
충돌처리를 위한 조건 콜라이더와 리지드바디가 있어야합니다.
그러힉에 콜라이더도 추가해 줄텐데요.
큐브를 다음과 같이 추가해 주세요.
메쉬 렌더러와 필터는 필요없으니 컴포넌트에서 지워주겠습니다!!
추가한 콜라이더는 Distance Grabbable 스크립트 그랩부분에 적용하시면 되겠습니다.
손으로 총을 잡는 부분이라고 생각하시면 됩니다.
1-3) 총 쏘기 - ㉢Grab Manager
GrabManager는 트리거를 이용해 잡을 수 있는 물체가 주변에 있는지 확인해 주는 역할을 합니다.
빈오프젝트 추가 후 해당 스크립트와 콜리이더를 추가해 줄게요.
잡을 수 있는 물체는 레이어 설정을 통해 지정해 줄거에요.
Grabbable이라는 레이어를 추가해 주겠습니다.
1-4) 총 쏘기 - ㉣Distance Grabber
손에 적용된 DistanceGrabber도 마찬가지로 레이어 설정을 해줄게요.
그리고 해당 스크립트를 추가해 주겠습니다.
DistanceGrabbable
/************************************************************************************
Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
See SampleFramework license.txt for license terms. Unless required by applicable law
or agreed to in writing, the sample code is provided “AS IS” WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the license for specific
language governing permissions and limitations under the license.
************************************************************************************/
using System;
using UnityEngine;
using OVRTouchSample;
namespace OculusSampleFramework
{
public class DistanceGrabbable : OVRGrabbable
{
public string m_materialColorField;
GrabbableCrosshair m_crosshair;
GrabManager m_crosshairManager;
Renderer m_renderer;
MaterialPropertyBlock m_mpb;
public bool InRange
{
get { return m_inRange; }
set
{
m_inRange = value;
RefreshCrosshair();
}
}
bool m_inRange;
public bool Targeted
{
get { return m_targeted; }
set
{
m_targeted = value;
RefreshCrosshair();
}
}
bool m_targeted;
protected override void Start()
{
base.Start();
m_crosshair = gameObject.GetComponentInChildren();
m_renderer = gameObject.GetComponent();
m_crosshairManager = FindObjectOfType();
m_mpb = new MaterialPropertyBlock();
RefreshCrosshair();
m_mpb.SetColor(m_materialColorField, Color.white);
if (!m_renderer) return;
m_renderer.SetPropertyBlock(m_mpb);
}
void RefreshCrosshair()
{
if (m_crosshair)
{
if (isGrabbed) m_crosshair.SetState(GrabbableCrosshair.CrosshairState.Disabled);
else if (!InRange) m_crosshair.SetState(GrabbableCrosshair.CrosshairState.Disabled);
else m_crosshair.SetState(Targeted ? GrabbableCrosshair.CrosshairState.Targeted : GrabbableCrosshair.CrosshairState.Enabled);
}
if (m_materialColorField != null)
{
if (!m_renderer) return;
m_renderer.GetPropertyBlock(m_mpb);
if (isGrabbed || !InRange) m_mpb.SetColor(m_materialColorField, Color.white);
else if (Targeted) m_mpb.SetColor(m_materialColorField, m_crosshairManager.OutlineColorHighlighted);
else m_mpb.SetColor(m_materialColorField, m_crosshairManager.OutlineColorInRange);
m_renderer.SetPropertyBlock(m_mpb);
}
}
public void SetColor(Color focusColor)
{
if (!m_renderer) return;
m_mpb.SetColor(m_materialColorField, focusColor);
m_renderer.SetPropertyBlock(m_mpb);
}
public void ClearColor()
{
if (!m_renderer) return;
m_mpb.SetColor(m_materialColorField, Color.white);
m_renderer.SetPropertyBlock(m_mpb);
}
}
}
GrabManager
/************************************************************************************
Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
See SampleFramework license.txt for license terms. Unless required by applicable law
or agreed to in writing, the sample code is provided “AS IS” WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the license for specific
language governing permissions and limitations under the license.
************************************************************************************/
/************************************************************************************
Quick implementation notes:
Grab candidates and grab range:
-------------------------------
The trigger volume on the OVRPlayerController, which also has a GrabManager component,
determines whether an object is in range or out of range.
Hands (via the DistanceGrabber component) determine the target object in one of two
ways, depending on bool m_useSpherecast:
true: cast a sphere of radius m_spherecastRadius at distance m_maxGrabDistance. Select
the first collision.
false: from all objects within the grab volume, select the closest object that can be
hit by a ray from the player's hand.
IMPORTANT NOTE: if you change the radius of the trigger volume on the
OVRPlayerController, you must ensure the spherecast or the grab volume on the grabbers
is big enough to reach all objects within that radius! Keep in mind the hand may be a
little behind or two the side of the player, so you need to make it somewhat larger
than the radius. There is no major concern with making it too large (aside from minor
performance questions), because if an object is not in range according to the
OVRPlayerController's trigger volume, it will not be considered for grabbing.
Crosshairs and Outlines:
------------------------
Objects with a DistanceGrabbable component draw their own in range / targeted
highlight. How these states are best presented is highly app-specific.
************************************************************************************/
using UnityEngine;
namespace OculusSampleFramework
{
public class GrabManager : MonoBehaviour
{
Collider m_grabVolume;
public Color OutlineColorInRange;
public Color OutlineColorHighlighted;
void OnTriggerEnter(Collider otherCollider)
{
DistanceGrabbable dg = otherCollider.GetComponentInParent();
if(dg)
{
dg.InRange = true;
}
}
void OnTriggerExit(Collider otherCollider)
{
DistanceGrabbable dg = otherCollider.GetComponentInParent();
if(dg)
{
dg.InRange = false;
}
}
}
}
DistanceGrabber
/************************************************************************************
Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
See SampleFramework license.txt for license terms. Unless required by applicable law
or agreed to in writing, the sample code is provided “AS IS” WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the license for specific
language governing permissions and limitations under the license.
************************************************************************************/
using System.Collections.Generic;
using UnityEngine;
#if UNITY_EDITOR
using UnityEngine.SceneManagement;
#endif
namespace OculusSampleFramework
{
///
/// Allows grabbing and throwing of objects with the DistanceGrabbable component on them.
///
[RequireComponent(typeof(Rigidbody))]
public class DistanceGrabber : OVRGrabber
{
// Radius of sphere used in spherecast from hand along forward ray to find target object.
[SerializeField]
public Color m_focusColor;
// Radius of sphere used in spherecast from hand along forward ray to find target object.
[SerializeField]
float m_spherecastRadius;
// Distance below which no-snap objects won't be teleported, but will instead be left
// where they are in relation to the hand.
[SerializeField]
float m_noSnapThreshhold = 0.05f;
[SerializeField]
bool m_useSpherecast;
public bool UseSpherecast
{
get { return m_useSpherecast; }
set
{
m_useSpherecast = value;
GrabVolumeEnable(!m_useSpherecast);
}
}
// Public to allow changing in demo.
[SerializeField]
public bool m_preventGrabThroughWalls;
[SerializeField]
float m_objectPullVelocity = 10.0f;
float m_objectPullMaxRotationRate = 360.0f; // max rotation rate in degrees per second
bool m_movingObjectToHand = false;
// Objects can be distance grabbed up to this distance from the hand.
[SerializeField]
float m_maxGrabDistance;
// Only allow grabbing objects in this layer.
[SerializeField]
int m_grabObjectsInLayer;
[SerializeField]
int m_obstructionLayer;
[SerializeField]
GameObject m_player;
DistanceGrabber m_otherHand;
protected DistanceGrabbable m_target;
// Tracked separately from m_target, because we support child colliders of a DistanceGrabbable.
// MTF TODO: verify this still works!
protected Collider m_targetCollider;
protected override void Start()
{
base.Start();
// Set up our max grab distance to be based on the player's max grab distance.
// Adding a liberal margin of error here, because users can move away some from the
// OVRPlayerController, and also players have arms.
// Note that there's no major downside to making this value too high, as objects
// outside the player's grabbable trigger volume will not be eligible targets regardless.
SphereCollider sc = m_player.GetComponentInChildren();
m_maxGrabDistance = sc.radius + 3.0f;
if(m_parentHeldObject == true)
{
Debug.LogError("m_parentHeldObject incompatible with DistanceGrabber. Setting to false.");
m_parentHeldObject = false;
}
DistanceGrabber[] grabbers = FindObjectsOfType();
for (int i = 0; i < grabbers.Length; ++i)
{
if (grabbers[i] != this) m_otherHand = grabbers[i];
}
Debug.Assert(m_otherHand != null);
#if UNITY_EDITOR
OVRPlugin.SendEvent("distance_grabber", (SceneManager.GetActiveScene().name == "DistanceGrab").ToString(), "sample_framework");
#endif
}
void Update()
{
Debug.DrawRay(transform.position, transform.forward, Color.red, 0.1f);
DistanceGrabbable target;
Collider targetColl;
FindTarget(out target, out targetColl);
if (target != m_target)
{
if (m_target != null)
{
m_target.Targeted = m_otherHand.m_target == m_target;
}
if(m_target != null)
m_target.ClearColor();
if(target != null)
target.SetColor(m_focusColor);
m_target = target;
m_targetCollider = targetColl;
if (m_target != null)
{
m_target.Targeted = true;
}
}
}
protected override void GrabBegin()
{
DistanceGrabbable closestGrabbable = m_target;
Collider closestGrabbableCollider = m_targetCollider;
GrabVolumeEnable(false);
if (closestGrabbable != null)
{
if (closestGrabbable.isGrabbed)
{
((DistanceGrabber)closestGrabbable.grabbedBy).OffhandGrabbed(closestGrabbable);
}
m_grabbedObj = closestGrabbable;
m_grabbedObj.GrabBegin(this, closestGrabbableCollider);
m_movingObjectToHand = true;
m_lastPos = transform.position;
m_lastRot = transform.rotation;
// If it's within a certain distance respect the no-snap.
Vector3 closestPointOnBounds = closestGrabbableCollider.ClosestPointOnBounds(m_gripTransform.position);
if(!m_grabbedObj.snapPosition && !m_grabbedObj.snapOrientation && m_noSnapThreshhold > 0.0f && (closestPointOnBounds - m_gripTransform.position).magnitude < m_noSnapThreshhold)
{
Vector3 relPos = m_grabbedObj.transform.position - transform.position;
m_movingObjectToHand = false;
relPos = Quaternion.Inverse(transform.rotation) * relPos;
m_grabbedObjectPosOff = relPos;
Quaternion relOri = Quaternion.Inverse(transform.rotation) * m_grabbedObj.transform.rotation;
m_grabbedObjectRotOff = relOri;
}
else
{
// Set up offsets for grabbed object desired position relative to hand.
m_grabbedObjectPosOff = m_gripTransform.localPosition;
if (m_grabbedObj.snapOffset)
{
Vector3 snapOffset = m_grabbedObj.snapOffset.position;
if (m_controller == OVRInput.Controller.LTouch) snapOffset.x = -snapOffset.x;
m_grabbedObjectPosOff += snapOffset;
}
m_grabbedObjectRotOff = m_gripTransform.localRotation;
if (m_grabbedObj.snapOffset)
{
m_grabbedObjectRotOff = m_grabbedObj.snapOffset.rotation * m_grabbedObjectRotOff;
if (m_controller == OVRInput.Controller.LTouch) m_grabbedObjectRotOff = Quaternion.Inverse(m_grabbedObjectRotOff);
}
}
}
}
protected override void MoveGrabbedObject(Vector3 pos, Quaternion rot, bool forceTeleport = false)
{
if (m_grabbedObj == null)
{
return;
}
// Set up offsets for grabbed object desired position relative to hand.
m_grabbedObjectPosOff = m_gripTransform.localPosition;
if (m_grabbedObj.snapOffset)
{
Vector3 snapOffset = m_grabbedObj.snapOffset.position;
if (m_controller == OVRInput.Controller.LTouch) snapOffset.x = -snapOffset.x;
m_grabbedObjectPosOff += snapOffset;
}
m_grabbedObjectRotOff = m_gripTransform.localRotation;
if (m_grabbedObj.snapOffset)
{
m_grabbedObjectRotOff = m_grabbedObj.snapOffset.rotation * m_grabbedObjectRotOff;
if (m_controller == OVRInput.Controller.LTouch) m_grabbedObjectRotOff = Quaternion.Inverse(m_grabbedObjectRotOff);
}
Rigidbody grabbedRigidbody = m_grabbedObj.grabbedRigidbody;
Vector3 grabbablePosition = pos + rot * m_grabbedObjectPosOff;
Quaternion grabbableRotation = rot * m_grabbedObjectRotOff;
if (m_movingObjectToHand)
{
float travel = m_objectPullVelocity * Time.deltaTime;
Vector3 dir = grabbablePosition - m_grabbedObj.transform.position;
if(travel * travel * 1.1f > dir.sqrMagnitude)
{
m_movingObjectToHand = false;
}
else
{
dir.Normalize();
grabbablePosition = m_grabbedObj.transform.position + dir * travel;
grabbableRotation = Quaternion.RotateTowards(m_grabbedObj.transform.rotation, grabbableRotation, m_objectPullMaxRotationRate * Time.deltaTime);
}
}
grabbedRigidbody.MovePosition(grabbablePosition);
grabbedRigidbody.MoveRotation(grabbableRotation);
}
static private DistanceGrabbable HitInfoToGrabbable(RaycastHit hitInfo)
{
if (hitInfo.collider != null)
{
GameObject go = hitInfo.collider.gameObject;
return go.GetComponent() ?? go.GetComponentInParent();
}
return null;
}
protected bool FindTarget(out DistanceGrabbable dgOut, out Collider collOut)
{
dgOut = null;
collOut = null;
float closestMagSq = float.MaxValue;
// First test for objects within the grab volume, if we're using those.
// (Some usage of DistanceGrabber will not use grab volumes, and will only
// use spherecasts, and that's supported.)
foreach (OVRGrabbable cg in m_grabCandidates.Keys)
{
DistanceGrabbable grabbable = cg as DistanceGrabbable;
bool canGrab = grabbable != null && grabbable.InRange && !(grabbable.isGrabbed && !grabbable.allowOffhandGrab);
if (!canGrab)
{
continue;
}
for (int j = 0; j < grabbable.grabPoints.Length; ++j)
{
Collider grabbableCollider = grabbable.grabPoints[j];
// Store the closest grabbable
Vector3 closestPointOnBounds = grabbableCollider.ClosestPointOnBounds(m_gripTransform.position);
float grabbableMagSq = (m_gripTransform.position - closestPointOnBounds).sqrMagnitude;
if (grabbableMagSq < closestMagSq)
{
bool accept = true;
if(m_preventGrabThroughWalls)
{
// NOTE: if this raycast fails, ideally we'd try other rays near the edges of the object, especially for large objects.
// NOTE 2: todo optimization: sort the objects before performing any raycasts.
Ray ray = new Ray();
ray.direction = grabbable.transform.position - m_gripTransform.position;
ray.origin = m_gripTransform.position;
RaycastHit obstructionHitInfo;
Debug.DrawRay(ray.origin, ray.direction, Color.red, 0.1f);
if (Physics.Raycast(ray, out obstructionHitInfo, m_maxGrabDistance, 1 << m_obstructionLayer))
{
float distToObject = (grabbableCollider.ClosestPointOnBounds(m_gripTransform.position) - m_gripTransform.position).magnitude;
if(distToObject > obstructionHitInfo.distance * 1.1)
{
accept = false;
}
}
}
if(accept)
{
closestMagSq = grabbableMagSq;
dgOut = grabbable;
collOut = grabbableCollider;
}
}
}
}
if (dgOut == null && m_useSpherecast)
{
return FindTargetWithSpherecast(out dgOut, out collOut);
}
return dgOut != null;
}
protected bool FindTargetWithSpherecast(out DistanceGrabbable dgOut, out Collider collOut)
{
dgOut = null;
collOut = null;
Ray ray = new Ray(m_gripTransform.position, m_gripTransform.forward);
RaycastHit hitInfo;
// If no objects in grab volume, raycast.
// Potential optimization:
// In DistanceGrabbable.RefreshCrosshairs, we could move the object between collision layers.
// If it's in range, it would move into the layer DistanceGrabber.m_grabObjectsInLayer,
// and if out of range, into another layer so it's ignored by DistanceGrabber's SphereCast.
// However, we're limiting the SphereCast by m_maxGrabDistance, so the optimization doesn't seem
// essential.
if (Physics.SphereCast(ray, m_spherecastRadius, out hitInfo, m_maxGrabDistance, 1 << m_grabObjectsInLayer))
{
DistanceGrabbable grabbable = null;
Collider hitCollider = null;
if (hitInfo.collider != null)
{
grabbable = hitInfo.collider.gameObject.GetComponentInParent();
hitCollider = grabbable == null ? null : hitInfo.collider;
if(grabbable)
{
dgOut = grabbable;
collOut = hitCollider;
}
}
if (grabbable != null && m_preventGrabThroughWalls)
{
// Found a valid hit. Now test to see if it's blocked by collision.
RaycastHit obstructionHitInfo;
ray.direction = hitInfo.point - m_gripTransform.position;
dgOut = grabbable;
collOut = hitCollider;
if (Physics.Raycast(ray, out obstructionHitInfo, 1 << m_obstructionLayer))
{
DistanceGrabbable obstruction = null;
if(hitInfo.collider != null)
{
obstruction = obstructionHitInfo.collider.gameObject.GetComponentInParent();
}
if (obstruction != grabbable && obstructionHitInfo.distance < hitInfo.distance)
{
dgOut = null;
collOut = null;
}
}
}
}
return dgOut != null;
}
protected override void GrabVolumeEnable(bool enabled)
{
if(m_useSpherecast) enabled = false;
base.GrabVolumeEnable(enabled);
}
// Just here to allow calling of a protected member function.
protected override void OffhandGrabbed(OVRGrabbable grabbable)
{
base.OffhandGrabbed(grabbable);
}
}
}
그리고 플레이어 위치 조정과
총 밑에 콜라이더를 추가한 후
게임을 실행시켜 주세요.
잡기 버튼을 이용하면 이렇게 총을 잡을 수 있어요.
그런데 잡는 부분과 총의 회전방향이 이상하네요.
1-5) 총 쏘기 - ㉤Crosshair
총의 잡는 부분을 수정하기 전 조준점을 적용해 보겠습니다.
빈 오브젝트를 생성 후 Quad를 자식으로 생성해 주세요.
그리고 해당 머티리얼을 적용해 주겠습니다.
잡을 수 없는 상태일 때는 해당 머티리얼을 적용해 주세요.
Grabbable Crosshair를 통해 잡을 수 있는 상태와 없는 상태를 눈으로 판별할 수 있게됩니다ㅎㅎ
1-6) 총 쏘기 - ㉥HandOffset
이번에는 총의 잡는 부분을 수정해 볼게요.
빈 오브젝트 생성 후 HandGunOffset를 만들어 주세요.
위치와 회전 방향을 총을 원점으로 만들어 주시고 참고하시면 되겠습니다.
HandGunOffset은 프리팹화 하시고 스냅 포지션과 원점을 체크하시면 되겠습니다.
1-7) 총 쏘기 - ㉦사격
이제 컨트롤러의 트리거 버튼을 클릭하면 총을 발사하도록 스크립트를 수정 및 추가해 줄 차례입니다.
SimpleShoot과 OVRGrabber에서 해당 부분을 추가해 주시면 되겠습니다.
오큘러스 퀘스트 컨트롤러 인풋을 확인해 보시면 Axis1D.PrimaryIndexTrigger를 사용한다는 걸 확인 가능합니다.
ShootIfGrabbed는 총을 잡고나서 총을 사격 가능하도록 구현하는 코드입니다.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class ShootIfGrabbed : MonoBehaviour
{
private SimpleShoot simpleShoot;
private OVRGrabbable ovrGrabbable;
public OVRInput.Button shootingButton;
// Start is called before the first frame update
void Start()
{
simpleShoot = GetComponent();
ovrGrabbable = GetComponent();
}
// Update is called once per frame
void Update()
{
if (ovrGrabbable.isGrabbed && OVRInput.GetDown(shootingButton, ovrGrabbable.grabbedBy.GetController()))
{
simpleShoot.TriggerShoot();
}
}
}
총에다가 해당 스크립트를 추가해 주세요^^
2. 마무리
오늘 강의는 여기까지입니다.
오큘러스 퀘스트를 이용해 총 쏘는 걸 배워보았습니다.
복잡하지만, 멋있는 기능이네요ㅎㅎ
오늘도 고생하셨습니다.
감사합니다.
수업자료: 오큘러스 퀘스트 응용 슈팅게임 #2 - 총 쏘기 구현