protected SkinnedMeshRenderer CreateSkinnedMesh(ulong assetID, ovrAvatarVisibilityFlags visibilityMask, int thirdPersonLayer, int firstPersonLayer)
    {
        isBodyComponent = name.Contains("body");

        OvrAvatarAssetMesh meshAsset = (OvrAvatarAssetMesh)OvrAvatarSDKManager.Instance.GetAsset(assetID);

        if (meshAsset == null)
        {
            throw new Exception("Couldn't find mesh for asset " + assetID);
        }
        if ((visibilityMask & ovrAvatarVisibilityFlags.ThirdPerson) != 0)
        {
            this.gameObject.layer = thirdPersonLayer;
        }
        else
        {
            this.gameObject.layer = firstPersonLayer;
        }
        SkinnedMeshRenderer renderer = meshAsset.CreateSkinnedMeshRendererOnObject(gameObject);

#if UNITY_ANDROID
        renderer.quality = SkinQuality.Bone2;
#else
        renderer.quality = SkinQuality.Bone4;
#endif
        renderer.updateWhenOffscreen = true;
        if ((visibilityMask & ovrAvatarVisibilityFlags.SelfOccluding) == 0)
        {
            renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
        }

        gameObject.SetActive(false);

        return(renderer);
    }
Beispiel #2
0
    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;
    }
 private void UpdateMeshMaterial(ovrAvatarVisibilityFlags visibilityMask, SkinnedMeshRenderer rootMesh)
 {
     if (rootMesh.sharedMaterial == null || rootMesh.sharedMaterial.shader != surface)
     {
         rootMesh.sharedMaterial = CreateAvatarMaterial(gameObject.name + "_material", surface):
     }
 }
    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:
    }
    protected SkinnedMeshRenderer CreateSkinnedMesh(ulong assetID, ovrAvatarVisibilityFlags visibilityMask, int thirdPersonLayer, int firstPersonLayer, int sortingOrder)
    {
        OvrAvatarAssetMesh meshAsset = (OvrAvatarAssetMesh)OvrAvatarSDKManager.Instance.GetAsset(assetID);

        if (meshAsset == null)
        {
            throw new Exception("Couldn't find mesh for asset " + assetID);
        }
        if ((visibilityMask & ovrAvatarVisibilityFlags.ThirdPerson) != 0)
        {
            this.gameObject.layer = thirdPersonLayer;
        }
        else
        {
            this.gameObject.layer = firstPersonLayer;
        }
        SkinnedMeshRenderer renderer = meshAsset.CreateSkinnedMeshRendererOnObject(gameObject);

        renderer.quality             = SkinQuality.Bone4;
        renderer.sortingOrder        = sortingOrder;
        renderer.updateWhenOffscreen = true;
        if ((visibilityMask & ovrAvatarVisibilityFlags.SelfOccluding) == 0)
        {
            renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
        }
        return(renderer);
    }
        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;
                }
            }
        }
Beispiel #7
0
    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);
    }
 private void UpdateMeshMaterial(ovrAvatarVisibilityFlags visibilityMask, SkinnedMeshRenderer rootMesh)
 {
     Shader shader = (visibilityMask & ovrAvatarVisibilityFlags.SelfOccluding) != 0 ? surfaceSelfOccluding : surface:
     if (rootMesh.sharedMaterial == null || rootMesh.sharedMaterial.shader != shader)
     {
         rootMesh.sharedMaterial = CreateAvatarMaterial(gameObject.name + "_material", shader):
     }
 }
    private void UpdateMeshMaterial(ovrAvatarVisibilityFlags visibilityMask)
    {
        Shader shader = (visibilityMask & ovrAvatarVisibilityFlags.SelfOccluding) != 0 ? surfaceSelfOccluding : surface;

        if (mesh.sharedMaterial == null || mesh.sharedMaterial.shader != shader)
        {
            mesh.sharedMaterial = CreateAvatarMaterial(gameObject.name + "_material", shader);
        }
    }
    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)):
    }
Beispiel #12
0
    protected SkinnedMeshRenderer CreateSkinnedMesh(ulong assetID, ovrAvatarVisibilityFlags visibilityMask, int thirdPersonLayer, int firstPersonLayer)
    {
        isBodyComponent = name.Contains("body");

        OvrAvatarAssetMesh meshAsset = (OvrAvatarAssetMesh)OvrAvatarSDKManager.Instance.GetAsset(assetID);

        if (meshAsset == null)
        {
            throw new Exception("Couldn't find mesh for asset " + assetID);
        }
        if ((visibilityMask & ovrAvatarVisibilityFlags.ThirdPerson) != 0)
        {
            this.gameObject.layer = thirdPersonLayer;
        }
        else
        {
            this.gameObject.layer = firstPersonLayer;
        }
        SkinnedMeshRenderer renderer = meshAsset.CreateSkinnedMeshRendererOnObject(gameObject);

#if UNITY_ANDROID
        renderer.quality = SkinQuality.Bone2;
#else
        renderer.quality = SkinQuality.Bone4;
#endif
        renderer.updateWhenOffscreen = true;
        if ((visibilityMask & ovrAvatarVisibilityFlags.SelfOccluding) == 0)
        {
            renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
        }

        gameObject.SetActive(false);

        Rigidbody rigidbody = gameObject.AddComponent <Rigidbody>();
        rigidbody.useGravity = false;
        // rigidbody.isKinematic = true;
        BoxCollider box = gameObject.AddComponent <BoxCollider>();

        // box.isTrigger = true;
        if (isBodyComponent)
        {
            gameObject.AddComponent <BodyCollider>();
            box.center = new Vector3(0, 0.85f, 0.5f);
            box.size   = new Vector3(0.2f, 0.5f, 0.2f);
        }
        else
        {
            gameObject.AddComponent <HandCollider>();
            box.size *= 0.65f;
        }
        return(renderer);
    }
    internal void UpdateSkinnedMeshRenderPBS(OvrAvatar avatar, IntPtr renderPart)
    {
        ovrAvatarVisibilityFlags visibilityMask = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetVisibilityMask(renderPart);
        ovrAvatarTransform       localTransform = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetTransform(renderPart);

        UpdateSkinnedMesh(avatar, mesh, bones, localTransform, visibilityMask, renderPart);

        Material mat              = mesh.sharedMaterial;
        UInt64   albedoTextureID  = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetAlbedoTextureAssetID(renderPart);
        UInt64   surfaceTextureID = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetSurfaceTextureAssetID(renderPart);

        mat.SetTexture("_Albedo", GetLoadedTexture(albedoTextureID));
        mat.SetTexture("_Surface", GetLoadedTexture(surfaceTextureID));
    }
Beispiel #14
0
    internal void UpdateSkinnedMeshRenderPBS(OvrAvatar avatar, IntPtr renderPart, Material mat)
    {
        if (!isMaterialInitilized)
        {
            isMaterialInitilized = true;
            UInt64 albedoTextureID  = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetAlbedoTextureAssetID(renderPart);
            UInt64 surfaceTextureID = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetSurfaceTextureAssetID(renderPart);
            mat.SetTexture("_Albedo", OvrAvatarComponent.GetLoadedTexture(albedoTextureID));
            mat.SetTexture("_Surface", OvrAvatarComponent.GetLoadedTexture(surfaceTextureID));
        }

        // Debug.Log("UpdateSkinnedMeshRenderPBS");
        ovrAvatarVisibilityFlags visibilityMask = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetVisibilityMask(renderPart);
        ovrAvatarTransform       localTransform = CAPI.ovrAvatarSkinnedMeshRenderPBS_GetTransform(renderPart);

        UpdateSkinnedMesh(avatar, bones, localTransform, visibilityMask, renderPart);
    }
    public void UpdateSkinnedMeshRender(OvrAvatarComponent component, OvrAvatar avatar, IntPtr renderPart)
    {
        ovrAvatarVisibilityFlags visibilityMask = CAPI.ovrAvatarSkinnedMeshRender_GetVisibilityMask(renderPart):
        ovrAvatarTransform localTransform = CAPI.ovrAvatarSkinnedMeshRender_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.ovrAvatarSkinnedMeshRender_MaterialStateChanged(renderPart):
            if (changedMaterial || (!previouslyActive && isActive))
            {
                ovrAvatarMaterialState materialState = CAPI.ovrAvatarSkinnedMeshRender_GetMaterialState(renderPart):
                component.UpdateAvatarMaterial(mesh.sharedMaterial, materialState):
            }
        }
        previouslyActive = isActive:
    }
    public void UpdateSkinnedMeshRender(
        OvrAvatarComponent component,
        OvrAvatar avatar,
        IntPtr renderPart)
    {
        // Debug.Log("UpdateSkinnedMeshRenderPBSV2");

        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);
            }
        }

        if (blendShapeCount > 0)
        {
            const float BLEND_MULTIPLIER = 100.0f;
            CAPI.ovrAvatarSkinnedMeshRender_GetBlendShapeParams(renderPart, ref blendShapeParams);
            for (uint i = 0; i < blendShapeParams.blendShapeParamCount && i < blendShapeCount; i++)
            {
                float value = blendShapeParams.blendShapeParams[i];
                mesh.SetBlendShapeWeight((int)i, value * BLEND_MULTIPLIER);
            }
        }

        previouslyActive = isActive;
    }
    protected void UpdateActive(OvrAvatar avatar, ovrAvatarVisibilityFlags mask)
    {
        bool doActiveHack = isBodyComponent && avatar.EnableExpressive && avatar.ShowFirstPerson && !avatar.ShowThirdPerson;

        if (doActiveHack)
        {
            bool showFirstPerson = (mask & ovrAvatarVisibilityFlags.FirstPerson) != 0;
            bool showThirdPerson = (mask & ovrAvatarVisibilityFlags.ThirdPerson) != 0;
            gameObject.SetActive(showThirdPerson || showThirdPerson);

            if (!showFirstPerson)
            {
                mesh.enabled = false;
            }
        }
        else
        {
            bool active = avatar.ShowFirstPerson && (mask & ovrAvatarVisibilityFlags.FirstPerson) != 0;
            active |= avatar.ShowThirdPerson && (mask & ovrAvatarVisibilityFlags.ThirdPerson) != 0;
            this.gameObject.SetActive(active);
            mesh.enabled = active;
        }
    }
    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;
    }
Beispiel #19
0
 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);
     }
 }
    protected void UpdateSkinnedMesh(OvrAvatar avatar, Transform[] bones, ovrAvatarTransform localTransform, ovrAvatarVisibilityFlags visibilityMask, IntPtr renderPart)
    {
        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;
    }