//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void BoundingBox::add(const Vec3fArray& points)
{
size_t i;
for (i = 0; i < points.size(); i++)
{
add(points[i]);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void UniformFloat::setArray(const Vec3fArray& values)
{
size_t numValues = values.size();
CVF_ASSERT(numValues > 0);
m_type = FLOAT_VEC3;
m_data.resize(3*numValues);
m_data.copyData(values.ptr()->ptr(), 3*numValues, 0);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, BasicVec3fArray)
{
// Vec3f array
Vec3fArray vA;
vA.resize(4);
ASSERT_EQ(4u, vA.size());
vA[0] = Vec3f(1,2,3);
vA[1] = Vec3f(1.1f, 2.2f, 3.3f);
vA[2] = Vec3f(0,0,0);
vA[3] = Vec3f(4,5,6);
ASSERT_EQ(true, vA[0] == Vec3f(1, 2, 3));
ASSERT_EQ(true, vA[1] == Vec3f(1.1f, 2.2f, 3.3f));
ASSERT_EQ(true, vA[2] == Vec3f(0, 0, 0));
ASSERT_EQ(true, vA[3] == Vec3f(4, 5, 6));
const float* pf = vA.ptr()->ptr();
ASSERT_FLOAT_EQ(1.0f, pf[0]);
ASSERT_FLOAT_EQ(2.0f, pf[1]);
ASSERT_FLOAT_EQ(3.0f, pf[2]);
ASSERT_FLOAT_EQ(1.1f, pf[3]);
ASSERT_FLOAT_EQ(2.2f, pf[4]);
ASSERT_FLOAT_EQ(3.3f, pf[5]);
ASSERT_FLOAT_EQ(0.0f, pf[6]);
ASSERT_FLOAT_EQ(0.0f, pf[7]);
ASSERT_FLOAT_EQ(0.0f, pf[8]);
ASSERT_FLOAT_EQ(4.0f, pf[9]);
ASSERT_FLOAT_EQ(5.0f, pf[10]);
ASSERT_FLOAT_EQ(6.0f, pf[11]);
vA.clear();
ASSERT_EQ(0u, vA.size());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void DrawableVectors::createUploadBufferObjectsGPU(OpenGLContext* oglContext)
{
if (!m_renderWithVBO || m_vertexArray->size() == 0 || m_vectorGlyph.isNull() || m_vectorGlyphPrimSet.isNull())
{
return;
}
if (m_glyphVerticesAndNormalsBO.isNull() || !m_glyphVerticesAndNormalsBO->isUploaded())
{
// Build a interleaved VBO for glyphs vertices and normals to get better performance
// during the main shader based draw path
size_t numVertices = m_vectorGlyph->vertexArray()->size();
Vec3fArray data;
data.reserve(numVertices*2);
size_t i;
for (i = 0; i < numVertices; i++)
{
data.add(m_vectorGlyph->vertexArray()->get(i));
data.add(m_vectorGlyph->normalArray()->get(i));
}
GLuint uiSizeInBytes = static_cast<GLuint>(data.size()*3*sizeof(float));
m_glyphVerticesAndNormalsBO = oglContext->resourceManager()->getOrCreateManagedBufferObject(oglContext, GL_ARRAY_BUFFER, uiSizeInBytes, data.ptr()->ptr());
}
if (m_indicesBO.isNull() || !m_indicesBO->isUploaded())
{
const UShortArray* indices = m_vectorGlyphPrimSet->indices();
size_t numIndices = indices->size();
if (numIndices > 0)
{
GLuint uiSizeInBytes = static_cast<GLuint>(numIndices*sizeof(GLushort));
m_indicesBO = oglContext->resourceManager()->getOrCreateManagedBufferObject(oglContext, GL_ELEMENT_ARRAY_BUFFER, uiSizeInBytes, indices->ptr());
CVF_CHECK_OGL(oglContext);
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(ArrayTest, ptrToIdx)
{
// Vec3f array
Vec3fArray vA;
vA.resize(4);
ASSERT_EQ(4u, vA.size());
vA[0] = Vec3f(1,2,3);
vA[1] = Vec3f(1.1f, 2.2f, 3.3f);
vA[2] = Vec3f(0,0,0);
vA[3] = Vec3f(4,5,6);
Vec3f* p1 = vA.ptr(1);
ASSERT_FLOAT_EQ(1.1f, p1->x());
ASSERT_FLOAT_EQ(2.2f, p1->y());
ASSERT_FLOAT_EQ(3.3f, p1->z());
Vec3f* p3 = vA.ptr(3);
ASSERT_FLOAT_EQ(4, p3->x());
ASSERT_FLOAT_EQ(5, p3->y());
ASSERT_FLOAT_EQ(6, p3->z());
}
//--------------------------------------------------------------------------------------------------
/// Create a sphere with center in origin
///
/// \param radius Radius of sphere
/// \param numSlices The number of subdivisions around the z-axis (similar to lines of longitude).
/// \param numStacks The number of subdivisions along the z-axis (similar to lines of latitude).
/// \param builder Geometry builder to use when creating geometry
//--------------------------------------------------------------------------------------------------
void GeometryUtils::createSphere(double radius, uint numSlices, uint numStacks, GeometryBuilder* builder)
{
// Code is strongly inspired by mesa.
// From GLviewAPI:
// float nsign = bNormalsOutwards ? 1.0f : -1.0f;
// Could be added as a param if needed (e.g. dome)
const double nsign = 1.0;
double rho = PI_D/numStacks;
double theta = 2.0*PI_D/static_cast<double>(numSlices);
// Array to receive the node coordinates
Vec3fArray vertices;
uint vertexCount = 1 + 2*numSlices + (numStacks - 2)*numSlices;
vertices.reserve(vertexCount);
// Create the +Z end as triangles
Vec3d vTop(0.0, 0.0, nsign*radius);
vertices.add(Vec3f(vTop));
ref<UIntArray> triangleFan = new UIntArray;
triangleFan->reserve(numSlices + 2);
triangleFan->add(0);
uint j;
for (j = 0; j < numSlices; j++)
{
double localTheta = j * theta;
Vec3d v;
v.x() = -Math::sin(localTheta) * Math::sin(rho);
v.y() = Math::cos(localTheta) * Math::sin(rho);
v.z() = nsign * Math::cos(rho);
v *= radius;
vertices.add(Vec3f(v));
triangleFan->add(j + 1);
}
// Close top fan
triangleFan->add(1);
builder->addTriangleFan(*triangleFan);
// Intermediate stacks as quad-strips
// First and last stacks are handled separately
ref<UIntArray> quadStrip = new UIntArray;
quadStrip->reserve(numSlices*2 + 2);
uint i;
for (i = 1; i < numStacks - 1; i++)
{
double localRho = i * rho;
quadStrip->setSizeZero();
for (j = 0; j < numSlices; j++)
{
double localTheta = j * theta;
Vec3d v;
v.x() = -Math::sin(localTheta) * Math::sin(localRho + rho);
v.y() = Math::cos(localTheta) * Math::sin(localRho + rho);
v.z() = nsign * Math::cos(localRho + rho);
v *= radius;
vertices.add(Vec3f(v));
uint iC1 = (i*numSlices) + 1 + j;
uint iC0 = iC1 - numSlices;
quadStrip->add(iC0);
quadStrip->add(iC1);
}
// Close quad-strip
uint iStartC1 = (i*numSlices) + 1;
uint iStartC0 = iStartC1 - numSlices;
quadStrip->add(iStartC0);
quadStrip->add(iStartC1);
builder->addQuadStrip(*quadStrip);
}
// Create -Z end as triangles
Vec3d vBot( 0.0, 0.0, -radius*nsign );
vertices.add(Vec3f(vBot));
uint endNodeIndex = static_cast<uint>(vertices.size()) - 1;
triangleFan->setSizeZero();
triangleFan->add(endNodeIndex);
for (j = 0; j < numSlices; j++)
{
triangleFan->add(endNodeIndex - j - 1);
}
// Close bottom fan
triangleFan->add(endNodeIndex - 1);
builder->addTriangleFan(*triangleFan);
builder->addVertices(vertices);
}
