back  Return to list

homeprevnext Name
homeprevnext Name Strings
homeprevnext Contact
    Eric Werness, NVIDIA (ewerness 'at'  
    Pat Brown, NVIDIA (pbrown 'at'  
homeprevnext Status
homeprevnext Version
    Last Modified Date:         11/29/2007  
    NVIDIA Revision:            2  
homeprevnext Number
homeprevnext Dependencies
    The extension is written against the OpenGL 2.0 Specification.  
    ARB_occlusion_query or OpenGL 1.5 is required.  
homeprevnext Overview
    This extension provides support for conditional rendering based on the  
    results of an occlusion query.  This mechanism allows an application to  
    potentially reduce the latency between the completion of an occlusion  
    query and the rendering commands depending on its result.  It additionally  
    allows the decision of whether to render to be made without application  
    This extension defines two new functions, BeginConditionalRenderNV and  
    EndConditionalRenderNV, between which rendering commands may be discarded  
    based on the results of an occlusion query.  If the specified occlusion  
    query returns a non-zero value, rendering commands between these calls are  
    executed.  If the occlusion query returns a value of zero, all rendering  
    commands between the calls are discarded.  
    If the occlusion query results are not available when  
    BeginConditionalRenderNV is executed, the <mode> parameter specifies  
    whether the GL should wait for the query to complete or should simply  
    render the subsequent geometry unconditionally.  
    Additionally, the extension provides a set of "by region" modes, allowing  
    for implementations that divide rendering work by screen regions to  
    perform the conditional query test on a region-by-region basis without  
    checking the query results from other regions.  Such a mode is useful for  
    cases like split-frame SLI, where a frame is divided between multiple  
    GPUs, each of which has its own occlusion query hardware.  
homeprevnext New Procedures and Functions
    void BeginConditionalRenderNV(uint id, enum mode);  
    void EndConditionalRenderNV(void);  
homeprevnext New Tokens
    Accepted by the <mode> parameter of BeginConditionalRenderNV:  
        QUERY_WAIT_NV                                   0x8E13  
        QUERY_NO_WAIT_NV                                0x8E14  
        QUERY_BY_REGION_WAIT_NV                         0x8E15  
        QUERY_BY_REGION_NO_WAIT_NV                      0x8E16  
homeprevnext Additions to Chapter 2 of the OpenGL 2.0 Specification (OpenGL Operation)
   (Incorporate the spec edits from the EXT_transform_feedback specification  
   that move the "Occlusion Queries" Section 4.1.7 -- to between Section 2.11,  
   Coordinate Transforms and Section 2.12, Clipping, and rename it to  
   "Asynchronous Queries".  Insert a new section immediately after the moved  
   "Asynchronous Queries" section.  If EXT_transform_feedback is incorporated,  
   this section should be inserted prior the the "Transform Feedback"  
    Section 2.X, Conditional Rendering  
    Conditional rendering can be used to discard rendering commands based on  
    the result of an occlusion query.  Conditional rendering is started and  
    stopped using the commands  
        void BeginConditionalRenderNV(uint id, enum mode);  
        void EndConditionalRenderNV(void);  
    <id> specifies the name of an occlusion query object whose results are  
    used to determine if the rendering commands are discarded.  If the result  
    (SAMPLES_PASSED) of the query is zero, all rendering commands between  
    BeginConditionalRenderNV and the corresponding EndConditionalRenderNV  
    are discarded.  In this case, Begin, End, all vertex array commands  
    performing an implicit Begin and End, DrawPixels (section 3.6), Bitmap  
    (section 3.7), Clear (section 4.2.3), Accum (section 4.2.4), CopyPixels  
    (section 4.3.3), EvalMesh1, and EvalMesh2 (section 5.1) have no effect.  
    The effect of commands setting current vertex state (e.g., Color,  
    VertexAttrib) is undefined.  If the result of the occlusion query is  
    non-zero, such commands are not discarded.  
    <mode> specifies how BeginConditionalRenderNV interprets the results of  
    the occlusion query given by <id>.  If <mode> is QUERY_WAIT_NV, the GL  
    waits for the results of the query to be available and then uses the  
    results to determine if subsquent rendering commands are discarded.  If  
    <mode> is QUERY_NO_WAIT_NV, the GL may choose to unconditionally execute  
    the subsequent rendering commands without waiting for the query to  
    If <mode> is QUERY_BY_REGION_WAIT_NV, the GL will also wait for occlusion  
    query results and discard rendering commands if the result of the  
    occlusion query is zero.  If the query result is non-zero, subsequent  
    rendering commands are executed, but the GL may discard the results of the  
    commands for any region of the framebuffer that did not contribute to the  
    sample count in the specified occlusion query.  Any such discarding is  
    done in an implementation-dependent manner, but the rendering command  
    results may not be discarded for any samples that contributed to the  
    occlusion query sample count.  If <mode> is QUERY_BY_REGION_NO_WAIT_NV,  
    the GL operates as in QUERY_BY_REGION_WAIT_NV, but may choose to  
    unconditionally execute the subsequent rendering commands without waiting  
    for the query to complete.  
    If BeginConditionalRenderNV is called while conditional rendering is in  
    progress, or if EndConditionalRenderNV is called while conditional  
    rendering is not in progress, the error INVALID_OPERATION is generated.  
    The error INVALID_VALUE is generated if <id> is not the name of an  
    existing query object query.  The error INVALID_OPERATION is generated if  
    <id> is the name of a query object with a target other than  
    SAMPLES_PASSED, or <id> is the name of a query currently in progress.  
homeprevnext Additions to Chapter 3 of the OpenGL 2.0 Specification (Rasterization)
homeprevnext Additions to Chapter 4 of the OpenGL 2.0 Specification (Per-Fragment Operations and the Frame Buffer)
homeprevnext Additions to Chapter 5 of the OpenGL 2.0 Specification (Special Functions)
homeprevnext Additions to Chapter 6 of the OpenGL 2.0 Specification (State and State Requests)
homeprevnext Additions to Appendix A of the OpenGL 2.0 Specification (Invariance)
homeprevnext Additions to the AGL/GLX/WGL Specifications
homeprevnext GLX Protocol
homeprevnext Errors
    INVALID_OPERATION is generated by BeginConditionalRenderNV if a previous  
    BeginConditionalRenderNV command has been executed without a  
    corresponding EndConditionalRenderNV command.  
    INVALID_OPERATION is generated by EndConditionalRenderNV if no  
    corresponding BeginConditionalRenderNV command has been executed.  
    INVALID_VALUE is generated by BeginConditionalRenderNV if <id> is not the  
    name of an existing occlusion query object.  
    INVALID_OPERATION is generated by BeginConditionalRenderNV if <id> is the  
    name of a query object with a <target> other than SAMPLES_PASSED.  
    INVALID_OPERAITON is generated by BeginConditionalRenderNV if the query  
    identified by <id> is still in progress.  
homeprevnext Issues
    (1) How should rendering commands other than "normal" Begin/End-style  
    geometry be affected by conditional rendering?  
      RESOLVED:  All rendering commands (DrawPixels, Bitmap, Clear, Accum,  
      etc...) are performed conditionally.  
    (2) What does NO_WAIT do, and why would anyone care?  
      RESOLVED:  Hardware OpenGL implementations are heavily pipelined.  After  
      vertices are transformed, they are assembled into primitives and  
      rasterized.  While a GPU is rasterizing a primitive, it may be  
      simultaneously transforming the vertices of the next primitive provided  
      to the GL.  At the same time, the CPU may be preparing hardware commands  
      to process primitives following that one.    
      Conditional rendering uses the results of rasterizing one primitive (an  
      occlusion query) to determine whether it will process subsequent ones.  
      In a pipelined implementation, the initial set of primitives may not be  
      finished drawing by the time the GL needs the occlusion query results.  
      Waiting for the query results will leave portions of the GPU temporarily  
      idle.  It may be preferable to avoid the idle time by proceeding with a  
      conservative assumption that the primitives rendered during the  
      occlusion query will hit at least one sample.  The NO_WAIT <mode>  
      parameter tells the driver move ahead in that case.  
      For best performance, applications should attempt to insert some amount  
      of non-dependent rendering between an occlusion query and the  
      conditionally-rendered primitives that depend on the query result.  
    (3) What does BY_REGION do, and why should anyone care?  
      RESOLVED:  Conditional rendering may be used for a variety of effects.  
      Some of these use conditional rendering only for performance.  One  
      common use would be to draw a bounding box for a primitive  
      unconditionally with an occlusion query active, and then conditionally  
      execute a DrawElements call to draw the full (complex) primitive.  If  
      the bounding box is not visible, any work needed to process the full  
      primitive can be skipped in the conditional rendering pass.  
      In a split-screen SLI implementation, one GPU might draw the top half of  
      the scene while a second might draw the bottom half.  The results of the  
      occlusion query would normally be obtained by combining individual  
      occlusion query results from each half of the screen.  However, it is  
      not necessary to do this for the bounding box algorithm.  We could skip  
      this synchronization point, and each region could instead use only its  
      local occlusion query results.  If the bounding box hits only the bottom  
      half of the screen, the complex primitive need not be drawn on the top  
      half, because that portion is known not to be visible.  The bottom half  
      would still be drawn, but the GPU used for the top half could skip it  
      and start drawing the next primitive specified.  The  
      QUERY_BY_REGION_*_NV modes would be useful in that case.  
      However, some algorithms may require conditional rendering for  
      correctness.  For example, an application may want to render a  
      post-processing effect that should be drawn if and only if a point is  
      visible in the scene.  Drawing only half of such an effect due to  
      BY_REGION tests would not be desirable.  
      For QUERY_BY_REGION_NO_WAIT_NV, we expect that GL implementations using  
      region-based rendering will discard rendering commands in any region  
      where query results are available and the region's sample count is zero.  
      Rendering would proceed normally in all other regions.  The spec  
      language doesn't require such behavior, however.  
    (4) Should the <mode> parameter passed to BeginConditionalRenderNV be  
    specified as a hint instead?  
      RESOLVED:  The "wait" or "don't wait" portion of the <mode> parameter  
      could be a hint.  But it doesn't fit nicely with the FASTEST or NICEST  
      values that are normally passed to Hint.  Providing this functionality  
      via a <mode> parameter to BeginConditionalRenderNV seems to make the  
      most sense.  Note that the <mode> parameter is specified such that  
      QUERY_NO_WAIT_NV can be implemented as though QUERY_WAIT_NV were  
      specified, which makes the "NO_WAIT" part of the mode a hint.  
      The "BY_REGION" part is also effectively a hint.  These modes may be  
      implemented as though the equivalent non-BY_REGION mode were provided.  
      Many OpenGL implementations will do all of their processing in a single  
    (5) What happens if BeginQuery is called while the specified occlusion  
    query is begin used for conditional rendering?  
      RESOLVED:  An INVALID_OPERATION error is generated.  
    (6) Should conditional rendering work with any type of query other than  
    SAMPLES_PASSED (occlusion)?  
      RESOLVED:  Not in this extension.  The spec currently requires that <id>  
      be the name of an occlusion query.  There might be other query types  
      where such an operation would make sense, but there aren't any in the  
      current OpenGL spec.  
    (7) What is the effect on current state for immediate mode attribute calls  
    (e.g., Color, VertexAttrib) made during conditional rendering if the  
    corresponding occlusion query failed?  
      RESOLVED:  The effect of these calls is undefined.  If subsequent  
      primitives depend on a vertex attribute set inside a conditional  
      rendering block, and application should re-send the values after  
    (8) Should we provide any new query object types for conditional  
      RESOLVED:  No.  It may be useful to some GL implementations to provide  
      an occlusion query type that only returns "zero" or "non-zero", or to  
      provide a query type that is used only for conditional rendering but  
      doesn't have to maintain results that can be returned to the  
      application.  However, performing conditional rendering using only the  
      occlusion query mechanisms already in core OpenGL is sufficient for  
      the platforms targeted by this extension.  
   (9) What happens if QUERY_BY_REGION_* is used, and the application switches  
   between windows or FBOs between the occlusion query and conditional  
   rendering blocks?  The "regions" used for the two operations may not be  
     RESOLVED:  The spec language doesn't specifically address this issue, and  
     implementations may choose to define regions arbitrarily in this case.  
     We strongly recommend that applications using QUERY_BY_REGION_* should  
     not change windows or FBO configuration between the occlusion query and  
     the dependent rendering.  
Usage Example  
    GLuint queryID = 0x12345678;  
    // Use an occlusion query while rendering the bounding box of the real  
    // object.   
    glBeginQuery(GL_SAMPLES_PASSED, queryID);  
    // Do some unrelated rendering in hope that the query result will be  
    // available by the time we call glBeginConditionalRenderNV.  
    // Now conditionally render the real object if any portion of its  
    // bounding box is visible.  
    glBeginConditionalRenderNV(queryID, GL_QUERY_WAIT_NV);  
homeprevnext Revision History
    Rev.    Date    Author    Changes  
    ----  --------  --------  --------------------------------------------  
     2    11/29/07  ewerness  First public release  
     1                        Internal revisions  
     1                        Internal revisions  
Valid XHTML 1.1! Valid CSS! Last update: November 14, 2006.
Cette page doit être lue avec un navigateur récent respectant le standard XHTML 1.1.