public override void OnPreviewGUI(Rect r, GUIStyle background)
{
if (m_ReflectiveMaterial != null)
{
m_ReflectiveMaterial.SetFloat("_Exposure", previewExposure);
m_ReflectiveMaterial.SetFloat("_MipLevel", mipLevelPreview);
}
if (m_PreviewUtility == null)
{
InitPreview();
}
// We init material just before using it as the inspector might have been enabled/awaked before during import.
InitMaterialIfNeeded();
UpdateCamera();
m_ReflectiveMaterial.SetTexture("_Cubemap", target as Texture);
m_PreviewUtility.BeginPreview(r, GUIStyle.none);
m_PreviewUtility.DrawMesh(sphereMesh, Matrix4x4.identity, m_ReflectiveMaterial, 0);
m_PreviewUtility.camera.Render();
m_PreviewUtility.EndAndDrawPreview(r);
if (Event.current.type != EventType.Repaint)
{
if (HandleMouse(r))
{
Repaint();
}
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
if (Event.current.type == EventType.Repaint)
{
previewRenderUtility.BeginPreview(r, background);
for (int i = 0; i < targetMeshFilters?.Length && i < targetMeshRenderers?.Length; i++)
{
previewRenderUtility.DrawMesh(targetMeshFilters[i].sharedMesh, targetMeshFilters[i].transform.position, targetMeshFilters[i].transform.rotation, targetMeshRenderers[i].sharedMaterial, 0);
}
previewRenderUtility.camera.Render();
Texture render = previewRenderUtility.EndPreview();
//Draw the model render
GUI.DrawTexture(r, render, ScaleMode.ScaleToFit);
//Draw the icon in the lower right corner
if (targetIconTexture)
{
float len = r.height / 2;
r = new Rect(r.xMax - len, r.yMax - len, len, len);
GUI.DrawTexture(r, targetIconTexture, ScaleMode.ScaleToFit);
}
}
}
private void DrawRenderPreview(Rect previewRect)
{
if (selectedMaterial)
{
previewMaterial.mainTexture = selectedMaterial.mainTexture;
if (selectedMaterial.HasProperty("_Color"))
{
previewMaterial.color = selectedMaterial.GetColor("_Color");
}
}
Quaternion rotation = Quaternion.Euler(previewRotationX, previewRotationY, 0);
Matrix4x4 matrix = Matrix4x4.identity;
matrix.SetTRS(Vector3.zero, rotation, Vector3.one);
Vector3 position = -matrix.MultiplyPoint(previewMesh.bounds.center);
float dist = previewMesh.bounds.extents.magnitude * 2;
preview.camera.transform.position = new Vector3(0, 0, -dist);
preview.camera.transform.LookAt(Vector3.zero);
preview.camera.clearFlags = CameraClearFlags.Color;
preview.camera.backgroundColor = Color.gray;
preview.camera.fieldOfView = 60;
preview.camera.nearClipPlane = .3f;
preview.camera.farClipPlane = 1000f;
preview.BeginPreview(previewRect, GUIStyle.none);
preview.DrawMesh(previewMesh, position, rotation, previewMaterial, 0);
preview.Render();
preview.EndAndDrawPreview(previewRect);
}
public void OnPreviewGUI_s(Rect r, GUIStyle background)
{
_drag = Drag2D(_drag, r);
if (Event.current.type == EventType.Repaint)
{
if (TargetMeshRenderer == null)
{
EditorGUI.DropShadowLabel(r, "Mesh Renderer Required");
}
else
{
if (_previewRenderUtility == null)
{
_previewRenderUtility = new PreviewRenderUtility();
}
_previewRenderUtility.BeginPreview(r, null);
_previewRenderUtility.camera.Render();
Texture resultRender = _previewRenderUtility.EndPreview();
GUI.DrawTexture(r, resultRender, ScaleMode.StretchToFill, false);
}
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
InitPreview();
if (m_PreviewUtility == null)
{
return;
}
Rect rect2 = r;
int controlID = GUIUtility.GetControlID(m_PreviewHint, FocusType.Passive, rect2);
Event current = Event.current;
EventType typeForControl = current.GetTypeForControl(controlID);
if (typeForControl == EventType.Repaint)
{
m_PreviewUtility.BeginPreview(rect2, background);
DoRenderPreview();
m_PreviewUtility.EndAndDrawPreview(rect2);
}
int controlID2 = GUIUtility.GetControlID(m_PreviewSceneHint, FocusType.Passive);
typeForControl = current.GetTypeForControl(controlID2);
HandleViewTool(current, typeForControl, controlID2, rect2);
DoAvatarPreviewFrame(current, typeForControl, rect2);
EditorGUI.DropShadowLabel(new Rect(r.x, r.yMax - 20f, r.width, 20f),
(r.width > 140f ? "Playback Time:" : string.Empty) + String.Format("{0:F}", m_RunningTime));
if (current.type == EventType.Repaint)
{
EditorGUIUtility.AddCursorRect(rect2, currentCursor);
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
//_drag = Drag2D(_drag, r);
if (Event.current.type == EventType.Repaint)
{
/*if(_targetMeshRenderer == null)
* {
* EditorGUI.DropShadowLabel(r, "Mesh Renderer Required");
* }
* else*/
{
m_PreviewRenderUtility.camera.orthographicSize = 12.0f; //scale * 2f;
m_PreviewRenderUtility.camera.nearClipPlane = 0f;
m_PreviewRenderUtility.camera.farClipPlane = 25f;
m_PreviewRenderUtility.BeginPreview(r, background);
ActorAsset asset = target as ActorAsset;
if (asset != null && asset.Actor == null)
{
asset.Load();
}
m_PreviewRenderUtility.camera.Render();
Texture resultRender = m_PreviewRenderUtility.EndPreview();
GUI.DrawTexture(r, resultRender, ScaleMode.StretchToFill, false);
}
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
_drag = Drag2D(_drag, r);
if (Event.current.type == EventType.Repaint)
{
if (_targetMeshRenderer == null)
{
EditorGUI.DropShadowLabel(r, "Mesh Renderer Required");
}
else
{
_previewRenderUtility.BeginPreview(r, background);
_previewRenderUtility.DrawMesh(_targetMeshFilter.sharedMesh, Matrix4x4.identity, _targetMeshRenderer.sharedMaterial, 0);
_previewRenderUtility.m_Camera.transform.position = Vector2.zero;
_previewRenderUtility.m_Camera.transform.rotation = Quaternion.Euler(new Vector3(-_drag.y, -_drag.x, 0));
_previewRenderUtility.m_Camera.transform.position = _previewRenderUtility.m_Camera.transform.forward * -6f;
_previewRenderUtility.m_Camera.Render();
Texture resultRender = _previewRenderUtility.EndPreview();
GUI.DrawTexture(r, resultRender, ScaleMode.ScaleToFit, true);
}
}
}
public PreviewInstanceScope(Rect guiRect, PreviewRenderUtility previewRenderUtility, GameObject paletteInstance, bool drawGizmos)
{
m_PreviewRenderUtility = previewRenderUtility;
m_PaletteInstance = paletteInstance;
m_DrawGizmos = drawGizmos;
m_OldFog = RenderSettings.fog;
m_PreviewRenderUtility.BeginPreview(guiRect, Styles.background);
Unsupported.SetRenderSettingsUseFogNoDirty(false);
if (m_DrawGizmos)
{
m_PaletteTransforms = m_PaletteInstance.GetComponentsInChildren <Transform>();
foreach (var transform in m_PaletteTransforms)
{
transform.gameObject.hideFlags = HideFlags.None;
}
// Case 1199516: Set Dirty on palette instance to force a refresh on gizmo drawing
EditorUtility.SetDirty(m_PaletteInstance);
Unsupported.SceneTrackerFlushDirty();
}
m_Renderers = m_PaletteInstance.GetComponentsInChildren <Renderer>();
foreach (var renderer in m_Renderers)
{
renderer.allowOcclusionWhenDynamic = false;
}
m_PreviewRenderUtility.AddManagedGO(m_PaletteInstance);
Handles.DrawCameraImpl(guiRect, m_PreviewRenderUtility.camera, DrawCameraMode.Textured, false, new DrawGridParameters(), true, false);
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
if (!SystemInfo.supportsCubemapArrayTextures || (m_Material != null && !m_Material.shader.isSupported))
{
if (Event.current.type == EventType.Repaint)
{
EditorGUI.DropShadowLabel(new Rect(r.x, r.y, r.width, 40), "Cubemap array preview is not supported");
}
return;
}
CubemapArray t = (CubemapArray)target;
m_Material.mainTexture = t;
m_PreviewUtility.BeginPreview(r, background);
const float previewDistance = 6.0f;
m_PreviewDir = PreviewGUI.Drag2D(m_PreviewDir, r);
m_PreviewUtility.camera.transform.position = -Vector3.forward * previewDistance;
m_PreviewUtility.camera.transform.rotation = Quaternion.identity;
Quaternion rot = Quaternion.Euler(m_PreviewDir.y, 0, 0) * Quaternion.Euler(0, m_PreviewDir.x, 0);
m_PreviewUtility.DrawMesh(m_Mesh, Vector3.zero, rot, m_Material, 0);
m_PreviewUtility.Render();
Texture renderedTexture = m_PreviewUtility.EndPreview();
GUI.DrawTexture(r, renderedTexture, ScaleMode.StretchToFill, false);
EditorGUI.DropShadowLabel(new Rect(r.x, r.y + 10, r.width, 30),
"Slice " + m_Slice + "\nMip " + m_Mip);
}
/// <summary>
/// Setup and draw to a mini scene with a RenderTexture output
/// </summary>
private Texture RenderPreview(Rect r)
{
m_PreviewUtility.BeginPreview(r, null);
m_PreviewUtility.camera.backgroundColor = Color.black;
m_PreviewUtility.camera.clearFlags = CameraClearFlags.Color;
if (m_target.mesh != null)
{
// Adjust the mesh position to fit to the viewport
// Reference: https://gist.github.com/radiatoryang/a2282d44ba71848e498bb2e03da98991
var bounds = m_target.mesh.bounds;
var magnitude = bounds.extents.magnitude;
var distance = 10f * magnitude;
m_PreviewUtility.camera.transform.position = new Vector3(0, 0, -distance);
m_PreviewUtility.camera.transform.rotation = Quaternion.identity;
m_PreviewUtility.camera.nearClipPlane = 0.1f;
m_PreviewUtility.camera.farClipPlane = distance + magnitude * 1.1f;
var rot = Quaternion.Euler(m_PreviewEuler);
var pos = rot * -bounds.center;
m_PreviewUtility.DrawMesh(m_target.mesh, pos, rot, m_target.material, 0);
}
// Render the camera view and generate the render texture
m_PreviewUtility.camera.Render();
return(m_PreviewUtility.EndPreview());
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
m_previewRenderUtility.BeginPreview(r, background);
var target = m_target.Head;
if (target != null)
{
#if UNITY_2017_1_OR_NEWER
SetPreviewCamera(
m_previewRenderUtility.camera,
target.position + new Vector3(0, 0.1f, 0),
target.forward
);
foreach (var x in m_items)
{
var mesh = x.Baked();
for (int i = 0; i < x.Materials.Length; ++i)
{
m_previewRenderUtility.DrawMesh(mesh, x.Transform.position, x.Transform.rotation,
x.Materials[i], i);
}
}
m_previewRenderUtility.Render();
#else
SetPreviewCamera(
m_previewRenderUtility.m_Camera,
target.position + new Vector3(0, 0.1f, 0),
target.forward
);
m_previewRenderUtility.m_Camera.Render();
#endif
}
m_previewRenderUtility.EndAndDrawPreview(r);
}
private void OnGUI()
{
if (m_PreviewRenderUtility == null)
{
m_PreviewRenderUtility = new PreviewRenderUtility();
m_PreviewRenderUtility.camera.farClipPlane = 500;
m_PreviewRenderUtility.camera.clearFlags = CameraClearFlags.SolidColor;
m_PreviewRenderUtility.camera.transform.position = new Vector3(0, 0, -10);
var go = GameObject.CreatePrimitive(PrimitiveType.Cube);
var meshFilter = go.GetComponentInChildren <MeshFilter>();
m_PreviewMesh = meshFilter.sharedMesh;
m_PreviewMaterial = go.GetComponent <MeshRenderer>().sharedMaterial;
DestroyImmediate(go);
}
var drawRect = new Rect(0, 0, 500, 500);
m_PreviewRenderUtility.BeginPreview(drawRect, GUIStyle.none);
m_PreviewRenderUtility.DrawMesh(m_PreviewMesh, Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(30, 45, 0), Vector3.one), m_PreviewMaterial, 0);
m_PreviewRenderUtility.camera.Render();
var texture = m_PreviewRenderUtility.EndPreview();
GUI.Box(drawRect, texture);
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
ReceiveInput(r);
if (Event.current.type != EventType.Repaint)
{
return;
}
previewRenderUtility.BeginPreview(r, background);
var info = DrawShape();
if (!(info is null))
{
// move camera
var transform = previewRenderUtility.camera.transform;
transform.rotation = Quaternion.Euler(-viewPos.y, -viewPos.x, 0);
transform.position = transform.forward * -cameraDistance;
previewRenderUtility.camera.Render();
Handles.SetCamera(previewRenderUtility.camera);
DrawGizmos(info);
}
previewRenderUtility.EndAndDrawPreview(r);
}
/// <summary>
/// Callback called on the Implemented IESImporterEditor (currently on HDRP Only)
/// </summary>
/// <param name="background">Background of the Preview</param>
/// <param name="r">Rect of the Preview</param>
/// <param name="target">ScriptedImporter targeted</param>
/// <param name="setupRenderPipelinePreviewLightIntensity">Delegate provided by the Rendering Pipeline to setup the Light Intensity</param>
public void CommonOnPreviewGUI(Rect r, GUIStyle background, ScriptedImporter target,
SetupRenderPipelinePreviewLightIntensity setupRenderPipelinePreviewLightIntensity)
{
if (Event.current.type == EventType.Repaint)
{
Texture cookieTexture = null;
Texture previewTexture = null;
if (m_PrefabLightTypeProp.enumValueIndex == (int)IESLightType.Point)
{
foreach (var subAsset in AssetDatabase.LoadAllAssetRepresentationsAtPath(target.assetPath))
{
if (subAsset.name.EndsWith("-Cube-IES"))
{
cookieTexture = subAsset as Texture;
break;
}
}
}
else // LightType.Spot
{
foreach (var subAsset in AssetDatabase.LoadAllAssetRepresentationsAtPath(target.assetPath))
{
if (subAsset.name.EndsWith("-2D-IES"))
{
cookieTexture = subAsset as Texture;
break;
}
}
}
if (cookieTexture != null)
{
m_PreviewRenderUtility.lights[0].transform.localEulerAngles = new Vector3(90f, 0f, m_LightAimAxisRotationProp.floatValue);
setupRenderPipelinePreviewLightIntensity(m_PreviewRenderUtility.lights[0], m_UseIESMaximumIntensityProp, m_IESMaximumIntensityUnitProp, m_IESMaximumIntensityProp);
m_PreviewRenderUtility.lights[0].cookie = cookieTexture;
m_PreviewRenderUtility.lights[0].type = m_PrefabLightTypeProp.enumValueIndex == (int)IESLightType.Point ? LightType.Point : LightType.Spot;
m_PreviewRenderUtility.BeginPreview(r, background);
bool fog = RenderSettings.fog;
Unsupported.SetRenderSettingsUseFogNoDirty(false);
m_PreviewRenderUtility.camera.Render();
Unsupported.SetRenderSettingsUseFogNoDirty(fog);
previewTexture = m_PreviewRenderUtility.EndPreview();
}
if (previewTexture == null)
{
GUI.DrawTexture(r, Texture2D.blackTexture, ScaleMode.StretchToFill, false);
}
else
{
GUI.DrawTexture(r, previewTexture, ScaleMode.ScaleToFit, false);
}
}
}
public override void OnInteractivePreviewGUI(Rect r, GUIStyle background)
{
previewRenderUtility.BeginPreview(r, background);
var drag = Vector2.zero;
if (Event.current.type == EventType.MouseDrag)
{
drag = Event.current.delta;
}
previewRenderUtility.m_Camera.transform.position = centerPosition + Vector3.forward * -5;
RotatePreviewObject(drag);
previewObject.SetActive(true);
previewRenderUtility.m_Camera.Render();
previewObject.SetActive(false);
previewRenderUtility.EndAndDrawPreview(r);
if (drag != Vector2.zero)
{
Repaint();
}
}
public override void ShowPreviewGUI(Rect r, GUIStyle background)
{
switch (previewType)
{
case PreviewType.Cube:
meshFilter.mesh = meshes[0];
break;
case PreviewType.Sphere:
meshFilter.mesh = meshes[1];
break;
case PreviewType.Capsule:
meshFilter.mesh = meshes[2];
break;
}
if (Event.current.type == EventType.Repaint)
{
previewRenderUtility.BeginPreview(r, background);
previewRenderUtility.DrawMesh(meshFilter.sharedMesh, Matrix4x4.identity, meshRenderer.sharedMaterial, 0);
previewRenderUtility.m_Camera.transform.position = cameraPosition;
previewRenderUtility.m_Camera.Render();
Texture renderedPreview = previewRenderUtility.EndPreview();
GUI.DrawTexture(r, renderedPreview, ScaleMode.StretchToFill, false);
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
if (m_ReflectiveMaterial != null)
{
m_ReflectiveMaterial.SetFloat("_Exposure", previewExposure);
m_ReflectiveMaterial.SetFloat("_MipLevel", mipLevelPreview);
}
if (m_PreviewUtility == null)
{
InitPreview();
}
UpdateCamera();
m_PreviewUtility.BeginPreview(r, GUIStyle.none);
m_PreviewUtility.DrawMesh(sphereMesh, Matrix4x4.identity, m_ReflectiveMaterial, 0);
m_PreviewUtility.camera.Render();
m_PreviewUtility.EndAndDrawPreview(r);
if (Event.current.type != EventType.Repaint)
{
if (HandleMouse(r))
{
Repaint();
}
}
}
private void DrawScene(Rect _rect)
{
if (Event.current.type == EventType.Repaint)
{
m_renderer.BeginPreview(_rect, GUIStyle.none);
m_renderer.DrawMesh(m_context.PreviewMesh, m_meshTransform, m_meshRenderer.sharedMaterial, 0);
m_renderer.camera.Render();
NPipeGL.PostRenderBegin(m_renderer.camera.projectionMatrix, m_renderer.camera.worldToCameraMatrix, s_materialHandles);
Transform t = m_context.PreviewObject.transform;
Bounds box = m_meshFilter.sharedMesh.bounds;
Vector3 extent = box.extents;
NPipeGL.DrawParallelepiped(
t.position - new Vector3(extent.x, extent.y, extent.z),
new Vector3(box.size.x, 0, 0),
new Vector3(0, box.size.y, 0),
new Vector3(0, 0, box.size.z),
s_colorBox);
NPVoxMeshData[] voxMeshData = m_context.MeshOutput.GetVoxMeshData();
Vector3 voxSize = m_context.MeshOutput.VoxelSize;
Vector3 voxExtent = voxSize * 0.5f;
Color cOutline = new Color(0.3f, 0.3f, 0.3f);
Color cNormals = new Color(0.4f, 0.4f, 0.4f);
Vector3 v1 = new Vector3(voxSize.x, 0, 0);
Vector3 v2 = new Vector3(0, voxSize.y, 0);
Vector3 v3 = new Vector3(0, 0, voxSize.z);
Vector3[] normals = m_context.PreviewMesh.normals;
foreach (NPVoxMeshData vox in voxMeshData)
{
if (!vox.isHidden)
{
if (m_previewGUIDrawOutlines)
{
Vector3 voxPosition = new Vector3(vox.voxelCenter.x, vox.voxelCenter.y, vox.voxelCenter.z);
NPipeGL.DrawParallelepiped(voxPosition - voxExtent, v1, v2, v3, cOutline);
}
if (m_previewGUIDrawNormals)
{
NPipeGL.DrawLine(vox.voxelCenter, vox.voxelCenter + normals[vox.vertexIndexOffsetBegin] * voxSize.x, cNormals);
}
}
}
DrawSceneInternal(_rect);
NPipeGL.PostRenderEnd();
GUI.DrawTexture(_rect, m_renderer.EndPreview());
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
_drag = Drag2D(_drag, r);
if (UnityEngine.Event.current.type == UnityEngine.EventType.Repaint)
{
if (_targetMeshRenderer == null)
{
EditorGUI.DropShadowLabel(r, "Mesh Renderer Required");
}
else
{
EditorGUILayout.BeginHorizontal();
{
_previewRenderUtility.BeginPreview(r, background);
_previewRenderUtility.DrawMesh(_targetMeshFilter.sharedMesh, Matrix4x4.identity, _targetMeshRenderer.sharedMaterial, 0);
// _previewRenderUtility.m_Camera.transform.eulerAngles = new Vector3(0, 180, 0);
// _previewRenderUtility.m_Camera.transform.position = Vector2.zero;
_previewRenderUtility.camera.transform.rotation = Quaternion.Euler(new Vector3(-_drag.y, -_drag.x, 0));
_previewRenderUtility.camera.transform.position = _previewRenderUtility.camera.transform.forward * -20;
_previewRenderUtility.camera.Render();
Texture resultRender = _previewRenderUtility.EndPreview();
GUI.DrawTexture(r, resultRender, ScaleMode.StretchToFill, false);
}
{
_previewRenderUtility.BeginPreview(r, background);
_previewRenderUtility.DrawMesh(_targetMeshFilter.sharedMesh, Matrix4x4.identity, _targetMeshRenderer.sharedMaterial, 0);
// _previewRenderUtility.m_Camera.transform.eulerAngles = new Vector3(0, 180, 0);
// _previewRenderUtility.m_Camera.transform.position = Vector2.zero;
_previewRenderUtility.camera.transform.rotation = Quaternion.Euler(new Vector3(_drag.y, _drag.x, 0));
_previewRenderUtility.camera.transform.position = _previewRenderUtility.camera.transform.forward * -20;
_previewRenderUtility.camera.Render();
Texture resultRender = _previewRenderUtility.EndPreview();
GUI.DrawTexture(r, resultRender, ScaleMode.StretchToFill, false);
}
EditorGUILayout.EndHorizontal();
}
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
InputCheck();
PreviewGUI();
m_Preview.BeginPreview(r, background);
m_Preview.camera.Render();
m_Preview.EndAndDrawPreview(r);
}
private void DrawWindow()
{
Vector2 size = _window.position.size;
_previewWindow = new Rect((size.x) - PREVIEW_WINDOW.x - 5, (size.y) - PREVIEW_WINDOW.y - 5, PREVIEW_WINDOW.x, PREVIEW_WINDOW.y);
_renderUtils.BeginPreview(_previewWindow, EditorStyles.helpBox);
_renderUtils.Render();
_renderUtils.EndAndDrawPreview(_previewWindow);
}
private Texture RenderPreview(Rect r, GUIStyle background)
{
previewRenderUtility.BeginPreview(r, background);
previewRenderUtility.DrawMesh(targetMeshFilter.sharedMesh,
previewRendererObject.transform.localToWorldMatrix,
targetMeshRenderer.sharedMaterial, 0);
previewRenderUtility.camera.Render();
return(previewRenderUtility.EndPreview());
}
private void OnGUI()
{
Init();
EditorGUIUtility.labelWidth = 50;
Rect previewRect = new Rect(0, 0, position.width, position.height / 2);
EditorGUI.BeginChangeCheck();
_previewDir = Drag2D(_previewDir, previewRect);
if (EditorGUI.EndChangeCheck())
{
_eulerAngles.x = Gyro.SignedAngle(Gyro.UnsignedAngle(_previewDir.y % 360));
_eulerAngles.z = Gyro.SignedAngle(Gyro.UnsignedAngle(_previewDir.x % 360));
}
else
{
_eulerAngles.x = Gyro.SignedAngle(EditorGUI.Slider(new Rect(0, previewRect.height, position.width, 20), "Pitch",
Gyro.SignedAngle(_eulerAngles.x), -180f, 180));
_eulerAngles.z = Gyro.SignedAngle(EditorGUI.Slider(
new Rect(0, previewRect.height + position.height / 10, position.width, 20),
"Roll", Gyro.SignedAngle(_eulerAngles.z), -180f, 180));
_eulerAngles.y = Gyro.SignedAngle(EditorGUI.Slider(
new Rect(0, previewRect.height + 2 * position.height / 10, position.width, 20), "Yaw",
Gyro.SignedAngle(_eulerAngles.y), -180f, 180));
}
if (GUI.Button(new Rect(0, previewRect.height + 4 * position.height / 10, position.width, 20), "Reset"))
{
_eulerAngles = Vector3.zero;
_previewDir = Vector2.zero;
}
_proxy.transform.eulerAngles = _eulerAngles;
_preview.BeginPreview(previewRect, GUIStyle.none);
Bounds bounds = _proxyFilter.sharedMesh.bounds;
float halfSize = bounds.extents.magnitude;
float distance = halfSize * 7f;
_preview.camera.transform.position = Vector3.up * distance;
_preview.camera.nearClipPlane = distance - halfSize * 1.1f;
_preview.camera.farClipPlane = distance + halfSize * 1.1f;
_preview.camera.transform.eulerAngles = Vector3.right * 90;
_preview.lights[0].intensity = 1.4f;
_preview.lights[0].transform.rotation = Quaternion.Euler(90, 0, 0);
_preview.ambientColor = Color.black;
//_preview.DrawMesh(_proxyFilter.sharedMesh, _proxyTransform.position, _proxyTransform.rotation, _proxyRenderer.sharedMaterial, 0);
_preview.Render();
_preview.EndAndDrawPreview(previewRect);
Gyro.VirtualTilt = Quaternion.Euler(Gyro.UnsignedAngle(-_eulerAngles.x), Gyro.UnsignedAngle(-_eulerAngles.z), _eulerAngles.y);
EditorGUI.LabelField(new Rect(0, previewRect.height + 3 * position.height / 10, position.width, 20), "Attitude: " + Gyro.VirtualTilt);
}
/// <summary>
/// Handle the display of the material preview
/// </summary>
/// <param name="materialEditor">Current Material Editor</param>
/// <param name="r">Fullsized rect for the interactive preview</param>
/// <param name="background">Background data for the interactive preview</param>
public override void OnMaterialInteractivePreviewGUI(MaterialEditor materialEditor, Rect r, GUIStyle background)
{
if (!ShaderUtil.hardwareSupportsRectRenderTexture)
{
if (Event.current.type != EventType.Repaint)
{
return;
}
EditorGUI.DropShadowLabel(new Rect(r.x, r.y, r.width, 40f), "Material preview \nnot available");
}
else
{
if (targetMesh == null)
{
base.OnMaterialInteractivePreviewGUI(materialEditor, r, background);
return;
}
Material mat = materialEditor.target as Material;
if (m_previewRenderUtility == null)
{
m_previewRenderUtility = new PreviewRenderUtility();
m_previewRenderUtility.AddSingleGO(GameObject.CreatePrimitive(PrimitiveType.Plane));
#if UNITY_2017_1_OR_NEWER
fov = m_previewRenderUtility.cameraFieldOfView = 30f;
#else
fov = m_previewRenderUtility.m_CameraFieldOfView = 30f;
#endif
}
if (m_previewGUIType == null)
{
m_previewGUIType = Type.GetType(GUISrc);
m_dragMethod = m_previewGUIType.GetMethod("Drag2D", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
}
if (m_modelInspectorType == null)
{
m_modelInspectorType = Type.GetType("UnityEditor.ModelInspector, UnityEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null");
m_renderMeshMethod = m_modelInspectorType.GetMethod("RenderMeshPreview", BindingFlags.Static | BindingFlags.NonPublic);
}
m_previewDir = (Vector2)m_dragMethod.Invoke(m_previewGUIType, new object[] { m_previewDir, r });
if (Event.current.type == EventType.Repaint)
{
m_previewRenderUtility.BeginPreview(r, background);
m_renderMeshMethod.Invoke(m_modelInspectorType, new object[] { targetMesh, m_previewRenderUtility, mat, null, m_previewDir, -1 });
m_previewRenderUtility.EndAndDrawPreview(r);
}
}
}
protected virtual void DrawWindow()
{
_rect.width = PREVIEW_WINDOW.x;
_rect.height = PREVIEW_WINDOW.y;
_rect.x += 5;
_renderUtils.BeginPreview(_rect, EditorStyles.helpBox);
_renderUtils.Render();
_renderUtils.EndAndDrawPreview(_rect);
NextLine();
}
public override void OnInteractivePreviewGUI(Rect r, GUIStyle background)
{
preview.BeginPreview(r, background);
preview.DrawMesh(generator.targetMesh, Matrix4x4.identity, previewMaterial, 0);
preview.camera.transform.SetPositionAndRotation(Vector3.forward * -5, Quaternion.identity);
preview.Render();
Texture texture = preview.EndPreview();
GUI.DrawTexture(r, texture, ScaleMode.StretchToFill, true);
}
public static byte[] GeneratePrefabThumbnail(GameObject prefab)
{
var prefabInstance = UnityObject.Instantiate(prefab);
var renderUtility = new PreviewRenderUtility();
var renderCamera = renderUtility.camera;
var renderCameraTransform = renderCamera.transform;
renderCamera.fieldOfView = k_FieldOfView;
renderUtility.AddSingleGO(prefabInstance);
renderCamera.backgroundColor = k_BackgroundColor;
var prefabList = new List <GameObject>();
prefabList.Add(prefabInstance);
var bounds = BoundsUtils.GetBounds(prefabList);
var halfSize = Mathf.Max(bounds.extents.magnitude, 0.0001f);
var distance = halfSize * k_CameraDistanceRatio;
var pos = bounds.center - k_PreviewRotation * (Vector3.forward * distance);
renderCameraTransform.position = pos;
renderCameraTransform.rotation = k_PreviewRotation;
renderCamera.nearClipPlane = distance - halfSize * k_Padding;
renderCamera.farClipPlane = distance + halfSize * k_Padding;
renderUtility.lights[0].intensity = k_LightIntensity;
renderUtility.lights[0].transform.rotation = k_FirstLightRotation;
renderUtility.lights[1].intensity = k_LightIntensity;
renderUtility.lights[1].transform.rotation = k_SecondLightRotation;
renderUtility.ambientColor = k_AmbientLightColor;
renderUtility.BeginPreview(k_TextureRect, null);
renderUtility.Render(true);
var renderTexture = renderUtility.EndPreview() as RenderTexture;
var temporary = RenderTexture.GetTemporary((int)k_TextureRect.width, (int)k_TextureRect.height, 0, GraphicsFormat.R8G8B8A8_UNorm);
Graphics.Blit(renderTexture, temporary);
RenderTexture.active = temporary;
var texture = new Texture2D((int)k_TextureRect.width, (int)k_TextureRect.height, TextureFormat.RGBA32, false, false);
texture.ReadPixels(new Rect(0.0f, 0.0f, k_TextureRect.width, k_TextureRect.height), 0, 0);
texture.Apply();
var thumbnail = texture.EncodeToPNG();
RenderTexture.ReleaseTemporary(temporary);
renderUtility.Cleanup();
UnityObject.DestroyImmediate(texture);
return(thumbnail);
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
if (bPrefab || previewRenderUtility == null)
{
return;
}
if (!(r.width > 0 && r.height > 0))
{
return;
}
var previewCamera = PreviewCam;
previewRenderUtility.BeginPreview(r, background);
var drag = Vector2.zero;
if (Event.current.type == EventType.MouseDrag &&
r.Contains(Event.current.mousePosition))
{
drag = Event.current.delta;
if (drag != Vector2.zero)
{
drag *= 0.02f;
Vector3 delta = previewCamera.transform.up * drag.y + previewCamera.transform.right * drag.x;
previewCamera.transform.Translate(delta);
}
}
GUI.Label(r, previewCamera.transform.position + ", " + previewCamera.transform.eulerAngles + "\n"
+ Camera.main.transform.position + ", " + Camera.main.transform.eulerAngles + "\n"
+ previewCamera.cullingMask + ", " + (1 << previewObject.layer));
if (IsEditorMode && previewObject != null)
{
previewObject.gameObject.SetActive(true);
previewCamera.Render();
previewObject.gameObject.SetActive(false);
}
else
{
previewCamera.Render();
}
Texture image = previewRenderUtility.EndPreview();
GUI.DrawTexture(r, image, ScaleMode.StretchToFill, false); // draw the RenderTexture in the ObjectPreview pane
if (drag != Vector2.zero)
{
Repaint();
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
if (!ShaderUtil.hardwareSupportsRectRenderTexture || !SystemInfo.supports3DTextures)
{
if (Event.current.type == EventType.Repaint)
{
EditorGUI.DropShadowLabel(new Rect(r.x, r.y, r.width, 40), "3D texture preview not supported");
}
return;
}
m_PreviewDir = Drag2D(m_PreviewDir, r);
Event e = Event.current;
if (e.type == EventType.ScrollWheel)
{
zoom = Mathf.Clamp(zoom + e.delta.y * 0.1f, 0.05f, 5f);
m_PreviewUtility.camera.nearClipPlane = Mathf.Lerp(0.05f, 2, Mathf.InverseLerp(0.05f, 3f, zoom));
e.Use();
Repaint();
}
if (e.type != EventType.Repaint)
{
return;
}
InitPreview();
material3D.mainTexture = target as Texture3D;
m_PreviewUtility.BeginPreview(r, background);
bool oldFog = RenderSettings.fog;
Unsupported.SetRenderSettingsUseFogNoDirty(false);
var cameraTransform = m_PreviewUtility.camera.transform;
cameraTransform.position = -Vector3.forward * zoom;
cameraTransform.rotation = Quaternion.identity;
Quaternion rot = Quaternion.Euler(m_PreviewDir.y, 0, 0) * Quaternion.Euler(0, m_PreviewDir.x, 0);
m_PreviewUtility.DrawMesh(Mesh, Vector3.zero, rot, material3D, 0);
m_PreviewUtility.Render();
Unsupported.SetRenderSettingsUseFogNoDirty(oldFog);
m_PreviewUtility.EndAndDrawPreview(r);
if (continuousRepaint)
{
Repaint();
}
}
public override void OnMaterialInteractivePreviewGUI(MaterialEditor materialEditor, Rect r, GUIStyle background)
{
if (Event.current.type == EventType.DragExited)
{
if (DragAndDrop.objectReferences.Length > 0)
{
GameObject dropped = DragAndDrop.objectReferences[0] as GameObject;
if (dropped != null)
{
m_targetMesh = AssetDatabase.LoadAssetAtPath <Mesh>(AssetDatabase.GetAssetPath(dropped));
EditorPrefs.SetString(PreviewModelPref, AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(m_targetMesh)));
}
}
}
if (m_targetMesh == null)
{
base.OnMaterialInteractivePreviewGUI(materialEditor, r, background);
return;
}
Material mat = materialEditor.target as Material;
if (m_previewRenderUtility == null)
{
m_previewRenderUtility = new PreviewRenderUtility();
#if UNITY_2017_1_OR_NEWER
m_previewRenderUtility.cameraFieldOfView = 30f;
#else
m_previewRenderUtility.m_CameraFieldOfView = 30f;
#endif
}
if (m_previewGUIType == null)
{
m_previewGUIType = Type.GetType("PreviewGUI, UnityEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null");
m_dragMethod = m_previewGUIType.GetMethod("Drag2D", BindingFlags.Static | BindingFlags.Public);
}
if (m_modelInspectorType == null)
{
m_modelInspectorType = Type.GetType("UnityEditor.ModelInspector, UnityEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null");
m_renderMeshMethod = m_modelInspectorType.GetMethod("RenderMeshPreview", BindingFlags.Static | BindingFlags.NonPublic);
}
m_previewDir = (Vector2)m_dragMethod.Invoke(m_previewGUIType, new object[] { m_previewDir, r });
if (Event.current.type == EventType.Repaint)
{
m_previewRenderUtility.BeginPreview(r, background);
m_renderMeshMethod.Invoke(m_modelInspectorType, new object[] { m_targetMesh, m_previewRenderUtility, mat, null, m_previewDir, -1 });
m_previewRenderUtility.EndAndDrawPreview(r);
}
}