CODEWITHSUNDEEP
androidopengl-esblendingdepth-buffer
brohan322
brohan322

Reputation: 368

Hiding fragments in OpenGL

I am working with OpenGL-ES 3.0 in Android.

To simplify my issue, I am going to describe a scenario very similar to mine. Let's say that I have a sphere centered at the origin. Let's also say that I have another sphere centered at the origin, with a larger radius. Finally, let's say that I have a cylinder, and the center of the top face of the cylinder is lying on the origin. The cylinder intersects the two spheres. A picture of the scenario is below:

This is my initial setup: Initial Setup

I would like to only draw the section in between the two spheres, as shown below: Section in Between

However, in my application, the smaller of the two spheres isn't visible (though it exists). It is completely transparent. Thus, the final end product I would like would look something like this:

enter image description here

Now, one more piece of information: as I mentioned earlier, this is a simplification of my current scenario. Instead of spheres, I have far more complex objects (not simple primitive shapes). Thus, approaching this from a mathematical perspective (such as only drawing the portion of the cylinder that is greater than the smaller sphere's radius and less than the larger sphere's radius) is not going to work. I need to approach this somehow from a programming perspective (but given my limited knowledge of OpenGL, I can only think of Depth Testing and Blending as viable options)

Upvotes: 0

Views: 229

Answers (2)

Dickson
Dickson

Reputation: 221

You can probably do this using a stencil buffer.

I haven't compiled this code and it will need modifying, but this is the general idea:

glDisable( GL_STENCIL_TEST );

<Render rest of scene (everything other than the spheres and cylinder)>

// Render the larger sphere into the stencil buffer, setting stencil bits to 1

glEnable( GL_STENCIL_TEST );
glClear( GL_STENCIL_BUFFER_BIT ); 
glColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );  // Don't render into the color buffer
glDepthMask( GL_FALSE );    // Don't render into the depth buffer
glStencilMask( 0xff ); // Enable writing to stencil buffer
glStencilFunc( GL_ALWAYS, 1, 0xff );    // Write 1s into stencil buffer
glStencilOp( GL_KEEP, GL_KEEP, GL_REPLACE ); // Overwrite for every fragment that passes depth test (and stencil <- GL_ALWAYS)

<Render big sphere>

// Render the smaller sphere into the stencil buffer, setting stencil bits to 0 (it carves out the big sphere)

glStencilFunc( GL_ALWAYS, 0, 0xff );    // Write 0s into stencil buffer

<Render small sphere>

// Render the cylinder into the color buffer, only where the stencil bits are 1

glStencilMask( 0 ); // Don't need to write to stencil buffer
glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );  // Render into the color buffer
glStencilFunc( GL_EQUAL, 1, 0xff ); // Only render where there are 1s in the stencil buffer

<Render cylinder>

glDisable( GL_STENCIL_TEST );

// Now render the translucent big sphere using alpha blending

<Render big sphere>

Upvotes: 1

Jherico
Jherico

Reputation: 29240

What you are describing is Constructive Solid Geometry, but with the added complexity of using meshes as one of the primitive types.

Event with only mathematically simple primitives, it is very hard to implement CSG purely in the OpenGL pipeline because you would need to find a way to represent the scene graph in a way that the shaders can understand and efficiently parse. Once you add in meshes, it's basically impossible because the vertex and fragment shaders won't have easy access to the mesh geometry.

You might be able approximate it by executing a draw call for every item in the CGS graph and with clever manipulation of stencil and depth buffers, but you would probably still end up with lots of edge cases that didn't render properly.

Upvotes: 0

Related Questions