private void UpdateAvatarComponent(ovrAvatarComponent component)
{
for (UInt32 renderPartIndex = 0; renderPartIndex < component.renderPartCount; renderPartIndex++)
{
if (RenderParts.Count <= renderPartIndex)
{
break;
}
OvrAvatarRenderComponent renderComponent = RenderParts[(int)renderPartIndex];
IntPtr renderPart = OvrAvatar.GetRenderPart(component, renderPartIndex);
ovrAvatarRenderPartType type = CAPI.ovrAvatarRenderPart_GetType(renderPart);
switch (type)
{
case ovrAvatarRenderPartType.SkinnedMeshRenderPBS:
var mat = renderComponent.mesh.sharedMaterial;
var bones = renderComponent.bones;
ovrAvatarVisibilityFlags visibilityMask = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetVisibilityMask(renderPart);
ovrAvatarTransform localTransform = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetTransform(renderPart);
UpdateSkinnedMesh(localTransform, renderPart, bones);
UInt64 albedoTextureID = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetAlbedoTextureAssetID(renderPart);
UInt64 surfaceTextureID = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetSurfaceTextureAssetID(renderPart);
mat.SetTexture("_Albedo", OvrAvatarComponent.GetLoadedTexture(albedoTextureID));
mat.SetTexture("_Surface", OvrAvatarComponent.GetLoadedTexture(surfaceTextureID));
break;
default:
break;
}
}
}
void UpdateExpressive()
{
ovrAvatarTransform baseTransform = OvrAvatar.CreateOvrAvatarTransform(transform.position, transform.rotation);
CAPI.ovrAvatar_UpdateWorldTransform(sdkAvatar, baseTransform);
UpdateFacewave();
}
public void UpdateAvatar(IntPtr nativeComponent)
{
CAPI.ovrAvatarComponent_Get(nativeComponent, false, ref nativeAvatarComponent);
OvrAvatar.ConvertTransform(nativeAvatarComponent.transform, transform);
for (UInt32 renderPartIndex = 0; renderPartIndex < 1; renderPartIndex++) //nativeAvatarComponent.renderPartCount
{
if (RenderParts.Count <= renderPartIndex)
{
break;
}
OvrAvatarRenderComponent renderComponent = RenderParts[(int)renderPartIndex];
IntPtr renderPart = OvrAvatar.GetRenderPart(nativeAvatarComponent, renderPartIndex);
ovrAvatarRenderPartType type = CAPI.ovrAvatarRenderPart_GetType(renderPart);
switch (type)
{
case ovrAvatarRenderPartType.SkinnedMeshRender:
((OvrAvatarSkinnedMeshRenderComponent)renderComponent).UpdateSkinnedMeshRender(this, owner, renderPart);
break;
case ovrAvatarRenderPartType.SkinnedMeshRenderPBS:
((OvrAvatarSkinnedMeshRenderPBSComponent)renderComponent).UpdateSkinnedMeshRenderPBS(owner, renderPart, renderComponent.mesh.sharedMaterial);
break;
case ovrAvatarRenderPartType.SkinnedMeshRenderPBS_V2:
((OvrAvatarSkinnedMeshPBSV2RenderComponent)renderComponent).UpdateSkinnedMeshRender(this, owner, renderPart);
break;
default:
break;
}
}
}
// Use this for initialization
void Start()
{
hp = 1;
display_hp = 1;
if (!isLocalPlayer)
{
hpText = GameObject.Find("OtherText").GetComponent <Text>();
hpImg = GameObject.Find("OtherHP").GetComponent <Image>();
gameObject.GetComponent <GestureManager>().enabled = false;
return;
}
eye_anchor = GameObject.Find("CenterEyeAnchor");
avatar = GameObject.Find("LocalAvatar").GetComponent <OvrAvatar>();
hpText = GameObject.Find("LocalText").GetComponent <Text>();
hpImg = GameObject.Find("LocalHP").GetComponent <Image>();
this.GetComponent <GestureManager>().player = this;
//gesture_manager = gameObject.AddComponent<GestureManager>();
//gesture_manager.player = this;
CmdSpawnPlayer();
}
private void ToggleControllers(bool enable)
{
if (vrInput.isSteamVR())
{
ToggleAllChildRenderers(gameObject, enable);
}
else
{
#if Int_Oculus
OvrAvatar avatar = GetComponentInParent <OvrAvatar>();
if (avatar == null)
{
avatar = FindObjectOfType <OvrAvatar>();
//Debug.LogWarning("Can't find OVRAvatar as parent of controller, using FindObjectOfType, warning this is slow and may result in a long frame");
}
if (avatar == null)
{
return;
}
if (vrInput.LeftHand)
{
ToggleAllChildRenderers(avatar.ControllerLeft.gameObject, enable);
ToggleAllChildRenderers(avatar.HandLeft.gameObject, enable);
}
else
{
ToggleAllChildRenderers(avatar.ControllerRight.gameObject, enable);
ToggleAllChildRenderers(avatar.HandRight.gameObject, enable);
}
#endif
}
}
// Use this for initialization
void Start()
{
target_to_hand["Long Knife"] = "_Knife";
target_to_hand["Scalpel"] = "_Scalpel";
target_to_hand["Pickups"] = "_PickupsOpen";
target_to_hand["Scissors"] = "_ScissorsOpen";
target_to_hand["Probe"] = "_Probe";
foreach (var hand in Resources.LoadAll <Transform>("Hands"))
{
hands[hand.name] = hand;
}
ovr = this.GetComponentInChildren <OvrAvatar>();
left_grab = GameObject.Find("LeftController").GetComponent <VRTK_InteractGrab>();
right_grab = GameObject.Find("RightController").GetComponent <VRTK_InteractGrab>();
left_use = left_grab.GetComponent <VRTK_InteractUse>();
right_use = right_grab.GetComponent <VRTK_InteractUse>();
left_grab.ControllerGrabInteractableObject += new ObjectInteractEventHandler(onGrab);
left_grab.ControllerUngrabInteractableObject += new ObjectInteractEventHandler(onUngrab);
right_grab.ControllerGrabInteractableObject += new ObjectInteractEventHandler(onGrab);
right_grab.ControllerUngrabInteractableObject += new ObjectInteractEventHandler(onUngrab);
right_use.ControllerUseInteractableObject += new ObjectInteractEventHandler(onUse);
right_use.ControllerUnuseInteractableObject += new ObjectInteractEventHandler(onUnuse);
left_use.ControllerUseInteractableObject += new ObjectInteractEventHandler(onUse);
left_use.ControllerUnuseInteractableObject += new ObjectInteractEventHandler(onUnuse);
pickups = GameObject.Find("Pickups");
scissors = GameObject.Find("Scissors");
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void UpdateData(HoverCursorDataProvider pCursorDataProv,
HoverInputOculusTouch.ControlState pState, OvrAvatar pAvatar)
{
ICursorDataForInput data = GetData(pCursorDataProv);
if (data == null)
{
return;
}
data.SetUsedByInput(pState.IsValid);
if (!pState.IsValid)
{
return;
}
if (!TryUpdateDataWithAvatarElement(data, pAvatar))
{
UpdateDataWithLocalOffsets(data, pState);
}
UpdateDataForTrigger(data, pState);
UpdateDataForSize(data, pState);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private bool TryUpdateDataWithAvatarElement(ICursorDataForInput pData, OvrAvatar pAvatar)
{
if (!ShouldFollowAvatarElement)
{
AvatarElementTransform = null;
return(false);
}
if (AvatarElementTransform == null)
{
AvatarElementTransform = HoverInputOculusTouch.FindAvatarTransform(
pAvatar.transform, AvatarElementName);
}
if (AvatarElementTransform == null)
{
return(false);
}
Quaternion sidedLocalRotFix = (Type < CursorType.RightPalm ?
LocalLeftRotFix : LocalRightRotFix);
pData.SetWorldRotation(AvatarElementTransform.rotation * sidedLocalRotFix);
pData.SetWorldPosition(AvatarElementTransform.position + pData.WorldRotation * LocalPosFix);
return(true);
}
public void UpdateSkinnedMeshRender(OvrAvatarComponent component, OvrAvatar avatar, IntPtr renderPart)
{
ovrAvatarVisibilityFlags visibilityMask = CAPI.ovrAvatarSkinnedMeshRenderPBSV2_GetVisibilityMask(renderPart):
ovrAvatarTransform localTransform = CAPI.ovrAvatarSkinnedMeshRenderPBSV2_GetTransform(renderPart):
UpdateSkinnedMesh(avatar, bones, localTransform, visibilityMask, renderPart):
UpdateMeshMaterial(visibilityMask, mesh == null ? component.RootMeshComponent : mesh):
bool isActive = this.gameObject.activeSelf:
if( mesh != null )
{
bool changedMaterial = CAPI.ovrAvatarSkinnedMeshRenderPBSV2_MaterialStateChanged(renderPart):
if (changedMaterial || (!previouslyActive && isActive))
{
ovrAvatarPBSMaterialState materialState = CAPI.ovrAvatarSkinnedMeshRenderPBSV2_GetPBSMaterialState(renderPart):
Material mat = mesh.sharedMaterial:
mat.SetVector("_AlbedoMultiplier", materialState.albedoMultiplier):
mat.SetTexture("_Albedo", OvrAvatarComponent.GetLoadedTexture(materialState.albedoTextureID)):
mat.SetTexture("_Metallicness", OvrAvatarComponent.GetLoadedTexture(materialState.metallicnessTextureID)):
mat.SetFloat("_GlossinessScale", materialState.glossinessScale):
}
}
previouslyActive = isActive:
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Awake()
{
CursorUtil.FindCursorReference(this, ref CursorDataProvider, false);
if (Avatar == null)
{
Avatar = FindObjectOfType <OvrAvatar>();
}
if (Look.FollowTransform == null)
{
Look.FollowTransform = Camera.main.transform;
}
LeftPalm.OriginTransform = transform;
LeftThumb.OriginTransform = transform;
LeftIndex.OriginTransform = transform;
LeftMiddle.OriginTransform = transform;
LeftRing.OriginTransform = transform;
LeftPinky.OriginTransform = transform;
RightPalm.OriginTransform = transform;
RightThumb.OriginTransform = transform;
RightIndex.OriginTransform = transform;
RightMiddle.OriginTransform = transform;
RightRing.OriginTransform = transform;
RightPinky.OriginTransform = transform;
}
protected void UpdateSkinnedMesh(OvrAvatar avatar, SkinnedMeshRenderer mesh, Transform[] bones, ovrAvatarTransform localTransform, ovrAvatarVisibilityFlags visibilityMask, IntPtr renderPart)
{
UpdateActive(avatar, visibilityMask);
OvrAvatar.ConvertTransform(localTransform, this.transform);
UInt64 dirtyJoints = CAPI.ovrAvatarSkinnedMeshRender_GetDirtyJoints(renderPart);
ovrAvatarRenderPartType type = CAPI.ovrAvatarRenderPart_GetType(renderPart);
// We need to make sure that we fully update the initial position of
// Skinned mesh renderers, then, thereafter, we can only update dirty joints
bool forceUpdate = (firstSkinnedUpdate &&
type == ovrAvatarRenderPartType.SkinnedMeshRender);
for (UInt32 i = 0; i < 64; i++)
{
UInt64 dirtyMask = (ulong)1 << (int)i;
if ((forceUpdate && i < bones.Length) ||
(dirtyMask & dirtyJoints) != 0)
{
//This joint is dirty and needs to be updated
Transform targetBone = bones[i];
ovrAvatarTransform transform =
CAPI.ovrAvatarSkinnedMeshRender_GetJointTransform(renderPart, i);
OvrAvatar.ConvertTransform(transform, targetBone);
}
}
firstSkinnedUpdate = false;
}
internal void UpdateProjectorRender(OvrAvatarComponent component, ovrAvatarRenderPart_ProjectorRender render)
{
OvrAvatar.ConvertTransform(render.localTransform, this.transform):
material.SetMatrix("_ProjectorWorldToLocal", this.transform.worldToLocalMatrix):
component.UpdateAvatarMaterial(material, render.materialState):
}
void Start()
{
player = GameObject.Find("OVRPlayerController");
playerCube = GameObject.Find("Cube");
characterController = player.GetComponent <CharacterController>();
ovrManager = GameObject.Find("OVRCameraRig").GetComponent <OVRManager>();
avatar = GameObject.Find("LocalAvatar").GetComponent <OvrAvatar>();
//sword = GameObject.Find("Weapon");
grip = GameObject.Find("RightHandAnchor");
swordEye = GameObject.FindGameObjectsWithTag("swordEye");
trackingAnchor = GameObject.Find("TrackerAnchor");
gManager = GameObject.Find("GameManager");
gScript = gManager.GetComponent <GameManager>();
soundObject = GameObject.Find("SoundManager");
soundManager = soundObject.GetComponent <SoundManager>();
soundPlayer = gameObject.GetComponent <AudioSource>();
soundPlayer2 = gameObject.GetComponentInParent <AudioSource>();
if (gScript.difficulty == 0 && gScript.GetGameLevel() == 3)
{
health = 20;
}
if (gScript.difficulty == 1 && gScript.GetGameLevel() == 3)
{
health = gScript.playerHealth;
}
}
protected void UpdateActive(OvrAvatar avatar, ovrAvatarVisibilityFlags mask)
{
bool active = avatar.ShowFirstPerson && (mask & ovrAvatarVisibilityFlags.FirstPerson) != 0;
active |= avatar.ShowThirdPerson && (mask & ovrAvatarVisibilityFlags.ThirdPerson) != 0;
this.gameObject.SetActive(active);
}
public void StartMeshCombining(ovrAvatarComponent component)
{
IsCombiningMeshes = true;
gameObject.SetActive(false);
ThreadData = new MeshThreadData[RenderParts.Count];
const UInt32 BODY_INDEX = 0;
for (UInt32 renderPartIndex = 0; renderPartIndex < RenderParts.Count; renderPartIndex++)
{
var renderPart = RenderParts[(int)renderPartIndex];
IntPtr ovrRenderPart = OvrAvatar.GetRenderPart(component, renderPartIndex);
var materialState = CAPI.ovrAvatarSkinnedMeshRender_GetMaterialState(ovrRenderPart);
ThreadData[renderPartIndex].VertexCount = renderPart.mesh.sharedMesh.vertexCount;
ThreadData[renderPartIndex].IsDarkMaterial = renderPartIndex != 0;
if (materialState.alphaMaskTextureID != 0)
{
if (renderPartIndex != BODY_INDEX)
{
ClothingAlphaOffset = materialState.alphaMaskScaleOffset;
ClothingAlphaTexture = materialState.alphaMaskTextureID;
}
ThreadData[renderPartIndex].UsesAlpha = true;
}
ThreadData[renderPartIndex].MeshColors = renderPart.mesh.sharedMesh.colors;
}
VertexThread = new Thread(() => UpdateVertices(ref ThreadData));
VertexThread.Start();
}
public void UpdateSkinnedMeshRender(
OvrAvatarComponent component,
OvrAvatar avatar,
IntPtr renderPart)
{
ovrAvatarVisibilityFlags visibilityMask
= CAPI.ovrAvatarSkinnedMeshRenderPBSV2_GetVisibilityMask(renderPart);
ovrAvatarTransform localTransform
= CAPI.ovrAvatarSkinnedMeshRenderPBSV2_GetTransform(renderPart);
UpdateSkinnedMesh(avatar, bones, localTransform, visibilityMask, renderPart);
bool isActive = gameObject.activeSelf;
if (mesh != null && !PreviouslyActive && isActive)
{
if (!IsCombinedMaterial)
{
InitializeSingleComponentMaterial(renderPart, (int)avatar.LevelOfDetail - 1);
}
}
PreviouslyActive = isActive;
}
protected void UpdateSkinnedMesh(OvrAvatar avatar, Transform[] bones, ovrAvatarTransform localTransform, ovrAvatarVisibilityFlags visibilityMask, IntPtr renderPart)
{
// Debug.Log("UpdateSkinnedMesh");
UpdateActive(avatar, visibilityMask);
OvrAvatar.ConvertTransform(localTransform, this.transform);
ovrAvatarRenderPartType type = CAPI.ovrAvatarRenderPart_GetType(renderPart);
UInt64 dirtyJoints;
switch (type)
{
case ovrAvatarRenderPartType.SkinnedMeshRender:
dirtyJoints = CAPI.ovrAvatarSkinnedMeshRender_GetDirtyJoints(renderPart);
break;
case ovrAvatarRenderPartType.SkinnedMeshRenderPBS:
dirtyJoints = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetDirtyJoints(renderPart);
break;
case ovrAvatarRenderPartType.SkinnedMeshRenderPBS_V2:
dirtyJoints = CAPI.ovrAvatarSkinnedMeshRenderPBSV2_GetDirtyJoints(renderPart);
break;
default:
throw new Exception("Unhandled render part type: " + type);
}
for (UInt32 i = 0; i < 64; i++)
{
UInt64 dirtyMask = (ulong)1 << (int)i;
// We need to make sure that we fully update the initial position of
// Skinned mesh renderers, then, thereafter, we can only update dirty joints
if ((firstSkinnedUpdate && i < bones.Length) ||
(dirtyMask & dirtyJoints) != 0)
{
//This joint is dirty and needs to be updated
Transform targetBone = bones[i];
ovrAvatarTransform transform;
switch (type)
{
case ovrAvatarRenderPartType.SkinnedMeshRender:
transform = CAPI.ovrAvatarSkinnedMeshRender_GetJointTransform(renderPart, i);
break;
case ovrAvatarRenderPartType.SkinnedMeshRenderPBS:
transform = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetJointTransform(renderPart, i);
break;
case ovrAvatarRenderPartType.SkinnedMeshRenderPBS_V2:
transform = CAPI.ovrAvatarSkinnedMeshRenderPBSV2_GetJointTransform(renderPart, i);
break;
default:
throw new Exception("Unhandled render part type: " + type);
}
OvrAvatar.ConvertTransform(transform, targetBone);
}
}
firstSkinnedUpdate = false;
}
private RaycastObjectInfo GetRaycastInfo(bool isHit, RaycastHit hit, RaycastObjectInfo info)
{
if (!isHit)
{
return(new RaycastObjectInfo());
}
GameObject hitObj = hit.collider.gameObject;
OvrAvatar ovrAvatar = hitObj.GetComponent <OvrAvatar>();
if (ovrAvatar == null)
{
ovrAvatar = hitObj.GetComponentInParent <OvrAvatar>();
}
if (ovrAvatar != null)
{
info.ObjectName = "Player Avatar";
info.OriginalObjectOwner = photonToParticipantDictionary[ovrAvatar.GetComponent <PhotonView>().Owner.ActorNumber].ToString();
info.ObjectOwner = info.OriginalObjectOwner;
info.ObjectID = "";
return(info);
}
Chart chart = hitObj.GetComponent <Chart>();
if (chart == null)
{
chart = hitObj.GetComponentInParent <Chart>();
}
if (chart != null)
{
info.ObjectName = "Chart";
info.OriginalObjectOwner = photonToParticipantDictionary[chart.OriginalOwner.ActorNumber].ToString();
info.ObjectOwner = photonToParticipantDictionary[chart.photonView.OwnerActorNr].ToString();
info.ObjectID = chart.ID;
return(info);
}
Panel panel = hitObj.GetComponent <Panel>();
if (panel == null)
{
panel = hitObj.GetComponentInParent <Panel>();
}
if (panel != null)
{
info.ObjectName = "Panel";
info.OriginalObjectOwner = photonToParticipantDictionary[panel.OriginalOwner.ActorNumber].ToString();
info.ObjectOwner = info.OriginalObjectOwner;
info.ObjectID = "";
return(info);
}
return(new RaycastObjectInfo());
}
IEnumerator DelayedAvatarInstantiation(object content, int senderid)
{
yield return(new WaitForSecondsRealtime(0.1f));
object[] instantiationData = (object[])content;
//Create panel
PhotonPlayer photonPlayer = PhotonPlayer.Find(senderid);
GameObject go = null;
int viewId = (int)instantiationData[0];
string oculusId = (string)instantiationData[1];
if (PhotonNetwork.player.ID == senderid)
{
go = Instantiate(m_LocalAvatarPrefab);
m_PlayerAvatars.Add(photonPlayer.ID, go);
_LocalAvatar = go;
_LocalVoiceRecorder = PhotonNetwork.Instantiate("PhotonPlayerVoice", Vector3.zero, Quaternion.identity, 0).GetComponent <PhotonVoiceRecorder>();
_LocalVoiceRecorder.transform.SetParent(go.transform);
_LocalAvatar.transform.SetParent(CameraController.CameraContainer.transform);
}
else
{
go = Instantiate(m_RemoteAvatarPrefab);
m_PlayerAvatars.Add(photonPlayer.ID, go);
}
if (go != null)
{
PhotonView pView = go.GetComponent <PhotonView>();
if (pView != null)
{
pView.viewID = viewId;
pView.ownerId = senderid;
}
OvrAvatar avatar = go.GetComponent <OvrAvatar>();
avatar.oculusUserID = oculusId;
if (photonPlayer.IsLocal)
{
Fader.FadeInAll();
}
m_PositionController.SetObjectPosition(go, (UserPosition)photonPlayer.CustomProperties["EnvironmentLocation"],
(int)photonPlayer.CustomProperties["EnvironmentPositionIndex"]);
if (!photonPlayer.IsLocal)
{
SetPlayerPosition(photonPlayer);
}
}
}
internal void UpdateSkinnedMeshRenderPBS(OvrAvatar avatar, ovrAvatarRenderPart_SkinnedMeshRenderPBS meshRender)
{
UpdateSkinnedMesh(avatar, mesh, bones, meshRender.localTransform, meshRender.visibilityMask, meshRender.skinnedPose);
Material mat = mesh.sharedMaterial;
mat.SetTexture("_Albedo", GetLoadedTexture(meshRender.albedoTextureAssetID));
mat.SetTexture("_Surface", GetLoadedTexture(meshRender.surfaceTextureAssetID));
}
void Start()
{
if (Avatar == null)
{
Debug.LogWarning("Avatar not assigned. Searching hierarchy. Please configure the Avatar before running to improve performance.");
Avatar = GameObject.FindObjectOfType <OvrAvatar>();
Assert.IsNotNull(Avatar);
}
}
protected void UpdateSkinnedMesh(OvrAvatar avatar, SkinnedMeshRenderer mesh, Transform[] bones, ovrAvatarTransform localTransform, ovrAvatarVisibilityFlags visibilityMask, ovrAvatarSkinnedMeshPose skinnedPose)
{
UpdateActive(avatar, visibilityMask);
OvrAvatar.ConvertTransform(localTransform, this.transform);
for (int i = 0; i < skinnedPose.jointCount; i++)
{
Transform targetBone = bones[i];
OvrAvatar.ConvertTransform(skinnedPose.jointTransform[i], targetBone);
}
}
private void OnGetLoggedInUser(Message <User> message)
{
if (!message.IsError)
{
OvrAvatar avatar = Instantiate(avatarPrefab.gameObject).GetComponent <OvrAvatar>();
Debug.Log(message.Data.ID);
//avatar.oculusUserID = message.Data.ID.ToString();
}
}
void Start()
{
//transform = GetComponent<Transform>();
line = GetComponent <LineRenderer>();
//raycaster = GetComponent<OVRPhysicsRaycaster>();
//eventSystem = GameObject.FindObjectOfType<EventSystem>();
avatar = GameObject.FindObjectOfType <OvrAvatar>();
activeStateHash = Animator.StringToHash(ActiveState);
Debug.LogFormat("Raycast mask: {0}", RaycastMask.mask);
}
// Use this for initialization
void Start()
{
sender = GetComponent <RayCastSender>();
avatar = GetComponentInParent <OvrAvatar>();
grabber = GetComponentInParent <Grabber>();
otherToggler = GetComponentInParent <ToggleRayCastOnGrabbable>();
controller = marker.controller;
ConnectController(controller);
}
internal void UpdateSkinnedMeshRender(OvrAvatar avatar, IntPtr renderPart)
{
ovrAvatarMaterialState materialState = CAPI.ovrAvatarSkinnedMeshRender_GetMaterialState(renderPart);
ovrAvatarVisibilityFlags visibilityMask = CAPI.ovrAvatarSkinnedMeshRender_GetVisibilityMask(renderPart);
ovrAvatarTransform localTransform = CAPI.ovrAvatarSkinnedMeshRender_GetTransform(renderPart);
UpdateSkinnedMesh(avatar, mesh, bones, localTransform, visibilityMask, renderPart);
UpdateMeshMaterial(visibilityMask);
UpdateAvatarMaterial(mesh.sharedMaterial, materialState);
}
internal void UpdateSkinnedMeshRenderPBS(OvrAvatar avatar, IntPtr renderPart, Material mat)
{
// ovrAvatarVisibilityFlags visibilityMask = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetVisibilityMask(renderPart);
// ovrAvatarTransform localTransform = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetTransform(renderPart);
// UpdateSkinnedMesh(avatar, bones, localTransform, visibilityMask, renderPart);
// UInt64 albedoTextureID = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetAlbedoTextureAssetID(renderPart);
// UInt64 surfaceTextureID = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetSurfaceTextureAssetID(renderPart);
// mat.SetTexture("_Albedo", OvrAvatarComponent.GetLoadedTexture(albedoTextureID));
// mat.SetTexture("_Surface", OvrAvatarComponent.GetLoadedTexture(surfaceTextureID));
}
public void UpdateTransformsFromPose(IntPtr sdkAvatar)
{
if (sdkAvatar != IntPtr.Zero)
{
ovrAvatarTransform bodyTransform = OvrAvatar.CreateOvrAvatarTransform(CurrentPose.headPosition, CurrentPose.headRotation);
ovrAvatarHandInputState inputStateLeft = OvrAvatar.CreateInputState(OvrAvatar.CreateOvrAvatarTransform(CurrentPose.handLeftPosition, CurrentPose.handLeftRotation), CurrentPose.controllerLeftPose);
ovrAvatarHandInputState inputStateRight = OvrAvatar.CreateInputState(OvrAvatar.CreateOvrAvatarTransform(CurrentPose.handRightPosition, CurrentPose.handRightRotation), CurrentPose.controllerRightPose);
CAPI.ovrAvatarPose_UpdateBody(sdkAvatar, bodyTransform);
CAPI.ovrAvatarPose_UpdateHandsWithType(sdkAvatar, inputStateLeft, inputStateRight, ControllerType);
}
}
// Use this for initialization
void Start()
{
sender = GetComponentInChildren <RayCastSender>();
avatar = GetComponentInParent <OvrAvatar>();
grabber = GetComponentInChildren <Grabber>();
otherToggler = GetComponentInChildren <ToggleRayCastOnGrabbable>();
controller = gameObject.GetComponent <VRController>();
marker = gameObject.GetComponentInChildren <FreeMarker>(true);
penModel = transform.Find("Pen").gameObject;
ConnectController(controller);
}
/// <summary>
/// The GetAvatar method is used to retrieve the Oculus Avatar object if it exists in the scene. This method is only available if the Oculus Avatar package is installed.
/// </summary>
/// <returns>The OvrAvatar script for managing the Oculus Avatar.</returns>
public virtual OvrAvatar GetAvatar()
{
if (avatarContainer == null)
{
avatarContainer = FindObjectOfType <OvrAvatar>();
if (avatarContainer)
{
var objectFollow = avatarContainer.gameObject.AddComponent <VRTK_TransformFollow>();
objectFollow.gameObjectToFollow = GetPlayArea().gameObject;
}
}
return(avatarContainer);
}
