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); } }