//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, AssignmentOperator)
{
FloatArray a0;
FloatArray a1;
a1.resize(2);
a1[0] = 10;
a1[1] = 11;
{
FloatArray a;
a = a0;
ASSERT_EQ(0u, a.size());
}
{
FloatArray a;
a = a1;
ASSERT_EQ(2u, a.size());
ASSERT_EQ(10, a[0]);
ASSERT_EQ(11, a[1]);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, SetSizeZero)
{
FloatArray a;
a.reserve(3);
a.add(1.0f);
a.add(3.3f);
a.add(5.5f);
float* before = a.ptr();
a.setSizeZero();
float* after = a.ptr();
ASSERT_EQ(before, after);
ASSERT_EQ(0u, a.size());
ASSERT_TRUE(3 <= a.capacity());
a.add(1.1f);
a.add(3.4f);
a.add(5.6f);
ASSERT_EQ(3u, a.size());
ASSERT_EQ(1.1f, a[0]);
ASSERT_EQ(3.4f, a[1]);
ASSERT_EQ(5.6f, a[2]);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, SqueezeEmptyArray)
{
FloatArray a;
a.reserve(5);
ASSERT_EQ(0, a.size());
ASSERT_TRUE(5 <= a.capacity());
a.squeeze();
ASSERT_EQ(0, a.size());
ASSERT_EQ(0, a.capacity());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void UniformFloat::setArray(const FloatArray& values)
{
CVF_ASSERT(values.size() > 0);
m_type = FLOAT;
m_data = values;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, ReserveAndAdd)
{
FloatArray a;
a.reserve(5);
a.add(1.0f);
a.add(3.3f);
a.add(5.5f);
ASSERT_EQ(3u, a.size());
ASSERT_TRUE(a.capacity() >= 5);
ASSERT_EQ(1.0f, a[0]);
ASSERT_EQ(3.3f, a[1]);
ASSERT_EQ(5.5f, a[2]);
// To test reuse of buffer
float* before = a.ptr();
a.reserve(3);
ASSERT_TRUE(a.capacity() >= 5);
float* after = a.ptr();
// Check that no realloc has been done
ASSERT_EQ(before, after);
ASSERT_TRUE(a.capacity() >= 5);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, Squeeze)
{
FloatArray a;
a.reserve(5);
a.add(1.0f);
a.add(3.3f);
a.add(5.5f);
ASSERT_EQ(3u, a.size());
ASSERT_TRUE(5 <= a.capacity());
a.squeeze();
ASSERT_EQ(3u, a.size());
ASSERT_EQ(3u, a.capacity());
ASSERT_EQ(1.0f, a[0]);
ASSERT_EQ(3.3f, a[1]);
ASSERT_EQ(5.5f, a[2]);
}
CLabel::TEXTPOSINFO CLabel::GetTextPosition(const StringArray& lines) const
{
TEXTPOSINFO result;
FloatArray lineWidths = GetLineWidths(lines);
result.linePosX.reserve(lineWidths.size());
for(unsigned int i = 0; i < lineWidths.size(); i++)
{
float posX = 0;
float lineWidth = lineWidths[i];
switch(m_horizontalAlignment)
{
case HORIZONTAL_ALIGNMENT_LEFT:
posX = 0;
break;
case HORIZONTAL_ALIGNMENT_RIGHT:
posX = m_size.x - lineWidth;
break;
case HORIZONTAL_ALIGNMENT_CENTER:
posX = static_cast<float>(static_cast<int>(m_size.x - lineWidth) / 2);
break;
}
result.linePosX.push_back(posX);
}
float textHeight = GetTextHeight(lines);
float posY = 0;
switch(m_verticalAlignment)
{
case VERTICAL_ALIGNMENT_TOP:
posY = 0;
break;
case VERTICAL_ALIGNMENT_BOTTOM:
posY = m_size.y - textHeight;
break;
case VERTICAL_ALIGNMENT_CENTER:
posY = static_cast<float>(static_cast<int>(m_size.y - textHeight) / 2);
break;
}
result.posY = posY;
return result;
}
TEST(ArrayTest, testConstruction)
{
// fundamental type
typedef Poco::Array<float,6> FloatArray;
FloatArray a = { { 42.f } };
for (unsigned i=1; i<a.size(); ++i) {
a[i] = a[i-1]+1.f;
}
// copy constructor and assignment operator
FloatArray b(a);
FloatArray c;
c = a;
EXPECT_TRUE (a==b && a==c);
typedef Poco::Array<double,6> DArray;
typedef Poco::Array<int,6> IArray;
IArray ia = {{1, 2, 3, 4, 5, 6 }};
DArray da;
da = ia;
da.assign(42);
// user-defined type
typedef Poco::Array<Element,10> ElementArray;
ElementArray g;
for (unsigned i=0; i<g.size(); ++i) {
g[i]._data = i;
}
for (unsigned i=0; i<g.size(); ++i) {
EXPECT_TRUE(g[i]._data == i);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, ReserveGrow)
{
FloatArray a;
a.resize(3);
a.set(0, 1.0f);
a.set(1, 3.3f);
a.set(2, 5.5f);
float* before = a.ptr();
a.reserve(8);
float* after = a.ptr();
a.add(2.2f);
a.add(2.5f);
ASSERT_NE(before, after);
ASSERT_EQ(5u, a.size());
ASSERT_TRUE(a.capacity() >= 8);
ASSERT_EQ(1.0f, a[0]);
ASSERT_EQ(3.3f, a[1]);
ASSERT_EQ(5.5f, a[2]);
ASSERT_EQ(2.2f, a[3]);
ASSERT_EQ(2.5f, a[4]);
}
void DoAnim()
{
static double time = 0.0; //Total time running.
static double artTime = 0.0; //Total time with the current art.
static DWORD lastTime = 0; //Time of last call.
const double elapsed = double(GetTickCount() - lastTime) / 1000.0;
if (lastTime)
{
lastTime = GetTickCount();
}
else
{
lastTime = GetTickCount();
return;
}
time += elapsed;
artTime += elapsed;
//If we need new art, get it.
static CKnot::AutoArt threads;
static Arrays arrays;
static FloatArray grid;
if (!threads.get() || artTime > ResetTime)
{
CKnot::StrokeList sl = CreateSquareStrokes();
sl = RemoveStrokes(sl);
threads = CKnot::CreateThread(sl);
artTime = 0.0;
grid.clear();
grid.reserve(sl.size() * 10);
for (CKnot::StrokeList::const_iterator it = sl.begin(); it != sl.end(); ++it)
{
grid.push_back(it->a.x);
grid.push_back(it->a.y);
grid.push_back(it->type == CKnot::Cross ? 1.0 : 0.0);
grid.push_back(it->type == CKnot::Glance ? 1.0 : 0.0);
grid.push_back(it->type == CKnot::Bounce ? 1.0 : 0.0);
grid.push_back(it->b.x);
grid.push_back(it->b.y);
grid.push_back(it->type == CKnot::Cross ? 1.0 : 0.0);
grid.push_back(it->type == CKnot::Glance ? 1.0 : 0.0);
grid.push_back(it->type == CKnot::Bounce ? 1.0 : 0.0);
}
for (size_t i = 0; i < arrays.size(); ++i)
delete arrays[i];
arrays.clear();
const size_t threadCount = threads->GetThreadCount();
for (size_t i = 0; i < threadCount; ++i)
{
const CKnot::Art::Thread* thread = threads->GetThread(i);
const CKnot::Art::Z* z = threads->GetZ(i);
const size_t segsPerKnot = 25;
const size_t kc = thread->GetKnotCount();
FloatArray* quads = new FloatArray;
arrays.push_back(quads);
const size_t target = kc * segsPerKnot;
const size_t memSize = 12 * (target + 1);
quads->reserve(memSize);
const float scr = double(rand()) / RAND_MAX / 2;
const float ecr = double(rand()) / RAND_MAX / 2 + .5;
const float scg = double(rand()) / RAND_MAX / 2;
const float ecg = double(rand()) / RAND_MAX / 2 + .5;
const float scb = double(rand()) / RAND_MAX / 2;
const float ecb = double(rand()) / RAND_MAX / 2 + .5;
for (size_t i = 0; i <= target; ++i)
{
const double s = double(i) / double(target);
const double t = s;
const CKnot::vec2 cur = thread->Y(t);
const CKnot::vec2 dcur = thread->Y(t + .00001);
const CKnot::vec2 diff = dcur - cur;
CKnot::vec2 normal(diff.y, -diff.x);
normal = normal * (1.0 / normal.GetLength());
normal = normal * .01;
const CKnot::vec2 flip(-normal.x, -normal.y);
const CKnot::vec2 start = cur + normal;
const CKnot::vec2 end = cur + flip;
const bool over = z->Y(t) > 0.0;
//Coords
quads->push_back(start.x);
quads->push_back(start.y);
quads->push_back(over ? 0.01 : .1);
//Colors
quads->push_back(scr);
quads->push_back(scg);
quads->push_back(scb);
quads->push_back(end.x);
quads->push_back(end.y);
quads->push_back(over ? 0.01 : .1);
quads->push_back(ecr);
quads->push_back(ecg);
quads->push_back(ecb);
}
assert(quads->size() == memSize);
}
}
//Clear the background some nice color.
glClearColor( 0.125f + std::sin(time / 2.0) / 8.0,
0.125f + std::sin(time / 3.0) / 8.0,
0.125f + std::sin(time / 5.0) / 8.0,
0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
for (size_t i = 0; i < arrays.size(); ++i)
{
FloatArray& quads = *arrays[i];
glVertexPointer(3, GL_FLOAT, 24, &quads.front());
glColorPointer(3, GL_FLOAT, 24, &quads.front() + 3);
const size_t count = quads.size() / 6;
const size_t progress = size_t(std::min(artTime / DrawTime, 1.0) * count / 2); //From 0 to .5 of vertices.
assert(progress >= 0);
assert(progress <= count / 2);
size_t start = (count / 2) - progress;
start += start % 2;
glDrawArrays(GL_QUAD_STRIP, start, progress * 2);
}
//Draw graph
if (DrawGraph)
{
glVertexPointer(2, GL_FLOAT, 20, &grid.front());
glColorPointer(3, GL_FLOAT, 20, &grid.front() + 2);
glDrawArrays(GL_LINES, 0, grid.size() / 5);
}
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glLoadIdentity();
}
