void RenderRamp(Vector3 position, Voxel voxel, MeshContext context)
{
RenderQuad2(context, voxel, position, Direction.YNeg);
RenderQuad2(context, voxel, position, Direction.ZPos);
var points = new List <Vector3>();
// Ramp
points.Add(FrontTop1);
points.Add(FrontTop2);
points.Add(BackBot1);
points.Add(BackBot2);
points.Add(BackBot1);
points.Add(FrontTop2);
// Left
points.Add(FrontBot1);
points.Add(FrontTop1);
points.Add(BackBot1);
// Right
points.Add(BackBot2);
points.Add(FrontTop2);
points.Add(FrontBot2);
AddPoints(position, points, voxel, context);
}
void RenderMiterConcave(Vector3 position, Voxel voxel, MeshContext context)
{
var points = new List <Vector3>();
RenderQuad2(context, voxel, position, Direction.YNeg);
RenderQuad2(context, voxel, position, Direction.ZPos);
RenderQuad2(context, voxel, position, Direction.XPos);
// Back
points.Add(BackBot1);
points.Add(BackTop2);
points.Add(BackBot2);
// Left
points.Add(FrontBot1);
points.Add(FrontTop1);
points.Add(BackBot1);
points.Add(FrontTop1);
points.Add(FrontTop2);
points.Add(BackBot1);
points.Add(BackTop2);
points.Add(BackBot1);
points.Add(FrontTop2);
AddPoints(position, points, voxel, context);
}
void RenderQuad(MeshContext context, Vector3 position, Vector3 normal)
{
foreach (var point in GetQuadVertices(normal))
{
context.AddVertex(position + point);
}
}
void RenderMeshContext(ushort blockType, MeshContext context)
{
var blockTypeObject = Chunk.Parent.BlockTypes[blockType];
var meshObject = new GameObject();
meshObject.name = blockTypeObject.BlockName;
meshObject.transform.parent = transform;
meshObject.transform.localPosition = Vector3.zero;
var meshFilter = meshObject.AddComponent <MeshFilter>();
var mesh = new Mesh();
meshFilter.mesh = mesh;
var meshCollider = meshObject.AddComponent <MeshCollider>();
var meshRenderer = meshObject.AddComponent <MeshRenderer>();
var chunkPosition = GetComponent <Chunk>().ChunkPosition;
mesh.vertices = context.Verticies.ToArray();
mesh.triangles = context.Triangles.ToArray();
mesh.Optimize();
mesh.RecalculateNormals();
meshCollider.sharedMesh = mesh;
meshRenderer.material = blockTypeObject.BlockMaterial;
}
public QuadPosition(Vector3 position, MeshContext context, Direction direction)
{
this.x = (byte)position.x;
this.y = (byte)position.y;
this.z = (byte)position.z;
this.context = context;
this.direction = direction;
}
void RenderCube(Vector3 position, Voxel voxel, MeshContext context)
{
RenderQuad2(context, voxel, position, Direction.XNeg);
RenderQuad2(context, voxel, position, Direction.XPos);
RenderQuad2(context, voxel, position, Direction.YNeg);
RenderQuad2(context, voxel, position, Direction.YPos);
RenderQuad2(context, voxel, position, Direction.ZNeg);
RenderQuad2(context, voxel, position, Direction.ZPos);
}
private MeshContext GetMeshContext(Voxel voxel)
{
MeshContext result;
if (!TypedBlocks.TryGetValue(voxel.BlockType, out result))
{
TypedBlocks[voxel.BlockType] = result = new MeshContext();
result.WorldPosition = transform.position;
}
return(result);
}
void RenderQuad2(MeshContext context, Voxel voxel, Vector3 position, Direction direction)
{
var transformedDirection = TransformDirection(direction, voxel);
var quadPos = new QuadPosition(position, context, transformedDirection);
var flippedDir = FlipDirection(transformedDirection);
var flippedPosition = MoveByDirection(position, transformedDirection);
var flippedQuad = new QuadPosition(flippedPosition, context, flippedDir);
if (QuadPositions.Contains(flippedQuad))
{
QuadPositions.Remove(flippedQuad);
return;
}
QuadPositions.Add(quadPos);
}
void AddPoints(Vector3 position, List <Vector3> points, Voxel voxel, MeshContext context)
{
var rotation = Quaternion.AngleAxis(GetRotationDegress(voxel.Rotation), Vector3.up);
if (voxel.IsUpsideDown)
{
for (var i = points.Count - 1; i >= 0; i--)
{
var point = points[i];
var p2 = new Vector3(point.x, -point.y, point.z);
context.AddVertex(position + (rotation * p2));
}
}
else
{
foreach (var point in points)
{
context.AddVertex(position + (rotation * point));
}
}
}
protected override void OnUpdate(float playTime)
{
int contextCount = _contextList.Count;
var curTime = Time.time;
if (_nextSampleTime < Time.time)
{
_nextSampleTime += _SampleInterval;
_curSampleIndex = (_curSampleIndex + 1) % _SampleCount;
if (contextCount <= _curSampleIndex)
{
var context = new MeshContext(ref _arrMeshFilter);
_contextList.Add(context);
}
_contextList[_curSampleIndex].Update(transform, _GhostLifeTime + curTime);
}
for (int i = 0; i < contextCount; i++)
{
_contextList[i].Draw(_Material, curTime);
}
}
void RenderSmallCorner(Vector3 position, Voxel voxel, MeshContext context)
{
var points = new List <Vector3>();
points.Add(FrontBot2);
points.Add(FrontTop2);
points.Add(FrontBot1);
points.Add(FrontBot2);
points.Add(BackBot2);
points.Add(FrontTop2);
points.Add(FrontBot1);
points.Add(FrontTop2);
points.Add(BackBot2);
points.Add(BackBot2);
points.Add(FrontBot2);
points.Add(FrontBot1);
AddPoints(position, points, voxel, context);
}
public MemoController(ILogger <MemoController> logger, MeshContext meshContext)
{
_logger = logger;
_meshContext = meshContext;
_permissionCheck = new PermissionCheckHelper(meshContext);
}
public WebDavPutCommand(MeshContext db)
{
_db = db;
}
public WebDavPropFindCommand(MeshContext db)
{
_db = db;
}
// mesh is sharing morph targets.
private static MeshContext _ImportMeshSharingMorphTarget(ImporterContext ctx, glTFMesh gltfMesh)
{
var positions = new List <Vector3>();
var normals = new List <Vector3>();
var tangents = new List <Vector4>();
var uv = new List <Vector2>();
var colors = new List <Color>();
var blendShapes = new List <BlendShape>();
var meshContext = new MeshContext();
// blendshapes
var targetNames = gltfMesh.extras.targetNames;
for (int i = 1; i < gltfMesh.primitives.Count; ++i)
{
if (gltfMesh.primitives[i].targets.Count != targetNames.Count)
{
throw new FormatException(string.Format("different targets length: {0} with targetNames length.",
gltfMesh.primitives[i]));
}
}
for (var i = 0; i < targetNames.Count; i++)
{
var blendShape = new BlendShape(!string.IsNullOrEmpty(targetNames[i]) ? targetNames[i] : i.ToString());
blendShapes.Add(blendShape);
}
foreach (var prim in gltfMesh.primitives)
{
var indexOffset = positions.Count;
var indexBuffer = prim.indices;
var positionCount = positions.Count;
positions.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector3>(prim.attributes.POSITION).Select(x => x.ReverseZ()));
positionCount = positions.Count - positionCount;
// normal
if (prim.attributes.NORMAL != -1)
{
normals.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector3>(prim.attributes.NORMAL).Select(x => x.ReverseZ()));
}
if (prim.attributes.TANGENT != -1)
{
tangents.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector4>(prim.attributes.TANGENT).Select(x => x.ReverseZ()));
}
// uv
if (prim.attributes.TEXCOORD_0 != -1)
{
if (ctx.IsGeneratedUniGLTFAndOlder(1, 16))
{
#pragma warning disable 0612
// backward compatibility
uv.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector2>(prim.attributes.TEXCOORD_0).Select(x => x.ReverseY()));
#pragma warning restore 0612
}
else
{
uv.AddRange(ctx.GLTF.GetArrayFromAccessor <Vector2>(prim.attributes.TEXCOORD_0).Select(x => x.ReverseUV()));
}
}
else
{
// for inconsistent attributes in primitives
uv.AddRange(new Vector2[positionCount]);
}
// color
if (prim.attributes.COLOR_0 != -1)
{
colors.AddRange(ctx.GLTF.GetArrayFromAccessor <Color>(prim.attributes.COLOR_0));
}
// skin
if (prim.attributes.JOINTS_0 != -1 && prim.attributes.WEIGHTS_0 != -1)
{
var joints0 = ctx.GLTF.GetArrayFromAccessor <UShort4>(prim.attributes.JOINTS_0); // uint4
var weights0 = ctx.GLTF.GetArrayFromAccessor <Float4>(prim.attributes.WEIGHTS_0).Select(x => x.One()).ToArray();
for (int j = 0; j < joints0.Length; ++j)
{
var bw = new BoneWeight();
bw.boneIndex0 = joints0[j].x;
bw.weight0 = weights0[j].x;
bw.boneIndex1 = joints0[j].y;
bw.weight1 = weights0[j].y;
bw.boneIndex2 = joints0[j].z;
bw.weight2 = weights0[j].z;
bw.boneIndex3 = joints0[j].w;
bw.weight3 = weights0[j].w;
meshContext.boneWeights.Add(bw);
}
}
// blendshape
if (prim.targets != null && prim.targets.Count > 0)
{
for (int i = 0; i < prim.targets.Count; ++i)
{
var primTarget = prim.targets[i];
if (primTarget.POSITION != -1)
{
blendShapes[i].Positions.AddRange(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.POSITION).Select(x => x.ReverseZ()).ToArray());
}
if (primTarget.NORMAL != -1)
{
blendShapes[i].Normals.AddRange(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.NORMAL).Select(x => x.ReverseZ()).ToArray());
}
if (primTarget.TANGENT != -1)
{
blendShapes[i].Tangents.AddRange(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.TANGENT).Select(x => x.ReverseZ()).ToArray());
}
}
}
var indices =
(indexBuffer >= 0)
? ctx.GLTF.GetIndices(indexBuffer)
: TriangleUtil.FlipTriangle(Enumerable.Range(0, meshContext.positions.Length)).ToArray() // without index array
;
for (int i = 0; i < indices.Length; ++i)
{
indices[i] += indexOffset;
}
meshContext.subMeshes.Add(indices);
// material
meshContext.materialIndices.Add(prim.material);
}
meshContext.positions = positions.ToArray();
meshContext.normals = normals.ToArray();
meshContext.tangents = tangents.ToArray();
meshContext.uv = uv.ToArray();
meshContext.blendShapes = blendShapes;
return(meshContext);
}
public StatisticsController(MeshContext meshContext)
{
_meshContext = meshContext;
}
public PreferenceController(ILogger <ProjectController> logger, MeshContext meshContext)
{
_logger = logger;
_meshContext = meshContext;
}
// multiple submesh sharing same VertexBuffer
private MeshContext ImportMeshSharingVertexBuffer(GLTFRoot gltf, GLTFMesh gltfMesh)
{
var context = new MeshContext();
{
var prim = gltfMesh.primitives.First();
context.positions = gltf.GetArrayFromAccessor <Vector3>(prim.attributes.POSITION).SelectInplace(x => x.ReverseZ());
// normal
if (prim.attributes.NORMAL != -1)
{
context.normals = gltf.GetArrayFromAccessor <Vector3>(prim.attributes.NORMAL).SelectInplace(x => x.ReverseZ());
}
// tangent
if (prim.attributes.TANGENT != -1)
{
context.tangents = gltf.GetArrayFromAccessor <Vector4>(prim.attributes.TANGENT).SelectInplace(x => x.ReverseZ());
}
// uv
if (prim.attributes.TEXCOORD_0 != -1)
{
// if (ctx.IsGeneratedGLTFumaAndOlder(1, 16))
// {
// #pragma warning disable 0612
// // backward compatibility
// context.uv = ctx.gltf.GetArrayFromAccessor<Vector2>(prim.attributes.TEXCOORD_0).SelectInplace(x => x.ReverseY());
// #pragma warning restore 0612
// }
// else
// {
context.uv = gltf.GetArrayFromAccessor <Vector2>(prim.attributes.TEXCOORD_0).SelectInplace(x => x.ReverseUV());
// }
}
else
{
// for inconsistent attributes in primitives
context.uv = new Vector2[context.positions.Length];
}
// color
if (prim.attributes.COLOR_0 != -1)
{
context.colors = gltf.GetArrayFromAccessor <Color>(prim.attributes.COLOR_0);
}
// skin
if (prim.attributes.JOINTS_0 != -1 && prim.attributes.WEIGHTS_0 != -1)
{
var joints0 = gltf.GetArrayFromAccessor <UShort4>(prim.attributes.JOINTS_0); // uint4
var weights0 = gltf.GetArrayFromAccessor <Float4>(prim.attributes.WEIGHTS_0);
for (int i = 0; i < weights0.Length; ++i)
{
weights0[i] = weights0[i].One();
}
for (int j = 0; j < joints0.Length; ++j)
{
var bw = new BoneWeight();
bw.boneIndex0 = joints0[j].x;
bw.weight0 = weights0[j].x;
bw.boneIndex1 = joints0[j].y;
bw.weight1 = weights0[j].y;
bw.boneIndex2 = joints0[j].z;
bw.weight2 = weights0[j].z;
bw.boneIndex3 = joints0[j].w;
bw.weight3 = weights0[j].w;
context.boneWeights.Add(bw);
}
}
// blendshape
if (prim.targets != null && prim.targets.Count > 0)
{
context.blendShapes.AddRange(prim.targets.Select((x, i) => new BlendShape(
i < prim.extras.targetNames.Count && !string.IsNullOrEmpty(prim.extras.targetNames[i])
? prim.extras.targetNames[i]
: i.ToString())));
for (int i = 0; i < prim.targets.Count; ++i)
{
//var name = string.Format("target{0}", i++);
var primTarget = prim.targets[i];
var blendShape = context.blendShapes[i];
if (primTarget.POSITION != -1)
{
blendShape.positions.Assign(
gltf.GetArrayFromAccessor <Vector3>(primTarget.POSITION), x => x.ReverseZ());
}
if (primTarget.NORMAL != -1)
{
blendShape.normals.Assign(
gltf.GetArrayFromAccessor <Vector3>(primTarget.NORMAL), x => x.ReverseZ());
}
if (primTarget.TANGENT != -1)
{
blendShape.tangents.Assign(
gltf.GetArrayFromAccessor <Vector3>(primTarget.TANGENT), x => x.ReverseZ());
}
}
}
}
foreach (var prim in gltfMesh.primitives)
{
if (prim.indices == -1)
{
context.subMeshes.Add(Enumerable.Range(0, context.positions.Length).FlipTriangle().ToArray());
}
else
{
var indices = gltf.GetIndices(prim.indices);
context.subMeshes.Add(indices);
}
// material
context.materialIndices.Add(prim.material);
}
return(context);
}
public ModelsController(ILogger <ModelsController> logger, MeshContext db)
{
_logger = logger;
_db = db;
}
public UserController(ILogger <UserController> logger, MeshContext meshContext)
{
_logger = logger;
_meshContext = meshContext;
}
// multiple submesh sharing same VertexBuffer
private static MeshContext _ImportMeshSharingVertexBuffer(ImporterContext ctx, glTFMesh gltfMesh)
{
var context = new MeshContext();
{
var prim = gltfMesh.primitives.First();
context.positions = ctx.GLTF.GetArrayFromAccessor <Vector3>(prim.attributes.POSITION).SelectInplace(x => x.ReverseZ());
// normal
if (prim.attributes.NORMAL != -1)
{
context.normals = ctx.GLTF.GetArrayFromAccessor <Vector3>(prim.attributes.NORMAL).SelectInplace(x => x.ReverseZ());
}
// tangent
if (prim.attributes.TANGENT != -1)
{
context.tangents = ctx.GLTF.GetArrayFromAccessor <Vector4>(prim.attributes.TANGENT).SelectInplace(x => x.ReverseZ());
}
// uv
if (prim.attributes.TEXCOORD_0 != -1)
{
if (ctx.IsGeneratedUniGLTFAndOlder(1, 16))
{
#pragma warning disable 0612
// backward compatibility
context.uv = ctx.GLTF.GetArrayFromAccessor <Vector2>(prim.attributes.TEXCOORD_0).SelectInplace(x => x.ReverseY());
#pragma warning restore 0612
}
else
{
context.uv = ctx.GLTF.GetArrayFromAccessor <Vector2>(prim.attributes.TEXCOORD_0).SelectInplace(x => x.ReverseUV());
}
}
else
{
// for inconsistent attributes in primitives
context.uv = new Vector2[context.positions.Length];
}
// color
if (prim.attributes.COLOR_0 != -1)
{
if (ctx.GLTF.accessors[prim.attributes.COLOR_0].TypeCount == 3)
{
var vec3Color = ctx.GLTF.GetArrayFromAccessor <Vector3>(prim.attributes.COLOR_0);
context.colors = new Color[vec3Color.Length];
for (int i = 0; i < vec3Color.Length; i++)
{
Vector3 color = vec3Color[i];
context.colors[i] = new Color(color.x, color.y, color.z);
}
}
else if (ctx.GLTF.accessors[prim.attributes.COLOR_0].TypeCount == 4)
{
context.colors = ctx.GLTF.GetArrayFromAccessor <Color>(prim.attributes.COLOR_0);
}
else
{
throw new NotImplementedException(string.Format("unknown color type {0}", ctx.GLTF.accessors[prim.attributes.COLOR_0].type));
}
}
// skin
if (prim.attributes.JOINTS_0 != -1 && prim.attributes.WEIGHTS_0 != -1)
{
var joints0 = ctx.GLTF.GetArrayFromAccessor <UShort4>(prim.attributes.JOINTS_0); // uint4
var weights0 = ctx.GLTF.GetArrayFromAccessor <Float4>(prim.attributes.WEIGHTS_0);
for (int i = 0; i < weights0.Length; ++i)
{
weights0[i] = weights0[i].One();
}
for (int j = 0; j < joints0.Length; ++j)
{
var bw = new BoneWeight();
bw.boneIndex0 = joints0[j].x;
bw.weight0 = weights0[j].x;
bw.boneIndex1 = joints0[j].y;
bw.weight1 = weights0[j].y;
bw.boneIndex2 = joints0[j].z;
bw.weight2 = weights0[j].z;
bw.boneIndex3 = joints0[j].w;
bw.weight3 = weights0[j].w;
context.boneWeights.Add(bw);
}
}
// blendshape
if (prim.targets != null && prim.targets.Count > 0)
{
context.blendShapes.AddRange(prim.targets.Select((x, i) => new BlendShape(
i < prim.extras.targetNames.Count && !string.IsNullOrEmpty(prim.extras.targetNames[i])
? prim.extras.targetNames[i]
: i.ToString())));
for (int i = 0; i < prim.targets.Count; ++i)
{
//var name = string.Format("target{0}", i++);
var primTarget = prim.targets[i];
var blendShape = context.blendShapes[i];
if (primTarget.POSITION != -1)
{
blendShape.Positions.Assign(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.POSITION), x => x.ReverseZ());
}
if (primTarget.NORMAL != -1)
{
blendShape.Normals.Assign(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.NORMAL), x => x.ReverseZ());
}
if (primTarget.TANGENT != -1)
{
blendShape.Tangents.Assign(
ctx.GLTF.GetArrayFromAccessor <Vector3>(primTarget.TANGENT), x => x.ReverseZ());
}
}
}
}
foreach (var prim in gltfMesh.primitives)
{
if (prim.indices == -1)
{
context.subMeshes.Add(TriangleUtil.FlipTriangle(Enumerable.Range(0, context.positions.Length)).ToArray());
}
else
{
var indices = ctx.GLTF.GetIndices(prim.indices);
context.subMeshes.Add(indices);
}
// material
context.materialIndices.Add(prim.material);
}
return(context);
}
public MeshContext LoadMesh(string lwfName,
Data data, Format.BitmapEx bitmapEx, int bitmapExId)
{
MeshItem item;
string cacheName = string.Format("{0}/{1}", lwfName, bitmapExId);
if (!m_meshCache.TryGetValue(cacheName, out item))
{
Format.TextureFragment fragment =
data.textureFragments[bitmapEx.textureFragmentId];
Format.Texture texture = data.textures[fragment.textureId];
float tw = (float)texture.width;
float th = (float)texture.height;
float x = (float)fragment.x;
float y = -(float)fragment.y;
float u = (float)fragment.u;
float v = th - (float)fragment.v;
float w = (float)fragment.w;
float h = (float)fragment.h;
float bu = bitmapEx.u * w;
float bv = bitmapEx.v * h;
float bw = bitmapEx.w;
float bh = bitmapEx.h;
x += bu;
y += bv;
u += bu;
v += bv;
w *= bw;
h *= bh;
float height = h / texture.scale;
float x0 = x / texture.scale;
float y0 = y / texture.scale;
float x1 = (x + w) / texture.scale;
float y1 = (y + h) / texture.scale;
Mesh mesh = new Mesh();
mesh.name = "LWF/" + cacheName;
mesh.vertices = new Vector3[] {
new Vector3(x1, y1, 0),
new Vector3(x1, y0, 0),
new Vector3(x0, y1, 0),
new Vector3(x0, y0, 0),
};
float dw = 2.0f * tw;
float dh = 2.0f * th;
if (fragment.rotated == 0)
{
float u0 = (float)(2 * u + 1) / dw;
float v0 = (float)(2 * (v - h) + 1) / dh;
float u1 = u0 + (float)(w * 2 - 2) / dw;
float v1 = (float)(v * 2 - 1) / dh;
mesh.uv = new Vector2[] {
new Vector2(u1, v1),
new Vector2(u1, v0),
new Vector2(u0, v1),
new Vector2(u0, v0),
};
}
else
{
float u0 = (float)(2 * u + 1) / dw;
float v0 = (float)(2 * (v - w) + 1) / dh;
float u1 = u0 + (float)(h * 2 - 2) / dw;
float v1 = (float)(v * 2 - 1) / dh;
mesh.uv = new Vector2[] {
new Vector2(u1, v0),
new Vector2(u0, v0),
new Vector2(u1, v1),
new Vector2(u0, v1),
};
}
mesh.triangles = new int[] {
0, 1, 2,
2, 1, 3,
};
mesh.RecalculateBounds();
//mesh.Optimize();
MeshContext context = new MeshContext(mesh, height);
item = new MeshItem(context);
m_meshCache[cacheName] = item;
}
item.Ref();
return(item.Entity());
}
// multiple submMesh is not sharing a VertexBuffer.
// each subMesh use a independent VertexBuffer.
private MeshContext ImportMeshIndependentVertexBuffer(GLTFRoot gltf, GLTFMesh gltfMesh)
{
//Debug.LogWarning("_ImportMeshIndependentVertexBuffer");
var targets = gltfMesh.primitives[0].targets;
for (int i = 1; i < gltfMesh.primitives.Count; ++i)
{
if (!gltfMesh.primitives[i].targets.SequenceEqual(targets))
{
throw new NotImplementedException(string.Format("diffirent targets: {0} with {1}",
gltfMesh.primitives[i],
targets));
}
}
var positions = new List <Vector3>();
var normals = new List <Vector3>();
var tangents = new List <Vector4>();
var uv = new List <Vector2>();
var colors = new List <Color>();
var meshContext = new MeshContext();
foreach (var prim in gltfMesh.primitives)
{
var indexOffset = positions.Count;
var indexBuffer = prim.indices;
var positionCount = positions.Count;
positions.AddRange(gltf.GetArrayFromAccessor <Vector3>(prim.attributes.POSITION).Select(x => x.ReverseZ()));
positionCount = positions.Count - positionCount;
// normal
if (prim.attributes.NORMAL != -1)
{
normals.AddRange(gltf.GetArrayFromAccessor <Vector3>(prim.attributes.NORMAL).Select(x => x.ReverseZ()));
}
if (prim.attributes.TANGENT != -1)
{
tangents.AddRange(gltf.GetArrayFromAccessor <Vector4>(prim.attributes.TANGENT).Select(x => x.ReverseZ()));
}
// uv
if (prim.attributes.TEXCOORD_0 != -1)
{
uv.AddRange(gltf.GetArrayFromAccessor <Vector2>(prim.attributes.TEXCOORD_0).Select(x => x.ReverseUV()));
}
else
{
// for inconsistent attributes in primitives
uv.AddRange(new Vector2[positionCount]);
}
// color
if (prim.attributes.COLOR_0 != -1)
{
colors.AddRange(gltf.GetArrayFromAccessor <Color>(prim.attributes.COLOR_0));
}
// skin
if (prim.attributes.JOINTS_0 != -1 && prim.attributes.WEIGHTS_0 != -1)
{
var joints0 = gltf.GetArrayFromAccessor <UShort4>(prim.attributes.JOINTS_0); // uint4
var weights0 = gltf.GetArrayFromAccessor <Float4>(prim.attributes.WEIGHTS_0).Select(x => x.One()).ToArray();
for (int j = 0; j < joints0.Length; ++j)
{
var bw = new BoneWeight();
bw.boneIndex0 = joints0[j].x;
bw.weight0 = weights0[j].x;
bw.boneIndex1 = joints0[j].y;
bw.weight1 = weights0[j].y;
bw.boneIndex2 = joints0[j].z;
bw.weight2 = weights0[j].z;
bw.boneIndex3 = joints0[j].w;
bw.weight3 = weights0[j].w;
meshContext.boneWeights.Add(bw);
}
}
// blendshape
if (prim.targets != null && prim.targets.Count > 0)
{
for (int i = 0; i < prim.targets.Count; ++i)
{
//var name = string.Format("target{0}", i++);
var primTarget = prim.targets[i];
var blendShape = new BlendShape(!string.IsNullOrEmpty(prim.extras.targetNames[i])
? prim.extras.targetNames[i]
: i.ToString())
;
if (primTarget.POSITION != -1)
{
blendShape.positions.AddRange(
gltf.GetArrayFromAccessor <Vector3>(primTarget.POSITION).Select(x => x.ReverseZ()).ToArray());
}
if (primTarget.NORMAL != -1)
{
blendShape.normals.AddRange(
gltf.GetArrayFromAccessor <Vector3>(primTarget.NORMAL).Select(x => x.ReverseZ()).ToArray());
}
if (primTarget.TANGENT != -1)
{
blendShape.tangents.AddRange(
gltf.GetArrayFromAccessor <Vector3>(primTarget.TANGENT).Select(x => x.ReverseZ()).ToArray());
}
meshContext.blendShapes.Add(blendShape);
}
}
var indices =
(indexBuffer >= 0)
? gltf.GetIndices(indexBuffer)
: Enumerable.Range(0, meshContext.positions.Length).FlipTriangle().ToArray() // without index array
;
for (int i = 0; i < indices.Length; ++i)
{
indices[i] += indexOffset;
}
meshContext.subMeshes.Add(indices);
// material
meshContext.materialIndices.Add(prim.material);
}
meshContext.positions = positions.ToArray();
meshContext.normals = normals.ToArray();
meshContext.tangents = tangents.ToArray();
meshContext.uv = uv.ToArray();
return(meshContext);
}
public FeedController(ILogger <FeedController> logger, MeshContext meshContext)
{
_meshContext = meshContext;
_logger = logger;
}
private MeshWithMaterials BuildMesh(GLTFRoot gltf, MeshContext meshContext)
{
if (!meshContext.materialIndices.Any())
{
meshContext.materialIndices.Add(0);
}
//Debug.Log(prims.ToJson());
var mesh = new Mesh();
mesh.name = meshContext.name;
if (meshContext.positions.Length > UInt16.MaxValue)
{
mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
}
mesh.vertices = meshContext.positions;
bool recalculateNormals = false;
if (meshContext.normals != null && meshContext.normals.Length > 0)
{
mesh.normals = meshContext.normals;
}
else
{
recalculateNormals = true;
}
if (meshContext.uv != null && meshContext.uv.Length > 0)
{
mesh.uv = meshContext.uv;
}
bool recalculateTangents = true;
#if UNIGLTF_IMPORT_TANGENTS
if (meshContext.tangents != null && meshContext.tangents.Length > 0)
{
mesh.tangents = meshContext.tangents;
recalculateTangents = false;
}
#endif
if (meshContext.colors != null && meshContext.colors.Length > 0)
{
mesh.colors = meshContext.colors;
}
if (meshContext.boneWeights != null && meshContext.boneWeights.Count > 0)
{
mesh.boneWeights = meshContext.boneWeights.ToArray();
}
mesh.subMeshCount = meshContext.subMeshes.Count;
for (int i = 0; i < meshContext.subMeshes.Count; ++i)
{
mesh.SetTriangles(meshContext.subMeshes[i], i);
}
if (recalculateNormals)
{
mesh.RecalculateNormals();
}
if (recalculateTangents)
{
#if UNITY_5_6_OR_NEWER
mesh.RecalculateTangents();
#else
CalcTangents(mesh);
#endif
}
var result = new MeshWithMaterials
{
mesh = mesh,
//materials = meshContext.materialIndices.Select(x => ctx.GetMaterial(x)).ToArray()
materialIndices = meshContext.materialIndices.ToArray()
};
if (meshContext.blendShapes != null)
{
Vector3[] emptyVertices = null;
foreach (var blendShape in meshContext.blendShapes)
{
if (blendShape.positions.Count > 0)
{
if (blendShape.positions.Count == mesh.vertexCount)
{
mesh.AddBlendShapeFrame(blendShape.name, FRAME_WEIGHT,
blendShape.positions.ToArray(),
(meshContext.normals != null && meshContext.normals.Length == mesh.vertexCount) ? blendShape.normals.ToArray() : null,
null
);
}
else
{
Debug.LogWarningFormat("May be partial primitive has blendShape. Rquire separete mesh or extend blend shape, but not implemented: {0}", blendShape.name);
}
}
else
{
if (emptyVertices == null)
{
emptyVertices = new Vector3[mesh.vertexCount];
}
// Debug.LogFormat("empty blendshape: {0}.{1}", mesh.name, blendShape.Name);
// add empty blend shape for keep blend shape index
mesh.AddBlendShapeFrame(blendShape.name, FRAME_WEIGHT, emptyVertices, null, null);
}
}
}
return(result);
}
public PermissionCheckHelper(MeshContext meshContext)
{
_meshContext = meshContext;
}
