/// <summary>
/// Instansiate new brick in place of all one.
/// Copy to new brick position, rotation and scale.
/// Make old brick inactive.
/// </summary>
/// <returns>The new brick.</returns>
/// <param name="newBrickPath">New brick resources path.</param>
/// <param name="oldBrick">Old brick.</param>
Brick ChangeBrick(string newBrickPath, AgaQBrick oldBrick)
{
var newBrick = BrickBuilder.InstansiateFromResources(newBrickPath);
if (newBrick == null)
{
return(null);
}
newBrick.transform.position = oldBrick.transform.position;
newBrick.transform.rotation = oldBrick.transform.rotation;
newBrick.transform.localScale = oldBrick.transform.localScale;
if (oldBrick.isDragging && ToolsManager.instance.tool is MoveTool)
{
//let exchange bricks in move tool
(ToolsManager.instance.tool as MoveTool).ChangeBrick(newBrick as DragableBrick);
}
else
{
oldBrick.gameObject.SetActive(false);
}
return(newBrick);
}
/// <summary>
/// Prepare property to display given dimension
/// </summary>
/// <param name="brick">Brick.</param>
/// <param name="index">Property index.</param>
public override void ConfigureProperty(AgaQBrick brick, int index)
{
base.ConfigureProperty(brick, index);
if (brick.dimensionGroup.dimensions[index].readOnly)
{
valueText.gameObject.SetActive(true);
valueText.text = brick.dimensionParams[index];
valueDropDown.gameObject.SetActive(false);
}
else
{
valueText.gameObject.SetActive(false);
valueDropDown.gameObject.SetActive(true);
valueDropDown.ClearOptions();
for (int i = 0; i < values.Length; i++)
{
var option = new Dropdown.OptionData(values[i]);
valueDropDown.options.Add(option);
if (brick.dimensionParams[index] == values[i])
{
valueDropDown.value = i;
}
}
}
}
/// <summary>
/// Change brick dimension.
/// Undefhood is replacing models.
/// </summary>
/// <returns><c>true</c>, if dimension was changed, <c>false</c> otherwise.</returns>
/// <param name="brick">Brick.</param>
public bool ChangeDimension(AgaQBrick brick, int propertyIndex, int valueIndex)
{
//check if new set of diemnsions is valid
var values = brick.dimensionGroup.GetPropertyValues(propertyIndex);
var newValues = brick.dimensionParams;
newValues[propertyIndex] = values[valueIndex];
var brickPath = brick.dimensionGroup.GetBrickPathForValues(newValues);
if (brickPath == null)
{
return(false);
}
//change brick
var newBrick = ChangeBrick(brickPath, brick);
if (newBrick == null)
{
return(false);
}
//register history
if (brick != null)
{
HistoryManager.instance.Register(new HistoryNodeDimension(brick.gameObject, newBrick.gameObject));
}
//change selection
SelectionManager.instance.Clear();
SelectionManager.instance.Add(newBrick as SelectableBrick);
return(true);
}
/// <summary>
/// Check current brick position. Check if it is valid (all joints fits).
/// </summary>
/// <returns><c>true</c>, if position is valid, <c>false</c> otherwise.</returns>
bool CheckPosition(PossibleJoint possibleJoint)
{
var brickJoints = possibleJoint.projectedBrickJoint.joint.parentBrick.joints;
//Check free joints with another neighbour bricks
//get bounds
AgaQBrick brick = possibleJoint.projectedBrickJoint.joint.parentBrick;
var bounds = brick.GetBounds();
//extend it by joint size
bounds.Expand(jointColisionDistance * 2);
//collide with other bricks
var otherBricks = Physics.OverlapBox(bounds.center, bounds.extents, brick.transform.rotation, 1);
//check joints at those other bricks
foreach (var otherBrick in otherBricks)
{
if (otherBrick.gameObject == possibleJoint.projectedBrickJoint.joint.parentBrick.gameObject)
{
continue;
}
var agaQBrick = otherBrick.GetComponent <AgaQBrick>();
if (agaQBrick != null && !CheckJoints(brickJoints, agaQBrick.joints))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Prepare property to display given dimension
/// </summary>
/// <param name="brick">Brick.</param>
/// <param name="index">Property index.</param>
public override void ConfigureProperty(AgaQBrick brick, int index)
{
base.ConfigureProperty(brick, index);
valueToggle.isOn = brick.dimensionParams[index] == "1";
valueToggle.enabled = !brick.dimensionGroup.dimensions[index].readOnly;
}
void RebuiltGroupData(DimensionGroup group)
{
//find all bricks in resources
var separator = Path.DirectorySeparatorChar;
string path = string.Concat("Assets", separator, "Resources", separator, "AgaQ");
var bricks = AssetDatabase.FindAssets("t:Prefab", new string[] { path });
//remove all data about bricks in group
group.bricksInGroup.Clear();
//iterate over found items an collect data
foreach (var brickGUID in bricks)
{
var brickPath = AssetDatabase.GUIDToAssetPath(brickGUID);
GameObject brickObject = AssetDatabase.LoadAssetAtPath <GameObject>(brickPath);
AgaQBrick brickScript = brickObject.GetComponent <AgaQBrick>();
brickPath = brickPath.Substring(17, brickPath.Length - 17 - 7); //remove trailing path /Assets/Resources/ and extension .prefab
if (brickScript.dimensionGroup == group)
{
brickScript.name = string.Format(group.groupName, brickScript.dimensionParams);
//add brick to group
group.bricksInGroup.Add(new DimensionGroupItem(brickPath, brickScript.dimensionParams));
}
}
EditorUtility.SetDirty(target);
}
/// <summary>
/// Build dimencsion properties
/// </summary>
/// <param name="brick">Brick.</param>
public void PrepareProperties(AgaQBrick brick)
{
Clear();
if (brick.dimensionGroup == null)
{
return;
}
int index = 0;
foreach (var dimension in brick.dimensionGroup.dimensions)
{
GameObject propertyObject;
if (dimension.paramType == Bricks.DimensionsGroups.DimensionParamType.boolean)
{
propertyObject = Instantiate(DimensionBoolPropertyPrefab);
}
else if (dimension.paramType == Bricks.DimensionsGroups.DimensionParamType.floatNumber ||
dimension.paramType == Bricks.DimensionsGroups.DimensionParamType.integerNumber)
{
propertyObject = Instantiate(DimensionNumberPropertyPrefab);
}
else
{
propertyObject = Instantiate(DimensionStringPropertyPrefab);
}
propertyObject.transform.SetParent(transform);
var propertyScript = propertyObject.GetComponent <InspectorDimensionProperty>();
propertyScript.ConfigureProperty(brick, index);
properties.Add(propertyScript);
index++;
}
//load description image
string imagePath = brick.dimensionGroup.translationImageResourcePath;
var translation = LeanLocalization.GetTranslation(imagePath);
if (translation != null)
{
imagePath = translation.Text;
if (Application.platform == RuntimePlatform.WindowsPlayer || Application.platform == RuntimePlatform.WindowsEditor)
{
imagePath = imagePath.Replace('/', '\\');
}
var sprite = Resources.Load <Sprite>(imagePath);
if (sprite != null)
{
descriptionImage.SetImage(sprite);
}
}
}
/// <summary>
/// Prepare property to display given dimension
/// </summary>
/// <param name="brick">Brick.</param>
/// <param name="index">Property index.</param>
public virtual void ConfigureProperty(AgaQBrick brick, int index)
{
this.brick = brick;
groupPropIndex = index;
values = brick.dimensionGroup.GetPropertyValues(index);
//set label
var translationKey = brick.dimensionGroup.dimensions[index].translationLabel;
var translation = LeanLocalization.GetTranslation(translationKey);
string translatedLabel = translation == null ? translationKey : translation.Text;
labelText.text = translatedLabel;
}
/// <summary>
/// Prepare property to display given dimension
/// </summary>
/// <param name="brick">Brick.</param>
/// <param name="index">Property index.</param>
public override void ConfigureProperty(AgaQBrick brick, int index)
{
base.ConfigureProperty(brick, index);
//value
currentValueIndex = Array.IndexOf(values, brick.dimensionParams[index]);
valueText.text = brick.dimensionParams[index];
//controls
bool show = !brick.dimensionGroup.dimensions[index].readOnly;
plusButton.SetActive(show);
minusButton.SetActive(show);
}
/// <summary>
/// Project joints to screen coordinates.
/// </summary>
/// <returns>The joints.</returns>
/// <param name="brick">AgaQ brick</param>
public static ProjectedJoint[] ProjectJoints(AgaQBrick brick)
{
ProjectedJoint[] brickJoints = new ProjectedJoint[brick.joints.Length];
//itareate over all joints and move its coordinates to screen space
int j = 0;
for (int i = 0; i < brickJoints.Length; i++)
{
if (brick.joints[i].other == null)
{
brickJoints[j++] = new ProjectedJoint(ProjectPosition(brick.joints[i].transform.position), brick.joints[i]);
}
}
Array.Resize <ProjectedJoint>(ref brickJoints, j);
return(brickJoints);
}
/// <summary>
/// Encapsulate all object components into child brick.
/// </summary>
void Encapsualte(AgaQBrick brick)
{
//create new GameObject
var childBrick = new GameObject("brick");
childBrick.transform.SetParent(brick.transform);
childBrick.transform.localPosition = Vector3.zero;
//move all children from brick to childBrick
for (int i = brick.transform.childCount - 1; i >= 0; i--)
{
var child = brick.transform.GetChild(i);
if (child != childBrick.transform)
{
child.SetParent(childBrick.transform);
}
}
//move all colliders
var colliders = brick.GetComponents <Collider>();
foreach (var collider in colliders)
{
ComponentUtility.CopyComponent(collider);
ComponentUtility.PasteComponentAsNew(childBrick);
DestroyImmediate(collider);
}
//move mesh
var meshFilter = brick.GetComponent <MeshFilter>();
var renderer = brick.GetComponent <MeshRenderer>();
if (meshFilter != null && renderer != null)
{
ComponentUtility.CopyComponent(meshFilter);
ComponentUtility.PasteComponentAsNew(childBrick);
ComponentUtility.CopyComponent(renderer);
ComponentUtility.PasteComponentAsNew(childBrick);
DestroyImmediate(renderer);
DestroyImmediate(meshFilter);
}
}
public void BeforeTests()
{
GameObject gameObject = new GameObject();
brick = gameObject.AddComponent <AgaQBrick>();
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.PropertyField(serializedObject.FindProperty("name"));
serializedObject.ApplyModifiedProperties();
//Encapsualte button
GUILayout.Space(10);
AgaQBrick brick = target as AgaQBrick;
if (!brick.gameObject.transform.Find("brick") && GUILayout.Button("Encapsulate"))
{
Encapsualte(brick);
}
//Group
GUILayout.Space(10);
brick.dimensionGroup = EditorGUILayout.ObjectField(brick.dimensionGroup, typeof(DimensionGroup), false) as DimensionGroup;
DimensionGroup group = brick.dimensionGroup;
if (group != null)
{
//group params
GUILayout.Space(10);
GUILayout.BeginVertical();
int index = 0;
if (brick.dimensionParams == null || group.dimensions.Length != brick.dimensionParams.Length)
{
brick.dimensionParams = new string[group.dimensions.Length];
}
foreach (var dimension in group.dimensions)
{
GUILayout.BeginHorizontal();
//label
GUILayout.Label(dimension.translationLabel);
//property field
if (dimension.paramType == DimensionParamType.integerNumber)
{
int val = 0;
int.TryParse(brick.dimensionParams[index], out val);
val = EditorGUILayout.IntField(val);
brick.dimensionParams[index] = val.ToString();
}
else if (dimension.paramType == DimensionParamType.floatNumber)
{
float val = 0;
float.TryParse(brick.dimensionParams[index], out val);
val = EditorGUILayout.FloatField(val);
brick.dimensionParams[index] = val.ToString();
}
else if (dimension.paramType == DimensionParamType.text)
{
brick.dimensionParams[index] = EditorGUILayout.TextField(brick.dimensionParams[index]);
}
else if (dimension.paramType == DimensionParamType.boolean)
{
bool toggleValue = brick.dimensionParams[index] == "1";
bool toggleNewValue = EditorGUILayout.Toggle(toggleValue);
brick.dimensionParams[index] = toggleValue ? "1" : "0";
}
GUILayout.EndHorizontal();
index++;
}
GUILayout.EndVertical();
}
GUILayout.Space(10);
if (GUILayout.Button("Move colliders"))
{
var colliders = brick.gameObject.GetComponentsInChildren <Collider>();
foreach (var collider in colliders)
{
Collider newCollider = brick.gameObject.AddComponent(collider.GetType()) as Collider;
EditorUtility.CopySerialized(collider, newCollider);
if (newCollider is BoxCollider)
{
((BoxCollider)newCollider).center += collider.gameObject.transform.localPosition;
}
DestroyImmediate(collider);
}
}
EditorUtility.SetDirty(brick);
}
