← Back to branch summary

~thumper/nux/next-changes

« back to all changes in this revision

Viewing changes to NuxGraphics/GLResourceManager.h

  • Committer: Neil Jagdish Patel
  • Date: 2010-09-01 21:15:42 UTC
  • Revision ID: neil.patel@canonical.com-20100901211542-cw2ce3ak28unouwb
Add NuxGraphics with licensing

Show diffs side-by-side

added added

removed removed

Lines of Context:
NuxGraphics/GLResourceManager.h
 
1
/*
 
2
 * Copyright 2010 Inalogic Inc.
 
3
 *
 
4
 * This program is free software: you can redistribute it and/or modify it 
 
5
 * under the terms of the GNU Lesser General Public License version 3, as
 
6
 * published by the  Free Software Foundation.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful, but 
 
9
 * WITHOUT ANY WARRANTY; without even the implied warranties of 
 
10
 * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR 
 
11
 * PURPOSE.  See the applicable version of the GNU Lesser General Public 
 
12
 * License for more details.
 
13
 * 
 
14
 * You should have received a copy of both the GNU Lesser General Public 
 
15
 * License version 3 along with this program.  If not, see 
 
16
 * <http://www.gnu.org/licenses/>
 
17
 *
 
18
 * Authored by: Jay Taoko <jay.taoko_AT_gmail_DOT_com>
 
19
 *
 
20
 */
 
21
 
 
22
 
 
23
#ifndef GLRESOURCEMANAGER_H
 
24
#define GLRESOURCEMANAGER_H
 
25
 
 
26
NAMESPACE_BEGIN_OGL
 
27
 
 
28
// class NTexture;
 
29
// class NTexture2D;
 
30
// class NRectangleTexture;
 
31
// class NTextureCube;
 
32
// class NTextureVolume;
 
33
// class NAnimatedTexture;
 
34
// 
 
35
// class NVertexBuffer;
 
36
// class NIndexBuffer;
 
37
// 
 
38
// class NGLTexture2D;
 
39
// class NGLRectangleTexture;
 
40
// class NGLTextureCube;
 
41
// class NGLTextureVolume;
 
42
// class NGLAnimatedTexture;
 
43
 
 
44
//     NResource           NGLResource
 
45
//         |                   |
 
46
//     NTexture            NGLTexture
 
47
//         |                   |
 
48
//     NTexture2D          NGLTexture2D
 
49
// 
 
50
// 
 
51
//     NResourceFactory
 
52
//         |
 
53
//     NGLResourceFactory
 
54
//         |
 
55
//     TGLResourceFactory<class NTexture2D, class NGLTexture2D>
 
56
// 
 
57
// 
 
58
//     NResourceSet
 
59
//         |
 
60
//     TResourceCache<class IdType(int), class ResourceType(NGLResource)>
 
61
//         |
 
62
//     NResourceCache: TResourceCache<int, NGLResource>
 
63
//
 
64
//
 
65
 
 
66
//! Device independent base resource.
 
67
class NResource: public NRefCount
 
68
{
 
69
    DECLARE_ROOT_OBJECT_TYPE(NResource);
 
70
public:
 
71
    NResource();
 
72
    virtual NString GetResourceName() { return NString(TEXT("")); }
 
73
    unsigned int GetResourceIndex() const;
 
74
private:
 
75
    unsigned int m_ResourceIndex;
 
76
};
 
77
 
 
78
class NGLResource;
 
79
 
 
80
class NResourceSet
 
81
{
 
82
public:
 
83
    NResourceSet();
 
84
    virtual ~NResourceSet(){};
 
85
 
 
86
protected:
 
87
    NGLResource* FirstResource;
 
88
 
 
89
    // Flush
 
90
    virtual void Flush() {}
 
91
 
 
92
    // FreeResource - Called when a potentially cached resource has been freed.
 
93
    virtual void FreeResource(NResource* Resource) {}
 
94
 
 
95
    // FlushResource - Removes a resource from the set.
 
96
    virtual void FlushResource(NGLResource* Resource) {}
 
97
 
 
98
    friend class NGLResource;
 
99
};
 
100
 
 
101
enum EResourceUpdateHint
 
102
{
 
103
    RUH_Static,                         // The resource is updated once, at creation time.
 
104
    RUH_CacheableDynamic,       // The resource is updated occasionally, but not every frame.
 
105
    RUH_Dynamic                         // The resource changes every frame.
 
106
};
 
107
 
 
108
class NGLResource: public NRefCount
 
109
{
 
110
    DECLARE_ROOT_OBJECT_TYPE(NGLResource);
 
111
 
 
112
public:
 
113
    NGLResource(NResourceSet* InSet);
 
114
    virtual ~NGLResource();
 
115
 
 
116
   virtual NString GetSubTypeDescription() { return NString(TEXT("Resource")); }
 
117
    virtual NString GetTypeDescription() { return NString(TEXT("Resource")); }
 
118
 
 
119
    //! Returns the size in bytes of the resource.
 
120
    /*! Returns the size in bytes of the resource.
 
121
        @return Size of the resource in bytes.
 
122
    */
 
123
    virtual unsigned int GetSize() const { return Size; }
 
124
 
 
125
    //! Returns the size of the max LOD of the resource.
 
126
    /*!
 
127
        Returns the size of the max LOD of the resource. For a texture, this is the size of mipmap 0.
 
128
        Texture resource overwrite this function.
 
129
        @return Size of the resource in bytes.
 
130
    */
 
131
    virtual unsigned int GetMaxLodSize() const { return Size; }
 
132
 
 
133
    /*! 
 
134
        Updates the resource.
 
135
    */
 
136
    virtual bool UpdateResource(NResource* Resource) = 0;
 
137
 
 
138
protected:
 
139
    NResourceSet*       Set;
 
140
    bool                Cached;
 
141
    unsigned int        NumRefs;
 
142
    NString             Description;
 
143
    NObjectType*        ResourceType;
 
144
 
 
145
    unsigned int        Size;
 
146
    EResourceUpdateHint UpdateHint;
 
147
 
 
148
    NGLResource* PrevResource;
 
149
    NGLResource* NextResource;
 
150
 
 
151
    template<class IdType, class ResourceType>
 
152
    friend class TResourceCache;
 
153
    friend class NResourceCache;
 
154
};
 
155
 
 
156
 
 
157
//! Device independent resource factory.
 
158
class NResourceFactory
 
159
{
 
160
public:
 
161
    NResourceFactory(NObjectType* Type)
 
162
        :   m_ResourceType(Type)
 
163
    {}
 
164
 
 
165
      // Returns the resource type for this factory
 
166
      const NObjectType& Type() const
 
167
      { 
 
168
          return *m_ResourceType; 
 
169
      }
 
170
 
 
171
      /*! 
 
172
        Returns true if the given NResource is created by this factory.
 
173
        @param  Resource - the resource in question.
 
174
      */
 
175
      bool BuildsThisResource(NResource* Resource) 
 
176
      { 
 
177
          return Resource->Type().IsObjectType(Type());
 
178
      }
 
179
 
 
180
      virtual NGLResource*      BuildResource(NResourceSet* ResourceManager, NResource* Resource) 
 
181
      { 
 
182
          return NULL; 
 
183
      }
 
184
private:
 
185
    //! Type associated with this factory class.
 
186
    NObjectType* m_ResourceType;
 
187
};
 
188
 
 
189
template <class T, class D>
 
190
class TGLResourceFactory : public NResourceFactory
 
191
{
 
192
public: 
 
193
    /*!
 
194
        Constructor.
 
195
        @param  type - resource class type to associate w/ this factory.
 
196
    */
 
197
    TGLResourceFactory(NObjectType* Type)
 
198
        :   NResourceFactory(Type)
 
199
    {}
 
200
 
 
201
    virtual     ~TGLResourceFactory(void) 
 
202
    {}
 
203
 
 
204
    //! Create a new resource.
 
205
    /*! Create a new resource for the given NResource.
 
206
        @param  ResourceManager The resource manager.
 
207
        @param  Resource        Resource to build and cache.
 
208
        @return The built resource.
 
209
    */
 
210
    virtual NGLResource*        BuildResource(NResourceSet* ResourceManager, NResource* Resource) 
 
211
    { 
 
212
        return new D(ResourceManager, (T*)Resource); 
 
213
    }
 
214
};
 
215
 
 
216
 
 
217
//! Device independent resource updater.
 
218
class NResourceUpdater
 
219
{
 
220
public:
 
221
    NResourceUpdater(NObjectType* Type)
 
222
        :   m_ResourceType(Type)
 
223
    {}
 
224
 
 
225
    //! Returns the resource type for this factory.
 
226
    const NObjectType& Type() const 
 
227
    { 
 
228
        return *m_ResourceType; 
 
229
    }
 
230
 
 
231
    /*! 
 
232
        Returns true if the given NResource can be updated by this factory.
 
233
        @param  Resource    The resource in question.
 
234
    */
 
235
    bool UpdatesThisResource(NResource* Resource) 
 
236
    { 
 
237
        return Resource->Type().IsObjectType(Type());
 
238
    }
 
239
 
 
240
    virtual bool UpdateResource(TRefGL< NGLResource > DeviceResource, NResource* Resource) const
 
241
    { 
 
242
        return DeviceResource->UpdateResource(Resource); 
 
243
    }
 
244
 
 
245
private:
 
246
    //! Type associated with this factory class.
 
247
    NObjectType*        m_ResourceType;
 
248
};
 
249
 
 
250
template<typename IdType, typename ResourceType>
 
251
class TResourceCache: public NResourceSet
 
252
{
 
253
public:
 
254
    std::map< IdType, TRefGL< ResourceType > > ResourceMap;
 
255
    
 
256
    // Resource factory instances for each NResource/NGLResource pair.
 
257
    std::vector<NResourceFactory*> ResourceFactories;
 
258
 
 
259
    // Resource updater instances for each NResource type.
 
260
    std::vector<NResourceUpdater*> ResourceUpdaters;
 
261
 
 
262
 
 
263
    TResourceCache()
 
264
        :   NResourceSet()
 
265
    {}
 
266
 
 
267
    void Flush()
 
268
    {
 
269
        // See the language FAQ 35.18 at http://www.parashift.com/c++-faq-lite/templates.html  for why the "typename".
 
270
        typename std::map< IdType, TRefGL< ResourceType > >::iterator It;
 
271
        for(It = ResourceMap.begin(); It != ResourceMap.end(); It++)
 
272
        {
 
273
            TRefGL< ResourceType >      CachedResource = (*It).second;
 
274
            CachedResource->Cached = 0;
 
275
        }
 
276
        // Erases all elements from the map.
 
277
        ResourceMap.clear();
 
278
    }
 
279
 
 
280
    void AddCachedResource(const IdType& Id, TRefGL< ResourceType > Resource)
 
281
    {
 
282
        typedef std::map< IdType, TRefGL< ResourceType > >  MapType; 
 
283
        ResourceMap.insert(typename MapType::value_type(Id, Resource));
 
284
        Resource->Cached = 1;
 
285
    }
 
286
 
 
287
    TRefGL< ResourceType > FindCachedResourceById(const IdType& Id)
 
288
    {
 
289
        typedef std::map< IdType, TRefGL< ResourceType > >  MapType; 
 
290
        typename MapType::iterator it = ResourceMap.find(Id);
 
291
        if(it != ResourceMap.end())
 
292
            return (*it).second;
 
293
        return 0;
 
294
    }
 
295
 
 
296
    void FlushResourceId(const IdType& Id)
 
297
    {
 
298
        TRefGL< ResourceType >  CachedResource = 0;
 
299
 
 
300
        typedef std::map< IdType, TRefGL< ResourceType > >  MapType; 
 
301
        typename MapType::iterator it = ResourceMap.find(Id);
 
302
        if(it != ResourceMap.end())
 
303
            CachedResource = (*it).second;
 
304
        if(CachedResource.IsValid())
 
305
        {
 
306
            ResourceMap.erase(it);
 
307
            CachedResource->Cached = 0; // Make sure that if the following line deletes the resource, it doesn't try to remove itself from the TDynamicMap we're iterating over.
 
308
        }
 
309
    }
 
310
 
 
311
    virtual void FlushResource(NGLResource* Resource)
 
312
    {
 
313
        typedef std::map< IdType, TRefGL< ResourceType > >  MapType; 
 
314
        typename MapType::iterator it;
 
315
        for(it = ResourceMap.begin(); it != ResourceMap.end(); it++)
 
316
        {
 
317
            TRefGL< ResourceType >      CachedResource = (*it).second;
 
318
            if(CachedResource == Resource)
 
319
            {
 
320
                ResourceMap.erase(it);
 
321
                CachedResource->Cached = 0; // Make sure that if the following line deletes the resource, it doesn't try to remove itself from the TDynamicMap we're iterating over.
 
322
                return;
 
323
            }
 
324
        }
 
325
    }
 
326
 
 
327
    // Register NGLResource with the corresponding NResource 
 
328
    virtual void InitializeResourceFactories() = 0;
 
329
 
 
330
    std::vector<NResourceFactory*>&     GetResourceFactories(void) { return(ResourceFactories); }
 
331
    std::vector<NResourceUpdater*>&     GetResourceUpdaters(void) { return(ResourceUpdaters); }
 
332
};
 
333
 
 
334
class NResourceCache: public TResourceCache<int, NGLResource>
 
335
{
 
336
public:
 
337
    NResourceCache()
 
338
        :   TResourceCache<int, NGLResource>()
 
339
    {}
 
340
 
 
341
    TRefGL< NGLResource > GetCachedResource(NResource* Source);
 
342
    bool         IsCachedResource(NResource* Source);
 
343
 
 
344
    virtual void InitializeResourceFactories();
 
345
    virtual void FreeResource(NResource* Resource)
 
346
    {
 
347
        FlushResourceId(Resource->GetResourceIndex());
 
348
    }
 
349
};
 
350
 
 
351
 
 
352
////////////////////////////////////////////////////////////////////////////////////////////////////
 
353
 
 
354
NAMESPACE_END_OGL
 
355
 
 
356
#endif // GLRESOURCEMANAGER_H
 
357