private void New(VCESceneSetting setting)
{
m_Setting = setting;
m_IsoData = new VCIsoData();
m_IsoData.Init(VCIsoData.ISO_VERSION, setting, new VCIsoOption(true));
m_IsoData.m_HeadInfo.Category = setting.m_Category;
m_Stencil = new VCIsoData();
m_Stencil.Init(VCIsoData.ISO_VERSION, setting, new VCIsoOption(true));
m_TempIsoMat.Init();
m_DocumentPath = VCConfig.s_Categories[setting.m_Category].m_DefaultPath + "/Untitled" + VCConfig.s_IsoFileExt;
int i = 2;
while (File.Exists(VCConfig.s_IsoPath + m_DocumentPath))
{
m_DocumentPath = VCConfig.s_Categories[setting.m_Category].m_DefaultPath + "/Untitled (" + i.ToString() + ")" + VCConfig.s_IsoFileExt;
++i;
}
VCEditor.Instance.m_MeshMgr.m_ColorMap = m_IsoData.m_Colors;
m_MeshComputer = new VCMCComputer();
m_MeshComputer.Init(m_Setting.m_EditorSize, VCEditor.Instance.m_MeshMgr);
m_CreationAttr = new CreationAttr();
#if false
this.GenSomeVoxelForTest();
#endif
}
public VCEScene(string iso_path)
{
m_IsoData = new VCIsoData();
if (!LoadIso(iso_path))
{
Destroy();
throw new Exception("Load ISO error");
}
VCESceneSetting isosetting = m_IsoData.m_HeadInfo.FindSceneSetting();
if (isosetting != null)
{
m_Setting = isosetting;
m_Stencil = new VCIsoData();
m_Stencil.Init(VCIsoData.ISO_VERSION, m_Setting, new VCIsoOption(true));
m_TempIsoMat.Init();
m_DocumentPath = iso_path;
VCEditor.Instance.m_MeshMgr.m_ColorMap = m_IsoData.m_Colors;
m_MeshComputer = new VCMCComputer();
m_MeshComputer.Init(m_Setting.m_EditorSize, VCEditor.Instance.m_MeshMgr);
m_CreationAttr = new CreationAttr();
}
else
{
Destroy();
throw new Exception("Scene setting error");
}
}
internal static void OnFileSharedEvent(object sender, EventArgs args)
{
SteamFileItem item = (SteamFileItem)sender;
if (!item._SendToServer)
{
return;
}
if (null != PlayerNetwork.mainPlayer)
{
VCIsoData da = new VCIsoData();
da.Import(item._Data, new VCIsoOption(false));
var components = from component in da.m_Components
where VCUtils.IsSeat(component.m_Type)
select(int) component.m_Type;
if (components.Count() > 0)
{
NetworkManager.SyncServer(EPacketType.PT_Common_WorkshopShared, item.FileID, item.RealFileName, item.HashCode, item._free, item.instanceId, true, components.ToArray());
}
else
{
NetworkManager.SyncServer(EPacketType.PT_Common_WorkshopShared, item.FileID, item.RealFileName, item.HashCode, item._free, item.instanceId, false);
}
}
string fielName = VCConfig.s_CreationNetCachePath + item.HashCode.ToString("X").PadLeft(16, '0') + VCConfig.s_CreationNetCacheFileExt;
using (FileStream fs = new FileStream(fielName, FileMode.Create, FileAccess.Write, FileShare.Read))
{
fs.Write(item._Data, 0, item._Data.Length);
}
_SteamItems[item.HashCode] = item.FileName;
}
public static void ISOCut(VCIsoData iso, VCEAction action)
{
List <VCEAlterVoxel> tmpModifies = new List <VCEAlterVoxel> ();
foreach (KeyValuePair <int, VCVoxel> kvp in iso.m_Voxels)
{
int pos0 = kvp.Key + 1;
int pos1 = kvp.Key - 1;
int pos2 = kvp.Key + (1 << 10);
int pos3 = kvp.Key - (1 << 10);
int pos4 = kvp.Key + (1 << 20);
int pos5 = kvp.Key - (1 << 20);
if (kvp.Value.Volume < VCEMath.MC_ISO_VALUE)
{
if (iso.GetVoxel(pos0).Volume < VCEMath.MC_ISO_VALUE &&
iso.GetVoxel(pos1).Volume < VCEMath.MC_ISO_VALUE &&
iso.GetVoxel(pos2).Volume < VCEMath.MC_ISO_VALUE &&
iso.GetVoxel(pos3).Volume < VCEMath.MC_ISO_VALUE &&
iso.GetVoxel(pos4).Volume < VCEMath.MC_ISO_VALUE &&
iso.GetVoxel(pos5).Volume < VCEMath.MC_ISO_VALUE)
{
VCEAlterVoxel modify = new VCEAlterVoxel(kvp.Key, kvp.Value, new VCVoxel(0, 0));
tmpModifies.Add(modify);
action.Modifies.Add(modify);
}
}
}
foreach (VCEAlterVoxel t in tmpModifies)
{
t.Redo();
}
}
public bool InSide(int poskey, int xsize, bool left)
{
IntVector3 pos = VCIsoData.KeyToIPos(poskey);
int size05 = Mathf.CeilToInt(0.5f * xsize);
return(left ? pos.x <= size05 : pos.x > size05);
}
void OnClickIso(int index)
{
if (index < 0 && index >= mLocalIsoInfo.Count)
{
return;
}
VCIsoHeadData headData;
if (VCIsoData.ExtractHeader(mLocalIsoInfo[index].m_Path, out headData) > 0)
{
mVCERightPanel.SetActive(true);
mRinghtPanelCtrl.m_NonEditorIcon = headData.IconTex;
mRinghtPanelCtrl.m_NonEditorISODesc = headData.Desc;
mRinghtPanelCtrl.m_NonEditorISOName = headData.Name;
mRinghtPanelCtrl.m_NonEditorRemark = headData.Remarks;
string version = ((headData.Version >> 24) & 0xff) + "." + ((headData.Version >> 16) & 0xff); //Log: lz-2016.05.13 Add version field
mRinghtPanelCtrl.m_NonEditorISOVersion = version;
mRinghtPanelCtrl.SetIsoIcon();
mRinghtPanelCtrl.OnCreationInfoRefresh();
mSelectedIsoIndex = index;
}
else
{
mVCERightPanel.SetActive(false);
mSelectedIsoIndex = -1;
}
}
private static VCIsoData LoadIso(string path)
{
try
{
VCIsoData iso_data = new VCIsoData();
string fullpath = path;
using (FileStream fs = new FileStream(fullpath, FileMode.Open, FileAccess.Read))
{
byte[] iso_buffer = new byte [(int)(fs.Length)];
fs.Read(iso_buffer, 0, (int)(fs.Length));
fs.Close();
if (iso_data.Import(iso_buffer, new VCIsoOption(false)))
{
return(iso_data);
}
else
{
return(null);
}
}
}
catch (Exception e)
{
Debug.LogError("Loading ISO Error : " + e.ToString());
return(null);
}
}
protected VCIsoData m_Iso; // pointer of current editing iso
// Functions
public virtual void Init(VCESelectVoxel parent)
{
m_Parent = parent;
m_Selecting = false;
m_Selection = parent.m_SelectionMgr.m_Selection;
m_Iso = VCEditor.s_Scene.m_IsoData;
}
public static VCIsoHeadData GetCreateionHead(int objId)
{
string filename = GetCreationPath(objId);
VCIsoHeadData headData;
VCIsoData.ExtractHeader(filename, out headData);
if (ItemProto.Mgr.Instance.Get(objId) != null)
{
return(headData);
}
ItemProto itemData = GenItemData(headData, objId);
if (itemData != null)
{
ItemProto.Mgr.Instance.Add(itemData);
byte[] buff = headData.IconTex;
if (null != buff)
{
Texture2D iconTex = new Texture2D(2, 2);
iconTex.LoadImage(buff);
iconTex.Apply(false, true);
itemData.iconTex = iconTex;
}
}
return(headData);
}
public bool ReadRes()
{
if (m_IsoData != null)
{
m_IsoData.Destroy();
}
m_IsoData = new VCIsoData();
return(m_IsoData.Import(m_Resource, new VCIsoOption(false)));
}
protected override void Do()
{
m_Action = new VCEAction();
ulong oldmat_guid = VCEditor.s_Scene.m_IsoData.MaterialGUID(VCEditor.SelectedVoxelType);
ulong newmat_guid = VCEditor.SelectedMaterial.m_Guid;
if (oldmat_guid != newmat_guid)
{
VCEAlterMaterialMap modify = new VCEAlterMaterialMap(VCEditor.SelectedVoxelType, oldmat_guid, newmat_guid);
m_Action.Modifies.Add(modify);
}
IntVector3 draw = m_Target.cursor + m_Offset;
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
VCEditor.s_Mirror.MirrorVoxel(draw);
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
if (VCEditor.s_Scene.m_IsoData.IsPointIn(VCEditor.s_Mirror.Output[i]))
{
int voxel_pos = VCIsoData.IPosToKey(VCEditor.s_Mirror.Output[i]);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = new VCVoxel(255, (byte)VCEditor.SelectedVoxelType);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
}
}
// No mirror
else
{
int voxel_pos = VCIsoData.IPosToKey(draw);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = new VCVoxel(255, (byte)VCEditor.SelectedVoxelType);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
if (m_Action.Modifies.Count > 0)
{
m_Action.Do();
}
VCEditor.Instance.m_MainCamera.GetComponent <VCECamera>().SetTarget(
(draw.ToVector3() + Vector3.one * 0.5f) * VCEditor.s_Scene.m_Setting.m_VoxelSize);
}
private void UpdateErrorLabel()
{
if (Time.frameCount % 60 == 0)
{
if (VCEditor.s_Scene != null)
{
VCIsoData isodata = VCEditor.s_Scene.m_IsoData;
attr.m_Errors.Clear();
attr.m_Warnings.Clear();
CreationData.CalcCreationType(isodata, attr);
string errortext = "";
if (isodata.m_Voxels.Count + isodata.m_Components.Count == 0)
{
errortext = "";
}
else
{
if (attr.m_Errors.Count + attr.m_Warnings.Count > 0)
{
errortext += "You must fix the issue(s) before you can export".ToLocalizationString();
}
else
{
errortext = "This ISO is ready to export".ToLocalizationString() + " !";
if (firstvalid)
{
firstvalid = false;
m_ExportTip.Show();
}
}
if (attr.m_Errors.Count > 0)
{
errortext += "\r\n[FF0000]\r\n";
foreach (string e in attr.m_Errors)
{
errortext += (" - " + e + "\r\n");
}
errortext += "[-]";
}
if (attr.m_Warnings.Count > 0)
{
errortext += "\r\n[FFFF00]\r\n";
foreach (string w in attr.m_Warnings)
{
errortext += (" - " + w + "\r\n");
}
errortext += "[-]";
}
}
m_ErrorLabel.text = errortext;
}
}
}
public void DeleteSelection()
{
m_Action = new VCEAction();
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
foreach (KeyValuePair <int, byte> kvp in m_SelectionMgr.m_Selection)
{
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
IntVector3 pos = VCIsoData.KeyToIPos(kvp.Key);
VCEditor.s_Mirror.MirrorVoxel(pos);
float strength = (float)(kvp.Value) / 255.0f;
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
if (VCEditor.s_Scene.m_IsoData.IsPointIn(VCEditor.s_Mirror.Output[i]))
{
int voxel_pos = VCIsoData.IPosToKey(VCEditor.s_Mirror.Output[i]);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = old_voxel;
new_voxel.VolumeF = new_voxel.VolumeF * (1 - strength);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
modify.Redo();
m_Action.Modifies.Add(modify);
}
}
}
}
// No mirror
else
{
float strength = (float)(kvp.Value) / 255.0f;
int voxel_pos = kvp.Key;
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = old_voxel;
new_voxel.VolumeF = new_voxel.VolumeF * (1 - strength);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
}
ColorSelection(VCIsoData.BLANK_COLOR, false, true);
if (m_Action.Modifies.Count > 0)
{
m_Action.DoButNotRegister();
VCUtils.ISOCut(VCEditor.s_Scene.m_IsoData, m_Action);
m_Action.Register();
VCEStatusBar.ShowText("Selected voxels have been removed".ToLocalizationString(), 2);
}
ClearSelection();
}
public static VArtifactCursor Create(string full_path, int layer = 0)
{
GameObject res_go = Resources.Load(s_PrefabPath) as GameObject;
if (res_go == null)
{
throw new Exception("Load artifact cursor prefab failed");
}
VArtifactCursor res_cursor = res_go.GetComponent <VArtifactCursor>();
if (res_cursor == null)
{
throw new Exception("Load artifact cursor prefab failed");
}
VCIsoData iso_data = LoadIso(full_path);
if (iso_data == null)
{
throw new Exception("Load artifact file error");
}
VArtifactCursor art_cursor = VArtifactCursor.Instantiate(res_cursor) as VArtifactCursor;
art_cursor.ISO = iso_data;
art_cursor.SetBoundSize(new Vector3(iso_data.m_HeadInfo.xSize, iso_data.m_HeadInfo.ySize, iso_data.m_HeadInfo.zSize));
art_cursor.Computer = new VCMCComputer();
art_cursor.Computer.Init(new IntVector3(iso_data.m_HeadInfo.xSize, iso_data.m_HeadInfo.ySize, iso_data.m_HeadInfo.zSize),
art_cursor.TMeshMgr, false);
foreach (VCComponentData cdata in iso_data.m_Components)
{
cdata.CreateEntity(false, art_cursor.ObjectGroup);
}
foreach (KeyValuePair <int, VCVoxel> kvp in iso_data.m_Voxels)
{
art_cursor.Computer.AlterVoxel(kvp.Key, kvp.Value);
}
art_cursor.Computer.ReqMesh();
art_cursor.gameObject.layer = layer;
Transform[] ts = art_cursor.gameObject.GetComponentsInChildren <Transform>(true);
foreach (Transform t in ts)
{
t.gameObject.layer = layer;
}
art_cursor.gameObject.SetActive(true);
art_cursor.Bound.gameObject.SetActive(true);
art_cursor.SceneGroup.gameObject.SetActive(true);
return(art_cursor);
}
void OnDownLoadFileCallBack(byte[] fileData, PublishedFileId_t p_id, bool bOK, int index = -1, int dungeonId = -1)
{
if (isActve == false)
{
return;
}
//bool DonLoadSucess = false;
if (bOK)
{
if (mItemsMap.ContainsKey(p_id))
{
if (mItemsMap[p_id] != null)
{
SteamPreFileAndVoteDetail detail = mItemsMap[p_id];
VCIsoHeadData headData;
string creation = "Object";
if (VCIsoData.ExtractHeader(fileData, out headData) > 0)
{
creation = headData.Category.ToString();
creation = creation.Substring(2, creation.Length - 2);
}
string downLoadFilePath = VCConfig.s_IsoPath + string.Format("/Download/{0}/", creation);
string netCacheFilePath = VCConfig.s_CreationNetCachePath;
string downLoadFileName = detail.m_rgchTitle;
string netCacheFileName = CRC64.Compute(fileData).ToString();
if (SaveToFile(fileData, downLoadFileName, downLoadFilePath, VCConfig.s_IsoFileExt))
{
UIWorkShopCtrl.AddDownloadFileName(mItemsMap[p_id].m_rgchTitle + VCConfig.s_IsoFileExt, mIsPrivate);
mDownMap[p_id] = 100;
}
//lz-2016.05.30 保存一份到NetCache路径下，避免NetCache重复下载
SaveToFile(fileData, netCacheFileName, netCacheFilePath, VCConfig.s_CreationNetCacheFileExt);
}
}
}
else
{
mDownMap[p_id] = -1;
MessageBox_N.ShowOkBox(PELocalization.GetString(8000493));
}
// if (e_DownLoadFile != null)
// e_DownLoadFile(filePath,DonLoadSucess);
}
// Destruction
public void Destroy()
{
m_ObjectID = 0;
m_Resource = null;
m_RandomSeed = 0;
m_HashCode = (ulong)(0);
if (m_IsoData != null)
{
m_IsoData.Destroy();
m_IsoData = null;
}
m_Attribute = null;
DestroyPrefab();
}
public void Show(VCIsoData iso)
{
DestroyTex();
m_Iso = iso;
ReadIso();
m_CaptureTex = new RenderTexture(256, 256, 24, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
m_CaptureMat.mainTexture = m_CaptureTex;
m_CaptureCamera.targetTexture = m_CaptureTex;
m_CaptureCamera.enabled = true;
VCEditor.Instance.m_MainCamera.GetComponent <VCECamera>().ControlMode = 2;
VCEditor.Instance.m_MirrorGroup.SetActive(false);
VCEditor.Instance.m_GLGroup.SetActive(false);
this.gameObject.SetActive(true);
}
public void Hide()
{
VCEditor.Instance.m_MainCamera.GetComponent <VCECamera>().ControlMode = 1;
VCEditor.Instance.m_MirrorGroup.SetActive(true);
VCEditor.Instance.m_GLGroup.SetActive(true);
this.gameObject.SetActive(false);
m_Iso = null;
m_CaptureCamera.enabled = false;
m_CaptureCamera.targetTexture = null;
DestroyTex();
if (VCEditor.Instance.m_UI.m_ISOTab.isChecked)
{
VCEditor.Instance.m_UI.m_IsoList.RefreshIsoList();
}
}
public override void Awake()
{
base.Awake();
var cc = GetComponent <CreationController>();
if (cc != null)
{
m_CreationData = cc.creationData;
if (m_CreationData != null)
{
m_IsoData = m_CreationData.m_IsoData;
m_SceneSetting = m_IsoData.m_HeadInfo.FindSceneSetting();
m_Attribute = m_CreationData.m_Attribute;
m_MassCenter = m_Attribute.m_CenterOfMass;
}
}
}
private void GenSomeVoxelForTest()
{
for (int x = 0; x < 31; ++x)
{
for (int y = 0; y < 12; ++y)
{
for (int z = 0; z < 31; ++z)
{
if ((x + y + z) % 3 == 0)
{
VCVoxel voxel = new VCVoxel((byte)(UnityEngine.Random.value * 128 + 128), 1);
m_IsoData.SetVoxel(VCIsoData.IPosToKey(new IntVector3(x, y, z)), voxel);
m_MeshComputer.AlterVoxel(x, y, z, voxel);
}
}
}
}
}
public VCEScene(VCESceneSetting setting, int template)
{
TextAsset asset = Resources.Load <TextAsset>("Isos/" + setting.m_Id.ToString() + "/" + template.ToString());
if (asset == null)
{
New(setting);
return;
}
m_IsoData = new VCIsoData();
if (!m_IsoData.Import(asset.bytes, new VCIsoOption(true)))
{
Destroy();
throw new Exception("Load Template ISO error");
}
VCESceneSetting isosetting = m_IsoData.m_HeadInfo.FindSceneSetting();
if (isosetting != null)
{
m_Setting = isosetting;
m_Stencil = new VCIsoData();
m_Stencil.Init(VCIsoData.ISO_VERSION, m_Setting, new VCIsoOption(true));
m_TempIsoMat.Init();
m_DocumentPath = VCConfig.s_Categories[setting.m_Category].m_DefaultPath + "/Untitled" + VCConfig.s_IsoFileExt;
int i = 2;
while (File.Exists(VCConfig.s_IsoPath + m_DocumentPath))
{
m_DocumentPath = VCConfig.s_Categories[setting.m_Category].m_DefaultPath + "/Untitled (" + i.ToString() + ")" + VCConfig.s_IsoFileExt;
++i;
}
VCEditor.Instance.m_MeshMgr.m_ColorMap = m_IsoData.m_Colors;
m_MeshComputer = new VCMCComputer();
m_MeshComputer.Init(m_Setting.m_EditorSize, VCEditor.Instance.m_MeshMgr);
m_CreationAttr = new CreationAttr();
}
else
{
Destroy();
throw new Exception("Scene setting error");
}
}
void SetLocalGridItemInfo(VCEAssetMgr.IsoFileInfo _isoFileInfo, UIWorkShopGridItem item)
{
string isoName = _isoFileInfo.m_Name;
if (_isoFileInfo.m_IsFolder)
{
item.InitItem(WorkGridItemType.mLocalFloder, isoName);
item.SetIco(null);
}
else
{
VCIsoHeadData headData;
VCIsoData.ExtractHeader(_isoFileInfo.m_Path, out headData);
item.InitItem(WorkGridItemType.mLocalIcon, isoName);
Texture2D texture = new Texture2D(256, 256);
texture.LoadImage(headData.IconTex);
item.SetIco(texture);
item.SetAuthor(headData.Author);
}
}
public bool CanSee(Vector3 iso_pos)
{
int x = Mathf.FloorToInt(iso_pos.x);
int y = Mathf.FloorToInt(iso_pos.y);
int z = Mathf.FloorToInt(iso_pos.z);
if (x <= 0 || y <= 0 || z <= 0 ||
x >= m_HeadInfo.xSize - 1 || y >= m_HeadInfo.ySize - 1 || z >= m_HeadInfo.zSize - 1)
{
return(true);
}
if (GetVoxel(VCIsoData.IPosToKey(x + 1, y, z)).Volume < 128)
{
return(true);
}
if (GetVoxel(VCIsoData.IPosToKey(x - 1, y, z)).Volume < 128)
{
return(true);
}
if (GetVoxel(VCIsoData.IPosToKey(x, y + 1, z)).Volume < 128)
{
return(true);
}
if (GetVoxel(VCIsoData.IPosToKey(x, y - 1, z)).Volume < 128)
{
return(true);
}
if (GetVoxel(VCIsoData.IPosToKey(x, y, z + 1)).Volume < 128)
{
return(true);
}
if (GetVoxel(VCIsoData.IPosToKey(x, y, z - 1)).Volume < 128)
{
return(true);
}
return(false);
}
public static void Calculate(Dictionary <int, byte> bitmap, ref List <SelBox> leastboxes)
{
// Clear old result
leastboxes.Clear();
// Fetch key array
int [] keyarr = new int [bitmap.Count];
bitmap.Keys.CopyTo(keyarr, 0);
// Unmark all voxels
foreach (int key in keyarr)
{
(bitmap[key]) &= (0xfe);
}
// Traverse all voxels
foreach (int key in keyarr)
{
// bitmap[key] & 1 is the voxel mark.
if ((bitmap[key] & 1) == 0)
{
// box value
byte box_val = bitmap[key];
box_val = (byte)((box_val == 0xfe) ? (0xfe) : (box_val & 0xe0));
// Mark this voxel
(bitmap[key]) |= (1);
// Begin & end of this box
IntVector3 begin = VCIsoData.KeyToIPos(key);
IntVector3 end = new IntVector3(begin);
// Can extend on xyz direction
bool can_extend_x = true;
bool can_extend_y = true;
bool can_extend_z = true;
// Start extending, make box
while (can_extend_x || can_extend_y || can_extend_z)
{
// Try to extend x
if (can_extend_x)
{
bool ext_p = true;
bool ext_n = true;
List <int> ext_key_p = new List <int> ();
List <int> ext_key_n = new List <int> ();
for (int y = begin.y; y <= end.y; y++)
{
for (int z = begin.z; z <= end.z; z++)
{
int _tst_key_p = VCIsoData.IPosToKey(end.x + 1, y, z);
int _tst_key_n = VCIsoData.IPosToKey(begin.x - 1, y, z);
byte _tst_val_p = 0xff;
byte _tst_val_n = 0xff;
if (bitmap.ContainsKey(_tst_key_p))
{
_tst_val_p = bitmap[_tst_key_p];
}
if (bitmap.ContainsKey(_tst_key_n))
{
_tst_val_n = bitmap[_tst_key_n];
}
_tst_val_p = (byte)((_tst_val_p == 0xfe) ? (0xfe) : (_tst_val_p & 0xe1));
_tst_val_n = (byte)((_tst_val_n == 0xfe) ? (0xfe) : (_tst_val_n & 0xe1));
if (_tst_val_p != box_val)
{
ext_p = false;
}
else
{
ext_key_p.Add(_tst_key_p);
}
if (_tst_val_n != box_val)
{
ext_n = false;
}
else
{
ext_key_n.Add(_tst_key_n);
}
if (!ext_p && !ext_n)
{
break;
}
}
if (!ext_p && !ext_n)
{
break;
}
}
if (ext_p)
{
foreach (int __key in ext_key_p)
{
// Mark this voxel
(bitmap[__key]) |= (1);
}
end.x++;
}
if (ext_n)
{
foreach (int __key in ext_key_n)
{
// Mark this voxel
(bitmap[__key]) |= (1);
}
begin.x--;
}
if (!ext_p && !ext_n)
{
can_extend_x = false;
}
ext_key_p.Clear();
ext_key_n.Clear();
}
// Try to extend z
if (can_extend_z)
{
bool ext_p = true;
bool ext_n = true;
List <int> ext_key_p = new List <int> ();
List <int> ext_key_n = new List <int> ();
for (int y = begin.y; y <= end.y; y++)
{
for (int x = begin.x; x <= end.x; x++)
{
int _tst_key_p = VCIsoData.IPosToKey(x, y, end.z + 1);
int _tst_key_n = VCIsoData.IPosToKey(x, y, begin.z - 1);
byte _tst_val_p = 0xff;
byte _tst_val_n = 0xff;
if (bitmap.ContainsKey(_tst_key_p))
{
_tst_val_p = bitmap[_tst_key_p];
}
if (bitmap.ContainsKey(_tst_key_n))
{
_tst_val_n = bitmap[_tst_key_n];
}
_tst_val_p = (byte)((_tst_val_p == 0xfe) ? (0xfe) : (_tst_val_p & 0xe1));
_tst_val_n = (byte)((_tst_val_n == 0xfe) ? (0xfe) : (_tst_val_n & 0xe1));
if (_tst_val_p != box_val)
{
ext_p = false;
}
else
{
ext_key_p.Add(_tst_key_p);
}
if (_tst_val_n != box_val)
{
ext_n = false;
}
else
{
ext_key_n.Add(_tst_key_n);
}
if (!ext_p && !ext_n)
{
break;
}
}
if (!ext_p && !ext_n)
{
break;
}
}
if (ext_p)
{
foreach (int __key in ext_key_p)
{
// Mark this voxel
(bitmap[__key]) |= (1);
}
end.z++;
}
if (ext_n)
{
foreach (int __key in ext_key_n)
{
// Mark this voxel
(bitmap[__key]) |= (1);
}
begin.z--;
}
if (!ext_p && !ext_n)
{
can_extend_z = false;
}
ext_key_p.Clear();
ext_key_n.Clear();
}
// Try to extend y
if (can_extend_y)
{
bool ext_p = true;
bool ext_n = true;
List <int> ext_key_p = new List <int> ();
List <int> ext_key_n = new List <int> ();
for (int x = begin.x; x <= end.x; x++)
{
for (int z = begin.z; z <= end.z; z++)
{
int _tst_key_p = VCIsoData.IPosToKey(x, end.y + 1, z);
int _tst_key_n = VCIsoData.IPosToKey(x, begin.y - 1, z);
byte _tst_val_p = 0xff;
byte _tst_val_n = 0xff;
if (bitmap.ContainsKey(_tst_key_p))
{
_tst_val_p = bitmap[_tst_key_p];
}
if (bitmap.ContainsKey(_tst_key_n))
{
_tst_val_n = bitmap[_tst_key_n];
}
_tst_val_p = (byte)((_tst_val_p == 0xfe) ? (0xfe) : (_tst_val_p & 0xe1));
_tst_val_n = (byte)((_tst_val_n == 0xfe) ? (0xfe) : (_tst_val_n & 0xe1));
if (_tst_val_p != box_val)
{
ext_p = false;
}
else
{
ext_key_p.Add(_tst_key_p);
}
if (_tst_val_n != box_val)
{
ext_n = false;
}
else
{
ext_key_n.Add(_tst_key_n);
}
if (!ext_p && !ext_n)
{
break;
}
}
if (!ext_p && !ext_n)
{
break;
}
}
if (ext_p)
{
foreach (int __key in ext_key_p)
{
// Mark this voxel
(bitmap[__key]) |= (1);
}
end.y++;
}
if (ext_n)
{
foreach (int __key in ext_key_n)
{
// Mark this voxel
(bitmap[__key]) |= (1);
}
begin.y--;
}
if (!ext_p && !ext_n)
{
can_extend_y = false;
}
ext_key_p.Clear();
ext_key_n.Clear();
}
}
// Create box
SelBox box = new SelBox();
box.m_Box.xMin = (short)(begin.x);
box.m_Box.yMin = (short)(begin.y);
box.m_Box.zMin = (short)(begin.z);
box.m_Box.xMax = (short)(end.x);
box.m_Box.yMax = (short)(end.y);
box.m_Box.zMax = (short)(end.z);
box.m_Val = (byte)(box_val | 0x07);
leastboxes.Add(box);
}
}
// Sort
leastboxes.Sort(SortSelBox);
// Increase all voxels
foreach (int key in keyarr)
{
(bitmap[key]) |= (0x01);
}
}
public void ColorSelection(Color32 color, bool consider_strength = true, bool action_segment = false)
{
if (!VCEditor.Instance.m_UI.m_PaintTab.isChecked)
{
return;
}
if (!action_segment)
{
m_Action = new VCEAction();
}
bool modified = false;
VCEUpdateColorSign sign_b = new VCEUpdateColorSign(false, true);
m_Action.Modifies.Add(sign_b);
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
foreach (SelBox sb in m_SelectionMgr.m_GL.m_Boxes)
{
float t = (float)(sb.m_Val) / 255.0f;
byte code; // This is a filter code, when color key was not on edge or vertex, their is no point to color this key.
float x, y, z;
for (x = sb.m_Box.xMin, code = 0; x <= sb.m_Box.xMax + 1.01f; x += 0.5f, code ^= 1)
{
for (y = sb.m_Box.yMin, code &= 1; y <= sb.m_Box.yMax + 1.01f; y += 0.5f, code ^= 2)
{
if (code == 0 || code == 4)
{
continue; // code 0, 4, no point to color
}
for (z = sb.m_Box.zMin, code &= 3; z <= sb.m_Box.zMax + 1.01f; z += 0.5f, code ^= 4)
{
if (code == 1 || code == 2)
{
continue; // code 1, 2, no point to color
}
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
IntVector3 color_pos = VCIsoData.IPosToColorPos(new Vector3(x, y, z));
VCEditor.s_Mirror.MirrorColor(color_pos);
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
if (VCEditor.s_Scene.m_IsoData.IsColorPosIn(VCEditor.s_Mirror.Output[i]))
{
int key = VCIsoData.ColorPosToColorKey(VCEditor.s_Mirror.Output[i]);
Color32 old_color = VCEditor.s_Scene.m_IsoData.GetColor(key);
Color32 new_color = consider_strength ? Color32.Lerp(old_color, color, t) : color;
if (old_color.r == new_color.r && old_color.g == new_color.g &&
old_color.b == new_color.b && old_color.a == new_color.a)
{
continue;
}
VCEAlterColor modify = new VCEAlterColor(key, old_color, new_color);
modify.Redo();
m_Action.Modifies.Add(modify);
modified = true;
}
}
}
// No mirror
else
{
int key = VCIsoData.IPosToColorKey(new Vector3(x, y, z));
Color32 old_color = VCEditor.s_Scene.m_IsoData.GetColor(key);
Color32 new_color = consider_strength ? Color32.Lerp(old_color, color, t) : color;
if (old_color.r == new_color.r && old_color.g == new_color.g &&
old_color.b == new_color.b && old_color.a == new_color.a)
{
continue;
}
VCEAlterColor modify = new VCEAlterColor(key, old_color, new_color);
m_Action.Modifies.Add(modify);
modified = true;
}
}
}
}
}
VCEUpdateColorSign sign_f = new VCEUpdateColorSign(true, false);
m_Action.Modifies.Add(sign_f);
if (action_segment && !modified)
{
m_Action.Modifies.RemoveRange(m_Action.Modifies.Count - 2, 2);
}
if (!action_segment && m_Action.Modifies.Count > 2)
{
m_Action.Do();
if (color.r == VCIsoData.BLANK_COLOR.r &&
color.g == VCIsoData.BLANK_COLOR.g &&
color.b == VCIsoData.BLANK_COLOR.b &&
color.a == VCIsoData.BLANK_COLOR.a)
{
VCEStatusBar.ShowText("Selection color have been erased".ToLocalizationString(), 2);
}
else
{
VCEStatusBar.ShowText("Selected voxels have been painted".ToLocalizationString(), 2);
}
}
}
public static bool RayCastDrawTarget(Ray ray, out DrawTarget target, int minvol, bool voxelbest = false)
{
target = new DrawTarget();
if (!VCEditor.DocumentOpen())
{
return(false);
}
// Cast grid and voxel above minvol
RaycastHit rch_voxel = new RaycastHit();
RaycastHit rch_grid = new RaycastHit();
float dist_voxel = 10000;
float dist_grid = 10000;
bool to_cast_grid = true;
if (VCEMath.RayCastVoxel(VCEInput.s_PickRay, out rch_voxel, minvol))
{
dist_voxel = rch_voxel.distance;
if (voxelbest)
{
to_cast_grid = false;
}
}
if (to_cast_grid && VCEMath.RayCastGrid(VCEInput.s_PickRay, out rch_grid))
{
if (rch_grid.normal.y > 0)
{
dist_grid = rch_grid.distance;
}
}
// cast voxel
if (dist_voxel < dist_grid)
{
target.rch = rch_voxel;
target.snapto = new IntVector3(Mathf.FloorToInt(rch_voxel.point.x - rch_voxel.normal.x * 0.5f),
Mathf.FloorToInt(rch_voxel.point.y - rch_voxel.normal.y * 0.5f),
Mathf.FloorToInt(rch_voxel.point.z - rch_voxel.normal.z * 0.5f));
target.cursor = new IntVector3(Mathf.FloorToInt(rch_voxel.point.x + rch_voxel.normal.x * 0.5f),
Mathf.FloorToInt(rch_voxel.point.y + rch_voxel.normal.y * 0.5f),
Mathf.FloorToInt(rch_voxel.point.z + rch_voxel.normal.z * 0.5f));
return(true);
}
// cast grid
else if (dist_grid < dist_voxel)
{
target.rch = rch_grid;
target.snapto = new IntVector3(Mathf.FloorToInt(rch_grid.point.x - rch_grid.normal.x * 0.5f),
Mathf.FloorToInt(rch_grid.point.y - rch_grid.normal.y * 0.5f),
Mathf.FloorToInt(rch_grid.point.z - rch_grid.normal.z * 0.5f));
target.cursor = new IntVector3(Mathf.FloorToInt(rch_grid.point.x + rch_grid.normal.x * 0.5f),
Mathf.FloorToInt(rch_grid.point.y + rch_grid.normal.y * 0.5f),
Mathf.FloorToInt(rch_grid.point.z + rch_grid.normal.z * 0.5f));
if (VCEditor.s_Scene.m_IsoData.GetVoxel(VCIsoData.IPosToKey(target.cursor)).Volume > VCEMath.MC_ISO_VALUE)
{
target.cursor = null;
return(false);
}
return(true);
}
// cast nothing
else
{
target.rch = new RaycastHit();
target.snapto = null;
target.cursor = null;
return(false);
}
}
// pick a voxel
public static bool RayCastVoxel(Ray ray, out RaycastHit rch, int minvol = 1)
{
rch = new RaycastHit();
if (!VCEditor.DocumentOpen())
{
return(false);
}
VCIsoData iso = VCEditor.s_Scene.m_IsoData;
// Define a small number.
float epsilon = 0.0001F;
// Define a large number.
float upsilon = 10000F;
ray = TransformRayToIsoCoord(ray);
// ray origin inside a voxel
if (iso.GetVoxel(VCIsoData.IPosToKey(Mathf.FloorToInt(ray.origin.x),
Mathf.FloorToInt(ray.origin.y),
Mathf.FloorToInt(ray.origin.z))).Volume >= minvol)
{
return(false);
}
// Start and adder.
float xStart, yStart, zStart;
float xAdder, yAdder, zAdder;
if (ray.direction.x > epsilon)
{
xAdder = 1;
}
else if (ray.direction.x < -epsilon)
{
xAdder = -1;
}
else
{
xAdder = 0;
}
if (ray.direction.y > epsilon)
{
yAdder = 1;
}
else if (ray.direction.y < -epsilon)
{
yAdder = -1;
}
else
{
yAdder = 0;
}
if (ray.direction.z > epsilon)
{
zAdder = 1;
}
else if (ray.direction.z < -epsilon)
{
zAdder = -1;
}
else
{
zAdder = 0;
}
xStart = (int)(((int)ray.origin.x) + 1 + xAdder * 0.5f);
yStart = (int)(((int)ray.origin.y) + 1 + yAdder * 0.5f);
zStart = (int)(((int)ray.origin.z) + 1 + zAdder * 0.5f);
// Clamp the start
xStart = Mathf.Clamp(xStart, 0.0f, VCEditor.s_Scene.m_Setting.m_EditorSize.x);
yStart = Mathf.Clamp(yStart, 0.0f, VCEditor.s_Scene.m_Setting.m_EditorSize.y);
zStart = Mathf.Clamp(zStart, 0.0f, VCEditor.s_Scene.m_Setting.m_EditorSize.z);
// Normalize the ray
ray.direction = ray.direction.normalized;
// Define the Enter
float EnterX = upsilon + 1;
float EnterY = upsilon + 1;
float EnterZ = upsilon + 1;
// Find the X-cast Enter
if (xAdder != 0)
{
for (float x = xStart; x > -0.1f && x <= VCEditor.s_Scene.m_Setting.m_EditorSize.x + 0.1f; x += xAdder)
{
float enter = (x - ray.origin.x) / ray.direction.x;
Vector3 Hit = ray.origin + ray.direction * enter;
if (iso.GetVoxel(VCIsoData.IPosToKey(Mathf.FloorToInt(Hit.x + xAdder * 0.5f),
Mathf.FloorToInt(Hit.y),
Mathf.FloorToInt(Hit.z))).Volume >= minvol)
{
EnterX = enter;
break;
}
}
}
// Find the Y-cast Enter
if (yAdder != 0)
{
for (float y = yStart; y >= -0.1f && y <= VCEditor.s_Scene.m_Setting.m_EditorSize.y + 0.1f; y += yAdder)
{
float enter = (y - ray.origin.y) / ray.direction.y;
Vector3 Hit = ray.origin + ray.direction * enter;
if (iso.GetVoxel(VCIsoData.IPosToKey(Mathf.FloorToInt(Hit.x),
Mathf.FloorToInt(Hit.y + yAdder * 0.5f),
Mathf.FloorToInt(Hit.z))).Volume >= minvol)
{
EnterY = enter;
break;
}
}
}
// Find the Z-cast Enter
if (zAdder != 0)
{
for (float z = zStart; z >= -0.1f && z <= VCEditor.s_Scene.m_Setting.m_EditorSize.z + 0.1f; z += zAdder)
{
float enter = (z - ray.origin.z) / ray.direction.z;
Vector3 Hit = ray.origin + ray.direction * enter;
if (iso.GetVoxel(VCIsoData.IPosToKey(Mathf.FloorToInt(Hit.x),
Mathf.FloorToInt(Hit.y),
Mathf.FloorToInt(Hit.z + zAdder * 0.5f))).Volume >= minvol)
{
EnterZ = enter;
break;
}
}
}
// cull negative x,y,z cast result
if (EnterX < 0)
{
EnterX = upsilon + 1;
}
if (EnterY < 0)
{
EnterY = upsilon + 1;
}
if (EnterZ < 0)
{
EnterZ = upsilon + 1;
}
// no cast
if (EnterX > upsilon && EnterY > upsilon && EnterZ > upsilon)
{
return(false);
}
// x enter is the smallest
if (EnterX < EnterY && EnterX < EnterZ)
{
rch.point = ray.GetPoint(EnterX);
rch.normal = Vector3.left * xAdder;
rch.distance = (rch.point - ray.origin).magnitude;
return(true);
}
// y enter is the smallest
else if (EnterY < EnterZ && EnterY < EnterX)
{
rch.point = ray.GetPoint(EnterY);
rch.normal = Vector3.down * yAdder;
rch.distance = (rch.point - ray.origin).magnitude;
return(true);
}
// z enter is the smallest
else if (EnterZ < EnterX && EnterZ < EnterY)
{
rch.point = ray.GetPoint(EnterZ);
rch.normal = Vector3.back * zAdder;
rch.distance = (rch.point - ray.origin).magnitude;
return(true);
}
else
{
return(false);
}
}
public void TextureSelection()
{
if (!VCEditor.Instance.m_UI.m_MaterialTab.isChecked)
{
return;
}
if (VCEditor.SelectedVoxelType < 0)
{
return;
}
m_Action = new VCEAction();
ulong oldmat_guid = VCEditor.s_Scene.m_IsoData.MaterialGUID(VCEditor.SelectedVoxelType);
ulong newmat_guid = VCEditor.SelectedMaterial.m_Guid;
if (oldmat_guid != newmat_guid)
{
VCEAlterMaterialMap modify = new VCEAlterMaterialMap(VCEditor.SelectedVoxelType, oldmat_guid, newmat_guid);
m_Action.Modifies.Add(modify);
}
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
foreach (KeyValuePair <int, byte> kvp in m_SelectionMgr.m_Selection)
{
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
IntVector3 pos = VCIsoData.KeyToIPos(kvp.Key);
VCEditor.s_Mirror.MirrorVoxel(pos);
float strength = (float)(kvp.Value) / 255.0f;
if (strength < 0.5f)
{
continue;
}
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
if (VCEditor.s_Scene.m_IsoData.IsPointIn(VCEditor.s_Mirror.Output[i]))
{
int voxel_pos = VCIsoData.IPosToKey(VCEditor.s_Mirror.Output[i]);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = new VCVoxel(old_voxel.Volume, (byte)(VCEditor.SelectedVoxelType));
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
modify.Redo();
m_Action.Modifies.Add(modify);
}
}
}
}
// No mirror
else
{
float strength = (float)(kvp.Value) / 255.0f;
if (strength < 0.5f)
{
continue;
}
int voxel_pos = kvp.Key;
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = new VCVoxel(old_voxel.Volume, (byte)(VCEditor.SelectedVoxelType));
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
}
if (m_Action.Modifies.Count > 0)
{
m_Action.Do();
VCEStatusBar.ShowText("Selected voxels have been textured".ToLocalizationString(), 2);
}
}
public static int MakeCreation(string path)
{
TextAsset aseet = Resources.Load <TextAsset>(path);
VCIsoData iso = new VCIsoData();
iso.Import(aseet.bytes, new VCIsoOption(false));
// Multi player
if (s_MultiplayerMode)
{
if (!VCConfig.s_Categories.ContainsKey(iso.m_HeadInfo.Category))
{
return(-1);
}
byte[] isodata = iso.Export();
if (isodata == null || isodata.Length <= 0)
{
return(-1);
}
ulong hash = CRC64.Compute(isodata);
ulong fileId = SteamWorkShop.GetFileHandle(hash);
VCGameMediator.SendIsoDataToServer(iso.m_HeadInfo.Name, iso.m_HeadInfo.SteamDesc,
iso.m_HeadInfo.SteamPreview, isodata, SteamWorkShop.AddNewVersionTag(iso.m_HeadInfo.ScenePaths()), true, fileId, true);
return(0);
}
else
{
CreationData new_creation = new CreationData();
new_creation.m_ObjectID = CreationMgr.QueryNewId();
new_creation.m_RandomSeed = UnityEngine.Random.value;
new_creation.m_Resource = iso.Export();
new_creation.ReadRes();
// Attr
new_creation.GenCreationAttr();
if (new_creation.m_Attribute.m_Type == ECreation.Null)
{
Debug.LogWarning("Creation is not a valid type !");
new_creation.Destroy();
return(-1);
}
// SaveRes
if (new_creation.SaveRes())
{
new_creation.BuildPrefab();
new_creation.Register();
CreationMgr.AddCreation(new_creation);
ItemAsset.ItemObject item;
int send_retval = new_creation.SendToPlayer(out item);
Debug.Log("Make creation succeed !");
if (send_retval == 0)
{
return(-1); // Error
}
else if (send_retval == -1)
{
return(-4); // Item Package Full
}
else
{
if (OnMakeCreation != null)
{
OnMakeCreation();
}
return(0); // Succeed
}
}
else
{
Debug.LogWarning("Save creation resource file failed !");
new_creation.Destroy();
return(-3);
}
}
}
// Input
public void AlterVoxel(int poskey, VCVoxel voxel)
{
IntVector3 pos = VCIsoData.KeyToIPos(poskey);
m_DataSource.Write(pos.x + 1, pos.y + 1, pos.z + 1, new VFVoxel(voxel.Volume, voxel.Type), 0, false);
}
