void RandomizeClayxel(ClayObject clay)
{
ClayObjectRandomizationStrength strength =
GetAddComponent <ClayObjectRandomizationStrength>(clay.gameObject);
clay.transform.localPosition = RandomizeNonZeroOfVector3(
clay.transform.localPosition,
0.25f * defaultStrength.all * defaultStrength.position * strength.all * strength.position);
clay.transform.localEulerAngles = RandomizeNonZeroOfVector3(
clay.transform.localEulerAngles,
5f * defaultStrength.all * defaultStrength.rotation * strength.all * strength.rotation);
clay.transform.localScale = RandomizeVector3(
clay.transform.localScale,
0.25f * defaultStrength.all * defaultStrength.scale * strength.all * strength.scale);
clay.color = RandomizeColor(
clay.color,
0.15f * defaultStrength.all * defaultStrength.color * strength.all * strength.color);
clay.blend = RandomizeFloat(
clay.blend,
0.1f * defaultStrength.all * defaultStrength.blend * strength.all * strength.blend);
}
public void Export(string meshName = "")
{
if (meshName.IsNullOrEmpty())
{
meshName = System.DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss");
}
if (!Directory.Exists(DigiClayConstant.CLAY_DATA_PATH))
{
Directory.CreateDirectory(DigiClayConstant.CLAY_DATA_PATH);
Debug.Log("CLAY_DATA_PATH Directory created.");
}
var lStream = new FileStream(DigiClayConstant.CLAY_DATA_PATH + meshName + ".obj", FileMode.Create);
var lOBJData = Mesh.EncodeOBJ();
OBJLoader.ExportOBJ(lOBJData, lStream);
lStream.Close();
Debug.Log("Mesh Saved.");
AssetDatabase.Refresh();
ClayObject co = ScriptableObject.CreateInstance <ClayObject>();
co.ClayName = meshName;
co.ClayMesh = ClayMesh;
co.ModelFile = AssetDatabase.LoadMainAssetAtPath(DigiClayConstant.CLAY_DATA_PATH + meshName + ".obj");
AssetDatabase.CreateAsset(co, DigiClayConstant.CLAY_DATA_PATH + meshName + " ClayData.asset");
Debug.Log(AssetDatabase.GetAssetPath(co));
AssetDatabase.SaveAssets();
}
void SetClayObjectFromSource(ClayObject source, ClayObject target)
{
target.transform.localPosition = source.transform.localPosition;
target.transform.localRotation = source.transform.localRotation;
target.transform.localScale = source.transform.localScale;
target.color = source.color;
target.blend = source.blend;
}
void pickingDone()
{
if (this.pickedClayxelId != -1 && this.pickedSolidId != -1 && this.pickedSolidId < 255)
{
ClayObject clayObj = this.clayxels[this.pickedClayxelId].getClayObj(this.pickedSolidId);
this.pickedClayObj = clayObj.gameObject;
}
this.clearPicking();
}
private void Start()
{
clayObject = GetComponent <ClayObject>();
clayObjectNull = clayObject == null;
if (!clayObjectNull)
{
fromClayObject = fromTransform.GetComponent <ClayObject>();
toClayObject = toTransform.GetComponent <ClayObject>();
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
ClayObject co = (ClayObject)target;
if (GUILayout.Button("Link"))
{
co.Link();
}
EditorGUILayout.HelpBox("Clay", MessageType.Info);
}
public ClayObject addSolid()
{
GameObject clayObj = new GameObject("claySolid");
clayObj.transform.parent = this.transform;
ClayObject clayObjComp = clayObj.AddComponent <ClayObject>();
clayObjComp.clayxelContainerRef = new WeakReference(this);
clayObjComp.color = new Color(1.0f, 1.0f, 1.0f, 1.0f);
this.solidsContainerNeedsUpdate = true;
return(clayObjComp);
}
void Start()
{
UIManager.Instance.AddCommand("Load All Mesh", () => {
var files = Directory.GetFiles(DigiClayConstant.CLAY_DATA_PATH, "*.obj");
foreach (var f in files)
{
Debug.Log(f);
}
//TODO load mesh data
});
UIManager.Instance.AddCommand("Create Clay Object", () => {
ClayObject a = ScriptableObject.CreateInstance <ClayObject>();
AssetDatabase.CreateAsset(a, DigiClayConstant.CLAY_DATA_PATH + "MyClay.asset");
Debug.Log(AssetDatabase.GetAssetPath(a));
});
}
void onSelectionChanged()
{
if (this.invalidated)
{
return;
}
if (this.meshCached)
{
return;
}
this.editingThisContainer = false;
if (UnityEditor.Selection.Contains(this.gameObject))
{
// check if this container got selected
this.editingThisContainer = true;
}
if (!this.editingThisContainer)
{
// check if one of thye clayObjs in container has been selected
for (int i = 0; i < this.clayObjects.Count; ++i)
{
ClayObject clayObj = (ClayObject)this.clayObjects[i].Target;
if (clayObj != null)
{
if (UnityEditor.Selection.Contains(clayObj.gameObject))
{
this.editingThisContainer = true;
return;
}
}
}
}
if (Clayxel.lastUpdatedContainerId != this.GetInstanceID())
{
this.switchComputeData();
}
}
void updateSolids()
{
Matrix4x4 thisMatInv = this.transform.worldToLocalMatrix;
float minNegativeBlend = (this.splatRadius * 2.0f); // makes negative blends less sharp, less artifacts
for (int i = 0; i < this.clayObjects.Count; ++i)
{
ClayObject clayObj = (ClayObject)this.clayObjects[i].Target;
Matrix4x4 clayObjMat = thisMatInv * clayObj.transform.localToWorldMatrix;
float blend = clayObj.blend;
if (blend < 0.0f)
{
blend = clayObj.blend - minNegativeBlend;
}
this.solidsPos[i] = (Vector3)clayObjMat.GetColumn(3);
this.solidsRot[i] = clayObjMat.rotation;
this.solidsScale[i] = clayObj.transform.localScale * 0.5f;
this.solidsBlend[i] = blend;
this.solidsType[i] = clayObj.primitiveType;
this.solidsColor[i] = new Vector3(clayObj.color.r, clayObj.color.g, clayObj.color.b);
this.solidsAttrs[i] = clayObj.attrs;
}
if (this.clayObjects.Count == 0)
{
return;
}
this.solidsPosBuffer.SetData(this.solidsPos);
this.solidsRotBuffer.SetData(this.solidsRot);
this.solidsScaleBuffer.SetData(this.solidsScale);
this.solidsBlendBuffer.SetData(this.solidsBlend);
this.solidsTypeBuffer.SetData(this.solidsType);
this.solidsColorBuffer.SetData(this.solidsColor);
this.solidsAttrsBuffer.SetData(this.solidsAttrs);
}
void onUndoPerformed()
{
if (Undo.GetCurrentGroupName() == "changed clayobject" ||
Undo.GetCurrentGroupName() == "changed clayxel container")
{
this.needsUpdate = true;
}
else if (Undo.GetCurrentGroupName() == "changed clayxel grid")
{
this.init();
}
else if (Undo.GetCurrentGroupName() == "added clayxel solid")
{
this.needsUpdate = true;
}
else if (Undo.GetCurrentGroupName() == "Selection Change")
{
if (UnityEditor.Selection.Contains(this.gameObject))
{
this.init();
}
else
{
if (UnityEditor.Selection.gameObjects.Length > 0)
{
ClayObject clayObj = UnityEditor.Selection.gameObjects[0].GetComponent <ClayObject>();
if (clayObj != null)
{
if (clayObj.getClayxelContainer() == this)
{
this.needsUpdate = true;
}
}
}
}
}
}
void scanRecursive(Transform trn)
{
if (this.clayObjects.Count == 128)
{
return;
}
ClayObject clayObj = trn.gameObject.GetComponent <ClayObject>();
if (clayObj != null)
{
if (clayObj.isValid() && trn.gameObject.activeSelf)
{
this.clayObjects.Add(new WeakReference(clayObj));
clayObj.transform.hasChanged = true;
clayObj.cacheClayxelContainer();
}
}
for (int i = 0; i < trn.childCount; ++i)
{
this.scanRecursive(trn.GetChild(i));
}
}
public override void OnInspectorGUI()
{
ClayObject clayObj = (ClayObject)this.targets[0];
EditorGUI.BeginChangeCheck();
float blend = EditorGUILayout.FloatField("blend", clayObj.blend);
Color color = EditorGUILayout.ColorField("color", clayObj.color);
Clayxel clayxel = clayObj.getClayxelContainer();
int primitiveType = EditorGUILayout.Popup("solidType", clayObj.primitiveType, clayxel.getSolidsCatalogueLabels());
Dictionary <string, float> paramValues = new Dictionary <string, float>();
paramValues["x"] = clayObj.attrs.x;
paramValues["y"] = clayObj.attrs.y;
paramValues["z"] = clayObj.attrs.z;
paramValues["w"] = clayObj.attrs.w;
List <string[]> parameters = clayxel.getSolidsCatalogueParameters(primitiveType);
List <string> wMaskLabels = new List <string>();
for (int paramIt = 0; paramIt < parameters.Count; ++paramIt)
{
string[] parameterValues = parameters[paramIt];
string attr = parameterValues[0];
string label = parameterValues[1];
string defaultValue = parameterValues[2];
if (primitiveType != clayObj.primitiveType)
{
// reset to default params when changing primitive type
paramValues[attr] = float.Parse(defaultValue);
}
if (attr.StartsWith("w"))
{
wMaskLabels.Add(label);
}
else
{
paramValues[attr] = EditorGUILayout.FloatField(label, paramValues[attr]);
}
}
if (wMaskLabels.Count > 0)
{
paramValues["w"] = (float)EditorGUILayout.MaskField("options", (int)clayObj.attrs.w, wMaskLabels.ToArray());
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(this.targets, "changed clayobject");
for (int i = 1; i < this.targets.Length; ++i)
{
bool somethingChanged = false;
ClayObject currentClayObj = (ClayObject)this.targets[i];
if (clayObj.blend != blend)
{
currentClayObj.blend = blend;
somethingChanged = true;
}
if (clayObj.color != color)
{
currentClayObj.color = color;
somethingChanged = true;
}
if (clayObj.primitiveType != primitiveType)
{
currentClayObj.primitiveType = primitiveType;
somethingChanged = true;
}
if (clayObj.attrs.x != paramValues["x"])
{
currentClayObj.attrs.x = paramValues["x"];
somethingChanged = true;
}
if (clayObj.attrs.y != paramValues["y"])
{
currentClayObj.attrs.y = paramValues["y"];
somethingChanged = true;
}
if (clayObj.attrs.z != paramValues["z"])
{
currentClayObj.attrs.z = paramValues["z"];
somethingChanged = true;
}
if (clayObj.attrs.w != paramValues["w"])
{
currentClayObj.attrs.w = paramValues["w"];
somethingChanged = true;
}
if (somethingChanged)
{
currentClayObj.getClayxelContainer().needsUpdate = true;
}
}
clayObj.blend = blend;
clayObj.color = color;
clayObj.primitiveType = primitiveType;
clayObj.attrs.x = paramValues["x"];
clayObj.attrs.y = paramValues["y"];
clayObj.attrs.z = paramValues["z"];
clayObj.attrs.w = paramValues["w"];
clayxel.needsUpdate = true;
UnityEditor.EditorApplication.QueuePlayerLoopUpdate();
clayxel.getSceneView().Repaint();
#if DEBUG_CLAYXEL_REPAINT_WARN
Debug.Log("editor update");
#endif
}
}
public override void OnInspectorGUI()
{
Clayxel clayxel = (Clayxel)this.target;
EditorGUILayout.LabelField("Clayxels, V0.462 beta");
EditorGUILayout.LabelField("contained clayObjects: " + clayxel.getNumClayObjects());
EditorGUILayout.LabelField("limit is 64 on free version");
EditorGUILayout.Space();
EditorGUI.BeginChangeCheck();
int chunkSize = EditorGUILayout.IntField("resolution", clayxel.chunkSize);
int numChunksX = EditorGUILayout.IntField("containerSizeX", clayxel.numChunksX);
int numChunksY = EditorGUILayout.IntField("containerSizeY", clayxel.numChunksY);
int numChunksZ = EditorGUILayout.IntField("containerSizeZ", clayxel.numChunksZ);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(this.target, "changed clayxel grid");
clayxel.chunkSize = chunkSize;
clayxel.numChunksX = numChunksX;
clayxel.numChunksY = numChunksY;
clayxel.numChunksZ = numChunksZ;
clayxel.init();
clayxel.needsUpdate = true;
UnityEditor.EditorApplication.QueuePlayerLoopUpdate();
clayxel.getSceneView().Repaint();
#if DEBUG_CLAYXEL_REPAINT_WARN
Debug.Log("ClayxelInspector 1!");
#endif
return;
}
bool showContainer = EditorGUILayout.Toggle("showContainer", clayxel.showContainer);
EditorGUILayout.Space();
EditorGUI.BeginChangeCheck();
float materialSmoothness = EditorGUILayout.FloatField("Smoothness", clayxel.materialSmoothness);
float materialMetallic = EditorGUILayout.FloatField("Metallic", clayxel.materialMetallic);
Color materialEmission = EditorGUILayout.ColorField("Emission", clayxel.materialEmission);
float splatSizeMultiplier = EditorGUILayout.FloatField("clayxelsSize", clayxel.splatSizeMultiplier);
float normalOrientedSplat = EditorGUILayout.FloatField("clayxelsNormalOriented", clayxel.normalOrientedSplat);
Texture2D splatTexture = (Texture2D)EditorGUILayout.ObjectField("clayxelsTexture", clayxel.splatTexture, typeof(Texture2D), false);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(this.target, "changed clayxel container");
clayxel.showContainer = showContainer;
clayxel.materialSmoothness = materialSmoothness;
clayxel.materialMetallic = materialMetallic;
clayxel.materialEmission = materialEmission;
clayxel.splatSizeMultiplier = splatSizeMultiplier;
clayxel.normalOrientedSplat = normalOrientedSplat;
clayxel.splatTexture = splatTexture;
if (clayxel.normalOrientedSplat < 0.0f)
{
clayxel.normalOrientedSplat = 0.0f;
}
else if (clayxel.normalOrientedSplat > 1.0f)
{
clayxel.normalOrientedSplat = 1.0f;
}
clayxel.updateSplatLook();
clayxel.needsUpdate = true;
UnityEditor.EditorApplication.QueuePlayerLoopUpdate();
clayxel.getSceneView().Repaint();
#if DEBUG_CLAYXEL_REPAINT_WARN
Debug.Log("ClayxelInspector 2!");
#endif
return;
}
EditorGUILayout.Space();
if (GUILayout.Button("reload all"))
{
Clayxel.reloadAll();
}
if (GUILayout.Button("pick solid (p)"))
{
ClaySceneViewer.getGlobalInstance().startPicking();
}
if (GUILayout.Button("add solid"))
{
ClayObject clayObj = ((Clayxel)this.target).addSolid();
Undo.RegisterCreatedObjectUndo(clayObj.gameObject, "added clayxel solid");
UnityEditor.Selection.objects = new GameObject[] { clayObj.gameObject };
clayxel.needsUpdate = true;
UnityEditor.EditorApplication.QueuePlayerLoopUpdate();
clayxel.getSceneView().Repaint();
return;
}
if (!clayxel.hasCachedMesh())
{
if (GUILayout.Button("freeze to mesh"))
{
clayxel.generateMesh();
}
}
else
{
if (GUILayout.Button("defrost clayxels"))
{
clayxel.disableMesh();
UnityEditor.EditorApplication.QueuePlayerLoopUpdate();
clayxel.getSceneView().Repaint();
}
}
}
private void Update()
{
uiContainer.transform.LookAt(Camera.main.transform);
if (lastTargetedClayObject != null)
{
MeshRenderer meshRenderer = lastTargetedClayObject.GetComponent <MeshRenderer>();
meshRenderer.enabled = false;
lastTargetedClayObject.transform.hasChanged = true;
lastTargetedClayObject = null;
}
GameObject targetObject = null;
ClayObject targetedClayObject = null;
// NOTE(Juan): Tool selection
Vector2 lastJoystickAxis = joystickVector.GetLastAxis(inputSource);
bool toolSelectionEnabled = grabed == null && lastJoystickAxis.magnitude > 0.5f;
if (grabed == null)
{
for (int toolIndex = 0; toolIndex < toolCount; ++toolIndex)
{
toolSprites[toolIndex].gameObject.SetActive(toolSelectionEnabled);
}
if (!toolSelectionEnabled && justSelectedTool)
{
justSelectedTool = false;
ChangeTool(selectedTool);
}
if (toolSelectionEnabled)
{
float toolSelectionDelta = Mathf.PI * 2f / toolCount;
toolSelector.transform.localPosition = new Vector3(lastJoystickAxis.x * TOOL_SELECTOR_SIZE, lastJoystickAxis.y * TOOL_SELECTOR_SIZE, 0);
float angle = Angle(lastJoystickAxis);
int selectedToolIndex = Mathf.RoundToInt(angle / toolSelectionDelta) % toolCount;
for (int toolIndex = 0; toolIndex < toolCount; ++toolIndex)
{
toolSprites[toolIndex].transform.localScale = Vector3.one * (toolIndex == selectedToolIndex ? SELECTED_TOOL_SCALE : DESELECTED_TOOL_SCALE);
toolSprites[toolIndex].color = (toolIndex == selectedToolIndex ? SELECTED_TOOL_COLOR : DESELECTED_TOOL_COLOR);
}
selectedTool = (ClayVRTool)selectedToolIndex;
toolText.text = selectedTool.ToString();
justSelectedTool = true;
}
else
{
toolSelector.transform.localPosition = Vector3.zero;
}
float maxDistance = raycastLength;
RaycastHit[] hitResults = new RaycastHit[10];
int hitCount = Physics.SphereCastNonAlloc(new Ray(raycastPoint.transform.position, raycastPoint.transform.forward),
raycastRadius, hitResults, maxDistance, ClayVR.instance.objectLayerMask);
if (hitCount > 0)
{
float closestDistance = maxDistance * 10f;
for (int i = 0; i < hitCount; ++i)
{
float tempDistance = Vector3.Distance(hitResults[i].transform.position, raycastPoint.transform.position);
if (tempDistance < closestDistance)
{
targetObject = hitResults[i].transform.gameObject;
}
}
targetedClayObject = targetObject.GetComponent <ClayObject>();
if (targetedClayObject != null)
{
targetedClayObject.transform.hasChanged = true;
}
lastTargetedClayObject = targetedClayObject;
MeshRenderer meshRenderer = lastTargetedClayObject.GetComponent <MeshRenderer>();
meshRenderer.enabled = true;
meshRenderer.material = ClayVR.instance.highlightMaterial;
}
}
else
{
MeshRenderer meshRenderer = grabed.GetComponent <MeshRenderer>();
meshRenderer.enabled = true;
meshRenderer.material = ClayVR.instance.grabbedMaterial;
}
if (grabGrip.GetLastStateDown(inputSource) && grabed == null)
{
if (targetedClayObject != null)
{
originalGrabParent = targetObject.transform.parent;
if (originalGrabParent.GetComponent <ClayContainer>())
{
targetedClayObject.steppedUpdate = .1f;
grabed = targetedClayObject;
if (currentTool == ClayVRTool.MOVE)
{
grabed.transform.SetParent(transform);
}
}
}
}
if (grabGrip.GetLastStateUp(inputSource) && grabed != null)
{
if (currentTool == ClayVRTool.MOVE)
{
grabed.transform.SetParent(originalGrabParent);
}
grabed.steppedUpdate = 0;
grabed.transform.hasChanged = true;
grabed = null;
}
Vector3 rootPosition = transform.position;
Vector3 rootDelta = (rootPosition - lastRootPositon) * TOOL_SENSIBILITY;
lastRootPositon = rootPosition;
toolText.color = Color.white;
colorPicker.SetActive(!toolSelectionEnabled && currentTool == ClayVRTool.COLOR);
if (grabed)
{
Vector3 toolDelta = grabed.transform.InverseTransformDirection(rootDelta);
if (currentTool == ClayVRTool.SCALE)
{
Vector3 scale = grabed.transform.localScale;
scale.x = Mathf.Abs(scale.x + toolDelta.x);
scale.y = Mathf.Abs(scale.y + toolDelta.y);
scale.z = Mathf.Abs(scale.z + toolDelta.z);
grabed.transform.localScale = scale;
}
else if (currentTool == ClayVRTool.BLEND)
{
grabed.blend = Mathf.Clamp(grabed.blend + toolDelta.y, -1, 1);
toolText.text = currentTool.ToString() + "\n" + grabed.blend.ToString("0.00");
}
else if (currentTool == ClayVRTool.PRIMITIVE)
{
if (interactButton.GetLastStateDown(inputSource))
{
grabed.primitiveType = (grabed.primitiveType + 1) % 4;
grabed.transform.hasChanged = true;
}
if ((ClayVRPrimitive)grabed.primitiveType == ClayVRPrimitive.CUBE)
{
grabed.attrs.x = Mathf.Clamp(grabed.attrs.x + toolDelta.x, -1, 1);
toolText.text = currentTool.ToString() + "\n" + ((ClayVRPrimitive)grabed.primitiveType).ToString() + "\n" +
string.Format("Round: {0}", grabed.attrs.x.ToString("0.00"));
}
else if ((ClayVRPrimitive)grabed.primitiveType == ClayVRPrimitive.CYLINDER)
{
grabed.attrs.x = Mathf.Clamp(grabed.attrs.x + toolDelta.x, -1, 1);
grabed.attrs.y = Mathf.Clamp(grabed.attrs.y + toolDelta.y, -1, 1);
grabed.attrs.z = Mathf.Clamp(grabed.attrs.z + toolDelta.z, -1, 1);
toolText.text = currentTool.ToString() + "\n" + ((ClayVRPrimitive)grabed.primitiveType).ToString() + "\n" +
string.Format("Round {0}\nSharp {1}\nCone {2}", grabed.attrs.x.ToString("0.00"), grabed.attrs.y.ToString("0.00"), grabed.attrs.z.ToString("0.00"));
}
else if ((ClayVRPrimitive)grabed.primitiveType == ClayVRPrimitive.TORUS)
{
grabed.attrs.x = Mathf.Clamp(grabed.attrs.x + toolDelta.x, -1, 1);
toolText.text = currentTool.ToString() + "\n" + ((ClayVRPrimitive)grabed.primitiveType).ToString() + "\n" +
string.Format("Fat {0}", grabed.attrs.x.ToString("0.00"));
}
else
{
toolText.text = currentTool.ToString() + "\n" + ((ClayVRPrimitive)grabed.primitiveType).ToString();
}
grabed.transform.hasChanged = true;
}
else if (currentTool == ClayVRTool.COLOR)
{
if (colorToolHSV)
{
grabed.color = Color.HSVToRGB(pickedColor.x, pickedColor.y, pickedColor.z);
}
else
{
grabed.color = new Color(pickedColor.x, pickedColor.y, pickedColor.z);
}
}
}
else if (!toolSelectionEnabled)
{
Vector3 toolDelta = transform.InverseTransformDirection(rootDelta);
//if(toolDelta.magnitude > 0)
//{
// Debug.Log(string.Format("X: {0} | Y: {1} | Z: {2}", toolDelta.x.ToString("0.000"), toolDelta.y.ToString("0.000"), toolDelta.z.ToString("0.000")));
//}
if (currentTool == ClayVRTool.PRIMITIVE)
{
if (interactButton.GetLastStateDown(inputSource))
{
if (targetedClayObject != null)
{
GameObject pieceObject = ClayVR.ClonePiece(targetedClayObject.gameObject, ClayVR.instance.inEditContainer.transform);
pieceObject.transform.position = transform.position;
}
else
{
GameObject pieceObject = ClayVR.CreatePiece(ClayVR.instance.inEditContainer.transform);
pieceObject.transform.position = transform.position;
pieceObject.transform.localScale = Vector3.one * 0.1f;
}
}
}
if (currentTool == ClayVRTool.COLOR)
{
if (interactButton.GetLastStateDown(inputSource))
{
if (targetedClayObject != null)
{
pickedColor.x = targetedClayObject.color.r;
pickedColor.y = targetedClayObject.color.g;
pickedColor.z = targetedClayObject.color.b;
}
else
{
if (colorToolHSV)
{
Color color = Color.HSVToRGB(pickedColor.x, pickedColor.y, pickedColor.z);
pickedColor.x = color.r;
pickedColor.y = color.g;
pickedColor.z = color.b;
}
else
{
Color color = new Color(pickedColor.x, pickedColor.y, pickedColor.z);
Color.RGBToHSV(color, out pickedColor.x, out pickedColor.y, out pickedColor.z);
}
colorToolHSV = !colorToolHSV;
}
}
if (grabGrip.GetState(inputSource))
{
pickedColor.x = Mathf.Clamp(pickedColor.x + toolDelta.x, 0, 1); // R / HUE
pickedColor.y = Mathf.Clamp(pickedColor.y + toolDelta.y, 0, 1); // G / SATURATION
pickedColor.z = Mathf.Clamp(pickedColor.z + toolDelta.z, 0, 1); // B / VALUE
}
toolSelector.transform.localPosition = new Vector3((pickedColor.x * 2 - 1) * TOOL_SELECTOR_SIZE, (pickedColor.y * 2 - 1) * TOOL_SELECTOR_SIZE, 0);
if (colorToolHSV)
{
colorPickerMaterial.SetFloat("_ZCoord", pickedColor.z);
colorPickerMaterial.SetFloat("_HSV", 1);
toolText.text = currentTool.ToString() + "\n" + string.Format("H: {0}, S: {1}, V: {2}", pickedColor.x.ToString("0.00"), pickedColor.y.ToString("0.00"), pickedColor.z.ToString("0.00"));
toolText.color = Color.HSVToRGB(pickedColor.x, pickedColor.y, pickedColor.z);
}
else
{
colorPickerMaterial.SetFloat("_ZCoord", pickedColor.z);
colorPickerMaterial.SetFloat("_HSV", -1);
toolText.text = currentTool.ToString() + "\n" + string.Format("R: {0}, G: {1}, B: {2}", pickedColor.x.ToString("0.00"), pickedColor.y.ToString("0.00"), pickedColor.z.ToString("0.00"));
toolText.color = new Color(pickedColor.x, pickedColor.y, pickedColor.z);
}
}
}
}
