private void DrawRenderPreview(Rect previewRect)
{
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);
Vector3 position2 = matrix.MultiplyPoint(importPivot - 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 = 10000f;
preview.BeginPreview(previewRect, GUIStyle.none);
preview.DrawMesh(previewMesh, position, rotation, previewMaterial, 0);
preview.DrawMesh(previewPivotMesh, position2, rotation, previewPivotMaterial, 0);
preview.Render();
preview.EndAndDrawPreview(previewRect);
}
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();
}
}
}
private void DrawScene()
{
var rect = new Rect(0, 0, this.position.size.x, this.position.size.y);
this.renderer.camera.nearClipPlane = 0.1f;
this.renderer.camera.farClipPlane = 10000.0f;
this.renderer.camera.fieldOfView = cameraFov;
this.renderer.camera.transform.position = Quaternion.Euler(mouseAction.rotateEuler) * new Vector3(0, 0, -this.mouseAction.zoom);
this.renderer.camera.transform.rotation = Quaternion.Euler(mouseAction.rotateEuler);
this.renderer.camera.clearFlags = CameraClearFlags.SolidColor;
var mesh = OctahedralHemiSphere.CreatePrimitive(modelScale, modelMeshes, modelRatio);
var grid = OctahedralGrid.CreatePrimitive(10.0f, 100, 10, Color.white * 0.125f, Color.white * 0.25f);
var gridMaterial = new Material(Shader.Find("OctahedralImposter/Grid"));
var material = new Material(Shader.Find("OctahedralImposter/Wireframe"));
renderer.DrawMesh(mesh, Vector3.zero, Quaternion.identity, material, 0);
renderer.DrawMesh(grid, Vector3.zero, Quaternion.identity, gridMaterial, 0);
this.renderer.BeginPreview(rect, GUIStyle.none);
this.renderer.camera.Render();
var tex = this.renderer.EndPreview();
GameObject.DestroyImmediate(mesh);
GameObject.DestroyImmediate(grid);
GUI.DrawTexture(rect, tex);
}
private static void BuildScene(Rect r, GUIStyle background, Mesh[] meshes)
{
int meshCount = meshes.Length;
UpdateInteraction(r);
if (PREV_RENDER == null)
{
PREV_RENDER = new PreviewRenderUtility();
}
Bounds sceneBounds = new Bounds(meshes[0].bounds.center, Vector3.zero);
sceneBounds.Expand(Vector3.one * 0.1f);
for (int m = 0; m < meshCount; m++)
{
sceneBounds.Encapsulate(meshes[m].bounds);
}
Vector3 max = sceneBounds.size;
float radius = Mathf.Max(max.x, Mathf.Max(max.y, max.z)) * 1.05f;
INTERACTION_SCALE = radius * 0.001f;
float dist = radius / (Mathf.Sin(camera.fieldOfView * Mathf.Deg2Rad)) * ZOOM;
camera.transform.position = Vector2.zero;
camera.transform.rotation = Quaternion.Euler(new Vector3(-DRAG.y, -DRAG.x, 0));
camera.transform.position = camera.transform.forward * -dist;
camera.nearClipPlane = 0.1f;
camera.farClipPlane = 500;
#if UNITY_2017_1_OR_NEWER
float baseColour = 0.4f;
PREV_RENDER.ambientColor = new Color(baseColour, baseColour, baseColour);
#endif
lights[0].intensity = 0.65f;
lights[0].transform.rotation = Quaternion.Euler(30f, -20f, 0f);
PREV_RENDER.BeginPreview(r, background);
if (PLANE != null && PLANE_MATERIAL != null)
{
#if UNITY_2017_1_OR_NEWER
Vector3 position = new Vector3(0, 0, Mathf.Max(0.2f, max.z)) - OFFSET;
Vector3 scale = max * 3000;
#else
Vector3 position = new Vector3(-max.x * 2, -max.y * 2, Mathf.Max(0.5f, max.z * 1.5f)) - OFFSET;
Vector3 scale = max * 3;
#endif
Matrix4x4 matrix = Matrix4x4.TRS(position, Quaternion.identity, scale);
PREV_RENDER.DrawMesh(PLANE, matrix, PLANE_MATERIAL, 0);
}
}
public Texture DrawRenderPreview(Rect size, Mesh mesh, Material material)
{
if (previewRenderer == null)
{
previewRenderer = new PreviewRenderUtility();
previewRenderer.cameraFieldOfView = 15.0f;
previewRenderer.ambientColor = (Color.white * 0.6f);
previewRenderer.camera.transform.position = (Vector3.forward * 5.0f) + (Vector3.up * 5.0f) + (Vector3.right * 5.0f);
previewRenderer.camera.transform.LookAt(Vector3.zero, Vector3.up);
previewRenderer.camera.nearClipPlane = 0.01f;
previewRenderer.camera.farClipPlane = 50.0f;
previewRenderer.lights[0].enabled = true;
previewRenderer.lights[0].type = LightType.Directional;
previewRenderer.lights[0].color = Color.white;
previewRenderer.lights[0].intensity = 1.5f;
previewRenderer.lights[0].transform.rotation = Quaternion.Euler(30f, 0f, 0f);
previewRenderer.lights[1].enabled = true;
previewRenderer.lights[1].intensity = 0.5f;
}
// Create a duplicate material with NO_CURVE enabled for rendering the preview
Material previewMaterial = Instantiate(material);
previewMaterial.EnableKeyword("NO_CURVE");
previewRenderer.BeginStaticPreview(size);
previewRenderer.DrawMesh(mesh, Matrix4x4.identity, previewMaterial, 0);
previewRenderer.Render();
return(previewRenderer.EndStaticPreview());
}
public override 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);
}
}
}
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);
}
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);
}
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)
{
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();
}
}
}
/// <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 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)
{
_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);
}
}
}
// Render a mesh in preview with wireframe material.
private void RenderMeshPreviewSkipCameraAndLightingWireframe(
Mesh cMeshWire,
Bounds cBounds,
PreviewRenderUtility cPreviewUtility,
Material cWireMaterial,
MaterialPropertyBlock cCustomProperties,
Vector2 vDirection,
int nMeshSubset // -1 for whole mesh.
)
{
if ((null == cMeshWire) || (null == cPreviewUtility))
{
return;
}
Quaternion cRot = Quaternion.Euler(vDirection.y, 0, 0) * Quaternion.Euler(0, vDirection.x, 0);
Vector3 vPos = cRot * (-cBounds.center);
bool bOldFog = RenderSettings.fog;
Unsupported.SetRenderSettingsUseFogNoDirty(false);
int submeshes = cMeshWire.subMeshCount;
if (null != cWireMaterial)
{
cPreviewUtility.camera.clearFlags = CameraClearFlags.Nothing;
GL.wireframe = true;
if ((nMeshSubset < 0) || (nMeshSubset >= submeshes))
{
for (int i = 0; i < submeshes; ++i)
{
cPreviewUtility.DrawMesh(cMeshWire, vPos, cRot, cWireMaterial, i, cCustomProperties);
}
}
else
{
cPreviewUtility.DrawMesh(cMeshWire, vPos, cRot, cWireMaterial, nMeshSubset, cCustomProperties);
}
cPreviewUtility.Render();
GL.wireframe = false;
}
Unsupported.SetRenderSettingsUseFogNoDirty(bOldFog);
}
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());
}
}
private void DrawDisplayObject(PreviewRenderUtility preview, Mesh mesh, Vector3 pos, Quaternion rot, Vector3 scale)
{
if (preview == null || mesh == null || scale == Vector3.zero)
{
return;
}
preview.DrawMesh(mesh, pos, scale, rot, material, 0, _propblock, null, false);
}
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();
}
}
}
/// <summary>
/// Create a Texture2D icon of a SVG image (editor only version).
/// </summary>
/// <param name="svg">String containing svg content.</param>
/// <param name="renderUtil">PreviewRenderUtility to use for drawing</param>
public static Texture2D GetIcon(string svg, PreviewRenderUtility renderUtil)
{
// Parse the SVG
SVGParser.SceneInfo sceneInfo = SVGParser.ImportSVG(new System.IO.StringReader(svg));
int width = Mathf.CeilToInt(sceneInfo.SceneViewport.width);
int height = Mathf.CeilToInt(sceneInfo.SceneViewport.height);
if ((width > 64) || (height > 64))
{
Debug.LogWarning("SVG icon of unusual size!");
}
// Save the render state and get a temporary render texture
RenderTexture activeTexture = RenderTexture.active;
renderUtil.camera.targetTexture = RenderTexture.GetTemporary(width, height, 8, RenderTextureFormat.ARGB32);
renderUtil.camera.backgroundColor = Color.clear;
// Generate the mesh
Mesh iconMesh = new Mesh();
VectorUtils.TessellationOptions tessellationOptions = new VectorUtils.TessellationOptions()
{
StepDistance = 0.05f,
MaxCordDeviation = float.MaxValue,
MaxTanAngleDeviation = Mathf.PI / 2.0f,
SamplingStepSize = 0.01f
};
List <VectorUtils.Geometry> iconGeometry = VectorUtils.TessellateScene(sceneInfo.Scene, tessellationOptions);
VectorUtils.FillMesh(iconMesh, iconGeometry, 1f);
// Activate the render texture and draw the mesh into it
RenderTexture.active = renderUtil.camera.targetTexture;
float cameraSize = renderUtil.camera.orthographicSize;
Vector3 cameraPosition = renderUtil.camera.transform.position;
renderUtil.camera.orthographicSize = sceneInfo.SceneViewport.height / 2;
renderUtil.camera.transform.position = new Vector3(sceneInfo.SceneViewport.center.x, sceneInfo.SceneViewport.center.y, -1);
// HACK until FillMesh() flpYAxis is fixed
renderUtil.camera.transform.Rotate(0, 0, 180f);
renderUtil.DrawMesh(iconMesh, Matrix4x4.identity, renderMaterial, 0);
renderUtil.camera.Render();
renderUtil.camera.transform.Rotate(0, 0, 180f);
renderUtil.camera.orthographicSize = cameraSize;
renderUtil.camera.transform.position = cameraPosition;
Texture2D iconTexture = new Texture2D(width, height);
iconTexture.ReadPixels(new Rect(0, 0, width, height), 0, 0);
iconTexture.Apply();
// Restore the render state and release the temporary render texture
RenderTexture.active = activeTexture;
RenderTexture.ReleaseTemporary(renderUtil.camera.targetTexture);
return(iconTexture);
}
public void Render([NotNull] PreviewRenderUtility preview)
{
// Input
preview.DrawMesh(_heightmap, _inputTransform, _inputHeightmapMaterial, 0);
preview.DrawMesh(_box, _inputTransform, _boxOutlineMaterial, 1);
preview.DrawMesh(_box, _inputTransform * _inputHighlightTransform, _highlightFillMaterial, 0);
preview.DrawMesh(_box, _inputTransform * _inputHighlightTransform, _highlightOutlineMaterial, 1);
// Output
preview.DrawMesh(_heightmap, _outputTransform, _outputHeightmapMaterial, 0);
preview.DrawMesh(_box, _outputTransform, _boxOutlineMaterial, 1);
preview.DrawMesh(_box, _outputTransform * _outputHighlightTransform, _highlightFillMaterial, 0);
preview.DrawMesh(_box, _outputTransform * _outputHighlightTransform, _highlightOutlineMaterial, 1);
// Connector
preview.DrawMesh(_range, Matrix4x4.identity, _highlightFillMaterial, 1);
preview.DrawMesh(_range, Matrix4x4.identity, _highlightOutlineMaterial, 0);
}
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);
}
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));
}
internal static void RenderMeshPreviewSkipCameraAndLighting(Mesh mesh, PreviewRenderUtility previewUtility, Material[] materials)
{
if (mesh == null || previewUtility == null)
{
return;
}
Bounds bounds = mesh.bounds;
float magnitude = bounds.extents.magnitude;
float num = 4f * magnitude;
previewUtility.m_Camera.transform.position = -Vector3.forward * num;
previewUtility.m_Camera.transform.rotation = Quaternion.identity;
previewUtility.m_Camera.nearClipPlane = num - magnitude * 1.1f;
previewUtility.m_Camera.farClipPlane = num + magnitude * 1.1f;
Quaternion quaternion = Quaternion.identity;
Vector3 pos = -bounds.center;
bool fog = RenderSettings.fog;
Unsupported.SetRenderSettingsUseFogNoDirty(false);
int subMeshCount = mesh.subMeshCount;
int meshSubset = materials.Length;
if (materials != null && materials.Length > 0)
{
previewUtility.m_Camera.clearFlags = CameraClearFlags.Nothing;
if (meshSubset < 0 || meshSubset >= subMeshCount)
{
for (int i = 0; i < subMeshCount; i++)
{
previewUtility.DrawMesh(mesh, pos, quaternion, materials[i], i);
}
}
else
{
previewUtility.DrawMesh(mesh, pos, quaternion, materials[0], -1);
}
previewUtility.m_Camera.Render();
}
Unsupported.SetRenderSettingsUseFogNoDirty(fog);
}
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 void Render(Rect rect, Mesh mesh, Material mat = null)
{
if (e.type == EventType.Repaint)
{
previewUtility.BeginPreview(rect, GUIStyle.none);
{
previewUtility.DrawMesh(mesh, Vector3.zero, Quaternion.identity, mat, 0);
previewUtility.Render(true, true);
}
previewUtility.EndAndDrawPreview(rect);
}
}
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 void Draw(Rect r, GUIStyle background, int tileIndex)
{
previewRenderUtility.BeginPreview(r, background);
DrawPrefab(brush.tiles[tileIndex].prefabs[0].prefab, Vector3.zero, brush.tiles[tileIndex].rotation);
for (int i = 0; i < brush.tiles[tileIndex].rule.Length; i++)
{
int gridIndex = i > 3 ? i + 1 : i;
int x = gridIndex % 3;
int y = gridIndex / 3;
Matrix4x4 trs = Matrix4x4.TRS(new Vector3((x - 1) * brush.size, 0, (y - 1) * brush.size), Quaternion.identity, Vector3.one * brush.size);
Mesh mesh = null;
switch (brush.tiles[tileIndex].rule[i])
{
case Brush.NeighborState.Empty:
mesh = emptyMesh;
break;
case Brush.NeighborState.Filled:
mesh = fillMesh;
break;
case Brush.NeighborState.Undefined:
mesh = undefMesh;
break;
}
previewRenderUtility.DrawMesh(mesh, trs, mat, 0);
}
previewRenderUtility.camera.transform.position = Vector3.zero;
previewRenderUtility.camera.transform.rotation = Quaternion.Euler(new Vector3(-drag.y, -drag.x, 0));
previewRenderUtility.camera.transform.position = previewRenderUtility.camera.transform.forward * -cameraDistance;
previewRenderUtility.camera.Render();
previewRenderUtility.EndAndDrawPreview(r);
}
private void AddPreviewMeshFromHeightmap(Terrain terrain, IOnInspectorGUI editContext)
{
if (!brushPreview3d.IsValid())
{
return;
}
int previewSize = 256;
Texture2D heightmap = brushPreview3d.meshPreviewTexture;
Mesh mesh = brushPreview3d.mesh;
Material material = brushPreview3d.material;
Bounds bounds = mesh.bounds;
/* center view:
* m_PreviewUtility.camera.clearFlags = CameraClearFlags.Color;
*
* float halfSize = bounds.extents.magnitude;
* float distance = 2.0f * halfSize;
*
* m_PreviewUtility.camera.transform.position = -Vector3.forward * distance;
* m_PreviewUtility.camera.transform.rotation = Quaternion.identity;
* m_PreviewUtility.camera.nearClipPlane = distance - halfSize * 1.1f;
* m_PreviewUtility.camera.farClipPlane = distance + halfSize * 1.1f;
*
* m_PreviewUtility.lights[0].intensity = 1.4f;
* m_PreviewUtility.lights[0].transform.rotation = Quaternion.Euler(40f, 60f, 0);
* m_PreviewUtility.lights[1].intensity = 1.4f;
*
* //m_PreviewUtility.camera.transform.position += Vector3.up * distance;
* //m_PreviewUtility.camera.transform.LookAt(bounds.center);
*/
Rect previewRect = new Rect(0, 0, previewSize, previewSize);
this.m_PreviewUtility.BeginStaticPreview(previewRect);
float angle = m_BrushRotation;
Quaternion quaternion = Quaternion.Euler(0f, angle, 0f);
Vector3 pos = quaternion * -bounds.center;
m_PreviewUtility.DrawMesh(mesh, pos, quaternion, material, 0);
m_PreviewUtility.camera.Render();
Texture previewImage = this.m_PreviewUtility.EndStaticPreview();
// draw image as label
GUILayout.Label(previewImage);
}
private void DrawMeshPreview(Rect r, GUIStyle background)
{
if (targetMesh == null)
{
EditorGUI.DropShadowLabel(r, "Mesh Required");
}
else
{
// applying camera movement
meshPreviewUtility.m_Camera.transform.RotateAround(Vector3.zero, Vector3.up, drag.x);
meshPreviewUtility.m_Camera.transform.RotateAround(Vector3.zero, meshPreviewUtility.m_Camera.transform.right, drag.y);
meshPreviewUtility.m_Camera.transform.position +=
meshPreviewUtility.m_Camera.transform.forward * -zoom * meshMaxSize * ZOOM_SPEED +
meshPreviewUtility.m_Camera.transform.right * -pan.x * meshMaxSize * PAN_SPEED +
meshPreviewUtility.m_Camera.transform.up * -pan.y * meshMaxSize * PAN_SPEED;
meshPreviewUtility.BeginPreview(r, background);
// setting up the lights
meshPreviewUtility.m_Light[0].intensity = 1.4f;
meshPreviewUtility.m_Light[0].transform.rotation = Quaternion.Euler(60f, 0f, 60f);
meshPreviewUtility.m_Light[0].type = LightType.Directional;
meshPreviewUtility.m_Light[0].shadows = LightShadows.Hard;
InternalEditorUtility.SetCustomLighting(meshPreviewUtility.m_Light, new Color(0.1f, 0.1f, 0.1f, 0f));
// drawing the inspected mesh
for (int i = 0; i < targetMesh.subMeshCount; i++)
{
Material mat;
if (targetMeshRenderer.sharedMaterials.Length <= i)
{
mat = defaultMaterial;
}
else
{
mat = targetMeshRenderer.sharedMaterials[i];
if (mat == null)
{
mat = defaultMaterial;
}
}
meshPreviewUtility.DrawMesh(targetMesh, Matrix4x4.identity, mat, i);
}
meshPreviewUtility.m_Camera.Render();
InternalEditorUtility.RemoveCustomLighting();
meshPreviewUtility.EndAndDrawPreview(r);
}
}
public void DrawMesh(Material overrideMaterial = null, bool sphere = false)
{
if (backgroundTexture == null)
{
UpdatePreviewBackgroundColor();
}
// Make sure all objects are set up properly
if (previewIsSetUp == false)
{
SetupPreview();
}
UpdateRenderPath();
//SetCustomLight(on: true);
Mesh drawMesh = sphere ? sphereMesh : mesh;
float A = sphere ? rotMeshSphere.y : rotMeshSmooth.y;
float B = sphere ? rotMeshSphere.x : rotMeshSmooth.x;
Quaternion rotA = Quaternion.Euler(0f, A, 0f);
Quaternion rotB = Quaternion.Euler(B, 0f, 0f);
Quaternion finalRot = rotA * rotB;
camPivot.rotation = finalRot;
float meshExtents = drawMesh.bounds.extents.magnitude;
Vector3 pos = new Vector3(-drawMesh.bounds.center.x, -drawMesh.bounds.center.y, -drawMesh.bounds.center.z);
cam.transform.localPosition = new Vector3(0f, 0f, -3f * meshExtents);
int smCount = drawMesh.subMeshCount;
Material mat = (overrideMaterial == null) ? InternalMaterial : overrideMaterial;
for (int i = 0; i < smCount; i++)
{
previewRenderUtility.DrawMesh(drawMesh, Quaternion.identity * pos, Quaternion.identity, mat, i);
}
cam.farClipPlane = 3f * meshExtents * 2f;
cam.nearClipPlane = 0.1f;
cam.fieldOfView = sphere ? fovSphere : smoothFOV;
cam.Render();
if (sphere) // Reset if needed. // TODO: What?
{
cam.fieldOfView = smoothFOV;
}
}