static void Main()
{
VoxData vd = new VoxData(new BinaryReader("res/kusa.vox"));
Console.Write(vd.Type);
Console.WriteLine(vd.Version);
Console.WriteLine(vd.NumModels);
int[,] sizes = vd.Sizes;
Bitmap[] danmens = vd.Danmens;
Bitmap[][] kaitentai = vd.Kaitentai;
//foreach(Bitmap img in danmens)
for (int modelIndex = 0; modelIndex < danmens.Length; modelIndex++)
{
Bitmap img = danmens[modelIndex];
//img.MakeTransparent();
img.Save("result/" + modelIndex + ".png", System.Drawing.Imaging.ImageFormat.Png);
img.Dispose();
for (int angleCount = 0; angleCount < kaitentai[modelIndex].Length; angleCount++)
{
img = kaitentai[modelIndex][angleCount];
img.Save("result/" + modelIndex + "_" + angleCount + ".png", System.Drawing.Imaging.ImageFormat.Png);
img.Dispose();
}
}
}
// Segmented is a flag, when true load_vox will create an individual model for each group or segment in the Vox_Data mesh.
// Please note that models which haven't been set as segmented cannot be fully animated upon using Model_Controller;
// Only the root node can be animated upon, which will animate the entire model collectively.
//
// -TH 4/29/2016
//
internal void LoadVox(VoxData data, bool segmented = true)
{
if (data.EmptyOrInvalid())
return;
foreach (GameObject go in Groups) {
Destroy(go);
}
Groups.Clear();
if (segmented) {
foreach (VoxGroup group in data.Groups) {
// Add a group object which will be assigned the mesh of the current group being iterated over
GameObject go = (GameObject)Instantiate(GameController.Instance.VoxPrefab, transform.position + group.Position, Quaternion.identity);
go.GetComponent<ModelController>().LoadGroup(group);
go.transform.parent = transform;
Groups.Add(go);
}
}
else {
GameObject go = (GameObject)Instantiate(GameController.Instance.VoxPrefab, transform.position, Quaternion.identity);
go.GetComponent<ModelController>().LoadData(data);
go.transform.parent = transform;
Groups.Add(go);
}
}
public static VOXModel CalcVoxelCruncher(VoxData chunk, Color32[] palette, VOXCruncherMode mode)
{
switch (mode)
{
case VOXCruncherMode.Stupid:
return(new VOXCruncherStupid().CalcVoxelCruncher(chunk, palette));
case VOXCruncherMode.Culled:
return(new VOXCruncherCulled().CalcVoxelCruncher(chunk, palette));
case VOXCruncherMode.Greedy:
return(new VOXCruncherGreedy().CalcVoxelCruncher(chunk, palette));
default:
return(null);
}
}
public VoxData GetVoxelDataLOD(int level)
{
if (x <= 1 || y <= 1 || z <= 1)
{
return(null);
}
level = Mathf.Clamp(level, 0, 16);
if (level <= 1)
{
return(this);
}
if (x <= level && y <= level && z <= level)
{
return(this);
}
VoxData data = new VoxData();
data.x = Mathf.CeilToInt((float)x / level);
data.y = Mathf.CeilToInt((float)y / level);
data.z = Mathf.CeilToInt((float)z / level);
data.voxels = new int[data.x, data.y, data.z];
for (int x = 0; x < data.x; x++)
{
for (int y = 0; y < data.y; y++)
{
for (int z = 0; z < data.z; z++)
{
data.voxels[x, y, z] = this.GetMajorityColorIndex(x * level, y * level, z * level, level);
}
}
}
return(data);
}
// Segmented is a flag, when true load_vox will create an individual model for each group or segment in the Vox_Data mesh.
// Please note that models which haven't been set as segmented cannot be fully animated upon using Model_Controller;
// Only the root node can be animated upon, which will animate the entire model collectively.
//
// -TH 4/29/2016
//
internal void LoadVox(VoxData data, bool segmented = true)
{
if (data.EmptyOrInvalid())
{
return;
}
foreach (GameObject go in Groups)
{
Destroy(go);
}
Groups.Clear();
if (segmented)
{
foreach (VoxGroup group in data.Groups)
{
// Add a group object which will be assigned the mesh of the current group being iterated over
GameObject go = (GameObject)Instantiate(GameController.Instance.VoxPrefab, transform.position + group.Position, Quaternion.identity);
go.GetComponent <ModelController>().LoadGroup(group);
go.transform.parent = transform;
Groups.Add(go);
}
}
else
{
GameObject go = (GameObject)Instantiate(GameController.Instance.VoxPrefab, transform.position, Quaternion.identity);
go.GetComponent <ModelController>().LoadData(data);
go.transform.parent = transform;
Groups.Add(go);
}
}
public VoxData GetVoxelDataLOD(int level)
{
if (x <= 1 || y <= 1 || z <= 1)
{
return(null);
}
level = System.Math.Max(0, System.Math.Min(level, 16));
if (level <= 1)
{
return(this);
}
if (x <= level && y <= level && z <= level)
{
return(this);
}
VoxData data = new VoxData();
data.x = (int)System.Math.Ceiling((float)x / level);
data.y = (int)System.Math.Ceiling((float)y / level);
data.z = (int)System.Math.Ceiling((float)z / level);
data.voxels = new int[data.x, data.y, data.z];
for (int x = 0; x < data.x; x++)
{
for (int y = 0; y < data.y; y++)
{
for (int z = 0; z < data.z; z++)
{
data.voxels[x, y, z] = this.GetMajorityColorIndex(x, y, z, level);
}
}
}
return(data);
}
public VOXModel CalcVoxelCruncher(VoxData chunk, Color32[] palette)
{
var crunchers = new List <VOXCruncher>();
var bound = new Vector3Int(chunk.x, chunk.y, chunk.z);
for (int i = 0; i < chunk.x; ++i)
{
for (int j = 0; j < chunk.y; ++j)
{
for (int k = 0; k < chunk.z; ++k)
{
var c = chunk.voxels[i, j, k];
if (c != int.MaxValue)
{
VOXVisiableFaces faces;
if (!GetVisiableFaces(chunk.voxels, bound, i, j, k, c, palette, out faces))
{
continue;
}
crunchers.Add(new VOXCruncher((byte)i, (byte)i, (byte)j, (byte)j, (byte)k, (byte)k, faces, c));
}
}
}
}
var array = new VOXCruncher[crunchers.Count];
int numbers = 0;
foreach (var it in crunchers)
{
array[numbers++] = it;
}
return(new VOXModel(array));
}
public VOXModel CalcVoxelCruncher(VoxData chunk, Color32[] palette)
{
var crunchers = new VOXCruncher[chunk.count];
var faces = new VOXVisiableFaces(true, true, true, true, true, true);
int n = 0;
for (int i = 0; i < chunk.x; ++i)
{
for (int j = 0; j < chunk.y; ++j)
{
for (int k = 0; k < chunk.z; ++k)
{
var m = chunk.voxels[i, j, k];
if (m != int.MaxValue)
{
crunchers[n++] = new VOXCruncher(i, i, j, j, k, k, faces, m);
}
}
}
}
return(new VOXModel(crunchers));
}
public static GameObject CreateGameObject(string name, VoxData data, Texture2D texture, Color32[] colors, float scale)
{
var cruncher = VOXPolygonCruncher.CalcVoxelCruncher(data, colors, VOXCruncherMode.Greedy);
var entities = new Dictionary <string, int>();
if (CalcFaceCountAsAllocate(cruncher, colors, ref entities) == 0)
{
throw new System.Exception(name + ": There is no voxel for this file");
}
var model = new GameObject(name);
foreach (var entity in entities)
{
if (entity.Value == 0)
{
continue;
}
var index = 0;
var allocSize = entity.Value;
var vertices = new Vector3[allocSize * 4];
var normals = new Vector3[allocSize * 4];
var uv = new Vector2[allocSize * 4];
var triangles = new int[allocSize * 6];
bool isTransparent = false;
foreach (var it in cruncher.voxels)
{
VOXModel.CreateCubeMesh16x16(it, ref vertices, ref normals, ref uv, ref triangles, ref index, scale);
isTransparent |= (colors[it.material].a < 255) ? true : false;
}
if (triangles.Length > 0)
{
Mesh mesh = new Mesh();
mesh.name = "mesh";
mesh.vertices = vertices;
mesh.normals = normals;
mesh.uv = uv;
mesh.triangles = triangles;
var meshFilter = model.AddComponent <MeshFilter>();
var meshRenderer = model.AddComponent <MeshRenderer>();
#if UNITY_EDITOR
MeshUtility.Optimize(mesh);
meshFilter.sharedMesh = mesh;
meshRenderer.sharedMaterial = new Material(Shader.Find("Mobile/Diffuse"));
meshRenderer.sharedMaterial.name = "material";
meshRenderer.sharedMaterial.mainTexture = texture;
#else
meshFilter.mesh = mesh;
meshRenderer.material = new Material(Shader.Find("Mobile/Diffuse"));
meshRenderer.material.mainTexture = texture;
#endif
}
}
return(model);
}
void LoadData(VoxData data)
{
DoData = true;
this.Data = data;
}
public LEVoxel(string name, VoxAtlas atlas)
{
Name = name;
VData = atlas.Create();
}
protected override void OnUpdate()
{
Entities.WithAll <Equipment>().ForEach((Entity e, ref Equipment equipment) =>
{
if (equipment.dirty == 1)
{
equipment.dirty = 0;
// get VoxData of the character stored in world system
VoxData model = new VoxData {
id = Bootstrap.GenerateUniqueID()
}; // make this part of equipment
//var voxes = new List<VoxData>();
//var positions = new List<int3>(); // after added them all, offset all positions by min, also get max to use as size
//var operations = new List<VoxOperation>();
var bodyLayer = new VoxBuildLayer();
bodyLayer.Init();
var gearLayer = new VoxBuildLayer();
gearLayer.Init();
for (int i = 0; i < equipment.body.Length; i++)
{
// first find core
// then for its meta
// find any children of that core
// then loop for them
// different merge function for each axis enum + the offset of the slot
var core = equipment.body[i].data;
if (meta.ContainsKey(core.id))
{
if (core.maleSlot.id == 0)
{
var coreDatam = meta[core.id];
//Debug.LogError("Adding Core");
bodyLayer.voxes.Add(coreDatam.model.data);
bodyLayer.positions.Add(int3.Zero());
bodyLayer.operations.Add(VoxOperation.None);
bodyLayer.parents.Add(-1);
bodyLayer.bonePositions.Add(coreDatam.model.data.size / 2);
bodyLayer.axes.Add((byte)SlotAxis.Center);
//float3 realPosition = coreDatam.model.data.size.ToFloat3()/2f;
//bodyLayer.realPositions.Add(realPosition);
AddChildren(ref equipment,
ref bodyLayer, ref gearLayer, //ref voxes, ref positions, ref operations,
VoxOperation.None, core, i, int3.Zero());
break;
}
}
}
// combine voxes
var combinedVoxes = new List <VoxData>();
combinedVoxes.AddRange(bodyLayer.voxes);
combinedVoxes.AddRange(gearLayer.voxes);
var combinedPositions = new List <int3>();
combinedPositions.AddRange(bodyLayer.positions);
combinedPositions.AddRange(gearLayer.positions);
int3 size = VoxData.GetSize(combinedVoxes, combinedPositions);
int3 min;
int3 max;
VoxData.CalculateMinMax(combinedVoxes, combinedPositions, out min, out max);
int3 addition = VoxData.CalculateAddition(min, max);
bodyLayer.positions = VoxData.FixPositions(bodyLayer.positions, addition);
gearLayer.positions = VoxData.FixPositions(gearLayer.positions, addition);
model.Build(bodyLayer, gearLayer, size);
// updates body model using this new vox data
float3 bodySize = model.GetSize();
World.EntityManager.SetComponentData(e, new Body {
size = bodySize
});
WorldBound worldBound = World.EntityManager.GetComponentData <WorldBound>(e);
worldBound.size = bodySize;
World.EntityManager.SetComponentData(e, worldBound);
// this can be done in equip system
int id = World.EntityManager.GetComponentData <ZoxID>(e).id;
//Debug.LogError("Equipment Mesh updated for: " + id);
WorldSpawnSystem.QueueUpdateModel(World.EntityManager, e, id, model);
if (World.EntityManager.HasComponent <Skeleton>(e))
{
var skeleton = World.EntityManager.GetComponentData <Skeleton>(e);
//skeleton.SetBody(model.size, bodyLayer.positions, bodyLayer.voxes);
combinedPositions = VoxData.FixPositions(combinedPositions, addition);
bodyLayer.bonePositions = VoxData.FixPositions(bodyLayer.bonePositions, addition);
skeleton.SetBody(model.size, combinedPositions, combinedVoxes);
skeleton.SetBones(World.EntityManager, e, bodyLayer.positions.ToArray(), bodyLayer.voxes.ToArray(), bodyLayer.bonePositions.ToArray(),
bodyLayer.parents.ToArray(), bodyLayer.axes.ToArray());
World.EntityManager.SetComponentData(e, skeleton);
}
}
});
}
void LoadData(VoxData data)
{
DoData = true;
this.Data = data;
}
public VOXModel CalcVoxelCruncher(VoxData chunk, Color32[] palette)
{
var crunchers = new List <VOXCruncher>();
var dims = new int[] { chunk.x, chunk.y, chunk.z };
var alloc = System.Math.Max(dims[0], System.Math.Max(dims[1], dims[2]));
var mask = new int[alloc * alloc];
var map = chunk.voxels;
for (var d = 0; d < 3; ++d)
{
var u = (d + 1) % 3;
var v = (d + 2) % 3;
var x = new int[3] {
0, 0, 0
};
var q = new int[3] {
0, 0, 0
};
q[d] = 1;
var faces = new VOXVisiableFaces(false, false, false, false, false, false);
for (x[d] = -1; x[d] < dims[d];)
{
var n = 0;
for (x[v] = 0; x[v] < dims[v]; ++x[v])
{
for (x[u] = 0; x[u] < dims[u]; ++x[u])
{
var a = x[d] >= 0 ? map[x[0], x[1], x[2]] : VOXMaterial.MaxValue;
var b = x[d] < dims[d] - 1 ? map[x[0] + q[0], x[1] + q[1], x[2] + q[2]] : VOXMaterial.MaxValue;
if (a != b)
{
if (a == VOXMaterial.MaxValue)
{
mask[n++] = b;
}
else if (b == VOXMaterial.MaxValue)
{
mask[n++] = -a;
}
else
{
mask[n++] = -b;
}
}
else
{
mask[n++] = VOXMaterial.MaxValue;
}
}
}
++x[d];
n = 0;
for (var j = 0; j < dims[v]; ++j)
{
for (var i = 0; i < dims[u];)
{
var c = mask[n];
if (c == VOXMaterial.MaxValue)
{
++i; ++n;
continue;
}
var w = 1;
var h = 1;
var k = 0;
for (; (i + w) < dims[u] && c == mask[n + w]; ++w)
{
}
var done = false;
for (; (j + h) < dims[v]; ++h)
{
for (k = 0; k < w; ++k)
{
if (c != mask[n + k + h * dims[u]])
{
done = true;
break;
}
}
if (done)
{
break;
}
}
x[u] = i; x[v] = j;
var du = new int[3] {
0, 0, 0
};
var dv = new int[3] {
0, 0, 0
};
du[u] = w;
dv[v] = h;
var v1 = new Vector3(x[0], x[1], x[2]);
var v2 = new Vector3(x[0] + du[0] + dv[0], x[1] + du[1] + dv[1], x[2] + du[2] + dv[2]);
v2.x = System.Math.Max(v2.x - 1, 0);
v2.y = System.Math.Max(v2.y - 1, 0);
v2.z = System.Math.Max(v2.z - 1, 0);
if (c > 0)
{
faces.front = d == 2;
faces.back = false;
faces.left = d == 0;
faces.right = false;
faces.top = false;
faces.bottom = d == 1;
}
else
{
c = -c;
faces.front = false;
faces.back = d == 2;
faces.left = false;
faces.right = d == 0;
faces.top = d == 1;
faces.bottom = false;
}
crunchers.Add(new VOXCruncher((byte)v1.x, (byte)(v2.x), (byte)(v1.y), (byte)(v2.y), (byte)(v1.z), (byte)(v2.z), faces, c));
for (var l = 0; l < h; ++l)
{
for (k = 0; k < w; ++k)
{
mask[n + k + l * dims[u]] = VOXMaterial.MaxValue;
}
}
i += w; n += w;
}
}
}
}
var array = new VOXCruncher[crunchers.Count];
int numbers = 0;
foreach (var it in crunchers)
{
array[numbers++] = it;
}
return(new VOXModel(array));
}
