public Texture DrawRenderPreview(Rect size, Mesh mesh, Material material)
{
if (previewRenderer == null)
{
previewRenderer = new PreviewRenderUtility();
previewRenderer.cameraFieldOfView = 15.0f;
previewRenderer.ambientColor = (Color.white * 0.6f);
previewRenderer.camera.transform.position = (Vector3.forward * 5.0f) + (Vector3.up * 5.0f) + (Vector3.right * 5.0f);
previewRenderer.camera.transform.LookAt(Vector3.zero, Vector3.up);
previewRenderer.camera.nearClipPlane = 0.01f;
previewRenderer.camera.farClipPlane = 50.0f;
previewRenderer.lights[0].enabled = true;
previewRenderer.lights[0].type = LightType.Directional;
previewRenderer.lights[0].color = Color.white;
previewRenderer.lights[0].intensity = 1.5f;
previewRenderer.lights[0].transform.rotation = Quaternion.Euler(30f, 0f, 0f);
previewRenderer.lights[1].enabled = true;
previewRenderer.lights[1].intensity = 0.5f;
}
// Create a duplicate material with NO_CURVE enabled for rendering the preview
Material previewMaterial = Instantiate(material);
previewMaterial.EnableKeyword("NO_CURVE");
previewRenderer.BeginStaticPreview(size);
previewRenderer.DrawMesh(mesh, Matrix4x4.identity, previewMaterial, 0);
previewRenderer.Render();
return(previewRenderer.EndStaticPreview());
}
public override Texture2D RenderStaticPreview(string assetPath, Object[] subAssets, int width, int height)
{
this.Init();
m_PreviewUtility.BeginStaticPreview(new Rect(0, 0, width, height));
DoRenderPreview();
return(m_PreviewUtility.EndStaticPreview());
}
public override Texture2D RenderStaticPreview(string assetPath, Object[] subAssets, int width, int height)
{
// If we attempted to render hdr cubemap previews in batchmode,
// we will error out with Texture creation failed. 'R16G16B16A16_SFloat' is not supported for Render usage on this platform.
// This would then trigger us to eject out of this function, without restoring the render pipeline asset.
// This causes GraphicsSettings to lose the reference to the HDRenderPipelineAsset, which causes all sorts of graphics build issues.
if (Application.isBatchMode)
{
return(null);
}
m_CameraDistance = 1.25f;
m_CameraPhi = Mathf.PI * 0.33f;
m_CameraTheta = Mathf.PI;
InitPreview();
UpdateCamera();
// Force loading the needed preview shader
var previewShader = EditorGUIUtility.LoadRequired("Previews/PreviewCubemap.shader") as Shader;
var previewMaterial = new Material(previewShader)
{
hideFlags = HideFlags.HideAndDontSave
};
// We need to force it to go through legacy
bool assetUsedFromQuality = false;
var currentPipelineAsset = HDUtils.SwitchToBuiltinRenderPipeline(out assetUsedFromQuality);
previewMaterial.SetVector("_CameraWorldPosition", m_PreviewUtility.camera.transform.position);
previewMaterial.SetFloat("_Mip", 0.0f);
previewMaterial.SetFloat("_Alpha", 0.0f);
previewMaterial.SetFloat("_Intensity", 1.0f);
previewMaterial.mainTexture = (target as Texture);
m_PreviewUtility.ambientColor = Color.black;
m_PreviewUtility.BeginStaticPreview(new Rect(0, 0, width, height));
m_PreviewUtility.DrawMesh(sphereMesh, Matrix4x4.identity, previewMaterial, 0);
// TODO: For now the following line is D3D11 + Metal only as it cause out of memory on both DX12 and Vulkan API.
// We will need to invest time to understand what is happening
// For now priority is to enable Yamato platform automation
// This mean that cubemap icon will render incorrectly on anything but D3D11
if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D11 || SystemInfo.graphicsDeviceType == GraphicsDeviceType.Metal)
{
m_PreviewUtility.camera.Render();
}
var outTexture = m_PreviewUtility.EndStaticPreview();
// Reset back to whatever asset was used before the rendering
HDUtils.RestoreRenderPipelineAsset(assetUsedFromQuality, currentPipelineAsset);
// Dummy empty render call to reset the pipeline in RenderPipelineManager
m_PreviewUtility.camera.Render();
return(outTexture);
}
public override Texture2D RenderStaticPreview(string assetPath, Object[] subAssets, int width, int height)
{
m_CameraDistance = 1.25f;
m_CameraPhi = Mathf.PI * 0.33f;
m_CameraTheta = Mathf.PI;
InitPreview();
UpdateCamera();
// Force loading the needed preview shader
var previewShader = EditorGUIUtility.LoadRequired("Previews/PreviewCubemap.shader") as Shader;
var previewMaterial = new Material(previewShader)
{
hideFlags = HideFlags.HideAndDontSave
};
// We need to force it to go through legacy
bool assetUsedFromQuality = false;
var currentPipelineAsset = HDUtils.SwitchToBuiltinRenderPipeline(out assetUsedFromQuality);
previewMaterial.SetVector("_CameraWorldPosition", m_PreviewUtility.camera.transform.position);
previewMaterial.SetFloat("_Mip", 0.0f);
previewMaterial.SetFloat("_Alpha", 0.0f);
previewMaterial.SetFloat("_Intensity", 1.0f);
previewMaterial.mainTexture = (target as Texture);
m_PreviewUtility.ambientColor = Color.black;
m_PreviewUtility.BeginStaticPreview(new Rect(0, 0, width, height));
m_PreviewUtility.DrawMesh(sphereMesh, Matrix4x4.identity, previewMaterial, 0);
// TODO: For now we comment this line as it cause out of memory on both DX12 and Vulkan API.
// We will need to invest time to understand what is happening
// For now priority is to enable Yamato platform automation
// This mean that cubemap icon will render incorrectly
//m_PreviewUtility.camera.Render();
var outTexture = m_PreviewUtility.EndStaticPreview();
// Reset back to whatever asset was used before the rendering
HDUtils.RestoreRenderPipelineAsset(assetUsedFromQuality, currentPipelineAsset);
// Dummy empty render call to reset the pipeline in RenderPipelineManager
m_PreviewUtility.camera.Render();
return(outTexture);
}
public Texture2D GetStaticPreview(int width, int height)
{
var c = this.PreviewUtilityCamera;
if (c == null)
{
return(null);
}
RefreshOnNextUpdate();
AdjustCameraGoals();
c.orthographicSize = cameraOrthoGoal / 2;
c.transform.position = cameraPositionGoal;
previewRenderUtility.BeginStaticPreview(new Rect(0, 0, width, height));
DoRenderPreview(false);
var tex = previewRenderUtility.EndStaticPreview();
return(tex);
}
static Texture GetPreviewTexture(PreviewRenderUtility previewUtility, Vector2 previewDir, Rect region, Material material)
{
if (styles == null)
{
styles = new Styles();
}
var background = styles.background;
var mesh = GetPreviewSphere();
var camera = previewUtility.camera;
var bounds = mesh.bounds;
var halfSize = bounds.extents.magnitude;
var distance = 2.5f * halfSize;
camera.transform.position = -Vector3.forward * distance;
camera.transform.rotation = Quaternion.identity;
camera.nearClipPlane = distance - halfSize * 1.1f;
camera.farClipPlane = distance + halfSize * 1.1f;
camera.fieldOfView = 30.0f;
camera.orthographicSize = 1.0f;
camera.clearFlags = CameraClearFlags.Nothing;
previewUtility.lights[0].intensity = 1.0f;
previewUtility.lights[0].transform.rotation = Quaternion.Euler(40f, 40f, 0);
previewUtility.lights[1].intensity = 1.0f;
previewUtility.BeginStaticPreview(region);
var fog = RenderSettings.fog;
Unsupported.SetRenderSettingsUseFogNoDirty(false);
camera.Render();
Unsupported.SetRenderSettingsUseFogNoDirty(fog);
var rot = Quaternion.Euler(previewDir.y, 0, 0) * Quaternion.Euler(0, previewDir.x, 0);
var pos = rot * (-bounds.center);
previewUtility.DrawMesh(mesh, pos, rot, material, 0);
previewUtility.Render(false, false);
return(previewUtility.EndStaticPreview());
}
Texture2D GetPreviewTexture(GameObject go, int width, int height)
{
if (renderUtility == null)
{
InitializePreviewRenderUtility();
}
var rect = new Rect(0, 0, width, height);
renderUtility.BeginStaticPreview(rect);
MeshFilter[] meshFilters = go.GetComponentsInChildren <MeshFilter>();
MeshRenderer[] meshRenderers = go.GetComponentsInChildren <MeshRenderer>();
for (int i = 0; i < meshRenderers.Length; i++)
{
bound.Encapsulate(meshRenderers[i].bounds);
renderUtility.DrawMesh(meshFilters[i].sharedMesh, Matrix4x4.identity, meshRenderers[i].sharedMaterials[0], 0);
}
float magnitude = bound.extents.magnitude;
float num = magnitude * rangeFactor;
var quaternion = Quaternion.Euler(-rotation.y, -rotation.x, 0f);
var position = bound.center - quaternion * (Vector3.forward * num);
renderUtility.camera.transform.position = position;
renderUtility.camera.transform.rotation = quaternion;
renderUtility.camera.nearClipPlane = num - magnitude * 1.1f;
renderUtility.camera.farClipPlane = num + magnitude * 1.1f;
//renderUtility.lights[0].transform.rotation = Quaternion.Euler(40f, 40f, 0f);
renderUtility.lights[0].transform.rotation = renderUtility.camera.transform.rotation;
//renderUtility.lights[1].intensity = 2.0f;
renderUtility.Render(true);
Texture2D result = renderUtility.EndStaticPreview();
renderUtility.Cleanup();
return(result);
}
public static Texture2D CreatePreviewTexture2D(PreviewRenderUtility previewRender, GradationMaterial material, Vector2 textureSize, Vector2 drawSize, Color lightColor, Color darkColor)
{
previewRender.m_Camera.orthographic = true;
previewRender.m_Camera.orthographicSize = 1.0f;
previewRender.m_Camera.nearClipPlane = 0.0f;
previewRender.m_Camera.farClipPlane = 2.0f;
var previewMaterial = new Material(Shader.Find("Sprites/Default"));
Rect r = new Rect(Vector2.zero, textureSize);
previewRender.BeginStaticPreview(r);
var matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.identity, new Vector3(previewRender.m_Camera.aspect, 1.0f, 1.0f));
var mesh = CreateMesh(material, drawSize, lightColor, darkColor);
previewRender.DrawMesh(mesh, matrix, previewMaterial, 0);
previewRender.m_Camera.Render();
var result = previewRender.EndStaticPreview();
return(result);
}
/// <summary>
/// RenderStaticPreview is poorly documented. Nonetheless this produces a nice
/// square thumbnail preview of the decal.
/// </summary>
public override Texture2D RenderStaticPreview(string assetPath, UnityEngine.Object[] subAssets,
int width, int height)
{
DecalAsset decalAsset = (DecalAsset)target;
if (decalAsset == null || !decalAsset.HasDiffuseAlphaTexture)
{
return(null);
}
PreviewRenderUtility utility = new PreviewRenderUtility();
utility.BeginStaticPreview(new Rect(0, 0, width, height));
// Normally would set up a little scene within PreviewRenderUtility, then render that manually
// useful links:
// https://github.com/raphael-ernaelsten/Texture3DPreview-for-Unity/blob/master/Assets/Texture3DPreview/Editor/Extensions/Texture3DExtensions.cs
// http://answers.unity.com/answers/1650714/view.html
// for example:
// utility.camera.transform.position = Vector2.zero;
// utility.camera.transform.position = utility.camera.transform.forward * -distance;
// utility.camera.backgroundColor = Color.red;
// utility.DrawMesh(someMesh, Matrix4x4.identity, someMaterial, 0);
// utility.camera.Render();
// But in this case we just blit to camera's target
thumbnailMaterial.SetVector(boundsID, decalAsset.BoundsAsVector4);
thumbnailMaterial.SetColor(colourForAlphaID, previewBackColour);
Graphics.Blit(decalAsset.diffuseAlpha, utility.camera.targetTexture, thumbnailMaterial, 0);
// EndStaticPreview() gives us the texture generated by utility.camera
// (for some reason returning a texture made this way works, returning a texture I make doesn't)
var result = utility.EndStaticPreview();
utility.Cleanup();
return(result);
}
public override void OnInspectorGUI()
{
Init();
if (!isVisible)
{
return;
}
SetDefaultGUIWidths();
Material material = target as Material;
int layerCount = MaxLayerCount;
while (layerCount > 0 && !material.IsKeywordEnabled(GetPropertyName(LayerKeywordPrefix, layerCount)))
{
--layerCount;
}
if (layerCount == 0)
{
layerCount = 1;
material.EnableKeyword("LAYERS_" + layerCount);
}
EditorGUILayout.LabelField("Global material properties");
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
TextureField("AlphaMask", material, AlphaMaskUniform);
AvatarMaterialEditorGUILayout.ColorField("DarkMultiplier", material, DarkMultUniform);
AvatarMaterialEditorGUILayout.ColorField("BaseColor", material, BaseColorUniform);
bool normalMapEnabled = AvatarMaterialEditorGUILayout.KeywordToggle("Normal map enabled", material, NormalMapPrefix);
if (normalMapEnabled)
{
TextureField("Normal map", material, NormalMapUniform);
}
bool parallaxEnabled = AvatarMaterialEditorGUILayout.KeywordToggle("Parallax enabled", material, ParallaxPrefix);
if (parallaxEnabled)
{
TextureField("Parallax map", material, ParallaxMapUniform);
}
bool roughnessEnabled = AvatarMaterialEditorGUILayout.KeywordToggle("Roughness enabled", material, RoughnessPrefix);
if (roughnessEnabled)
{
TextureField("Roughness map", material, RoughnessMapUniform);
}
MaskField("Base mask type", material, BaseMaskTypeUniform, BaseMaskParametersUniform, BaseMaskAxisUniform, baseMaskAxisCache, baseMaskParametersCache, normalMapEnabled);
EditorGUILayout.EndVertical();
int layerVisibilityMask = 0;
layerVisibilityMasks.TryGetValue(material, out layerVisibilityMask);
EditorGUILayout.LabelField("Layers");
EditorGUI.indentLevel++;
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
int?removeLayerIndex = null;
int?swapSource = null;
int?swapTarget = null;
for (int i = 0; i < layerCount; ++i)
{
// Draw the preview material
if (previewMaterials[i] == null)
{
previewMaterials[i] = CreatePreviewMaterial(material, i);
}
const int previewSize = 64;
const int buttonSize = 20;
Rect layerHeaderRect = GUILayoutUtility.GetRect(previewSize, previewSize, GUILayout.ExpandWidth(true));
// Draw the preview texture
previewUtility.m_Camera.transform.position = Vector3.forward * 5.0f;
previewUtility.m_Camera.transform.rotation = Quaternion.identity;
previewUtility.m_Camera.transform.LookAt(Vector3.zero);
previewUtility.BeginStaticPreview(new Rect(0, 0, previewSize, previewSize));
previewUtility.DrawMesh(previewMesh, Vector3.zero, Quaternion.identity, previewMaterials[i], 0);
previewUtility.m_Camera.Render();
Texture preview = previewUtility.EndStaticPreview();
GUI.Label(new Rect(layerHeaderRect.xMax - previewSize - buttonSize, layerHeaderRect.y, previewSize, previewSize), preview);
float yButton = layerHeaderRect.y;
EditorGUI.BeginDisabledGroup(layerCount <= 1);
if (GUI.Button(new Rect(layerHeaderRect.xMax - buttonSize, yButton, buttonSize, buttonSize), new GUIContent("X", "Remove layer")))
{
removeLayerIndex = i;
}
yButton += buttonSize + 4;
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(i == 0);
if (GUI.Button(new Rect(layerHeaderRect.xMax - buttonSize, yButton, buttonSize, buttonSize), new GUIContent("^", "Move layer up")))
{
swapSource = i;
swapTarget = i - 1;
}
yButton += buttonSize;
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(i == layerCount - 1);
if (GUI.Button(new Rect(layerHeaderRect.xMax - buttonSize, yButton, buttonSize, buttonSize), new GUIContent("v", "Move layer down")))
{
swapSource = i;
swapTarget = i + 1;
}
yButton += buttonSize;
EditorGUI.EndDisabledGroup();
// Create a toggleable group for the layer
int layerMaskBit = 1 << i;
bool layerVisible = (layerVisibilityMask & layerMaskBit) != 0;
layerVisible = EditorGUI.Foldout(layerHeaderRect, layerVisible, string.Format("Layer {0}", i + 1));
if (layerVisible)
{
layerVisibilityMask |= layerMaskBit;
}
else
{
layerVisibilityMask &= ~layerMaskBit;
}
if (layerVisible)
{
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
EditorGUI.BeginChangeCheck();
{
// Handle the blend mode
AvatarMaterialEditorGUILayout.IntField("Blend mode", material, GetPropertyName(LayerBlendModePrefix, i), layerBlendModeLabels);
// Handle the sample mode selector
string layerSampleParametersProperty = GetPropertyName(LayerSampleParametersPrefix, i);
EditorGUI.BeginChangeCheck();
LayerSampleMode sampleMode = (LayerSampleMode)AvatarMaterialEditorGUILayout.IntField("Sample mode", material, GetPropertyName(LayerSampleModePrefix, i), layerSampleModeLabels);
if (EditorGUI.EndChangeCheck())
{
material.SetVector(layerSampleParametersProperty, sampleParametersCache[i, (int)sampleMode]);
}
// Show the mode-specific sample controls
EditorGUI.BeginChangeCheck();
AvatarMaterialEditorGUILayout.ColorField("Surface color", material, GetPropertyName(LayerColorPrefix, i));
switch (sampleMode)
{
case LayerSampleMode.Texture:
TextureField("Surface texture", material, GetPropertyName(LayerSurfacePrefix, i));
AvatarMaterialEditorGUILayout.Vector2Field("Panning speed", material, layerSampleParametersProperty);
break;
case LayerSampleMode.TextureSingleChannel:
TextureField("Surface texture", material, GetPropertyName(LayerSurfacePrefix, i));
AvatarMaterialEditorGUILayout.ChannelMaskField("Channel", material, layerSampleParametersProperty);
break;
case LayerSampleMode.Parallax:
TextureField("Surface texture", material, GetPropertyName(LayerSurfacePrefix, i));
AvatarMaterialEditorGUILayout.VectorComponentField("Parallax min height", material, layerSampleParametersProperty, 0);
AvatarMaterialEditorGUILayout.VectorComponentField("Parallax max height", material, layerSampleParametersProperty, 1);
break;
case LayerSampleMode.RSRM:
TextureField("RSRM texture", material, GetPropertyName(LayerSurfacePrefix, i));
if (roughnessEnabled)
{
AvatarMaterialEditorGUILayout.VectorComponentField("Roughness min", material, layerSampleParametersProperty, 0);
AvatarMaterialEditorGUILayout.VectorComponentField("Roughness max", material, layerSampleParametersProperty, 1);
}
else
{
AvatarMaterialEditorGUILayout.VectorComponentField("Roughness", material, layerSampleParametersProperty, 0);
}
if (normalMapEnabled)
{
AvatarMaterialEditorGUILayout.VectorComponentField("Normal map strength", material, layerSampleParametersProperty, 2);
}
break;
}
if (EditorGUI.EndChangeCheck())
{
sampleParametersCache[i, (int)sampleMode] = material.GetVector(layerSampleParametersProperty);
}
// Handle the mask mode selector
string maskParametersName = GetPropertyName(LayerMaskParametersPrefix, i);
string maskAxisName = GetPropertyName(LayerMaskAxisPrefix, i);
MaskField("Mask Type", material, GetPropertyName(LayerMaskTypePrefix, i), maskParametersName, maskAxisName, maskAxisCache[i], maskParametersCache[i], normalMapEnabled);
}
if (EditorGUI.EndChangeCheck())
{
previewMaterials[i] = null;
}
EditorGUILayout.EndVertical();
}
}
layerVisibilityMasks[material] = layerVisibilityMask;
if (layerCount < MaxLayerCount)
{
if (GUILayout.Button("Add layer"))
{
Undo.RecordObject(material, "Add layer");
SetLayerCount(material, layerCount + 1);
removeLayerIndex = null;
}
}
if (removeLayerIndex.HasValue)
{
Undo.RecordObject(material, "Remove layer");
for (int i = removeLayerIndex.Value; i < layerCount - 1; ++i)
{
CopyAttributes(material, i + 1, i);
}
SetLayerCount(material, layerCount - 1);
}
if (swapSource.HasValue && swapTarget.HasValue)
{
Undo.RecordObject(material, string.Format("Swap layers {1} and {0}", swapSource.Value, swapTarget.Value));
SwapAttributes(material, swapSource.Value, swapTarget.Value);
}
EditorGUI.indentLevel--;
EditorGUILayout.EndVertical();
EditorUtility.SetDirty(target);
}