Head

GCC Code Coverage Report

Directory:	src/		Exec	Total	Coverage
File:	src/render/vertexes/openglgraphicsvertexes.cpp	Lines:	30	98	30.6 %
Date:	2021-03-17	Branches:	12	56	21.4 %


/*
 *  The ManaPlus Client
 *  Copyright (C) 2011-2019  The ManaPlus Developers
 *  Copyright (C) 2019-2021  Andrei Karas
 *
 *  This file is part of The ManaPlus Client.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifdef USE_OPENGL

#include "render/vertexes/openglgraphicsvertexes.h"

#include "render/graphics.h"

#include "debug.h"

unsigned int vertexBufSize = 500;

OpenGLGraphicsVertexes::OpenGLGraphicsVertexes() :
    ptr(0),
    mFloatTexArray(nullptr),
    mIntTexArray(nullptr),
    mIntVertArray(nullptr),
    mShortVertArray(nullptr),
    mVp(),
    mFloatTexPool(),
    mIntVertPool(),
    mShortVertPool(),
    mIntTexPool(),
    mVbo()
{
    mFloatTexPool.reserve(30);
    mIntVertPool.reserve(30);
    mShortVertPool.reserve(30);
    mIntTexPool.reserve(30);
    mVp.reserve(30);
    mVbo.reserve(30);
}

OpenGLGraphicsVertexes::~OpenGLGraphicsVertexes()
{
    clear();
}

void OpenGLGraphicsVertexes::clear() restrict2
{
    for (STD_VECTOR<GLfloat*>::iterator it = mFloatTexPool.begin();
        it != mFloatTexPool.end(); ++ it)
    {
        delete [] (*it);
    }
    mFloatTexPool.clear();

    for (STD_VECTOR<GLint*>::iterator it = mIntVertPool.begin();
        it != mIntVertPool.end(); ++ it)
    {
        delete [] (*it);
    }
    mIntVertPool.clear();

    for (STD_VECTOR<GLshort*>::iterator it = mShortVertPool.begin();
        it != mShortVertPool.end(); ++ it)
    {
        delete [] (*it);
    }
    mShortVertPool.clear();

    for (STD_VECTOR<GLint*>::iterator it = mIntTexPool.begin();
        it != mIntTexPool.end(); ++ it)
    {
        delete [] (*it);
    }
    mIntTexPool.clear();

    const int sz = CAST_S32(mVbo.size());
    if (sz > 0)
    {
        mainGraphics->removeArray(sz, &mVbo[0]);
        mVbo.clear();
    }

    mVp.clear();
    if (ptr != 0)
    {
        ptr = 0;
        delete []mFloatTexArray;
        mFloatTexArray = nullptr;
        delete []mIntTexArray;
        mIntTexArray = nullptr;
        delete []mIntVertArray;
        mIntVertArray = nullptr;
        delete []mShortVertArray;
        mShortVertArray = nullptr;
    }
}

void OpenGLGraphicsVertexes::init() restrict2
{
    clear();
}

GLfloat *OpenGLGraphicsVertexes::switchFloatTexArray() restrict2
{
    mFloatTexArray = new GLfloat[CAST_SIZE(vertexBufSize * 4 + 30)];
    mFloatTexPool.push_back(mFloatTexArray);
    return mFloatTexArray;
}

GLint *OpenGLGraphicsVertexes::switchIntVertArray() restrict2
{
    mIntVertArray = new GLint[CAST_SIZE(vertexBufSize * 4 + 30)];
    mIntVertPool.push_back(mIntVertArray);
    return mIntVertArray;
}

GLshort *OpenGLGraphicsVertexes::switchShortVertArray() restrict2
{
    mShortVertArray = new GLshort[CAST_SIZE(vertexBufSize * 4 + 30)];
    mShortVertPool.push_back(mShortVertArray);
    return mShortVertArray;
}

GLint *OpenGLGraphicsVertexes::switchIntTexArray() restrict2
{
    mIntTexArray = new GLint[CAST_SIZE(vertexBufSize * 4 + 30)];
    mIntTexPool.push_back(mIntTexArray);
    return mIntTexArray;
}

void OpenGLGraphicsVertexes::switchVp(const int n) restrict2
{
    mVp.push_back(n);
}

int OpenGLGraphicsVertexes::continueVp() restrict2
{
    if (mVp.empty())
    {
        return 0;
    }
    else
    {
        const int val = mVp.back();
        mVp.pop_back();
        return val;
    }
}

void OpenGLGraphicsVertexes::updateVp(const int n) restrict2
{
    if (!mVp.empty())
        mVp.pop_back();
    mVp.push_back(n);
}

GLfloat *OpenGLGraphicsVertexes::continueFloatTexArray() restrict2
{
    if (mFloatTexPool.empty())
    {
        mFloatTexArray = new GLfloat[CAST_SIZE(vertexBufSize) * 4 + 30];
        mFloatTexPool.push_back(mFloatTexArray);
    }
    else
    {
        mFloatTexArray = mFloatTexPool.back();
    }
    return mFloatTexArray;
}

GLint *OpenGLGraphicsVertexes::continueIntVertArray() restrict2
{
    if (mIntVertPool.empty())
    {
        mIntVertArray = new GLint[CAST_SIZE(vertexBufSize * 4 + 30)];
        mIntVertPool.push_back(mIntVertArray);
    }
    else
    {
        mIntVertArray = mIntVertPool.back();
    }
    return mIntVertArray;
}

GLshort *OpenGLGraphicsVertexes::continueShortVertArray() restrict2
{
    if (mShortVertPool.empty())
    {
        mShortVertArray = new GLshort[CAST_SIZE(vertexBufSize) * 4 + 30];
        mShortVertPool.push_back(mShortVertArray);
    }
    else
    {
        mShortVertArray = mShortVertPool.back();
    }
    return mShortVertArray;
}

GLint *OpenGLGraphicsVertexes::continueIntTexArray() restrict2
{
    if (mIntTexPool.empty())
    {
        mIntTexArray = new GLint[CAST_SIZE(vertexBufSize * 4 + 30)];
        mIntTexPool.push_back(mIntTexArray);
    }
    else
    {
        mIntTexArray = mIntTexPool.back();
    }
    return mIntTexArray;
}
#endif  // USE_OPENGL


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/*
2			* The ManaPlus Client
3			* Copyright (C) 2011-2019 The ManaPlus Developers
4			* Copyright (C) 2019-2021 Andrei Karas
5			*
6			* This file is part of The ManaPlus Client.
7			*
8			* This program is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation; either version 2 of the License, or
11			* any later version.
12			*
13			* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with this program. If not, see <http://www.gnu.org/licenses/>.
20			*/
21
22			#ifdef USE_OPENGL
23
24			#include "render/vertexes/openglgraphicsvertexes.h"
25
26			#include "render/graphics.h"
27
28			#include "debug.h"
29
30			unsigned int vertexBufSize = 500;
31
32		269	OpenGLGraphicsVertexes::OpenGLGraphicsVertexes() :
33			ptr(0),
34			mFloatTexArray(nullptr),
35			mIntTexArray(nullptr),
36			mIntVertArray(nullptr),
37			mShortVertArray(nullptr),
38			mVp(),
39			mFloatTexPool(),
40			mIntVertPool(),
41			mShortVertPool(),
42			mIntTexPool(),
43		1883	mVbo()
44			{
45	✓✗	269	mFloatTexPool.reserve(30);
46	✓✗	269	mIntVertPool.reserve(30);
47	✓✗	269	mShortVertPool.reserve(30);
48	✓✗	269	mIntTexPool.reserve(30);
49	✓✗	269	mVp.reserve(30);
50	✓✗	269	mVbo.reserve(30);
51		269	}
52
53		2152	OpenGLGraphicsVertexes::~OpenGLGraphicsVertexes()
54			{
55		269	clear();
56		269	}
57
58		269	void OpenGLGraphicsVertexes::clear() restrict2
59			{
60	✗✓	807	for (STD_VECTOR<GLfloat*>::iterator it = mFloatTexPool.begin();
61		538	it != mFloatTexPool.end(); ++ it)
62			{
63			delete [] (*it);
64			}
65		538	mFloatTexPool.clear();
66
67	✗✓	807	for (STD_VECTOR<GLint*>::iterator it = mIntVertPool.begin();
68		538	it != mIntVertPool.end(); ++ it)
69			{
70			delete [] (*it);
71			}
72		538	mIntVertPool.clear();
73
74	✗✓	807	for (STD_VECTOR<GLshort*>::iterator it = mShortVertPool.begin();
75		538	it != mShortVertPool.end(); ++ it)
76			{
77			delete [] (*it);
78			}
79		538	mShortVertPool.clear();
80
81	✗✓	807	for (STD_VECTOR<GLint*>::iterator it = mIntTexPool.begin();
82		538	it != mIntTexPool.end(); ++ it)
83			{
84			delete [] (*it);
85			}
86		538	mIntTexPool.clear();
87
88		538	const int sz = CAST_S32(mVbo.size());
89	✗✓	269	if (sz > 0)
90			{
91			mainGraphics->removeArray(sz, &mVbo[0]);
92			mVbo.clear();
93			}
94
95		538	mVp.clear();
96	✗✓	269	if (ptr != 0)
97			{
98			ptr = 0;
99			delete []mFloatTexArray;
100			mFloatTexArray = nullptr;
101			delete []mIntTexArray;
102			mIntTexArray = nullptr;
103			delete []mIntVertArray;
104			mIntVertArray = nullptr;
105			delete []mShortVertArray;
106			mShortVertArray = nullptr;
107			}
108		269	}
109
110			void OpenGLGraphicsVertexes::init() restrict2
111			{
112			clear();
113			}
114
115			GLfloat *OpenGLGraphicsVertexes::switchFloatTexArray() restrict2
116			{
117			mFloatTexArray = new GLfloat[CAST_SIZE(vertexBufSize * 4 + 30)];
118			mFloatTexPool.push_back(mFloatTexArray);
119			return mFloatTexArray;
120			}
121
122			GLint *OpenGLGraphicsVertexes::switchIntVertArray() restrict2
123			{
124			mIntVertArray = new GLint[CAST_SIZE(vertexBufSize * 4 + 30)];
125			mIntVertPool.push_back(mIntVertArray);
126			return mIntVertArray;
127			}
128
129			GLshort *OpenGLGraphicsVertexes::switchShortVertArray() restrict2
130			{
131			mShortVertArray = new GLshort[CAST_SIZE(vertexBufSize * 4 + 30)];
132			mShortVertPool.push_back(mShortVertArray);
133			return mShortVertArray;
134			}
135
136			GLint *OpenGLGraphicsVertexes::switchIntTexArray() restrict2
137			{
138			mIntTexArray = new GLint[CAST_SIZE(vertexBufSize * 4 + 30)];
139			mIntTexPool.push_back(mIntTexArray);
140			return mIntTexArray;
141			}
142
143			void OpenGLGraphicsVertexes::switchVp(const int n) restrict2
144			{
145			mVp.push_back(n);
146			}
147
148			int OpenGLGraphicsVertexes::continueVp() restrict2
149			{
150			if (mVp.empty())
151			{
152			return 0;
153			}
154			else
155			{
156			const int val = mVp.back();
157			mVp.pop_back();
158			return val;
159			}
160			}
161
162			void OpenGLGraphicsVertexes::updateVp(const int n) restrict2
163			{
164			if (!mVp.empty())
165			mVp.pop_back();
166			mVp.push_back(n);
167			}
168
169			GLfloat *OpenGLGraphicsVertexes::continueFloatTexArray() restrict2
170			{
171			if (mFloatTexPool.empty())
172			{
173			mFloatTexArray = new GLfloat[CAST_SIZE(vertexBufSize) * 4 + 30];
174			mFloatTexPool.push_back(mFloatTexArray);
175			}
176			else
177			{
178			mFloatTexArray = mFloatTexPool.back();
179			}
180			return mFloatTexArray;
181			}
182
183			GLint *OpenGLGraphicsVertexes::continueIntVertArray() restrict2
184			{
185			if (mIntVertPool.empty())
186			{
187			mIntVertArray = new GLint[CAST_SIZE(vertexBufSize * 4 + 30)];
188			mIntVertPool.push_back(mIntVertArray);
189			}
190			else
191			{
192			mIntVertArray = mIntVertPool.back();
193			}
194			return mIntVertArray;
195			}
196
197			GLshort *OpenGLGraphicsVertexes::continueShortVertArray() restrict2
198			{
199			if (mShortVertPool.empty())
200			{
201			mShortVertArray = new GLshort[CAST_SIZE(vertexBufSize) * 4 + 30];
202			mShortVertPool.push_back(mShortVertArray);
203			}
204			else
205			{
206			mShortVertArray = mShortVertPool.back();
207			}
208			return mShortVertArray;
209			}
210
211			GLint *OpenGLGraphicsVertexes::continueIntTexArray() restrict2
212			{
213			if (mIntTexPool.empty())
214			{
215			mIntTexArray = new GLint[CAST_SIZE(vertexBufSize * 4 + 30)];
216			mIntTexPool.push_back(mIntTexArray);
217			}
218			else
219			{
220			mIntTexArray = mIntTexPool.back();
221			}
222			return mIntTexArray;
223			}
224			#endif // USE_OPENGL