Exemple #1
0
void PixelNode::onDraw(const cocos2d::Mat4 &transform, uint32_t flags)
{

    auto glProgram = _programState->getGLProgram();
    glProgram->use();


    auto loc = glProgram->getUniformLocation("u_cbf_opacity");
    glProgram->setUniformLocationWith1f(loc, _opacityAsAlpha ? getOpacity()/255.f : 1.f);
    loc = glProgram->getUniformLocation("u_posexpand");
    glProgram->setUniformLocationWith1f(loc, _opacityAsPosExpand ? _posexpand*(1.f - getOpacity()/255.f) : 0.f);
    loc = glProgram->getUniformLocation("u_mixcolor");
    glProgram->setUniformLocationWith4fv(loc, &(_mixColor.x), 1);

    loc = glProgram->getUniformLocation("u_y_cut");
    glProgram->setUniformLocationWith1f(loc, _yCut);

    glProgram->setUniformsForBuiltins(transform);

    glBindBuffer(GL_ARRAY_BUFFER, _vbo);
    if (Configuration::getInstance()->supportsShareableVAO())
    {
        GL::bindVAO(_vao);
    }
    else
    {
        // TODO
    }

    if (_blend) {
        glEnable (GL_BLEND);
        glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    } else {
        glDisable(GL_BLEND);
    }

    glEnable(GL_CULL_FACE);
    // shadow cover打开depth test同时在fsh中对a为0的进行discard,以保证重合交叠处不会交叠而加深。
    glEnable(GL_DEPTH_TEST);
    glDepthMask(true);
    if (_stencil) {

        glEnable(GL_STENCIL_TEST);
        // Draw floor
        glStencilFunc(GL_ALWAYS, 1, 0xFF); // Set any stencil to 1
        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
        glStencilMask(0xFF); // Write to stencil buffer
        glDepthMask(GL_FALSE); // Don't write to depth buffer
        glClear(GL_STENCIL_BUFFER_BIT); // Clear stencil buffer (0 by default)
    }
    if (_stenciled) {

        glEnable(GL_STENCIL_TEST);
        glStencilFunc(GL_EQUAL, 1, 0xFF); // Pass test if stencil value is 1
        glStencilMask(0x00); // Don't write anything to stencil buffer
        glDepthMask(GL_TRUE); // Write to depth buffer
    }

    glDrawArrays(GL_TRIANGLES, 0, _count);


    if (Configuration::getInstance()->supportsShareableVAO())
    {
        GL::bindVAO(0);
    }
    glDisable(GL_STENCIL_TEST);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glDisable(GL_DEPTH_TEST);
    glDepthMask(false);
    glEnable (GL_BLEND);

    CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1,_count);
    CHECK_GL_ERROR_DEBUG();
}
Exemple #2
0
	void TestStage::onRender( float dFrame )
	{
		glDisable( GL_DEPTH_TEST );
		glDisable( GL_CULL_FACE );
		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
		glEnable( GL_STENCIL_TEST );

		GameWindow& window = Global::getDrawEngine()->getWindow();
		int w = window.getWidth();
		int h = window.getHeight();

	
		for ( LightList::iterator iter = lights.begin(), itEnd = lights.end();
			  iter != itEnd ; ++iter )
		{
			Light& light = *iter;

#if 1
			glColorMask(false, false, false, false);
			glStencilFunc(GL_ALWAYS, 1, 1);
			glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

			for( BlockList::iterator iter = blocks.begin(), itEnd = blocks.end();
				 iter != itEnd ; ++iter )
			{
				Block& block = *iter;
				renderPolyShadow( light , block.pos , block.getVertices() , block.getVertexNum() );
			}
			
			glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
			glStencilFunc(GL_EQUAL, 0, 1);
			glColorMask(true, true, true, true);
#endif

			glEnable(GL_BLEND);
			glBlendFunc(GL_ONE, GL_ONE);

			glUseProgram(program);

			glUniform2f( loc_lightLocation , light.pos.x , light.pos.y );
			glUniform3f( loc_lightColor , light.color.x , light.color.y , light.color.z );
			glUniform3f( loc_lightAttenuation , 0 , 1 / 5.0 , 0 );

			glBegin( GL_QUADS );
			glVertex2i( 0 , 0 );
			glVertex2i( w , 0 );
			glVertex2i( w , h );
			glVertex2i( 0 , h );
			glEnd();

			glUseProgram(0);
			glDisable(GL_BLEND);
			glClear(GL_STENCIL_BUFFER_BIT);
		}

		glDisable( GL_STENCIL_TEST );


		GLGraphics2D& g = ::Global::getDrawEngine()->getGLGraphics();

		g.beginRender();

		RenderUtility::setFont( g , FONT_S8 );
		FixString< 256 > str;
		Vec2i pos = Vec2i( 10 , 10 );
		g.drawText( pos , str.format( "Lights Num = %u" , lights.size() ) );

		g.endRender();
	}
Exemple #3
0
void test_stencil(void)
{
    GLint numStencilBits;
    GLuint stencilValues[NumTests] = {
        0x7, // Result of test 0
        0x0, // Result of test 1
        0x2, // Result of test 2
        0xff // Result of test 3.  We need to fill this value in a run-time
    };
    int i;

    RD_START("stencil", "");

    display = get_display();

    /* get an appropriate EGL frame buffer configuration */
    ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config));
    DEBUG_MSG("num_config: %d", num_config);

    /* create an EGL rendering context */
    ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list));

    surface = make_window(display, config, 400, 240);

    ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width));
    ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height));

    DEBUG_MSG("Buffer: %dx%d", width, height);

    /* connect the context to the surface */
    ECHK(eglMakeCurrent(display, surface, surface, context));

    program = get_program(vertex_shader_source, fragment_shader_source);

    GCHK(glBindAttribLocation(program, 0, "aPosition"));

    link_program(program);

    /* now set up our uniform. */
    GCHK(uniform_location = glGetUniformLocation(program, "uColor"));

    GCHK(glClearColor(0.0, 0.0, 0.0, 0.0));
    GCHK(glClearStencil(0x1));
    GCHK(glClearDepthf(0.75));

    GCHK(glEnable(GL_DEPTH_TEST));
    GCHK(glEnable(GL_STENCIL_TEST));

    // Set the viewport
    GCHK(glViewport(0, 0, width, height));

    // Clear the color, depth, and stencil buffers.  At this
    //   point, the stencil buffer will be 0x1 for all pixels
    GCHK(glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT));

    // Use the program object
    GCHK(glUseProgram(program));

    // Load the vertex position
    GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices));

    GCHK(glEnableVertexAttribArray(0));

    // Test 0:
    //
    // Initialize upper-left region.  In this case, the
    //   stencil-buffer values will be replaced because the
    //   stencil test for the rendered pixels will fail the
    //   stencil test, which is
    //
    //        ref   mask   stencil  mask
    //      ( 0x7 & 0x3 ) < ( 0x1 & 0x7 )
    //
    //   The value in the stencil buffer for these pixels will
    //   be 0x7.
    //
    GCHK(glStencilFunc(GL_LESS, 0x7, 0x3));
    GCHK(glStencilOp(GL_REPLACE, GL_DECR, GL_DECR));
    GCHK(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[0]));

    // Test 1:
    //
    // Initialize the upper-right region.  Here, we'll decrement
    //   the stencil-buffer values where the stencil test passes
    //   but the depth test fails.  The stencil test is
    //
    //        ref  mask    stencil  mask
    //      ( 0x3 & 0x3 ) > ( 0x1 & 0x3 )
    //
    //    but where the geometry fails the depth test.  The
    //    stencil values for these pixels will be 0x0.
    //
    GCHK(glStencilFunc(GL_GREATER, 0x3, 0x3));
    GCHK(glStencilOp(GL_KEEP, GL_DECR, GL_KEEP));
    GCHK(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[1]));

    // Test 2:
    //
    // Initialize the lower-left region.  Here we'll increment
    //   (with saturation) the stencil value where both the
    //   stencil and depth tests pass.  The stencil test for
    //   these pixels will be
    //
    //        ref  mask     stencil  mask
    //      ( 0x1 & 0x3 ) == ( 0x1 & 0x3 )
    //
    //   The stencil values for these pixels will be 0x2.
    //
    GCHK(glStencilFunc(GL_EQUAL, 0x1, 0x3));
    GCHK(glStencilOp(GL_KEEP, GL_INCR, GL_INCR));
    GCHK(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[2]));

    // Test 3:
    //
    // Finally, initialize the lower-right region.  We'll invert
    //   the stencil value where the stencil tests fails.  The
    //   stencil test for these pixels will be
    //
    //        ref   mask    stencil  mask
    //      ( 0x2 & 0x1 ) == ( 0x1 & 0x1 )
    //
    //   The stencil value here will be set to ~((2^s-1) & 0x1),
    //   (with the 0x1 being from the stencil clear value),
    //   where 's' is the number of bits in the stencil buffer
    //
    GCHK(glStencilFunc(GL_EQUAL, 0x2, 0x1));
    GCHK(glStencilOp(GL_INVERT, GL_KEEP, GL_KEEP));
    GCHK(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[3]));

    // Since we don't know at compile time how many stencil bits are present,
    //   we'll query, and update the value correct value in the
    //   stencilValues arrays for the fourth tests.  We'll use this value
    //   later in rendering.
    GCHK(glGetIntegerv(GL_STENCIL_BITS, &numStencilBits));

    stencilValues[3] = ~(((1 << numStencilBits) - 1) & 0x1) & 0xff;

    // Use the stencil buffer for controlling where rendering will
    //   occur.  We disable writing to the stencil buffer so we
    //   can test against them without modifying the values we
    //   generated.
    GCHK(glStencilMask(0x0));

    for (i = 0; i < NumTests; i++) {
        GCHK(glStencilFunc(GL_EQUAL, stencilValues[i], 0xff));
        GCHK(glUniform4fv(uniform_location, 1, colors[i]));
        GCHK(glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices[4]));
    }

    ECHK(eglSwapBuffers(display, surface));
    GCHK(glFlush());

    ECHK(eglDestroySurface(display, surface));

    usleep(1000000);

    dump_bmp(display, surface, "stencil.bmp");

    ECHK(eglTerminate(display));

    RD_END();
}
Exemple #4
0
void GLGSRender::begin()
{
	rsx::thread::begin();

	if (skip_frame)
		return;

	if (conditional_render_enabled && conditional_render_test_failed)
		return;

	init_buffers();

	if (!framebuffer_status_valid)
		return;

	std::chrono::time_point<steady_clock> then = steady_clock::now();

	bool color_mask_b = rsx::method_registers.color_mask_b();
	bool color_mask_g = rsx::method_registers.color_mask_g();
	bool color_mask_r = rsx::method_registers.color_mask_r();
	bool color_mask_a = rsx::method_registers.color_mask_a();

	gl_state.color_mask(color_mask_r, color_mask_g, color_mask_b, color_mask_a);
	gl_state.depth_mask(rsx::method_registers.depth_write_enabled());
	gl_state.stencil_mask(rsx::method_registers.stencil_mask());

	if (gl_state.enable(rsx::method_registers.depth_test_enabled(), GL_DEPTH_TEST))
	{
		gl_state.depth_func(comparison_op(rsx::method_registers.depth_func()));

		float range_near = rsx::method_registers.clip_min();
		float range_far = rsx::method_registers.clip_max();

		if (g_cfg.video.strict_rendering_mode)
			gl_state.depth_range(range_near, range_far);
		else
		{
			//Workaround to preserve depth precision but respect z direction
			//Ni no Kuni sets a very restricted z range (0.9x - 1.) and depth reads / tests are broken
			if (range_near <= range_far)
				gl_state.depth_range(0.f, 1.f);
			else
				gl_state.depth_range(1.f, 0.f);
		}
	}

	if (glDepthBoundsEXT && (gl_state.enable(rsx::method_registers.depth_bounds_test_enabled(), GL_DEPTH_BOUNDS_TEST_EXT)))
	{
		gl_state.depth_bounds(rsx::method_registers.depth_bounds_min(), rsx::method_registers.depth_bounds_max());
	}

	gl_state.enable(rsx::method_registers.dither_enabled(), GL_DITHER);

	if (gl_state.enable(rsx::method_registers.blend_enabled(), GL_BLEND))
	{
		glBlendFuncSeparate(blend_factor(rsx::method_registers.blend_func_sfactor_rgb()),
			blend_factor(rsx::method_registers.blend_func_dfactor_rgb()),
			blend_factor(rsx::method_registers.blend_func_sfactor_a()),
			blend_factor(rsx::method_registers.blend_func_dfactor_a()));

		auto blend_colors = rsx::get_constant_blend_colors();
		glBlendColor(blend_colors[0], blend_colors[1], blend_colors[2], blend_colors[3]);

		glBlendEquationSeparate(blend_equation(rsx::method_registers.blend_equation_rgb()),
			blend_equation(rsx::method_registers.blend_equation_a()));
	}

	if (gl_state.enable(rsx::method_registers.stencil_test_enabled(), GL_STENCIL_TEST))
	{
		glStencilFunc(comparison_op(rsx::method_registers.stencil_func()),
			rsx::method_registers.stencil_func_ref(),
			rsx::method_registers.stencil_func_mask());

		glStencilOp(stencil_op(rsx::method_registers.stencil_op_fail()), stencil_op(rsx::method_registers.stencil_op_zfail()),
			stencil_op(rsx::method_registers.stencil_op_zpass()));

		if (rsx::method_registers.two_sided_stencil_test_enabled())
		{
			glStencilMaskSeparate(GL_BACK, rsx::method_registers.back_stencil_mask());

			glStencilFuncSeparate(GL_BACK, comparison_op(rsx::method_registers.back_stencil_func()),
				rsx::method_registers.back_stencil_func_ref(), rsx::method_registers.back_stencil_func_mask());

			glStencilOpSeparate(GL_BACK, stencil_op(rsx::method_registers.back_stencil_op_fail()),
				stencil_op(rsx::method_registers.back_stencil_op_zfail()), stencil_op(rsx::method_registers.back_stencil_op_zpass()));
		}
	}

	gl_state.enablei(rsx::method_registers.blend_enabled_surface_1(), GL_BLEND, 1);
	gl_state.enablei(rsx::method_registers.blend_enabled_surface_2(), GL_BLEND, 2);
	gl_state.enablei(rsx::method_registers.blend_enabled_surface_3(), GL_BLEND, 3);

	if (gl_state.enable(rsx::method_registers.logic_op_enabled(), GL_COLOR_LOGIC_OP))
	{
		gl_state.logic_op(logic_op(rsx::method_registers.logic_operation()));
	}

	gl_state.line_width(rsx::method_registers.line_width());
	gl_state.enable(rsx::method_registers.line_smooth_enabled(), GL_LINE_SMOOTH);

	gl_state.enable(rsx::method_registers.poly_offset_point_enabled(), GL_POLYGON_OFFSET_POINT);
	gl_state.enable(rsx::method_registers.poly_offset_line_enabled(), GL_POLYGON_OFFSET_LINE);
	gl_state.enable(rsx::method_registers.poly_offset_fill_enabled(), GL_POLYGON_OFFSET_FILL);

	gl_state.polygon_offset(rsx::method_registers.poly_offset_scale(), rsx::method_registers.poly_offset_bias());

	if (gl_state.enable(rsx::method_registers.cull_face_enabled(), GL_CULL_FACE))
	{
		gl_state.cull_face(cull_face(rsx::method_registers.cull_face_mode()));
	}

	gl_state.front_face(front_face(rsx::method_registers.front_face_mode()));

	//TODO
	//NV4097_SET_ANISO_SPREAD
	//NV4097_SET_SPECULAR_ENABLE
	//NV4097_SET_TWO_SIDE_LIGHT_EN
	//NV4097_SET_FLAT_SHADE_OP
	//NV4097_SET_EDGE_FLAG



	//NV4097_SET_COLOR_KEY_COLOR
	//NV4097_SET_SHADER_CONTROL
	//NV4097_SET_ZMIN_MAX_CONTROL
	//NV4097_SET_ANTI_ALIASING_CONTROL
	//NV4097_SET_CLIP_ID_TEST_ENABLE

	std::chrono::time_point<steady_clock> now = steady_clock::now();
	m_begin_time += (u32)std::chrono::duration_cast<std::chrono::microseconds>(now - then).count();
}
// Inherited from BatchRenderer
void SceneObject_Decal_BatchRenderer::Execute()
{
	if(!GetScene()->m_renderingDeferred)
		return;

	glEnable(GL_STENCIL_TEST);
	glClearStencil(0);
	glClear(GL_STENCIL_BUFFER_BIT);

	glDepthFunc(GL_LEQUAL);
	
	glDepthMask(false);

	glEnable(GL_POLYGON_OFFSET_FILL);
	
	for(unsigned int i = 0, numDecals = m_pDecals.size(); i < numDecals;)
	{
		// Stencil in batches of 8
		glColorMask(false, false, false, false);
		Shader::Unbind();

		glPolygonOffset(2.0f, 2.0f);

		// Mark parts where depth test fails
		glStencilFunc(GL_ALWAYS, 0xff, 0xff);
		glStencilOp(GL_KEEP, GL_REPLACE, GL_KEEP);

		unsigned int firstDecalInBatchIndex = i;

		// Stencil out regions with stencil mask
		for(unsigned int j = 0; j < 8 && i < numDecals; j++, i++)
		{
			glStencilMask(m_decalIndices[j]);
			m_pDecals[i]->Render_Batch_NoTexture();
		}

		glColorMask(true, true, true, true);

		// Stencil test
		glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
	
		glPolygonOffset(-2.0f, -2.0f);

		// Re-render, second pass
		i = firstDecalInBatchIndex;

		GetScene()->RebindGBufferRenderShader();

		for(unsigned int j = 0; j < 8 && i < numDecals; j++, i++)
		{
			glStencilFunc(GL_EQUAL, 0xff, m_decalIndices[j]);

			m_pDecals[i]->Render_Batch_Textured();
		}

		glClear(GL_STENCIL_BUFFER_BIT);
	}

	GetScene()->SetCurrentGBufferRenderShader(Scene::e_plain);

	glDisable(GL_POLYGON_OFFSET_FILL);
	glDepthMask(true);

	glDepthFunc(GL_LESS);

	glDisable(GL_STENCIL_TEST);
}
QSGRenderer::ClipType QSGRenderer::updateStencilClip(const QSGClipNode *clip)
{
    if (!clip) {
        glDisable(GL_STENCIL_TEST);
        glDisable(GL_SCISSOR_TEST);
        return NoClip;
    }

    ClipType clipType = NoClip;

    glDisable(GL_SCISSOR_TEST);

    m_current_stencil_value = 0;
    m_current_scissor_rect = QRect();
    while (clip) {
        QMatrix4x4 m = m_current_projection_matrix;
        if (clip->matrix())
            m *= *clip->matrix();

        // TODO: Check for multisampling and pixel grid alignment.
        bool isRectangleWithNoPerspective = clip->isRectangular()
                && qFuzzyIsNull(m(3, 0)) && qFuzzyIsNull(m(3, 1));
        bool noRotate = qFuzzyIsNull(m(0, 1)) && qFuzzyIsNull(m(1, 0));
        bool isRotate90 = qFuzzyIsNull(m(0, 0)) && qFuzzyIsNull(m(1, 1));

        if (isRectangleWithNoPerspective && (noRotate || isRotate90)) {
            QRectF bbox = clip->clipRect();
            qreal invW = 1 / m(3, 3);
            qreal fx1, fy1, fx2, fy2;
            if (noRotate) {
                fx1 = (bbox.left() * m(0, 0) + m(0, 3)) * invW;
                fy1 = (bbox.bottom() * m(1, 1) + m(1, 3)) * invW;
                fx2 = (bbox.right() * m(0, 0) + m(0, 3)) * invW;
                fy2 = (bbox.top() * m(1, 1) + m(1, 3)) * invW;
            } else {
                Q_ASSERT(isRotate90);
                fx1 = (bbox.bottom() * m(0, 1) + m(0, 3)) * invW;
                fy1 = (bbox.left() * m(1, 0) + m(1, 3)) * invW;
                fx2 = (bbox.top() * m(0, 1) + m(0, 3)) * invW;
                fy2 = (bbox.right() * m(1, 0) + m(1, 3)) * invW;
            }

            if (fx1 > fx2)
                qSwap(fx1, fx2);
            if (fy1 > fy2)
                qSwap(fy1, fy2);

            GLint ix1 = qRound((fx1 + 1) * m_device_rect.width() * qreal(0.5));
            GLint iy1 = qRound((fy1 + 1) * m_device_rect.height() * qreal(0.5));
            GLint ix2 = qRound((fx2 + 1) * m_device_rect.width() * qreal(0.5));
            GLint iy2 = qRound((fy2 + 1) * m_device_rect.height() * qreal(0.5));

            if (!(clipType & ScissorClip)) {
                m_current_scissor_rect = QRect(ix1, iy1, ix2 - ix1, iy2 - iy1);
                glEnable(GL_SCISSOR_TEST);
                clipType |= ScissorClip;
            } else {
                m_current_scissor_rect &= QRect(ix1, iy1, ix2 - ix1, iy2 - iy1);
            }
            glScissor(m_current_scissor_rect.x(), m_current_scissor_rect.y(),
                      m_current_scissor_rect.width(), m_current_scissor_rect.height());
        } else {
            if (!(clipType & StencilClip)) {
                if (!m_clip_program.isLinked()) {
                    m_clip_program.addShaderFromSourceCode(QOpenGLShader::Vertex,
                        "attribute highp vec4 vCoord;       \n"
                        "uniform highp mat4 matrix;         \n"
                        "void main() {                      \n"
                        "    gl_Position = matrix * vCoord; \n"
                        "}");
                    m_clip_program.addShaderFromSourceCode(QOpenGLShader::Fragment,
                        "void main() {                                   \n"
                        "    gl_FragColor = vec4(0.81, 0.83, 0.12, 1.0); \n" // Trolltech green ftw!
                        "}");
                    m_clip_program.bindAttributeLocation("vCoord", 0);
                    m_clip_program.link();
                    m_clip_matrix_id = m_clip_program.uniformLocation("matrix");
                }

                glClearStencil(0);
                glClear(GL_STENCIL_BUFFER_BIT);
                glEnable(GL_STENCIL_TEST);
                glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
                glDepthMask(GL_FALSE);

                if (m_vertex_buffer_bound) {
                    glBindBuffer(GL_ARRAY_BUFFER, 0);
                    m_vertex_buffer_bound = false;
                }
                if (m_index_buffer_bound) {
                    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
                    m_index_buffer_bound = false;
                }

                m_clip_program.bind();
                m_clip_program.enableAttributeArray(0);

                clipType |= StencilClip;
            }

            glStencilFunc(GL_EQUAL, m_current_stencil_value, 0xff); // stencil test, ref, test mask
            glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); // stencil fail, z fail, z pass

            const QSGGeometry *g = clip->geometry();
            Q_ASSERT(g->attributeCount() > 0);
            const QSGGeometry::Attribute *a = g->attributes();
            glVertexAttribPointer(0, a->tupleSize, a->type, GL_FALSE, g->sizeOfVertex(), g->vertexData());

            m_clip_program.setUniformValue(m_clip_matrix_id, m);
            if (g->indexCount()) {
                glDrawElements(g->drawingMode(), g->indexCount(), g->indexType(), g->indexData());
            } else {
                glDrawArrays(g->drawingMode(), 0, g->vertexCount());
            }

            ++m_current_stencil_value;
        }

        clip = clip->clipList();
    }

    if (clipType & StencilClip) {
        m_clip_program.disableAttributeArray(0);
        glStencilFunc(GL_EQUAL, m_current_stencil_value, 0xff); // stencil test, ref, test mask
        glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); // stencil fail, z fail, z pass
        bindable()->reactivate();
    } else {
        glDisable(GL_STENCIL_TEST);
    }

    return clipType;
}
Exemple #7
0
void TextWidget::draw(const glm::mat4 &projection) {
    bool should_hover = (_hover_on && _hovering);
    if (_background_on || should_hover) {
        glm::mat4 bg_mvp = projection * _bg_model;
        glm::vec4 color = should_hover ? _hover_color : _background_color;
        gui_window->fill_rect(color, bg_mvp);
    }

    if (_icon_img) {
        glm::mat4 icon_mvp = projection * _icon_model;
        gui->draw_image(gui_window, _icon_img, icon_mvp);
    }

    glm::mat4 label_mvp = projection * _label_model;
    if (_text_interaction_on) {
        if (_placeholder_label.text().length() > 0 && _label.text().length() == 0)
            _placeholder_label.draw(label_mvp, _placeholder_color);
    }

    glEnable(GL_STENCIL_TEST);

    glStencilFunc(GL_ALWAYS, 1, 0xFF);
    glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
    glStencilMask(0xFF);

    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
    glClear(GL_STENCIL_BUFFER_BIT);

    gui_window->fill_rect(glm::vec4(1.0f, 1.0f, 1.0f, 1.0f),
            left + label_start_x(), top + label_start_y(),
            label_area_width(), _label.height());

    glStencilFunc(GL_EQUAL, 1, 0xFF);
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

    _label.draw(label_mvp, _text_color);

    glStencilFunc(GL_ALWAYS, 1, 0xFF);
    glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
    glStencilMask(0xFF);

    glClear(GL_STENCIL_BUFFER_BIT);

    if (_text_interaction_on && _have_focus && _cursor_start != -1 && _cursor_end != -1) {
        if (_cursor_start == _cursor_end) {
            // draw cursor
            glm::mat4 cursor_mvp = projection * _cursor_model;
            gui_window->fill_rect(_selection_color, cursor_mvp);
        } else {

            // draw selection rectangle
            glm::mat4 sel_mvp = projection * _sel_model;
            gui_window->fill_rect(_selection_color, sel_mvp);

            glStencilFunc(GL_EQUAL, 1, 0xFF);
            glStencilMask(0x00);

            _label.draw(label_mvp, _sel_text_color);
        }
    }

    glDisable(GL_STENCIL_TEST);

}
Exemple #8
0
M(void, glStencilFunc, jint func, jint ref, jint mask) {
	glStencilFunc(func, ref, mask);
}
void display(){


  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

  glViewport(0, 0, glwidth, glheight);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  gluPerspective(1.5, (double)glwidth / (double)glheight, 1.0, 1000.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  gluLookAt(150.0,100.0,-200.0, 
	    0.0,0.0,0.0, 
	    0.0,1.0,0.0); 

  glMultMatrixd(Rotate);

  glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, gold_diff);

  glPushMatrix();
  glTranslated(sin(t),cos(t),-3.);
  glRotatef(90, 1.0f, 0.0f, 0.0f);
  glutSolidSphere(.3,20,20);
  glPopMatrix();

  glutSolidSphere(1.5,20,20);

  glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);

  glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, red_light);

  if(!colormask_on){
    glColorMask(0,0,0,0);
    glDepthMask(0);
  }

  glEnable(GL_CULL_FACE);
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_STENCIL_TEST);

  glStencilMask(~0);

  if(frontcull){

    glCullFace(GL_FRONT);
    glStencilFunc(GL_ALWAYS, 1, ~0);

    glStencilOp(GL_REPLACE, GL_KEEP, GL_REPLACE);
    /* glStencilOp(GL_KEEP, GL_KEEP, GL_INCR); */
    /* glStencilOp(GL_KEEP, GL_INCR, GL_KEEP); */

    glPushMatrix();
    glTranslated(sin(t),cos(t),-3);
    glRotatef(90, 1.0f, 0.0f, 0.0f);
    /* glRotatef(90, 0.0f, 0.0f, 1.0f); */
    cylinder(.3,100,20);
    glPopMatrix();
  }

  if(backcull){

    glCullFace(GL_BACK);
    glStencilFunc(GL_ALWAYS, 1, ~0);

    glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
    /* glStencilOp(GL_KEEP, GL_DECR, GL_KEEP); */

    glPushMatrix();
    glTranslated(sin(t),cos(t),-3.);
    glRotatef(90, 1.0f, 0.0f, 0.0f);
    /* glRotatef(90, 0.0f, 0.0f, 1.0f); */
    cylinder(.3,100,20);
    glPopMatrix();
  }

  glDisable(GL_CULL_FACE);
  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  glDepthMask(GL_TRUE);

  glStencilFunc(GL_EQUAL, 1, ~0);
  glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

  glDisable(GL_DEPTH_TEST);
  glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,black_light);
  glBegin(GL_QUADS);
  glVertex2i(-10, -10);
  glVertex2i(-10, 10);
  glVertex2i(10, 10);
  glVertex2i(10, -10);
  glEnd();
  glEnable(GL_DEPTH_TEST);

  /* glEnable(GL_DEPTH_TEST); */
  glDisable(GL_STENCIL_TEST);

  console();

  t+=1e-2;
  glFinish();
  glutSwapBuffers();

}
Exemple #10
0
void MapRenderer::draw(GameWorld* world, const MapInfo& mi)
{
	renderer->pushDebugGroup("Map");
	renderer->useProgram(rectProg);

	// World out the number of units per tile
	glm::vec2 worldSize(GAME_MAP_SIZE);
	const int mapBlockLine = 8;
	glm::vec2 tileSize = worldSize / (float)mapBlockLine;
	// Determine the scale to show the right number of world units on the screen
	float worldScale = mi.screenSize / mi.worldSize;

	auto proj = renderer->get2DProjection();
	glm::mat4 view, model;
	renderer->setUniform(rectProg, "proj", proj);
	renderer->setUniform(rectProg, "model", glm::mat4());
	renderer->setUniform(rectProg, "colour", glm::vec4(0.f, 0.f, 0.f, 1.f));

	view = glm::translate(view, glm::vec3(mi.screenPosition, 0.f));

	if (mi.clipToSize)
	{
		glBindVertexArray( circle.getVAOName() );
		glBindTexture(GL_TEXTURE_2D, 0);
		glm::mat4 circleView = glm::scale(view, glm::vec3(mi.screenSize));
		renderer->setUniform(rectProg, "view", circleView);
		glEnable(GL_STENCIL_TEST);
		glStencilFunc(GL_ALWAYS, 1, 0xFF);
		glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
		glStencilMask(0xFF);
		glColorMask(0x00, 0x00, 0x00, 0x00);
		glDrawArrays(GL_TRIANGLE_FAN, 0, 182);
		glColorMask(0xFF, 0xFF, 0xFF, 0xFF);
		glStencilFunc(GL_EQUAL, 1, 0xFF);
	}

	view = glm::scale(view, glm::vec3(worldScale));
	view = glm::rotate(view, mi.rotation, glm::vec3(0.f, 0.f, 1.f));
	view = glm::translate(view, glm::vec3(glm::vec2(-1.f, 1.f) * mi.worldCenter, 0.f));
	renderer->setUniform(rectProg, "view", view);

	glBindVertexArray( rect.getVAOName() );
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, 0);

	// radar00 = -x, +y
	// incrementing in X, then Y
	
	int initX = -(mapBlockLine/2);
	int initY = -(mapBlockLine/2);

	for( int m = 0; m < MAP_BLOCK_SIZE; ++m )
	{
		std::string num = (m < 10 ? "0" : "");
		std::string name = "radar" + num +  std::to_string(m);
		auto texture = world->data->textures[{name,""}];
		
		glBindTexture(GL_TEXTURE_2D, texture->getName());
		
		int mX = initX + (m % mapBlockLine);
		int mY = initY + (m / mapBlockLine);
		
		auto tc = glm::vec2(mX, mY) * tileSize + glm::vec2(tileSize/2.f);
		
		glm::mat4 tilemodel = model;
		tilemodel = glm::translate( tilemodel, glm::vec3( tc, 0.f ) );
		tilemodel = glm::scale( tilemodel, glm::vec3( tileSize, 1.f ) );
		
		renderer->setUniform(rectProg, "model", tilemodel);
		
		glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
	}

	// From here on out we will work in screenspace
	renderer->setUniform(rectProg, "view", glm::mat4());

	if (mi.clipToSize) {
		glDisable(GL_STENCIL_TEST);
		// We only need the outer ring if we're clipping.
		glBlendFuncSeparate(GL_DST_COLOR, GL_ZERO, GL_ONE, GL_ZERO);
		TextureData::Handle radarDisc = data->findTexture("radardisc");

		glm::mat4 model;
		model = glm::translate(model, glm::vec3(mi.screenPosition, 0.0f));
		model = glm::scale(model, glm::vec3(mi.screenSize*1.07));
		renderer->setUniform(rectProg, "model", model);
		glBindTexture(GL_TEXTURE_2D, radarDisc->getName());
		glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
		glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
	}
	
	for(auto& blip : world->state->radarBlips)
	{
		glm::vec2 blippos( blip.second.coord );
		if( blip.second.target > 0 )
		{
			GameObject* object = nullptr;
			switch( blip.second.type ) {
				case BlipData::Vehicle:
					object = world->vehiclePool.find(blip.second.target);
					break;
				case BlipData::Character:
					object = world->pedestrianPool.find(blip.second.target);
					break;
				case BlipData::Pickup:
					object = world->pickupPool.find(blip.second.target);
					break;
				default: break;
			}
			if( object )
			{
				blippos = glm::vec2( object->getPosition() );
			}
		}
		
		drawBlip(blippos, view, mi, blip.second.texture);
	}
	
	// Draw the player blip
	auto player = world->pedestrianPool.find(world->state->playerObject);
	if( player )
	{
		glm::vec2 plyblip(player->getPosition());
		float hdg = glm::roll(player->getRotation());
		drawBlip(plyblip, view, mi, "radar_centre", mi.rotation - hdg);
	}

	drawBlip(mi.worldCenter + glm::vec2(0.f, mi.worldSize), view, mi, "radar_north", 0.f, 24.f);

	glBindVertexArray( 0 );
	glBindTexture(GL_TEXTURE_2D, 0);
	glUseProgram(0);
	
	/// @TODO migrate to using the renderer
	renderer->invalidate();
	renderer->popDebugGroup();
}
Exemple #11
0
static void new_ship(ModeInfo *mi)
{
  commander_conf *cp = &commander[MI_SCREEN(mi)];
  int i;
  GLfloat *this_v;
  GLint *p;
  /*GLfloat *this_n;*/
  int count;
#if 0
  int wire = MI_IS_WIREFRAME(mi);

  GLfloat bcolor[4] = {0.2, 0.2, 0.2, 0.2};
  GLfloat bspec[4]  = {0.1, 0.1, 0.1, 0.1};
  GLfloat bshiny    = 32.0;
  GLfloat pos[4] = {-8.0, -8.0, -16.0, 0.0}; /* -6 -6 -16 */
  GLfloat amb[4] = {0.2, 0.2, 0.2, 0.4};
  GLfloat dif[4] = {0.2, 0.2, 0.2, 0.2};
  GLfloat spc[4] = {0.0, 0.0, 0.0, 0.0};

	if(!wire) {
		glEnable(GL_LIGHTING);
		glEnable(GL_LIGHT0);

		glLightfv(GL_LIGHT0, GL_POSITION, pos);
		glLightfv(GL_LIGHT0, GL_AMBIENT,  amb);
		glLightfv(GL_LIGHT0, GL_DIFFUSE,  dif);
		glLightfv(GL_LIGHT0, GL_SPECULAR, spc);

		glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, bcolor);
		glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, bspec);
		glMateriali  (GL_FRONT_AND_BACK, GL_SHININESS, bshiny);
	}
#endif

  cp->list = glGenLists(1);
  glNewList(cp->list, GL_COMPILE);
  if(MI_IS_MONO(mi)) {
    /* FIXME support mono display */
    abort();
  }

	/* wireframe strategy: use stencil buffer, not polygon offset,
	 * because it's impossible to get the right parameters for
	 * glPolygonOffset() reliably */
  
	/* hidden-line removal as per
	 * http://glprogramming.com/red/chapter14.html#name16
	 */

	/* TODO:
		 - reinstate choice of wireframe vs filled
		 - rationalise some of the duplicated code below
	 */

	glEnable(GL_STENCIL_TEST);
	glEnable(GL_DEPTH_TEST);
	glClear(GL_STENCIL_BUFFER_BIT);
	glStencilFunc(GL_ALWAYS, 0, 1);
	glStencilOp(GL_INVERT, GL_INVERT, GL_INVERT);

	glColor3f(1.0, 1.0, 1.0);

	p=ship_f[cp->which];
	this_v=ship_v[cp->which];

	/* for debugging - draw axes */
#if 0
	glLineWidth(1); 
	glBegin(GL_LINES); glVertex3f(0,0,0); glVertex3f(10,0,0); glEnd();
	glBegin(GL_LINES); glVertex3f(0,0,0); glVertex3f(0,10,0); glEnd();
	glBegin(GL_LINES); glVertex3f(0.1,0,0); glVertex3f(0.1,10,0); glEnd();
	glBegin(GL_LINES); glVertex3f(0,0,0); glVertex3f(0,0,10); glEnd();
	glBegin(GL_LINES); glVertex3f(0,0.1,0); glVertex3f(0,0.1,10); glEnd();
	glBegin(GL_LINES); glVertex3f(0,0.2,0); glVertex3f(0,0.2,10); glEnd();
#endif

	/* draw the wireframe shape */
	while(*p != 0) {
		count=*p; p++;

		/* draw outline polygon */

		if(count==1) { glBegin(GL_POINTS); }
		else if(count==2) {
			/* chunky lines :-) */
			glLineWidth(2); 
			glBegin(GL_LINES);
		}
		else {
			glLineWidth(2); 
			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
			glBegin(GL_POLYGON); 
			do_normal(this_v[p[0]*3], this_v[p[0]*3+1], this_v[p[0]*3+2],
				this_v[p[1]*3], this_v[p[1]*3+1], this_v[p[1]*3+2],
				this_v[p[2]*3], this_v[p[2]*3+1], this_v[p[2]*3+2]);
		}
		for (i = 0 ; i < count ; i++) {
			glVertex3f(this_v[p[i]*3], this_v[p[i]*3+1], this_v[p[i]*3+2]);
		}
		glEnd();

		glColor3f(0.0, 0.0, 0.0);

		glStencilFunc(GL_EQUAL, 0, 1);
		glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

		/* draw filled polygon */

		if(count>=3) {
			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
			glBegin(GL_POLYGON); 
			do_normal(this_v[p[0]*3], this_v[p[0]*3+1], this_v[p[0]*3+2],
				this_v[p[1]*3], this_v[p[1]*3+1], this_v[p[1]*3+2],
				this_v[p[2]*3], this_v[p[2]*3+1], this_v[p[2]*3+2]);
			for (i = 0 ; i < count ; i++) {
				glVertex3f(this_v[p[i]*3], this_v[p[i]*3+1], this_v[p[i]*3+2]);
			}
			glEnd();
		}

		glColor3f(1.0, 1.0, 1.0);

		glStencilFunc(GL_ALWAYS, 0, 1);
		glStencilOp(GL_INVERT, GL_INVERT, GL_INVERT);

		/* draw outline polygon */

		if(count==1) { glBegin(GL_POINTS); }
		else if(count==2) {
			/* chunky lines :-) */
			glLineWidth(2); 
			glBegin(GL_LINES);
		}
		else {
			glLineWidth(2); 
			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
			glBegin(GL_POLYGON); 
			do_normal(this_v[p[0]*3], this_v[p[0]*3+1], this_v[p[0]*3+2],
				this_v[p[1]*3], this_v[p[1]*3+1], this_v[p[1]*3+2],
				this_v[p[2]*3], this_v[p[2]*3+1], this_v[p[2]*3+2]);
		}
		for (i = 0 ; i < count ; i++) {
			glVertex3f(this_v[p[i]*3], this_v[p[i]*3+1], this_v[p[i]*3+2]);
		}
		glEnd();

		cp->npoints++;
		p+=count;
	}

  glEndList();
}
void RawStencilBufferTest::setupStencilForDrawingOnPlane(GLint plane)
{
    GLint planeMask = 0x1 << plane;
    glStencilFunc(GL_EQUAL, planeMask, planeMask);
    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
}
Exemple #13
0
static void pie_DrawShadows(void)
{
	const float width = pie_GetVideoBufferWidth();
	const float height = pie_GetVideoBufferHeight();
	GLenum op_depth_pass_front = GL_INCR, op_depth_pass_back = GL_DECR;

	pie_SetTexturePage(TEXPAGE_NONE);

	glPushMatrix();

	pie_SetAlphaTest(false);
	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
	glDepthFunc(GL_LESS);
	glDepthMask(GL_FALSE);
	glEnable(GL_STENCIL_TEST);

	// Check if we have the required extensions
	if (GLEE_EXT_stencil_wrap)
	{
		op_depth_pass_front = GL_INCR_WRAP_EXT;
		op_depth_pass_back = GL_DECR_WRAP_EXT;
	}

	// generic 1-pass version
	if (GLEE_EXT_stencil_two_side)
	{
		glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
		glDisable(GL_CULL_FACE);
		glStencilMask(~0);
		glActiveStencilFaceEXT(GL_BACK);
		glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_back);
		glStencilFunc(GL_ALWAYS, 0, ~0);
		glActiveStencilFaceEXT(GL_FRONT);
		glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_front);
		glStencilFunc(GL_ALWAYS, 0, ~0);

		pie_ShadowDrawLoop();
		
		glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
	}
	// check for ATI-specific 1-pass version
	else if (GLEE_ATI_separate_stencil)
	{
		glDisable(GL_CULL_FACE);
		glStencilMask(~0);
		glStencilOpSeparateATI(GL_BACK, GL_KEEP, GL_KEEP, op_depth_pass_back);
		glStencilOpSeparateATI(GL_FRONT, GL_KEEP, GL_KEEP, op_depth_pass_front);
		glStencilFunc(GL_ALWAYS, 0, ~0);

		pie_ShadowDrawLoop();	
	}
	// fall back to default 2-pass version
	else
	{
		glStencilMask(~0);
		glStencilFunc(GL_ALWAYS, 0, ~0);
		glEnable(GL_CULL_FACE);
		
		// Setup stencil for front-facing polygons
		glCullFace(GL_BACK);
		glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_front);

		pie_ShadowDrawLoop();

		// Setup stencil for back-facing polygons
		glCullFace(GL_FRONT);
		glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_back);

		pie_ShadowDrawLoop();
	}

	pie_SetRendMode(REND_ALPHA);
	glEnable(GL_CULL_FACE);
	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
	glStencilMask(~0);
	glStencilFunc(GL_LESS, 0, ~0);
	glColor4f(0, 0, 0, 0.5);

	pie_PerspectiveEnd();
	glLoadIdentity();
	glDisable(GL_DEPTH_TEST);
	glBegin(GL_TRIANGLE_STRIP);
		glVertex2f(0, 0);
		glVertex2f(width, 0);
		glVertex2f(0, height);
		glVertex2f(width, height);
	glEnd();
	pie_PerspectiveBegin();

	pie_SetRendMode(REND_OPAQUE);
	glDisable(GL_STENCIL_TEST);
	glEnable(GL_DEPTH_TEST);
	glDepthMask(GL_TRUE);

	glPopMatrix();

	nb_scshapes = 0;
}
Exemple #14
0
enum piglit_result
piglit_display(void)
{
	GLboolean pass = GL_TRUE;
	int i;
	static float red[]   = {1.0, 0.0, 0.0, 0.0};
	static float green[] = {0.0, 1.0, 0.0, 0.0};
	static float blue[]  = {0.0, 0.0, 1.0, 0.0};
	static float square[100];

	piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);

	/* whole window gray -- none should be visible */
	glClearColor(0.5, 0.5, 0.5, 0.0);
	glClear(GL_COLOR_BUFFER_BIT);

	/* Clear stencil to 0, which will be drawn red */
	glClearStencil(0);
	glClear(GL_STENCIL_BUFFER_BIT);

	/* quad at 10, 10 that will be drawn green. */
	for (i = 0; i < 100; i++)
		square[i] = 1.0;
	glRasterPos2i(10, 10);
	glDrawPixels(10, 10, GL_STENCIL_INDEX, GL_FLOAT, square);

	/* quad at 30, 10 that will be drawn blue. */
	for (i = 0; i < 100; i++)
		square[i] = 2.0;
	glRasterPos2i(30, 10);
	glDrawPixels(10, 10, GL_STENCIL_INDEX, GL_FLOAT, square);

	glDisable(GL_SCISSOR_TEST);
	glEnable(GL_STENCIL_TEST);
	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

	/* First quad -- stencil == 0 gets red */
	glStencilFunc(GL_EQUAL, 0, ~0);
	glColor4fv(red);
	piglit_draw_rect(0, 0, piglit_width, piglit_height);

	/* Second quad -- stencil == 1 gets green */
	glStencilFunc(GL_EQUAL, 1, ~0);
	glColor4fv(green);
	piglit_draw_rect(0, 0, piglit_width, piglit_height);

	/* Last quad -- stencil == 2 gets blue */
	glStencilFunc(GL_EQUAL, 2, ~0);
	glColor4fv(blue);
	piglit_draw_rect(0, 0, piglit_width, piglit_height);

	assert(glGetError() == 0);

	pass &= piglit_probe_rect_rgb(0, 0, piglit_width, 10, red);

	pass &= piglit_probe_rect_rgb(0, 10, 10, 10, red);
	pass &= piglit_probe_rect_rgb(10, 10, 10, 10, green);
	pass &= piglit_probe_rect_rgb(20, 10, 10, 10, red);
	pass &= piglit_probe_rect_rgb(30, 10, 10, 10, blue);
	pass &= piglit_probe_rect_rgb(40, 10, piglit_width-40, 10, red);

	pass &= piglit_probe_rect_rgb(0, 20, piglit_width, piglit_height - 20,
				      red);

	glutSwapBuffers();

	return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
Exemple #15
0
void Application::drawScene() {

	GLenum err;

	glViewport(0, 0, 2048, 2048);
	glBindFramebuffer(GL_FRAMEBUFFER, fbo);

	float back_color[] = { 1, 1, 1, 1 };
	float zero[]       = { 0.0f, 0.0f, 0.0f, -10.0f };
	float one          = 1.0f;
	int   zero_int     = 0;

	glClearBufferfv(GL_COLOR, 0, back_color);
	glClearBufferfv(GL_DEPTH, 0, &one);
	glClearBufferiv(GL_STENCIL, 0, &zero_int);

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

	glm::mat4* transform_matrices = nullptr;

	GL_ERROR

		// =====================================================================
		// =====================================================================
		// == Rendering the mirror contents 
		// =====================================================================
		// =====================================================================

#define RENDER_MIRROR
#ifdef RENDER_MIRROR
	glEnable(GL_STENCIL_TEST);
	glStencilFunc(GL_ALWAYS, 1, 1);
	glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);

	GL_ERROR

	// Do Masking
	//glColorMask(0, 0, 0, 0);
	glEnable(GL_STENCIL_TEST);
	glStencilFunc(GL_ALWAYS, 1, 1);
	glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
	glDepthMask(GL_TRUE);
	glEnable(GL_DEPTH_TEST);

	GL_ERROR

	// Apply the mirror
	glBindBufferBase(GL_UNIFORM_BUFFER, 0, m_transformation_buffer);
	transform_matrices = (glm::mat4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 3 * sizeof(glm::mat4), GL_MAP_WRITE_BIT);
	transform_matrices[0] = m_projmat;
	transform_matrices[1] = m_viewmat;
	transform_matrices[2] =
		m_worldmat *
		glm::mat4(
			5.0f, 0.0f, 0.0f, 0.0f,
			0.0f, 5.0f, 0.0f, 0.0f,
			0.0f, 0.0f, 5.0f, 0.0f,
			0.0f, 0.0f, 0.0f, 1.0f
		);
	glUnmapBuffer(GL_UNIFORM_BUFFER);

	drawMirror();

	// Render Mirrored Triangle
	glDepthMask(GL_FALSE);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_GREATER);
	glColorMask(1, 1, 1, 1);
	glStencilFunc(GL_EQUAL, 1, 1);
	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

	// Apply the mirror
	glBindBufferBase(GL_UNIFORM_BUFFER, 0, m_transformation_buffer);
	transform_matrices = (glm::mat4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 3 * sizeof(glm::mat4), GL_MAP_WRITE_BIT);
	transform_matrices[0] = m_projmat;
	transform_matrices[1] = m_viewmat;
	transform_matrices[2] =
		m_worldmat *
		glm::mat4(
			5.0f, 0.0f, 0.0f, 0.0f,
			0.0f, 5.0f, 0.0f, 0.0f,
			0.0f, 0.0f, -5.0f, 0.0f,
			0.0f, 0.0f, 0.0f, 1.0f
		);
	glUnmapBuffer(GL_UNIFORM_BUFFER);
	drawTriangle();

	GL_ERROR

#endif
	// ===================================================================
	// ===================================================================
	// Render main triangle
	// ===================================================================
	// ===================================================================

	glBindBufferBase(GL_UNIFORM_BUFFER, 0, m_transformation_buffer);
	transform_matrices = (glm::mat4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 3 * sizeof(glm::mat4), GL_MAP_WRITE_BIT);
	transform_matrices[0] = m_projmat;
	transform_matrices[1] = m_viewmat;
	transform_matrices[2] =
		m_worldmat *
		glm::mat4(
			5.0f, 0.0f, 0.0f, 0.0f,
			0.0f, 5.0f, 0.0f, 0.0f,
			0.0f, 0.0f, 5.0f, 0.0f,
			0.0f, 0.0f, 0.0f, 1.0f
		);
	glUnmapBuffer(GL_UNIFORM_BUFFER);
	glDepthFunc(GL_LESS);
	glEnable(GL_DEPTH_TEST);
	glDepthMask(GL_TRUE);
	glDisable(GL_STENCIL_TEST);
	drawTriangle();

	GL_ERROR

	glBindBufferBase(GL_UNIFORM_BUFFER, 0, m_transformation_buffer);
	transform_matrices = (glm::mat4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 3 * sizeof(glm::mat4), GL_MAP_WRITE_BIT);
	transform_matrices[0] = m_projmat;
	transform_matrices[1] = m_viewmat;
	transform_matrices[2] =	m_worldmat;
	glUnmapBuffer(GL_UNIFORM_BUFFER);

	GL_ERROR
}
void game_draw(int pose, float st)
{
    float fov = view_fov;

    if (jump_b) fov *= 2.f * fabsf(jump_dt - 0.5);

    if (game_state)
    {
        config_push_persp(fov, 0.1f, FAR_DIST);
        glPushMatrix();
        {
            float v[3], rx, ry;
            float pup[3];
            float pdn[3];

            v_cpy(pup, view_p);
            v_cpy(pdn, view_p);
            pdn[1] = -pdn[1];

            /* Compute and apply the view. */

            v_sub(v, view_c, view_p);

            rx = V_DEG(fatan2f(-v[1], fsqrtf(v[0] * v[0] + v[2] * v[2])));
            ry = V_DEG(fatan2f(+v[0], -v[2])) + st;

            glTranslatef(0.f, 0.f, -v_len(v));
            glRotatef(rx, 1.f, 0.f, 0.f);
            glRotatef(ry, 0.f, 1.f, 0.f);
            glTranslatef(-view_c[0], -view_c[1], -view_c[2]);

#ifndef DREAMCAST_KGL_NOT_IMPLEMENT
            if (config_get_d(CONFIG_REFLECTION))
            {
                /* Draw the mirror only into the stencil buffer. */

                glDisable(GL_DEPTH_TEST);
                glEnable(GL_STENCIL_TEST);
                glStencilFunc(GL_ALWAYS, 1, 0xFFFFFFFF);
                glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
                glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

                game_refl_all(0);

                /* Draw the scene reflected into color and depth buffers. */

                glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
                glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
                glStencilFunc(GL_EQUAL, 1, 0xFFFFFFFF);
                glEnable(GL_DEPTH_TEST);

                glFrontFace(GL_CW);
                glPushMatrix();
                {
                    glScalef(+1.f, -1.f, +1.f);

                    game_draw_light();
                    game_draw_back(pose,         -1, pdn);
                    game_draw_fore(pose, rx, ry, -1, pdn);
                }
                glPopMatrix();
                glFrontFace(GL_CCW);

                glDisable(GL_STENCIL_TEST);
            }
#endif

            /* Draw the scene normally. */
            game_draw_light();
            game_refl_all(pose ? 0 : config_get_d(CONFIG_SHADOW));
            game_draw_back(pose,         +1, pup);
            game_draw_fore(pose, rx, ry, +1, pup);
        }
        glPopMatrix();
        config_pop_matrix();

        /* Draw the fade overlay. */

        fade_draw(fade_k);
    }
}
void PaintView::initSetup()
{
#ifndef MESA
	// To avoid flicker on some machines.
	glDrawBuffer(GL_FRONT_AND_BACK);
#endif // !MESA

	if (!valid())
	{

		glClearColor(0.7f, 0.7f, 0.7f, 1.0);

		// We're only using 2-D, so turn off depth 
		glDisable(GL_DEPTH_TEST);

		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		glEnable(GL_BLEND);

		ortho();

		glClear(GL_COLOR_BUFFER_BIT);

	}

	Point scrollpos;// = GetScrollPosition();
	scrollpos.x = 0;
	scrollpos.y = 0;

	// Main window width and height
	m_nWindowWidth = w();
	m_nWindowHeight = h();

	int drawWidth, drawHeight;
	drawWidth = min(m_nWindowWidth, m_pDoc->m_nPaintWidth);
	drawHeight = min(m_nWindowHeight, m_pDoc->m_nPaintHeight);

	int startrow = m_pDoc->m_nPaintHeight - (scrollpos.y + drawHeight);
	if (startrow < 0) startrow = 0;

	m_pPaintBitstart = m_pDoc->m_ucPainting + 3 * ((m_pDoc->m_nPaintWidth * startrow) + scrollpos.x);

	m_nDrawWidth = drawWidth;
	m_nDrawHeight = drawHeight;

	m_nStartRow = startrow;
	m_nEndRow = startrow + drawHeight;
	m_nStartCol = scrollpos.x;
	m_nEndCol = m_nStartCol + drawWidth;

	// Implement edge clipping here using stencil buffer
	// There are two steps:
	// 1. Initialize stencil buffer by setting color buffer masks to false
	//    and then setting appropriate ref value to stencil buffer by failing 
	//    the stencil test every time.
	// 2. Use the initialized stencil buffer and stencil test to write only 
	//    in the locations where stencil value is 1
	if (!valid()) {

		// Quick explanation: 
		// Stencil buffer gives an option to which 
		// fragments should be drawn and which shouldn't
		// more info: https://en.wikipedia.org/wiki/Stencil_buffer

		/************** Step 1 **************/
		glEnable(GL_STENCIL_TEST);

		/* Basically glStencilMask allows us to set a bitmask that is
		ANDed with the stencil value about to be written to the buffer */
		/*----------------------------------------------------------------*/
		// 0xFF means we set all stencil values to 1 per bit, no mask  
		glStencilMask(0xFF);
		// clear stencil buffer witih 0s
		glClear(GL_STENCIL_BUFFER_BIT);

		/* Configure Stencil Testing*/
		/* a. glStencilFunc describes what OpenGL should do
		with the content of the stencil buffer
		/* b. glStencilOp describes how we can update
		the stencil buffer
		/*------------------------------------------------*/
		// Force drawing to stencil by declaring stencil test function fails
		// This means we draw 1s on test fail (always)
		glStencilFunc(GL_NEVER, 1, 0xFF);
		// replace stencil buffer values to ref=1, 2nd parameter of glStencilFunc
		glStencilOp(GL_REPLACE, GL_KEEP, GL_KEEP);

		// Disable all color channels so stencil buffer won't affect 
		// the content of the color buffer
		glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

		// Draw stencil shape
		glBegin(GL_TRIANGLE_STRIP);
		// Get the vertices for the paint view 
		glVertex2f(0, m_nWindowHeight - m_nDrawHeight); // bottom left 
		glVertex2f(m_nDrawWidth, m_nWindowHeight - m_nDrawHeight); //  bottom right
		glVertex2f(0, m_nWindowHeight); // top left
		glVertex2f(m_nDrawWidth, m_nWindowHeight); // top right

		glEnd();

		/************** Step 2 **************/
		// Enable color
		glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

		// no more modifying of stencil buffer on stencil
		glStencilMask(0);

		// stencil test: only pass stencil test at stencilValue less than 0 
		// and write actual content to color buffer only at stencil shape locations.
		glStencilFunc(GL_LESS, 0, 0xFF);
	}

}
void RenderTextureTestDepthStencil::onBeforDraw()
{
    glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
}
void glRenderer::render(const iClipState &rClipState)
{
	glClipState result;
	result.reset(&rClipState);

	float alpha = result.alpha;
	const Point3f &color = result.color;
	const Rect &clip = result.clip;

	if (clip.GetWidth() && clip.GetHeight())
	{
		glColorMask(0,0,0,0);								// Set Color Mask
		glEnable(GL_STENCIL_TEST);							// Enable Stencil Buffer For "marking" The Floor
		glStencilFunc(GL_ALWAYS, 1, 1);						// Always Passes, 1 Bit Plane, 1 As Mask
		glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);			// We Set The Stencil Buffer To 1 Where We Draw Any Polygon
		// Keep If Test Fails, Keep If Test Passes But Buffer Test Fails
		// Replace If Test Passes
		glDisable(GL_DEPTH_TEST);							// Disable Depth Testing
		//DrawFloor();										// Draw The Floor (Draws To The Stencil Buffer)
		glBegin(GL_QUADS);
		glVertex3f(result.position.x + clip.leftTop.x, result.position.y + clip.leftTop.y, 0);
		glVertex3f(result.position.x + clip.rightBottom.x, result.position.y + clip.leftTop.y, 0);
		glVertex3f(result.position.x + clip.rightBottom.x, result.position.y + clip.rightBottom.y, 0);
		glVertex3f(result.position.x + clip.leftTop.x, result.position.y + clip.rightBottom.y, 0);
		glEnd();
		// We Only Want To Mark It In The Stencil Buffer
		//glEnable(GL_DEPTH_TEST);							// Enable Depth Testing
		glColorMask(1,1,1,1);								// Set Color Mask to TRUE, TRUE, TRUE, TRUE
		glStencilFunc(GL_EQUAL, 1, 1);						// We Draw Only Where The Stencil Is 1
		// (I.E. Where The Floor Was Drawn)
		glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);				// Don't Change The Stencil Buffer
	}
	glColor4f(color.x, color.y, color.z, alpha);

	const Image &image = result.image;
	if (image.valid())
	{
		Wm4::Matrix3f m33;
		result.getMatrix(m33, 1, 1, 1, 1);
		//glClipState::updateMatrix(m33, (const glClipState&)rClipState, (const glClipState&)rParentClipState);
		m33 = m33.Transpose();
		glTexture &glTex = *(glTexture*)&image.getTexture();
		unsigned int tex = glTex.getGlTexture();
		glBindTexture(GL_TEXTURE_2D, tex);
		const Rect &texRect = image.getRect();
		const float w_2 = texRect.GetWidth() * 0.5f;
		const float h_2 = texRect.GetHeight() * 0.5f;
		Wm4::Vector3f wmPosition0 = m33 * Wm4::Vector3f(-w_2, -h_2, 1.f);
		Wm4::Vector3f wmPosition1 = m33 * Wm4::Vector3f(w_2, -h_2, 1.f);
		Wm4::Vector3f wmPosition2 = m33 * Wm4::Vector3f(w_2, h_2, 1.f);
		Wm4::Vector3f wmPosition3 = m33 * Wm4::Vector3f(-w_2, h_2, 1.f);

		float left = (float)texRect.leftTop.x / glTex.getWidth();
		float right = (float)texRect.rightBottom.x / glTex.getWidth();
		float top = (float)texRect.leftTop.y / glTex.getHeight();
		float bottom = (float)texRect.rightBottom.y / glTex.getHeight();

		glEnable(GL_TEXTURE_2D);    
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		glBegin(GL_QUADS);

		glTexCoord2f(left, top);
		glVertex3f(wmPosition0.X(), wmPosition0.Y(), 0.5f);// x-,y-
		glTexCoord2f(right, top);
		glVertex3f(wmPosition1.X(), wmPosition1.Y(), 0.5f);// x+,y-
		glTexCoord2f(right, bottom);
		glVertex3f(wmPosition2.X(), wmPosition2.Y(), 0.5f);// x+,y+
		glTexCoord2f(left, bottom);
		glVertex3f(wmPosition3.X(), wmPosition3.Y(), 0.5f);// x-,y+
		glEnd();
	}
	const std::string &text = result.text;
	if (text.length())
	{
		glport::Font *pFont = fontmap->GetFont("Impact");
		if (pFont)
		{
			glPushMatrix();
			glTranslatef(result.position.x, result.position.y, 0);
			glScalef(result.scale.x, -result.scale.y, 1); // reverse y direciton
			glTranslatef(-result.anchorOffPos.x, -result.anchorOffPos.y, 0);
			glDisable(GL_TEXTURE_2D);
			glEnable(GL_LINE_SMOOTH);
			glEnable(GL_BLEND);
			glBlendFunc(GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA);
			glLineWidth(0.3f);
			pFont->textOut(text.c_str());
			glPopMatrix();
		}
	}

	glDisable(GL_STENCIL_TEST);
}
Exemple #20
0
void set_gl_options (TRenderMode mode) 
{
	switch (mode) {
    case GUI:
        glEnable (GL_TEXTURE_2D);
        glDisable (GL_DEPTH_TEST);
        glDisable (GL_CULL_FACE);
		glDisable (GL_LIGHTING);
		glDisable (GL_NORMALIZE);
		glDisable (GL_ALPHA_TEST);
        glEnable (GL_BLEND);
		glDisable (GL_STENCIL_TEST);
		glDisable (GL_TEXTURE_GEN_S);
		glDisable (GL_TEXTURE_GEN_T);
		glDisable (GL_COLOR_MATERIAL);
		glDepthMask (GL_TRUE);
		glShadeModel (GL_SMOOTH);
		glDepthFunc (GL_LESS);
		glDisable (GL_FOG);
        break;
    
	case GAUGE_BARS:
        glEnable (GL_TEXTURE_2D);
        glDisable (GL_DEPTH_TEST);
        glDisable (GL_CULL_FACE);
		glDisable (GL_LIGHTING);
		glDisable (GL_NORMALIZE);
		glDisable (GL_ALPHA_TEST);
        glEnable (GL_BLEND);
		glDisable (GL_STENCIL_TEST);
		glEnable (GL_TEXTURE_GEN_S);
		glEnable (GL_TEXTURE_GEN_T);
		glDisable (GL_COLOR_MATERIAL);
		glDepthMask (GL_TRUE);
		glShadeModel (GL_SMOOTH);
		glDepthFunc (GL_LESS);

		glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
		glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
        break;

    case TEXFONT:
        glEnable (GL_TEXTURE_2D);
        glDisable (GL_DEPTH_TEST);
        glDisable (GL_CULL_FACE);
		glDisable (GL_LIGHTING);
		glDisable (GL_NORMALIZE);
		glDisable (GL_ALPHA_TEST);
        glEnable (GL_BLEND);
		glDisable (GL_STENCIL_TEST);
		glDisable (GL_TEXTURE_GEN_S);
		glDisable (GL_TEXTURE_GEN_T);
		glDisable (GL_COLOR_MATERIAL);
		glDepthMask (GL_TRUE);
		glShadeModel (GL_SMOOTH);
		glDepthFunc (GL_LESS);
        break;
    
	case COURSE:
		glEnable (GL_TEXTURE_2D);
		glEnable (GL_DEPTH_TEST);
		glEnable (GL_CULL_FACE);
		glEnable (GL_LIGHTING);
		glDisable (GL_NORMALIZE);
		glDisable (GL_ALPHA_TEST);
		glEnable (GL_BLEND);
		glDisable (GL_STENCIL_TEST);
		glEnable (GL_TEXTURE_GEN_S);
		glEnable (GL_TEXTURE_GEN_T);
		glEnable (GL_COLOR_MATERIAL);
		glDepthMask (GL_TRUE);
		glShadeModel (GL_SMOOTH);
		glDepthFunc (GL_LEQUAL);

		glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
		glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
		break;

    case TREES:
		glEnable (GL_TEXTURE_2D);
		glEnable (GL_DEPTH_TEST);
        glDisable (GL_CULL_FACE);
		glEnable (GL_LIGHTING);
		glDisable (GL_NORMALIZE);
        glEnable (GL_ALPHA_TEST);
		glEnable (GL_BLEND);
		glDisable (GL_STENCIL_TEST);
		glDisable (GL_TEXTURE_GEN_S);
		glDisable (GL_TEXTURE_GEN_T);
		glDisable (GL_COLOR_MATERIAL);
		glDepthMask (GL_TRUE);
		glShadeModel (GL_SMOOTH);
		glDepthFunc (GL_LESS);

        glAlphaFunc (GL_GEQUAL, 0.5);
        break;
        
    case PARTICLES:
        glEnable (GL_TEXTURE_2D);
		glEnable (GL_DEPTH_TEST);
        glDisable (GL_CULL_FACE);
		glDisable (GL_LIGHTING);
		glDisable (GL_NORMALIZE);
		glEnable (GL_ALPHA_TEST);
        glEnable (GL_BLEND);
		glDisable (GL_STENCIL_TEST);
		glDisable (GL_TEXTURE_GEN_S);
		glDisable (GL_TEXTURE_GEN_T);
		glDisable (GL_COLOR_MATERIAL);
		glDepthMask (GL_TRUE);
		glShadeModel (GL_SMOOTH);
		glDepthFunc (GL_LESS);

        glAlphaFunc (GL_GEQUAL, 0.5);
        break;
    
	case SKY:
		glEnable (GL_TEXTURE_2D);
		glDisable (GL_DEPTH_TEST);
		glDisable (GL_CULL_FACE); 
		glDisable (GL_LIGHTING);
		glDisable (GL_NORMALIZE);
		glDisable (GL_ALPHA_TEST);
		glEnable (GL_BLEND);
		glDisable (GL_STENCIL_TEST);
		glDisable (GL_TEXTURE_GEN_S);
		glDisable (GL_TEXTURE_GEN_T);
		glDisable (GL_COLOR_MATERIAL);
		glDepthMask (GL_FALSE);
		glShadeModel (GL_SMOOTH);
		glDepthFunc (GL_LESS);
		break;
 	
    case FOG_PLANE:
		glDisable (GL_TEXTURE_2D);
		glEnable (GL_DEPTH_TEST);
		glDisable (GL_CULL_FACE); 
		glDisable (GL_LIGHTING);
		glDisable (GL_NORMALIZE);
		glDisable (GL_ALPHA_TEST);
		glEnable (GL_BLEND);
		glDisable (GL_STENCIL_TEST);
		glDisable (GL_TEXTURE_GEN_S);
		glDisable (GL_TEXTURE_GEN_T);
		glDisable (GL_COLOR_MATERIAL);
		glDepthMask (GL_TRUE);
		glShadeModel (GL_SMOOTH);
		glDepthFunc (GL_LESS);
		break;

    case TUX:
	    glDisable (GL_TEXTURE_2D);
		glEnable (GL_DEPTH_TEST);
		glEnable (GL_CULL_FACE);
    	glEnable (GL_LIGHTING);
		glEnable (GL_NORMALIZE);
		glDisable (GL_ALPHA_TEST);
		glEnable (GL_BLEND);
		glDisable (GL_STENCIL_TEST);
		glDisable (GL_TEXTURE_GEN_S);
		glDisable (GL_TEXTURE_GEN_T);
		glDisable (GL_COLOR_MATERIAL);
		glDepthMask (GL_TRUE);
		glShadeModel (GL_SMOOTH);
		glDepthFunc (GL_LESS);
    	break;

    case TUX_SHADOW:
	#ifdef USE_STENCIL_BUFFER
		glDisable (GL_TEXTURE_2D);
		glEnable (GL_DEPTH_TEST);
		glDisable (GL_CULL_FACE);
		glDisable (GL_LIGHTING);
		glDisable (GL_NORMALIZE);
		glDisable (GL_ALPHA_TEST);
		glEnable (GL_BLEND);
		glEnable (GL_STENCIL_TEST);
		glDisable (GL_COLOR_MATERIAL);
		glDepthMask (GL_FALSE);
		glShadeModel (GL_SMOOTH);
		glDepthFunc (GL_LESS);

		glStencilFunc (GL_EQUAL, 0, ~0);
		glStencilOp (GL_KEEP, GL_KEEP, GL_INCR);
	#else
		glDisable (GL_TEXTURE_2D);
		glEnable (GL_DEPTH_TEST);
		glEnable (GL_CULL_FACE);
		glDisable (GL_LIGHTING);
		glDisable (GL_NORMALIZE);
		glDisable (GL_ALPHA_TEST);
		glEnable (GL_BLEND);
		glDisable (GL_STENCIL_TEST);
		glDisable (GL_COLOR_MATERIAL);
		glDepthMask (GL_TRUE);
		glShadeModel (GL_SMOOTH);
		glDepthFunc (GL_LESS);
	#endif
	break;

    case TRACK_MARKS:
		glEnable (GL_TEXTURE_2D);
		glEnable (GL_DEPTH_TEST);
		glDisable (GL_CULL_FACE);
		glEnable (GL_LIGHTING);
		glDisable (GL_NORMALIZE);
		glDisable (GL_ALPHA_TEST);
		glEnable (GL_BLEND);
		glDisable (GL_STENCIL_TEST);
		glDisable (GL_COLOR_MATERIAL);
		glDisable (GL_TEXTURE_GEN_S);
		glDisable (GL_TEXTURE_GEN_T);
		glDepthMask (GL_FALSE);
		glShadeModel (GL_SMOOTH);
		glDepthFunc (GL_LEQUAL);
		break;
    
	default:
		Message ("not a valid render mode", "");
    } 
} 
void e_beginpass(e_device_t* device,unsigned int pass)
{
	glPushAttrib(GL_ENABLE_BIT|GL_STENCIL_BUFFER_BIT|GL_POLYGON_BIT);
	switch(pass)
	{
		case E_RENDER_MESHES:
			glBindProgramARB(GL_VERTEX_PROGRAM_ARB,e_programids[E_PROGRAM_PASSTOFRAGMENT]);
			glEnable(GL_VERTEX_PROGRAM_ARB);
			glEnable(GL_FRAGMENT_PROGRAM_ARB);

			glEnable(GL_DEPTH_TEST);
			glEnable(GL_CULL_FACE);
			break;
		case E_RENDER_SHADOWS:
			//The support of this extension depends on the 3D card
			if(glActiveStencilFaceEXT)
			{
				glActiveStencilFaceEXT(GL_BACK);
				glStencilOp(GL_KEEP,GL_INCR_WRAP_EXT,GL_KEEP);
				glActiveStencilFaceEXT(GL_FRONT);
				glStencilOp(GL_KEEP,GL_DECR_WRAP_EXT,GL_KEEP);
				glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
			}
			else
				glEnable(GL_CULL_FACE);

			glBindProgramARB(GL_VERTEX_PROGRAM_ARB,e_programids[E_PROGRAM_SHADOW]);
			glEnable(GL_VERTEX_PROGRAM_ARB);

			glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
			glDepthMask(GL_FALSE);
			glEnable(GL_STENCIL_TEST);
			glStencilFunc(GL_ALWAYS,0,~0);
			glEnable(GL_DEPTH_TEST);
			break;
		case E_RENDER_SHADING:
			glBindProgramARB(GL_VERTEX_PROGRAM_ARB,e_programids[E_PROGRAM_PASSTOFRAGMENT]);
			glEnable(GL_VERTEX_PROGRAM_ARB);
			glEnable(GL_FRAGMENT_PROGRAM_ARB);

			glBlendFunc(GL_ONE,GL_ONE);
			glEnable(GL_BLEND);

			glEnable(GL_STENCIL_TEST);
			glStencilFunc(GL_EQUAL,0,~0);
			glStencilOp(GL_KEEP,GL_KEEP,GL_KEEP);
			glDepthFunc(GL_LEQUAL);

			glEnable(GL_CULL_FACE);
			glEnable(GL_DEPTH_TEST);
			break;
		case E_RENDER_OUTLINES:
			glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
#ifdef E_OUTLINES_SMOOTH
			glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
			glEnable(GL_LINE_SMOOTH);
			glEnable(GL_BLEND);
#endif
			glLineWidth(E_OUTLINES_WIDTH);
			glPolygonOffset(1.0f,1.0f);
			glEnable(GL_POLYGON_OFFSET_LINE);
			glColor3ub(0,0,0);
			glEnable(GL_CULL_FACE);
			glCullFace(GL_FRONT);
			glEnable(GL_DEPTH_TEST);
			break;
	}
}
void drawCam(Player *p, PlayerVisual* pV) {
	int i;
	float up[3] = { 0, 0, 1 };
	Visual *d = & pV->display;
	
	float reflectivity = getReflectivity();
	// compute shadow color based on glocal constant & reflectivity
	for(i = 0; i < 4; i++) 
		gCurrentShadowColor[i] = gShadowColor[i] * (1 - reflectivity);

	glColor3f(0.0, 1.0, 0.0);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	doPerspective(gSettingsCache.fov, (float) d->vp_w / (float) d->vp_h,
		gSettingsCache.znear, box2_Diameter(& game2->level->boundingBox) * 6.5f);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	doLookAt(p->camera->cam, p->camera->target, up);
	glDisable(GL_LIGHTING); // initial config at frame start
	glDisable(GL_BLEND); // initial config at frame start

	// disable writes to alpha
	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);

	/* skybox */
	glDepthMask(GL_FALSE);
	glDisable(GL_DEPTH_TEST);

	drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f );

	glDepthMask(GL_TRUE);
	glEnable(GL_DEPTH_TEST);
	/* skybox done */

	/* floor */ 
	if(reflectivity == 0) {
		// draw floor to fb and stencil (set to 1),
		// using alpha-blending
		// TODO: draw floor alpha to fb
		video_Shader_Setup(& gWorld->floor_shader);
		glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
		glStencilFunc(GL_ALWAYS, 1, 255);
		glEnable(GL_STENCIL_TEST);
		glEnable(GL_BLEND);
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		nebu_Mesh_DrawGeometry( gWorld->floor );
		glDisable(GL_BLEND);
		glDisable(GL_STENCIL_TEST);
		video_Shader_Cleanup(& gWorld->floor_shader);
	} else {
		/* reflections */
		/* first draw reflector to stencil */
		/* and reflector alpha to fb */

		video_Shader_Setup(& gWorld->floor_shader);

		// store only reflector alpha in framebuffer
		glDepthMask(GL_FALSE);
		glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
		glStencilFunc(GL_ALWAYS, 1, 255);
		glEnable(GL_STENCIL_TEST);
		glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
		// glEnable(GL_ALPHA_TEST);
		// glAlphaFunc(GL_GREATER, 0.1f);

		nebu_Mesh_DrawGeometry( gWorld->floor );
		
		// glDisable(GL_ALPHA_TEST);
		glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
		glDepthMask(GL_TRUE);
		glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
		glStencilFunc(GL_EQUAL, 1, 255);

		video_Shader_Cleanup(& gWorld->floor_shader);
		
		/* then draw world & skybox reflected, where stencil is set */
		/* protect the alpha buffer */
		glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);

		isRenderingReflection = 1; // hack: reverse lighting
		glPushMatrix();
		glScalef(1,1,-1);
		glCullFace(GL_FRONT); // reverse culling
		// clip skybox & world to floor plane
		glEnable(GL_CLIP_PLANE0);
		{
			double plane[] = { 0, 0, 1, 0 };
			glClipPlane(GL_CLIP_PLANE0, plane);
		}

		drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f );
		drawWorld(p, pV);

		glDisable(GL_CLIP_PLANE0);
		glCullFace(GL_BACK);
		glPopMatrix();
		isRenderingReflection = 0; // hack: normal lighting

		/* then blend the skybox into the scene, where stencil is set */
		/* modulate with the destination alpha */
		glDisable(GL_DEPTH_TEST);
		glEnable(GL_BLEND);
		glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA);
		drawSkybox( box2_Diameter( & game2->level->boundingBox ) * 2.5f );
		glDisable(GL_BLEND);
		glEnable(GL_DEPTH_TEST);
		
		/* then blend reflector into the scene */
		glDisable(GL_DEPTH_TEST);
		glEnable(GL_BLEND);
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

		glColor4f(1, 1, 1, 1 - reflectivity);

		glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
		glStencilFunc(GL_ALWAYS, 1, 255);

		video_Shader_Setup(& gWorld->floor_shader);
		nebu_Mesh_DrawGeometry( gWorld->floor );
		video_Shader_Cleanup(& gWorld->floor_shader);

		glDisable(GL_STENCIL_TEST);
		glDisable(GL_BLEND);
		glEnable(GL_DEPTH_TEST);
	}
	/* floor done */

	/* planar shadows */
	glDepthMask(GL_FALSE);
	glDisable(GL_DEPTH_TEST);

	if(reflectivity != 1) // there are no shadows on perfect mirrors
		drawPlanarShadows(p);

	glDepthMask(GL_TRUE);
	glEnable(GL_DEPTH_TEST);
	/* planar shadows done */

	drawWorld(p, pV);

	/* transparent stuff */
	/* draw the glow around the other players: */
	if (gSettingsCache.show_glow == 1) {
		glEnable(GL_BLEND);
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

		for (i = 0; i < game->players; i++)
		{
			if (p != game->player + i && PLAYER_IS_ACTIVE(game->player + i))
			{
				drawGlow(p->camera, game->player + i, gPlayerVisuals + i,
					d, TRAIL_HEIGHT * 4);
			}
		}
		glDisable(GL_BLEND);
	}
}
//
// Draw the reachable SHADED terrain glide amoeba
// This is not the outlined perimeter
//
void MapWindow::DrawTerrainAbove(LKSurface& Surface, const RECT& rc) {

  // Lets try to make it better understandable with a goto.
  // If CAR or GA users dont want amoeba, they should disable it in config. 
  // Otherwise we should paint it, not hide it automatically!
  // Here are the conditions we print this amoeba, otherwise we return;

  // First is we are in SIM mode and we changed the altitude;
  if (SIMMODE && DerivedDrawInfo.AltitudeAGL>100) goto _doit;

  // Second, if we are flying
  if (DerivedDrawInfo.Flying) goto _doit;

  return;

_doit:

#ifndef ENABLE_OPENGL
  LKColor whitecolor = LKColor(0xff,0xff,0xff);
  LKColor graycolor = LKColor(0xf0,0xf0,0xf0);
  LKColor origcolor = TempSurface.SetTextColor(whitecolor);

  TempSurface.SetBackgroundTransparent();

  TempSurface.SetBkColor(whitecolor);

  TempSurface.SelectObject(LK_WHITE_PEN);
  TempSurface.SetTextColor(graycolor);
  TempSurface.SelectObject(hAboveTerrainBrush);
  TempSurface.Rectangle(rc.left,rc.top,rc.right,rc.bottom);
  TempSurface.SelectObject(LK_WHITE_PEN);
  TempSurface.SelectObject(LKBrush_White);
  TempSurface.Polygon(Groundline,NUMTERRAINSWEEPS+1);

  // need to do this to prevent drawing of colored outline
  TempSurface.SelectObject(LK_WHITE_PEN);
#ifdef HAVE_HATCHED_BRUSH
  Surface.TransparentCopy(
          rc.left,rc.top,
          rc.right-rc.left,rc.bottom-rc.top,
          TempSurface,
          rc.left,rc.top);
#else
  Surface.AlphaBlendNotWhite(rc, TempSurface, rc, 255/2);
#endif


  // restore original color
  TempSurface.SetTextColor(origcolor);
  TempSurface.SetBackgroundOpaque();
#else

    Canvas& canvas = Surface;
  
    const GLEnable<GL_STENCIL_TEST> stencil;
    
    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
    glDepthMask(GL_FALSE);
    glStencilFunc(GL_NEVER, 1, 0xFF);
    glStencilOp(GL_REPLACE, GL_KEEP, GL_KEEP);  // draw 1s on test fail (always)

    // draw stencil pattern
    glStencilMask(0xFF);
    glClear(GL_STENCIL_BUFFER_BIT);  // needs mask=0xFF

    canvas.DrawPolygon(Groundline,NUMTERRAINSWEEPS+1);

    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
    glDepthMask(GL_TRUE);
    glStencilMask(0x00);
    // draw where stencil's value is 0
    glStencilFunc(GL_EQUAL, 0, 0xFF);

    canvas.DrawFilledRectangle(rc.left,rc.top,rc.right,rc.bottom, AboveTerrainColor);

#endif  

}
Exemple #24
0
void ClippingNode::onBeforeVisit()
{
    ///////////////////////////////////
    // INIT

    // increment the current layer
    s_layer++;

    // mask of the current layer (ie: for layer 3: 00000100)
    GLint mask_layer = 0x1 << s_layer;
    // mask of all layers less than the current (ie: for layer 3: 00000011)
    GLint mask_layer_l = mask_layer - 1;
    // mask of all layers less than or equal to the current (ie: for layer 3: 00000111)
    _mask_layer_le = mask_layer | mask_layer_l;

    // manually save the stencil state

    _currentStencilEnabled = glIsEnabled(GL_STENCIL_TEST);
    glGetIntegerv(GL_STENCIL_WRITEMASK, (GLint *)&_currentStencilWriteMask);
    glGetIntegerv(GL_STENCIL_FUNC, (GLint *)&_currentStencilFunc);
    glGetIntegerv(GL_STENCIL_REF, &_currentStencilRef);
    glGetIntegerv(GL_STENCIL_VALUE_MASK, (GLint *)&_currentStencilValueMask);
    glGetIntegerv(GL_STENCIL_FAIL, (GLint *)&_currentStencilFail);
    glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, (GLint *)&_currentStencilPassDepthFail);
    glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, (GLint *)&_currentStencilPassDepthPass);

    // enable stencil use
    glEnable(GL_STENCIL_TEST);
    // check for OpenGL error while enabling stencil test
    CHECK_GL_ERROR_DEBUG();

    // all bits on the stencil buffer are readonly, except the current layer bit,
    // this means that operation like glClear or glStencilOp will be masked with this value
    glStencilMask(mask_layer);

    // manually save the depth test state

    glGetBooleanv(GL_DEPTH_WRITEMASK, &_currentDepthWriteMask);

    // disable depth test while drawing the stencil
    //glDisable(GL_DEPTH_TEST);
    // disable update to the depth buffer while drawing the stencil,
    // as the stencil is not meant to be rendered in the real scene,
    // it should never prevent something else to be drawn,
    // only disabling depth buffer update should do
    glDepthMask(GL_FALSE);

    ///////////////////////////////////
    // CLEAR STENCIL BUFFER

    // manually clear the stencil buffer by drawing a fullscreen rectangle on it
    // setup the stencil test func like this:
    // for each pixel in the fullscreen rectangle
    //     never draw it into the frame buffer
    //     if not in inverted mode: set the current layer value to 0 in the stencil buffer
    //     if in inverted mode: set the current layer value to 1 in the stencil buffer
    glStencilFunc(GL_NEVER, mask_layer, mask_layer);
    glStencilOp(!_inverted ? GL_ZERO : GL_REPLACE, GL_KEEP, GL_KEEP);

    // draw a fullscreen solid rectangle to clear the stencil buffer
    //ccDrawSolidRect(Point::ZERO, ccpFromSize([[Director sharedDirector] winSize]), Color4F(1, 1, 1, 1));
    drawFullScreenQuadClearStencil();

    ///////////////////////////////////
    // DRAW CLIPPING STENCIL

    // setup the stencil test func like this:
    // for each pixel in the stencil node
    //     never draw it into the frame buffer
    //     if not in inverted mode: set the current layer value to 1 in the stencil buffer
    //     if in inverted mode: set the current layer value to 0 in the stencil buffer
    glStencilFunc(GL_NEVER, mask_layer, mask_layer);
    glStencilOp(!_inverted ? GL_REPLACE : GL_ZERO, GL_KEEP, GL_KEEP);

    // enable alpha test only if the alpha threshold < 1,
    // indeed if alpha threshold == 1, every pixel will be drawn anyways
    if (_alphaThreshold < 1) {
#if (CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WINDOWS || CC_TARGET_PLATFORM == CC_PLATFORM_LINUX)
        // manually save the alpha test state
        _currentAlphaTestEnabled = glIsEnabled(GL_ALPHA_TEST);
        glGetIntegerv(GL_ALPHA_TEST_FUNC, (GLint *)&_currentAlphaTestFunc);
        glGetFloatv(GL_ALPHA_TEST_REF, &_currentAlphaTestRef);
        // enable alpha testing
        glEnable(GL_ALPHA_TEST);
        // check for OpenGL error while enabling alpha test
        CHECK_GL_ERROR_DEBUG();
        // pixel will be drawn only if greater than an alpha threshold
        glAlphaFunc(GL_GREATER, _alphaThreshold);
#else
        
#endif
    }

    //Draw _stencil
}
void SoGLStencilBufferElement::updategl( uint32_t updatebits ) const
{

    if( updatebits & ENABLE )
    {
        if (enable) {
            glEnable(GL_STENCIL_TEST);
            checkGLErrors();
        }
        else
        {
            glDisable(GL_STENCIL_TEST);
            checkGLErrors();
        }
    }
    if( updatebits & FUNC )
    {
        GLint glref = ref;
        GLuint glmask = mask;
        switch(func) {
        case NEVER:
            glStencilFunc( GL_NEVER, glref, glmask );
        	break;
        case LESS:
            glStencilFunc( GL_LESS, glref, glmask );
        	break;
        case LEQUAL:
            glStencilFunc( GL_LEQUAL, glref, glmask );
            break;
        case GREATER:
            glStencilFunc( GL_GREATER, glref, glmask );
            break;
        case GEQUAL:
            glStencilFunc( GL_GEQUAL, glref, glmask );
            break;
        case EQUAL:
            glStencilFunc( GL_EQUAL, glref, glmask );
            break;
        case NOTEQUAL:
            glStencilFunc( GL_NOTEQUAL, glref, glmask );
            break;
        case ALWAYS:
            glStencilFunc( GL_ALWAYS, glref, glmask );
            break;
        default:
            assert(NULL && "SoGLStencilBufferElement undefined stencil function!");
        }
        checkGLErrors();
    }
    if( updatebits & MASK )
    {
        glStencilMask( bits );
        checkGLErrors();
    }
    if ( updatebits & OP) 
    {
        static const GLenum functions[6] = { GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, GL_DECR, GL_INVERT };
        GLenum glfail = functions[fail];
        GLenum glzfail = functions[zfail];
        GLenum glzpass = functions[zpass];
        glStencilOp( glfail, glzfail, glzpass );
        checkGLErrors();
    }
}
void LLDrawPoolWater::render(S32 pass)
{
    LLFastTimer ftm(LLFastTimer::FTM_RENDER_WATER);
    if (mDrawFace.empty() || LLDrawable::getCurrentFrame() <= 1)
    {
        return;
    }

    //do a quick 'n dirty depth sort
    for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
            iter != mDrawFace.end(); iter++)
    {
        LLFace* facep = *iter;
        facep->mDistance = -facep->mCenterLocal.mV[2];
    }

    std::sort(mDrawFace.begin(), mDrawFace.end(), LLFace::CompareDistanceGreater());
    static const LLCachedControl<bool> render_transparent_water("RenderTransparentWater",false);
    if(!render_transparent_water)
    {
        // render water for low end hardware
        renderOpaqueLegacyWater();
        return;
    }

    LLGLEnable blend(GL_BLEND);

    if ((mVertexShaderLevel > 0) && !sSkipScreenCopy)
    {
        shade();
        return;
    }

    LLVOSky *voskyp = gSky.mVOSkyp;

    stop_glerror();

    if (!gGLManager.mHasMultitexture)
    {
        // Ack!  No multitexture!  Bail!
        return;
    }

    LLFace* refl_face = voskyp->getReflFace();

    gPipeline.disableLights();

    LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);

    LLGLDisable cullFace(GL_CULL_FACE);

    // Set up second pass first
    mWaterImagep->addTextureStats(1024.f*1024.f);
    gGL.getTexUnit(1)->activate();
    gGL.getTexUnit(1)->enable(LLTexUnit::TT_TEXTURE);
    gGL.getTexUnit(1)->bind(mWaterImagep) ;

    LLVector3 camera_up = LLViewerCamera::getInstance()->getUpAxis();
    F32 up_dot = camera_up * LLVector3::z_axis;

    LLColor4 water_color;
    if (LLViewerCamera::getInstance()->cameraUnderWater())
    {
        water_color.setVec(1.f, 1.f, 1.f, 0.4f);
    }
    else
    {
        water_color.setVec(1.f, 1.f, 1.f, 0.5f*(1.f + up_dot));
    }

    glColor4fv(water_color.mV);

    // Automatically generate texture coords for detail map
    glEnable(GL_TEXTURE_GEN_S); //texture unit 1
    glEnable(GL_TEXTURE_GEN_T); //texture unit 1
    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

    // Slowly move over time.
    F32 offset = fmod(gFrameTimeSeconds*2.f, 100.f);
    F32 tp0[4] = {16.f/256.f, 0.0f, 0.0f, offset*0.01f};
    F32 tp1[4] = {0.0f, 16.f/256.f, 0.0f, offset*0.01f};
    glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0);
    glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1);

    gGL.getTexUnit(1)->setTextureColorBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_COLOR, LLTexUnit::TBS_PREV_COLOR);
    gGL.getTexUnit(1)->setTextureAlphaBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_PREV_ALPHA);

    gGL.getTexUnit(0)->activate();

    glClearStencil(1);
    glClear(GL_STENCIL_BUFFER_BIT);
    LLGLEnable gls_stencil(GL_STENCIL_TEST);
    glStencilOp(GL_KEEP, GL_REPLACE, GL_KEEP);
    glStencilFunc(GL_ALWAYS, 0, 0xFFFFFFFF);

    for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
            iter != mDrawFace.end(); iter++)
    {
        LLFace *face = *iter;
        if (voskyp->isReflFace(face))
        {
            continue;
        }
        gGL.getTexUnit(0)->bind(face->getTexture());
        face->renderIndexed();
    }

    // Now, disable texture coord generation on texture state 1
    gGL.getTexUnit(1)->activate();
    gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
    gGL.getTexUnit(1)->disable();
    glDisable(GL_TEXTURE_GEN_S); //texture unit 1
    glDisable(GL_TEXTURE_GEN_T); //texture unit 1

    // Disable texture coordinate and color arrays
    gGL.getTexUnit(0)->activate();
    gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);

    stop_glerror();

    if (gSky.mVOSkyp->getCubeMap())
    {
        gSky.mVOSkyp->getCubeMap()->enable(0);
        gSky.mVOSkyp->getCubeMap()->bind();

        glMatrixMode(GL_TEXTURE);
        glLoadIdentity();
        LLMatrix4 camera_mat = LLViewerCamera::getInstance()->getModelview();
        LLMatrix4 camera_rot(camera_mat.getMat3());
        camera_rot.invert();

        glLoadMatrixf((F32 *)camera_rot.mMatrix);

        glMatrixMode(GL_MODELVIEW);
        LLOverrideFaceColor overrid(this, 1.f, 1.f, 1.f,  0.5f*up_dot);

        gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);

        for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
                iter != mDrawFace.end(); iter++)
        {
            LLFace *face = *iter;
            if (voskyp->isReflFace(face))
            {
                //refl_face = face;
                continue;
            }

            if (face->getGeomCount() > 0)
            {
                face->renderIndexed();
            }
        }

        gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);

        gSky.mVOSkyp->getCubeMap()->disable();

        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
        gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
        glMatrixMode(GL_TEXTURE);
        glLoadIdentity();
        glMatrixMode(GL_MODELVIEW);

    }

    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

    if (refl_face)
    {
        glStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF);
        renderReflection(refl_face);
    }

    gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
}
Exemple #27
0
// *********************************************************************
// render the scene
void World::vrender(void)
{
  Vec3D camPos = m_cam->getPosition();
  Vec3D lookAt = m_cam->getLookAt();


  gluLookAt(camPos[0], camPos[1], camPos[2], 
              lookAt[0], lookAt[1], lookAt[2], 
              0.0f, 1.0f, 0.0f );

  // draw the shadows first
  //   used tutorial and adjusted as explained in the text (Hawkins 470).
  glPushMatrix();
    glLightfv(GL_LIGHT0, GL_POSITION, m_lightPosition);
    setShadowMatrix();

      // set up the stencil buffer so that we only draw the shadow
      // on the reflecting surface
      glEnable(GL_STENCIL_TEST);
      glStencilFunc(GL_ALWAYS, 3, 0xFFFFFFFF);
      glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
      m_floor->vrender();
      glStencilFunc(GL_LESS, 2, 0xFFFFFFFF);
      glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
      glEnable(GL_POLYGON_OFFSET_FILL);

      // draw the shadow as half-blended black
      glEnable(GL_BLEND);
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
      glDisable(GL_LIGHTING);
      glDisable(GL_TEXTURE_2D);
      glDisable(GL_DEPTH_TEST);
      glDisable(GL_FOG);
      glColor4f(0.0, 0.0, 0.0, 0.5);
  
      // project the objects through the shadow matrix
      glMultMatrixf(m_shadowMatrix);
      m_dome->vrender();
      m_lamp->vrender();
      m_endTable->vrender();
      m_torus->vrender();
      m_pawn->vrender();
      glDisable(GL_BLEND);
      glEnable(GL_LIGHTING);
      glEnable(GL_TEXTURE_2D);
      glEnable(GL_DEPTH_TEST);
      glEnable(GL_FOG);
      glDisable(GL_POLYGON_OFFSET_FILL);
      glDisable(GL_STENCIL_TEST);
  glPopMatrix();

  // now draw the real objects
  glPushMatrix();
    glLightfv(GL_LIGHT0, GL_POSITION, m_lightPosition);
    glCallList(m_dList);   // put in the boring walls 
  
    //the floor gets drawn in the shadows section
    m_dome->vrender();
    m_lamp->vrender();
    m_endTable->vrender();
    m_torus->vrender();
    m_pawn->vrender();
  glPopMatrix();

  return;
}
Exemple #28
0
void OpenGLState::Apply() const {
    // Culling
    if (cull.enabled != cur_state.cull.enabled) {
        if (cull.enabled) {
            glEnable(GL_CULL_FACE);
        } else {
            glDisable(GL_CULL_FACE);
        }
    }

    if (cull.mode != cur_state.cull.mode) {
        glCullFace(cull.mode);
    }

    if (cull.front_face != cur_state.cull.front_face) {
        glFrontFace(cull.front_face);
    }

    // Depth test
    if (depth.test_enabled != cur_state.depth.test_enabled) {
        if (depth.test_enabled) {
            glEnable(GL_DEPTH_TEST);
        } else {
            glDisable(GL_DEPTH_TEST);
        }
    }

    if (depth.test_func != cur_state.depth.test_func) {
        glDepthFunc(depth.test_func);
    }

    // Depth mask
    if (depth.write_mask != cur_state.depth.write_mask) {
        glDepthMask(depth.write_mask);
    }

    // Color mask
    if (color_mask.red_enabled != cur_state.color_mask.red_enabled ||
        color_mask.green_enabled != cur_state.color_mask.green_enabled ||
        color_mask.blue_enabled != cur_state.color_mask.blue_enabled ||
        color_mask.alpha_enabled != cur_state.color_mask.alpha_enabled) {
        glColorMask(color_mask.red_enabled, color_mask.green_enabled, color_mask.blue_enabled,
                    color_mask.alpha_enabled);
    }

    // Stencil test
    if (stencil.test_enabled != cur_state.stencil.test_enabled) {
        if (stencil.test_enabled) {
            glEnable(GL_STENCIL_TEST);
        } else {
            glDisable(GL_STENCIL_TEST);
        }
    }

    if (stencil.test_func != cur_state.stencil.test_func ||
        stencil.test_ref != cur_state.stencil.test_ref ||
        stencil.test_mask != cur_state.stencil.test_mask) {
        glStencilFunc(stencil.test_func, stencil.test_ref, stencil.test_mask);
    }

    if (stencil.action_depth_fail != cur_state.stencil.action_depth_fail ||
        stencil.action_depth_pass != cur_state.stencil.action_depth_pass ||
        stencil.action_stencil_fail != cur_state.stencil.action_stencil_fail) {
        glStencilOp(stencil.action_stencil_fail, stencil.action_depth_fail,
                    stencil.action_depth_pass);
    }

    // Stencil mask
    if (stencil.write_mask != cur_state.stencil.write_mask) {
        glStencilMask(stencil.write_mask);
    }

    // Blending
    if (blend.enabled != cur_state.blend.enabled) {
        if (blend.enabled) {
            glEnable(GL_BLEND);

            cur_state.logic_op = GL_COPY;
            glLogicOp(cur_state.logic_op);
            glDisable(GL_COLOR_LOGIC_OP);
        } else {
            glDisable(GL_BLEND);
            glEnable(GL_COLOR_LOGIC_OP);
        }
    }

    if (blend.color.red != cur_state.blend.color.red ||
        blend.color.green != cur_state.blend.color.green ||
        blend.color.blue != cur_state.blend.color.blue ||
        blend.color.alpha != cur_state.blend.color.alpha) {
        glBlendColor(blend.color.red, blend.color.green, blend.color.blue, blend.color.alpha);
    }

    if (blend.src_rgb_func != cur_state.blend.src_rgb_func ||
        blend.dst_rgb_func != cur_state.blend.dst_rgb_func ||
        blend.src_a_func != cur_state.blend.src_a_func ||
        blend.dst_a_func != cur_state.blend.dst_a_func) {
        glBlendFuncSeparate(blend.src_rgb_func, blend.dst_rgb_func, blend.src_a_func,
                            blend.dst_a_func);
    }

    if (blend.rgb_equation != cur_state.blend.rgb_equation ||
        blend.a_equation != cur_state.blend.a_equation) {
        glBlendEquationSeparate(blend.rgb_equation, blend.a_equation);
    }

    if (logic_op != cur_state.logic_op) {
        glLogicOp(logic_op);
    }

    // Textures
    for (unsigned i = 0; i < ARRAY_SIZE(texture_units); ++i) {
        if (texture_units[i].texture_2d != cur_state.texture_units[i].texture_2d) {
            glActiveTexture(GL_TEXTURE0 + i);
            glBindTexture(GL_TEXTURE_2D, texture_units[i].texture_2d);
        }
        if (texture_units[i].sampler != cur_state.texture_units[i].sampler) {
            glBindSampler(i, texture_units[i].sampler);
        }
    }

    // Lighting LUTs
    for (unsigned i = 0; i < ARRAY_SIZE(lighting_luts); ++i) {
        if (lighting_luts[i].texture_1d != cur_state.lighting_luts[i].texture_1d) {
            glActiveTexture(GL_TEXTURE3 + i);
            glBindTexture(GL_TEXTURE_1D, lighting_luts[i].texture_1d);
        }
    }

    // Fog LUT
    if (fog_lut.texture_1d != cur_state.fog_lut.texture_1d) {
        glActiveTexture(GL_TEXTURE9);
        glBindTexture(GL_TEXTURE_1D, fog_lut.texture_1d);
    }

    // Framebuffer
    if (draw.read_framebuffer != cur_state.draw.read_framebuffer) {
        glBindFramebuffer(GL_READ_FRAMEBUFFER, draw.read_framebuffer);
    }
    if (draw.draw_framebuffer != cur_state.draw.draw_framebuffer) {
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, draw.draw_framebuffer);
    }

    // Vertex array
    if (draw.vertex_array != cur_state.draw.vertex_array) {
        glBindVertexArray(draw.vertex_array);
    }

    // Vertex buffer
    if (draw.vertex_buffer != cur_state.draw.vertex_buffer) {
        glBindBuffer(GL_ARRAY_BUFFER, draw.vertex_buffer);
    }

    // Uniform buffer
    if (draw.uniform_buffer != cur_state.draw.uniform_buffer) {
        glBindBuffer(GL_UNIFORM_BUFFER, draw.uniform_buffer);
    }

    // Shader program
    if (draw.shader_program != cur_state.draw.shader_program) {
        glUseProgram(draw.shader_program);
    }

    cur_state = *this;
}
Exemple #29
0
static void
draw_edges(void)
{
    /*
     * render the offset depth image
     */
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
#ifdef GL_POLYGON_OFFSET_FILL
    glPolygonOffset(4.0, 1.0);
#else
    /* XXX should change to use glPolygonOffset in OpenGL 1.1 */
    glPolygonOffsetEXT(4.0, (1.0 / (1 << 22)));
#endif
    glEnable(GL_POLYGON_OFFSET_FILL);
    /* glColorMask(0,0,0,0); */
    glCallList(1);
    /* glColorMask(1,1,1,1); */
    glDisable(GL_POLYGON_OFFSET_FILL);

    /*
     *  make no further changes to the depth image
     */
    glDepthMask(0);
    glDisable(GL_DEPTH_TEST);	/* XXX */
    glEnable(GL_DEPTH_TEST);	/* XXX */

    /*
     * cull all facets of one (arbitrary) orientation.  render the
     * remaining facets in outline mode, toggling the stencil bit
     * at each pixel.
     */
    glDisable(GL_LIGHTING);
    glColor3f(0.f, 0.f, 0.f);
    glLineWidth(2.0);
    glEnable(GL_STENCIL_TEST);
    glStencilFunc(GL_ALWAYS, 0, 1);
    glStencilOp(GL_KEEP, GL_KEEP, GL_INVERT);
    glEnable(GL_CULL_FACE);
    glColorMask(0, 0, 0, 0);
    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    glCallList(1);
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    glColorMask(1, 1, 1, 1);
    glDisable(GL_CULL_FACE);

    /*
     * color all pixels in the framebuffer with stencil value 1
     */
    glStencilFunc(GL_EQUAL, 1, 1);
    glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
    glColor3f(0, 0, 0);
    fill_window();
    glDisable(GL_STENCIL_TEST);

    /*
     * draw all true edges, testing against the depth image
     */
    glColor3f(0, 0, 0);
    glCallList(2);

    /*
     * return state to default values
     */
    glDepthMask(1);
    glDisable(GL_DEPTH_TEST);	/* XXX */
    glEnable(GL_DEPTH_TEST);	/* XXX */
    if (lighting)
	glEnable(GL_LIGHTING);
    glLineWidth(1.0);
    glColor3f(1.f, 1.f, 1.f);
}
void Robot::applyShadow(GLfloat rows, GLfloat columns) {
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable(GL_BLEND);
        glDisable(GL_LIGHTING);
         if (calculateAlpha(0, 0, rows, columns) >=0) {
             glPushMatrix();
                glEnable(GL_STENCIL_TEST);
                glStencilFunc(GL_EQUAL, 10, ~0);
                glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
                glTranslatef(xPos, 0.02f, zPos); 
                TextureManager::getInstance()->toggleTextures();
                shadowMatrix(0-xPos, 12, 0-zPos, 1.0f);
                
                glColor4f(0.0, 0.0, 0.0, calculateAlpha(0, 0, rows, columns));
                model->draw();
                //draw();
                TextureManager::getInstance()->toggleTextures();
                
                 glDisable(GL_STENCIL_TEST); 
             glPopMatrix();
         }
            if (calculateAlpha(0, rows, rows, columns) >=0) {
            glPushMatrix();
                glEnable(GL_STENCIL_TEST);
                glStencilFunc(GL_EQUAL, 10, ~0);
                glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
                glTranslatef(xPos, 0.02f, zPos); 
                TextureManager::getInstance()->toggleTextures();
                shadowMatrix(0-xPos, 12, rows-zPos, 1.0f);
                glColor4f(0.0, 0.0, 0.0, calculateAlpha(0, rows, rows, columns));
                model->draw();
                //draw();
                TextureManager::getInstance()->toggleTextures();
                glDisable(GL_STENCIL_TEST); 
             glPopMatrix();
            }
            if (calculateAlpha(columns, 0, rows, columns) >=0) {
            glPushMatrix();
                glEnable(GL_STENCIL_TEST);
                glStencilFunc(GL_EQUAL, 10, ~0);
                glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
                glTranslatef(xPos, 0.02f, zPos); 
                TextureManager::getInstance()->toggleTextures();
                shadowMatrix(columns-xPos, 12, 0-zPos, 1.0f);
                glColor4f(0.0, 0.0, 0.0, calculateAlpha(columns, 0, rows, columns));
                model->draw();
                //draw();
                TextureManager::getInstance()->toggleTextures();
                glDisable(GL_STENCIL_TEST); 
             glPopMatrix();
            }
            if (calculateAlpha(columns, rows, rows, columns) >=0) {
            glPushMatrix();
                glEnable(GL_STENCIL_TEST);
                glStencilFunc(GL_EQUAL, 10, ~0);
                glStencilOp(GL_KEEP, GL_KEEP, GL_ZERO);
                glTranslatef(xPos, 0.02f, zPos); 
                TextureManager::getInstance()->toggleTextures();
                shadowMatrix(columns-xPos, 12, rows-zPos, 1.0f);
                glColor4f(0.0, 0.0, 0.0, calculateAlpha(columns, rows, rows, columns));
                model->draw();
                //draw();
                TextureManager::getInstance()->toggleTextures();
                glDisable(GL_STENCIL_TEST); 
             glPopMatrix();
            }
    //}
    //glDisable(GL_TEXTURE_2D);
                
                
                
                
                //glDisable(GL_STENCIL_TEST);  
       // glPopMatrix();
                    
        glEnable(GL_DEPTH_TEST);
        glDisable(GL_BLEND);
        glEnable(GL_LIGHTING);
        //glEnable(GL_COLOR_MATERIAL);
    //}
    
}