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);
}
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:
}
private void HandleAssetAvailable(OvrAvatarAsset asset)
{
if (asset.assetID == MeshID)
{
Mesh = gameObject.AddComponent <MeshFilter>();
MeshInstance = gameObject.AddComponent <MeshRenderer>();
MeshInstance.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
Mesh.sharedMesh = ((OvrAvatarAssetMesh)asset).mesh;
Material mat = new Material(Shader.Find("OvrAvatar/AvatarSurfaceShaderSelfOccluding"));
MeshInstance.material = mat;
}
if (asset.assetID == MaterialID)
{
MaterialState = ((OvrAvatarAssetMaterial)asset).material;
MaterialState.alphaMaskTextureID = FadeTextureID;
RequestMaterialTextures();
}
}
public void UpdateAvatarMaterial(Material mat, ovrAvatarMaterialState matState)
{
mat.SetColor("_BaseColor", matState.baseColor);
mat.SetInt("_BaseMaskType", (int)matState.baseMaskType);
mat.SetVector("_BaseMaskParameters", matState.baseMaskParameters);
mat.SetVector("_BaseMaskAxis", matState.baseMaskAxis);
if (matState.alphaMaskTextureID != 0)
{
mat.SetTexture("_AlphaMask", GetLoadedTexture(matState.alphaMaskTextureID));
mat.SetTextureScale("_AlphaMask", new Vector2(matState.alphaMaskScaleOffset.x, matState.alphaMaskScaleOffset.y));
mat.SetTextureOffset("_AlphaMask", new Vector2(matState.alphaMaskScaleOffset.z, matState.alphaMaskScaleOffset.w));
}
if (ClothingAlphaTexture != 0)
{
mat.EnableKeyword("VERTALPHA_ON");
mat.SetTexture("_AlphaMask2", GetLoadedTexture(ClothingAlphaTexture));
mat.SetTextureScale("_AlphaMask2", new Vector2(ClothingAlphaOffset.x, ClothingAlphaOffset.y));
mat.SetTextureOffset("_AlphaMask2", new Vector2(ClothingAlphaOffset.z, ClothingAlphaOffset.w));
}
if (matState.normalMapTextureID != 0)
{
mat.EnableKeyword("NORMAL_MAP_ON");
mat.SetTexture("_NormalMap", GetLoadedTexture(matState.normalMapTextureID));
mat.SetTextureScale("_NormalMap", new Vector2(matState.normalMapScaleOffset.x, matState.normalMapScaleOffset.y));
mat.SetTextureOffset("_NormalMap", new Vector2(matState.normalMapScaleOffset.z, matState.normalMapScaleOffset.w));
}
if (matState.parallaxMapTextureID != 0)
{
mat.SetTexture("_ParallaxMap", GetLoadedTexture(matState.parallaxMapTextureID));
mat.SetTextureScale("_ParallaxMap", new Vector2(matState.parallaxMapScaleOffset.x, matState.parallaxMapScaleOffset.y));
mat.SetTextureOffset("_ParallaxMap", new Vector2(matState.parallaxMapScaleOffset.z, matState.parallaxMapScaleOffset.w));
}
if (matState.roughnessMapTextureID != 0)
{
mat.EnableKeyword("ROUGHNESS_ON");
mat.SetTexture("_RoughnessMap", GetLoadedTexture(matState.roughnessMapTextureID));
mat.SetTextureScale("_RoughnessMap", new Vector2(matState.roughnessMapScaleOffset.x, matState.roughnessMapScaleOffset.y));
mat.SetTextureOffset("_RoughnessMap", new Vector2(matState.roughnessMapScaleOffset.z, matState.roughnessMapScaleOffset.w));
}
mat.EnableKeyword(LayerKeywords[matState.layerCount]);
for (ulong layerIndex = 0; layerIndex < matState.layerCount; layerIndex++)
{
ovrAvatarMaterialLayerState layer = matState.layers[layerIndex];
mat.SetInt(LayerSampleModeParameters[layerIndex], (int)layer.sampleMode);
mat.SetInt(LayerBlendModeParameters[layerIndex], (int)layer.blendMode);
mat.SetInt(LayerMaskTypeParameters[layerIndex], (int)layer.maskType);
mat.SetColor(LayerColorParameters[layerIndex], layer.layerColor);
if (layer.sampleMode != ovrAvatarMaterialLayerSampleMode.Color)
{
string surfaceProperty = LayerSurfaceParameters[layerIndex];
mat.SetTexture(surfaceProperty, GetLoadedTexture(layer.sampleTexture));
mat.SetTextureScale(surfaceProperty, new Vector2(layer.sampleScaleOffset.x, layer.sampleScaleOffset.y));
mat.SetTextureOffset(surfaceProperty, new Vector2(layer.sampleScaleOffset.z, layer.sampleScaleOffset.w));
}
if (layer.sampleMode == ovrAvatarMaterialLayerSampleMode.Parallax)
{
mat.EnableKeyword("PARALLAX_ON");
}
mat.SetColor(LayerSampleParametersParameters[layerIndex], layer.sampleParameters);
mat.SetColor(LayerMaskParametersParameters[layerIndex], layer.maskParameters);
mat.SetColor(LayerMaskAxisParameters[layerIndex], layer.maskAxis);
}
materialStates[mat] = matState;
}
protected void UpdateAvatarMaterial(Material mat, ovrAvatarMaterialState matState)
{
// Only update the material if it's a material we actively created
ovrAvatarMaterialState cachedState;
if (!materialStates.TryGetValue(mat, out cachedState))
{
return;
}
if (cachedState.Equals(matState))
{
return;
}
mat.SetColor("_BaseColor", matState.baseColor);
mat.SetInt("_BaseMaskType", (int)matState.baseMaskType);
mat.SetVector("_BaseMaskParameters", matState.baseMaskParameters);
mat.SetVector("_BaseMaskAxis", matState.baseMaskAxis);
if (matState.alphaMaskTextureID != 0)
{
mat.SetTexture("_AlphaMask", GetLoadedTexture(matState.alphaMaskTextureID));
mat.SetTextureScale("_AlphaMask", new Vector2(matState.alphaMaskScaleOffset.x, matState.alphaMaskScaleOffset.y));
mat.SetTextureOffset("_AlphaMask", new Vector2(matState.alphaMaskScaleOffset.z, matState.alphaMaskScaleOffset.w));
}
if (matState.normalMapTextureID != 0)
{
mat.EnableKeyword("NORMAL_MAP_ON");
mat.SetTexture("_NormalMap", GetLoadedTexture(matState.normalMapTextureID));
mat.SetTextureScale("_NormalMap", new Vector2(matState.normalMapScaleOffset.x, matState.normalMapScaleOffset.y));
mat.SetTextureOffset("_NormalMap", new Vector2(matState.normalMapScaleOffset.z, matState.normalMapScaleOffset.w));
}
if (matState.parallaxMapTextureID != 0)
{
mat.EnableKeyword("PARALLAX_ON");
mat.SetTexture("_ParallaxMap", GetLoadedTexture(matState.parallaxMapTextureID));
mat.SetTextureScale("_ParallaxMap", new Vector2(matState.parallaxMapScaleOffset.x, matState.parallaxMapScaleOffset.y));
mat.SetTextureOffset("_ParallaxMap", new Vector2(matState.parallaxMapScaleOffset.z, matState.parallaxMapScaleOffset.w));
}
if (matState.parallaxMapTextureID != 0)
{
mat.EnableKeyword("ROUGHNESS_ON");
mat.SetTexture("_RoughnessMap", GetLoadedTexture(matState.roughnessMapTextureID));
mat.SetTextureScale("_RoughnessMap", new Vector2(matState.roughnessMapScaleOffset.x, matState.roughnessMapScaleOffset.y));
mat.SetTextureOffset("_RoughnessMap", new Vector2(matState.roughnessMapScaleOffset.z, matState.roughnessMapScaleOffset.w));
}
mat.EnableKeyword(LayerKeywords[matState.layerCount]);
for (ulong layerIndex = 0; layerIndex < matState.layerCount; layerIndex++)
{
ovrAvatarMaterialLayerState layer = matState.layers[layerIndex];
mat.SetInt(LayerSampleModeParameters[layerIndex], (int)layer.sampleMode);
mat.SetInt(LayerBlendModeParameters[layerIndex], (int)layer.blendMode);
mat.SetInt(LayerMaskTypeParameters[layerIndex], (int)layer.maskType);
mat.SetColor(LayerColorParameters[layerIndex], layer.layerColor);
if (layer.sampleMode != ovrAvatarMaterialLayerSampleMode.Color)
{
string surfaceProperty = LayerSurfaceParameters[layerIndex];
mat.SetTexture(surfaceProperty, GetLoadedTexture(layer.sampleTexture));
mat.SetTextureScale(surfaceProperty, new Vector2(layer.sampleScaleOffset.x, layer.sampleScaleOffset.y));
mat.SetTextureOffset(surfaceProperty, new Vector2(layer.sampleScaleOffset.z, layer.sampleScaleOffset.w));
}
mat.SetColor(LayerSampleParametersParameters[layerIndex], layer.sampleParameters);
mat.SetColor(LayerMaskParametersParameters[layerIndex], layer.maskParameters);
mat.SetColor(LayerMaskAxisParameters[layerIndex], layer.maskAxis);
}
materialStates[mat] = matState;
}
public void UpdateAvatar(ovrAvatarComponent component, OvrAvatar avatar)
{
if (IsCombiningMeshes)
{
if (!IsVertexDataUpdating)
{
CombineMeshes(component);
IsCombiningMeshes = false;
ThreadData = null;
}
return;
}
OvrAvatar.ConvertTransform(component.transform, transform);
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.SkinnedMeshRender:
((OvrAvatarSkinnedMeshRenderComponent)renderComponent).UpdateSkinnedMeshRender(this, avatar, renderPart);
break;
case ovrAvatarRenderPartType.SkinnedMeshRenderPBS:
var material = RootMeshComponent != null ? RootMeshComponent.sharedMaterial : renderComponent.mesh.sharedMaterial;
((OvrAvatarSkinnedMeshRenderPBSComponent)renderComponent).UpdateSkinnedMeshRenderPBS(avatar, renderPart, material);
break;
case ovrAvatarRenderPartType.ProjectorRender:
((OvrAvatarProjectorRenderComponent)renderComponent).UpdateProjectorRender(this, CAPI.ovrAvatarRenderPart_GetProjectorRender(renderPart));
break;
case ovrAvatarRenderPartType.SkinnedMeshRenderPBS_V2:
((OvrAvatarSkinnedMeshPBSV2RenderComponent)renderComponent).UpdateSkinnedMeshRender(this, avatar, renderPart);
break;
default:
break;
}
}
// The mesh has been combined and therefore update the combined mesh "components"
if (RootMeshComponent != null)
{
var part_zero = OvrAvatar.GetRenderPart(component, 0);
ovrAvatarRenderPartType typeZero = CAPI.ovrAvatarRenderPart_GetType(part_zero);
switch (typeZero)
{
case ovrAvatarRenderPartType.SkinnedMeshRender:
UpdateActive(avatar, CAPI.ovrAvatarSkinnedMeshRender_GetVisibilityMask(part_zero));
bool changedMaterial = (FirstMaterialUpdate && gameObject.activeSelf) || CAPI.ovrAvatarSkinnedMeshRender_MaterialStateChanged(part_zero);
if (changedMaterial)
{
FirstMaterialUpdate = false;
ovrAvatarMaterialState materialState = CAPI.ovrAvatarSkinnedMeshRender_GetMaterialState(part_zero);
UpdateAvatarMaterial(RootMeshComponent.sharedMaterial, materialState);
}
break;
case ovrAvatarRenderPartType.SkinnedMeshRenderPBS:
UpdateActive(avatar, CAPI.ovrAvatarSkinnedMeshRenderPBS_GetVisibilityMask(part_zero));
break;
case ovrAvatarRenderPartType.ProjectorRender:
default:
break;
}
}
DebugDrawTransforms();
}
public override bool Equals(object obj)
{
if (!(obj is ovrAvatarMaterialState))
{
return(false);
}
ovrAvatarMaterialState other = (ovrAvatarMaterialState)obj;
if (!VectorEquals(baseColor, other.baseColor))
{
return(false);
}
if (baseMaskType != other.baseMaskType)
{
return(false);
}
if (!VectorEquals(baseMaskParameters, other.baseMaskParameters))
{
return(false);
}
if (!VectorEquals(baseMaskAxis, other.baseMaskAxis))
{
return(false);
}
if (sampleMode != other.sampleMode)
{
return(false);
}
if (alphaMaskTextureID != other.alphaMaskTextureID)
{
return(false);
}
if (!VectorEquals(alphaMaskScaleOffset, other.alphaMaskScaleOffset))
{
return(false);
}
if (normalMapTextureID != other.normalMapTextureID)
{
return(false);
}
if (!VectorEquals(normalMapScaleOffset, other.normalMapScaleOffset))
{
return(false);
}
if (parallaxMapTextureID != other.parallaxMapTextureID)
{
return(false);
}
if (!VectorEquals(parallaxMapScaleOffset, other.parallaxMapScaleOffset))
{
return(false);
}
if (roughnessMapTextureID != other.roughnessMapTextureID)
{
return(false);
}
if (!VectorEquals(roughnessMapScaleOffset, other.roughnessMapScaleOffset))
{
return(false);
}
if (layerCount != other.layerCount)
{
return(false);
}
for (int i = 0; i < layerCount; ++i)
{
if (!layers[i].Equals(other.layers[i]))
{
return(false);
}
}
return(true);
}
