BlackMATov/unity-iso-tools
1
0
Fork 0
mirror of https://github.com/BlackMATov/unity-iso-tools.git synced 2025-12-13 15:52:03 +07:00
Code Issues Packages Projects Releases Wiki Activity

name refactor

Browse Source
This commit is contained in:
Matvey Cherevko
2016-12-29 07:11:48 +07:00
parent 70a28c743d
commit 6e15ee2d45
12 changed files with 236 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Assets/IsoTools/Addons/Tiled/Internal/Editor/TiledMapAssetEditor.cs
View File

@@ -30,7 +30,7 @@ namespace IsoTools.Tiled.Internal {
var map_data = _asset.Data;
var iso_object = map_go.AddComponent<IsoObject>();
iso_object.mode = IsoObject.Mode.Mode3d;
iso_object.renderersMode = IsoObject.RenderersMode.Mode3d;
iso_object.position = Vector3.zero;
iso_object.size = IsoUtils.Vec3FromXY(map_data.Height, map_data.Width);

26
Assets/IsoTools/Scripts/Internal/IsoBehaviour.cs
View File

@@ -1,6 +1,10 @@
using UnityEngine;
using System.Collections.Generic;
#if UNITY_EDITOR
using UnityEditor;
#endif
namespace IsoTools.Internal {
public abstract class IsoBehaviour<T> : MonoBehaviour
where T : IsoBehaviour<T>
@@ -14,10 +18,18 @@ namespace IsoTools.Internal {
//
// ---------------------------------------------------------------------
public bool IsActive() {
return isActiveAndEnabled && gameObject.activeInHierarchy;
public void Internal_SetDirtyInEditorMode() {
#if UNITY_EDITOR
EditorUtility.SetDirty(this);
#endif
}
// ---------------------------------------------------------------------
//
// Protected
//
// ---------------------------------------------------------------------
protected IsoWorld FindFirstActiveWorld() {
IsoWorld ret_value = null;
GetComponentsInParent<IsoWorld>(false, _tempWorlds);
@@ -40,6 +52,16 @@ namespace IsoTools.Internal {
return _behaviours[index];
}
// ---------------------------------------------------------------------
//
// Public
//
// ---------------------------------------------------------------------
public bool IsActive() {
return isActiveAndEnabled && gameObject.activeInHierarchy;
}
// ---------------------------------------------------------------------
//
// Virtual

71
Assets/IsoTools/Scripts/Internal/IsoHolder.cs
View File

@@ -1,71 +0,0 @@
using System.Collections.Generic;
namespace IsoTools.Internal {
public abstract class IsoHolder<THold, TInst> : IsoBehaviour<THold>
where THold : IsoHolder <THold, TInst>
where TInst : IsoInstance <THold, TInst>
{
IsoAssocList<TInst> _instances = new IsoAssocList<TInst>();
static List<TInst> _tempInstances = new List<TInst>();
// ---------------------------------------------------------------------
//
// Private
//
// ---------------------------------------------------------------------
void RecacheChildrenHolders() {
GetComponentsInChildren<TInst>(false, _tempInstances);
for ( int i = 0, e = _tempInstances.Count; i < e; ++i ) {
_tempInstances[i].RecacheHolder();
}
_tempInstances.Clear();
}
// ---------------------------------------------------------------------
//
// Internal
//
// ---------------------------------------------------------------------
public void AddInstance(TInst instance) {
if ( instance && instance.IsActive() ) {
_instances.Add(instance);
OnAddInstanceToHolder(instance);
}
}
public void RemoveInstance(TInst instance) {
if ( instance ) {
_instances.Remove(instance);
OnRemoveInstanceFromHolder(instance);
}
}
protected IsoAssocList<TInst> GetInstances() {
return _instances;
}
// ---------------------------------------------------------------------
//
// Virtual
//
// ---------------------------------------------------------------------
protected override void OnEnable() {
base.OnEnable();
RecacheChildrenHolders();
}
protected override void OnDisable() {
base.OnDisable();
RecacheChildrenHolders();
}
protected virtual void OnAddInstanceToHolder(TInst instance) {
}
protected virtual void OnRemoveInstanceFromHolder(TInst instance) {
}
}
}

81
Assets/IsoTools/Scripts/Internal/IsoInstance.cs
View File

@@ -1,81 +0,0 @@
using System.Collections.Generic;
namespace IsoTools.Internal {
public abstract class IsoInstance<THold, TInst> : IsoBehaviour<TInst>
where THold : IsoHolder <THold, TInst>
where TInst : IsoInstance <THold, TInst>
{
THold _holder = null;
static List<THold> _tempHolders = new List<THold>();
// ---------------------------------------------------------------------
//
// Private
//
// ---------------------------------------------------------------------
THold FindFirstActiveHolder() {
THold ret_value = null;
GetComponentsInParent<THold>(false, _tempHolders);
for ( int i = 0, e = _tempHolders.Count; i < e; ++i ) {
var holder = _tempHolders[i];
if ( holder.IsActive() ) {
ret_value = holder;
break;
}
}
_tempHolders.Clear();
return ret_value;
}
// ---------------------------------------------------------------------
//
// Internal
//
// ---------------------------------------------------------------------
public void ResetHolder() {
if ( _holder ) {
_holder.RemoveInstance(this as TInst);
_holder = null;
}
}
public void RecacheHolder() {
ResetHolder();
if ( IsActive() ) {
_holder = FindFirstActiveHolder();
if ( _holder ) {
_holder.AddInstance(this as TInst);
}
}
}
protected THold GetHolder() {
if ( !_holder ) {
RecacheHolder();
}
return _holder;
}
// ---------------------------------------------------------------------
//
// Virtual
//
// ---------------------------------------------------------------------
protected override void OnEnable() {
base.OnEnable();
RecacheHolder();
}
protected override void OnDisable() {
base.OnDisable();
ResetHolder();
}
protected virtual void OnTransformParentChanged() {
RecacheHolder();
}
}
}

63
Assets/IsoTools/Scripts/Internal/IsoObjectBase.cs Normal file
View File

@@ -0,0 +1,63 @@
namespace IsoTools.Internal {
public abstract class IsoObjectBase : IsoBehaviour<IsoObject> {
IsoWorld _isoWorld = null;
// ---------------------------------------------------------------------
//
// Internal
//
// ---------------------------------------------------------------------
public void Internal_ResetIsoWorld() {
if ( _isoWorld ) {
_isoWorld.Internal_RemoveIsoObject(this as IsoObject);
_isoWorld = null;
}
}
public void Internal_RecacheIsoWorld() {
Internal_ResetIsoWorld();
if ( IsActive() ) {
_isoWorld = FindFirstActiveWorld();
if ( _isoWorld ) {
_isoWorld.Internal_AddIsoObject(this as IsoObject);
}
}
}
// ---------------------------------------------------------------------
//
// Public
//
// ---------------------------------------------------------------------
public IsoWorld isoWorld {
get {
if ( !_isoWorld ) {
Internal_RecacheIsoWorld();
}
return _isoWorld;
}
}
// ---------------------------------------------------------------------
//
// Virtual
//
// ---------------------------------------------------------------------
protected override void OnEnable() {
base.OnEnable();
Internal_RecacheIsoWorld();
}
protected override void OnDisable() {
base.OnDisable();
Internal_ResetIsoWorld();
}
protected virtual void OnTransformParentChanged() {
Internal_RecacheIsoWorld();
}
}
}

0
Assets/IsoTools/Scripts/Internal/IsoInstance.cs.meta → Assets/IsoTools/Scripts/Internal/IsoObjectBase.cs.meta
View File

20
Assets/IsoTools/Scripts/Internal/IsoScreenSolver.cs
View File

@@ -151,14 +151,14 @@ namespace IsoTools.Internal {
//
// ---------------------------------------------------------------------
public void OnAddInstance(IsoObject iso_object) {
public void OnAddIsoObject(IsoObject iso_object) {
iso_object.Internal.QTItem = _quadTree.AddItem(
iso_object.Internal.QTBounds,
iso_object);
_minIsoXY = IsoUtils.Vec2Min(_minIsoXY, iso_object.position);
}
public void OnRemoveInstance(IsoObject iso_object) {
public void OnRemoveIsoObject(IsoObject iso_object) {
_oldVisibles.Remove(iso_object);
_curVisibles.Remove(iso_object);
if ( iso_object.Internal.QTItem != null ) {
@@ -168,7 +168,7 @@ namespace IsoTools.Internal {
ClearIsoObjectDepends(iso_object);
}
public bool OnMarkDirtyInstance(IsoObject iso_object) {
public bool OnMarkDirtyIsoObject(IsoObject iso_object) {
if ( iso_object.Internal.QTItem != null ) {
iso_object.Internal.QTItem = _quadTree.MoveItem(
iso_object.Internal.QTBounds,
@@ -198,9 +198,9 @@ namespace IsoTools.Internal {
//
// ---------------------------------------------------------------------
public void StepSortingAction(IsoWorld iso_world, IsoAssocList<IsoObject> instances) {
Profiler.BeginSample("IsoScreenSolver.ProcessInstances");
ProcessInstances(instances);
public void StepSortingAction(IsoWorld iso_world, IsoAssocList<IsoObject> iso_objects) {
Profiler.BeginSample("IsoScreenSolver.ProcessIsoObjects");
ProcessIsoObjects(iso_objects);
Profiler.EndSample();
Profiler.BeginSample("IsoScreenSolver.ProcessVisibles");
ProcessVisibles(iso_world.isSortInSceneView);
@@ -236,10 +236,10 @@ namespace IsoTools.Internal {
//
// ---------------------------------------------------------------------
void ProcessInstances(IsoAssocList<IsoObject> instances) {
if ( instances.Count > 0 ) {
for ( int i = 0, e = instances.Count; i < e; ++i ) {
var iso_object = instances[i];
void ProcessIsoObjects(IsoAssocList<IsoObject> iso_objects) {
if ( iso_objects.Count > 0 ) {
for ( int i = 0, e = iso_objects.Count; i < e; ++i ) {
var iso_object = iso_objects[i];
if ( !IsoUtils.Vec2Approximately(
iso_object.Internal.LastTrans,
iso_object.Internal.Transform.position) )

16
Assets/IsoTools/Scripts/Internal/IsoSortingSolver.cs
View File

@@ -19,19 +19,19 @@ namespace IsoTools.Internal {
//
// ---------------------------------------------------------------------
public void OnAddInstance(IsoObject iso_object) {
if ( iso_object.cacheRenderers ) {
public void OnAddIsoObject(IsoObject iso_object) {
if ( iso_object.isCachedRenderers ) {
iso_object.UpdateCachedRenderers();
}
}
public void OnRemoveInstance(IsoObject iso_object) {
if ( iso_object.cacheRenderers ) {
public void OnRemoveIsoObject(IsoObject iso_object) {
if ( iso_object.isCachedRenderers ) {
iso_object.ClearCachedRenderers();
}
}
public bool OnMarkDirtyInstance(IsoObject iso_object) {
public bool OnMarkDirtyIsoObject(IsoObject iso_object) {
return false;
}
@@ -77,7 +77,7 @@ namespace IsoTools.Internal {
iso_object.Internal.Dirty = false;
mark_dirty = true;
}
if ( iso_object.mode == IsoObject.Mode.Mode3d ) {
if ( iso_object.renderersMode == IsoObject.RenderersMode.Mode3d ) {
if ( UpdateIsoObjectBounds3d(iso_object) ) {
mark_dirty = true;
}
@@ -141,7 +141,7 @@ namespace IsoTools.Internal {
}
List<Renderer> GetIsoObjectRenderers(IsoObject iso_object) {
if ( iso_object.cacheRenderers ) {
if ( iso_object.isCachedRenderers ) {
return iso_object.Internal.Renderers;
} else {
iso_object.GetComponentsInChildren<Renderer>(_tmpRenderers);
@@ -174,7 +174,7 @@ namespace IsoTools.Internal {
for ( int i = 0, e = self_depends.Count; i < e; ++i ) {
start_depth = RecursivePlaceIsoObject(self_depends[i], step_depth, start_depth);
}
if ( iso_object.mode == IsoObject.Mode.Mode3d ) {
if ( iso_object.renderersMode == IsoObject.RenderersMode.Mode3d ) {
var zoffset = iso_object.Internal.Offset3d;
var extents = iso_object.Internal.MinMax3d.size;
PlaceIsoObject(iso_object, start_depth + extents * 0.5f + zoffset);

68
Assets/IsoTools/Scripts/Internal/IsoWorldBase.cs Normal file
View File

@@ -0,0 +1,68 @@
using System.Collections.Generic;
namespace IsoTools.Internal {
public abstract class IsoWorldBase : IsoBehaviour<IsoWorld> {
IsoAssocList<IsoObject> _isoObjects = new IsoAssocList<IsoObject>();
static List<IsoObject> _tempIsoObjects = new List<IsoObject>();
// ---------------------------------------------------------------------
//
// Private
//
// ---------------------------------------------------------------------
void RecacheIsoObjectWorlds() {
GetComponentsInChildren<IsoObject>(false, _tempIsoObjects);
for ( int i = 0, e = _tempIsoObjects.Count; i < e; ++i ) {
_tempIsoObjects[i].Internal_RecacheIsoWorld();
}
_tempIsoObjects.Clear();
}
// ---------------------------------------------------------------------
//
// Internal
//
// ---------------------------------------------------------------------
public void Internal_AddIsoObject(IsoObject iso_object) {
if ( iso_object && iso_object.IsActive() ) {
_isoObjects.Add(iso_object);
OnAddIsoObjectToWorld(iso_object);
}
}
public void Internal_RemoveIsoObject(IsoObject iso_object) {
if ( iso_object ) {
_isoObjects.Remove(iso_object);
OnRemoveIsoObjectFromWorld(iso_object);
}
}
protected IsoAssocList<IsoObject> GetIsoObjects() {
return _isoObjects;
}
// ---------------------------------------------------------------------
//
// Virtual
//
// ---------------------------------------------------------------------
protected override void OnEnable() {
base.OnEnable();
RecacheIsoObjectWorlds();
}
protected override void OnDisable() {
base.OnDisable();
RecacheIsoObjectWorlds();
}
protected virtual void OnAddIsoObjectToWorld(IsoObject iso_object) {
}
protected virtual void OnRemoveIsoObjectFromWorld(IsoObject iso_object) {
}
}
}

0
Assets/IsoTools/Scripts/Internal/IsoHolder.cs.meta → Assets/IsoTools/Scripts/Internal/IsoWorldBase.cs.meta
View File

54
Assets/IsoTools/Scripts/IsoObject.cs
View File

@@ -2,14 +2,10 @@ using UnityEngine;
using IsoTools.Internal;
using System.Collections.Generic;
#if UNITY_EDITOR
using UnityEditor;
#endif
namespace IsoTools {
[SelectionBase]
[ExecuteInEditMode, DisallowMultipleComponent]
public sealed class IsoObject : IsoInstance<IsoWorld, IsoObject> {
public sealed class IsoObject : IsoObjectBase {
// ---------------------------------------------------------------------
//
@@ -142,22 +138,22 @@ namespace IsoTools {
// ---------------------------------------------------------------------
//
// Mode
// Renderers mode
//
// ---------------------------------------------------------------------
public enum Mode {
public enum RenderersMode {
Mode2d,
Mode3d
}
[SerializeField]
Mode _mode = Mode.Mode2d;
RenderersMode _renderersMode = RenderersMode.Mode2d;
public Mode mode {
get { return _mode; }
public RenderersMode renderersMode {
get { return _renderersMode; }
set {
_mode = value;
_renderersMode = value;
FixTransform();
}
}
@@ -169,12 +165,12 @@ namespace IsoTools {
// ---------------------------------------------------------------------
[SerializeField]
bool _cacheRenderers = false;
bool _cachedRenderers = false;
public bool cacheRenderers {
get { return _cacheRenderers; }
public bool isCachedRenderers {
get { return _cachedRenderers; }
set {
_cacheRenderers = value;
_cachedRenderers = value;
if ( value ) {
UpdateCachedRenderers();
} else {
@@ -208,16 +204,10 @@ namespace IsoTools {
// ---------------------------------------------------------------------
//
// Functions
// Public
//
// ---------------------------------------------------------------------
public IsoWorld isoWorld {
get {
return GetHolder();
}
}
public void FixTransform() {
var iso_world = isoWorld;
var cached_transform = FixCachedTransform();
@@ -249,6 +239,12 @@ namespace IsoTools {
Internal.Renderers.Clear();
}
// ---------------------------------------------------------------------
//
// Private
//
// ---------------------------------------------------------------------
void FixScreenBounds() {
var iso_world = isoWorld;
if ( iso_world ) {
@@ -277,11 +273,9 @@ namespace IsoTools {
void MartDirtyIsoWorld() {
var iso_world = isoWorld;
if ( iso_world ) {
iso_world.MarkDirty(this);
iso_world.Internal_MarkDirty(this);
}
#if UNITY_EDITOR
EditorUtility.SetDirty(this);
#endif
Internal_SetDirtyInEditorMode();
}
// ---------------------------------------------------------------------
@@ -316,15 +310,15 @@ namespace IsoTools {
void Reset() {
size = Vector3.one;
position = Vector3.zero;
mode = Mode.Mode2d;
cacheRenderers = false;
renderersMode = RenderersMode.Mode2d;
isCachedRenderers = false;
}
void OnValidate() {
size = _size;
position = _position;
mode = _mode;
cacheRenderers = _cacheRenderers;
renderersMode = _renderersMode;
isCachedRenderers = _cachedRenderers;
}
void OnDrawGizmos() {

71
Assets/IsoTools/Scripts/IsoWorld.cs
View File

@@ -1,14 +1,9 @@
using UnityEngine;
using IsoTools.Internal;
using System.Collections.Generic;
#if UNITY_EDITOR
using UnityEditor;
#endif
namespace IsoTools {
[ExecuteInEditMode, DisallowMultipleComponent]
public sealed class IsoWorld : IsoHolder<IsoWorld, IsoObject> {
public sealed class IsoWorld : IsoWorldBase {
Matrix4x4 _isoMatrix = Matrix4x4.identity;
Matrix4x4 _isoRMatrix = Matrix4x4.identity;
@@ -180,10 +175,11 @@ namespace IsoTools {
}
public Vector3 TouchIsoPosition(int finger_id, float iso_z) {
if ( !Camera.main ) {
var camera = Camera.main;
if ( !camera ) {
throw new UnityException("Main camera not found!");
}
return TouchIsoPosition(finger_id, Camera.main, iso_z);
return TouchIsoPosition(finger_id, camera, iso_z);
}
public Vector3 TouchIsoPosition(int finger_id, Camera camera) {
@@ -192,7 +188,7 @@ namespace IsoTools {
public Vector3 TouchIsoPosition(int finger_id, Camera camera, float iso_z) {
if ( !camera ) {
throw new UnityException("Camera argument is incorrect!");
throw new UnityException("Camera argument is null!");
}
for ( var i = 0; i < Input.touchCount; ++i ) {
var touch = Input.GetTouch(i);
@@ -238,10 +234,11 @@ namespace IsoTools {
}
public Vector3 MouseIsoPosition(float iso_z) {
if ( !Camera.main ) {
var camera = Camera.main;
if ( !camera ) {
throw new UnityException("Main camera not found!");
}
return MouseIsoPosition(Camera.main, iso_z);
return MouseIsoPosition(camera, iso_z);
}
public Vector3 MouseIsoPosition(Camera camera) {
@@ -250,7 +247,7 @@ namespace IsoTools {
public Vector3 MouseIsoPosition(Camera camera, float iso_z) {
if ( !camera ) {
throw new UnityException("Camera argument is incorrect!");
throw new UnityException("Camera argument is null!");
}
return ScreenToIso(
camera.ScreenToWorldPoint(Input.mousePosition),
@@ -329,12 +326,12 @@ namespace IsoTools {
//
// ---------------------------------------------------------------------
public void MarkDirty(IsoObject iso_object) {
if ( _screenSolver.OnMarkDirtyInstance(iso_object) ) {
MarkDirty();
public void Internal_MarkDirty(IsoObject iso_object) {
if ( _screenSolver.OnMarkDirtyIsoObject(iso_object) ) {
Internal_SetDirtyInEditorMode();
}
if ( _sortingSolver.OnMarkDirtyInstance(iso_object) ) {
MarkDirty();
if ( _sortingSolver.OnMarkDirtyIsoObject(iso_object) ) {
Internal_SetDirtyInEditorMode();
}
}
@@ -344,12 +341,6 @@ namespace IsoTools {
//
// ---------------------------------------------------------------------
void MarkDirty() {
#if UNITY_EDITOR
EditorUtility.SetDirty(this);
#endif
}
void UpdateIsoMatrix() {
_isoMatrix =
Matrix4x4.Scale(new Vector3(1.0f, tileRatio, 1.0f)) *
@@ -360,23 +351,23 @@ namespace IsoTools {
_isoRMatrix = _isoMatrix.inverse;
}
void FixInstanceTransforms() {
var instances = GetInstances();
for ( int i = 0, e = instances.Count; i < e; ++i ) {
instances[i].FixTransform();
void FixIsoObjectTransforms() {
var iso_objects = GetIsoObjects();
for ( int i = 0, e = iso_objects.Count; i < e; ++i ) {
iso_objects[i].FixTransform();
}
}
void ChangeSortingProperty() {
MarkDirty();
UpdateIsoMatrix();
FixInstanceTransforms();
FixIsoObjectTransforms();
Internal_SetDirtyInEditorMode();
}
void StepSortingProcess() {
_screenSolver.StepSortingAction(this, GetInstances());
_screenSolver.StepSortingAction(this, GetIsoObjects());
if ( _sortingSolver.StepSortingAction(this, _screenSolver) ) {
MarkDirty();
Internal_SetDirtyInEditorMode();
}
}
@@ -405,16 +396,16 @@ namespace IsoTools {
_sortingSolver.Clear();
}
protected override void OnAddInstanceToHolder(IsoObject instance) {
base.OnAddInstanceToHolder(instance);
_screenSolver.OnAddInstance(instance);
_sortingSolver.OnAddInstance(instance);
protected override void OnAddIsoObjectToWorld(IsoObject iso_object) {
base.OnAddIsoObjectToWorld(iso_object);
_screenSolver.OnAddIsoObject(iso_object);
_sortingSolver.OnAddIsoObject(iso_object);
}
protected override void OnRemoveInstanceFromHolder(IsoObject instance) {
base.OnRemoveInstanceFromHolder(instance);
_screenSolver.OnRemoveInstance(instance);
_sortingSolver.OnRemoveInstance(instance);
protected override void OnRemoveIsoObjectFromWorld(IsoObject iso_object) {
base.OnRemoveIsoObjectFromWorld(iso_object);
_screenSolver.OnRemoveIsoObject(iso_object);
_sortingSolver.OnRemoveIsoObject(iso_object);
}
#if UNITY_EDITOR
@@ -439,7 +430,7 @@ namespace IsoTools {
void OnRenderObject() {
var camera = Camera.current;
if ( camera && camera.name == "SceneCamera" ) {
MarkDirty();
Internal_SetDirtyInEditorMode();
}
}