using System.Collections;
using System.Collections.Generic;
using Oculus.Avatar;
using UnityEngine;
public class OvrAvatarTextureCopyManager : MonoBehaviour
{
[System.Serializable]
public struct FallbackTextureSet
{
public bool Initialized;
public Texture2D DiffuseRoughness;
public Texture2D Normal;
}
// Fallback texture sets are indexed with ovrAvatarAssetLevelOfDetail.
// We currently only use 1, 3 (mobile default), 5 (PC default).
public FallbackTextureSet[] FallbackTextureSets = new FallbackTextureSet[(int)ovrAvatarAssetLevelOfDetail.Highest + 1];
struct CopyTextureParams
{
public Texture Src;
public Texture Dst;
public int Mip;
public int SrcSize;
public int DstElement;
public CopyTextureParams(
Texture src,
Texture dst,
int mip,
int srcSize,
int dstElement)
{
Src = src;
Dst = dst;
Mip = mip;
SrcSize = srcSize;
DstElement = dstElement;
}
}
private Queue<CopyTextureParams> texturesToCopy;
public struct TextureSet
{
// Contains all texture asset IDs that are part of an avatar spec.
// Used by DeleteTextureSet().
// Textures that are part of combined mesh avatars can be safely deleted once they have been
// uploaded to the texture arrays.
// Textures that are part of single component meshes will remain in memory.
public Dictionary<ulong, bool> TextureIDSingleMeshPair;
public bool IsProcessed;
public TextureSet(
Dictionary<ulong, bool> textureIDSingleMeshPair,
bool isProcessed)
{
TextureIDSingleMeshPair = textureIDSingleMeshPair;
IsProcessed = isProcessed;
}
}
private Dictionary<int, TextureSet> textureSets;
private const int TEXTURES_TO_COPY_QUEUE_CAPACITY = 256;
private const int COPIES_PER_FRAME = 8;
// Fallback texture paths are indexed with ovrAvatarAssetLevelOfDetail
// We currently only use 1, 3 (mobile default), 5 (PC default)
private readonly string[] FALLBACK_TEXTURE_PATHS_DIFFUSE_ROUGHNESS = new string[]
{
"null",
PATH_LOWEST_DIFFUSE_ROUGHNESS,
"null",
PATH_MEDIUM_DIFFUSE_ROUGHNESS,
"null",
PATH_HIGHEST_DIFFUSE_ROUGHNESS,
};
private readonly string[] FALLBACK_TEXTURE_PATHS_NORMAL = new string[]
{
"null",
PATH_LOWEST_NORMAL,
"null",
PATH_MEDIUM_NORMAL,
"null",
PATH_HIGHEST_NORMAL,
};
private const string PATH_HIGHEST_DIFFUSE_ROUGHNESS = "FallbackTextures/fallback_diffuse_roughness_2048";
private const string PATH_MEDIUM_DIFFUSE_ROUGHNESS = "FallbackTextures/fallback_diffuse_roughness_1024";
private const string PATH_LOWEST_DIFFUSE_ROUGHNESS = "FallbackTextures/fallback_diffuse_roughness_256";
private const string PATH_HIGHEST_NORMAL = "FallbackTextures/fallback_normal_2048";
private const string PATH_MEDIUM_NORMAL = "FallbackTextures/fallback_normal_1024";
private const string PATH_LOWEST_NORMAL = "FallbackTextures/fallback_normal_256";
private const int GPU_TEXTURE_COPY_WAIT_TIME = 10;
public OvrAvatarTextureCopyManager()
{
texturesToCopy = new Queue<CopyTextureParams>(TEXTURES_TO_COPY_QUEUE_CAPACITY);
textureSets = new Dictionary<int, TextureSet>();
}
public void Update()
{
if (texturesToCopy.Count == 0)
{
return;
}
lock (texturesToCopy)
{
for (int i = 0; i < Mathf.Min(COPIES_PER_FRAME, texturesToCopy.Count); ++i)
{
CopyTexture(texturesToCopy.Dequeue());
}
}
}
public int GetTextureCount()
{
return texturesToCopy.Count;
}
public void CopyTexture(
Texture src,
Texture dst,
int mipLevel,
int mipSize,
int dstElement,
bool useQueue = true)
{
var copyTextureParams = new CopyTextureParams(src, dst, mipLevel, mipSize, dstElement);
if (useQueue)
{
lock (texturesToCopy)
{
if (texturesToCopy.Count < TEXTURES_TO_COPY_QUEUE_CAPACITY)
{
texturesToCopy.Enqueue(copyTextureParams);
}
else
{
// Queue is full so copy texture immediately
CopyTexture(copyTextureParams);
}
}
}
else
{
CopyTexture(copyTextureParams);
}
}
private void CopyTexture(CopyTextureParams copyTextureParams)
{
Graphics.CopyTexture(
copyTextureParams.Src,
0,
copyTextureParams.Mip,
copyTextureParams.Dst,
copyTextureParams.DstElement,
copyTextureParams.Mip);
}
public void AddTextureIDToTextureSet(int gameobjectID, ulong textureID, bool isSingleMesh)
{
if (!textureSets.ContainsKey(gameobjectID))
{
TextureSet newTextureSet = new TextureSet(new Dictionary<ulong, bool>(), false);
newTextureSet.TextureIDSingleMeshPair.Add(textureID, isSingleMesh);
textureSets.Add(gameobjectID, newTextureSet);
}
else
{
bool TexIDSingleMesh;
if (textureSets[gameobjectID].TextureIDSingleMeshPair.TryGetValue(textureID, out TexIDSingleMesh))
{
if (!TexIDSingleMesh && isSingleMesh)
{
textureSets[gameobjectID].TextureIDSingleMeshPair[textureID] = true;
}
}
else
{
textureSets[gameobjectID].TextureIDSingleMeshPair.Add(textureID, isSingleMesh);
}
}
}
// This is called by a fully loaded avatar using combined mesh to safely delete unused textures.
public void DeleteTextureSet(int gameobjectID)
{
TextureSet textureSetToDelete;
if (!textureSets.TryGetValue(gameobjectID, out textureSetToDelete))
{
return;
};
if (textureSetToDelete.IsProcessed)
{
return;
}
StartCoroutine(DeleteTextureSetCoroutine(textureSetToDelete, gameobjectID));
}
private IEnumerator DeleteTextureSetCoroutine(TextureSet textureSetToDelete, int gameobjectID)
{
// Wait a conservative amount of time for gpu upload to finish. Unity 2017 doesn't support async GPU calls,
// so this 10 second time is a very conservative delay for this process to occur, which should be <1 sec.
yield return new WaitForSeconds(GPU_TEXTURE_COPY_WAIT_TIME);
// Spin if an avatar is loading
while (OvrAvatarSDKManager.Instance.IsAvatarLoading())
{
yield return null;
}
// The avatar's texture set is compared against all other loaded or loading avatar texture sets.
foreach (var textureIdAndSingleMeshFlag in textureSetToDelete.TextureIDSingleMeshPair)
{
bool triggerDelete = !textureIdAndSingleMeshFlag.Value;
if (triggerDelete)
{
foreach (KeyValuePair<int, TextureSet> textureSet in textureSets)
{
if (textureSet.Key == gameobjectID)
{
continue;
}
foreach (var comparisonTextureIDSingleMeshPair in textureSet.Value.TextureIDSingleMeshPair)
{
// Mark the texture as not deletable if it's present in another set and that set hasn't been processed
// or that texture ID is marked as part of a single mesh component.
if (comparisonTextureIDSingleMeshPair.Key == textureIdAndSingleMeshFlag.Key &&
(!textureSet.Value.IsProcessed || comparisonTextureIDSingleMeshPair.Value))
{
triggerDelete = false;
break;
}
}
if (!triggerDelete)
{
break;
}
}
}
if (triggerDelete)
{
Texture2D textureToDelete = OvrAvatarComponent.GetLoadedTexture(textureIdAndSingleMeshFlag.Key);
if (textureToDelete != null)
{
AvatarLogger.Log("Deleting texture " + textureIdAndSingleMeshFlag.Key);
OvrAvatarSDKManager.Instance.DeleteAssetFromCache(textureIdAndSingleMeshFlag.Key);
Destroy(textureToDelete);
}
}
}
textureSetToDelete.IsProcessed = true;
textureSets.Remove(gameobjectID);
}
public void CheckFallbackTextureSet(ovrAvatarAssetLevelOfDetail lod)
{
if (FallbackTextureSets[(int)lod].Initialized)
{
return;
}
InitFallbackTextureSet(lod);
}
private void InitFallbackTextureSet(ovrAvatarAssetLevelOfDetail lod)
{
FallbackTextureSets[(int)lod].DiffuseRoughness = FallbackTextureSets[(int)lod].DiffuseRoughness =
Resources.Load<Texture2D>(FALLBACK_TEXTURE_PATHS_DIFFUSE_ROUGHNESS[(int)lod]);
FallbackTextureSets[(int)lod].Normal = FallbackTextureSets[(int)lod].Normal =
Resources.Load<Texture2D>(FALLBACK_TEXTURE_PATHS_NORMAL[(int)lod]);
FallbackTextureSets[(int)lod].Initialized = true;
}
}
