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