Fichier source en cours : FW - Buffers.h

Voici le code source cpp :

001    #ifndef BUFFER_H
002#define BUFFER_H
003 
004namespace fw
005{
006    class Buffer
007    {
008    public: 
009        friend class GameResourcesManager;
010 
011        enum Type
012        {
013            File,
014            GPU,
015            Network,
016            Zip
017        };
018 
019        Buffer(Type type) :
020            m_pBuffer(nullptr),
021            m_iSize(0),
022            m_sName(NONE),
023            m_bEmpty(true),
024            m_type(type),
025            m_bDone(false)
026        {
027        }
028 
029        Buffer(Type type, char* pData) :
030            Buffer(type)
031        {
032            if (pData != nullptr)
033            {
034                m_pBuffer = pData;
035            }
036        }
037 
038        virtual ~Buffer()
039        {
040            if (m_bDone)
041            {
042                SAFE_DELETE(m_pBuffer);
043            }
044        }
045 
046        void Delete()
047        {
048            SAFE_DELETE(m_pBuffer);
049 
050            SetEmpty(true);
051        }
052 
053        bool IsDeleted()
054        {
055            return m_pBuffer == nullptr;
056        }
057 
058        void SetName(const std::string& sName)
059        {
060            m_sName = sName;
061        }
062 
063        char* GetBuffer()
064        {
065            return m_pBuffer;
066        }
067 
068        const char* GetBuffer() const
069        {
070            return m_pBuffer;
071        }
072 
073        fw::size_t32 GetSize()
074        {
075            return m_iSize;
076        }
077 
078        void SetSize(fw::size_t32 iSize)
079        {
080            m_iSize = iSize;
081        }
082 
083        std::string GetName() const
084        {
085            return m_sName;
086        }
087 
088        bool operator== (const Buffer& f) const
089        {
090            bool resultat = (f.GetBuffer() == GetBuffer()) && (f.GetName() == GetName());
091 
092            return resultat;
093        }
094 
095        bool IsEmpty() const
096        {
097            return m_bEmpty;
098        }
099 
100        void Done()
101        {
102            m_bDone = true;
103        }
104 
105    protected:
106        char** AccessBuffer()
107        {
108            SetEmpty(false);
109 
110            return &m_pBuffer;
111        }
112 
113        void SetBuffer(char* pBuffer)
114        {
115            m_pBuffer = pBuffer;
116                     
117            if (pBuffer != nullptr)
118            {
119                SetEmpty(false);
120            }
121        }
122 
123        Buffer& Get()
124        {
125            return *this;
126        }
127 
128    private:
129        void SetEmpty(bool bEmpty)
130        {
131            m_bEmpty = bEmpty;
132        }
133 
134    private:
135        char* m_pBuffer;
136        fw::size_t32 m_iSize;
137        std::string m_sName;
138        bool m_bEmpty;
139        Type m_type;
140        bool m_bDone;
141    };
142 
143    class ChunkedBuffer : public Buffer
144    {
145    public:
146        ChunkedBuffer(Type type) :
147            Buffer(type)
148        {
149        }
150 
151        ChunkedBuffer(Type type, char* pData) :
152            Buffer(type, pData)
153        {
154        }
155 
156        size_t32 GetChunkSize() const
157        {
158            return m_iChunkSize;
159        }
160 
161 
162        size_t32 GetElementsCount() const
163        {
164            return m_iElementsCount;
165        }
166 
167    protected:
168        void SetElementsCount(size_t32 iElementsCount)
169        {
170            m_iElementsCount = iElementsCount;
171        }
172 
173        void SetChunkSize(size_t32 iChunkSize)
174        {
175            m_iChunkSize = iChunkSize;
176        }
177 
178    private:
179        size_t32 m_iChunkSize = 0;
180        size_t32 m_iElementsCount = 0;
181    };
182 
183    class FileBuffer : public Buffer
184    {
185    public:
186        friend class FileSystemManager;
187 
188        FileBuffer() :
189            Buffer(Buffer::Type::File)
190        {
191        }
192 
193        FileBuffer& Get()
194        {
195            return *this;
196        }
197    };
198 
199    class CursorFileBuffer : public FileBuffer
200    {
201    public:
202        friend class GameResourcesManager;
203 
204        CursorFileBuffer()
205        {
206            m_iImageWidth = 0;
207            m_iImageHeight = 0;
208        }
209 
210        virtual ~CursorFileBuffer()
211        {
212        }
213 
214        size_t GetCursorWidth()
215        {
216            return m_iImageWidth;
217        }
218 
219        size_t GetCursorHeight()
220        {
221            return m_iImageHeight;
222        }
223 
224        CursorFileBuffer& Get()
225        {
226            return *this;
227        }
228 
229    private:
230        size_t32 m_iImageWidth;
231        size_t32 m_iImageHeight;
232    };
233 
234    class TextureFileBuffer : public FileBuffer
235    {
236    public:
237        friend class GameResourcesManager;
238 
239        TextureFileBuffer()
240        {
241        }
242 
243        TextureFileBuffer& Get()
244        {
245            return *this;
246        }
247         
248    private:
249        size_t32 m_iImageWidth;
250        size_t32 m_iImageHeight;
251    };
252 
253    class ShaderFileBuffer : public FileBuffer
254    {
255    public:
256        friend class GameResourcesManager;
257        friend class D3DIncludeHandlerZIP;
258 
259        ShaderFileBuffer()
260        {
261        }
262 
263        ShaderFileBuffer& Get()
264        {
265            return *this;
266        }
267    };
268 
269    class MeshFileBuffer : public FileBuffer
270    {
271    public:
272        friend class GameResourcesManager;
273 
274        MeshFileBuffer()
275        {
276        }
277 
278        MeshFileBuffer& Get()
279        {
280            return *this;
281        }
282    };
283}
284 
285#endif
286    