public void CallUpdate()
{
if (_focusDist < 0)
{
_focusDist = 0;
}
if (_fstopIndex < 0 || _fstopIndex >= FStop.list.Length)
{
_fstopIndex = 0;
}
// Populate lens data
if (_lensFOVList == null)
{
ProCamsLensDataTable.FilmFormatData curFilmFormat = ProCamsLensDataTable.Instance.GetFilmFormat(_filmFormatName);
if (curFilmFormat != null)
{
ProCamsLensDataTable.LensKitData lensKitData = curFilmFormat.GetLensKitData(_lensKitIndex);
if (lensKitData != null)
{
// Set available lens data for this film format
_lensFOVList = lensKitData._fovDataset.ToArray();
}
}
}
if (_lensIndex < 0 || _lensIndex >= _lensFOVList.Length)
{
_lensIndex = 0;
}
UpdateTransforms();
NodalCamera.fieldOfView = _lensFOVList[_lensIndex]._unityVFOV;
UpdateDepthOfField();
}
/// <summary>
/// Updates the lists.
/// </summary>
private void UpdateLists()
{
// Film Formats
if (_ffList == null)
{
List <ProCamsLensDataTable.FilmFormatData> .Enumerator filmFormatList = ProCamsLensDataTable.Instance.FilmFormatDataEmumerator;
_ffList = new string[ProCamsLensDataTable.Instance.NumFilmFormats];
int i = 0;
while (filmFormatList.MoveNext())
{
ProCamsLensDataTable.FilmFormatData formatData = filmFormatList.Current;
_ffList[i] = formatData._formatName;
++i;
}
}
if (_fstopList == null)
{
_fstopList = new string[FStop.list.Length];
int num = FStop.list.Length;
for (int i = 0; i < num; ++i)
{
_fstopList[i] = FStop.list[i].name;
}
}
}
/// <summary>
/// Draws the lens kit field.
/// This field represents the lens manufacturer.
/// </summary>
private void DrawLensKitField()
{
if (_lensKitList == null)
{
ProCamsLensDataTable.FilmFormatData curFilmFormat = ProCamsLensDataTable.Instance.GetFilmFormat(_ffList[_currentFilmFormatIndex]);
if (curFilmFormat != null)
{
_lensKitList = new string[curFilmFormat._lensKits.Count];
int i = 0;
foreach (ProCamsLensDataTable.LensKitData lensData in curFilmFormat._lensKits)
{
_lensKitList[i] = lensData._lensKit.Replace("/", "");
++i;
}
_lensKitIndex = 0;
_lensList = null;
_lensIndex = 0;
}
}
if (_lensKitList != null)
{
int newLensIndex = EditorGUILayout.Popup("Lens Kit", _lensKitIndex, _lensKitList);
if (newLensIndex != _lensKitIndex)
{
_lensList = null;
_lensIndex = 0;
}
}
}
/// <summary>
/// Draws the definition field.
/// </summary>
private void DrawScreenSizeField()
{
if (_resolutionList == null)
{
ProCamsLensDataTable.FilmFormatData curFilmFormatData = ProCamsLensDataTable.Instance.GetFilmFormat(_ffList[_currentFilmFormatIndex]);
if (curFilmFormatData != null)
{
int numSizes = curFilmFormatData._screenSizes.Count;
_resolutionList = new string[numSizes];
for (int i = 0; i < numSizes; ++i)
{
_resolutionList[i] = curFilmFormatData._screenSizes[i].name;
}
}
}
if (_resolutionList != null)
{
int newResIndex = EditorGUILayout.Popup("Screen Size (px)", _currentScreenSizeIndex, _resolutionList);
if (newResIndex != _currentScreenSizeIndex)
{
_currentScreenSizeIndex = newResIndex;
UpdateFOV();
}
}
}
// Populate lens data
void PopulateLens()
{
ProCamsLensDataTable.FilmFormatData curFilmFormat = ProCamsLensDataTable.Instance.GetFilmFormat(_filmFormatName.stringValue);
if (curFilmFormat != null)
{
if (_lensKitIndex.intValue < 0 || _lensKitIndex.intValue > curFilmFormat._lensKits.Count)
{
_lensKitIndex.intValue = 0;
}
ProCamsLensDataTable.LensKitData lensKitData = curFilmFormat.GetLensKitData(_lensKitIndex.intValue);
if (lensKitData != null)
{
// Set available lens data for this film format
cb.LensFOVList = lensKitData._fovDataset.ToArray();
if (_lensIndex.intValue < 0 || _lensIndex.intValue > cb.LensFOVList.Length)
{
_lensIndex.intValue = 0;
}
}
// Populate lens names
int numLenses = lensKitData._fovDataset.Count;
_lensOptions = new string[numLenses];
for (int i = 0; i < numLenses; ++i)
{
_lensOptions[i] = lensKitData._fovDataset[i]._focalLength + "mm";
}
}
}
private void DrawAspectRatioField()
{
ProCamsLensDataTable.FilmFormatData curFilmFormatData = ProCamsLensDataTable.Instance.GetFilmFormat(_filmFormatName.stringValue);
if (curFilmFormatData != null)
{
EditorGUILayout.LabelField("Aspect Ratio: ", curFilmFormatData._aspect.ToString());
}
}
void OnEnable()
{
_unitOfMeasure = serializedObject.FindProperty("_unitOfMeasure");
_rigTransform = serializedObject.FindProperty("_rigTransform");
_description = serializedObject.FindProperty("_cameraDesc");
_lensKitName = serializedObject.FindProperty("_lensKitName");
_lensKitIndex = serializedObject.FindProperty("_lensKitIndex");
_lensIndex = serializedObject.FindProperty("_lensIndex");
_fstopIndex = serializedObject.FindProperty("_fstopIndex");
_focusDistance = serializedObject.FindProperty("_focusDist");
_dofDistTotal = serializedObject.FindProperty("_dofDistTotal");
_dofNearLimit = serializedObject.FindProperty("_dofNearLimit");
_dofFarLimit = serializedObject.FindProperty("_dofFarLimit");
_focusTransform = serializedObject.FindProperty("_focusTransform");
_clickToFocus = serializedObject.FindProperty("_clickToFocus");
_centerOnSubject = serializedObject.FindProperty("_centerOnSubject");
_fpOffset = serializedObject.FindProperty("_fpOffset");
_showGizmos = serializedObject.FindProperty("_showGizmos");
_filmFormatName = serializedObject.FindProperty("_filmFormatName");
_screenSizeName = serializedObject.FindProperty("_screenSizeName");
cb = target as CameraBody;
// Populate film formats
List <ProCamsLensDataTable.FilmFormatData> .Enumerator filmFormatList = ProCamsLensDataTable.Instance.FilmFormatDataEmumerator;
_ffList = new string[ProCamsLensDataTable.Instance.NumFilmFormats];
int i = 0;
while (filmFormatList.MoveNext())
{
ProCamsLensDataTable.FilmFormatData formatData = filmFormatList.Current;
_ffList[i] = formatData._formatName;
if (_filmFormatName.stringValue == formatData._formatName)
{
_currentFilmFormatIndex = i;
}
++i;
}
PopulateLens();
// Populate FStop options
_fstopOptions = new string[FStop.list.Length];
int num = FStop.list.Length;
for (i = 0; i < num; ++i)
{
_fstopOptions[i] = FStop.list[i].name;
}
if (UnityEditorInternal.InternalEditorUtility.HasPro())
{
CameraBody.CameraPreview =
new RenderTexture(
PlayerSettings.defaultScreenWidth,
PlayerSettings.defaultScreenHeight,
(int)RenderTextureFormat.ARGB32);
}
}
/// <summary>
/// Creates the camera body.
///
/// Create all the child nodes for the camera body such as film plane, nodal point and focus object.
/// Once created, it will update the CameraBody script with the inputed data.
/// </summary>
private GameObject CreateCameraBody()
{
SceneView sv = SceneView.lastActiveSceneView;
GameObject go = new GameObject();
Undo.RegisterCreatedObjectUndo(go, "Created Camera");
go.AddComponent <CameraBody>();
//string lensKitName = "";
ProCamsLensDataTable.FilmFormatData curFilmFormat = ProCamsLensDataTable.Instance.GetFilmFormat(_ffList[_currentFilmFormatIndex]);
if (curFilmFormat != null)
{
ProCamsLensDataTable.LensKitData lensKitData = curFilmFormat.GetLensKitData(_lensKitIndex);
if (lensKitData != null)
{
//lensKitName = lensKitData._lensKit.Replace(",","");
}
}
Transform jt = go.transform;
// The Nodal Point transform which holds the Camera and DOF components
//GameObject nodalPoint = new GameObject(_cameraName);
//nodalPoint.transform.parent = jt;
//nodalPoint.transform.position = Vector3.zero;
if (sv != null)
{
Transform ct = sv.camera.transform;
jt.rotation = ct.rotation;
jt.position = ct.position;
}
//Camera cbNodalCamera = nodalPoint.AddComponent<Camera>();
Camera cbNodalCamera = go.GetComponent <Camera>();
if (cbNodalCamera == null)
{
go.AddComponent <Camera>();
go.AddComponent <CSDOFScatter>();
}
cbNodalCamera.nearClipPlane = 0.01f;
//cbNodalCamera.cullingMask = ~(1<<8);
return(go);
}
void Start()
{
// Populate lens data
ProCamsLensDataTable.FilmFormatData curFilmFormat = ProCamsLensDataTable.Instance.GetFilmFormat(_filmFormatName);
if (curFilmFormat != null)
{
ProCamsLensDataTable.LensKitData lensKitData = curFilmFormat.GetLensKitData(_lensKitIndex);
if (lensKitData != null)
{
// Set available lens data for this film format
_lensFOVList = lensKitData._fovDataset.ToArray();
}
}
}
private void DrawHFOVField()
{
//float unityHFOV = 0;
float realHFOV = 0;
ProCamsLensDataTable.FilmFormatData curFilmFormatData = ProCamsLensDataTable.Instance.GetFilmFormat(_filmFormatName.stringValue);
if (curFilmFormatData != null)
{
//float ar = curFilmFormatData._aspect;
//unityHFOV = Mathf.Floor(Lens.GetHorizontalFOV(ar, cb.LensFOVList[cb.IndexOfLens]._unityVFOV) * 100) / 100;
realHFOV = Mathf.Floor(cb.LensFOVList[cb.IndexOfLens]._realHFOV * 100) / 100f;
}
EditorGUILayout.LabelField("Real Horizontal FOV", "" + realHFOV + " degrees (film plane)");
//EditorGUILayout.LabelField("Unity Horizontal FOV", "" + unityHFOV + " degrees (nodal pt)");
}
/// <summary>
/// Draws the lens field.
/// It will include a popup for the lens length and labels for offset and hfov
/// </summary>
private void DrawLensField()
{
List <string> hfovList = new List <string>();
List <string> offsetList = new List <string>();
ProCamsLensDataTable.FilmFormatData curFilmFormat = ProCamsLensDataTable.Instance.GetFilmFormat(_ffList[_currentFilmFormatIndex]);
if (curFilmFormat != null)
{
ProCamsLensDataTable.LensKitData lensKit = curFilmFormat.GetLensKitData(_lensKitIndex);
if (lensKit != null)
{
if (_lensList == null)
{
_lensList = new string[lensKit._fovDataset.Count];
int i = 0;
foreach (ProCamsLensDataTable.FOVData fovData in lensKit._fovDataset)
{
_lensList[i] = fovData._focalLength + "mm";
++i;
}
}
foreach (ProCamsLensDataTable.FOVData fovData in lensKit._fovDataset)
{
//float hfov = Lens.GetHorizontalFOV(curFilmFormat._aspect, fovData._unityVFOV);
// Rounding to two decimal places
//hfov = Mathf.Floor(hfov * 100) / 100f;
//hfovList.Add ("" + hfov);
float hfov = Mathf.Floor(fovData._realHFOV * 100) / 100f;
hfovList.Add(hfov.ToString());
offsetList.Add("" + fovData._nodalOffset);
}
}
}
_lensIndex = EditorGUILayout.Popup("Lenses", _lensIndex, _lensList);
//GUILayout.Space(20f);
DrawNodalPointOffsetField(offsetList[_lensIndex]);
DrawHFOVField(hfovList[_lensIndex]);
}
private void UpdateFOV()
{
ProCamsLensDataTable.FilmFormatData curFilmFormat = ProCamsLensDataTable.Instance.GetFilmFormat(_ffList[_currentFilmFormatIndex]);
if (curFilmFormat != null)
{
if (_currentScreenSizeIndex > curFilmFormat._screenSizes.Count)
{
_currentScreenSizeIndex = 0;
}
if (curFilmFormat._aspect != 0)
{
ScreenSize ss = curFilmFormat._screenSizes[_currentScreenSizeIndex];
float scaleFactor = ss.width / curFilmFormat._aspect;
PlayerSettings.defaultScreenHeight = (int)(scaleFactor + 0.5f);
PlayerSettings.defaultScreenWidth = (int)(curFilmFormat._aspect * scaleFactor + 0.5f);
}
}
}
/// <summary>
/// Create the camera body script.
/// </summary>
/// <param name='go'>
/// CameraBody GameObject. The root node GameObject.
/// </param>
private CameraBody SetupCameraBodyScript(GameObject go)
{
CameraBody cb = go.GetComponent <CameraBody>();
ProCamsLensDataTable.FilmFormatData curFilmFormat = ProCamsLensDataTable.Instance.GetFilmFormat(_ffList[_currentFilmFormatIndex]);
cb.FilmFormatName = curFilmFormat._formatName;
if (curFilmFormat != null)
{
cb.ScreenSizeName = ProCamsLensDataTable.Instance.GetScreenSize(curFilmFormat, _resolutionList[_currentScreenSizeIndex]).name;
ProCamsLensDataTable.LensKitData lensKitData = curFilmFormat.GetLensKitData(_lensKitIndex);
if (lensKitData != null)
{
cb.LensKitName = lensKitData._lensKit;
cb.IndexOfLensKit = _lensKitIndex;
cb.LensFOVList = lensKitData._fovDataset.ToArray();
cb.IndexOfLens = _lensIndex;
}
}
cb.UnitOfMeasure = _unitOfMeasure;
// Depth of field
cb.IndexOfFStop = _fstopIndex;
cb.FocusDistance = _focusDistance;
// Camera Description
cb.CameraSpecs = ", " + cb.LensKitName;
cb.CameraSpecs = cb.CameraSpecs.Replace("/", "");
// Camera Name
cb.CameraDescription = _cameraName;
go.name = cb.CameraDescription;// +cb.CameraSpecs;
// Rig
cb.RigTransform = _rigTransform;
return(cb);
}
public void drawFrustum(Color frustumColor, Color focusColor, Color dofColor)
{
if (!frustumInitialized)
{
lineMaterial = new Material(Shader.Find("Particles/Additive"));
GameObject rig;
ElPresidente.createdGameObjects.TryGet("Rig", out rig);
int cameraFrustumLayerId = LayerMask.NameToLayer("CameraFrustum");
//make some line rendering game objects
frustumLines = new GameObject[7];
frustumLineRenderers = new LineRenderer[7];
for (int i = 0; i < 7; i++)
{
frustumLines[i] = new GameObject();
frustumLines[i].transform.SetParent(rig.transform);
frustumLines[i].transform.localPosition = Vector3.zero;
frustumLines[i].transform.localRotation = Quaternion.identity;
frustumLines[i].layer = cameraFrustumLayerId;
var lineRenderer = frustumLines[i].AddComponent <LineRenderer>();
lineRenderer.SetWidth(0.5f, 0.5f);
lineRenderer.useWorldSpace = false;
lineRenderer.material = lineMaterial;
lineRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
frustumLineRenderers[i] = lineRenderer;
}
//set up frustum edges
for (int i = 0; i < 4; i++)
{
frustumLineRenderers[i].SetColors(Color.white, Color.white);
frustumLineRenderers[i].SetVertexCount(2);
}
//set up the far and near dof planes and focus plane
frustumLineRenderers[4].SetColors(dofColor, dofColor);
frustumLineRenderers[4].SetVertexCount(8);
frustumLineRenderers[5].SetColors(dofColor, dofColor);
frustumLineRenderers[5].SetVertexCount(8);
frustumLineRenderers[6].SetColors(focusColor, focusColor);
frustumLineRenderers[6].SetVertexCount(8);
frustumInitialized = true;
}
float dofNearM = _dofNearLimit * 0.3048f; // feet to meters
float dofFarM = _dofFarLimit * 0.3048f; // feet to meters
float dofFocusM = _focusDist; // feet to meters
if (_unitOfMeasure == UnitOfMeasure.Imperial)
{
dofNearM = _dofNearLimit * 0.3048f; // feet to meters
dofFarM = _dofFarLimit * 0.3048f; // feet to meters
dofFocusM = _focusDist * 0.3048f; // feet to meters
}
Transform camTransform = _nodalCamera.transform;
//Gizmos.matrix = Matrix4x4.TRS(
//camTransform.position, camTransform.rotation, camTransform.lossyScale);
Vector3 toNear = Vector3.forward * dofNearM;
Vector3 toFar = Vector3.forward * dofFarM;
Vector3 toFocus = Vector3.forward * dofFocusM;
Vector3 toNearClip = Vector3.forward * _nodalCamera.nearClipPlane;
Vector3 toFarClip = Vector3.forward * _nodalCamera.farClipPlane;
float fov = 0;
ProCamsLensDataTable.FilmFormatData curFilmFormat = ProCamsLensDataTable.Instance.GetFilmFormat(_filmFormatName);
if (curFilmFormat != null)
{
fov = Lens.GetHorizontalFOV(curFilmFormat._aspect, _lensFOVList[_lensIndex]._unityVFOV);
}
float ang = Mathf.Tan(Mathf.Deg2Rad * (fov / 2f));
float oppNear = ang * dofNearM;
float oppFar = ang * dofFarM;
float oppFocus = ang * dofFocusM;
float oppNearClip = ang * _nodalCamera.nearClipPlane;
float oppFarClip = ang * _nodalCamera.farClipPlane;
Vector3 toNearR = Vector3.right * oppNear;
Vector3 toFarR = Vector3.right * oppFar;
Vector3 toFocusR = Vector3.right * oppFocus;
Vector3 toNearClipR = Vector3.right * oppNearClip;
Vector3 toFarClipR = Vector3.right * oppFarClip;
fov = _lensFOVList[_lensIndex]._unityVFOV;
ang = Mathf.Tan(Mathf.Deg2Rad * (fov / 2f));
oppNear = ang * dofNearM;
oppFar = ang * dofFarM;
oppFocus = ang * dofFocusM;
oppNearClip = ang * _nodalCamera.nearClipPlane;
oppFarClip = ang * _nodalCamera.farClipPlane;
Vector3 toNearT = Vector3.up * oppNear;
Vector3 toFarT = Vector3.up * oppFar;
Vector3 toFocusT = Vector3.up * oppFocus;
Vector3 toNearClipT = Vector3.up * oppNearClip;
Vector3 toFarClipT = Vector3.up * oppFarClip;
// Calculate all the points (L = Left, R = Right, T = top, B = bottom)
Vector3 nearLB = toNear - toNearR - toNearT;
Vector3 nearLT = toNear - toNearR + toNearT;
Vector3 nearRB = toNear + toNearR - toNearT;
Vector3 nearRT = toNear + toNearR + toNearT;
Vector3 focusLB = toFocus - toFocusR - toFocusT;
Vector3 focusLT = toFocus - toFocusR + toFocusT;
Vector3 focusRB = toFocus + toFocusR - toFocusT;
Vector3 focusRT = toFocus + toFocusR + toFocusT;
Vector3 farLB = toFar - toFarR - toFarT;
Vector3 farLT = toFar - toFarR + toFarT;
Vector3 farRB = toFar + toFarR - toFarT;
Vector3 farRT = toFar + toFarR + toFarT;
Vector3 nearCLB = toNearClip - toNearClipR - toNearClipT;
Vector3 nearCLT = toNearClip - toNearClipR + toNearClipT;
Vector3 nearCRB = toNearClip + toNearClipR - toNearClipT;
Vector3 nearCRT = toNearClip + toNearClipR + toNearClipT;
Vector3 farCLB = toFarClip - toFarClipR - toFarClipT;
Vector3 farCLT = toFarClip - toFarClipR + toFarClipT;
Vector3 farCRB = toFarClip + toFarClipR - toFarClipT;
Vector3 farCRT = toFarClip + toFarClipR + toFarClipT;
// camera frustum
frustumLineRenderers[0].SetPositions(new Vector3[] { nearCLB, farCLB });
frustumLineRenderers[1].SetPositions(new Vector3[] { nearCRB, farCRB });
frustumLineRenderers[2].SetPositions(new Vector3[] { nearCLT, farCLT });
frustumLineRenderers[3].SetPositions(new Vector3[] { nearCRT, farCRT });
// near dof rectangle
frustumLineRenderers[4].SetPositions(new Vector3[]
{
nearLB, nearRB,
nearRB, nearRT,
nearRT, nearLT,
nearLT, nearLB
});
if (_dofFarLimit >= 0)
{
// far rectangle
frustumLineRenderers[5].SetPositions(new Vector3[]
{
farLB, farRB,
farRB, farRT,
farRT, farLT,
farLT, farLB
});
}
// focus rectangle
frustumLineRenderers[6].SetPositions(new Vector3[]
{
focusLB, focusRB,
focusRB, focusRT,
focusRT, focusLT,
focusLT, focusLB
});
}
/// <summary>
/// Draws the depth of field field.
/// </summary>
private void DrawDepthOfFieldField()
{
float F, f, H, S, DN, DF, D, TI, NI, FI;
//float focalLength = ProCamsDataTable.list[_lensKitIndex].lenses[_lensIndex].length;
float focalLength = 0;
ProCamsLensDataTable.FilmFormatData curFilmFormat = ProCamsLensDataTable.Instance.GetFilmFormat(_ffList[_currentFilmFormatIndex]);
if (curFilmFormat != null)
{
ProCamsLensDataTable.FOVData fovData = curFilmFormat.GetFOVData(_lensKitIndex, _lensIndex);
if (fovData != null)
{
focalLength = fovData._focalLength;
}
}
F = ProCamsUtility.Convert(
focalLength,
Units.Millimeter, // from mm
Units.Inch); // to inches
f = FStop.list[_fstopIndex].fstop;
H = (F * F) / (f * 0.001f); // 0.001 = Circle of Confusion
if (_unitOfMeasure == UnitOfMeasure.Imperial)
{
S = ProCamsUtility.Convert(_focusDistance, Units.Foot, Units.Inch);
}
else
{
S = ProCamsUtility.Convert(_focusDistance, Units.Meter, Units.Inch);
}
DN = (H * S) / (H + (S - F)); // near depth of field
DF = (H * S) / (H - (S - F)); // far depth of field
D = DF - DN; // depth of field
if (_unitOfMeasure == UnitOfMeasure.Imperial)
{
// rounding to two decimal places
D = ProCamsUtility.Convert(D, Units.Inch, Units.Foot); // from inches to feet
D = Mathf.Floor(D * 100) / 100f;
DN = ProCamsUtility.Convert(DN, Units.Inch, Units.Foot);
DN = Mathf.Floor(DN * 100) / 100f;
DF = ProCamsUtility.Convert(DF, Units.Inch, Units.Foot);
DF = Mathf.Floor(DF * 100) / 100f;
TI = Mathf.Floor(
ProCamsUtility.Convert(
D - Mathf.Floor(D),
Units.Foot,
Units.Inch));
NI = Mathf.Floor(
ProCamsUtility.Convert(
DN - Mathf.Floor(DN),
Units.Foot,
Units.Inch));
FI = Mathf.Floor(
ProCamsUtility.Convert(
DF - Mathf.Floor(DF),
Units.Foot,
Units.Inch));
D = Mathf.Floor(D);
DN = Mathf.Floor(DN);
DF = Mathf.Floor(DF);
if (D >= 0)
{
EditorGUILayout.LabelField("Depth of Field", "" + D + "' " + TI + "\"");
}
else
{
EditorGUILayout.LabelField("Depth of Field", "INF");
}
EditorGUILayout.LabelField("Near Depth", "" + DN + "' " + NI + "\"");
if (DF >= 0)
{
EditorGUILayout.LabelField("Far Depth", "" + DF + "' " + FI + "\"");
}
else
{
EditorGUILayout.LabelField("Far Depth", "INF");
}
}
else
{
float dof = ProCamsUtility.Convert(D, Units.Inch, Units.Meter);
float dn = ProCamsUtility.Convert(DN, Units.Inch, Units.Meter);
float df = ProCamsUtility.Convert(DF, Units.Inch, Units.Meter);
if (D >= 0)
{
EditorGUILayout.LabelField("Depth of Field", dof.ToString("0.00") + "m");
}
else
{
EditorGUILayout.LabelField("Depth of Field", "INF");
}
EditorGUILayout.LabelField("Near Depth", dn.ToString("0.00") + "m");
if (DF >= 0)
{
EditorGUILayout.LabelField("Far Depth", df.ToString("0.00") + "m");
}
else
{
EditorGUILayout.LabelField("Far Depth", "INF");
}
}
}
/// <summary>
/// Raises the draw gizmos event.
///
/// Will draw the camera frustum along with the near,focus and far planes.
/// </summary>
void OnDrawGizmos()
{
// Draw Near Plane Line
if (_showGizmos && _lensFOVList != null)
{
float dofNearM = _dofNearLimit * 0.3048f; // feet to meters
float dofFarM = _dofFarLimit * 0.3048f; // feet to meters
float dofFocusM = _focusDist; // feet to meters
if (_unitOfMeasure == UnitOfMeasure.Imperial)
{
dofNearM = _dofNearLimit * 0.3048f; // feet to meters
dofFarM = _dofFarLimit * 0.3048f; // feet to meters
dofFocusM = _focusDist * 0.3048f; // feet to meters
}
Transform camTransform = _nodalCamera.transform;
Gizmos.matrix = Matrix4x4.TRS(
camTransform.position, camTransform.rotation, camTransform.lossyScale);
Vector3 toNear = Vector3.forward * dofNearM;
Vector3 toFar = Vector3.forward * dofFarM;
Vector3 toFocus = Vector3.forward * dofFocusM;
Vector3 toNearClip = Vector3.forward * _nodalCamera.nearClipPlane;
Vector3 toFarClip = Vector3.forward * _nodalCamera.farClipPlane;
float fov = 0;
ProCamsLensDataTable.FilmFormatData curFilmFormat = ProCamsLensDataTable.Instance.GetFilmFormat(_filmFormatName);
if (curFilmFormat != null)
{
fov = Lens.GetHorizontalFOV(curFilmFormat._aspect, _lensFOVList[_lensIndex]._unityVFOV);
}
float ang = Mathf.Tan(Mathf.Deg2Rad * (fov / 2f));
float oppNear = ang * dofNearM;
float oppFar = ang * dofFarM;
float oppFocus = ang * dofFocusM;
float oppNearClip = ang * _nodalCamera.nearClipPlane;
float oppFarClip = ang * _nodalCamera.farClipPlane;
Vector3 toNearR = Vector3.right * oppNear;
Vector3 toFarR = Vector3.right * oppFar;
Vector3 toFocusR = Vector3.right * oppFocus;
Vector3 toNearClipR = Vector3.right * oppNearClip;
Vector3 toFarClipR = Vector3.right * oppFarClip;
fov = _lensFOVList[_lensIndex]._unityVFOV;
ang = Mathf.Tan(Mathf.Deg2Rad * (fov / 2f));
oppNear = ang * dofNearM;
oppFar = ang * dofFarM;
oppFocus = ang * dofFocusM;
oppNearClip = ang * _nodalCamera.nearClipPlane;
oppFarClip = ang * _nodalCamera.farClipPlane;
Vector3 toNearT = Vector3.up * oppNear;
Vector3 toFarT = Vector3.up * oppFar;
Vector3 toFocusT = Vector3.up * oppFocus;
Vector3 toNearClipT = Vector3.up * oppNearClip;
Vector3 toFarClipT = Vector3.up * oppFarClip;
// Calculate all the points (L = Left, R = Right, T = top, B = bottom)
Vector3 nearLB = toNear - toNearR - toNearT;
Vector3 nearLT = toNear - toNearR + toNearT;
Vector3 nearRB = toNear + toNearR - toNearT;
Vector3 nearRT = toNear + toNearR + toNearT;
Vector3 focusLB = toFocus - toFocusR - toFocusT;
Vector3 focusLT = toFocus - toFocusR + toFocusT;
Vector3 focusRB = toFocus + toFocusR - toFocusT;
Vector3 focusRT = toFocus + toFocusR + toFocusT;
Vector3 farLB = toFar - toFarR - toFarT;
Vector3 farLT = toFar - toFarR + toFarT;
Vector3 farRB = toFar + toFarR - toFarT;
Vector3 farRT = toFar + toFarR + toFarT;
Vector3 nearCLB = toNearClip - toNearClipR - toNearClipT;
Vector3 nearCLT = toNearClip - toNearClipR + toNearClipT;
Vector3 nearCRB = toNearClip + toNearClipR - toNearClipT;
Vector3 nearCRT = toNearClip + toNearClipR + toNearClipT;
Vector3 farCLB = toFarClip - toFarClipR - toFarClipT;
Vector3 farCLT = toFarClip - toFarClipR + toFarClipT;
Vector3 farCRB = toFarClip + toFarClipR - toFarClipT;
Vector3 farCRT = toFarClip + toFarClipR + toFarClipT;
Gizmos.color = Color.white;
// far clip rectangle
Gizmos.DrawLine(farCLB, farCRB);
Gizmos.DrawLine(farCLT, farCRT);
Gizmos.DrawLine(farCLB, farCLT);
Gizmos.DrawLine(farCRB, farCRT);
// camera frustum
Gizmos.DrawLine(nearCLB, farCLB);
Gizmos.DrawLine(nearCRB, farCRB);
Gizmos.DrawLine(nearCLT, farCLT);
Gizmos.DrawLine(nearCRT, farCRT);
// near rectangle
Gizmos.color = Color.cyan;
Gizmos.DrawLine(nearLB, nearRB);
Gizmos.DrawLine(nearLB, nearLT);
Gizmos.DrawLine(nearLT, nearRT);
Gizmos.DrawLine(nearRB, nearRT);
if (_dofFarLimit >= 0)
{
// far rectangle
Gizmos.DrawLine(farLB, farRB);
Gizmos.DrawLine(farLT, farRT);
Gizmos.DrawLine(farLB, farLT);
Gizmos.DrawLine(farRB, farRT);
// dof frustum
Gizmos.DrawLine(nearLB, farLB);
Gizmos.DrawLine(nearRB, farRB);
Gizmos.DrawLine(nearLT, farLT);
Gizmos.DrawLine(nearRT, farRT);
}
// focus rectangle
Gizmos.color = Color.yellow;
Gizmos.DrawLine(focusLB, focusLT);
Gizmos.DrawLine(focusLB, focusRB);
Gizmos.DrawLine(focusRB, focusRT);
Gizmos.DrawLine(focusLT, focusRT);
Gizmos.DrawLine(Vector3.zero, toFocus);
//Gizmos.matrix = Matrix4x4.TRS(
//transform.position, transform.rotation, transform.lossyScale);
if (ShowBody)
{
Gizmos.color = Color.green;
Gizmos.DrawWireCube(
Vector3.zero, new Vector3(0.01f, 0.01f, 0.02f));
Gizmos.DrawWireCube(Vector3.forward * -0.1f, new Vector3(0.05f, 0.08f, 0.175f));
}
}
}
static void DrawFieldOfViewMarkers(Transform transform, GizmoType gizmoType)
{
CameraBody cb = transform.GetComponent <CameraBody>();
ProCamsLensDataTable.FilmFormatData curFilmFormat = null;
if (cb != null)
{
curFilmFormat = ProCamsLensDataTable.Instance.GetFilmFormat(cb.FilmFormatName);
}
if (curFilmFormat != null && cb != null && cb.ShowGizmos && cb.LensFOVList[cb.IndexOfLens] != null)
{
float aspect = curFilmFormat._aspect;
GUIStyle style = new GUIStyle();
style.normal.textColor = new Color(0, 60, 160, 255);
float nearInches = Mathf.Floor((cb.DOFNearLimit - Mathf.Floor(cb.DOFNearLimit)) * 12);
float nearFeet = Mathf.Floor(cb.DOFNearLimit);
Transform ct = cb.NodalCamera.transform;
Matrix4x4 oldMatrix = Handles.matrix;
Handles.matrix = Matrix4x4.TRS(ct.position, ct.rotation, ct.lossyScale);
if (cb.UnitOfMeasure == UnitOfMeasure.Imperial)
{
Vector3 dofNearPos = Vector3.forward * cb.DOFNearLimit * 0.3048f + Vector3.left *
((cb.DOFNearLimit * aspect) / cb.LensFOVList[cb.IndexOfLens]._focalLength);
Vector3 dofFarPos = Vector3.forward * cb.DOFFarLimit * 0.3048f + Vector3.left *
((cb.DOFFarLimit * aspect) / cb.LensFOVList[cb.IndexOfLens]._focalLength);
Vector3 dofFocusPos = Vector3.forward * cb.FocusDistance * 0.3048f;
Handles.Label(dofNearPos, "" + nearFeet + "' " + nearInches + "\"", style);
float farInches = Mathf.Floor((cb.DOFFarLimit - Mathf.Floor(cb.DOFFarLimit)) * 12);
float farFeet = Mathf.Floor(cb.DOFFarLimit);
if (cb.DOFFarLimit >= 0)
{
Handles.Label(dofFarPos, "" + farFeet + "' " + farInches + "\"", style);
}
style.normal.textColor = Color.yellow;
float dofInches = Mathf.Floor((cb.FocusDistance - Mathf.Floor(cb.FocusDistance)) * 12);
float dofFeet = Mathf.Floor(cb.FocusDistance);
Handles.Label(dofFocusPos, "" + dofFeet + "' " + dofInches + "\"", style);
}
else
{
Vector3 dofNearPos = Vector3.forward * cb.DOFNearLimit * 0.3048f + Vector3.left *
((cb.DOFNearLimit * aspect) / cb.LensFOVList[cb.IndexOfLens]._focalLength);
Vector3 dofFarPos = Vector3.forward * cb.DOFFarLimit * 0.3048f + Vector3.left *
((cb.DOFFarLimit * aspect) / cb.LensFOVList[cb.IndexOfLens]._focalLength);
Vector3 dofFocusPos = Vector3.forward * cb.FocusDistance;
Handles.Label(dofNearPos, (cb.DOFNearLimit * 0.3048f).ToString("0.00") + "m", style);
//float farInches = Mathf.Floor((cb.DOFFarLimit - Mathf.Floor(cb.DOFFarLimit)) * 12);
//float farFeet = Mathf.Floor(cb.DOFFarLimit);
if (cb.DOFFarLimit >= 0)
{
Handles.Label(dofFarPos, (cb.DOFFarLimit * 0.3048f).ToString("0.00") + "m", style);
}
style.normal.textColor = Color.yellow;
Handles.Label(dofFocusPos, cb.FocusDistance.ToString("0.00") + "m", style);
}
Handles.matrix = oldMatrix;
}
}
