1 /*---------------------------------------------------------------------------*
2   Project:  Horizon
3   File:     Loader.cpp
4 
5   Copyright (C)2009-2012 Nintendo Co., Ltd.  All rights reserved.
6 
7   These coded instructions, statements, and computer programs contain
8   proprietary information of Nintendo of America Inc. and/or Nintendo
9   Company Ltd., and are protected by Federal copyright law.  They may
10   not be disclosed to third parties or copied or duplicated in any form,
11   in whole or in part, without the prior written consent of Nintendo.
12 
13   $Rev: 46365 $
14  *---------------------------------------------------------------------------*/
15 
16 /*
17  *------------------------------------------------------------
18  * Copyright(c) 2009-2010 by Digital Media Professionals Inc.
19  * All rights reserved.
20  *------------------------------------------------------------
21  * This source code is the confidential and proprietary
22  * of Digital Media Professionals Inc.
23  *------------------------------------------------------------
24  */
25 
26 #include <GLES2/gl2.h>
27 #include <GLES2/gl2ext.h>
28 #include <nn/fs.h>
29 
30 #include <string.h>
31 #include <cstdlib>
32 
33 #include "Loader.h"
34 #include "Memory.h"
35 
36 #include <nn/dbg.h>
37 
loadDAT(const char * _name,dat_t * _dat)38 void loadDAT(const char* _name, dat_t* _dat)
39 {
40     if (!_name || !_dat)
41         return;
42 
43     char* fname = 0;
44     wchar_t* wfname = 0;
45     unsigned char* dat = 0;
46     long long int filesize;
47     nn::fs::FileReader file;
48     do
49     {
50         fname = (char*)malloc(strlen(_name) + 1);
51         if (!fname)
52             break;
53 
54         int dotpos = 0;
55         strcpy(fname, _name);
56         for (int i = (int)strlen(fname) - 1; i >= 0; i--)
57         {
58             if (fname[i] == '.')
59             {
60                 dotpos = i;
61                 break;
62             }
63         }
64         if (strncmp(&fname[dotpos + 1], "dat", 3) != 0)
65             break;
66 
67         wfname = static_cast<wchar_t*>(malloc( (strlen(fname)+1)*2 ));
68         if (!wfname)
69             break;
70         (void)std::mbstowcs( wfname, fname, strlen(fname)+1 );
71         file.Initialize(wfname);
72         filesize = file.GetSize();
73         dat = static_cast<unsigned char*>(malloc(filesize));
74         if (!dat)
75             break;
76         filesize = file.Read(dat, filesize);
77 
78         dat_header_t* header = (dat_header_t*)dat;
79         dat_obj_t* obj = (dat_obj_t*)&dat[sizeof(dat_header_t)];
80         dat_patch_t* patch = (dat_patch_t*)&dat[sizeof(dat_header_t) + sizeof(dat_obj_t) * header->obj_num];
81 
82         nn::fs::FileReader attribfile;
83         unsigned char* attribdata = 0;
84         memset(_dat, 0, sizeof(dat_t));
85 
86         if (header->vtx_size)
87         {
88             memcpy(&fname[dotpos + 1], "vtx", 3);
89             (void)std::mbstowcs( wfname, fname, strlen(fname)+1 );
90             attribfile.Initialize(wfname);
91             filesize = attribfile.GetSize();
92             attribdata = static_cast<unsigned char*>(malloc(filesize));
93             if (!attribdata)
94                 break;
95             (void)attribfile.Read(attribdata, filesize);
96             glGenBuffers(1, &_dat->posVB);
97             glBindBuffer(GL_ARRAY_BUFFER, _dat->posVB);
98             glBufferData(GL_ARRAY_BUFFER, header->vtx_size, attribdata, GL_STATIC_DRAW);
99             free(attribdata);
100             attribfile.Finalize();
101         }
102         if (header->nrm_size)
103         {
104             memcpy(&fname[dotpos + 1], "nrm", 3);
105             (void)std::mbstowcs( wfname, fname, strlen(fname)+1 );
106             attribfile.Initialize(wfname);
107             filesize = attribfile.GetSize();
108             attribdata = static_cast<unsigned char*>(malloc(filesize));
109             if (!attribdata)
110                 break;
111             (void)attribfile.Read(attribdata, filesize);
112             glGenBuffers(1, &_dat->normVB);
113             glBindBuffer(GL_ARRAY_BUFFER, _dat->normVB);
114             glBufferData(GL_ARRAY_BUFFER, header->nrm_size, attribdata, GL_STATIC_DRAW);
115             free(attribdata);
116             attribfile.Finalize();
117         }
118         if (header->tex_size)
119         {
120             memcpy(&fname[dotpos + 1], "tex", 3);
121             (void)std::mbstowcs( wfname, fname, strlen(fname)+1 );
122             attribfile.Initialize(wfname);
123             filesize = attribfile.GetSize();
124             attribdata = static_cast<unsigned char*>(malloc(filesize));
125             if (!attribdata)
126                 break;
127             (void)attribfile.Read(attribdata, filesize);
128             glGenBuffers(1, &_dat->texVB);
129             glBindBuffer(GL_ARRAY_BUFFER, _dat->texVB);
130             glBufferData(GL_ARRAY_BUFFER, header->tex_size, attribdata, GL_STATIC_DRAW);
131             free(attribdata);
132             attribfile.Finalize();
133         }
134         if (header->tgt_size)
135         {
136             memcpy(&fname[dotpos + 1], "tgt", 3);
137             (void)std::mbstowcs( wfname, fname, strlen(fname)+1 );
138             attribfile.Initialize(wfname);
139             filesize = attribfile.GetSize();
140             attribdata = static_cast<unsigned char*>(malloc(filesize));
141             if (!attribdata)
142                 break;
143             (void)attribfile.Read(attribdata, filesize);
144             glGenBuffers(1, &_dat->tangVB);
145             glBindBuffer(GL_ARRAY_BUFFER, _dat->tangVB);
146             glBufferData(GL_ARRAY_BUFFER, header->tgt_size, attribdata, GL_STATIC_DRAW);
147             free(attribdata);
148             attribfile.Finalize();
149         }
150         if (header->wgt_size)
151         {
152             memcpy(&fname[dotpos + 1], "wgt", 3);
153             (void)std::mbstowcs( wfname, fname, strlen(fname)+1 );
154             attribfile.Initialize(wfname);
155             filesize = attribfile.GetSize();
156             attribdata = static_cast<unsigned char*>(malloc(filesize));
157             if (!attribdata)
158                 break;
159             (void)attribfile.Read(attribdata, filesize);
160             glGenBuffers(1, &_dat->wghtVB);
161             glBindBuffer(GL_ARRAY_BUFFER, _dat->wghtVB);
162             glBufferData(GL_ARRAY_BUFFER, header->wgt_size, attribdata, GL_STATIC_DRAW);
163             free(attribdata);
164             attribfile.Finalize();
165         }
166         if (header->idx_size)
167         {
168             memcpy(&fname[dotpos + 1], "idx", 3);
169             (void)std::mbstowcs( wfname, fname, strlen(fname)+1 );
170             attribfile.Initialize(wfname);
171             filesize = attribfile.GetSize();
172             attribdata = static_cast<unsigned char*>(malloc(filesize));
173             if (!attribdata)
174                 break;
175             (void)attribfile.Read(attribdata, filesize);
176             glGenBuffers(1, &_dat->midxVB);
177             glBindBuffer(GL_ARRAY_BUFFER, _dat->midxVB);
178             glBufferData(GL_ARRAY_BUFFER, header->idx_size, attribdata, GL_STATIC_DRAW);
179             free(attribdata);
180             attribfile.Finalize();
181         }
182         if (header->elm_size)
183         {
184             memcpy(&fname[dotpos + 1], "elm", 3);
185             (void)std::mbstowcs( wfname, fname, strlen(fname)+1 );
186             attribfile.Initialize(wfname);
187             filesize = attribfile.GetSize();
188             attribdata = static_cast<unsigned char*>(malloc(filesize));
189             if (!attribdata)
190                 break;
191             (void)attribfile.Read(attribdata, filesize);
192             glGenBuffers(1, &_dat->idxVB);
193             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _dat->idxVB);
194             glBufferData(GL_ELEMENT_ARRAY_BUFFER, header->elm_size, attribdata, GL_STATIC_DRAW);
195             free(attribdata);
196             attribfile.Finalize();
197         }
198 
199         _dat->obj = (dat_obj_t*)malloc(sizeof(dat_obj_t) * header->obj_num);
200         _dat->patch = (dat_patch_t*)malloc(sizeof(dat_patch_t) * header->patch_num);
201         if (!_dat->obj || !_dat->patch)
202         {
203             if (_dat->obj)
204                 free(_dat->obj);
205             if (_dat->patch)
206                 free(_dat->patch);
207             break;
208         }
209         memcpy(_dat->obj, obj, sizeof(dat_obj_t) * header->obj_num);
210         memcpy(_dat->patch, patch, sizeof(dat_patch_t) * header->patch_num);
211         _dat->obj_num = header->obj_num;
212     } while (0);
213 
214     if (fname)
215         free(fname);
216     if (wfname)
217         free(wfname);
218     if (dat)
219         free(dat);
220     file.Finalize();
221 
222     return;
223 }
224 
unloadDAT(dat_t * dat)225 void unloadDAT(dat_t* dat)
226 {
227     if (dat)
228     {
229         if (dat->posVB)
230             glDeleteBuffers(1, &dat->posVB);
231         if (dat->normVB)
232             glDeleteBuffers(1, &dat->normVB);
233         if (dat->texVB)
234             glDeleteBuffers(1, &dat->texVB);
235         if (dat->tangVB)
236             glDeleteBuffers(1, &dat->tangVB);
237         if (dat->wghtVB)
238             glDeleteBuffers(1, &dat->wghtVB);
239         if (dat->midxVB)
240             glDeleteBuffers(1, &dat->midxVB);
241         if (dat->idxVB)
242             glDeleteBuffers(1, &dat->idxVB);
243         if (dat->obj)
244             free(dat->obj);
245         if (dat->patch)
246             free(dat->patch);
247     }
248 
249     return;
250 }
251 
252 
253