henrisel/DeltaVR3DModelGeneration
1
0
Fork 0
forked from cgvr/DeltaVR
Code Pull Requests Activity

Initial Commit

Browse Source
This commit is contained in:
Toomas Tamm
2020-11-28 16:54:41 +02:00
parent 97292ee26e
commit ea967135f2
4217 changed files with 2945663 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
Assets/Oculus/VR/Scripts/Editor/OVRCustomSkeletonEditor.cs Normal file
View File

@@ -0,0 +1,80 @@
/************************************************************************************
Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
Licensed under the Oculus Master SDK License Version 1.0 (the "License"); you may not use
the Utilities SDK except in compliance with the License, which is provided at the time of installation
or download, or which otherwise accompanies this software in either electronic or hard copy form.
You may obtain a copy of the License at
https://developer.oculus.com/licenses/oculusmastersdk-1.0/
Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
ANY KIND, either express or implied. See the License for the specific language governing
permissions and limitations under the License.
************************************************************************************/
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using UnityEditor.SceneManagement;
using BoneId = OVRSkeleton.BoneId;
[CustomEditor(typeof(OVRCustomSkeleton))]
public class OVRCustomSkeletonEditor : Editor
{
public override void OnInspectorGUI()
{
DrawPropertiesExcluding(serializedObject, new string[] { "_customBones" });
serializedObject.ApplyModifiedProperties();
OVRCustomSkeleton skeleton = (OVRCustomSkeleton)target;
OVRSkeleton.SkeletonType skeletonType = skeleton.GetSkeletonType();
if (skeletonType == OVRSkeleton.SkeletonType.None)
{
EditorGUILayout.HelpBox("Please select a SkeletonType.", MessageType.Warning);
}
else
{
if (GUILayout.Button("Auto Map Bones"))
{
skeleton.TryAutoMapBonesByName();
EditorUtility.SetDirty(skeleton);
EditorSceneManager.MarkSceneDirty(skeleton.gameObject.scene);
}
EditorGUILayout.LabelField("Bones", EditorStyles.boldLabel);
BoneId start = skeleton.GetCurrentStartBoneId();
BoneId end = skeleton.GetCurrentEndBoneId();
if (start != BoneId.Invalid && end != BoneId.Invalid)
{
for (int i = (int)start; i < (int)end; ++i)
{
string boneName = BoneLabelFromBoneId((BoneId)i);
skeleton.CustomBones[i] = (Transform)EditorGUILayout.ObjectField(boneName, skeleton.CustomBones[i], typeof(Transform), true);
}
}
}
}
// force aliased enum values to the more appropriate value
private static string BoneLabelFromBoneId(BoneId boneId)
{
if (boneId == BoneId.Hand_Start)
{
return "Hand_WristRoot";
}
else if (boneId == BoneId.Hand_MaxSkinnable)
{
return "Hand_ThumbTip";
}
else
{
return boneId.ToString();
}
}
}

11
Assets/Oculus/VR/Scripts/Editor/OVRCustomSkeletonEditor.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 48b4582957a398741abd6d10bcb62042
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

159
Assets/Oculus/VR/Scripts/Editor/OVREditorUtil.cs Normal file
View File

@@ -0,0 +1,159 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.Diagnostics;
public static class OVREditorUtil {
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupBoolField(Object target, string name, ref bool member, ref bool modified)
{
SetupBoolField(target, new GUIContent(name), ref member, ref modified);
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupBoolField(Object target, GUIContent name, ref bool member, ref bool modified)
{
EditorGUI.BeginChangeCheck();
bool value = EditorGUILayout.Toggle(name, member);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Changed " + name);
member = value;
modified = true;
}
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupIntField(Object target, string name, ref int member, ref bool modified)
{
SetupIntField(target, new GUIContent(name), ref member, ref modified);
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupIntField(Object target, GUIContent name, ref int member, ref bool modified)
{
EditorGUI.BeginChangeCheck();
int value = EditorGUILayout.IntField(name, member);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Changed " + name);
member = value;
modified = true;
}
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupFloatField(Object target, string name, ref float member, ref bool modified)
{
SetupFloatField(target, new GUIContent(name), ref member, ref modified);
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupFloatField(Object target, GUIContent name, ref float member, ref bool modified)
{
EditorGUI.BeginChangeCheck();
float value = EditorGUILayout.FloatField(name, member);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Changed " + name);
member = value;
modified = true;
}
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupDoubleField(Object target, string name, ref double member, ref bool modified)
{
SetupDoubleField(target, new GUIContent(name), ref member, ref modified);
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupDoubleField(Object target, GUIContent name, ref double member, ref bool modified)
{
EditorGUI.BeginChangeCheck();
double value = EditorGUILayout.DoubleField(name, member);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Changed " + name);
member = value;
modified = true;
}
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupColorField(Object target, string name, ref Color member, ref bool modified)
{
SetupColorField(target, new GUIContent(name), ref member, ref modified);
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupColorField(Object target, GUIContent name, ref Color member, ref bool modified)
{
EditorGUI.BeginChangeCheck();
Color value = EditorGUILayout.ColorField(name, member);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Changed " + name);
member = value;
modified = true;
}
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupLayerMaskField(Object target, string name, ref LayerMask layerMask, string[] layerMaskOptions, ref bool modified)
{
SetupLayerMaskField(target, new GUIContent(name), ref layerMask, layerMaskOptions, ref modified);
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupLayerMaskField(Object target, GUIContent name, ref LayerMask layerMask, string[] layerMaskOptions, ref bool modified)
{
EditorGUI.BeginChangeCheck();
int value = EditorGUILayout.MaskField(name, layerMask, layerMaskOptions);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Changed " + name);
layerMask = value;
}
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupEnumField<T>(Object target, string name, ref T member, ref bool modified) where T : struct
{
SetupEnumField(target, new GUIContent(name), ref member, ref modified);
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupEnumField<T>(Object target, GUIContent name, ref T member, ref bool modified) where T : struct
{
EditorGUI.BeginChangeCheck();
T value = (T)(object)EditorGUILayout.EnumPopup(name, member as System.Enum);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Changed " + name);
member = value;
modified = true;
}
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupInputField(Object target, string name, ref string member, ref bool modified)
{
SetupInputField(target, new GUIContent(name), ref member, ref modified);
}
[Conditional("UNITY_EDITOR_WIN"), Conditional("UNITY_STANDALONE_WIN"), Conditional("UNITY_ANDROID")]
public static void SetupInputField(Object target, GUIContent name, ref string member, ref bool modified)
{
EditorGUI.BeginChangeCheck();
string value = EditorGUILayout.TextField(name, member);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Changed " + name);
member = value;
modified = true;
}
}
}

11
Assets/Oculus/VR/Scripts/Editor/OVREditorUtil.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 00e66be22bd6053489650de094c5efa8
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

146
Assets/Oculus/VR/Scripts/Editor/OVRManagerEditor.cs Normal file
View File

@@ -0,0 +1,146 @@
/************************************************************************************
Copyright : Copyright (c) Facebook Technologies, LLC and its affiliates. All rights reserved.
Licensed under the Oculus Master SDK License Version 1.0 (the "License"); you may not use
the Utilities SDK except in compliance with the License, which is provided at the time of installation
or download, or which otherwise accompanies this software in either electronic or hard copy form.
You may obtain a copy of the License at
https://developer.oculus.com/licenses/oculusmastersdk-1.0/
Unless required by applicable law or agreed to in writing, the Utilities SDK distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
ANY KIND, either express or implied. See the License for the specific language governing
permissions and limitations under the License.
************************************************************************************/
using UnityEngine;
using UnityEditor;
using System.Collections.Generic;
using System.Reflection;
[CustomEditor(typeof(OVRManager))]
public class OVRManagerEditor : Editor
{
override public void OnInspectorGUI()
{
#if UNITY_ANDROID
OVRProjectConfig projectConfig = OVRProjectConfig.GetProjectConfig();
OVRProjectConfigEditor.DrawTargetDeviceInspector(projectConfig);
EditorGUILayout.Space();
#endif
DrawDefaultInspector();
bool modified = false;
#if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN || UNITY_ANDROID
OVRManager manager = (OVRManager)target;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Display", EditorStyles.boldLabel);
OVREditorUtil.SetupBoolField(target, new GUIContent("Enable Specific Color Gamut",
"If checked, the target HMD will perform a color space transformation"), ref manager.enableColorGamut, ref modified);
if (manager.enableColorGamut)
{
OVREditorUtil.SetupEnumField(target, new GUIContent("Color Gamut",
"The target color gamut when displayed on the HMD"), ref manager.colorGamut, ref modified);
}
#endif
#if UNITY_ANDROID
EditorGUILayout.Space();
OVRProjectConfigEditor.DrawProjectConfigInspector(projectConfig);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Mixed Reality Capture for Quest (experimental)", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
OVREditorUtil.SetupEnumField(target, "ActivationMode", ref manager.mrcActivationMode, ref modified);
EditorGUI.indentLevel--;
#endif
#if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
EditorGUILayout.Space();
EditorGUILayout.LabelField("Mixed Reality Capture", EditorStyles.boldLabel);
OVREditorUtil.SetupBoolField(target, "Show Properties", ref manager.expandMixedRealityCapturePropertySheet, ref modified);
if (manager.expandMixedRealityCapturePropertySheet)
{
string[] layerMaskOptions = new string[32];
for (int i=0; i<32; ++i)
{
layerMaskOptions[i] = LayerMask.LayerToName(i);
if (layerMaskOptions[i].Length == 0)
{
layerMaskOptions[i] = "<Layer " + i.ToString() + ">";
}
}
EditorGUI.indentLevel++;
EditorGUILayout.Space();
OVREditorUtil.SetupBoolField(target, "enableMixedReality", ref manager.enableMixedReality, ref modified);
OVREditorUtil.SetupEnumField(target, "compositionMethod", ref manager.compositionMethod, ref modified);
OVREditorUtil.SetupLayerMaskField(target, "extraHiddenLayers", ref manager.extraHiddenLayers, layerMaskOptions, ref modified);
if (manager.compositionMethod == OVRManager.CompositionMethod.External)
{
EditorGUILayout.Space();
EditorGUILayout.LabelField("External Composition", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
OVREditorUtil.SetupColorField(target, "backdropColor (target, Rift)", ref manager.externalCompositionBackdropColorRift, ref modified);
OVREditorUtil.SetupColorField(target, "backdropColor (target, Quest)", ref manager.externalCompositionBackdropColorQuest, ref modified);
}
if (manager.compositionMethod == OVRManager.CompositionMethod.Direct)
{
EditorGUILayout.Space();
EditorGUILayout.LabelField("Direct Composition", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Camera", EditorStyles.boldLabel);
OVREditorUtil.SetupEnumField(target, "capturingCameraDevice", ref manager.capturingCameraDevice, ref modified);
OVREditorUtil.SetupBoolField(target, "flipCameraFrameHorizontally", ref manager.flipCameraFrameHorizontally, ref modified);
OVREditorUtil.SetupBoolField(target, "flipCameraFrameVertically", ref manager.flipCameraFrameVertically, ref modified);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Chroma Key", EditorStyles.boldLabel);
OVREditorUtil.SetupColorField(target, "chromaKeyColor", ref manager.chromaKeyColor, ref modified);
OVREditorUtil.SetupFloatField(target, "chromaKeySimilarity", ref manager.chromaKeySimilarity, ref modified);
OVREditorUtil.SetupFloatField(target, "chromaKeySmoothRange", ref manager.chromaKeySmoothRange, ref modified);
OVREditorUtil.SetupFloatField(target, "chromaKeySpillRange", ref manager.chromaKeySpillRange, ref modified);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Dynamic Lighting", EditorStyles.boldLabel);
OVREditorUtil.SetupBoolField(target, "useDynamicLighting", ref manager.useDynamicLighting, ref modified);
OVREditorUtil.SetupEnumField(target, "depthQuality", ref manager.depthQuality, ref modified);
OVREditorUtil.SetupFloatField(target, "dynamicLightingSmoothFactor", ref manager.dynamicLightingSmoothFactor, ref modified);
OVREditorUtil.SetupFloatField(target, "dynamicLightingDepthVariationClampingValue", ref manager.dynamicLightingDepthVariationClampingValue, ref modified);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Virtual Green Screen", EditorStyles.boldLabel);
OVREditorUtil.SetupEnumField(target, "virtualGreenScreenType", ref manager.virtualGreenScreenType, ref modified);
OVREditorUtil.SetupFloatField(target, "virtualGreenScreenTopY", ref manager.virtualGreenScreenTopY, ref modified);
OVREditorUtil.SetupFloatField(target, "virtualGreenScreenBottomY", ref manager.virtualGreenScreenBottomY, ref modified);
OVREditorUtil.SetupBoolField(target, "virtualGreenScreenApplyDepthCulling", ref manager.virtualGreenScreenApplyDepthCulling, ref modified);
OVREditorUtil.SetupFloatField(target, "virtualGreenScreenDepthTolerance", ref manager.virtualGreenScreenDepthTolerance, ref modified);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Latency Control", EditorStyles.boldLabel);
OVREditorUtil.SetupFloatField(target, "handPoseStateLatency", ref manager.handPoseStateLatency, ref modified);
EditorGUI.indentLevel--;
}
EditorGUI.indentLevel--;
}
#endif
if (modified)
{
EditorUtility.SetDirty(target);
}
}
}

12
Assets/Oculus/VR/Scripts/Editor/OVRManagerEditor.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 9b07d18088099f94fa00fc15e64b2b17
timeCreated: 1502747851
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

162
Assets/Oculus/VR/Scripts/Editor/OVROverlayDestRectEditor.shader Normal file
View File

@@ -0,0 +1,162 @@
Shader "Unlit/OVROverlayDestRectEditor"
{
Properties
{
_MainTex ("Texture", 2D) = "white" {}
_SrcRectLeft("SrcRectLeft", Vector) = (0,0,1,1)
_SrcRectRight("SrcRectRight", Vector) = (0,0,1,1)
_DestRectLeft ("DestRectLeft", Vector) = (0,0,1,1)
_DestRectRight("DestRectRight", Vector) = (0,0,1,1)
_BackgroundColor("Background Color", Color) = (0.225, 0.225, 0.225, 1)
}
SubShader
{
Tags { "RenderType"="Opaque" }
LOD 100
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 leftDragX : TEXCOORD1;
float4 leftDragY : TEXCOORD2;
float4 rightDragX : TEXCOORD3;
float4 rightDragY : TEXCOORD4;
};
sampler2D _MainTex;
float4 _MainTex_ST;
float4 _SrcRectLeft;
float4 _SrcRectRight;
float4 _DestRectLeft;
float4 _DestRectRight;
fixed4 _BackgroundColor;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
// Add padding
o.uv = (o.uv - 0.5) * (256.0 + 8.0) / (256.0) + 0.5;
// left
o.leftDragX.x = _DestRectLeft.x;
o.leftDragY.x = _DestRectLeft.y + _DestRectLeft.w * 0.5;
// right
o.leftDragX.y = _DestRectLeft.x + _DestRectLeft.z;
o.leftDragY.y = _DestRectLeft.y + _DestRectLeft.w * 0.5;
// top
o.leftDragX.z = _DestRectLeft.x + _DestRectLeft.z * 0.5;
o.leftDragY.z = _DestRectLeft.y;
// bottom
o.leftDragX.w = _DestRectLeft.x + _DestRectLeft.z * 0.5;
o.leftDragY.w = _DestRectLeft.y + _DestRectLeft.w;
// right
o.rightDragX.x = _DestRectRight.x;
o.rightDragY.x = _DestRectRight.y + _DestRectRight.w * 0.5;
// right
o.rightDragX.y = _DestRectRight.x + _DestRectRight.z;
o.rightDragY.y = _DestRectRight.y + _DestRectRight.w * 0.5;
// top
o.rightDragX.z = _DestRectRight.x + _DestRectRight.z * 0.5;
o.rightDragY.z = _DestRectRight.y;
// bottom
o.rightDragX.w = _DestRectRight.x + _DestRectRight.z * 0.5;
o.rightDragY.w = _DestRectRight.y + _DestRectRight.w;
return o;
}
float onDrag(float2 uv, float x, float y)
{
const float pixelSize = 6;
return abs(uv.x - x) < ((pixelSize / 2) / 128.0) && abs(uv.y - y) < ((pixelSize / 2) / 128.0);
}
float onLine(float2 uv, float4 rect)
{
return
(abs(uv.x - rect.x) < (1 / 128.0) && uv.y >= rect.y && uv.y <= rect.y + rect.w) ||
(abs(uv.x - rect.x - rect.z) < (1 / 128.0) && uv.y >= rect.y && uv.y <= rect.y + rect.w) ||
(abs(uv.y - rect.y) < (1 / 128.0) && uv.x >= rect.x && uv.x <= rect.x + rect.z) ||
(abs(uv.y - rect.y - rect.w) < (1 / 128.0) && uv.x >= rect.x && uv.x <= rect.x + rect.z);
}
float checkerboard(float2 uv)
{
float x = floor(uv.x * (16 + 2));
float y = floor(uv.y * 8);
return 2 * ((x + y) / 2.0 - floor((x + y) / 2.0));
}
fixed4 frag (v2f i) : SV_Target
{
float isLeftEye = i.uv < 0.5;
float2 leftUV = float2(i.uv.x * (256.0 + 32.0) / 128.0, i.uv.y);
float2 rightUV = float2(1 - ((1 - i.uv.x) * (256.0 + 32.0) / 128.0), i.uv.y);
float2 uv = i.uv;
float2 textureUV = i.uv;
if (isLeftEye)
{
uv = (leftUV - _DestRectLeft.xy) / _DestRectLeft.zw;
textureUV = uv * _SrcRectLeft.zw + _SrcRectLeft.xy;
}
else
{
uv = (rightUV - _DestRectRight.xy) / _DestRectRight.zw;
textureUV = uv * _SrcRectRight.zw + _SrcRectRight.xy;
}
// sample the texture
fixed4 col = tex2D(_MainTex, float2(textureUV.x, 1 - textureUV.y));
if (uv.x < 0 || uv.x > 1 || uv.y < 0 || uv.y > 1)
{
col.a = 0;
}
col.rgb = lerp(0.41 - 0.13 * checkerboard(i.uv), col.rgb, col.a);
if (i.uv.x < 0 || i.uv.x > 1 || i.uv.y < 0 || i.uv.y > 1 || abs(i.uv.x - 0.5) < (14 / 256.0))
{
col = _BackgroundColor;
}
// now draw clipping objects
float left = isLeftEye && (onLine(leftUV, _DestRectLeft) ||
onDrag(leftUV, i.leftDragX.x, i.leftDragY.x) ||
onDrag(leftUV, i.leftDragX.y, i.leftDragY.y) ||
onDrag(leftUV, i.leftDragX.z, i.leftDragY.z) ||
onDrag(leftUV, i.leftDragX.w, i.leftDragY.w));
float right = (!isLeftEye) && (onLine(rightUV, _DestRectRight) ||
onDrag(rightUV, i.rightDragX.x, i.rightDragY.x) ||
onDrag(rightUV, i.rightDragX.y, i.rightDragY.y) ||
onDrag(rightUV, i.rightDragX.z, i.rightDragY.z) ||
onDrag(rightUV, i.rightDragX.w, i.rightDragY.w));
return lerp(col, fixed4(left, right, 0, 1), left || right);
}
ENDCG
}
}
}

9
Assets/Oculus/VR/Scripts/Editor/OVROverlayDestRectEditor.shader.meta Normal file
View File

@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 7c52c9bacdbb59f4a973dd1849d03106
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

581
Assets/Oculus/VR/Scripts/Editor/OVROverlayEditor.cs Normal file
View File

@@ -0,0 +1,581 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
[CustomEditor(typeof(OVROverlay))]
public class OVROverlayEditor : Editor
{
/// <summary>
/// Common Video Types, to ease source and dest rect creation
/// </summary>
public enum StereoType
{
Custom = 0,
Mono = 1,
Stereo = 2,
StereoLeftRight = 3,
StereoTopBottom = 4,
}
public enum DisplayType
{
Custom = 0,
Full = 1,
Half = 2
}
private bool sourceRectsVisible = false;
private bool destRectsVisible = false;
private Material _SrcRectMaterial;
protected Material SrcRectMaterial
{
get
{
if (_SrcRectMaterial == null)
{
string[] shaders = AssetDatabase.FindAssets("OVROverlaySrcRectEditor");
if (shaders.Length > 0)
{
Shader shader = (Shader)AssetDatabase.LoadAssetAtPath(AssetDatabase.GUIDToAssetPath(shaders[0]), typeof(Shader));
if (shader != null)
{
_SrcRectMaterial = new Material(shader);
}
}
}
return _SrcRectMaterial;
}
}
private Material _DestRectMaterial;
protected Material DestRectMaterial
{
get
{
if (_DestRectMaterial == null)
{
string[] shaders = AssetDatabase.FindAssets("OVROverlayDestRectEditor");
if (shaders.Length > 0)
{
Shader shader = (Shader)AssetDatabase.LoadAssetAtPath(AssetDatabase.GUIDToAssetPath(shaders[0]), typeof(Shader));
if (shader != null)
{
_DestRectMaterial = new Material(shader);
}
}
}
return _DestRectMaterial;
}
}
private TextureRect _DraggingRect;
private Side _DraggingSide;
enum TextureRect
{
None,
SrcLeft,
SrcRight,
DestLeft,
DestRight
}
enum Side
{
Left,
Right,
Top,
Bottom
}
public override void OnInspectorGUI()
{
OVROverlay overlay = (OVROverlay)target;
if (overlay == null)
{
return;
}
EditorGUILayout.LabelField("Display Order", EditorStyles.boldLabel);
overlay.currentOverlayType = (OVROverlay.OverlayType)EditorGUILayout.EnumPopup(new GUIContent("Current Overlay Type", "Whether this overlay should layer behind the scene or in front of it"), overlay.currentOverlayType);
overlay.compositionDepth = EditorGUILayout.IntField(new GUIContent("Composition Depth", "Depth value used to sort OVROverlays in the scene, smaller value appears in front"), overlay.compositionDepth);
overlay.noDepthBufferTesting = EditorGUILayout.Toggle(new GUIContent("No Depth Buffer Testing", "The noDepthBufferTesting will stop layer's depth buffer compositing even if the engine has \"Shared Depth Buffer\" enabled"), overlay.noDepthBufferTesting);
EditorGUILayout.Space();
EditorGUILayout.LabelField(new GUIContent("Overlay Shape", "The shape of this overlay"), EditorStyles.boldLabel);
overlay.currentOverlayShape = (OVROverlay.OverlayShape)EditorGUILayout.EnumPopup(new GUIContent("Overlay Shape", "The shape of this overlay"), overlay.currentOverlayShape);
EditorGUILayout.Space();
EditorGUILayout.Separator();
EditorGUILayout.LabelField("Textures", EditorStyles.boldLabel);
#if UNITY_ANDROID
bool lastIsExternalSurface = overlay.isExternalSurface;
overlay.isExternalSurface = EditorGUILayout.Toggle(new GUIContent("Is External Surface", "On Android, retrieve an Android Surface object to render to (e.g., video playback)"), overlay.isExternalSurface);
if (lastIsExternalSurface)
{
overlay.externalSurfaceWidth = EditorGUILayout.IntField("External Surface Width", overlay.externalSurfaceWidth);
overlay.externalSurfaceHeight = EditorGUILayout.IntField("External Surface Height", overlay.externalSurfaceHeight);
overlay.isProtectedContent = EditorGUILayout.Toggle(new GUIContent("Is Protected Content", "The external surface has L1 widevine protection."), overlay.isProtectedContent);
}
else
#endif
{
if (overlay.textures == null)
{
overlay.textures = new Texture[2];
}
if (overlay.textures.Length < 2)
{
Texture[] tmp = new Texture[2];
for (int i = 0; i < overlay.textures.Length; i++)
{
tmp[i] = overlay.textures[i];
}
overlay.textures = tmp;
}
var labelControlRect = EditorGUILayout.GetControlRect();
EditorGUI.LabelField(new Rect(labelControlRect.x, labelControlRect.y, labelControlRect.width / 2, labelControlRect.height), new GUIContent("Left Texture", "Texture used for the left eye"));
EditorGUI.LabelField(new Rect(labelControlRect.x + labelControlRect.width / 2, labelControlRect.y, labelControlRect.width / 2, labelControlRect.height), new GUIContent("Right Texture", "Texture used for the right eye"));
var textureControlRect = EditorGUILayout.GetControlRect(GUILayout.Height(64));
overlay.textures[0] = (Texture)EditorGUI.ObjectField(new Rect(textureControlRect.x, textureControlRect.y, 64, textureControlRect.height), overlay.textures[0], typeof(Texture), true);
Texture right = (Texture)EditorGUI.ObjectField(new Rect(textureControlRect.x + textureControlRect.width / 2, textureControlRect.y, 64, textureControlRect.height), overlay.textures[1] != null ? overlay.textures[1] : overlay.textures[0], typeof(Texture), true);
if (right == overlay.textures[0])
{
overlay.textures[1] = null;
}
else
{
overlay.textures[1] = right;
}
overlay.isDynamic = EditorGUILayout.Toggle(new GUIContent("Dynamic Texture", "This texture will be updated dynamically at runtime (e.g., Video)"), overlay.isDynamic);
#if !UNITY_ANDROID
overlay.isProtectedContent = EditorGUILayout.Toggle(new GUIContent("Is Protected Content", "The texture has copy protection, e.g., HDCP"), overlay.isProtectedContent);
#endif
}
if (overlay.currentOverlayShape == OVROverlay.OverlayShape.Cylinder || overlay.currentOverlayShape == OVROverlay.OverlayShape.Equirect || overlay.currentOverlayShape == OVROverlay.OverlayShape.Quad)
{
EditorGUILayout.Separator();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Texture Rects", EditorStyles.boldLabel);
bool lastOverrideTextureRectMatrix = overlay.overrideTextureRectMatrix;
overlay.overrideTextureRectMatrix = !EditorGUILayout.Toggle(new GUIContent("Use Default Rects", overlay.textures[1] == null ? "If you need to use a single texture as a stereo image, uncheck this box" : "Uncheck this box if you need to clip you textures or layer"), !overlay.overrideTextureRectMatrix);
if (lastOverrideTextureRectMatrix)
{
sourceRectsVisible = EditorGUILayout.Foldout(sourceRectsVisible, new GUIContent("Source Rects", "What portion of the source texture will ultimately be shown in each eye."));
if (sourceRectsVisible)
{
var mat = SrcRectMaterial;
if (mat != null)
{
Rect drawRect = EditorGUILayout.GetControlRect(GUILayout.Height(128 + 8));
Vector4 srcLeft = new Vector4(Mathf.Max(0.0f, overlay.srcRectLeft.x), Mathf.Max(0.0f, overlay.srcRectLeft.y), Mathf.Min(1.0f - overlay.srcRectLeft.x, overlay.srcRectLeft.width), Mathf.Min(1.0f - overlay.srcRectLeft.y, overlay.srcRectLeft.height));
Vector4 srcRight = new Vector4(Mathf.Max(0.0f, overlay.srcRectRight.x), Mathf.Max(0.0f, overlay.srcRectRight.y), Mathf.Min(1.0f - overlay.srcRectRight.x, overlay.srcRectRight.width), Mathf.Min(1.0f - overlay.srcRectRight.y, overlay.srcRectRight.height));
if (overlay.invertTextureRects)
{
srcLeft.y = 1 - srcLeft.y - srcLeft.w;
srcRight.y = 1 - srcRight.y - srcRight.w;
}
mat.SetVector("_SrcRectLeft", srcLeft);
mat.SetVector("_SrcRectRight", srcRight);
// center our draw rect
var drawRectCentered = new Rect(drawRect.x + drawRect.width / 2 - 128 - 4, drawRect.y, 256 + 8, drawRect.height);
EditorGUI.DrawPreviewTexture(drawRectCentered, overlay.textures[0] ?? Texture2D.blackTexture, mat);
var drawRectInset = new Rect(drawRectCentered.x + 4, drawRectCentered.y + 4, drawRectCentered.width - 8, drawRectCentered.height - 8);
UpdateRectDragging(drawRectInset, drawRectInset, TextureRect.SrcLeft, TextureRect.SrcRight, overlay.invertTextureRects, ref overlay.srcRectLeft, ref overlay.srcRectRight);
CreateCursorRects(drawRectInset, overlay.srcRectLeft, overlay.invertTextureRects);
CreateCursorRects(drawRectInset, overlay.srcRectRight, overlay.invertTextureRects);
}
var labelControlRect = EditorGUILayout.GetControlRect();
EditorGUI.LabelField(new Rect(labelControlRect.x, labelControlRect.y, labelControlRect.width / 2, labelControlRect.height), new GUIContent("Left Source Rect", "The rect in the source image that will be displayed on the left eye layer"));
EditorGUI.LabelField(new Rect(labelControlRect.x + labelControlRect.width / 2, labelControlRect.y, labelControlRect.width / 2, labelControlRect.height), new GUIContent("Right Source Rect", "The rect in the source image that will be displayed on the right eye layer"));
var rectControlRect = EditorGUILayout.GetControlRect(GUILayout.Height(34));
overlay.srcRectLeft = Clamp01(EditorGUI.RectField(new Rect(rectControlRect.x, rectControlRect.y, rectControlRect.width / 2 - 20, rectControlRect.height), overlay.srcRectLeft));
overlay.srcRectRight = Clamp01(EditorGUI.RectField(new Rect(rectControlRect.x + rectControlRect.width / 2, rectControlRect.y, rectControlRect.width / 2 - 20, rectControlRect.height), overlay.srcRectRight));
EditorGUILayout.BeginHorizontal();
if (overlay.textures[1] != null)
{
if (GUILayout.Button(new GUIContent("Reset To Default", "Reset Source Rects to default")))
{
SetRectsByVideoType(overlay, StereoType.Stereo, DisplayType.Custom);
}
}
else
{
if (GUILayout.Button(new GUIContent("Monoscopic", "Display the full Texture in both eyes")))
{
SetRectsByVideoType(overlay, StereoType.Mono, DisplayType.Custom);
}
if (GUILayout.Button(new GUIContent("Stereo Left/Right", "The left half of the texture is displayed in the left eye, and the right half in the right eye")))
{
SetRectsByVideoType(overlay, StereoType.StereoLeftRight, DisplayType.Custom);
}
if (GUILayout.Button(new GUIContent("Stereo Top/Bottom", "The top half of the texture is displayed in the left eye, and the bottom half in the right eye")))
{
SetRectsByVideoType(overlay, StereoType.StereoTopBottom, DisplayType.Custom);
}
}
EditorGUILayout.EndHorizontal();
}
destRectsVisible = EditorGUILayout.Foldout(destRectsVisible, new GUIContent("Destination Rects", "What portion of the destination texture that the source will be rendered into."));
if (destRectsVisible)
{
var mat = DestRectMaterial;
if (mat != null)
{
Rect drawRect = EditorGUILayout.GetControlRect(GUILayout.Height(128 + 8));
Vector4 srcLeft = new Vector4(Mathf.Max(0.0f, overlay.srcRectLeft.x), Mathf.Max(0.0f, overlay.srcRectLeft.y), Mathf.Min(1.0f - overlay.srcRectLeft.x, overlay.srcRectLeft.width), Mathf.Min(1.0f - overlay.srcRectLeft.y, overlay.srcRectLeft.height));
Vector4 srcRight = new Vector4(Mathf.Max(0.0f, overlay.srcRectRight.x), Mathf.Max(0.0f, overlay.srcRectRight.y), Mathf.Min(1.0f - overlay.srcRectRight.x, overlay.srcRectRight.width), Mathf.Min(1.0f - overlay.srcRectRight.y, overlay.srcRectRight.height));
Vector4 destLeft = new Vector4(Mathf.Max(0.0f, overlay.destRectLeft.x), Mathf.Max(0.0f, overlay.destRectLeft.y), Mathf.Min(1.0f - overlay.destRectLeft.x, overlay.destRectLeft.width), Mathf.Min(1.0f - overlay.destRectLeft.y, overlay.destRectLeft.height));
Vector4 destRight = new Vector4(Mathf.Max(0.0f, overlay.destRectRight.x), Mathf.Max(0.0f, overlay.destRectRight.y), Mathf.Min(1.0f - overlay.destRectRight.x, overlay.destRectRight.width), Mathf.Min(1.0f - overlay.destRectRight.y, overlay.destRectRight.height));
if (overlay.invertTextureRects)
{
srcLeft.y = 1 - srcLeft.y - srcLeft.w;
srcRight.y = 1 - srcRight.y - srcRight.w;
destLeft.y = 1 - destLeft.y - destLeft.w;
destRight.y = 1 - destRight.y - destRight.w;
}
mat.SetVector("_SrcRectLeft", srcLeft);
mat.SetVector("_SrcRectRight", srcRight);
mat.SetVector("_DestRectLeft", destLeft);
mat.SetVector("_DestRectRight", destRight);
mat.SetColor("_BackgroundColor", EditorGUIUtility.isProSkin ? (Color)new Color32(56, 56, 56, 255) : (Color)new Color32(194, 194, 194, 255));
var drawRectCentered = new Rect(drawRect.x + drawRect.width / 2 - 128 - 16 - 4, drawRect.y, 256 + 32 + 8, drawRect.height);
// center our draw rect
EditorGUI.DrawPreviewTexture(drawRectCentered, overlay.textures[0] ?? Texture2D.blackTexture, mat);
var drawRectInsetLeft = new Rect(drawRectCentered.x + 4, drawRectCentered.y + 4, drawRectCentered.width / 2 - 20, drawRectCentered.height - 8);
var drawRectInsetRight = new Rect(drawRectCentered.x + drawRectCentered.width / 2 + 16, drawRectCentered.y + 4, drawRectCentered.width / 2 - 20, drawRectCentered.height - 8);
UpdateRectDragging(drawRectInsetLeft, drawRectInsetRight, TextureRect.DestLeft, TextureRect.DestRight, overlay.invertTextureRects, ref overlay.destRectLeft, ref overlay.destRectRight);
CreateCursorRects(drawRectInsetLeft, overlay.destRectLeft, overlay.invertTextureRects);
CreateCursorRects(drawRectInsetRight, overlay.destRectRight, overlay.invertTextureRects);
}
var labelControlRect = EditorGUILayout.GetControlRect();
EditorGUI.LabelField(new Rect(labelControlRect.x, labelControlRect.y, labelControlRect.width / 2, labelControlRect.height), new GUIContent("Left Destination Rect", "The rect in the destination layer the left eye will display to"));
EditorGUI.LabelField(new Rect(labelControlRect.x + labelControlRect.width / 2, labelControlRect.y, labelControlRect.width / 2, labelControlRect.height), new GUIContent("Right Destination Rect", "The rect in the destination layer the right eye will display to"));
var rectControlRect = EditorGUILayout.GetControlRect(GUILayout.Height(34));
overlay.destRectLeft = Clamp01(EditorGUI.RectField(new Rect(rectControlRect.x, rectControlRect.y, rectControlRect.width / 2 - 20, rectControlRect.height), overlay.destRectLeft));
overlay.destRectRight = Clamp01(EditorGUI.RectField(new Rect(rectControlRect.x + rectControlRect.width / 2, rectControlRect.y, rectControlRect.width / 2 - 20, rectControlRect.height), overlay.destRectRight));
if (overlay.currentOverlayShape == OVROverlay.OverlayShape.Equirect)
{
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button(new GUIContent("360 Video", "Display the full 360 layer")))
{
SetRectsByVideoType(overlay, StereoType.Custom, DisplayType.Full);
}
if (GUILayout.Button(new GUIContent("180 Video", "Display the front 180 layer")))
{
SetRectsByVideoType(overlay, StereoType.Custom, DisplayType.Half);
}
EditorGUILayout.EndHorizontal();
}
else
{
if (GUILayout.Button(new GUIContent("Reset To Default", "Reset Source Rects to default")))
{
SetRectsByVideoType(overlay, StereoType.Custom, DisplayType.Full);
}
}
}
overlay.invertTextureRects = EditorGUILayout.Toggle(new GUIContent("Invert Rect Coordinates", "Check this box to use the top left corner of the texture as the origin"), overlay.invertTextureRects);
}
}
EditorGUILayout.Separator();
EditorGUILayout.LabelField("Color Scale", EditorStyles.boldLabel);
EditorGUILayout.Space();
overlay.overridePerLayerColorScaleAndOffset = EditorGUILayout.Toggle(new GUIContent("Override Color Scale", "Manually set color scale and offset of this layer, regardless of what the global values are from OVRManager.SetColorScaleAndOffset()."), overlay.overridePerLayerColorScaleAndOffset);
if (overlay.overridePerLayerColorScaleAndOffset)
{
Vector4 colorScale = EditorGUILayout.Vector4Field(new GUIContent("Color Scale", "Scale that the color values for this overlay will be multiplied by."), overlay.colorScale);
Vector4 colorOffset = EditorGUILayout.Vector4Field(new GUIContent("Color Offset", "Offset that the color values for this overlay will be added to."), overlay.colorOffset);
overlay.SetPerLayerColorScaleAndOffset(colorScale, colorOffset);
}
EditorGUILayout.Separator();
EditorGUILayout.LabelField("Preview", EditorStyles.boldLabel);
overlay.previewInEditor = EditorGUILayout.Toggle(new GUIContent("Preview in Editor (Experimental)", "Preview the overlay in the editor using a mesh renderer."), overlay.previewInEditor);
EditorUtility.SetDirty(overlay);
}
private Rect Clamp01(Rect rect)
{
rect.x = Mathf.Clamp01(rect.x);
rect.y = Mathf.Clamp01(rect.y);
rect.width = Mathf.Clamp01(rect.width);
rect.height = Mathf.Clamp01(rect.height);
return rect;
}
private bool IsUnitRect(Rect rect)
{
return IsRect(rect, 0, 0, 1, 1);
}
private bool IsRect(Rect rect, float x, float y, float w, float h)
{
return rect.x == x && rect.y == y && rect.width == w && rect.height == h;
}
private StereoType GetStereoType(OVROverlay overlay)
{
if (overlay.textures[0] != null && overlay.textures[1] != null)
{
if (IsUnitRect(overlay.srcRectLeft) && IsUnitRect(overlay.srcRectRight))
{
return StereoType.Stereo;
}
else
{
return StereoType.Custom;
}
}
else if (overlay.textures[0] != null)
{
if (IsUnitRect(overlay.srcRectLeft) && IsUnitRect(overlay.srcRectRight))
{
return StereoType.Mono;
}
else if (IsRect(overlay.srcRectLeft, 0, 0, 0.5f, 1f) && IsRect(overlay.srcRectRight, 0.5f, 0, 0.5f, 1f))
{
return StereoType.StereoLeftRight;
}
else if (overlay.invertTextureRects && IsRect(overlay.srcRectLeft, 0, 0.0f, 1f, 0.5f) && IsRect(overlay.srcRectRight, 0f, 0.5f, 1f, 0.5f))
{
return StereoType.StereoTopBottom;
}
else if (!overlay.invertTextureRects && IsRect(overlay.srcRectLeft, 0, 0.5f, 1f, 0.5f) && IsRect(overlay.srcRectRight, 0f, 0f, 1f, 0.5f))
{
return StereoType.StereoTopBottom;
}
else
{
return StereoType.Custom;
}
}
else
{
return StereoType.Mono;
}
}
private void SetRectsByVideoType(OVROverlay overlay, StereoType stereoType, DisplayType displayType)
{
Rect srcRectLeft, srcRectRight, destRectLeft, destRectRight;
switch (displayType)
{
case DisplayType.Full:
destRectLeft = destRectRight = new Rect(0, 0, 1, 1);
break;
case DisplayType.Half:
destRectLeft = destRectRight = new Rect(0.25f, 0, 0.5f, 1);
break;
default:
destRectLeft = overlay.destRectLeft;
destRectRight = overlay.destRectRight;
break;
}
switch (stereoType)
{
case StereoType.Mono:
case StereoType.Stereo:
srcRectLeft = srcRectRight = new Rect(0, 0, 1, 1);
break;
case StereoType.StereoTopBottom:
if (overlay.invertTextureRects)
{
srcRectLeft = new Rect(0, 0.0f, 1, 0.5f);
srcRectRight = new Rect(0, 0.5f, 1, 0.5f);
}
else
{
srcRectLeft = new Rect(0, 0.5f, 1, 0.5f);
srcRectRight = new Rect(0, 0.0f, 1, 0.5f);
}
break;
case StereoType.StereoLeftRight:
srcRectLeft = new Rect(0, 0, 0.5f, 1);
srcRectRight = new Rect(0.5f, 0, 0.5f, 1);
break;
default:
srcRectLeft = overlay.srcRectLeft;
srcRectRight = overlay.srcRectRight;
break;
}
overlay.SetSrcDestRects(srcRectLeft, srcRectRight, destRectLeft, destRectRight);
}
private void GetCursorPoints(Rect drawRect, Rect selectRect, bool invertY, out Vector2 leftPos, out Vector2 rightPos, out Vector2 topPos, out Vector2 bottomPos)
{
if (invertY)
{
selectRect.y = 1 - selectRect.y - selectRect.height;
}
leftPos = new Vector2(drawRect.x + selectRect.x * drawRect.width, drawRect.y + (1 - selectRect.y - selectRect.height / 2) * drawRect.height);
rightPos = new Vector2(drawRect.x + (selectRect.x + selectRect.width) * drawRect.width, drawRect.y + (1 - selectRect.y - selectRect.height / 2) * drawRect.height);
topPos = new Vector2(drawRect.x + (selectRect.x + selectRect.width / 2) * drawRect.width, drawRect.y + (1 - selectRect.y - selectRect.height) * drawRect.height);
bottomPos = new Vector2(drawRect.x + (selectRect.x + selectRect.width / 2) * drawRect.width, drawRect.y + (1 - selectRect.y) * drawRect.height);
if (invertY)
{
// swap top and bottom
var tmp = topPos;
topPos = bottomPos;
bottomPos = tmp;
}
}
private void CreateCursorRects(Rect drawRect, Rect selectRect, bool invertY)
{
Vector2 leftPos, rightPos, topPos, bottomPos;
GetCursorPoints(drawRect, selectRect, invertY, out leftPos, out rightPos, out topPos, out bottomPos);
EditorGUIUtility.AddCursorRect(new Rect(leftPos - 5 * Vector2.one, 10 * Vector2.one), MouseCursor.ResizeHorizontal);
EditorGUIUtility.AddCursorRect(new Rect(rightPos - 5 * Vector2.one, 10 * Vector2.one), MouseCursor.ResizeHorizontal);
EditorGUIUtility.AddCursorRect(new Rect(topPos - 5 * Vector2.one, 10 * Vector2.one), MouseCursor.ResizeVertical);
EditorGUIUtility.AddCursorRect(new Rect(bottomPos - 5 * Vector2.one, 10 * Vector2.one), MouseCursor.ResizeVertical);
}
private bool IsOverRectControls(Rect drawRect, Vector2 mousePos, Rect selectRect, bool invertY, ref Side side)
{
Vector2 leftPos, rightPos, topPos, bottomPos;
GetCursorPoints(drawRect, selectRect, invertY, out leftPos, out rightPos, out topPos, out bottomPos);
if ((leftPos - mousePos).sqrMagnitude <= 25)
{
side = Side.Left;
return true;
}
if ((rightPos - mousePos).sqrMagnitude <= 25)
{
side = Side.Right;
return true;
}
if ((topPos - mousePos).sqrMagnitude <= 25)
{
side = Side.Top;
return true;
}
if ((bottomPos - mousePos).sqrMagnitude <= 25)
{
side = Side.Bottom;
return true;
}
return false;
}
private void UpdateRectDragging(Rect drawingRectLeft, Rect drawingRectRight, TextureRect rectLeftType, TextureRect rectRightType, bool invertY, ref Rect rectLeft, ref Rect rectRight)
{
if (!Event.current.isMouse || Event.current.button != 0)
{
return;
}
if (Event.current.type == EventType.MouseUp)
{
_DraggingRect = TextureRect.None;
return;
}
Vector2 mousePos = Event.current.mousePosition;
if (_DraggingRect == TextureRect.None && Event.current.type == EventType.MouseDown)
{
if (IsOverRectControls(drawingRectLeft, mousePos, rectLeft, invertY, ref _DraggingSide))
{
_DraggingRect = rectLeftType;
}
if (_DraggingRect == TextureRect.None || Event.current.shift)
{
if (IsOverRectControls(drawingRectRight, mousePos, rectRight, invertY, ref _DraggingSide))
{
_DraggingRect = rectRightType;
}
}
}
if (_DraggingRect == rectLeftType)
{
SetRectSideValue(drawingRectLeft, mousePos, _DraggingSide, invertY, ref rectLeft);
}
if (_DraggingRect == rectRightType)
{
SetRectSideValue(drawingRectRight, mousePos, _DraggingSide, invertY, ref rectRight);
}
}
private void SetRectSideValue(Rect drawingRect, Vector2 mousePos, Side side, bool invertY, ref Rect rect)
{
// quantize to 1/32
float x = Mathf.Clamp01(Mathf.Round(((mousePos.x - drawingRect.x) / drawingRect.width) * 32) / 32.0f);
float y = Mathf.Clamp01(Mathf.Round(((mousePos.y - drawingRect.y) / drawingRect.height) * 32) / 32.0f);
if (!invertY)
{
y = 1 - y;
}
switch (side)
{
case Side.Left:
float xMax = rect.xMax;
rect.x = Mathf.Min(x, xMax);
rect.width = xMax - rect.x;
break;
case Side.Right:
rect.width = Mathf.Max(0, x - rect.x);
break;
case Side.Bottom:
float yMax = rect.yMax;
rect.y = Mathf.Min(y, yMax);
rect.height = yMax - rect.y;
break;
case Side.Top:
rect.height = Mathf.Max(0, y - rect.y);
break;
}
}
}

11
Assets/Oculus/VR/Scripts/Editor/OVROverlayEditor.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: fde3aeb28643f6c48a48f926ac7207e0
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

138
Assets/Oculus/VR/Scripts/Editor/OVROverlaySrcRectEditor.shader Normal file
View File

@@ -0,0 +1,138 @@
Shader "Unlit/OVROverlaySrcRectEditor"
{
Properties
{
_MainTex ("Texture", 2D) = "white" {}
_SrcRectLeft ("SrcRectLeft", Vector) = (0,0,1,1)
_SrcRectRight("SrcRectRight", Vector) = (0,0,1,1)
_BackgroundColor("Background Color", Color) = (0.225, 0.225, 0.225, 1)
}
SubShader
{
Tags { "RenderType"="Opaque" }
LOD 100
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
float4 leftDragX : TEXCOORD1;
float4 leftDragY : TEXCOORD2;
float4 rightDragX : TEXCOORD3;
float4 rightDragY : TEXCOORD4;
};
sampler2D _MainTex;
float4 _MainTex_ST;
float4 _SrcRectLeft;
float4 _SrcRectRight;
fixed4 _BackgroundColor;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
// Add padding
o.uv = (o.uv - 0.5) * (256.0 + 8.0) / (256.0) + 0.5;
// left
o.leftDragX.x = _SrcRectLeft.x;
o.leftDragY.x = _SrcRectLeft.y + _SrcRectLeft.w * 0.5;
// right
o.leftDragX.y = _SrcRectLeft.x + _SrcRectLeft.z;
o.leftDragY.y = _SrcRectLeft.y + _SrcRectLeft.w * 0.5;
// top
o.leftDragX.z = _SrcRectLeft.x + _SrcRectLeft.z * 0.5;
o.leftDragY.z = _SrcRectLeft.y;
// bottom
o.leftDragX.w = _SrcRectLeft.x + _SrcRectLeft.z * 0.5;
o.leftDragY.w = _SrcRectLeft.y + _SrcRectLeft.w;
// right
o.rightDragX.x = _SrcRectRight.x;
o.rightDragY.x = _SrcRectRight.y + _SrcRectRight.w * 0.5;
// right
o.rightDragX.y = _SrcRectRight.x + _SrcRectRight.z;
o.rightDragY.y = _SrcRectRight.y + _SrcRectRight.w * 0.5;
// top
o.rightDragX.z = _SrcRectRight.x + _SrcRectRight.z * 0.5;
o.rightDragY.z = _SrcRectRight.y;
// bottom
o.rightDragX.w = _SrcRectRight.x + _SrcRectRight.z * 0.5;
o.rightDragY.w = _SrcRectRight.y + _SrcRectRight.w;
return o;
}
float onDrag(float2 uv, float x, float y)
{
const float pixelSize = 6;
return abs(uv.x - x) < ((pixelSize / 2) / 256.0) && abs(uv.y - y) < ((pixelSize / 2) / 128.0);
}
float onLine(float2 uv, float4 rect)
{
return
(abs(uv.x - rect.x) < (1 / 256.0) && uv.y >= rect.y && uv.y <= rect.y + rect.w) ||
(abs(uv.x - rect.x - rect.z) < (1 / 256.0) && uv.y >= rect.y && uv.y <= rect.y + rect.w) ||
(abs(uv.y - rect.y) < (1 / 128.0) && uv.x >= rect.x && uv.x <= rect.x + rect.z) ||
(abs(uv.y - rect.y - rect.w) < (1 / 128.0) && uv.x >= rect.x && uv.x <= rect.x + rect.z);
}
float checkerboard(float2 uv)
{
float x = floor(uv.x * (16));
float y = floor(uv.y * 8);
return 2 * ((x + y) / 2.0 - floor((x + y) / 2.0));
}
fixed4 frag (v2f i) : SV_Target
{
// sample the texture
fixed4 col = tex2D(_MainTex, i.uv);
col.rgb = lerp(0.41 - 0.13 * checkerboard(i.uv), col.rgb, col.a);
if (i.uv.x < 0 || i.uv.x > 1 || i.uv.y < 0 || i.uv.y > 1)
{
col = _BackgroundColor;
}
float2 uv = i.uv.xy;
// now draw clipping objects
float left = onLine(uv, _SrcRectLeft) ||
onDrag(uv, i.leftDragX.x, i.leftDragY.x) ||
onDrag(uv, i.leftDragX.y, i.leftDragY.y) ||
onDrag(uv, i.leftDragX.z, i.leftDragY.z) ||
onDrag(uv, i.leftDragX.w, i.leftDragY.w);
float right = onLine(uv, _SrcRectRight) ||
onDrag(uv, i.rightDragX.x, i.rightDragY.x) ||
onDrag(uv, i.rightDragX.y, i.rightDragY.y) ||
onDrag(uv, i.rightDragX.z, i.rightDragY.z) ||
onDrag(uv, i.rightDragX.w, i.rightDragY.w);
return lerp(col, fixed4(left, right, 0, 1), left || right);
}
ENDCG
}
}
}

9
Assets/Oculus/VR/Scripts/Editor/OVROverlaySrcRectEditor.shader.meta Normal file
View File

@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 589b36d0aa66c7349bcff8750b670434
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

102
Assets/Oculus/VR/Scripts/Editor/OVRProjectConfigEditor.cs Normal file
View File

@@ -0,0 +1,102 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
[CustomEditor(typeof(OVRProjectConfig))]
public class OVRProjectConfigEditor : Editor
{
override public void OnInspectorGUI()
{
OVRProjectConfig projectConfig = (OVRProjectConfig)target;
DrawTargetDeviceInspector(projectConfig);
EditorGUILayout.Space();
DrawProjectConfigInspector(projectConfig);
}
public static void DrawTargetDeviceInspector(OVRProjectConfig projectConfig)
{
bool hasModified = false;
// Target Devices
EditorGUILayout.LabelField("Target Devices", EditorStyles.boldLabel);
foreach (OVRProjectConfig.DeviceType deviceType in System.Enum.GetValues(typeof(OVRProjectConfig.DeviceType)))
{
bool oldSupportsDevice = projectConfig.targetDeviceTypes.Contains(deviceType);
bool newSupportsDevice = oldSupportsDevice;
OVREditorUtil.SetupBoolField(projectConfig, ObjectNames.NicifyVariableName(deviceType.ToString()), ref newSupportsDevice, ref hasModified);
if (newSupportsDevice && !oldSupportsDevice)
{
projectConfig.targetDeviceTypes.Add(deviceType);
}
else if (oldSupportsDevice && !newSupportsDevice)
{
projectConfig.targetDeviceTypes.Remove(deviceType);
}
}
if (hasModified)
{
OVRProjectConfig.CommitProjectConfig(projectConfig);
}
}
public static void DrawProjectConfigInspector(OVRProjectConfig projectConfig)
{
bool hasModified = false;
EditorGUI.BeginDisabledGroup(!projectConfig.targetDeviceTypes.Contains(OVRProjectConfig.DeviceType.Quest));
EditorGUILayout.LabelField("Quest Features", EditorStyles.boldLabel);
// Show overlay support option
OVREditorUtil.SetupBoolField(projectConfig, new GUIContent("Focus Aware",
"If checked, the new overlay will be displayed when the user presses the home button. The game will not be paused, but will now receive InputFocusLost and InputFocusAcquired events."),
ref projectConfig.focusAware, ref hasModified);
if (!projectConfig.focusAware && projectConfig.requiresSystemKeyboard)
{
projectConfig.requiresSystemKeyboard = false;
hasModified = true;
}
// Hand Tracking Support
OVREditorUtil.SetupEnumField(projectConfig, "Hand Tracking Support", ref projectConfig.handTrackingSupport, ref hasModified);
// System Keyboard Support
OVREditorUtil.SetupBoolField(projectConfig, new GUIContent("Requires System Keyboard",
"*Requires Focus Awareness* If checked, the Oculus System keyboard will be enabled for Unity input fields and any calls to open/close the Unity TouchScreenKeyboard."),
ref projectConfig.requiresSystemKeyboard, ref hasModified);
if (projectConfig.requiresSystemKeyboard && !projectConfig.focusAware)
{
projectConfig.focusAware = true;
hasModified = true;
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.Space();
EditorGUI.BeginDisabledGroup(false);
EditorGUILayout.LabelField("Android Build Settings", EditorStyles.boldLabel);
// Show overlay support option
OVREditorUtil.SetupBoolField(projectConfig, new GUIContent("Skip Unneeded Shaders",
"If checked, prevent building shaders that are not used by default to reduce time spent when building."),
ref projectConfig.skipUnneededShaders, ref hasModified);
EditorGUI.EndDisabledGroup();
EditorGUILayout.Space();
EditorGUILayout.LabelField("Security", EditorStyles.boldLabel);
OVREditorUtil.SetupInputField(projectConfig, "Custom Security XML Path", ref projectConfig.securityXmlPath, ref hasModified);
OVREditorUtil.SetupBoolField(projectConfig, "Disable Backups", ref projectConfig.disableBackups, ref hasModified);
OVREditorUtil.SetupBoolField(projectConfig, "Enable NSC Configuration", ref projectConfig.enableNSCConfig, ref hasModified);
// apply any pending changes to project config
if (hasModified)
{
OVRProjectConfig.CommitProjectConfig(projectConfig);
}
}
}

11
Assets/Oculus/VR/Scripts/Editor/OVRProjectConfigEditor.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 950d95332920b814ea41df294856f96a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

17
Assets/Oculus/VR/Scripts/Editor/Oculus.VR.Scripts.Editor.asmdef Normal file
View File

@@ -0,0 +1,17 @@
{
"name": "Oculus.VR.Scripts.Editor",
"references": [
"Oculus.VR",
"Oculus.VR.Editor"
],
"optionalUnityReferences": [],
"includePlatforms": [
"Editor"
],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": []
}

7
Assets/Oculus/VR/Scripts/Editor/Oculus.VR.Scripts.Editor.asmdef.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 7305c54a43f3814439df347c7519653e
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant: