/// <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); } } }
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) { _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 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) { //_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 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 (!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) { 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 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(); } } }
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()); }
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); }
private static void Render(Rect r) { camera.Render(); Texture texture = PREV_RENDER.EndPreview(); GUI.DrawTexture(r, texture); PLANE = null; PLANE_MATERIAL = null; }
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(); } }
protected Texture EndPreview(PreviewRenderUtility util) { util.Render(true); UnityEditorInternal.InternalEditorUtility.RemoveCustomLighting(); Unsupported.SetRenderSettingsUseFogNoDirty(fog); var texture = util.EndPreview(); return(texture); }
public override void OnPreviewGUI(Rect r, GUIStyle background) { if (Event.current.type == EventType.Repaint) { _previewRenderUtility.BeginPreview(r, background); LevelTiles[] levelTiles = (target as Pattern).gameObject.GetComponentsInChildren <LevelTiles> (); for (int i = 0; i < levelTiles.Length; i++) { Transform prefab = levelTiles[i].levelTilePrefab; MeshFilter[] meshFilters = prefab.GetComponentsInChildren <MeshFilter> (); for (int j = 0; j < meshFilters.Length; j++) { Vector3 scale = Vector3.Scale(meshFilters [j].transform.lossyScale, levelTiles[i].transform.localScale); Vector3 pos = levelTiles[i].transform.position + (meshFilters [j].transform.position - meshFilters[j].transform.root.position); Quaternion rot = Quaternion.Euler(levelTiles[i].transform.rotation.eulerAngles + meshFilters [j].transform.rotation.eulerAngles); Matrix4x4 matrix = Matrix4x4.TRS(pos, rot, scale); Material mat = meshFilters [j].transform.GetComponent <MeshRenderer> ().sharedMaterial; int subMeshCount = meshFilters [j].sharedMesh.subMeshCount; //Debug.Log (subMeshCount); _previewRenderUtility.DrawMesh(meshFilters [j].sharedMesh, matrix, mat, 0); } /**Transform[] childTransforms = prefab.GetComponentsInChildren<Transform> (); * for (int j = 0; j < childTransforms.Length; j++) { * if (childTransforms [j].GetComponent<MeshFilter> () != null) { * MeshFilter myMeshFilter = childTransforms [j].GetComponent<MeshFilter> (); * Vector3 scale = Vector3.Scale(myMeshFilter.transform.lossyScale,levelTiles[i].transform.localScale); * Vector3 pos = levelTiles[i].transform.position + (myMeshFilter.transform.position - myMeshFilter.transform.root.position); * Quaternion rot = Quaternion.Euler(levelTiles[i].transform.rotation.eulerAngles + myMeshFilter.transform.rotation.eulerAngles); * Matrix4x4 matrix = Matrix4x4.TRS (pos, rot, scale); * * Material mat = myMeshFilter.transform.GetComponent<MeshRenderer> ().sharedMaterial; * * _previewRenderUtility.DrawMesh (myMeshFilter.sharedMesh, matrix, mat, 0); * } * }**/ } _previewRenderUtility.camera.Render(); Texture resultRender = _previewRenderUtility.EndPreview(); GUI.DrawTexture(r, resultRender, ScaleMode.StretchToFill, false); } }
public override void OnInteractivePreviewGUI(Rect r, GUIStyle background) { base.OnInteractivePreviewGUI(r, background); if (_util == null) { _util = new PreviewRenderUtility(); } _util.BeginPreview(r, background); GUILayout.Button("asdf"); Texture resultRender = _util.EndPreview(); GUI.DrawTexture(r, resultRender, ScaleMode.StretchToFill, false); }
private Texture RenderObjectPreview(Rect r, GameObject currentObjectToPreview, GUIStyle background) { var previewObject = GameObject.Instantiate(currentObjectToPreview); previewObject.hideFlags = HideFlags.HideAndDontSave; _targetMeshFilter = previewObject.GetComponentInChildren <MeshFilter>(); _targetMeshRenderer = previewObject.GetComponentInChildren <MeshRenderer>(); bool renderPreview = true; if (_targetMeshFilter == null || _targetMeshRenderer == null) { renderPreview = false; } if (renderPreview) { _previewRenderUtility.BeginPreview(r, background); var cam = _previewRenderUtility.m_Camera; cam.transform.position = Vector2.zero; cam.transform.rotation = Quaternion.Euler(new Vector3(-_drag.y, -_drag.x, 0)); cam.transform.position = cam.transform.forward * -10f; cam.farClipPlane = 50; var lookAtCamRotation = previewObject.transform.rotation; _previewRenderUtility.DrawMesh(_targetMeshFilter.sharedMesh, Vector3.zero, // use the correction throught the Transform of the host gameobject lookAtCamRotation, _targetMeshRenderer.sharedMaterial, 0); var light = _previewRenderUtility.m_Light.First(); light.type = LightType.Directional; light.transform.position = _previewRenderUtility.m_Camera.transform.position; light.transform.rotation = _previewRenderUtility.m_Camera.transform.rotation; _previewRenderUtility.m_Camera.Render(); var result = _previewRenderUtility.EndPreview(); DestroyImmediate(previewObject); return(result); } return(null); }
public override void OnPreviewGUI(Rect r, GUIStyle background) { if (Event.current.type == EventType.Repaint) { if (pru == null) { pru = new PreviewRenderUtility(true); //Draws handles? glyphCamera = pru.camera; glyphCamera.orthographic = true; glyphCamera.aspect = 1f; glyphCamera.orthographicSize = 0.625f; glyphCamera.cullingMask = 0; } Vector2 rCenter = r.center; if (r.width > r.height) { r.width = r.height; } else { r.height = r.width; } r.center = rCenter; pru.BeginPreview(r, background); if (glyphCamera == null) { Debug.LogWarning("Camera is null."); } else { Handles.SetCamera(glyphCamera); Handles.matrix = baseMatrix * glyphCamera.cameraToWorldMatrix; //Draw handles float d = 0.62f; Handles.DrawSolidRectangleWithOutline(new Vector3[] { new Vector3(-d, -d, 0), new Vector3(-d, d, 0), new Vector3(d, d, 0), new Vector3(d, -d, 0) }, new Color(0.1f, 0.1f, 0.1f), new Color(0.7f, 0.7f, 0.7f)); Handles.color = new Color(0.7f, 0.7f, 0.7f); DrawGlyphHandleLines(); // GLDrawGlyph(); } glyphCamera.Render(); Texture previewTexture = pru.EndPreview(); GUI.DrawTexture(r, previewTexture, ScaleMode.ScaleToFit); } }
Texture GetPreviewTexture(Vector2 previewDir, Rect region, GUIStyle background) { if (previewUtility == null) { previewUtility = new PreviewRenderUtility(); } //if (Event.current.type != EventType.Repaint) // return; var material = renderMaterialProp.objectReferenceValue as Material; var mesh = GetPreviewSphere(); var camera = previewUtility.camera; Bounds bounds = mesh.bounds; float halfSize = bounds.extents.magnitude; float distance = 5.0f * 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.4f; previewUtility.lights[0].transform.rotation = Quaternion.Euler(40f, 40f, 0); previewUtility.lights[1].intensity = 1.4f; previewUtility.BeginPreview(region, background); bool fog = RenderSettings.fog; Unsupported.SetRenderSettingsUseFogNoDirty(false); camera.Render(); Unsupported.SetRenderSettingsUseFogNoDirty(fog); Quaternion rot = Quaternion.Euler(previewDir.y, 0, 0) * Quaternion.Euler(0, previewDir.x, 0); Vector3 pos = rot * (-bounds.center); previewUtility.DrawMesh(mesh, pos, rot, material, 0); var texture = previewUtility.EndPreview(); texture.hideFlags = HideFlags.HideAndDontSave; return(texture); }
public void OnGUI() { _animator = instance.GetComponent <Animator>(); rect = position; _animator.Update((float)Time.realtimeSinceStartup - (float)lastTime); lastTime = Time.realtimeSinceStartup; _previewRenderUtility.BeginPreview(rect, new GUIStyle()); Mesh mesh = new Mesh(); instance.GetComponentInChildren <SkinnedMeshRenderer>().BakeMesh(mesh); _previewRenderUtility.DrawMesh(mesh, Matrix4x4.identity, instance.GetComponentInChildren <SkinnedMeshRenderer>().sharedMaterial, 0); _previewRenderUtility.camera.Render(); Texture outputTexture = _previewRenderUtility.EndPreview(); GUI.DrawTexture(rect, outputTexture, ScaleMode.StretchToFill, false); if (GUILayout.Button("Attack")) { _animator.SetTrigger(Attack); } if (GUILayout.Button("Jump")) { _animator.SetTrigger("Jump"); } if (GUILayout.Button("Somersault")) { _animator.SetTrigger("Somersault"); } if (GUILayout.Button("Walk")) { _animator.SetTrigger("Walk"); } if (GUILayout.Button("Sit")) { _animator.SetTrigger("Sit"); } _drag = Drag2D(_drag, rect); }
public Texture GetSceneTexture(Rect rectangle, GUIStyle background) { _previewRenderUtility.BeginPreview(rectangle, background); foreach (ScenePreviewModel model in _models) { _previewRenderUtility.DrawMesh(model.mesh, model.matrix, model.material, 0); } _previewRenderUtility.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 * -_distance; _previewRenderUtility.camera.transform.position += _previewRenderUtility.camera.transform.right * _offset.x; _previewRenderUtility.camera.transform.position += _previewRenderUtility.camera.transform.up * _offset.y; _previewRenderUtility.camera.Render(); return(_previewRenderUtility.EndPreview()); }
/// <summary> /// Render the added objects and return as Texture. /// </summary> /// <param name="r">The Rect component used for dimensions.</param> /// <param name="background">The GUIStyle which will be used for the background.</param> public Texture Render(Rect r) { if (renderUtil == null) { throw new System.NullReferenceException("RenderUtil was not initialized"); } renderUtil.BeginPreview(r, GUI.skin.box); foreach (RenderItem rItem in RenderQueue) { renderUtil.DrawMesh(rItem.Mesh, rItem.Matrix, rItem.Material, 0); } renderUtil.camera.Render(); return(renderUtil.EndPreview()); }
private void OnGUI() { GUILayout.Label("Settings"); sub = EditorGUILayout.IntSlider("Subdivison Depth", sub, 0, 5); bool g = GUILayout.Button("Generate"); bool b = GUILayout.Button("Save"); Rect r = new Rect(0, 0, 512, 512); if (mat == null) { mat = Resources.Load <Material>("_Game/Materials/PlanetSurface"); } if (prev == null) { prev = new PreviewRenderUtility(); } if (g) { // SphereMesh sm = new SphereMesh(sub); // m = sm.Mesh; } if (m != null && mat != null && prev != null) { prev.camera.transform.position = -Vector3.forward * 5; prev.camera.transform.rotation = Quaternion.identity; prev.BeginPreview(r, GUIStyle.none); prev.DrawMesh(m, Vector3.zero, Quaternion.identity, mat, 0); prev.Render(); GUI.DrawTexture(r, prev.EndPreview()); } if (b) { SaveMesh(); } }
//画预览图 public override void OnPreviewGUI(Rect r, GUIStyle background) { bool isPrefab = renderer.gameObject.scene.name == null; if (isPrefab) { _drag = Drag2D(_drag, r); if (Event.current.type == EventType.Repaint) { _previewRenderUtility.BeginPreview(r, background); Rect rect = new Rect(); if (meshes.Count > 0) { rect = meshes[0].rect; } for (int i = 1; i < meshes.Count; i++) { rect = ExpandRect(rect, meshes[i].rect); } for (int i = 0; i < meshes.Count; i++) { if (meshes[i].graphic is Text) { (meshes[i].graphic as Text).FontTextureChanged(); } meshes[i].material.mainTexture = meshes[i].graphic.mainTexture; meshes[i].material.color = meshes[i].graphic.color; meshes[i].material.SetVector("_TextureSampleAdd", (meshes[i].graphic is Text) ? new Color(1, 1, 1, 0) : new Color(0, 0, 0, 0)); _previewRenderUtility.DrawMesh(meshes[i].mesh, meshes[i].matrix, meshes[i].material, 0); _previewRenderUtility.m_Camera.transform.position = new Vector3(rect.center.x + _drag.x, rect.center.y - _drag.y, 0) + _previewRenderUtility.m_Camera.transform.forward * -60f; _previewRenderUtility.m_Camera.orthographic = true; _previewRenderUtility.m_Camera.orthographicSize = Mathf.Max(rect.width, rect.height); _previewRenderUtility.m_Camera.nearClipPlane = 0.1f; _previewRenderUtility.m_Camera.farClipPlane = 100; _previewRenderUtility.m_Camera.Render(); } Texture resultRender = _previewRenderUtility.EndPreview(); GUI.DrawTexture(r, resultRender, ScaleMode.StretchToFill, false); } } }
public override void DrawPreview(Rect rect) { //process preview controls ProcessPreviewInput(rect); //update display flags UpdateDisplayFlags(); if (_update_mesh) { //update mesh UpdateMesh(); //clear update mesh flag _update_mesh = false; } if (_render_mesh) { UpdateDisplay(); //update preview render texture _previewutility.BeginPreview(rect, GUI.skin.GetStyle("DarkGrey")); //draw axi stuff _display.DrawDisplayObjects(_previewutility); //draw mesh if (_mesh.triangles.Length > 0 && mesh_mat != null) { _previewutility.DrawMesh(_mesh, Vector3.zero, Quaternion.identity, mesh_mat, 0); } //draw vertices DrawVertex(); //render preview scene _previewutility.Render(); _render = _previewutility.EndPreview(); //clear render mesh flag _render_mesh = false; } //return if nothing to draw if (_render == null) { return; } //draw preview render texture GUI.DrawTexture(rect, _render); rect = VxlGUI.GetPaddedRect(rect, VxlGUI.MED_PAD); _display.DrawGUI(new Rect(rect.x, rect.y, 0.5f * rect.width, 0.5f * rect.height)); }
private void RenderIcon(PreviewRenderUtility previewRenderer, Target target) { const int w = 1024; const int h = 1024; var rect = new Rect(0f, 0f, w, h); previewRenderer.BeginPreview(rect, null); previewRenderer.InstantiatePrefabInScene(_prefab); previewRenderer.camera.clearFlags = CameraClearFlags.SolidColor; previewRenderer.camera.backgroundColor = target.Background; previewRenderer.camera.transform.position = _cameraSettings.Position; previewRenderer.camera.transform.rotation = Quaternion.Euler(_cameraSettings.Rotation); previewRenderer.camera.nearClipPlane = _cameraSettings.Near; previewRenderer.camera.farClipPlane = _cameraSettings.Far; previewRenderer.Render(true); var rt = previewRenderer.EndPreview(); var temporary = RenderTexture.GetTemporary(w, h, 0, GraphicsFormat.R8G8B8A8_UNorm); Graphics.Blit(rt, temporary, _tex2rgbMaterial); RenderTexture.active = temporary; var texture = new Texture2D(w, h, TextureFormat.RGBA32, false, false); texture.ReadPixels(rect, 0, 0); texture.Apply(); RenderTexture.ReleaseTemporary(temporary); try { var path = AssetDatabase.GetAssetPath(target.TargetTexture); File.WriteAllBytes(path, texture.EncodeToPNG()); AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate); } catch (Exception e) { Debug.LogError($"Unable to write to icon: {e.Message}"); } }
public void HandleInteractivePreviewGUI(Rect r, GUIStyle background) { if (Event.current.type == EventType.Repaint) { if (requiresRefresh) { previewRenderUtility.BeginPreview(r, background); DoRenderPreview(true); previewTexture = previewRenderUtility.EndPreview(); requiresRefresh = false; } if (previewTexture != null) { GUI.DrawTexture(r, previewTexture, ScaleMode.StretchToFill, false); } } DrawSkinToolbar(r); DrawTimeBar(r); MouseScroll(r); }