coretypes/implementation/grnfileinfo.cs

using System;
using System.Collections.Generic;
using System.Text;
using gr2lib.core.helpers;
using gr2lib.core.interfaces;

namespace gr2lib.core.coretypes.implementation
{

    public class grnfileinfo : Igrnfileinfo
    {
        private string fromFileName;
        private ArtToolInfo _ArtToolInfo;
        private ExporterInfo _ExporterInfo;
        private List<Texture> _Textures;
        private List<Material> _Materials;
        private List<Skeleton> _Skeletons;


        //VertexDatas
        //TriTopologies
        //Meshes
        //Models
        //TrackGroups
        //Animations
        //ExtendedData


        private string filePath;
        private string fileName;

        public grnfileinfo(string path)
        {
            this.filePath = path;
            this.fileName = FileNameFromPath(path);
        }

        private static string FileNameFromPath(string path)
        {
            int lastSlash = path.LastIndexOf('\\');
            if (lastSlash > 0) return path.Substring(lastSlash + 1);
            lastSlash = path.LastIndexOf('/');
            if (lastSlash > 0) return path.Substring(lastSlash + 1);
            return path;
        }

        internal static grnfileinfo ReadFromMemory(IntPtr pointer, string path)
        {
            try
            {
                if (pointer == IntPtr.Zero) return null;
                native.grnfileinfo native = Helpers.ReadFromMemory<native.grnfileinfo>(pointer);
                grnfileinfo managed = new grnfileinfo(path);
                managed.NativePointer = pointer;

                if (native.ArtToolInfo != IntPtr.Zero)
                {
                    managed.ArtToolInfo = ArtToolInfo.ReadFromMemory(native.ArtToolInfo);
                }
                else
                {
                    managed.ArtToolInfo = new ArtToolInfo();
                }
                if (native.ExporterInfo != IntPtr.Zero)
                {
                    managed.ExporterInfo = ExporterInfo.ReadFromMemory(native.ExporterInfo);
                }
                else
                {
                    managed.ExporterInfo = new ExporterInfo();
                }

                managed.fromFileName = string.IsNullOrEmpty(native.FromFileName) ? "{null}" : native.FromFileName;
                managed.ExtendedData = native.ExtendedData;

                int length = 0;
                if (native.Textures.Pointer != IntPtr.Zero)
                {

                    IntPtr[] textures = Helpers.ReadArrayFromMemory(native.Textures);
                    length = textures.Length;
                    managed.Textures = new List<Texture>(length);
                    foreach (IntPtr ptr in textures)
                    {
                        Texture _tmp = new Texture();
                        _tmp.NativePointer = ptr;
                        managed.Textures.Add(_tmp);
                    }
                    for (int i = 0; i < length; i++)
                    {
                        managed.Textures[i] = Texture.ReadFromMemory(textures[i]);
                    }
                }
                else
                {
                    managed.Textures = new List<Texture>();
                }

                if (native.Materials.Pointer != IntPtr.Zero)
                {
                    IntPtr[] materials = Helpers.ReadArrayFromMemory(native.Materials);
                    length = materials.Length;
                    managed.Materials = new List<Material>(length);
                    foreach (IntPtr ptr in materials)
                    {
                        managed.Materials.Add(new Material());
                    }
                    for (int i = 0; i < length; i++)
                    {
                        managed.Materials[i] = Material.ReadFromMemory(materials[i]);
                    }
                }
                else
                {
                    managed.Materials = new List<Material>();
                }

                if (native.Skeletons.Pointer != IntPtr.Zero)
                {
                    IntPtr[] skeletons = Helpers.ReadArrayFromMemory(native.Skeletons);
                    length = skeletons.Length;
                    managed.Skeletons = new List<Skeleton>(length);
                    foreach (IntPtr ptr in skeletons)
                    {
                        managed.Skeletons.Add(new Skeleton());
                    }
                    for (int i = 0; i < length; i++)
                    {
                        managed.Skeletons[i] = (Skeleton.ReadFromMemory(skeletons[i]));
                    }
                }
                else
                {
                    managed.Skeletons = new List<Skeleton>();
                }

                return managed;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                return default(grnfileinfo);
            }
        }
        public static grnfileinfo ReadFromFile(string fileName)
        {
            IntPtr file = coreapi.GrannyReadEntireFile(fileName);

            if (file == null || file == IntPtr.Zero)
            {
                Console.WriteLine("Error: unable to load {0} as a Granny file.", fileName);
            }
            grnfileinfo info = null;

            try
            {
                IntPtr pinfo = coreapi.GetFileInfo(file);
                info = ReadFromMemory(pinfo, fileName);
                coreapi.FreeFile(file);

                return info;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                return default(grnfileinfo);
            }
        }


        #region Igrnfileinfo Members
        public ArtToolInfo ArtToolInfo { get { return _ArtToolInfo; } set { _ArtToolInfo = value; } }
        public ExporterInfo ExporterInfo { get { return _ExporterInfo; } set { _ExporterInfo = value; } }
        public string FromFileName { get { return fromFileName; } set { fromFileName = value; } }
        public List<Texture> Textures { get { return _Textures; } set { _Textures = value; } }
        public List<Material> Materials { get { return _Materials; } set { _Materials = value; } }
        public List<Skeleton> Skeletons { get { return _Skeletons; } set { _Skeletons = value; } }
        #endregion

        #region INativePointer Members
        private IntPtr _NativePointer;
        public IntPtr NativePointer { get { return _NativePointer; } set { _NativePointer = value; } }
        #endregion

        #region IExtendedData Members
        private IntPtr _ExtendedData;
        public IntPtr ExtendedData { get { return _ExtendedData; } set { _ExtendedData = value; } }
        #endregion
    }
}
Revision:	87
Committed:	Fri Jul 16 23:37:52 2010 UTC (12 years, 8 months ago) by william
File size:	6971 byte(s)
Log Message:	return default(grnfileinfo); in Try/Catch block Add another Try/Catch block
#	Content
1	using System;
2	using System.Collections.Generic;
3	using System.Text;
4	using gr2lib.core.helpers;
5	using gr2lib.core.interfaces;
6
7	namespace gr2lib.core.coretypes.implementation
8	{
9
10	public class grnfileinfo : Igrnfileinfo
11	{
12	private string fromFileName;
13	private ArtToolInfo _ArtToolInfo;
14	private ExporterInfo _ExporterInfo;
15	private List<Texture> _Textures;
16	private List<Material> _Materials;
17	private List<Skeleton> _Skeletons;
18
19
20	//VertexDatas
21	//TriTopologies
22	//Meshes
23	//Models
24	//TrackGroups
25	//Animations
26	//ExtendedData
27
28
29
30	private string filePath;
31	private string fileName;
32
33	public grnfileinfo(string path)
34	{
35	this.filePath = path;
36	this.fileName = FileNameFromPath(path);
37	}
38
39	private static string FileNameFromPath(string path)
40	{
41	int lastSlash = path.LastIndexOf('\\');
42	if (lastSlash > 0) return path.Substring(lastSlash + 1);
43	lastSlash = path.LastIndexOf('/');
44	if (lastSlash > 0) return path.Substring(lastSlash + 1);
45	return path;
46	}
47
48	internal static grnfileinfo ReadFromMemory(IntPtr pointer, string path)
49	{
50	try
51	{
52	if (pointer == IntPtr.Zero) return null;
53	native.grnfileinfo native = Helpers.ReadFromMemory<native.grnfileinfo>(pointer);
54	grnfileinfo managed = new grnfileinfo(path);
55	managed.NativePointer = pointer;
56
57	if (native.ArtToolInfo != IntPtr.Zero)
58	{
59	managed.ArtToolInfo = ArtToolInfo.ReadFromMemory(native.ArtToolInfo);
60	}
61	else
62	{
63	managed.ArtToolInfo = new ArtToolInfo();
64	}
65	if (native.ExporterInfo != IntPtr.Zero)
66	{
67	managed.ExporterInfo = ExporterInfo.ReadFromMemory(native.ExporterInfo);
68	}
69	else
70	{
71	managed.ExporterInfo = new ExporterInfo();
72	}
73
74	managed.fromFileName = string.IsNullOrEmpty(native.FromFileName) ? "{null}" : native.FromFileName;
75	managed.ExtendedData = native.ExtendedData;
76
77	int length = 0;
78	if (native.Textures.Pointer != IntPtr.Zero)
79	{
80
81	IntPtr[] textures = Helpers.ReadArrayFromMemory(native.Textures);
82	length = textures.Length;
83	managed.Textures = new List<Texture>(length);
84	foreach (IntPtr ptr in textures)
85	{
86	Texture _tmp = new Texture();
87	_tmp.NativePointer = ptr;
88	managed.Textures.Add(_tmp);
89	}
90	for (int i = 0; i < length; i++)
91	{
92	managed.Textures[i] = Texture.ReadFromMemory(textures[i]);
93	}
94	}
95	else
96	{
97	managed.Textures = new List<Texture>();
98	}
99
100	if (native.Materials.Pointer != IntPtr.Zero)
101	{
102	IntPtr[] materials = Helpers.ReadArrayFromMemory(native.Materials);
103	length = materials.Length;
104	managed.Materials = new List<Material>(length);
105	foreach (IntPtr ptr in materials)
106	{
107	managed.Materials.Add(new Material());
108	}
109	for (int i = 0; i < length; i++)
110	{
111	managed.Materials[i] = Material.ReadFromMemory(materials[i]);
112	}
113	}
114	else
115	{
116	managed.Materials = new List<Material>();
117	}
118
119	if (native.Skeletons.Pointer != IntPtr.Zero)
120	{
121	IntPtr[] skeletons = Helpers.ReadArrayFromMemory(native.Skeletons);
122	length = skeletons.Length;
123	managed.Skeletons = new List<Skeleton>(length);
124	foreach (IntPtr ptr in skeletons)
125	{
126	managed.Skeletons.Add(new Skeleton());
127	}
128	for (int i = 0; i < length; i++)
129	{
130	managed.Skeletons[i] = (Skeleton.ReadFromMemory(skeletons[i]));
131	}
132	}
133	else
134	{
135	managed.Skeletons = new List<Skeleton>();
136	}
137
138	return managed;
139	}
140	catch (Exception ex)
141	{
142	Console.WriteLine(ex.ToString());
143	return default(grnfileinfo);
144	}
145	}
146	public static grnfileinfo ReadFromFile(string fileName)
147	{
148	IntPtr file = coreapi.GrannyReadEntireFile(fileName);
149
150	if (file == null \|\| file == IntPtr.Zero)
151	{
152	Console.WriteLine("Error: unable to load {0} as a Granny file.", fileName);
153	}
154	grnfileinfo info = null;
155
156	try
157	{
158	IntPtr pinfo = coreapi.GetFileInfo(file);
159	info = ReadFromMemory(pinfo, fileName);
160	coreapi.FreeFile(file);
161
162	return info;
163	}
164	catch (Exception ex)
165	{
166	Console.WriteLine(ex.ToString());
167	return default(grnfileinfo);
168	}
169	}
170
171
172	#region Igrnfileinfo Members
173	public ArtToolInfo ArtToolInfo { get { return _ArtToolInfo; } set { _ArtToolInfo = value; } }
174	public ExporterInfo ExporterInfo { get { return _ExporterInfo; } set { _ExporterInfo = value; } }
175	public string FromFileName { get { return fromFileName; } set { fromFileName = value; } }
176	public List<Texture> Textures { get { return _Textures; } set { _Textures = value; } }
177	public List<Material> Materials { get { return _Materials; } set { _Materials = value; } }
178	public List<Skeleton> Skeletons { get { return _Skeletons; } set { _Skeletons = value; } }
179	#endregion
180
181	#region INativePointer Members
182	private IntPtr _NativePointer;
183	public IntPtr NativePointer { get { return _NativePointer; } set { _NativePointer = value; } }
184	#endregion
185
186	#region IExtendedData Members
187	private IntPtr _ExtendedData;
188	public IntPtr ExtendedData { get { return _ExtendedData; } set { _ExtendedData = value; } }
189	#endregion
190	}
191	}