BlueGit

blue-star ggj-2020

Files

ggj-2020 / Assets / Oculus / Avatar / Scripts / OvrAvatarSkinnedMeshRenderPBSV2Component.cs

OvrAvatarSkinnedMeshRenderPBSV2Component.cs

Project Import
timfa Tim Falken · pushed by timfa · 6 years ago
b77834a1 History
OvrAvatarSkinnedMeshRenderPBSV2Component.cs 15.7 KiB Download Raw
1using UnityEngine;
2using System.Collections.Generic;
3using System;
4using Oculus.Avatar;
5
6public class OvrAvatarSkinnedMeshPBSV2RenderComponent : OvrAvatarRenderComponent
7{
8 private OvrAvatarMaterialManager avatarMaterialManager;
9 private bool previouslyActive = false;
10 private bool isCombinedMaterial = false;
11 private ovrAvatarExpressiveParameters ExpressiveParameters;
12 private bool EnableExpressive = false;
13 private int blendShapeCount = 0;
14 private ovrAvatarBlendShapeParams blendShapeParams;
15
16 private const string MAIN_MATERIAL_NAME = "main_material";
17 private const string EYE_MATERIAL_NAME = "eye_material";
18 private const string DEFAULT_MATERIAL_NAME = "_material";
19
20 internal void Initialize(
21 IntPtr renderPart,
22 ovrAvatarRenderPart_SkinnedMeshRenderPBS_V2 skinnedMeshRender,
23 OvrAvatarMaterialManager materialManager,
24 int thirdPersonLayer,
25 int firstPersonLayer,
26 bool combinedMesh,
27 ovrAvatarAssetLevelOfDetail lod,
28 bool assignExpressiveParams,
29 OvrAvatar avatar,
30 bool isControllerModel)
31 {
32 avatarMaterialManager = materialManager;
33 isCombinedMaterial = combinedMesh;
34
35 mesh = CreateSkinnedMesh(
36 skinnedMeshRender.meshAssetID,
37 skinnedMeshRender.visibilityMask,
38 thirdPersonLayer,
39 firstPersonLayer);
40
41 EnableExpressive = assignExpressiveParams;
42
43#if UNITY_ANDROID
44 var singleComponentShader = EnableExpressive
45 ? avatar.Skinshaded_Expressive_VertFrag_SingleComponent
46 : avatar.Skinshaded_VertFrag_SingleComponent;
47#else
48 var singleComponentShader = EnableExpressive
49 ? avatar.Skinshaded_Expressive_SurfaceShader_SingleComponent
50 : avatar.Skinshaded_SurfaceShader_SingleComponent;
51#endif
52 var combinedComponentShader = EnableExpressive
53 ? avatar.Skinshaded_Expressive_VertFrag_CombinedMesh
54 : avatar.Skinshaded_VertFrag_CombinedMesh;
55
56 var mainShader = isCombinedMaterial ? combinedComponentShader : singleComponentShader;
57
58 if (isControllerModel)
59 {
60 mainShader = avatar.ControllerShader;
61 }
62
63 AvatarLogger.Log("OvrAvatarSkinnedMeshPBSV2RenderComponent Shader is: " + mainShader != null
64 ? mainShader.name : "null");
65
66 if (EnableExpressive)
67 {
68 ExpressiveParameters = CAPI.ovrAvatar_GetExpressiveParameters(avatar.sdkAvatar);
69 var eyeShader = avatar.EyeLens;
70
71 Material[] matArray = new Material[2];
72 matArray[0] = CreateAvatarMaterial(gameObject.name + MAIN_MATERIAL_NAME, mainShader);
73 matArray[1] = CreateAvatarMaterial(gameObject.name + EYE_MATERIAL_NAME, eyeShader);
74
75 if (avatar.UseTransparentRenderQueue)
76 {
77 SetMaterialTransparent(matArray[0]);
78 }
79 else
80 {
81 SetMaterialOpaque(matArray[0]);
82 }
83 // Eye lens shader queue is transparent and set from shader
84 matArray[1].renderQueue = -1;
85 mesh.materials = matArray;
86 }
87 else
88 {
89 mesh.sharedMaterial = CreateAvatarMaterial(gameObject.name + DEFAULT_MATERIAL_NAME, mainShader);
90 if (avatar.UseTransparentRenderQueue && !isControllerModel)
91 {
92 SetMaterialTransparent(mesh.sharedMaterial);
93 }
94 else
95 {
96 SetMaterialOpaque(mesh.sharedMaterial);
97 }
98 }
99 bones = mesh.bones;
100
101 if (isCombinedMaterial)
102 {
103 avatarMaterialManager.SetRenderer(mesh);
104 InitializeCombinedMaterial(renderPart, (int)lod);
105 avatarMaterialManager.OnCombinedMeshReady();
106 }
107
108 blendShapeParams = new ovrAvatarBlendShapeParams();
109 blendShapeParams.blendShapeParamCount = 0;
110 blendShapeParams.blendShapeParams = new float[64];
111
112 blendShapeCount = mesh.sharedMesh.blendShapeCount;
113 }
114
115 public void UpdateSkinnedMeshRender(
116 OvrAvatarComponent component,
117 OvrAvatar avatar,
118 IntPtr renderPart)
119 {
120 ovrAvatarVisibilityFlags visibilityMask
121 = CAPI.ovrAvatarSkinnedMeshRenderPBSV2_GetVisibilityMask(renderPart);
122
123 ovrAvatarTransform localTransform
124 = CAPI.ovrAvatarSkinnedMeshRenderPBSV2_GetTransform(renderPart);
125
126 UpdateSkinnedMesh(avatar, bones, localTransform, visibilityMask, renderPart);
127
128 bool isActive = gameObject.activeSelf;
129
130 if (mesh != null && !previouslyActive && isActive)
131 {
132 if (!isCombinedMaterial)
133 {
134 InitializeSingleComponentMaterial(renderPart, (int)avatar.LevelOfDetail - 1);
135 }
136 }
137
138 if (blendShapeCount > 0)
139 {
140 const float BLEND_MULTIPLIER = 100.0f;
141 CAPI.ovrAvatarSkinnedMeshRender_GetBlendShapeParams(renderPart, ref blendShapeParams);
142 for (uint i = 0; i < blendShapeParams.blendShapeParamCount && i < blendShapeCount; i++)
143 {
144 float value = blendShapeParams.blendShapeParams[i];
145 mesh.SetBlendShapeWeight((int)i, value * BLEND_MULTIPLIER);
146 }
147 }
148
149 previouslyActive = isActive;
150 }
151
152 private void InitializeSingleComponentMaterial(IntPtr renderPart, int lodIndex)
153 {
154 ovrAvatarPBSMaterialState materialState =
155 CAPI.ovrAvatarSkinnedMeshRenderPBSV2_GetPBSMaterialState(renderPart);
156
157 int componentType = (int)OvrAvatarMaterialManager.GetComponentType(gameObject.name);
158
159 Texture2D diffuseTexture = OvrAvatarComponent.GetLoadedTexture(materialState.albedoTextureID);
160 Texture2D normalTexture = OvrAvatarComponent.GetLoadedTexture(materialState.normalTextureID);
161 Texture2D metallicTexture = OvrAvatarComponent.GetLoadedTexture(materialState.metallicnessTextureID);
162
163 if (diffuseTexture != null)
164 {
165 avatarMaterialManager.AddTextureIDToTextureManager(materialState.albedoTextureID, true);
166 }
167 else
168 {
169 diffuseTexture = OvrAvatarSDKManager.Instance.GetTextureCopyManager().FallbackTextureSets[lodIndex].DiffuseRoughness;
170 }
171 diffuseTexture.anisoLevel = 4;
172 if (normalTexture != null)
173 {
174 avatarMaterialManager.AddTextureIDToTextureManager(materialState.normalTextureID, true);
175 }
176 else
177 {
178 normalTexture = OvrAvatarSDKManager.Instance.GetTextureCopyManager().FallbackTextureSets[lodIndex].Normal;
179 }
180 normalTexture.anisoLevel = 4;
181 if (metallicTexture != null)
182 {
183 avatarMaterialManager.AddTextureIDToTextureManager(materialState.metallicnessTextureID, true);
184 }
185 else
186 {
187 metallicTexture = OvrAvatarSDKManager.Instance.GetTextureCopyManager().FallbackTextureSets[lodIndex].DiffuseRoughness;
188 }
189 metallicTexture.anisoLevel = 16;
190
191 mesh.materials[0].SetTexture(OvrAvatarMaterialManager.AVATAR_SHADER_MAINTEX, diffuseTexture);
192 mesh.materials[0].SetTexture(OvrAvatarMaterialManager.AVATAR_SHADER_NORMALMAP, normalTexture);
193 mesh.materials[0].SetTexture(OvrAvatarMaterialManager.AVATAR_SHADER_ROUGHNESSMAP, metallicTexture);
194
195 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_COLOR, materialState.albedoMultiplier);
196
197 mesh.materials[0].SetFloat(OvrAvatarMaterialManager.AVATAR_SHADER_DIFFUSEINTENSITY,
198 OvrAvatarMaterialManager.DiffuseIntensities[componentType]);
199 mesh.materials[0].SetFloat(OvrAvatarMaterialManager.AVATAR_SHADER_RIMINTENSITY,
200 OvrAvatarMaterialManager.RimIntensities[componentType]);
201 mesh.materials[0].SetFloat(OvrAvatarMaterialManager.AVATAR_SHADER_REFLECTIONINTENSITY,
202 OvrAvatarMaterialManager.ReflectionIntensities[componentType]);
203
204 mesh.GetClosestReflectionProbes(avatarMaterialManager.ReflectionProbes);
205 if (avatarMaterialManager.ReflectionProbes != null &&
206 avatarMaterialManager.ReflectionProbes.Count > 0)
207 {
208 mesh.materials[0].SetTexture(OvrAvatarMaterialManager.AVATAR_SHADER_CUBEMAP,
209 avatarMaterialManager.ReflectionProbes[0].probe.texture);
210 }
211
212 if (EnableExpressive)
213 {
214 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_IRIS_COLOR,
215 ExpressiveParameters.irisColor);
216 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_LIP_COLOR,
217 ExpressiveParameters.lipColor);
218 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_BROW_COLOR,
219 ExpressiveParameters.browColor);
220 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_LASH_COLOR,
221 ExpressiveParameters.lashColor);
222 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_SCLERA_COLOR,
223 ExpressiveParameters.scleraColor);
224 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_GUM_COLOR,
225 ExpressiveParameters.gumColor);
226 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_TEETH_COLOR,
227 ExpressiveParameters.teethColor);
228 mesh.materials[0].SetFloat(OvrAvatarMaterialManager.AVATAR_SHADER_LIP_SMOOTHNESS,
229 ExpressiveParameters.lipSmoothness);
230 }
231 }
232
233 private void InitializeCombinedMaterial(IntPtr renderPart, int lodIndex)
234 {
235 ovrAvatarPBSMaterialState[] materialStates = CAPI.ovrAvatar_GetBodyPBSMaterialStates(renderPart);
236
237 if (materialStates.Length == (int)ovrAvatarBodyPartType.Count)
238 {
239 avatarMaterialManager.CreateTextureArrays();
240 var localProperties = avatarMaterialManager.LocalAvatarConfig.ComponentMaterialProperties;
241
242 AvatarLogger.Log("InitializeCombinedMaterial - Loading Material States");
243
244 for (int i = 0; i < materialStates.Length; i++)
245 {
246 localProperties[i].TypeIndex = (ovrAvatarBodyPartType)i;
247 localProperties[i].Color = materialStates[i].albedoMultiplier;
248 localProperties[i].DiffuseIntensity = OvrAvatarMaterialManager.DiffuseIntensities[i];
249 localProperties[i].RimIntensity = OvrAvatarMaterialManager.RimIntensities[i];
250 localProperties[i].ReflectionIntensity = OvrAvatarMaterialManager.ReflectionIntensities[i];
251
252 var diffuse = OvrAvatarComponent.GetLoadedTexture(materialStates[i].albedoTextureID);
253 var normal = OvrAvatarComponent.GetLoadedTexture(materialStates[i].normalTextureID);
254 var roughness = OvrAvatarComponent.GetLoadedTexture(materialStates[i].metallicnessTextureID);
255
256 if (diffuse != null)
257 {
258 localProperties[i].Textures[(int)OvrAvatarMaterialManager.TextureType.DiffuseTextures] = diffuse;
259 avatarMaterialManager.AddTextureIDToTextureManager(materialStates[i].albedoTextureID, false);
260 }
261 else
262 {
263 localProperties[i].Textures[(int)OvrAvatarMaterialManager.TextureType.DiffuseTextures] =
264 OvrAvatarSDKManager.Instance.GetTextureCopyManager().FallbackTextureSets[lodIndex].DiffuseRoughness;
265 }
266 localProperties[i].Textures[(int)OvrAvatarMaterialManager.TextureType.DiffuseTextures].anisoLevel = 4;
267
268 if (normal != null)
269 {
270 localProperties[i].Textures[(int)OvrAvatarMaterialManager.TextureType.NormalMaps] = normal;
271 avatarMaterialManager.AddTextureIDToTextureManager(materialStates[i].normalTextureID, false);
272 }
273 else
274 {
275 localProperties[i].Textures[(int)OvrAvatarMaterialManager.TextureType.NormalMaps] =
276 OvrAvatarSDKManager.Instance.GetTextureCopyManager().FallbackTextureSets[lodIndex].Normal;
277 }
278 localProperties[i].Textures[(int)OvrAvatarMaterialManager.TextureType.NormalMaps].anisoLevel = 4;
279
280 if (roughness != null)
281 {
282 localProperties[i].Textures[(int)OvrAvatarMaterialManager.TextureType.RoughnessMaps] = roughness;
283 avatarMaterialManager.AddTextureIDToTextureManager(materialStates[i].metallicnessTextureID, false);
284 }
285 else
286 {
287 localProperties[i].Textures[(int)OvrAvatarMaterialManager.TextureType.RoughnessMaps] =
288 OvrAvatarSDKManager.Instance.GetTextureCopyManager().FallbackTextureSets[lodIndex].DiffuseRoughness;
289 }
290 localProperties[i].Textures[(int)OvrAvatarMaterialManager.TextureType.RoughnessMaps].anisoLevel = 16;
291
292 AvatarLogger.Log(localProperties[i].TypeIndex.ToString());
293 AvatarLogger.Log(AvatarLogger.Tab + "Diffuse: " + materialStates[i].albedoTextureID);
294 AvatarLogger.Log(AvatarLogger.Tab + "Normal: " + materialStates[i].normalTextureID);
295 AvatarLogger.Log(AvatarLogger.Tab + "Metallic: " + materialStates[i].metallicnessTextureID);
296 }
297
298 if (EnableExpressive)
299 {
300 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_IRIS_COLOR,
301 ExpressiveParameters.irisColor);
302 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_LIP_COLOR,
303 ExpressiveParameters.lipColor);
304 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_BROW_COLOR,
305 ExpressiveParameters.browColor);
306 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_LASH_COLOR,
307 ExpressiveParameters.lashColor);
308 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_SCLERA_COLOR,
309 ExpressiveParameters.scleraColor);
310 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_GUM_COLOR,
311 ExpressiveParameters.gumColor);
312 mesh.materials[0].SetVector(OvrAvatarMaterialManager.AVATAR_SHADER_TEETH_COLOR,
313 ExpressiveParameters.teethColor);
314 mesh.materials[0].SetFloat(OvrAvatarMaterialManager.AVATAR_SHADER_LIP_SMOOTHNESS,
315 ExpressiveParameters.lipSmoothness);
316 }
317
318 avatarMaterialManager.ValidateTextures();
319 }
320 }
321
322 private void SetMaterialTransparent(Material mat)
323 {
324 // Initialize shader to use transparent render queue with alpha blending
325 mat.SetOverrideTag("Queue", "Transparent");
326 mat.SetOverrideTag("RenderType", "Transparent");
327 mat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
328 mat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
329 mat.EnableKeyword("_ALPHATEST_ON");
330 mat.EnableKeyword("_ALPHABLEND_ON");
331 mat.EnableKeyword("_ALPHAPREMULTIPLY_ON");
332 mat.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
333 }
334
335 private void SetMaterialOpaque(Material mat)
336 {
337 // Initialize shader to use geometry render queue with no blending
338 mat.SetOverrideTag("Queue", "Geometry");
339 mat.SetOverrideTag("RenderType", "Opaque");
340 mat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
341 mat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
342 mat.DisableKeyword("_ALPHATEST_ON");
343 mat.DisableKeyword("_ALPHABLEND_ON");
344 mat.DisableKeyword("_ALPHAPREMULTIPLY_ON");
345 mat.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Geometry;
346 }
347}