← Back to branch summary

~thumper/nux/next-changes

« back to all changes in this revision

Viewing changes to NuxGraphics/RunTimeStats.cpp

  • 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/RunTimeStats.cpp
 
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
#include "GLResource.h"
 
24
#include "IOpenGLResource.h"
 
25
#include "IOpenGLBaseTexture.h"
 
26
#include "IOpenGLIndexBuffer.h"
 
27
#include "IOpenGLVertexBuffer.h"
 
28
#include "RunTimeStats.h"
 
29
 
 
30
 
 
31
NAMESPACE_BEGIN_OGL
 
32
 
 
33
INL_IMPLEMENT_GLOBAL_OBJECT(RenderingStats);
 
34
 
 
35
t_u32 RenderingStats::m_NumTex2D = 0;
 
36
t_u32 RenderingStats::m_GPUSizeTex2D = 0;
 
37
t_u32 RenderingStats::m_NumTexRectangle = 0;
 
38
t_u32 RenderingStats::m_GPUSizeTexRectangle = 0;
 
39
t_u32 RenderingStats::m_NumTexCube = 0;
 
40
t_u32 RenderingStats::m_GPUSizeTexCube = 0;
 
41
t_u32 RenderingStats::m_NumTexVolume = 0;
 
42
t_u32 RenderingStats::m_GPUSizeTexVolume = 0;
 
43
 
 
44
t_u32 RenderingStats::m_NumTexAnimated = 0;
 
45
t_u32 RenderingStats::m_GPUSizeTexAnimated = 0;
 
46
 
 
47
t_u32 RenderingStats::m_NumPBO = 0; // Counted as Vertex Buffer
 
48
t_u32 RenderingStats::m_GPUSizePBO = 0; // Counted as Vertex Buffer
 
49
t_u32 RenderingStats::m_NumQueryObject = 0;
 
50
t_u32 RenderingStats::m_NumFrameBufferObject = 0;
 
51
t_u32 RenderingStats::m_NumVertexBuffer = 0;
 
52
t_u32 RenderingStats::m_GPUSizeVertexBuffer = 0;
 
53
t_u32 RenderingStats::m_NumIndexBuffer = 0;
 
54
t_u32 RenderingStats::m_GPUSizeIndexBuffer = 0;
 
55
t_u32 RenderingStats::m_NumVertexShader = 0;
 
56
t_u32 RenderingStats::m_NumPixelShader = 0;
 
57
t_u32 RenderingStats::m_NumShaderProgram = 0;
 
58
 
 
59
t_u32 RenderingStats::m_TotalGPUSize = 0;
 
60
 
 
61
void RenderingStats::Constructor()
 
62
{
 
63
 
 
64
}
 
65
 
 
66
void RenderingStats::Destructor()
 
67
{
 
68
    if(m_NumIndexBuffer != 0)
 
69
    {
 
70
        nuxDebugMsg(TEXT("[RenderingStats::Destructor] Some index buffers have not been released."));
 
71
    }
 
72
 
 
73
    if(m_NumTex2D != 0)
 
74
    {
 
75
        nuxDebugMsg(TEXT("[RenderingStats::Destructor] Some 2D textures have not been released."));
 
76
        std::vector<int>::iterator it;
 
77
        for(it = v.begin(); it != v.end(); it++)
 
78
        {
 
79
            nuxDebugMsg(TEXT("[RenderingStats::Destructor] Remaining 2D textures: %d."), *it);
 
80
        }
 
81
    }
 
82
 
 
83
    if(m_NumTexRectangle != 0)
 
84
    {
 
85
        nuxDebugMsg(TEXT("[RenderingStats::Destructor] Some rectangle textures buffers have not been released."));
 
86
    }
 
87
}
 
88
 
 
89
void RenderingStats::Register(IOpenGLResource* GraphicsObject)
 
90
{
 
91
    switch (GraphicsObject->GetResourceType())
 
92
    {
 
93
    case RTINDEXBUFFER:
 
94
        {
 
95
            m_NumIndexBuffer++;
 
96
            m_GPUSizeIndexBuffer += INL_REINTERPRET_CAST(IOpenGLIndexBuffer*, GraphicsObject)->GetSize();
 
97
            m_TotalGPUSize += m_GPUSizeIndexBuffer;
 
98
            break;
 
99
        }
 
100
    case RTVERTEXBUFFER:
 
101
        {
 
102
            m_NumVertexBuffer++;
 
103
            m_GPUSizeVertexBuffer += INL_REINTERPRET_CAST(IOpenGLVertexBuffer*, GraphicsObject)->GetSize();
 
104
            m_TotalGPUSize += m_GPUSizeVertexBuffer;
 
105
            break;
 
106
        }
 
107
    case RTTEXTURE:
 
108
        {
 
109
            v.push_back(INL_STATIC_CAST(IOpenGLBaseTexture*, GraphicsObject)->GetOpenGLID());
 
110
            m_NumTex2D++;
 
111
            m_GPUSizeTex2D += GetTextureSize(INL_REINTERPRET_CAST(IOpenGLBaseTexture*, GraphicsObject));
 
112
            m_TotalGPUSize += m_GPUSizeTex2D;
 
113
            break;
 
114
        }
 
115
    case RTTEXTURERECTANGLE:
 
116
        {
 
117
            m_NumTexRectangle++;
 
118
            m_GPUSizeTexRectangle += GetTextureSize(INL_REINTERPRET_CAST(IOpenGLBaseTexture*, GraphicsObject));
 
119
            m_TotalGPUSize += m_GPUSizeTexRectangle;
 
120
            break;
 
121
        }
 
122
    case RTCUBETEXTURE:
 
123
        {
 
124
            m_NumTexCube++;
 
125
            m_GPUSizeTexCube += GetTextureSize(INL_STATIC_CAST(IOpenGLBaseTexture*, GraphicsObject));
 
126
            m_TotalGPUSize += m_GPUSizeTexCube;
 
127
            break;
 
128
        }
 
129
    case RTVOLUMETEXTURE:
 
130
        {
 
131
            m_NumTexVolume++;
 
132
            m_GPUSizeTexVolume += GetTextureSize(INL_STATIC_CAST(IOpenGLBaseTexture*, GraphicsObject));
 
133
            m_TotalGPUSize += m_GPUSizeTexVolume;
 
134
            break;
 
135
        }
 
136
    case RTANIMATEDTEXTURE:
 
137
        {
 
138
            // Animated texture size is compted as rectangle textures;
 
139
            m_NumTexAnimated++;
 
140
            break;
 
141
        }
 
142
    case RTQUERY:
 
143
        {
 
144
            m_NumQueryObject++;
 
145
            break;
 
146
        }
 
147
    case RTFRAMEBUFFEROBJECT:
 
148
        {
 
149
            m_NumFrameBufferObject++;
 
150
            break;
 
151
        }
 
152
    }
 
153
}
 
154
void RenderingStats::UnRegister(IOpenGLResource* GraphicsObject)
 
155
{
 
156
    switch (GraphicsObject->GetResourceType())
 
157
    {
 
158
    case RTINDEXBUFFER:
 
159
        {
 
160
            m_NumIndexBuffer--;
 
161
            m_GPUSizeIndexBuffer -= INL_REINTERPRET_CAST(IOpenGLIndexBuffer*, GraphicsObject)->GetSize();
 
162
            m_TotalGPUSize -= m_GPUSizeIndexBuffer;
 
163
            break;
 
164
        }
 
165
    case RTVERTEXBUFFER:
 
166
        {
 
167
            m_NumVertexBuffer--;
 
168
            m_GPUSizeVertexBuffer -= INL_REINTERPRET_CAST(IOpenGLVertexBuffer*, GraphicsObject)->GetSize();
 
169
            m_TotalGPUSize -= m_GPUSizeVertexBuffer;
 
170
            break;
 
171
        }
 
172
    case RTTEXTURE:
 
173
        {
 
174
            std::vector<int>::iterator it;
 
175
            it = std::find(v.begin(), v.end(), INL_STATIC_CAST(IOpenGLBaseTexture*, GraphicsObject)->GetOpenGLID());
 
176
            if(it != v.end())
 
177
                v.erase(it);
 
178
            m_NumTex2D--;
 
179
            m_GPUSizeTex2D -= GetTextureSize(INL_REINTERPRET_CAST(IOpenGLBaseTexture*, GraphicsObject));
 
180
            m_TotalGPUSize -= m_GPUSizeTex2D;
 
181
            break;
 
182
        }
 
183
    case RTTEXTURERECTANGLE:
 
184
        {
 
185
            m_NumTexRectangle--;
 
186
            m_GPUSizeTexRectangle -= GetTextureSize(INL_REINTERPRET_CAST(IOpenGLBaseTexture*, GraphicsObject));
 
187
            m_TotalGPUSize -= m_GPUSizeTexRectangle;
 
188
            break;
 
189
        }
 
190
    case RTCUBETEXTURE:
 
191
        {
 
192
            m_NumTexCube--;
 
193
            m_GPUSizeTexCube -= GetTextureSize(INL_STATIC_CAST(IOpenGLBaseTexture*, GraphicsObject));
 
194
            m_TotalGPUSize -= m_GPUSizeTexCube;
 
195
            break;
 
196
        }
 
197
    case RTVOLUMETEXTURE:
 
198
        {
 
199
            m_NumTexVolume--;
 
200
            m_GPUSizeTexVolume -= GetTextureSize(INL_STATIC_CAST(IOpenGLBaseTexture*, GraphicsObject));
 
201
            m_TotalGPUSize -= m_GPUSizeTexVolume;
 
202
            break;
 
203
        }
 
204
    case RTANIMATEDTEXTURE:
 
205
        {
 
206
            // Animated texture size is compted as rectangle textures;
 
207
            m_NumTexAnimated--;
 
208
            break;
 
209
        }
 
210
    case RTQUERY:
 
211
        {
 
212
            m_NumQueryObject--;
 
213
            break;
 
214
        }
 
215
    case RTFRAMEBUFFEROBJECT:
 
216
        {
 
217
            m_NumFrameBufferObject--;
 
218
            break;
 
219
        }
 
220
    }
 
221
}
 
222
 
 
223
NAMESPACE_END_OGL