using System;
using Oculus.Avatar;
using UnityEngine;

public class OvrAvatarSkinnedMeshPBSV2RenderComponent : OvrAvatarRenderComponent
{
	public OvrAvatarMaterialManager AvatarMaterialManager;

	private bool PreviouslyActive;

	private bool IsCombinedMaterial;

	private ovrAvatarExpressiveParameters ExpressiveParameters;

	private bool EnableExpressive;

	private const string MAIN_MATERIAL_NAME = "main_material";

	private const string EYE_MATERIAL_NAME = "eye_material";

	private const string DEFAULT_MATERIAL_NAME = "_material";

	internal void Initialize(IntPtr renderPart, ovrAvatarRenderPart_SkinnedMeshRenderPBS_V2 skinnedMeshRender, OvrAvatarMaterialManager materialManager, int thirdPersonLayer, int firstPersonLayer, int sortOrder, bool isCombinedMaterial, ovrAvatarAssetLevelOfDetail lod, bool assignExpressiveParams, OvrAvatar avatar, bool isControllerModel)
	{
		AvatarMaterialManager = materialManager;
		IsCombinedMaterial = isCombinedMaterial;
		mesh = CreateSkinnedMesh(skinnedMeshRender.meshAssetID, skinnedMeshRender.visibilityMask, thirdPersonLayer, firstPersonLayer, sortOrder);
		EnableExpressive = assignExpressiveParams;
		Shader shader = ((!EnableExpressive) ? avatar.Skinshaded_SurfaceShader_SingleComponent : avatar.Skinshaded_Expressive_SurfaceShader_SingleComponent);
		Shader shader2 = ((!EnableExpressive) ? avatar.Skinshaded_VertFrag_CombinedMesh : avatar.Skinshaded_Expressive_VertFrag_CombinedMesh);
		Shader shader3 = ((!IsCombinedMaterial) ? shader : shader2);
		if (isControllerModel)
		{
			shader3 = Shader.Find("OvrAvatar/AvatarPBRV2Simple");
		}
		if (EnableExpressive)
		{
			ExpressiveParameters = CAPI.ovrAvatar_GetExpressiveParameters(avatar.sdkAvatar);
			Shader eyeLens = avatar.EyeLens;
			Material[] array = new Material[2]
			{
				CreateAvatarMaterial(base.gameObject.name + "main_material", shader3),
				CreateAvatarMaterial(base.gameObject.name + "eye_material", eyeLens)
			};
			if (avatar.UseTransparentRenderQueue)
			{
				array[0].SetOverrideTag("RenderType", "Transparent");
				array[0].SetInt("_SrcBlend", 5);
				array[0].SetInt("_DstBlend", 10);
				array[0].EnableKeyword("_ALPHATEST_ON");
				array[0].EnableKeyword("_ALPHABLEND_ON");
				array[0].EnableKeyword("_ALPHAPREMULTIPLY_ON");
				array[0].renderQueue = 3000;
			}
			else
			{
				array[0].SetOverrideTag("RenderType", "Opaque");
				array[0].SetInt("_SrcBlend", 1);
				array[0].SetInt("_DstBlend", 0);
				array[0].DisableKeyword("_ALPHATEST_ON");
				array[0].DisableKeyword("_ALPHABLEND_ON");
				array[0].DisableKeyword("_ALPHAPREMULTIPLY_ON");
				array[0].renderQueue = 2000;
			}
			array[1].renderQueue = -1;
			mesh.materials = array;
		}
		else
		{
			mesh.sharedMaterial = CreateAvatarMaterial(base.gameObject.name + "_material", shader3);
			if (avatar.UseTransparentRenderQueue && !isControllerModel)
			{
				mesh.sharedMaterial.SetOverrideTag("RenderType", "Transparent");
				mesh.sharedMaterial.SetInt("_SrcBlend", 5);
				mesh.sharedMaterial.SetInt("_DstBlend", 10);
				mesh.sharedMaterial.EnableKeyword("_ALPHATEST_ON");
				mesh.sharedMaterial.EnableKeyword("_ALPHABLEND_ON");
				mesh.sharedMaterial.EnableKeyword("_ALPHAPREMULTIPLY_ON");
				mesh.sharedMaterial.renderQueue = 3000;
			}
			else
			{
				mesh.sharedMaterial.SetOverrideTag("RenderType", "Opaque");
				mesh.sharedMaterial.SetInt("_SrcBlend", 1);
				mesh.sharedMaterial.SetInt("_DstBlend", 0);
				mesh.sharedMaterial.DisableKeyword("_ALPHATEST_ON");
				mesh.sharedMaterial.DisableKeyword("_ALPHABLEND_ON");
				mesh.sharedMaterial.DisableKeyword("_ALPHAPREMULTIPLY_ON");
				mesh.sharedMaterial.renderQueue = 2000;
			}
		}
		bones = mesh.bones;
		if (IsCombinedMaterial)
		{
			AvatarMaterialManager.SetRenderer(mesh);
			InitializeCombinedMaterial(renderPart, (int)(lod - 1));
			AvatarMaterialManager.OnCombinedMeshReady();
		}
	}

	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 activeSelf = base.gameObject.activeSelf;
		if (mesh != null && !PreviouslyActive && activeSelf && !IsCombinedMaterial)
		{
			InitializeSingleComponentMaterial(renderPart, (int)(avatar.LevelOfDetail - 1));
		}
		PreviouslyActive = activeSelf;
	}

	private void InitializeSingleComponentMaterial(IntPtr renderPart, int lodIndex)
	{
		ovrAvatarPBSMaterialState ovrAvatarPBSMaterialState2 = CAPI.ovrAvatarSkinnedMeshRenderPBSV2_GetPBSMaterialState(renderPart);
		int componentType = (int)OvrAvatarMaterialManager.GetComponentType(base.gameObject.name);
		OvrAvatarMaterialManager.AvatarComponentMaterialProperties[] componentMaterialProperties = AvatarMaterialManager.DefaultAvatarConfig.ComponentMaterialProperties;
		Texture2D texture2D = OvrAvatarComponent.GetLoadedTexture(ovrAvatarPBSMaterialState2.albedoTextureID);
		Texture2D texture2D2 = OvrAvatarComponent.GetLoadedTexture(ovrAvatarPBSMaterialState2.normalTextureID);
		Texture2D texture2D3 = OvrAvatarComponent.GetLoadedTexture(ovrAvatarPBSMaterialState2.metallicnessTextureID);
		if (texture2D == null)
		{
			texture2D = AvatarMaterialManager.DiffuseFallbacks[lodIndex];
		}
		if (texture2D2 == null)
		{
			texture2D2 = AvatarMaterialManager.NormalFallbacks[lodIndex];
		}
		if (texture2D3 == null)
		{
			texture2D3 = AvatarMaterialManager.DiffuseFallbacks[lodIndex];
		}
		mesh.materials[0].SetTexture(OvrAvatarMaterialManager.AVATAR_SHADER_MAINTEX, texture2D);
		mesh.materials[0].SetTexture(OvrAvatarMaterialManager.AVATAR_SHADER_NORMALMAP, texture2D2);
		mesh.materials[0].SetTexture(OvrAvatarMaterialManager.AVATAR_SHADER_ROUGHNESSMAP, texture2D3);
		mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_COLOR, ovrAvatarPBSMaterialState2.albedoMultiplier);
		mesh.materials[0].SetFloat(OvrAvatarMaterialManager.AVATAR_SHADER_DIFFUSEINTENSITY, componentMaterialProperties[componentType].DiffuseIntensity);
		mesh.materials[0].SetFloat(OvrAvatarMaterialManager.AVATAR_SHADER_RIMINTENSITY, componentMaterialProperties[componentType].RimIntensity);
		mesh.materials[0].SetFloat(OvrAvatarMaterialManager.AVATAR_SHADER_REFLECTIONINTENSITY, componentMaterialProperties[componentType].ReflectionIntensity);
		mesh.GetClosestReflectionProbes(AvatarMaterialManager.ReflectionProbes);
		if (AvatarMaterialManager.ReflectionProbes != null && AvatarMaterialManager.ReflectionProbes.Count > 0)
		{
			mesh.materials[0].SetTexture(OvrAvatarMaterialManager.AVATAR_SHADER_CUBEMAP, AvatarMaterialManager.ReflectionProbes[0].probe.texture);
		}
		if (EnableExpressive)
		{
			mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_IRIS_COLOR, ExpressiveParameters.irisColor);
			mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_LIP_COLOR, ExpressiveParameters.lipColor);
			mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_BROW_COLOR, ExpressiveParameters.browColor);
			mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_LASH_COLOR, ExpressiveParameters.lashColor);
			mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_SCLERA_COLOR, ExpressiveParameters.scleraColor);
			mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_GUM_COLOR, ExpressiveParameters.gumColor);
			mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_TEETH_COLOR, ExpressiveParameters.teethColor);
			mesh.materials[0].SetFloat(OvrAvatarMaterialManager.AVATAR_SHADER_LIP_SMOOTHNESS, ExpressiveParameters.lipSmoothness);
		}
	}

	private void InitializeCombinedMaterial(IntPtr renderPart, int lodIndex)
	{
		ovrAvatarPBSMaterialState[] array = CAPI.ovrAvatar_GetBodyPBSMaterialStates(renderPart);
		if (array.Length == 5)
		{
			AvatarMaterialManager.CreateTextureArrays();
			AvatarMaterialManager.LocalAvatarConfig = AvatarMaterialManager.DefaultAvatarConfig;
			OvrAvatarMaterialManager.AvatarComponentMaterialProperties[] componentMaterialProperties = AvatarMaterialManager.LocalAvatarConfig.ComponentMaterialProperties;
			for (int i = 0; i < array.Length; i++)
			{
				componentMaterialProperties[i].TypeIndex = (ovrAvatarBodyPartType)i;
				componentMaterialProperties[i].Color = array[i].albedoMultiplier;
				Texture2D loadedTexture = OvrAvatarComponent.GetLoadedTexture(array[i].albedoTextureID);
				Texture2D loadedTexture2 = OvrAvatarComponent.GetLoadedTexture(array[i].normalTextureID);
				Texture2D loadedTexture3 = OvrAvatarComponent.GetLoadedTexture(array[i].metallicnessTextureID);
				componentMaterialProperties[i].Textures[0] = ((!(loadedTexture == null)) ? loadedTexture : AvatarMaterialManager.DiffuseFallbacks[lodIndex]);
				componentMaterialProperties[i].Textures[1] = ((!(loadedTexture2 == null)) ? loadedTexture2 : AvatarMaterialManager.NormalFallbacks[lodIndex]);
				componentMaterialProperties[i].Textures[2] = ((!(loadedTexture3 == null)) ? loadedTexture3 : AvatarMaterialManager.DiffuseFallbacks[lodIndex]);
			}
			if (EnableExpressive)
			{
				mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_IRIS_COLOR, ExpressiveParameters.irisColor);
				mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_LIP_COLOR, ExpressiveParameters.lipColor);
				mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_BROW_COLOR, ExpressiveParameters.browColor);
				mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_LASH_COLOR, ExpressiveParameters.lashColor);
				mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_SCLERA_COLOR, ExpressiveParameters.scleraColor);
				mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_GUM_COLOR, ExpressiveParameters.gumColor);
				mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_TEETH_COLOR, ExpressiveParameters.teethColor);
				mesh.materials[0].SetFloat(OvrAvatarMaterialManager.AVATAR_SHADER_LIP_SMOOTHNESS, ExpressiveParameters.lipSmoothness);
			}
			AvatarMaterialManager.ValidateTextures();
		}
	}
}