/// <summary>
/// Computes camera poses on a cylinder.
/// </summary>
/// <param name="cameraCount"></param> The number of cameras on the circular section and on the vertical side of the cylinder.
/// <param name="setupDirection"></param> The direction of the cylinder setup, inward or outward.
public void ComputeCylinderPoses(Vector2Int cameraCount, SetupDirection setupDirection)
{
// Compute several preliminary values.
Transform parentTransform = cameraModels[0].transform.parent;
float horizontalDegreesPerIteration = 360f / cameraCount.x;
int facingDirection = (setupDirection == SetupDirection.Outwards) ? 1 : -1;
int numberOfVerticalIntervals = cameraCount.y - 1;
float verticalIntervalSize = 1f / Mathf.Max(1, numberOfVerticalIntervals);
float distanceToClosestVerticalCam = Mathf.Abs(parentTransform.lossyScale.y) * verticalIntervalSize;
// Update the camera model of all source cameras.
for (int j = 0; j < cameraCount.y; j++)
{
for (int i = 0; i < cameraCount.x; i++)
{
int index = j * cameraCount.x + i;
CameraModel cameraModel = cameraModels[index];
cameraModel.SetCameraReferenceIndexAndImageName(index + 1, index.ToString("0000") + ".png");
cameraModel.transform.localRotation = Quaternion.AngleAxis(i * horizontalDegreesPerIteration, -Vector3.up);
cameraModel.transform.localPosition = facingDirection * (cameraModel.transform.localRotation * Vector3.forward) + ((j - 0.5f * numberOfVerticalIntervals) * verticalIntervalSize) * Vector3.up;
cameraModel.UpdateDistanceToClosestCam(distanceToClosestVerticalCam);
CheckCamDistanceWithOthersInSetup(index, Mathf.Max(0, index - 1), index);
}
}
// Set the initial viewing position so that the viewer will look outwards from within, or inwards from without, based on the specified setup direction.
initialViewingPosition = (facingDirection == 1) ? parentTransform.position : parentTransform.position - 1.5f * parentTransform.localScale.magnitude * parentTransform.forward;
}
/// <summary>
/// Computes camera poses on a sphere.
/// </summary>
/// <param name="cameraCount"></param> The number of cameras on each of the arcs of the sphere.
/// <param name="setupDirection"></param> The direction of the sphere setup, inward or outward.
public void ComputeSpherePoses(Vector2Int cameraCount, SetupDirection setupDirection)
{
// Compute several preliminary values.
Transform parentTransform = cameraModels[0].transform.parent;
Vector3 lossyScale = parentTransform.lossyScale;
Vector2 intervalArcDistance = Vector2.one / cameraCount;
Vector2 degreesPerIteration = new Vector2(360f, 180f) * intervalArcDistance;
int facingDirection = (setupDirection == SetupDirection.Outwards) ? 1 : -1;
// Update the camera model of all source cameras.
for (int j = 0; j < cameraCount.y; j++)
{
for (int i = 0; i < cameraCount.x; i++)
{
int index = j * cameraCount.x + i;
CameraModel cameraModel = cameraModels[index];
cameraModel.SetCameraReferenceIndexAndImageName(index + 1, index.ToString("0000") + ".png");
cameraModel.transform.localRotation = Quaternion.AngleAxis(i * degreesPerIteration.x, -Vector3.up) * Quaternion.AngleAxis(-90f + (j + 0.5f) * degreesPerIteration.y, -Vector3.right);
cameraModel.transform.localPosition = facingDirection * (cameraModel.transform.localRotation * Vector3.forward);
CheckCamDistanceWithOthersInSetup(index, Mathf.Max(0, index - cameraCount.x), index);
}
}
// Set the initial viewing position so that the viewer will look outwards from within, or inwards from without, based on the specified setup direction.
initialViewingPosition = (facingDirection == 1) ? parentTransform.position : parentTransform.position - 1.5f * parentTransform.localScale.magnitude * parentTransform.forward;
}
public void StartOperator(SetupDirection direction)
{
blockingEnemy.Clear();
setupDirection = direction;
string lastAnimation = operatorObject._armature.animation.lastAnimationName;
DragonBones.AnimationState lastAnimationState = operatorObject._armature.animation.lastAnimationState;
if (direction == SetupDirection.Bottom)
{
operatorObject.armature.flipX = false;
_underlayObject.transform.localEulerAngles = new Vector3(_underlayObject.transform.localEulerAngles.x, 270f, _underlayObject.transform.localEulerAngles.z);
DrowRange(SetupDirection.Bottom);
}
if (direction == SetupDirection.Top)
{
string armatureName = operatorObject.armatureName;
ChangeArmatureData(operatorObject, armatureName.Replace("_Front", "_Back"), operatorObject.unityData.dataName);
operatorObject._armature.animation.Play("Idle", 0);
operatorObject.armature.flipX = false;
operatorObject.DBUpdate();
_underlayObject.transform.localEulerAngles = new Vector3(_underlayObject.transform.localEulerAngles.x, 90f, _underlayObject.transform.localEulerAngles.z);
DrowRange(SetupDirection.Top);
}
if (direction == SetupDirection.Left)
{
operatorObject.armature.flipX = true;
_underlayObject.transform.localEulerAngles = new Vector3(_underlayObject.transform.localEulerAngles.x, 0f, _underlayObject.transform.localEulerAngles.z);
DrowRange(SetupDirection.Left);
}
if (direction == SetupDirection.Right)
{
operatorObject.armature.flipX = false;
_underlayObject.transform.localEulerAngles = new Vector3(_underlayObject.transform.localEulerAngles.x, 180f, _underlayObject.transform.localEulerAngles.z);
DrowRange(SetupDirection.Right);
}
StartCoroutine(AnimationStartOperator());
StartCoroutine(EnemySearch());
StartCoroutine(AnimationAttack());
StartCoroutine(_operatorData.skill.SkillPointGenerate(this, _operatorData.skill.initCost));
}
/// <summary>
/// Resets the object's properties.
/// </summary>
void Reset()
{
// Reset the key child components.
_cameraSetup = CameraSetup.CreateOrResetCameraSetup(transform);
_dataHandler = DataHandler.CreateOrResetDataHandler(transform);
_previewCameraManager = PreviewCameraManager.CreateOrResetPreviewCameraManager(transform);
#if UNITY_EDITOR
// Reset parameters to their default values.
_cameraPrefab = null;
_cameraCount = new Vector2Int(4, 4);
_acquireDepthData = false;
_copyGlobalMesh = false;
_setupType = SetupType.Grid;
_setupDirection = SetupDirection.Outwards;
_lockSetup = false;
// Update the acquisition camera poses to reflect the updated setup.
ComputeAcquisitionCameraPoses();
// Create a preview camera from the prefab.
CreatePreviewCameraFromPrefab();
#endif //UNITY_EDITOR
}
/// <summary>
/// Computes camera poses on a sphere.
/// </summary>
/// <param name="parentTransform"></param> The parent transform.
/// <param name="cameraCount"></param> The number of cameras on each of the arcs of the sphere.
/// <param name="setupDirection"></param> The direction of the sphere setup, inward or outward.
public void ComputeSpherePoses(Transform parentTransform, Vector2Int cameraCount, SetupDirection setupDirection)
{
// Compute several preliminary values.
Vector2 intervalArcDistance = Vector2.one / cameraCount;
Vector2 degreesPerIteration = new Vector2(360f, 180f) * intervalArcDistance;
int facingDirection = (setupDirection == SetupDirection.Outwards) ? 1 : -1;
Vector3 absScale = new Vector3(Mathf.Abs(parentTransform.lossyScale.x), Mathf.Abs(parentTransform.lossyScale.y), Mathf.Abs(parentTransform.lossyScale.z));
// Update the camera model of all source cameras.
for (int j = 0; j < cameraCount.y; j++)
{
for (int i = 0; i < cameraCount.x; i++)
{
int index = j * cameraCount.x + i;
CameraModel cameraModel = cameraModels[index];
cameraModel.SetCameraReferenceIndexAndImageName(index, index.ToString("0000") + ".png");
cameraModel.transform.rotation = Quaternion.AngleAxis(i * degreesPerIteration.x, -parentTransform.up) * Quaternion.AngleAxis(-90f + (j + 0.5f) * degreesPerIteration.y, -parentTransform.right) * parentTransform.rotation;
cameraModel.transform.position = parentTransform.position + Vector3.Scale(cameraModels[index].transform.rotation * Vector3.forward, facingDirection * absScale);
}
}
// Set the initial viewing position so that the viewer will look outwards from within, or inwards from without, based on the specified setup direction.
initialViewingPosition = (facingDirection == 1) ? parentTransform.position : parentTransform.position - 1.5f * parentTransform.localScale.magnitude * parentTransform.forward;
// Compute the inter-camera distance factor (here: minimum inter-camera distance).
float interCamDistanceFactor = 1f;
int totalCameraCount = cameraCount.x * cameraCount.y;
if (totalCameraCount > 1)
{
float xDistance = (cameraModels[1].transform.position - cameraModels[0].transform.position).magnitude;
if (xDistance > 0)
{
interCamDistanceFactor = xDistance;
}
int halfHeightIndexOne = (Mathf.FloorToInt(cameraCount.y / 2) - 1) * cameraCount.x;
int halfHeightIndexTwo = (halfHeightIndexOne + cameraCount.x);
float yDistance = (cameraModels[halfHeightIndexOne % totalCameraCount].transform.position - cameraModels[halfHeightIndexTwo % totalCameraCount].transform.position).magnitude;
if (yDistance > 0)
{
interCamDistanceFactor = Mathf.Min(interCamDistanceFactor, yDistance);
}
}
#if UNITY_EDITOR
// Compute the gizmo size.
gizmoSize = ComputeGizmoSize(cameraModels, interCamDistanceFactor);
UpdateGizmosSize();
#endif //UNITY_EDITOR
}
public void DrowRange(SetupDirection direction = SetupDirection.Right, bool isActive = false)
{
if (rangeTilesParent != null)
{
Destroy(rangeTilesParent);
rangeTiles.Clear();
}
Range.RangeOfOperator.Range rangeOfOperator = new Range.RangeOfOperator.Range();
if (direction == SetupDirection.Right)
{
rangeOfOperator = _operatorData.rangeOfOperator.ArrayTransformRightMain();
}
if (direction == SetupDirection.Top)
{
rangeOfOperator = _operatorData.rangeOfOperator.ArrayTransformTop();
}
if (direction == SetupDirection.Bottom)
{
rangeOfOperator = _operatorData.rangeOfOperator.ArrayTransformBottom();
}
if (direction == SetupDirection.Left)
{
rangeOfOperator = _operatorData.rangeOfOperator.ArrayTransformLeft();
}
bool[,] range = rangeOfOperator.array;
int operatorPositionX = rangeOfOperator.x;
int operatorPositionY = rangeOfOperator.y;
GameObject rangeTilePrefab = _operatorData.rangeOfOperator.tileRangePrefab;
rangeTilesParent = new GameObject("Range Tiles");
rangeTilesParent.transform.SetParent(transform);
rangeTilesParent.transform.localPosition = new Vector3(-0.5f, 0f, -0.5f);
for (int x = 0; x < range.GetLength(0); x++)
{
for (int y = 0; y < range.GetLength(1); y++)
{
if (range[x, y] == true || (x == operatorPositionX && y == operatorPositionY))
{
GameObject tileRange = Instantiate(rangeTilePrefab, rangeTilesParent.transform);
RangeTile rangeTileComponent = tileRange.GetComponent <RangeTile>();
rangeTileComponent.operatorController = this;
rangeTiles.Add(rangeTileComponent);
Vector3 position = Vector3.zero;
if (direction == SetupDirection.Bottom || direction == SetupDirection.Top)
{
position = new Vector3((operatorPositionY - y) * 1f, 0f, (operatorPositionX - x) * 1f);
}
if (direction == SetupDirection.Left || direction == SetupDirection.Right)
{
position = new Vector3((y - operatorPositionY) * 1f, 0f, (x - operatorPositionX) * 1f);
}
tileRange.GetComponent <BoxCollider>().enabled = isActive;
tileRange.transform.localPosition = position;
}
}
}
isShowRange = true;
}
