示例#1
0
        private IAsset CreateAsset(AssetLoadInfo loadInfo)
        {
            var fileBytes = loadInfo.FileSystem.ReadAllBytes(loadInfo.LoadPath);

            int    width, height;
            double duration;

            using (var stream = new MemoryStream(fileBytes))
                using (var reader = new FFmpegMovieReader(stream))
                {
                    width    = reader.Width;
                    height   = reader.Height;
                    duration = reader.Duration;
                }

            var assetName = loadInfo.AssetName;
            var fileName  = Path.GetFileName(loadInfo.LoadPath);
            var movie     = new FFmpegFileMovie(width, height, duration, () => OpenAssetFile(assetName, fileName));
            var hash      = AssetHashMd5.FromSingleFile(fileBytes);

            return(new Asset(assetName, movie, loadInfo.StorageType, hash, loadInfo.ReferencePath, fileName));
        }
示例#2
0
 public AssetLoadResultByLoader Load(AssetLoadInfo loadInfo)
 {
     try
     {
         var points   = new List <Vector3>();
         var loadPath = loadInfo.LoadPath;
         var fileData = loadInfo.FileSystem.ReadAllBytes(loadPath);
         using (var reader = new StreamReader(new MemoryStream(fileData)))
             while (true)
             {
                 var line = reader.ReadLine();
                 if (line == null)
                 {
                     break;
                 }
                 var match = PointRegex.Match(line);
                 if (!match.Success)
                 {
                     continue;
                 }
                 points.Add(new Vector3(
                                float.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture),
                                float.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture),
                                float.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture)
                                ));
             }
         var resource = new SpherePackingResult(points);
         var hash     = AssetHashMd5.FromSingleFile(fileData);
         var asset    = new Asset(loadInfo.AssetName, resource, loadInfo.StorageType, hash, loadInfo.ReferencePath, Path.GetFileName(loadInfo.ReferencePath));
         return(AssetLoadResultByLoader.Success(asset));
     }
     catch (Exception ex)
     {
         return(AssetLoadResultByLoader.Failure("EXCEPTION", ex));
     }
 }
示例#3
0
        private unsafe IAsset BuildAsset(AssetLoadInfo loadInfo)
        {
            var fileData = loadInfo.FileSystem.ReadAllBytes(loadInfo.LoadPath);

            var        objLoaderFactory = new ObjLoaderFactory();
            var        objLoader        = objLoaderFactory.Create(new MyMaterialStreamProvider(Path.GetDirectoryName(loadInfo.LoadPath), loadInfo.FileSystem));
            LoadResult objLoadResult;

            using (var stream = new MemoryStream(fileData))
                objLoadResult = objLoader.Load(stream);

            var anyTextures            = objLoadResult.Textures.Any();
            var initialMediatorIndices = new int?[objLoadResult.Vertices.Count];
            var mediators           = new List <VertexMediator>();
            var faceMediatorIndices = new List <int>();
            var indexList           = new List <int>();
            var materials           = new List <IStandardMaterial>();
            var modelParts          = new List <FlexibleModelPart>();

            foreach (var grp in objLoadResult.Groups)
            {
                var startIndexLocation = indexList.Count;
                foreach (var face in grp.Faces)
                {
                    faceMediatorIndices.Clear();
                    foreach (var fv in face.EnumerateVertices())
                    {
                        var newMediator = new VertexMediator
                        {
                            PositionIndex = fv.VertexIndex - 1,
                            NormalIndex   = fv.NormalIndex - 1,
                            TexCoordIndex = anyTextures ? fv.TextureIndex - 1 : 0
                        };
                        var initialIndex = initialMediatorIndices[newMediator.PositionIndex];
                        if (!initialIndex.HasValue)
                        {
                            var mediatorIndex = mediators.Count;
                            mediators.Add(newMediator);
                            faceMediatorIndices.Add(mediatorIndex);
                            initialMediatorIndices[newMediator.PositionIndex] = mediatorIndex;
                        }
                        else
                        {
                            var mediatorIndex = initialIndex.Value;
                            var oldMediator   = mediators[mediatorIndex];
                            while (true)
                            {
                                if (oldMediator.PositionIndex == newMediator.PositionIndex &&
                                    oldMediator.NormalIndex == newMediator.NormalIndex &&
                                    oldMediator.TexCoordIndex == newMediator.TexCoordIndex)
                                {
                                    break;
                                }
                                if (!oldMediator.NextMediator.HasValue)
                                {
                                    mediatorIndex = mediators.Count;
                                    mediators.Add(newMediator);
                                    oldMediator.NextMediator = mediatorIndex;
                                    break;
                                }
                                mediatorIndex = oldMediator.NextMediator.Value;
                                oldMediator   = mediators[mediatorIndex];
                            }
                            faceMediatorIndices.Add(mediatorIndex);
                        }
                    }
                    if (faceMediatorIndices.Count <= 3)
                    {
                        for (int i = 0; i < faceMediatorIndices.Count - 3; i++)
                        {
                            indexList.Add(faceMediatorIndices[0]);
                        }
                        foreach (var mi in faceMediatorIndices)
                        {
                            indexList.Add(mi);
                        }
                    }
                    else
                    {
                        for (int i = 0; i < faceMediatorIndices.Count - 2; i++)
                        {
                            indexList.Add(faceMediatorIndices[0]);
                            indexList.Add(faceMediatorIndices[i + 1]);
                            indexList.Add(faceMediatorIndices[i + 2]);
                        }
                    }
                }
                var indexCount = indexList.Count - startIndexLocation;
                var color      = grp.Material != null
                    ? new Color4(
                    grp.Material.DiffuseColor.X,
                    grp.Material.DiffuseColor.Y,
                    grp.Material.DiffuseColor.Z)
                    : (Color4?)null;

                // todo: use material

                modelParts.Add(new FlexibleModelPart
                {
                    VertexSetIndex    = 0,
                    ModelMaterialName = grp.Material?.Name ?? "DefaultMaterial",
                    PrimitiveTopology = FlexibleModelPrimitiveTopology.TriangleList,
                    IndexCount        = indexCount,
                    FirstIndex        = startIndexLocation
                });
            }

            VertexPosNormTex[] finalVertices;
            int[] finalIndices;

            if (objLoadResult.Normals.Count > 0)
            {
                var vertices = mediators.Select(m => new VertexPosNormTex()).ToArray();
                for (int i = 0; i < mediators.Count; i++)
                {
                    var mediator = mediators[i];
                    vertices[i].Position = objLoadResult.Vertices[mediator.PositionIndex].ToClarity();
                    vertices[i].Normal   = objLoadResult.Normals[mediator.NormalIndex].ToClarity();
                    if (anyTextures)
                    {
                        vertices[i].TexCoord = objLoadResult.Textures[mediator.TexCoordIndex].ToClarity();
                    }
                }

                finalVertices = vertices;
                finalIndices  = indexList.ToArray();
            }
            else
            {
                var newIndices  = Enumerable.Range(0, indexList.Count).ToArray();
                var newVertices = new VertexPosNormTex[newIndices.Length];
                for (int i = 0; i + 2 < indexList.Count; i += 3)
                {
                    var mediator0 = mediators[indexList[i]];
                    var mediator1 = mediators[indexList[i + 1]];
                    var mediator2 = mediators[indexList[i + 2]];
                    var pos0      = objLoadResult.Vertices[mediator0.PositionIndex].ToClarity();
                    var pos1      = objLoadResult.Vertices[mediator1.PositionIndex].ToClarity();
                    var pos2      = objLoadResult.Vertices[mediator2.PositionIndex].ToClarity();
                    newVertices[i] = new VertexPosNormTex
                    {
                        Position = pos0,
                        Normal   = -Vector3.Cross(pos2 - pos0, pos1 - pos0).Normalize(),
                        TexCoord = new Vector2(0.3f, 0.3f)
                    };
                    newVertices[i + 1] = new VertexPosNormTex
                    {
                        Position = pos1,
                        Normal   = -Vector3.Cross(pos0 - pos1, pos2 - pos1).Normalize(),
                        TexCoord = new Vector2(0.7f, 0.3f)
                    };
                    newVertices[i + 2] = new VertexPosNormTex
                    {
                        Position = pos2,
                        Normal   = -Vector3.Cross(pos1 - pos2, pos0 - pos2).Normalize(),
                        TexCoord = new Vector2(0.5f, 0.7f)
                    };
                }

                finalVertices = newVertices;
                finalIndices  = newIndices;
            }

            var pack = new ResourcePack(ResourceVolatility.Immutable);

            IRawDataResource vertexRawData;

            fixed(VertexPosNormTex *pVertices = finalVertices)
            vertexRawData = new RawDataResource(ResourceVolatility.Immutable, (IntPtr)pVertices, sizeof(VertexPosNormTex) * finalVertices.Length);

            pack.AddSubresource("VertexRawData", vertexRawData);

            IRawDataResource indexRawData;

            fixed(int *pIndices = finalIndices)
            indexRawData = new RawDataResource(ResourceVolatility.Immutable, (IntPtr)pIndices, sizeof(int) * finalIndices.Length);

            pack.AddSubresource("IndexRawData", indexRawData);

            var arraySubranges = new []
            {
                vertexRawData.GetSubrange(0),
                indexRawData.GetSubrange(0)
            };

            var elementInfos = VertexPosNormTex.GetElementsInfos(0);
            var indicesInfo  = new VertexIndicesInfo(1, CommonFormat.R32_UINT);
            var vertexSet    = new FlexibleModelVertexSet(ResourceVolatility.Immutable, arraySubranges, elementInfos, indicesInfo);

            pack.AddSubresource("VertexSet", vertexSet);

            var sphere = Sphere.BoundingSphere(finalVertices, x => x.Position);
            var model  = new FlexibleModel(ResourceVolatility.Immutable, new [] { vertexSet }, modelParts, sphere);

            pack.AddSubresource("Model", model);
            pack.MainSubresource = model;

            var hash     = AssetHashMd5.FromSingleFile(fileData);
            var fileName = Path.GetFileName(loadInfo.LoadPath);

            return(new Asset(loadInfo.AssetName, pack, AssetStorageType.CopyLocal, hash, loadInfo.ReferencePath, fileName));
        }
示例#4
0
        private static AssetLoadResultByLoader Load(AssetLoadInfo loadInfo, void *dicomManager)
        {
            int width, height, depth;

            CheckSuccess(DicomProject.AnalyzerGetDimensions(dicomManager, 1, &width, &height, &depth));

            var lowerBuffer  = new byte[width * height];
            var higherBuffer = new byte[width * height];
            var vertexList   = new List <VertexPosNormTex>();

            fixed(byte *pBuffer = higherBuffer)
            {
                int bufferSize = higherBuffer.Length;
                int bytesWritten;

                CheckSuccess(DicomProject.AnalyzerGetMonochromePixelDataBufferOfSlice(dicomManager, 1, pBuffer, &bufferSize, &bytesWritten));
            }

            for (int z = 1; z < depth; z++)
            {
                CodingHelper.Swap(ref lowerBuffer, ref higherBuffer);

                fixed(byte *pBuffer = higherBuffer)
                {
                    int bufferSize = higherBuffer.Length;
                    int bytesWritten;

                    CheckSuccess(DicomProject.AnalyzerGetMonochromePixelDataBufferOfSlice(dicomManager, z + 1, pBuffer, &bufferSize, &bytesWritten));
                }

                for (int y = 0; y < height - 1; y++)
                {
                    for (int x = 0; x < width - 1; x++)
                    {
                        var vx = (100f / width) * x - 50f;
                        var vy = (100f / height) * y - 50f;
                        var vz = (100f / depth) * z - 50f;

                        var yStride = width;

                        var mcCube = new MCCubeCornerScalarStruct
                        {
                            CubeDim   = new IrtPtType(100.0 / width, 100.0 / height, 100.0 / depth),
                            Vrtx0Lctn = new IrtPtType(vx, vy, vz)
                        };
                        mcCube.Corners[0] = UNormToDouble(lowerBuffer[yStride * y + x]);
                        mcCube.Corners[1] = UNormToDouble(lowerBuffer[yStride * y + (x + 1)]);
                        mcCube.Corners[2] = UNormToDouble(lowerBuffer[yStride * (y + 1) + (x + 1)]);
                        mcCube.Corners[3] = UNormToDouble(lowerBuffer[yStride * (y + 1) + x]);
                        mcCube.Corners[4] = UNormToDouble(higherBuffer[yStride * y + x]);
                        mcCube.Corners[5] = UNormToDouble(higherBuffer[yStride * y + (x + 1)]);
                        mcCube.Corners[6] = UNormToDouble(higherBuffer[yStride * (y + 1) + (x + 1)]);
                        mcCube.Corners[7] = UNormToDouble(higherBuffer[yStride * (y + 1) + x]);
                        // todo: use ref instead
                        EstimateGradient(&mcCube);
                        var MCPolys = Irit.MCThresholdCube(&mcCube, 0.5);

                        while (MCPolys != null)
                        {
                            var texCoord = new Vector2((float)x / width, (float)z / depth);

                            var vertex0    = MCPolys->GetClarityVertex(0, texCoord);
                            var vertexCurr = MCPolys->GetClarityVertex(1, texCoord);

                            for (var i = 2; i < MCPolys->NumOfVertices; i++)
                            {
                                var vertexPrev = vertexCurr;

                                vertexCurr = MCPolys->GetClarityVertex(i, texCoord);
                                vertexList.Add(vertex0);
                                vertexList.Add(vertexPrev);
                                vertexList.Add(vertexCurr);
                            }

                            //Irit.IritFree(MCPolys);

                            MCPolys = MCPolys->Pnext;
                        }
                    }
                }
            }

            var pack = new ResourcePack(ResourceVolatility.Immutable);

            var rawVerticesData = new RawDataResource(ResourceVolatility.Immutable, vertexList.Count * sizeof(VertexPosNormTex));

            pack.AddSubresource("VertexData", rawVerticesData);
            var pRawData = (VertexPosNormTex *)rawVerticesData.Map();

            for (int i = 0; i < vertexList.Count; i++)
            {
                pRawData[i] = vertexList[i];
            }
            rawVerticesData.Unmap(true);

            var vertexSet = new FlexibleModelVertexSet(ResourceVolatility.Immutable, new[] { new RawDataResSubrange(rawVerticesData, 0) }, VertexPosNormTex.GetElementsInfos(0), null);

            pack.AddSubresource("ModelVertexSet", vertexSet);
            var modelPart = new FlexibleModelPart
            {
                IndexCount        = vertexList.Count,
                PrimitiveTopology = FlexibleModelPrimitiveTopology.TriangleList,
                VertexSetIndex    = 0
            };
            var model = new FlexibleModel(ResourceVolatility.Immutable, new[] { vertexSet }, new[] { modelPart }, new Sphere(Vector3.Zero, 50));

            pack.AddSubresource("Model", model);
            pack.MainSubresource = model;

            CheckSuccess(DicomProject.AnalyzerKillDicomAnalyzer(&dicomManager));

            // todo: calculate hash honestly
            var hash     = AssetHashMd5.Random(new Random());
            var fileName = Path.GetFileName(loadInfo.LoadPath);
            var asset    = new Asset(loadInfo.AssetName, pack, AssetStorageType.ReferenceOriginal, hash, loadInfo.ReferencePath, fileName);

            return(AssetLoadResultByLoader.Success(asset));
        }