public int LoadFromStream(Stream stream) { if (stream == null) return 0; ImageImporter imageImporter = new ImageImporter(); Image image = imageImporter.LoadImageFromStream(stream); GCHandle imageDataGCHandle = GCHandle.Alloc(image.GetImageData(0).Data, GCHandleType.Pinned); IntPtr imageDataIntPtr = imageDataGCHandle.AddrOfPinnedObject(); int glTextureHandle = GL.GenTexture(); GL.Enable(EnableCap.Texture2D); GL.BindTexture(TextureTarget.Texture2D, glTextureHandle); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)All.Linear); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)All.Linear); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba8, image.Width, image.Height, 0, PixelFormat.Rgba, PixelType.UnsignedByte, imageDataIntPtr); GL.BindTexture(TextureTarget.Texture2D, 0); GL.Disable(EnableCap.Texture2D); imageDataGCHandle.Free(); textures.Add(glTextureHandle); return glTextureHandle; }
protected void SetFromStream(Stream stream) { // try loading using standard .net first try { // We need to copy the stream over to a new, in-memory bitmap to // avoid keeping the input stream open. // See http://support.microsoft.com/kb/814675/en-us using (var img = Image.FromStream(stream)) { _image = new Bitmap(img.Width, img.Height, PixelFormat.Format32bppArgb); using (var gfx = Graphics.FromImage(_image)) { gfx.DrawImage(img, 0, 0, img.Width, img.Height); } _result = LoadResult.Good; } } catch (Exception) { // if this fails, load using DevIL using (var imp = new DevIL.ImageImporter()) { try { using (var devilImage = imp.LoadImageFromStream(stream)) { devilImage.Bind(); var info = DevIL.Unmanaged.IL.GetImageInfo(); var bitmap = new Bitmap(info.Width, info.Height, PixelFormat.Format32bppArgb); var rect = new Rectangle(0, 0, info.Width, info.Height); var data = bitmap.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); DevIL.Unmanaged.IL.CopyPixels(0, 0, 0, info.Width, info.Height, 1, DataFormat.BGRA, DataType.UnsignedByte, data.Scan0); bitmap.UnlockBits(data); _image = bitmap; _result = LoadResult.Good; _image.RotateFlip(RotateFlipType.RotateNoneFlipY); } } catch (Exception) { // TODO any other viable fall back image loaders? _result = LoadResult.UnknownFileFormat; } } } }
public static System.Drawing.Image LoadImageFromStream(Stream stream) { ImageImporter importer = new ImageImporter(); DevIL.Image img = importer.LoadImageFromStream(stream); DevIL.Unmanaged.ImageInfo imageInfo = img.GetImageInfo(); System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(imageInfo.Width, imageInfo.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb); System.Drawing.Rectangle rectangle = new System.Drawing.Rectangle(0, 0, imageInfo.Width, imageInfo.Height); System.Drawing.Imaging.BitmapData bitmapData = bitmap.LockBits(rectangle, System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); DevIL.Unmanaged.IL.CopyPixels(0, 0, 0, imageInfo.Width, imageInfo.Height, 1, DataFormat.BGRA, DevIL.DataType.UnsignedByte, bitmapData.Scan0); bitmap.UnlockBits(bitmapData); return (System.Drawing.Image)bitmap; }
public Bitmap LoadImage(DevIL.ImageImporter ImImport, MemoryStream mStream, int width = 128, int height = 128) { try { Bitmap img2 = null; using (DevIL.Image IconImg = ImImport.LoadImageFromStream(mStream)) { IconImg.Bind(); using (var img = new Bitmap(IconImg.Width, IconImg.Height, PixelFormat.Format32bppArgb)) { Rectangle rect = new Rectangle(0, 0, IconImg.Width, IconImg.Height); BitmapData data = img.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); DevIL.Unmanaged.IL.CopyPixels(0, 0, 0, IconImg.Width, IconImg.Height, 1, DevIL.DataFormat.BGRA, DevIL.DataType.UnsignedByte, data.Scan0); img.UnlockBits(data); img2 = (Bitmap)img.Clone(); } } return(img2); } catch { return(new Bitmap(width, height)); } }
private static void exportModelAsOBJToDirectory(Model model, string directory, ExportOptions options) { //TODO: Figure out what to do with non-version 4 models. if (model != null && model.Version != 4) { return; } NumberFormatInfo format = new NumberFormatInfo(); format.NumberDecimalSeparator = "."; if (options.Package) { try { DirectoryInfo directoryInfo = Directory.CreateDirectory(directory + @"\" + Path.GetFileNameWithoutExtension(model.Name)); directory = directoryInfo.FullName; } catch (Exception) { } } if (options.Textures) { ImageImporter imageImporter = new ImageImporter(); ImageExporter imageExporter = new ImageExporter(); foreach(String textureString in model.TextureStrings) { MemoryStream textureMemoryStream = AssetManager.Instance.CreateAssetMemoryStreamByName(textureString); if(textureMemoryStream == null) continue; Image textureImage = imageImporter.LoadImageFromStream(textureMemoryStream); if(textureImage == null) continue; imageExporter.SaveImage(textureImage, options.TextureFormat.ImageType, directory + @"\" + Path.GetFileNameWithoutExtension(textureString) + @"." + options.TextureFormat.Extension); } } String path = directory + @"\" + Path.GetFileNameWithoutExtension(model.Name) + ".obj"; FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Write); StreamWriter streamWriter = new StreamWriter(fileStream); for (Int32 i = 0; i < model.Meshes.Length; ++i) { Mesh mesh = model.Meshes[i]; MaterialDefinition materialDefinition = MaterialDefinitionManager.Instance.MaterialDefinitions[model.Materials[(Int32)mesh.MaterialIndex].MaterialDefinitionHash]; VertexLayout vertexLayout = MaterialDefinitionManager.Instance.VertexLayouts[materialDefinition.DrawStyles[0].VertexLayoutNameHash]; //position VertexLayout.Entry.DataTypes positionDataType; Int32 positionOffset; Int32 positionStreamIndex; vertexLayout.GetEntryInfoFromDataUsageAndUsageIndex(VertexLayout.Entry.DataUsages.Position, 0, out positionDataType, out positionStreamIndex, out positionOffset); Mesh.VertexStream positionStream = mesh.VertexStreams[positionStreamIndex]; for (Int32 j = 0; j < mesh.VertexCount; ++j) { Vector3 position = readVector3(options, positionOffset, positionStream, j); position.X *= options.Scale.X; position.Y *= options.Scale.Y; position.Z *= options.Scale.Z; streamWriter.WriteLine("v " + position.X.ToString(format) + " " + position.Y.ToString(format) + " " + position.Z.ToString(format)); } //texture coordinates if (options.TextureCoordinates) { VertexLayout.Entry.DataTypes texCoord0DataType; Int32 texCoord0Offset = 0; Int32 texCoord0StreamIndex = 0; Boolean texCoord0Present = vertexLayout.GetEntryInfoFromDataUsageAndUsageIndex(VertexLayout.Entry.DataUsages.Texcoord, 0, out texCoord0DataType, out texCoord0StreamIndex, out texCoord0Offset); if (texCoord0Present) { Mesh.VertexStream texCoord0Stream = mesh.VertexStreams[texCoord0StreamIndex]; for (Int32 j = 0; j < mesh.VertexCount; ++j) { Vector2 texCoord; switch (texCoord0DataType) { case VertexLayout.Entry.DataTypes.Float2: texCoord.X = BitConverter.ToSingle(texCoord0Stream.Data, (j * texCoord0Stream.BytesPerVertex) + 0); texCoord.Y = 1.0f - BitConverter.ToSingle(texCoord0Stream.Data, (j * texCoord0Stream.BytesPerVertex) + 4); break; case VertexLayout.Entry.DataTypes.float16_2: texCoord.X = Half.FromBytes(texCoord0Stream.Data, (j * texCoord0Stream.BytesPerVertex) + texCoord0Offset + 0).ToSingle(); texCoord.Y = 1.0f - Half.FromBytes(texCoord0Stream.Data, (j * texCoord0Stream.BytesPerVertex) + texCoord0Offset + 2).ToSingle(); break; default: texCoord.X = 0; texCoord.Y = 0; break; } streamWriter.WriteLine("vt " + texCoord.X.ToString(format) + " " + texCoord.Y.ToString(format)); } } } } //faces UInt32 vertexCount = 0; for (Int32 i = 0; i < model.Meshes.Length; ++i) { Mesh mesh = model.Meshes[i]; streamWriter.WriteLine("g Mesh" + i); for (Int32 j = 0; j < mesh.IndexCount; j += 3) { UInt32 index0, index1, index2; switch (mesh.IndexSize) { case 2: index0 = vertexCount + BitConverter.ToUInt16(mesh.IndexData, (j * 2) + 0) + 1; index1 = vertexCount + BitConverter.ToUInt16(mesh.IndexData, (j * 2) + 2) + 1; index2 = vertexCount + BitConverter.ToUInt16(mesh.IndexData, (j * 2) + 4) + 1; break; case 4: index0 = vertexCount + BitConverter.ToUInt32(mesh.IndexData, (j * 4) + 0) + 1; index1 = vertexCount + BitConverter.ToUInt32(mesh.IndexData, (j * 4) + 4) + 1; index2 = vertexCount + BitConverter.ToUInt32(mesh.IndexData, (j * 4) + 8) + 1; break; default: index0 = 0; index1 = 0; index2 = 0; break; } if (options.Normals && options.TextureCoordinates) { streamWriter.WriteLine("f " + index2 + "/" + index2 + "/" + index2 + " " + index1 + "/" + index1 + "/" + index1 + " " + index0 + "/" + index0 + "/" + index0); } else if (options.Normals) { streamWriter.WriteLine("f " + index2 + "//" + index2 + " " + index1 + "//" + index1 + " " + index0 + "//" + index0); } else if (options.TextureCoordinates) { streamWriter.WriteLine("f " + index2 + "/" + index2 + " " + index1 + "/" + index1 + " " + index0 + "/" + index0); } else { streamWriter.WriteLine("f " + index2 + " " + index1 + " " + index0); } } vertexCount += (UInt32)mesh.VertexCount; } streamWriter.Close(); }
protected void SetFromStream(Stream stream) { // try loading using standard .net first try { // We need to copy the stream over to a new, in-memory bitmap to // avoid keeping the input stream open. // See http://support.microsoft.com/kb/814675/en-us using(var img = Image.FromStream(stream)) { _image = new Bitmap(img.Width, img.Height, PixelFormat.Format32bppArgb); using (var gfx = Graphics.FromImage(_image)) { gfx.DrawImage(img, 0, 0, img.Width, img.Height); } _result = LoadResult.Good; } } catch (Exception) { // if this fails, load using DevIL using (var imp = new DevIL.ImageImporter()) { try { using(var devilImage = imp.LoadImageFromStream(stream)) { devilImage.Bind(); var info = DevIL.Unmanaged.IL.GetImageInfo(); var bitmap = new Bitmap(info.Width, info.Height, PixelFormat.Format32bppArgb); var rect = new Rectangle(0, 0, info.Width, info.Height); var data = bitmap.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); DevIL.Unmanaged.IL.CopyPixels(0, 0, 0, info.Width, info.Height, 1, DataFormat.BGRA, DataType.UnsignedByte, data.Scan0); bitmap.UnlockBits(data); _image = bitmap; _result = LoadResult.Good; } } catch (Exception) { // TODO any other viable fall back image loaders? _result = LoadResult.UnknownFileFormat; } } } }
public bool saveImage(string fileName) { try { string txtFile = fileName.Replace(".dds", ".txt"); string txtFilepng = fileName.Replace(".dds", ".png"); try { File.Delete(fileName); } catch { } GeneralIcon[] array = currentIcons.Values.ToArray(); StringBuilder sb = new StringBuilder(); sb.AppendLine(w.ToString()); sb.AppendLine(h.ToString()); int rrow = array.Length / cols; sb.AppendLine(rrow.ToString()); sb.AppendLine(cols.ToString()); int imageWidth = w * cols; using (Bitmap img = new Bitmap(imageWidth, imageWidth, PixelFormat.Format32bppArgb)) { using (Graphics graphics = Graphics.FromImage(img)) { int x, y = 0; for (int i = 0; i < array.Length; i++) { GeneralIcon icon = array[i]; y = i / cols; x = i - y * cols; x = x * w; y = y * h; graphics.DrawImage(icon.icon, x, y); sb.AppendLine(icon.name); } } using (DevIL.ImageImporter ImImport = new DevIL.ImageImporter()) { using (MemoryStream ms = new MemoryStream()) { img.Save(ms, System.Drawing.Imaging.ImageFormat.Png); using (DevIL.Image IconImg = ImImport.LoadImageFromStream(new MemoryStream(ms.ToArray()))) { IconImg.Bind(); ImageExporter exporter = new ImageExporter(); exporter.SaveImage(IconImg, ImageType.Dds, fileName); } } } File.WriteAllText(txtFile, sb.ToString(), Encoding.GetEncoding("GBK")); } Remake(); return(true); } catch { return(false); } }
public void ExportModelToDirectoryWithExportOptions(Model model, string directory, ModelExportOptions exportOptions) { if (model == null || directory == null || exportOptions == null ) return; NumberFormatInfo numberFormatInfo = new NumberFormatInfo(); numberFormatInfo.NumberDecimalSeparator = "."; if (exportOptions.Package) { try { DirectoryInfo directoryInfo = Directory.CreateDirectory(directory + @"\" + Path.GetFileNameWithoutExtension(model.Name)); directory = directoryInfo.FullName; } catch (Exception) { } } if (exportOptions.Textures) { ImageImporter imageImporter = new ImageImporter(); ImageExporter imageExporter = new ImageExporter(); foreach(string textureString in model.TextureStrings) { MemoryStream textureMemoryStream = AssetManager.Instance.CreateAssetMemoryStreamByName(textureString); if(textureMemoryStream == null) continue; Image textureImage = imageImporter.LoadImageFromStream(textureMemoryStream); if(textureImage == null) continue; imageExporter.SaveImage(textureImage, exportOptions.TextureFormat.ImageType, directory + @"\" + Path.GetFileNameWithoutExtension(textureString) + @"." + exportOptions.TextureFormat.Extension); } } string path = string.Format(@"{0}\{1}.{2}", directory, Path.GetFileNameWithoutExtension(model.Name), Extension); FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Write); StreamWriter streamWriter = new StreamWriter(fileStream); for (int i = 0; i < model.Meshes.Length; ++i) { Mesh mesh = model.Meshes[i]; //positions List<Vector3> positions; if (mesh.GetPositions(out positions, 0)) { foreach (Vector3 position in positions) { Vector3 scaledPosition = Vector3.Multiply(position, exportOptions.Scale); streamWriter.WriteLine("v {0} {1} {2}", scaledPosition.X.ToString(numberFormatInfo), scaledPosition.Y.ToString(numberFormatInfo), scaledPosition.Z.ToString(numberFormatInfo)); } } //texture coordinates if (exportOptions.TextureCoordinates) { Vector2[] texCoords; if (mesh.GetTexCoords(out texCoords, 0)) { foreach (Vector2 texcoord in texCoords) streamWriter.WriteLine("vt {0} {1}", texcoord.X.ToString(numberFormatInfo), (-texcoord.Y).ToString(numberFormatInfo)); } } //normals if (exportOptions.Normals) { Vector3[] normals; if (mesh.GetNormals(out normals, 0)) { foreach (Vector3 normal in normals) streamWriter.WriteLine("vn {0} {1} {2}", normal.X.ToString(numberFormatInfo), normal.Y.ToString(numberFormatInfo), normal.Z.ToString(numberFormatInfo)); } } } //faces uint vertexCount = 0; for (int i = 0; i < model.Meshes.Length; ++i) { Mesh mesh = model.Meshes[i]; streamWriter.WriteLine("g Mesh{0}", i); uint[] indices; mesh.GetIndices(out indices); for (int j = 0; j < mesh.IndexCount; j += 3) { uint index0 = indices[j + 0]; uint index1 = indices[j + 1]; uint index2 = indices[j + 2]; if (exportOptions.TextureCoordinates && exportOptions.Normals) { streamWriter.WriteLine("f {0}/{0}/{0} {1}/{1}/{1} {2}/{2}/{2}", index2, index1, index0); } else if (exportOptions.Normals) { streamWriter.WriteLine("f {0}//{0} {1}//{1} {2}//{2}", index2, index1, index0); } else if (exportOptions.TextureCoordinates) { streamWriter.WriteLine("f {0}/{0} {1}/{1} {2}/{2}", index2, index1, index0); } else { streamWriter.WriteLine("f {0} {1} {2}", index2, index1, index0); } } vertexCount += (uint)mesh.VertexCount; } streamWriter.Close(); }