bool PointSpritesBenchmark::initializeBenchmark()
{
std::stringstream vstrstr;
// Verify "numVaryings" is within MAX_VARYINGS limit
GLint maxVaryings;
glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
if (mParams.numVaryings > static_cast<unsigned int>(maxVaryings))
{
std::cerr << "Varying count (" << mParams.numVaryings << ")"
<< " exceeds maximum varyings: " << maxVaryings << std::endl;
return false;
}
vstrstr << "attribute vec2 vPosition;\n"
"uniform float uPointSize;\n";
for (unsigned int varCount = 0; varCount < mParams.numVaryings; varCount++)
{
vstrstr << "varying vec4 v" << varCount << ";\n";
}
vstrstr << "void main()\n"
"{\n";
for (unsigned int varCount = 0; varCount < mParams.numVaryings; varCount++)
{
vstrstr << " v" << varCount << " = vec4(1.0);\n";
}
vstrstr << " gl_Position = vec4(vPosition, 0, 1.0);\n"
" gl_PointSize = uPointSize;\n"
"}";
std::stringstream fstrstr;
fstrstr << "precision mediump float;\n";
for (unsigned int varCount = 0; varCount < mParams.numVaryings; varCount++)
{
fstrstr << "varying vec4 v" << varCount << ";\n";
}
fstrstr << "void main()\n"
"{\n"
" vec4 colorOut = vec4(1.0, 0.0, 0.0, 1.0);\n";
for (unsigned int varCount = 0; varCount < mParams.numVaryings; varCount++)
{
fstrstr << " colorOut.r += v" << varCount << ".r;\n";
}
fstrstr << " gl_FragColor = colorOut;\n"
"}\n";
mProgram = CompileProgram(vstrstr.str(), fstrstr.str());
if (!mProgram)
{
return false;
}
// Use the program object
glUseProgram(mProgram);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
std::vector<float> vertexPositions(mParams.count * 2);
for (size_t pointIndex = 0; pointIndex < vertexPositions.size(); ++pointIndex)
{
vertexPositions[pointIndex] = RandomBetween(-1.0f, 1.0f);
}
glGenBuffers(1, &mBuffer);
glBindBuffer(GL_ARRAY_BUFFER, mBuffer);
glBufferData(GL_ARRAY_BUFFER, vertexPositions.size() * sizeof(float), &vertexPositions[0], GL_STATIC_DRAW);
int positionLocation = glGetAttribLocation(mProgram, "vPosition");
if (positionLocation == -1)
{
return false;
}
glVertexAttribPointer(positionLocation, 2, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(positionLocation);
// Set the viewport
glViewport(0, 0, getWindow()->getWidth(), getWindow()->getHeight());
int pointSizeLocation = glGetUniformLocation(mProgram, "uPointSize");
if (pointSizeLocation == -1)
{
return false;
}
glUniform1f(pointSizeLocation, mParams.size);
GLenum glErr = glGetError();
if (glErr != GL_NO_ERROR)
{
return false;
}
return true;
}
/******************************************************************************
* Renders the construction grid.
******************************************************************************/
void ViewportSceneRenderer::renderGrid()
{
if(isPicking())
return;
FloatType gridSpacing;
Box2I gridRange;
std::tie(gridSpacing, gridRange) = determineGridRange(viewport());
if(gridSpacing <= 0) return;
// Determine how many grid lines need to be rendered.
int xstart = gridRange.minc.x();
int ystart = gridRange.minc.y();
int numLinesX = gridRange.size(0) + 1;
int numLinesY = gridRange.size(1) + 1;
FloatType xstartF = (FloatType)xstart * gridSpacing;
FloatType ystartF = (FloatType)ystart * gridSpacing;
FloatType xendF = (FloatType)(xstart + numLinesX - 1) * gridSpacing;
FloatType yendF = (FloatType)(ystart + numLinesY - 1) * gridSpacing;
// Allocate vertex buffer.
int numVertices = 2 * (numLinesX + numLinesY);
std::unique_ptr<Point3[]> vertexPositions(new Point3[numVertices]);
std::unique_ptr<ColorA[]> vertexColors(new ColorA[numVertices]);
// Build lines array.
ColorA color = Viewport::viewportColor(ViewportSettings::COLOR_GRID);
ColorA majorColor = Viewport::viewportColor(ViewportSettings::COLOR_GRID_INTENS);
ColorA majorMajorColor = Viewport::viewportColor(ViewportSettings::COLOR_GRID_AXIS);
Point3* v = vertexPositions.get();
ColorA* c = vertexColors.get();
FloatType x = xstartF;
for(int i = xstart; i < xstart + numLinesX; i++, x += gridSpacing, c += 2) {
*v++ = Point3(x, ystartF, 0);
*v++ = Point3(x, yendF, 0);
if((i % 10) != 0)
c[0] = c[1] = color;
else if(i != 0)
c[0] = c[1] = majorColor;
else
c[0] = c[1] = majorMajorColor;
}
FloatType y = ystartF;
for(int i = ystart; i < ystart + numLinesY; i++, y += gridSpacing, c += 2) {
*v++ = Point3(xstartF, y, 0);
*v++ = Point3(xendF, y, 0);
if((i % 10) != 0)
c[0] = c[1] = color;
else if(i != 0)
c[0] = c[1] = majorColor;
else
c[0] = c[1] = majorMajorColor;
}
OVITO_ASSERT(c == vertexColors.get() + numVertices);
// Render grid lines.
setWorldTransform(viewport()->gridMatrix());
if(!_constructionGridGeometry || !_constructionGridGeometry->isValid(this))
_constructionGridGeometry = createLinePrimitive();
_constructionGridGeometry->setVertexCount(numVertices);
_constructionGridGeometry->setVertexPositions(vertexPositions.get());
_constructionGridGeometry->setVertexColors(vertexColors.get());
_constructionGridGeometry->render(this);
}
void IShape::Update()
{
const unsigned int numVertices = GetVertexCount();
// Get all the data.
std::unique_ptr<glm::vec3[]> vertexPositions(new glm::vec3[numVertices]);
std::unique_ptr<glm::vec4[]> vertexColors(new glm::vec4[numVertices]);
std::unique_ptr<glm::vec2[]> vertexTextureCoordinates(new glm::vec2[numVertices]);
for (unsigned int i = 0; i < numVertices; ++i)
{
const glm::vec2 position = GetVertexPosition(i);
vertexPositions[i] = glm::vec3(position, 0.0f);
vertexColors[i] = m_fillColor;
vertexTextureCoordinates[i] = GetTextureCoordinate(i);
}
// Bind the Vertex Array Object.
glBindVertexArray(m_VAO);
// Send the vertex position data to the corresponding VBO.
glBindBuffer(GL_ARRAY_BUFFER, m_positionVBO);
glBufferData(
GL_ARRAY_BUFFER,
sizeof(glm::vec3) * numVertices,
&vertexPositions[0],
GL_STATIC_DRAW
);
// Set the vertex position data to be the first attribute
// passed to the shader (index 0).
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
// Send the vertex color data to the corresponding VBO.
glBindBuffer(GL_ARRAY_BUFFER, m_colorVBO);
glBufferData(
GL_ARRAY_BUFFER,
sizeof(glm::vec4) * numVertices,
&vertexColors[0],
GL_STATIC_DRAW
);
// Set the vertex color data to be the third attribute
// passed to the shader (index 2).
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 0, 0);
// Texturing...
if (m_texture)
{
// Send the texture coordinate data to the corresponding VBO.
glBindBuffer(GL_ARRAY_BUFFER, m_textureCoordinatesVBO);
glBufferData(
GL_ARRAY_BUFFER,
sizeof(glm::vec2) * numVertices,
&vertexTextureCoordinates[0],
GL_STATIC_DRAW
);
// Set the vertex texture coordinate data to be the fourth
// attribute passed to the shader (index 3).
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, 0, 0);
}
// Unbind the Vertex Array Object.
glBindVertexArray(0);
}
