void Update()
{
BSMath.DrawTarget dtar;
if (ShowBlock)
{
if (BSMath.RayCastDrawTarget(Camera.main.ScreenPointToRay(Input.mousePosition), BuildingMan.Voxels, out dtar, minVol, true, BuildingMan.Datas))
{
m_Center = dtar.snapto;
}
else
{
m_Center = InvalidPos;
}
}
else
{
if (BSMath.RayCastDrawTarget(Camera.main.ScreenPointToRay(Input.mousePosition), BuildingMan.Voxels, out dtar, minVol))
{
m_Center = dtar.snapto;
}
else
{
m_Center = InvalidPos;
}
}
}
void GetCenterVoxel()
{
for (int vol = minVol; vol < BSMath.MC_ISO_VALUE + volAdder; vol += volAdder)
{
if (BSMath.RayCastDrawTarget(PeCamera.mouseRay, BuildingMan.Voxels, out m_DTar, vol))
{
m_Center = new IntVector3(m_DTar.snapto);
if (CheckVoxel(m_Center))
{
m_FindVoxel = true;
return;
}
}
}
//checkOriginNear
if (CheckVoxel(PeCamera.mouseRay.origin - BuildingMan.Voxels.Offset))
{
m_Center = new IntVector3(PeCamera.mouseRay.origin - BuildingMan.Voxels.Offset);
m_FindVoxel = true;
m_DTar = new BSMath.DrawTarget();
m_DTar.snapto = m_Center;
return;
}
m_FindVoxel = false;
m_Center = InvalidPos;
}
void Update()
{
BSMath.DrawTarget dtar;
if (BSMath.RayCastDrawTarget(Camera.main.ScreenPointToRay(Input.mousePosition), BuildingMan.Blocks, out dtar, BSMath.MC_ISO_VALUE, true, BuildingMan.Datas))
{
m_Center = new Vector3(Mathf.FloorToInt(dtar.snapto.x * Block45Constants._scaleInverted) * Block45Constants._scale,
Mathf.FloorToInt(dtar.snapto.y * Block45Constants._scaleInverted) * Block45Constants._scale,
Mathf.FloorToInt(dtar.snapto.z * Block45Constants._scaleInverted) * Block45Constants._scale);
}
else
{
m_Center = InvalidPos;
}
}
void Update()
{
if (dataSource == null)
{
return;
}
if (GameConfig.IsInVCE)
{
return;
}
if (m_Phase == EPhase.Free)
{
if (BSInput.s_MouseOnUI)
{
gizmoBox.gameObject.SetActive(false);
return;
}
if (BSInput.s_Cancel)
{
ResetDrawing();
}
// Ray cast voxel
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
BSMath.DrawTarget blockTgt = new BSMath.DrawTarget();
BSMath.DrawTarget voxelTgt = new BSMath.DrawTarget();
bool castBlock = BSMath.RayCastDrawTarget(ray, dataSource, out blockTgt, minvol, true);
bool castVoxel = BSMath.RayCastDrawTarget(ray, dataSource, out voxelTgt, minvol, true, BuildingMan.Voxels);
if (castBlock || castVoxel)
{
if (!gizmoBox.gameObject.activeSelf)
{
gizmoBox.gameObject.SetActive(true);
}
Vector3 cursor = m_Target.cursor;
if (castBlock && castVoxel)
{
if (blockTgt.rch.distance <= voxelTgt.rch.distance)
{
m_Target = blockTgt;
cursor = CalcSnapto(m_Target, dataSource, pattern);
m_Cursor = m_Target.rch.point;
}
else
{
m_Target = voxelTgt;
cursor = CalcCursor(m_Target, dataSource, 1);
m_Cursor = m_Target.rch.point;
}
}
else if (castBlock)
{
m_Target = blockTgt;
cursor = CalcSnapto(m_Target, dataSource, pattern);
m_Cursor = m_Target.rch.point;
}
else if (castVoxel)
{
m_Target = voxelTgt;
cursor = CalcCursor(m_Target, dataSource, 1);
m_Cursor = m_Target.rch.point;
}
gizmoBox.size = Vector3.one * dataSource.Scale;
gizmoBox.position = cursor + dataSource.Offset;
float offset = dataSource.Scale;
Vector3 begin = cursor;
Vector3 end = begin + new Vector3(offset, offset, offset);
// Click mouse and change phase
if (Input.GetMouseButtonDown(0))
{
m_Begin = begin;
_beginPos = begin;
m_End = end;
m_Phase = EPhase.DragPlane;
_prevMousePos = Input.mousePosition;
}
}
else
{
ResetDrawing();
}
}
else if (m_Phase == EPhase.DragPlane)
{
if (BSInput.s_Cancel)
{
ResetDrawing();
return;
}
RaycastHit rch;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
float position = 0;
if (DragPlane == ECoordPlane.XY)
{
position = m_Cursor.z;
}
else if (DragPlane == ECoordPlane.XZ)
{
position = m_Cursor.y;
}
else if (DragPlane == ECoordPlane.ZY)
{
position = m_Cursor.x;
}
if (BSMath.RayCastCoordPlane(ray, DragPlane, position, out rch))
{
m_PointBeforeAdjustHeight = rch.point;
if (!Vector3.Equals(_prevMousePos, Input.mousePosition))
{
Vector3 point = rch.point - dataSource.Offset;
if (DragPlane == ECoordPlane.XZ)
{
// x
float x = 0;
m_Begin.x = CalcValue(point.x, _beginPos.x, out x);
// z
float z = 0;
m_Begin.z = CalcValue(point.z, _beginPos.z, out z);
m_End = new Vector3(x, _beginPos.y + (pattern.size) * dataSource.Scale, z);
m_End = Clamp(m_Begin, m_End);
}
else if (DragPlane == ECoordPlane.XY)
{
// x
float x = 0;
m_Begin.x = CalcValue(point.x, _beginPos.x, out x);
// y
float y = 0;
m_Begin.y = CalcValue(point.y, _beginPos.y, out y);
m_End = new Vector3(x, y, _beginPos.z + (pattern.size) * dataSource.Scale);
m_End = Clamp(m_Begin, m_End);
}
else if (DragPlane == ECoordPlane.ZY)
{
// y
float y = 0;
m_Begin.y = CalcValue(point.y, _beginPos.y, out y);
// z
float z = 0;
m_Begin.z = CalcValue(point.z, _beginPos.z, out z);
m_End = new Vector3(_beginPos.x + (pattern.size) * dataSource.Scale, y, z);
m_End = Clamp(m_Begin, m_End);
}
gizmoBox.position = Min + dataSource.Offset;
gizmoBox.size = Size * dataSource.Scale;
}
// Click mouse and change phase
if (Input.GetMouseButtonUp(0))
{
m_Phase = EPhase.AdjustHeight;
_prevMousePos = new Vector3(-100, -100, -100);
}
}
}
else if (m_Phase == EPhase.AdjustHeight)
{
if (BSInput.s_Cancel)
{
ResetDrawing();
return;
}
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (DragPlane == ECoordPlane.XZ)
{
float adjustHeight = m_PointBeforeAdjustHeight.y;
BSMath.RayAdjustHeight(ray, ECoordAxis.Y, m_PointBeforeAdjustHeight, out adjustHeight);
// y
float y = 0;
m_Begin.y = CalcValue(adjustHeight, _beginPos.y, out y);
m_End.y = y;
}
else if (DragPlane == ECoordPlane.XY)
{
float adjustHeight = m_PointBeforeAdjustHeight.z;
BSMath.RayAdjustHeight(ray, ECoordAxis.Z, m_PointBeforeAdjustHeight, out adjustHeight);
// z
float z = 0;
m_Begin.z = CalcValue(adjustHeight, _beginPos.z, out z);
m_End.z = z;
}
else if (DragPlane == ECoordPlane.ZY)
{
float adjustHeight = m_PointBeforeAdjustHeight.x;
BSMath.RayAdjustHeight(ray, ECoordAxis.X, m_PointBeforeAdjustHeight, out adjustHeight);
// x
float x = 0;
m_Begin.x = CalcValue(adjustHeight, _beginPos.x, out x);
m_End.x = x;
}
m_End = Clamp(m_Begin, m_End);
gizmoBox.position = Min + dataSource.Offset;
gizmoBox.size = Size * dataSource.Scale;
if (PeInput.Get(PeInput.LogicFunction.Build))
{
Do();
m_Phase = EPhase.Drawing;
}
}
else if (m_Phase == EPhase.Drawing)
{
if (BSInput.s_Cancel)
{
ResetDrawing();
return;
}
if (BSInput.s_Delete)
{
DeleteVoxels();
}
}
}
protected void Update()
{
if (dataSource == null)
{
return;
}
if (BSInput.s_MouseOnUI)
{
return;
}
if (_datasource == dataSource)
{
// Clear and rebuild;
ClearSelection(null);
_datasource = dataSource;
}
if (seletionBoxeRenderer != null)
{
seletionBoxeRenderer.m_Boxes = m_SelectionBoxes;
seletionBoxeRenderer.scale = dataSource.Scale;
seletionBoxeRenderer.offset = dataSource.Offset;
}
if (m_RecalcBoxes)
{
CalcBoxes();
m_RecalcBoxes = false;
}
if (GameConfig.IsInVCE)
{
return;
}
// Depth
if (!BSInput.s_Shift && Input.GetKeyDown(KeyCode.UpArrow))
{
Depth = ++Depth >= maxDragSize ? maxDragSize : Depth;
m_GUIAlpha = 5;
}
else if (!BSInput.s_Shift && Input.GetKeyDown(KeyCode.DownArrow))
{
Depth = --Depth >= 1 ? Depth : 1;
m_GUIAlpha = 5;
}
m_GUIAlpha = Mathf.Lerp(m_GUIAlpha, 0, 0.05f);
// Drag Box
//
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (!m_Selecting)
{
// Cancel
if (BSInput.s_Cancel)
{
if (!canDo)
{
return;
}
Dictionary <IntVector3, byte> old_seletion = new Dictionary <IntVector3, byte>(m_Selections);
Cancel();
Dictionary <IntVector3, byte> new_selection = new Dictionary <IntVector3, byte>(m_Selections);
// For History
if (old_seletion.Count != 0)
{
BSSelectedBoxModify modify = new BSSelectedBoxModify(old_seletion, new_selection, this);
m_Action.AddModify(modify);
DoHistory();
}
return;
}
if (BSMath.RayCastDrawTarget(ray, dataSource, out m_Target, minvol, true, BuildingMan.Datas))
{
m_Drawing = true;
m_Begin = m_Target.snapto;
_beginPos = m_Begin;
m_End = m_Begin;
float vx = Mathf.Abs(m_Target.rch.normal.x);
float vy = Mathf.Abs(m_Target.rch.normal.y);
float vz = Mathf.Abs(m_Target.rch.normal.z);
if (vx > 0.9f * m_Target.ds.Scale)
{
m_Coord = ECoordPlane.ZY;
m_PlanePos = m_Target.rch.point.x;
}
else if (vy > 0.9f * m_Target.ds.Scale)
{
m_Coord = ECoordPlane.XZ;
m_PlanePos = m_Target.rch.point.y;
}
else if (vz > 0.9f * m_Target.ds.Scale)
{
m_Coord = ECoordPlane.XY;
m_PlanePos = m_Target.rch.point.z;
}
if (Input.GetMouseButtonDown(0))
{
if (canDo)
{
m_Selecting = true;
}
}
}
else
{
m_Drawing = false;
}
}
// Selecting
else
{
m_Drawing = true;
// Cancel
if (BSInput.s_Cancel)
{
if (!canDo)
{
return;
}
m_Selecting = false;
m_Begin = new Vector3(-10000, -10000, -10000);
m_End = new Vector3(-10000, -10000, -10000);
return;
}
RaycastHit rch;
if (BSMath.RayCastCoordPlane(ray, m_Coord, m_PlanePos, out rch))
{
Vector3 point = rch.point - dataSource.Offset;
if (m_Coord == ECoordPlane.XY)
{
// x componet
float x = 0;
m_Begin.x = CalcValue(point.x, _beginPos.x, out x);
// y componet
float y = 0;
m_Begin.y = CalcValue(point.y, _beginPos.y, out y);
m_End.x = x;
m_End.y = y;
m_End.z = Mathf.FloorToInt(point.z * dataSource.ScaleInverted) * dataSource.Scale;
if (m_Target.rch.normal.z > 0)
{
m_Begin.z = m_PlanePos - Depth * dataSource.Scale;
}
else
{
m_Begin.z = m_PlanePos + Depth * dataSource.Scale;
}
m_End = Clamp(m_Begin, m_End);
}
else if (m_Coord == ECoordPlane.XZ)
{
// x componet
float x = 0;
m_Begin.x = CalcValue(point.x, _beginPos.x, out x);
// z componet
float z = 0;
m_Begin.z = CalcValue(point.z, _beginPos.z, out z);
m_End.x = x;
m_End.y = Mathf.FloorToInt(point.y * dataSource.ScaleInverted) * dataSource.Scale;
m_End.z = z;
if (m_Target.rch.normal.y > 0)
{
m_Begin.y = m_PlanePos - Depth * dataSource.Scale;
}
else
{
m_Begin.y = m_PlanePos + Depth * dataSource.Scale;
}
m_End = Clamp(m_Begin, m_End);
}
else if (m_Coord == ECoordPlane.ZY)
{
// y componet
float y = 0;
m_Begin.y = CalcValue(point.y, _beginPos.y, out y);
// z componet
float z = 0;
m_Begin.z = CalcValue(point.z, _beginPos.z, out z);
m_End.x = Mathf.FloorToInt(point.x * dataSource.ScaleInverted) * dataSource.Scale;
m_End.y = y;
m_End.z = z;
if (m_Target.rch.normal.x > 0)
{
m_Begin.x = m_PlanePos - Depth * dataSource.Scale;
}
else
{
m_Begin.x = m_PlanePos + Depth * dataSource.Scale;
}
m_End = Clamp(m_Begin, m_End);
}
}
// In Valid area ?
if (m_PrevDS != null && m_PrevDS == dataSource)
{
if (m_Selections.Count != 0)
{
BSTools.SelBox box = new BSTools.SelBox();
box.m_Box.xMin = (short)Mathf.FloorToInt(Mathf.Min(m_Begin.x, m_End.x) * dataSource.ScaleInverted);
box.m_Box.yMin = (short)Mathf.FloorToInt(Mathf.Min(m_Begin.y, m_End.y) * dataSource.ScaleInverted);
box.m_Box.zMin = (short)Mathf.FloorToInt(Mathf.Min(m_Begin.z, m_End.z) * dataSource.ScaleInverted);
box.m_Box.xMax = (short)Mathf.FloorToInt(Mathf.Max(m_Begin.x, m_End.x) * dataSource.ScaleInverted);
box.m_Box.yMax = (short)Mathf.FloorToInt(Mathf.Max(m_Begin.y, m_End.y) * dataSource.ScaleInverted);
box.m_Box.zMax = (short)Mathf.FloorToInt(Mathf.Max(m_Begin.z, m_End.z) * dataSource.ScaleInverted);
// Add current box to list temporarily
m_SelectionBoxes.Add(box);
BSTools.IntBox bound = BSTools.SelBox.CalculateBound(m_SelectionBoxes);
Vector3 size = new Vector3(bound.xMax - bound.xMin, bound.yMax - bound.yMin, bound.zMax - bound.zMin);
if (size.x > maxSelectBoxSize.x || size.y > maxSelectBoxSize.y || size.z > maxSelectBoxSize.z)
{
m_IsValidBox = false;
}
else
{
m_IsValidBox = true;
}
// revert the list
m_SelectionBoxes.RemoveAt(m_SelectionBoxes.Count - 1);
}
else
{
m_IsValidBox = true;
}
}
else
{
m_IsValidBox = true;
}
if (Input.GetMouseButtonUp(0))
{
if (!canDo)
{
return;
}
// bool result = false;
if (m_IsValidBox)
{
// Add
if (m_PrevDS == dataSource)
{
if (BSInput.s_Shift)
{
if (m_PrevDS == dataSource)
{
/*result = */ CalcSelection(0);
}
}
// Substract
else if (BSInput.s_Alt)
{
/*result = */ CalcSelection(1);
}
// Cross
else if (BSInput.s_Control)
{
/*result = */ CalcSelection(2);
}
else
{
ClearSelection(m_Action);
/*result = */ CalcSelection(0);
}
m_PrevDS = dataSource;
}
else
{
ClearSelection(m_Action);
/*result = */ CalcSelection(0);
m_PrevDS = dataSource;
}
}
m_Selecting = false;
ResetValue();
}
}
// Other Ajust
if (AfterSelectionUpdate())
{
DoHistory();
}
}
void Update()
{
if (GameConfig.IsInVCE)
{
return;
}
if (Input.GetKeyDown(KeyCode.O))
{
Gen = true;
}
if (Gen)
{
if (m_Cursor != null)
{
Destroy(m_Cursor.gameObject);
}
m_Cursor = BIsoCursor.CreateIsoCursor(GameConfig.GetUserDataPath() + BSSaveIsoBrush.s_IsoPath + File_Name + BSSaveIsoBrush.s_Ext);
m_Rot = 0;
Gen = false;
}
if (m_Cursor == null)
{
return;
}
if (BSInput.s_Cancel)
{
Cancel();
if (onCancelClick != null)
{
onCancelClick();
}
return;
}
if (m_Cursor != null)
{
m_Cursor.gameObject.SetActive(true);
}
if (m_Cursor.ISO.m_HeadInfo.Mode == EBSVoxelType.Block)
{
if (BSMath.RayCastDrawTarget(BSInput.s_PickRay, BuildingMan.Blocks, out m_Target, BSMath.MC_ISO_VALUE, true, BuildingMan.Datas))
{
m_Cursor.gameObject.SetActive(true);
Vector3 offset = Vector3.zero;
offset.x = (m_Cursor.ISO.m_HeadInfo.xSize) / 2 * BSBlock45Data.s_Scale;
offset.z = (m_Cursor.ISO.m_HeadInfo.zSize) / 2 * BSBlock45Data.s_Scale;
if (Input.GetKeyDown(KeyCode.T))
{
m_Rot = ++m_Rot > 3 ? 0 : m_Rot;
}
m_Cursor.SetOriginOffset(-offset);
m_Cursor.transform.rotation = Quaternion.Euler(0, 90 * m_Rot, 0);
// Adjust Offset
FocusAjust();
m_Cursor.transform.position = m_Target.cursor + m_FocusOffset * BSBlock45Data.s_Scale;
if (Input.GetMouseButtonDown(0))
{
if (BSInput.s_MouseOnUI)
{
return;
}
if (m_Cursor.gizmoTrigger.RayCast)
{
return;
}
// For History
m_OldVoxel.Clear();
m_NewVoxel.Clear();
m_Indexes.Clear();
m_VoxelMap.Clear();
m_Cursor.OutputVoxels(Vector3.zero, OnOutputBlocks);
// Extra Extendable
FindExtraExtendableVoxels(dataSource, m_NewVoxel, m_OldVoxel, m_Indexes, m_VoxelMap);
// For History
BSAction action = new BSAction();
BSVoxelModify modify = new BSVoxelModify(m_Indexes.ToArray(), m_OldVoxel.ToArray(), m_NewVoxel.ToArray(), BuildingMan.Blocks, EBSBrushMode.Add);
if (!modify.IsNull())
{
action.AddModify(modify);
}
if (action.Do())
{
BSHistory.AddAction(action);
if (onBrushDo != null)
{
onBrushDo();
}
}
}
}
else
{
m_Cursor.gameObject.SetActive(false);
}
}
else if (m_Cursor.ISO.m_HeadInfo.Mode == EBSVoxelType.Block)
{
if (BSMath.RayCastDrawTarget(BSInput.s_PickRay, BuildingMan.Voxels, out m_Target, 1, true, BuildingMan.Datas))
{
m_Cursor.gameObject.SetActive(false);
Debug.Log("Draw building Iso dont support the voxel");
return;
}
else
{
m_Cursor.gameObject.SetActive(false);
}
}
}
void AddMode()
{
// Set gizmo
if (pattern != prvePattern)
{
if (Gizmo != null)
{
Destroy(Gizmo.gameObject);
Gizmo = null;
}
if (pattern.MeshPath != null && pattern.MeshPath != "")
{
Gizmo = GameObject.Instantiate(Resources.Load(pattern.MeshPath)) as GameObject;
Gizmo.transform.parent = transform;
}
prvePattern = pattern;
m_Rot = 0;
}
if (pattern.MeshMat != null && Gizmo != null)
{
Renderer gizmo_render = Gizmo.GetComponent <Renderer>();
if (gizmo_render != null)
{
gizmo_render.material = pattern.MeshMat;
}
}
// Ratate the gizmo ? Only block can rotate
if (pattern.type == EBSVoxelType.Block)
{
if (Input.GetKeyDown(KeyCode.T))
{
m_Rot = ++m_Rot > 3 ? 0 : m_Rot;
}
}
// Gizmo rotate
Vector3 rot_offset = Vector3.zero;
if (Gizmo != null)
{
Quaternion rot = Quaternion.Euler(0, 90 * m_Rot, 0);
Gizmo.transform.rotation = Quaternion.Euler(0, 90 * m_Rot, 0);
float half_size = pattern.size * 0.5f;
rot_offset = (rot * new Vector3(-half_size, -half_size, -half_size) + new Vector3(half_size, half_size, half_size)) * dataSource.Scale;
// Gizmo scale
Gizmo.transform.localScale = new Vector3(pattern.size, pattern.size, pattern.size) * dataSource.Scale;
}
// default gizmo cube
GizmoCube.m_VoxelSize = dataSource.Scale;
GizmoCube.CubeSize = new IntVector3(pattern.size, pattern.size, pattern.size);
Vector3 trigget_size = new Vector3(GizmoCube.CubeSize.x * dataSource.Scale,
GizmoCube.CubeSize.y * dataSource.Scale,
GizmoCube.CubeSize.z * dataSource.Scale);
GizmoTrigger.boxCollider.size = trigget_size;
GizmoTrigger.boxCollider.center = trigget_size * 0.5f;
// Ray cast voxel
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (BSMath.RayCastDrawTarget(ray, dataSource, out m_Target, minvol, true, BuildingMan.Datas))
{
// Show the Gizmo
if (Gizmo != null)
{
Gizmo.SetActive(true);
}
GizmoCube.gameObject.SetActive(true);
m_Cursor = CalcCursor(m_Target, dataSource, pattern.size);
// Gizmo position
FocusAjust();
m_Cursor += m_FocusOffset * dataSource.Scale;
if (Gizmo != null)
{
Gizmo.transform.position = m_Cursor + dataSource.Offset + rot_offset;
}
GizmoCube.transform.position = m_Cursor + dataSource.Offset;
// Bursh do
if (Input.GetMouseButtonDown(0) && !GizmoTrigger.RayCast)
{
Do();
}
}
}
void SubtractMode()
{
m_Rot = 0;
prvePattern = null;
if (Gizmo != null)
{
Destroy(Gizmo.gameObject);
Gizmo = null;
}
GizmoCube.gameObject.SetActive(true);
GizmoCube.m_VoxelSize = dataSource.Scale;
GizmoCube.CubeSize = new IntVector3(pattern.size, pattern.size, pattern.size);
// Ray cast voxel
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (BSMath.RayCastDrawTarget(ray, dataSource, out m_Target, minvol, false))
{
// Show the Gizmo
if (Gizmo != null)
{
Gizmo.SetActive(true);
}
if (!GizmoCube.gameObject.activeSelf)
{
GizmoCube.gameObject.SetActive(true);
}
// Cursor position
m_Cursor = CalcSnapto(m_Target, dataSource, pattern);
// Gizmo position
FocusAjust();
m_Cursor += m_FocusOffset * dataSource.Scale;
if (Gizmo != null)
{
Gizmo.transform.position = m_Cursor + dataSource.Offset;
}
GizmoCube.transform.position = m_Cursor + dataSource.Offset;
// Bursh do
if (Input.GetMouseButtonDown(0))
{
Do();
}
}
else
{
if (Gizmo != null)
{
Gizmo.SetActive(false);
}
if (GizmoCube.gameObject.activeSelf)
{
GizmoCube.gameObject.SetActive(false);
}
}
}
protected void Update()
{
if (dataSource == null)
{
return;
}
if (pattern == null)
{
return;
}
if (!ExtraAdjust())
{
return;
}
if (GameConfig.IsInVCE)
{
return;
}
gizmoCube.m_VoxelSize = dataSource.Scale;
if (m_Phase == EPhase.Free)
{
if (BSInput.s_MouseOnUI)
{
gizmoCube.gameObject.SetActive(false);
return;
}
if (BSInput.s_Cancel)
{
ResetDrawing();
}
// Ray cast voxel
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
bool ignoreDiagonal = (mode == EBSBrushMode.Add);
bool cast = BSMath.RayCastDrawTarget(ray, dataSource, out m_Target, minvol, ignoreDiagonal, BuildingMan.Datas);
if (cast)
{
Vector3 cursor = Vector3.zero;
if (mode == EBSBrushMode.Add)
{
cursor = CalcCursor(m_Target, dataSource, pattern.size);
m_Cursor = m_Target.rch.point;
}
else if (mode == EBSBrushMode.Subtract)
{
cursor = CalcSnapto(m_Target, dataSource, pattern);
m_Cursor = m_Target.rch.point;
}
m_GizmoCursor = cursor;
_drawGL = true;
gizmoCube.CubeSize = new IntVector3(pattern.size, pattern.size, pattern.size);
gizmoCube.gameObject.SetActive(true);
gizmoCube.transform.position = cursor + dataSource.Offset;
UpdateGizmoTrigger();
float offset = pattern.size * dataSource.Scale;
Vector3 begin = cursor;
Vector3 end = begin + new Vector3(offset, offset, offset);
_glCenter = cursor + new Vector3(offset, offset, offset) * 0.5f + dataSource.Offset;
_glCenter.y = begin.y;
// Click mouse and change phase
if (Input.GetMouseButtonDown(0))
{
m_Begin = begin;
_beginPos = begin;
m_End = end;
m_Phase = EPhase.DragPlane;
_prevMousePos = Input.mousePosition;
}
}
else
{
ResetDrawing();
}
// Switch the panel
if (Input.GetKeyDown(KeyCode.G))
{
if (DragPlane == ECoordPlane.XZ)
{
DragPlane = ECoordPlane.ZY;
}
else if (DragPlane == ECoordPlane.ZY)
{
DragPlane = ECoordPlane.XY;
}
else if (DragPlane == ECoordPlane.XY)
{
DragPlane = ECoordPlane.XZ;
}
Debug.Log("Switch the drag reference plane : " + DragPlane.ToString());
}
}
else if (m_Phase == EPhase.DragPlane)
{
if (BSInput.s_Cancel)
{
ResetDrawing();
return;
}
RaycastHit rch;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
float position = 0;
if (DragPlane == ECoordPlane.XY)
{
position = m_Cursor.z;
}
else if (DragPlane == ECoordPlane.XZ)
{
position = m_Cursor.y;
}
else if (DragPlane == ECoordPlane.ZY)
{
position = m_Cursor.x;
}
if (BSMath.RayCastCoordPlane(ray, DragPlane, position, out rch))
{
m_PointBeforeAdjustHeight = rch.point;
if (!Vector3.Equals(_prevMousePos, Input.mousePosition))
{
Vector3 point = rch.point - dataSource.Offset;
if (DragPlane == ECoordPlane.XZ)
{
// x
float x = 0;
m_Begin.x = CalcValue(point.x, _beginPos.x, out x);
// z
float z = 0;
m_Begin.z = CalcValue(point.z, _beginPos.z, out z);
m_End = new Vector3(x, _beginPos.y + (pattern.size) * dataSource.Scale, z);
m_End = Clamp(m_Begin, m_End);
}
else if (DragPlane == ECoordPlane.XY)
{
// x
float x = 0;
m_Begin.x = CalcValue(point.x, _beginPos.x, out x);
// y
float y = 0;
m_Begin.y = CalcValue(point.y, _beginPos.y, out y);
m_End = new Vector3(x, y, _beginPos.z + (pattern.size) * dataSource.Scale);
m_End = Clamp(m_Begin, m_End);
}
else if (DragPlane == ECoordPlane.ZY)
{
// y
float y = 0;
m_Begin.y = CalcValue(point.y, _beginPos.y, out y);
// z
float z = 0;
m_Begin.z = CalcValue(point.z, _beginPos.z, out z);
m_End = new Vector3(_beginPos.x + (pattern.size) * dataSource.Scale, y, z);
m_End = Clamp(m_Begin, m_End);
}
// other phase Drag plane
DragPlaneExtraDo(DragPlane);
gizmoCube.transform.position = Min + dataSource.Offset;
gizmoCube.CubeSize = new IntVector3((int)Size.x, (int)Size.y, (int)Size.z);
UpdateGizmoTrigger();
}
// Click mouse and change phase
if (Input.GetMouseButtonUp(0))
{
m_Phase = EPhase.AdjustHeight;
_prevMousePos = new Vector3(-100, -100, -100);
}
}
}
else if (m_Phase == EPhase.AdjustHeight)
{
if (BSInput.s_Cancel)
{
ResetDrawing();
return;
}
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
// ECoordAxis axis = ECoordAxis.Y;
if (DragPlane == ECoordPlane.XZ)
{
float adjustHeight = m_PointBeforeAdjustHeight.y;
BSMath.RayAdjustHeight(ray, ECoordAxis.Y, m_PointBeforeAdjustHeight, out adjustHeight);
// y
float y = 0;
m_Begin.y = CalcValue(adjustHeight, _beginPos.y, out y);
m_End.y = y + m_EndOffset.y;
}
else if (DragPlane == ECoordPlane.XY)
{
float adjustHeight = m_PointBeforeAdjustHeight.z;
BSMath.RayAdjustHeight(ray, ECoordAxis.Z, m_PointBeforeAdjustHeight, out adjustHeight);
// z
float z = 0;
m_Begin.z = CalcValue(adjustHeight, _beginPos.z, out z);
m_End.z = z + m_EndOffset.z;
}
else if (DragPlane == ECoordPlane.ZY)
{
float adjustHeight = m_PointBeforeAdjustHeight.x;
BSMath.RayAdjustHeight(ray, ECoordAxis.X, m_PointBeforeAdjustHeight, out adjustHeight);
// x
float x = 0;
m_Begin.x = CalcValue(adjustHeight, _beginPos.x, out x);
m_End.x = x + m_EndOffset.x;
}
m_End = Clamp(m_Begin, m_End);
// Other adjustHeight
AdjustHeightExtraDo(DragPlane);
gizmoCube.transform.position = Min + dataSource.Offset;
gizmoCube.CubeSize = new IntVector3((int)Size.x, (int)Size.y, (int)Size.z);
UpdateGizmoTrigger();
// Click mouse and change phase
//if (Input.GetMouseButtonDown(0))
if (PeInput.Get(PeInput.LogicFunction.Build))
{
Do();
m_Phase = EPhase.Free;
}
}
AfterDo();
}
void Update()
{
if (VFVoxelTerrain.self == null)
{
return;
}
if (IsVoxel)
{
// Gizmo.transform.localScale = new Vector3(1, 1, 1);
Gizmo.transform.localScale = new Vector3(BrushSize, BrushSize, BrushSize);
m_Indicator.enabled = true;
m_BlockIndicator.enabled = false;
}
else
{
m_Indicator.enabled = false;
m_BlockIndicator.enabled = true;
Gizmo.transform.localScale = new Vector3(0.5f * BrushSize, 0.5f * BrushSize, 0.5f * BrushSize);
m_BlockIndicator.m_Expand = 1 + BrushSize;
}
IBSDataSource ds = null; //= IsVoxel ? BuildingMan.Voxels : BuildingMan.Blocks;
BSVoxel voxel;
if (IsVoxel)
{
voxel = new BSVoxel();
voxel.value0 = 255;
voxel.value1 = 2;
ds = BuildingMan.Voxels;
}
else
{
voxel = new BSVoxel();
voxel.value0 = B45Block.MakeBlockType(1, 0);
voxel.value1 = 0;
ds = BuildingMan.Blocks;
}
// if (BSMath.RayCastDrawTarget(Camera.main.ScreenPointToRay( Input.mousePosition), out m_Target, BSMath.MC_ISO_VALUE, IsVoxel))
if (BSMath.RayCastDrawTarget(Camera.main.ScreenPointToRay(Input.mousePosition),
ds, out m_Target, BSMath.MC_ISO_VALUE, false, BuildingMan.Datas))
{
IntVector3 realPos = new IntVector3(Mathf.FloorToInt(m_Target.cursor.x * ds.ScaleInverted),
Mathf.FloorToInt(m_Target.cursor.y * ds.ScaleInverted),
Mathf.FloorToInt(m_Target.cursor.z * ds.ScaleInverted));
float offset = Mathf.FloorToInt(BrushSize * 0.5f) * ds.Scale;
//int xMultiplier = 0, yMultiplier = 0, zMultiplier = 0;
Vector3 cursor = realPos.ToVector3() * ds.Scale - new Vector3(offset, offset, offset);
int sign = BrushSize % 2 == 0? 1 : 0;
if (offset != 0)
{
Vector3 offset_v = Vector3.zero;
if (m_Target.rch.normal.x > 0)
{
offset_v.x += offset;
}
else if (m_Target.rch.normal.x < 0)
{
offset_v.x -= (offset - ds.Scale * sign);
}
else
{
offset_v.x = 0;
}
if (m_Target.rch.normal.y > 0)
{
offset_v.y += offset;
}
else if (m_Target.rch.normal.y < 0)
{
offset_v.y -= (offset - ds.Scale * sign);
}
else
{
offset_v.y = 0;
}
if (m_Target.rch.normal.z > 0)
{
offset_v.z += offset;
}
else if (m_Target.rch.normal.z < 0)
{
offset_v.z -= (offset - ds.Scale * sign);
}
else
{
offset_v.z = 0;
}
cursor += offset_v;
}
Gizmo.transform.position = cursor + ds.Offset;
if (Input.GetMouseButtonDown(0))
{
int cnt = BrushSize;
for (int x = 0; x < cnt; x++)
{
for (int y = 0; y < cnt; y++)
{
for (int z = 0; z < cnt; z++)
{
IntVector3 inpos = new IntVector3(Mathf.FloorToInt(cursor.x * ds.ScaleInverted) + x,
Mathf.FloorToInt(cursor.y * ds.ScaleInverted) + y,
Mathf.FloorToInt(cursor.z * ds.ScaleInverted) + z);
ds.Write(voxel, inpos.x, inpos.y, inpos.z);
}
}
}
}
// if (IsVoxel)
// {
//// Gizmo.transform.position = m_Target.cursor - Vector3.one * 0.5f;
////
//// if (Input.GetMouseButtonDown(0))
//// {
//// VFVoxel voxel = new VFVoxel(255, 2);
//// IntVector3 cursor = m_Target.iCursor;
//// VFVoxelTerrain.self.Voxels.Write(cursor.x, cursor.y, cursor.z, voxel);
//// }
//
//
// }
// else
// {
//
// IntVector3 realPos = new IntVector3( Mathf.FloorToInt(m_Target.cursor.x * Block45Constants._scaleInverted),
// Mathf.FloorToInt( m_Target.cursor.y * Block45Constants._scaleInverted),
// Mathf.FloorToInt( m_Target.cursor.z * Block45Constants._scaleInverted));
//
// float offset = Mathf.FloorToInt(BrushSize * 0.5f) * Block45Constants._scale;
// int xMultiplier = 0, yMultiplier = 0, zMultiplier = 0;
//
//
// Vector3 cursor = realPos.ToVector3() * Block45Constants._scale - new Vector3(offset, offset, offset);
// int sign = BrushSize % 2 == 0? 1 : 0;
//
// if (offset != 0)
// {
// Vector3 offset_v = Vector3.zero;
//
// if (m_Target.rch.normal.x > 0)
// offset_v.x += offset;
// else if (m_Target.rch.normal.x < 0)
// offset_v.x -= (offset - Block45Constants._scale * sign);
// else
// offset_v.x = 0;
//
// if (m_Target.rch.normal.y > 0)
// offset_v.y += offset;
// else if (m_Target.rch.normal.y < 0)
// offset_v.y -= (offset - Block45Constants._scale * sign);
//
// else
// offset_v.y = 0;
//
// if (m_Target.rch.normal.z > 0)
// offset_v.z += offset;
// else if (m_Target.rch.normal.z < 0)
// offset_v.z -= (offset - Block45Constants._scale * sign);
// else
// offset_v.z = 0;
//
// cursor += offset_v;
// }
//
//
//
// Gizmo.transform.position = cursor ;
//
// if (Input.GetMouseButtonDown(0))
// {
// int cnt = BrushSize;
//
// for (int x = 0; x < cnt; x++)
// {
// for (int y = 0; y < cnt; y++)
// {
// for (int z = 0; z < cnt; z++)
// {
// B45Block block = new B45Block(B45Block.MakeBlockType(1,0), 0);
// IntVector3 inpos = new IntVector3(Mathf.FloorToInt( cursor.x * Block45Constants._scaleInverted) + x,
// Mathf.FloorToInt( cursor.y * Block45Constants._scaleInverted) + y,
// Mathf.FloorToInt( cursor.z * Block45Constants._scaleInverted) + z);
// Block45Man.self.DataSource.Write(block, inpos.x,
// inpos.y,
// inpos.z);
// }
// }
// }
//
// }
// }
}
}