void PlatformShoes::Renderer::drawSquare(float x, float y, float width, float height, double tu, double tv, double tw, double th) {
// square ////////////////////////////////////////////////////////////////////
// v1------v0
// | |
// | |
// | |
// v2------v3
// vertex coords array
static const float vertices[] = {1,1,0, -1,1,0, -1,-1,0, 1,-1,0}; // v0-v1-v2-v3
// normal array
static const float normals[] = {0,0,1, 0,0,1, 0,0,1, 0,0,1}; // v0-v1-v2-v3
// color array
static const float colors[] = {0.72f,0.54f,0, 0.72f,0.54f,0, 0.52f,0.388f,0, 0.72f,0.388f,0}; // v0-v1-v2-v3
double texture_coords[] = {tu+tw, tv, tu, tv, tu, tv+th, tu+tw, tv+th}; // v0-v1-v2-v3
static const unsigned char indices[] = {0, 1, 2, 3};
glCullFace(GL_BACK);
float half_width = width / 2.0f;
float half_height = height / 2.0f;
glPushMatrix();
glTranslatef(x, y, 0);
glScalef(half_width, half_height, 1.0);
drawArrays(vertices, normals, colors, indices, texture_coords, 4);
glPopMatrix();
}
//----------------------------------------------------------------------
void Render::renderPointsAsSpheres()
{
glEnable(GL_POINT_SPRITE);
glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
glUseProgram(glsl_program[SPHERE_SHADER]);
//float particle_radius = 0.125f * 0.5f;
glUniform1f( glGetUniformLocation(glsl_program[SPHERE_SHADER], "pointScale"), ((float)window_width) / tanf(65. * (0.5f * 3.1415926535f/180.0f)));
//GE PUT particle_radius in the panel (as a test)
float radius_scale = settings->getRadiusScale(); //GE
//glUniform1f( glGetUniformLocation(glsl_program[SPHERE_SHADER], "pointRadius"), particle_radius );
glUniform1f( glGetUniformLocation(glsl_program[SPHERE_SHADER], "pointRadius"), particle_radius*radius_scale ); //GE
glUniform1f( glGetUniformLocation(glsl_program[SPHERE_SHADER], "near"), near_depth );
glUniform1f( glGetUniformLocation(glsl_program[SPHERE_SHADER], "far"), far_depth );
//glColor3f(1., 1., 1.);
drawArrays();
glUseProgram(0);
glDisable(GL_VERTEX_PROGRAM_POINT_SIZE);
glDisable(GL_POINT_SPRITE);
}
//----------------------------------------------------------------------
void Render::render()
{
timers["render"]->start();
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
//printf("*** before renderPointCloud\n");
glDepthMask(GL_TRUE);
glEnable(GL_LIGHTING);
#ifdef CLOUD_COLLISION
renderPointCloud(); //GE
#endif
glDisable(GL_LIGHTING);
glDepthMask(GL_FALSE);
if (blending)
{
//glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
else
{
//glEnable(GL_DEPTH_TEST);
}
//glBlendFunc(GL_SRC_ALPHA, GL_ONE);
// draws circles instead of squares
glEnable(GL_POINT_SMOOTH);
//TODO make the point size a setting
glPointSize(5.0f);
drawArrays();
//printf("done rendering, clean up\n");
glDepthMask(GL_TRUE);
glDisable(GL_LIGHTING);
glPopClientAttrib();
glPopAttrib();
//glDisable(GL_POINT_SMOOTH);
if (blending)
{
glDisable(GL_BLEND);
}
//glEnable(GL_LIGHTING);
glBindBuffer(GL_ARRAY_BUFFER, 0);
//printf("done rendering\n");
timers["render"]->end();
//make sure rendering timing is accurate
glFinish();
}
void VertBatch::draw()
{
// this pushes the VAO, which needs to be popped
setupBuffers();
ScopedVao vao( mVao );
auto ctx = context();
ctx->setDefaultShaderVars();
ctx->drawArrays( mPrimType, 0, (GLsizei)mVertices.size() );
}
void PlatformShoes::Renderer::drawCube(float x, float y, float z, float width, float height, float depth) {
// cube ///////////////////////////////////////////////////////////////////////
// v6----- v5
// /| /|
// v1------v0|
// | | | |
// | |v7---|-|v4
// |/ |/
// v2------v3
// vertex coords array
static const float vertices[] = {1,1,1, -1,1,1, -1,-1,1, 1,-1,1, // v0-v1-v2-v3
1,1,1, 1,-1,1, 1,-1,-1, 1,1,-1, // v0-v3-v4-v5
1,1,1, 1,1,-1, -1,1,-1, -1,1,1, // v0-v5-v6-v1
-1,1,1, -1,1,-1, -1,-1,-1, -1,-1,1, // v1-v6-v7-v2
-1,-1,-1, 1,-1,-1, 1,-1,1, -1,-1,1, // v7-v4-v3-v2
1,-1,-1, -1,-1,-1, -1,1,-1, 1,1,-1}; // v4-v7-v6-v5
// normal array
static const float normals[] = {0,0,1, 0,0,1, 0,0,1, 0,0,1, // v0-v1-v2-v3
1,0,0, 1,0,0, 1,0,0, 1,0,0, // v0-v3-v4-v5
0,1,0, 0,1,0, 0,1,0, 0,1,0, // v0-v5-v6-v1
-1,0,0, -1,0,0, -1,0,0, -1,0,0, // v1-v6-v7-v2
0,-1,0, 0,-1,0, 0,-1,0, 0,-1,0, // v7-v4-v3-v2
0,0,-1, 0,0,-1, 0,0,-1, 0,0,-1}; // v4-v7-v6-v5
// color array
static const float colors[] = {0.72f,0.54f,0, 0.72f,0.54f,0, 0.52f,0.388f,0, 0.72f,0.388f,0, // v0-v1-v2-v3
0.72f,0.54f,0, 0.72f,0.54f,0, 0.52f,0.388f,0, 0.72f,0.388f,0, // v0-v3-v4-v5
1,1,1, 0,1,1, 0,1,0, 1,1,0, // v0-v5-v6-v1
0.72f,0.54f,0, 0.72f,0.54f,0, 0.52f,0.388f,0, 0.72f,0.388f,0, // v1-v6-v7-v2
0,0,0, 0,0,1, 1,0,1, 1,0,0, // v7-v4-v3-v2
0.72f,0.54f,0, 0.72f,0.54f,0, 0.52f,0.388f,0, 0.72f,0.388f,0};// v4-v7-v6-v5
static const unsigned char indices[] = {0,1,2,3,
4,5,6,7,
8,9,10,11,
12,13,14,15,
16,17,18,19,
20,21,22,23};
glCullFace(GL_BACK);
float half_width = width / 2.0f;
float half_height = height / 2.0f;
float half_depth = depth / 2.0f;
glPushMatrix();
glTranslatef(x, y, z);
glScalef(half_width, half_height, half_depth);
drawArrays(vertices, normals, colors, indices, 24);
glPopMatrix();
}
void ImageSprite::draw(SPRenderer renderer)
{
auto context = renderer->getContext();
context->useProgram(_program);
// setUniform must after useProgram
_program->setUniform(_program->getUniform("view"), Director::getInstance().getView());
_program->setUniform(_program->getUniform("proj"), Director::getInstance().getProj());
_program->setUniform(_program->getUniform("model"), getModel());
context->bindTexture(_texture, 0);
context->drawArrays(*_vao, cppgl::Primitive::Triangles, 0, 6);
}
/// Draw a vertex array
void RendererOpenGL::draw(const VertexArray2D& varray, const RenderState& state)
{
const char* data = reinterpret_cast<const char*>(&varray.m_vertices[0]);
if(m_activeShader)
{
enableVertexAttribArray(0);
enableVertexAttribArray(1);
enableVertexAttribArray(2);
setVertexAttribPointer(0, 2, GL_FLOAT, false, sizeof(VertexArray2D::Vertex), data + 0);
setVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, sizeof(VertexArray2D::Vertex), data + 8);
setVertexAttribPointer(2, 2, GL_FLOAT, false, sizeof(VertexArray2D::Vertex), data + 12);
drawArrays(varray.geometryType, 0, varray.m_vertices.size());
disableVertexAttribArray(0);
disableVertexAttribArray(1);
disableVertexAttribArray(2);
}
else
{
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(2, GL_FLOAT, sizeof(VertexArray2D::Vertex), data + 0);
glColorPointer(4, GL_UNSIGNED_BYTE,sizeof(VertexArray2D::Vertex), data + 8);
glTexCoordPointer(2, GL_FLOAT, sizeof(VertexArray2D::Vertex), data + 12);
drawArrays(varray.geometryType, 0, varray.m_vertices.size());
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
}
}
void RenderState::draw()
{
gl_check(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT));
switch (m_vao->method()) {
case VertexArrayObject::Method::ELEMENTS:
drawElementArrays();
break;
case VertexArrayObject::Method::ARRAYS:
drawArrays();
break;
default:
break;
}
}
void operator () (GEdge *e)
{
if(!e->getVisibility()) {
if(e->getCompound()) {
if(!e->getCompound()->getVisibility()) return;
}
else
return;
}
bool select = (_ctx->render_mode == drawContext::GMSH_SELECT &&
e->model() == GModel::current());
if(select) {
glPushName(1);
glPushName(e->tag());
}
if(CTX::instance()->mesh.lines)
drawArrays(_ctx, e, e->va_lines, GL_LINES, false);
if(CTX::instance()->mesh.linesNum)
drawElementLabels(_ctx, e, e->lines);
if(CTX::instance()->mesh.points || CTX::instance()->mesh.pointsNum){
if(e->getAllElementsVisible())
drawVerticesPerEntity(_ctx, e);
else
drawVerticesPerElement(_ctx, e, e->lines);
}
if(CTX::instance()->mesh.tangents)
drawTangents(_ctx, e->lines);
if(select) {
glPopName();
glPopName();
}
}
gl::Error RendererD3D::drawArrays(const gl::Data &data,
GLenum mode, GLint first,
GLsizei count, GLsizei instances)
{
gl::Program *program = data.state->getProgram();
ASSERT(program != NULL);
program->updateSamplerMapping();
gl::Error error = generateSwizzles(data);
if (error.isError())
{
return error;
}
if (!applyPrimitiveType(mode, count, program->usesPointSize()))
{
return gl::Error(GL_NO_ERROR);
}
error = applyRenderTarget(data, mode, false);
if (error.isError())
{
return error;
}
error = applyState(data, mode);
if (error.isError())
{
return error;
}
applyTransformFeedbackBuffers(*data.state);
error = applyVertexBuffer(*data.state, mode, first, count, instances, nullptr);
if (error.isError())
{
return error;
}
error = applyShaders(data);
if (error.isError())
{
return error;
}
error = applyTextures(data);
if (error.isError())
{
return error;
}
error = program->applyUniformBuffers(data);
if (error.isError())
{
return error;
}
if (!skipDraw(data, mode))
{
error = drawArrays(data, mode, count, instances, program->usesPointSize());
if (error.isError())
{
return error;
}
if (data.state->isTransformFeedbackActiveUnpaused())
{
markTransformFeedbackUsage(data);
}
}
return gl::Error(GL_NO_ERROR);
}
void DrawExecution::perform()
{
m_glStateManager.enableTextureCubeMapSeamless(true);
// Apply State
applyDepthState();
applyBlendState();
applyCullState();
applyRasterizerState();
applyStencilState();
applyViewport();
gl::glUseProgram(m_drawImpl.program->glProgramName);
// Setup texture units
for (auto b = 0u; b < m_drawImpl.samplers.size(); b++)
{
auto & sampler = m_drawImpl.samplers[b];
auto * texture = sampler.texture;
Assert(texture, "");
if (texture->glName == 0)
{
texture->allocate();
}
gl::glActiveTexture(gl::GL_TEXTURE0 + b);
gl::glBindTexture(texture->type, texture->glName);
gl::glTexParameteri(texture->type, gl::GL_TEXTURE_BASE_LEVEL, texture->baseLevel);
gl::glTexParameteri(texture->type, gl::GL_TEXTURE_MAX_LEVEL, texture->maxLevel);
gl::glBindSampler(b, sampler.glSampler.name());
gl::glSamplerParameteri(sampler.glSampler.name(), gl::GL_TEXTURE_MIN_FILTER, (gl::GLint)texture->minFilter);
gl::glSamplerParameteri(sampler.glSampler.name(), gl::GL_TEXTURE_MAG_FILTER, (gl::GLint)texture->maxFilter);
gl::glUniform1i(sampler.location, b);
}
// Setup RenderTarget / Framebuffer
Assert(m_drawImpl.framebuffer.m_impl.get(), "");
m_drawImpl.framebuffer.m_impl->bind(m_glStateManager);
// Set uniforms
{
/*
TODO
Port to GLStateManager
*/
for (auto & uniform : m_drawImpl.uniforms)
{
Assert(uniform.isAssigned, "Uniform " + m_drawImpl.program->interface.uniformByLocation(uniform.location)->name() + " not set");
Assert(uniform.count > 0, "");
auto count = uniform.count;
auto * data = uniform.blob.ptr();
auto location = uniform.location;
switch (TypeToGLType(uniform.type))
{
case gl::GL_INT:
gl::glUniform1iv(location, count, ((const gl::GLint*)data));
break;
case gl::GL_UNSIGNED_INT:
gl::glUniform1uiv(location, count, ((const gl::GLuint*)data));
break;
case gl::GL_INT_VEC2:
{
auto idata = (const gl::GLint*)data;
gl::glUniform2iv(location, count, idata);
break;
}
case gl::GL_FLOAT:
gl::glUniform1fv(location, count, ((const gl::GLfloat*)data));
break;
case gl::GL_FLOAT_VEC2:
{
auto fdata = (const gl::GLfloat*)data;
gl::glUniform2fv(location, count, fdata);
break;
}
case gl::GL_FLOAT_VEC3:
{
auto fdata = (const gl::GLfloat*)data;
gl::glUniform3fv(location, count, fdata);
break;
}
case gl::GL_FLOAT_VEC4:
{
auto fdata = (const gl::GLfloat*)data;
gl::glUniform4fv(location, count, fdata);
break;
}
case gl::GL_FLOAT_MAT4:
gl::glUniformMatrix4fv(location, count, gl::GL_FALSE, (const gl::GLfloat*)data);
break;
default:
Fail(std::string("Not implemented for type ") + uniform.type.name());
}
}
}
// Set uniform buffers
{
for (auto b = 0; b < m_drawImpl.uniformBuffers.size(); b++)
{
auto & binding = m_drawImpl.uniformBuffers[b];
Assert(binding.engaged(), "UniformBuffer " + m_drawImpl.program->interface.uniformBlocks()[b].name() + " not bound");
auto & buffer = *binding.get().buffer;
auto size = buffer.count * buffer.layout.stride();
Assert(size > binding.get().begin, "begin beyond buffer bounds");
gl::glUniformBlockBinding(m_drawImpl.program->glProgramName, b, b);
gl::glBindBufferRange(gl::GL_UNIFORM_BUFFER, b, buffer.glName, binding.get().begin, buffer.layout.stride());
}
}
// Dispatch draw
if (m_drawImpl.indexBuffer)
{
if (!m_drawImpl.instanceBuffers.empty())
{
drawElementsInstanced();
}
else
{
drawElements();
}
}
else
{
if (!m_drawImpl.instanceBuffers.empty())
{
drawArraysInstanced();
}
else
{
drawArrays();
}
}
}
void ShadowsDemo::onDraw() {
App::onDraw();
const auto device = graphicsDevice();
device->setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
device->clear(ciri::ClearFlags::Color | ciri::ClearFlags::Depth);
device->setRasterizerState(_rasterState);
device->restoreDefaultBlendState();
if( _spotlightShader->isValid() && _directionalShader->isValid() ) {
const cc::Mat4f& cameraViewProj = _camera.getProj() * _camera.getView();
bool firstLight = true;
Light::Type boundLightType = Light::Type::Invalid;
for( auto& light : _lights ) {
// compute light matrices
//const cc::Mat4f& lightView = light.view();
//const cc::Mat4f& lightProj = light.proj();//cc::math::perspectiveRH(45.0f, 1.0f, 0.1f, light.range());//light.proj();
//const cc::Mat4f lightViewProj = lightProj * lightView;
if( light.type() == Light::Type::Directional ) {
//light.computeViewProjFromFrustum(BoundingFrustum(cameraViewProj));
light.computeViewProjFromFrustum(BoundingFrustum(_camera.getFov(), _camera.getAspect(), _camera.getNearPlane(), _camera.getFarPlane(), _camera.getPosition(), _camera.getFpsFront(), _camera.getUp()));
//light.computeViewProjOrtho(_camera.getView(), _camera.getFov(), _camera.getAspect(), _camera.getNearPlane(), _camera.getFarPlane());
}
const cc::Mat4f lightViewProj = light.proj() * light.view();
if( light.castShadows() ) {
device->setDepthStencilState(device->getDefaultDepthStencilDefault());
// set and clear render target
ciri::IRenderTarget2D* depthTarget = _shadowTarget.get();
device->setRenderTargets(&depthTarget, 1);
device->setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
device->clear(ciri::ClearFlags::Color | ciri::ClearFlags::Depth);
// apply depth shader
device->applyShader(_depthShader);
// set viewport to depth size
device->setViewport(ciri::Viewport(0, 0, _shadowTarget->getDepth()->getWidth(), _shadowTarget->getDepth()->getHeight()));
// render all models
for( auto& mdl : _models ) {
_depthConstants.xform = lightViewProj * mdl->getXform().getWorld();
_depthConstantsBuffer->setData(sizeof(DepthConstants), &_depthConstants);
device->setVertexBuffer(mdl->getVertexBuffer());
if( mdl->getIndexBuffer() != nullptr ) {
device->setIndexBuffer(mdl->getIndexBuffer());
device->drawIndexed(ciri::PrimitiveTopology::TriangleList, mdl->getIndexBuffer()->getIndexCount());
} else {
device->drawArrays(ciri::PrimitiveTopology::TriangleList, mdl->getVertexBuffer()->getVertexCount(), 0);
}
}
// reser viewport to screen
device->setViewport(ciri::Viewport(0, 0, window()->getWidth(), window()->getHeight()));
// restore default render targets
device->restoreDefaultRenderTargets();
}
switch( light.type() ) {
case Light::Type::Directional: {
if( boundLightType != Light::Type::Directional || light.castShadows() ) {
boundLightType = Light::Type::Directional;
device->applyShader(_directionalShader);
device->setTexture2D(0, _shadowTarget->getDepth(), ciri::ShaderStage::Pixel);
device->setSamplerState(0, _shadowSampler, ciri::ShaderStage::Pixel);
}
_directionalConstants.LightDirection = light.direction();
_directionalConstants.LightColor = light.diffuseColor();
_directionalConstants.LightIntensity = light.diffuseIntensity();
_directionalConstants.campos = _camera.getPosition();
_directionalConstants.CastShadows = light.castShadows();
_directionalConstants.lightViewProj = lightViewProj;
for( auto& mdl : _models ) {
if( !mdl->isValid() ) {
continue;
}
_directionalConstants.world = mdl->getXform().getWorld();
_directionalConstants.xform = cameraViewProj * _directionalConstants.world;
_directionalConstantsBuffer->setData(sizeof(DirectionalConstants), &_directionalConstants);
device->setVertexBuffer(mdl->getVertexBuffer());
if( mdl->getIndexBuffer() != nullptr ) {
device->setIndexBuffer(mdl->getIndexBuffer());
device->drawIndexed(ciri::PrimitiveTopology::TriangleList, mdl->getIndexBuffer()->getIndexCount());
} else {
device->drawArrays(ciri::PrimitiveTopology::TriangleList, mdl->getVertexBuffer()->getVertexCount(), 0);
}
}
break;
}
case Light::Type::Spot: {
if( boundLightType != Light::Type::Spot || light.castShadows() ) {
boundLightType = Light::Type::Spot;
device->applyShader(_spotlightShader);
device->setTexture2D(0, _shadowTarget->getDepth(), ciri::ShaderStage::Pixel);
device->setSamplerState(0, _shadowSampler, ciri::ShaderStage::Pixel);
}
_spotlightConstants.LightPosition = light.position();
_spotlightConstants.LightDirection = light.direction();
_spotlightConstants.LightColor = light.diffuseColor();
_spotlightConstants.LightCosInner = light.cosConeInnerAngle(true);
_spotlightConstants.LightCosOuter = light.cosConeOuterAngle(true);
_spotlightConstants.LightIntensity = light.diffuseIntensity();
_spotlightConstants.LightRange = light.range();
_spotlightConstants.CastShadows = light.castShadows();
_spotlightConstants.lightViewProj = lightViewProj;
for( auto& mdl : _models ) {
_spotlightConstants.world = mdl->getXform().getWorld();
_spotlightConstants.xform = cameraViewProj * _spotlightConstants.world;
_spotlightConstantsBuffer->setData(sizeof(SpotlightConstants), &_spotlightConstants);
device->setVertexBuffer(mdl->getVertexBuffer());
if( mdl->getIndexBuffer() != nullptr ) {
device->setIndexBuffer(mdl->getIndexBuffer());
device->drawIndexed(ciri::PrimitiveTopology::TriangleList, mdl->getIndexBuffer()->getIndexCount());
} else {
device->drawArrays(ciri::PrimitiveTopology::TriangleList, mdl->getVertexBuffer()->getVertexCount(), 0);
}
}
break;
}
}
if( firstLight ) {
firstLight = false;
device->setBlendState(_additiveBlendState);
}
}
}
device->present();
}
inline void draw(const Pack & pack) {
drawArrays(pack.mode, pack.first, pack.count);
}
void operator () (GRegion *r)
{
if(!r->getVisibility()) return;
bool select = (_ctx->render_mode == drawContext::GMSH_SELECT &&
r->model() == GModel::current());
if(select) {
glPushName(3);
glPushName(r->tag());
}
drawArrays(_ctx, r, r->va_lines, GL_LINES, CTX::instance()->mesh.light &&
CTX::instance()->mesh.lightLines, CTX::instance()->mesh.volumesFaces,
CTX::instance()->color.mesh.line);
drawArrays(_ctx, r, r->va_triangles, GL_TRIANGLES, CTX::instance()->mesh.light);
if(CTX::instance()->mesh.volumesNum) {
if(CTX::instance()->mesh.tetrahedra)
drawElementLabels(_ctx, r, r->tetrahedra, CTX::instance()->mesh.volumesFaces ||
CTX::instance()->mesh.surfacesFaces,
CTX::instance()->color.mesh.line);
if(CTX::instance()->mesh.hexahedra)
drawElementLabels(_ctx, r, r->hexahedra, CTX::instance()->mesh.volumesFaces ||
CTX::instance()->mesh.surfacesFaces,
CTX::instance()->color.mesh.line);
if(CTX::instance()->mesh.prisms)
drawElementLabels(_ctx, r, r->prisms, CTX::instance()->mesh.volumesFaces ||
CTX::instance()->mesh.surfacesFaces,
CTX::instance()->color.mesh.line);
if(CTX::instance()->mesh.pyramids)
drawElementLabels(_ctx, r, r->pyramids, CTX::instance()->mesh.volumesFaces ||
CTX::instance()->mesh.surfacesFaces,
CTX::instance()->color.mesh.line);
drawElementLabels(_ctx, r, r->polyhedra, CTX::instance()->mesh.volumesFaces ||
CTX::instance()->mesh.surfacesFaces,
CTX::instance()->color.mesh.line);
}
if(CTX::instance()->mesh.points || CTX::instance()->mesh.pointsNum){
if(r->getAllElementsVisible())
drawVerticesPerEntity(_ctx, r);
else{
if(CTX::instance()->mesh.tetrahedra) drawVerticesPerElement(_ctx, r, r->tetrahedra);
if(CTX::instance()->mesh.hexahedra) drawVerticesPerElement(_ctx, r, r->hexahedra);
if(CTX::instance()->mesh.prisms) drawVerticesPerElement(_ctx, r, r->prisms);
if(CTX::instance()->mesh.pyramids) drawVerticesPerElement(_ctx, r, r->pyramids);
drawVerticesPerElement(_ctx, r, r->polyhedra);
}
}
if(CTX::instance()->mesh.dual) {
if(CTX::instance()->mesh.tetrahedra) drawBarycentricDual(r->tetrahedra);
if(CTX::instance()->mesh.hexahedra) drawBarycentricDual(r->hexahedra);
if(CTX::instance()->mesh.prisms) drawBarycentricDual(r->prisms);
if(CTX::instance()->mesh.pyramids) drawBarycentricDual(r->pyramids);
drawBarycentricDual(r->polyhedra);
}
if(CTX::instance()->mesh.voronoi) {
if(CTX::instance()->mesh.tetrahedra) drawVoronoiDual(r->tetrahedra);
}
if(select) {
glPopName();
glPopName();
}
}
void operator () (GFace *f)
{
if(!f->getVisibility()) {
if(f->getCompound()) {
if(!f->getCompound()->getVisibility()) return;
}
else
return;
}
bool select = (_ctx->render_mode == drawContext::GMSH_SELECT &&
f->model() == GModel::current());
if(select) {
glPushName(2);
glPushName(f->tag());
}
drawArrays(_ctx, f, f->va_lines, GL_LINES,
CTX::instance()->mesh.light && CTX::instance()->mesh.lightLines,
CTX::instance()->mesh.surfacesFaces, CTX::instance()->color.mesh.line);
drawArrays(_ctx, f, f->va_triangles, GL_TRIANGLES, CTX::instance()->mesh.light);
if(CTX::instance()->mesh.surfacesNum) {
if(CTX::instance()->mesh.triangles)
drawElementLabels(_ctx, f, f->triangles, CTX::instance()->mesh.surfacesFaces,
CTX::instance()->color.mesh.line);
if(CTX::instance()->mesh.quadrangles)
drawElementLabels(_ctx, f, f->quadrangles, CTX::instance()->mesh.surfacesFaces,
CTX::instance()->color.mesh.line);
drawElementLabels(_ctx, f, f->polygons, CTX::instance()->mesh.surfacesFaces,
CTX::instance()->color.mesh.line);
}
if(CTX::instance()->mesh.points || CTX::instance()->mesh.pointsNum){
if(f->getAllElementsVisible())
drawVerticesPerEntity(_ctx, f);
else{
if(CTX::instance()->mesh.triangles)
drawVerticesPerElement(_ctx, f, f->triangles);
if(CTX::instance()->mesh.quadrangles)
drawVerticesPerElement(_ctx, f, f->quadrangles);
drawVerticesPerElement(_ctx, f, f->polygons);
}
}
if(CTX::instance()->mesh.normals) {
if(CTX::instance()->mesh.triangles) drawNormals(_ctx, f->triangles);
if(CTX::instance()->mesh.quadrangles) drawNormals(_ctx, f->quadrangles);
drawNormals(_ctx, f->polygons);
}
if(CTX::instance()->mesh.dual) {
if(CTX::instance()->mesh.triangles) drawBarycentricDual(f->triangles);
if(CTX::instance()->mesh.quadrangles) drawBarycentricDual(f->quadrangles);
drawBarycentricDual(f->polygons);
}
else if(CTX::instance()->mesh.voronoi) {
if(CTX::instance()->mesh.triangles) drawVoronoiDual(f->triangles);
}
if(select) {
glPopName();
glPopName();
}
}
// Test a particular primitive mode
static bool
testPrim(GLenum mode, const GLfloat *verts, GLuint count)
{
GLfloat x, y;
GLuint facing, fill;
int drawMode;
bool pass = true;
// Loop over polygon mode: filled vs. outline
for (fill = 0; fill < 2; fill++) {
glPolygonMode(GL_FRONT_AND_BACK, fill ? GL_LINE : GL_FILL);
// Loop over drawing mode: glBegin/End vs glDrawArrays vs glDrawElements
for (drawMode = 0; drawMode < NUM_DRAW_MODES; drawMode++) {
// Loop over CW vs. CCW winding (should make no difference)
for (facing = 0; facing < 2; facing++) {
if (facing == 0) {
glFrontFace(GL_CCW);
glCullFace(GL_BACK);
}
else {
glFrontFace(GL_CW);
glCullFace(GL_FRONT);
}
// Position the geometry at 9 different locations to test
// clipping against the left, right, bottom and top edges of
// the window.
// Only the center location will be unclipped.
for (y = -1.0; y <= 1.0; y += 1.0) {
for (x = -1.0; x <= 1.0; x += 1.0) {
bool quad_pass;
GLfloat badColor[3];
glPushMatrix();
glTranslatef(x, y, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
switch (drawMode) {
case BEGIN_END:
drawBeginEnd(mode, verts, count);
break;
case DRAW_ARRAYS:
drawArrays(mode, verts, count);
break;
case DRAW_ELEMENTS:
drawElements(mode, verts, count);
break;
default:
assert(0);
}
glPopMatrix();
quad_pass = checkResult(badColor);
pass = pass && quad_pass;
reportSubtest(mode, drawMode, facing, fill,
badColor, x, y, quad_pass);
}
}
}
}
}
return pass;
}
