Changeset 2762


Ignore:
Timestamp:
Jun 22, 2013, 5:31:19 PM (8 years ago)
Author:
sam
Message:

gpu: implement all depth test functions in the renderer.

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/core.h

    r2761 r2762  
    8686
    8787
    88 /* XXX: workaround for X11 headers that try to #define None */
     88/* XXX: workaround for X11 headers that try to #define these */
     89#undef Always
     90#define Always Always
    8991#undef None
    9092#define None None
  • trunk/src/gpu/rendercontext.cpp

    r2761 r2762  
    5858    TrackedState<float> m_clear_depth;
    5959    TrackedState<bool> m_alpha_blend;
    60     TrackedState<BlendFactor> m_blend_src;
    61     TrackedState<BlendFactor> m_blend_dst;
     60    TrackedState<BlendFunc> m_blend_src;
     61    TrackedState<BlendFunc> m_blend_dst;
    6262    TrackedState<bool> m_alpha_test;
    63     TrackedState<bool> m_depth_test;
     63    TrackedState<DepthFunc> m_depth_func;
    6464    TrackedState<CullMode> m_face_culling;
    6565};
     
    9393        g_renderer->SetAlphaTest(m_data->m_alpha_test.GetValue());
    9494
    95     if (m_data->m_depth_test.HasChanged())
    96         g_renderer->SetDepthTest(m_data->m_depth_test.GetValue());
     95    if (m_data->m_depth_func.HasChanged())
     96        g_renderer->SetDepthFunc(m_data->m_depth_func.GetValue());
    9797
    9898    if (m_data->m_face_culling.HasChanged())
     
    126126}
    127127
    128 void RenderContext::SetBlendFunc(BlendFactor src, BlendFactor dst)
     128void RenderContext::SetBlendFunc(BlendFunc src, BlendFunc dst)
    129129{
    130130    if (!m_data->m_blend_src.HasChanged())
     
    144144}
    145145
    146 void RenderContext::SetDepthTest(bool set)
     146void RenderContext::SetDepthFunc(DepthFunc func)
    147147{
    148     if (!m_data->m_depth_test.HasChanged())
    149         m_data->m_depth_test.TrackValue(g_renderer->GetDepthTest());
     148    if (!m_data->m_depth_func.HasChanged())
     149        m_data->m_depth_func.TrackValue(g_renderer->GetDepthFunc());
    150150
    151     g_renderer->SetDepthTest(set);
     151    g_renderer->SetDepthFunc(func);
    152152}
    153153
  • trunk/src/gpu/renderer.cpp

    r2761 r2762  
    5656    vec4 m_clear_color;
    5757    float m_clear_depth;
    58     BlendFactor m_blend_src, m_blend_dst;
     58    BlendFunc m_blend_src, m_blend_dst;
     59    DepthFunc m_depth_func;
    5960    CullMode m_face_culling;
    60     bool m_alpha_blend, m_alpha_test, m_depth_test;
     61    bool m_alpha_blend, m_alpha_test;
    6162
    6263#if defined USE_D3D9
     
    102103    SetAlphaTest(false);
    103104
    104     m_data->m_blend_src = BlendFactor::Zero;
    105     m_data->m_blend_dst = BlendFactor::Zero;
    106     SetBlendFunc(BlendFactor::SrcAlpha, BlendFactor::OneMinusSrcAlpha);
    107 
    108     m_data->m_depth_test = false;
    109     SetDepthTest(true);
    110 
    111     m_data->m_face_culling = CullMode::None;
    112     SetFaceCulling(CullMode::CCW);
     105    m_data->m_blend_src = BlendFunc::Zero;
     106    m_data->m_blend_dst = BlendFunc::Zero;
     107    SetBlendFunc(BlendFunc::SrcAlpha, BlendFunc::OneMinusSrcAlpha);
     108
     109    m_data->m_depth_func = DepthFunc::Disabled;
     110    SetDepthFunc(DepthFunc::LessOrEqual);
     111
     112    m_data->m_face_culling = CullMode::Disabled;
     113    SetFaceCulling(CullMode::CounterClockwise);
    113114
    114115    /* Add some rendering states that we don't export to the user */
     
    199200 */
    200201
    201 void Renderer::SetBlendFunc(BlendFactor src, BlendFactor dst)
     202void Renderer::SetBlendFunc(BlendFunc src, BlendFunc dst)
    202203{
    203204    if (m_data->m_blend_src == src && m_data->m_blend_dst == dst)
     
    206207#if defined USE_D3D9 || defined _XBOX
    207208    enum D3DBLEND s1[2] = { D3DBLEND_ONE, D3DBLEND_ZERO };
    208     BlendFactor s2[2] = { src, dst };
     209    BlendFunc s2[2] = { src, dst };
    209210
    210211    for (int i = 0; i < 2; ++i)
     
    212213        switch (s2[i])
    213214        {
    214             case BlendFactor::Zero:
     215            case BlendFunc::Zero:
    215216                s1[i] = D3DBLEND_ZERO; break;
    216             case BlendFactor::One:
     217            case BlendFunc::One:
    217218                s1[i] = D3DBLEND_ONE; break;
    218             case BlendFactor::SrcColor:
     219            case BlendFunc::SrcColor:
    219220                s1[i] = D3DBLEND_SRCCOLOR; break;
    220             case BlendFactor::OneMinusSrcColor:
     221            case BlendFunc::OneMinusSrcColor:
    221222                s1[i] = D3DBLEND_INVSRCCOLOR; break;
    222             case BlendFactor::DstColor:
     223            case BlendFunc::DstColor:
    223224                s1[i] = D3DBLEND_DESTCOLOR; break;
    224             case BlendFactor::OneMinusDstColor:
     225            case BlendFunc::OneMinusDstColor:
    225226                s1[i] = D3DBLEND_INVDESTCOLOR; break;
    226             case BlendFactor::SrcAlpha:
     227            case BlendFunc::SrcAlpha:
    227228                s1[i] = D3DBLEND_SRCALPHA; break;
    228             case BlendFactor::OneMinusSrcAlpha:
     229            case BlendFunc::OneMinusSrcAlpha:
    229230                s1[i] = D3DBLEND_INVSRCALPHA; break;
    230             case BlendFactor::DstAlpha:
     231            case BlendFunc::DstAlpha:
    231232                s1[i] = D3DBLEND_DESTALPHA; break;
    232             case BlendFactor::OneMinusDstAlpha:
     233            case BlendFunc::OneMinusDstAlpha:
    233234                s1[i] = D3DBLEND_INVDESTALPHA; break;
    234235            /* FiXME: these can be supported using D3DPBLENDCAPS_BLENDFACTOR */
    235             case BlendFactor::ConstantColor:
    236                 assert(0, "BlendFactor::ConstantColor not supported");
     236            case BlendFunc::ConstantColor:
     237                assert(0, "BlendFunc::ConstantColor not supported");
    237238                break;
    238             case BlendFactor::OneMinusConstantColor:
    239                 assert(0, "BlendFactor::OneMinusConstantColor not supported");
     239            case BlendFunc::OneMinusConstantColor:
     240                assert(0, "BlendFunc::OneMinusConstantColor not supported");
    240241                break;
    241             case BlendFactor::ConstantAlpha:
    242                 assert(0, "BlendFactor::ConstantAlpha not supported");
     242            case BlendFunc::ConstantAlpha:
     243                assert(0, "BlendFunc::ConstantAlpha not supported");
    243244                break;
    244             case BlendFactor::OneMinusConstantAlpha:
    245                 assert(0, "BlendFactor::OneMinusConstantAlpha not supported");
     245            case BlendFunc::OneMinusConstantAlpha:
     246                assert(0, "BlendFunc::OneMinusConstantAlpha not supported");
    246247                break;
    247248        }
     
    252253#else
    253254    GLenum s1[2] = { GL_ONE, GL_ZERO };
    254     BlendFactor s2[2] = { src, dst };
     255    BlendFunc s2[2] = { src, dst };
    255256
    256257    for (int i = 0; i < 2; ++i)
     
    258259        switch (s2[i])
    259260        {
    260             case BlendFactor::Zero:
     261            case BlendFunc::Zero:
    261262                s1[i] = GL_ZERO; break;
    262             case BlendFactor::One:
     263            case BlendFunc::One:
    263264                s1[i] = GL_ONE; break;
    264             case BlendFactor::SrcColor:
     265            case BlendFunc::SrcColor:
    265266                s1[i] = GL_SRC_COLOR; break;
    266             case BlendFactor::OneMinusSrcColor:
     267            case BlendFunc::OneMinusSrcColor:
    267268                s1[i] = GL_ONE_MINUS_SRC_COLOR; break;
    268             case BlendFactor::DstColor:
     269            case BlendFunc::DstColor:
    269270                s1[i] = GL_DST_COLOR; break;
    270             case BlendFactor::OneMinusDstColor:
     271            case BlendFunc::OneMinusDstColor:
    271272                s1[i] = GL_ONE_MINUS_DST_COLOR; break;
    272             case BlendFactor::SrcAlpha:
     273            case BlendFunc::SrcAlpha:
    273274                s1[i] = GL_SRC_ALPHA; break;
    274             case BlendFactor::OneMinusSrcAlpha:
     275            case BlendFunc::OneMinusSrcAlpha:
    275276                s1[i] = GL_ONE_MINUS_SRC_ALPHA; break;
    276             case BlendFactor::DstAlpha:
     277            case BlendFunc::DstAlpha:
    277278                s1[i] = GL_DST_ALPHA; break;
    278             case BlendFactor::OneMinusDstAlpha:
     279            case BlendFunc::OneMinusDstAlpha:
    279280                s1[i] = GL_ONE_MINUS_DST_ALPHA; break;
    280             case BlendFactor::ConstantColor:
     281            case BlendFunc::ConstantColor:
    281282                s1[i] = GL_CONSTANT_COLOR; break;
    282             case BlendFactor::OneMinusConstantColor:
     283            case BlendFunc::OneMinusConstantColor:
    283284                s1[i] = GL_ONE_MINUS_CONSTANT_COLOR; break;
    284             case BlendFactor::ConstantAlpha:
     285            case BlendFunc::ConstantAlpha:
    285286                s1[i] = GL_CONSTANT_ALPHA; break;
    286             case BlendFactor::OneMinusConstantAlpha:
     287            case BlendFunc::OneMinusConstantAlpha:
    287288                s1[i] = GL_ONE_MINUS_CONSTANT_ALPHA; break;
    288289        }
     
    296297}
    297298
    298 BlendFactor Renderer::GetBlendFuncSrc() const
     299BlendFunc Renderer::GetBlendFuncSrc() const
    299300{
    300301    return m_data->m_blend_src;
    301302}
    302303
    303 BlendFactor Renderer::GetBlendFuncDst() const
     304BlendFunc Renderer::GetBlendFuncDst() const
    304305{
    305306    return m_data->m_blend_dst;
     
    336337 */
    337338
    338 void Renderer::SetDepthTest(bool set)
    339 {
    340     if (m_data->m_depth_test == set)
     339void Renderer::SetDepthFunc(DepthFunc func)
     340{
     341    if (m_data->m_depth_func == func)
    341342        return;
    342343
    343344#if defined USE_D3D9 || defined _XBOX
    344 #   define STR0(x) #x
    345 #   define STR(x) STR0(x)
    346 #   pragma message(__FILE__ "(" STR(__LINE__) "): warning: Renderer::SetDepthTest() not implemented")
    347 #else
    348     if (set)
     345    switch (func)
     346    {
     347        case DepthFunc::Disabled:
     348            break; /* Nothing to do */
     349        case DepthFunc::Never:
     350            m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_NEVER);
     351            break;
     352        case DepthFunc::Less:
     353            m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESS);
     354            break;
     355        case DepthFunc::Equal:
     356            m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_EQUAL);
     357            break;
     358        case DepthFunc::LessOrEqual:
     359            m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
     360            break;
     361        case DepthFunc::Greater:
     362            m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_GREATER);
     363            break;
     364        case DepthFunc::NotEqual:
     365            m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_NOTEQUAL);
     366            break;
     367        case DepthFunc::GreaterOrEqual:
     368            m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_GREATEREQUAL);
     369            break;
     370        case DepthFunc::Always:
     371            m_data->m_d3d_dev->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
     372            break;
     373    }
     374
     375    if (func == DepthFunc::Disabled)
     376        m_data->m_d3d_dev->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
     377    else
     378        m_data->m_d3d_dev->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
     379#else
     380    switch (func)
     381    {
     382        case DepthFunc::Disabled:
     383            break; /* Nothing to do */
     384        case DepthFunc::Never:
     385            glDepthFunc(GL_NEVER); break;
     386        case DepthFunc::Less:
     387            glDepthFunc(GL_LESS); break;
     388        case DepthFunc::Equal:
     389            glDepthFunc(GL_EQUAL); break;
     390        case DepthFunc::LessOrEqual:
     391            glDepthFunc(GL_LEQUAL); break;
     392        case DepthFunc::Greater:
     393            glDepthFunc(GL_GREATER); break;
     394        case DepthFunc::NotEqual:
     395            glDepthFunc(GL_NOTEQUAL); break;
     396        case DepthFunc::GreaterOrEqual:
     397            glDepthFunc(GL_GEQUAL); break;
     398        case DepthFunc::Always:
     399            glDepthFunc(GL_ALWAYS); break;
     400    }
     401
     402    if (func == DepthFunc::Disabled)
     403        glDisable(GL_DEPTH_TEST);
     404    else
    349405        glEnable(GL_DEPTH_TEST);
    350     else
    351         glDisable(GL_DEPTH_TEST);
    352 #endif
    353 
    354     m_data->m_depth_test = set;
    355 }
    356 
    357 bool Renderer::GetDepthTest() const
    358 {
    359     return m_data->m_depth_test;
     406#endif
     407
     408    m_data->m_depth_func = func;
     409}
     410
     411DepthFunc Renderer::GetDepthFunc() const
     412{
     413    return m_data->m_depth_func;
    360414}
    361415
     
    372426    switch (mode)
    373427    {
    374     case CullMode::None:
     428    case CullMode::Disabled:
    375429        m_data->m_d3d_dev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    376430        break;
    377     case CullMode::CW:
     431    case CullMode::Clockwise:
    378432        m_data->m_d3d_dev->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
    379433        break;
    380     case CullMode::CCW:
     434    case CullMode::CounterClockwise:
    381435        m_data->m_d3d_dev->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
    382436        break;
     
    385439    switch (mode)
    386440    {
    387     case CullMode::None:
     441    case CullMode::Disabled:
    388442        glDisable(GL_CULL_FACE);
    389443        break;
    390     case CullMode::CW:
     444    case CullMode::Clockwise:
    391445        glEnable(GL_CULL_FACE);
    392446        glFrontFace(GL_CW);
    393447        break;
    394     case CullMode::CCW:
     448    case CullMode::CounterClockwise:
    395449        glEnable(GL_CULL_FACE);
    396450        glFrontFace(GL_CCW);
  • trunk/src/lol/gpu/rendercontext.h

    r2761 r2762  
    3131    void SetClearDepth(float depth);
    3232    void SetAlphaBlend(bool set);
    33     void SetBlendFunc(BlendFactor src, BlendFactor dst);
     33    void SetBlendFunc(BlendFunc src, BlendFunc dst);
    3434    void SetAlphaTest(bool set);
    35     void SetDepthTest(bool set);
     35    void SetDepthFunc(DepthFunc func);
    3636    void SetFaceCulling(CullMode mode);
    3737
  • trunk/src/lol/gpu/renderer.h

    r2761 r2762  
    2323
    2424/* A safe enum to indicate the blending factors. */
    25 struct BlendFactor
     25struct BlendFunc
    2626{
    2727    enum Value
     
    4444    m_value;
    4545
    46     inline BlendFactor() : m_value(Zero) {}
    47     inline BlendFactor(Value v) : m_value(v) {}
     46    inline BlendFunc() : m_value(Zero) {}
     47    inline BlendFunc(Value v) : m_value(v) {}
    4848    inline operator Value() { return m_value; }
    4949};
     
    5454    enum Value
    5555    {
    56         None,
    57         CW,
    58         CCW,
     56        Disabled,
     57        Clockwise,
     58        CounterClockwise,
    5959    }
    6060    m_value;
    6161
    62     inline CullMode() : m_value(None) {}
     62    inline CullMode() : m_value(Disabled) {}
    6363    inline CullMode(Value v) : m_value(v) {}
     64    inline operator Value() { return m_value; }
     65};
     66
     67/* A safe enum to indicate the depth test mode. */
     68struct DepthFunc
     69{
     70    enum Value
     71    {
     72        Disabled,
     73        Never,
     74        Less,
     75        Equal,
     76        LessOrEqual,
     77        Greater,
     78        NotEqual,
     79        GreaterOrEqual,
     80        Always,
     81    }
     82    m_value;
     83
     84    inline DepthFunc() : m_value(Disabled) {}
     85    inline DepthFunc(Value v) : m_value(v) {}
    6486    inline operator Value() { return m_value; }
    6587};
     
    84106    bool GetAlphaBlend() const;
    85107
    86     void SetBlendFunc(BlendFactor src, BlendFactor dst);
    87     BlendFactor GetBlendFuncSrc() const;
    88     BlendFactor GetBlendFuncDst() const;
     108    void SetBlendFunc(BlendFunc src, BlendFunc dst);
     109    BlendFunc GetBlendFuncSrc() const;
     110    BlendFunc GetBlendFuncDst() const;
    89111
    90112    void SetAlphaTest(bool set);
    91113    bool GetAlphaTest() const;
    92114
    93     void SetDepthTest(bool set);
    94     bool GetDepthTest() const;
     115    void SetDepthFunc(DepthFunc func);
     116    DepthFunc GetDepthFunc() const;
    95117
    96118    void SetFaceCulling(CullMode mode);
  • trunk/src/scene.cpp

    r2760 r2762  
    193193{
    194194    RenderContext rc;
    195     rc.SetDepthTest(true);
     195    rc.SetDepthFunc(DepthFunc::LessOrEqual);
    196196    rc.SetAlphaBlend(true);
    197     rc.SetBlendFunc(BlendFactor::SrcAlpha, BlendFactor::OneMinusSrcAlpha);
     197    rc.SetBlendFunc(BlendFunc::SrcAlpha, BlendFunc::OneMinusSrcAlpha);
    198198
    199199#if defined USE_D3D9 || defined _XBOX
    200200#else
    201     glDepthFunc(GL_LEQUAL);
    202201#if defined HAVE_GL_2X && !defined __APPLE__
    203202    glEnable(GL_ALPHA_TEST);
  • trunk/tools/neercs/video/render.cpp

    r2760 r2762  
    14541454    RenderContext rc;
    14551455    rc.SetAlphaBlend(true);
    1456     rc.SetBlendFunc(BlendFactor::SrcColor, BlendFactor::DstAlpha);
     1456    rc.SetBlendFunc(BlendFunc::SrcColor, BlendFunc::DstAlpha);
    14571457
    14581458    glEnable(GL_TEXTURE_2D);
     
    14811481    RenderContext rc;
    14821482    rc.SetAlphaBlend(false);
    1483     rc.SetDepthTest(false);
     1483    rc.SetDepthFunc(DepthFunc::Disabled);
    14841484
    14851485    glEnableClientState(GL_VERTEX_ARRAY);
  • trunk/tools/neercs/video/text-render.cpp

    r2752 r2762  
    146146    {
    147147        RenderContext rc;
    148         rc.SetDepthTest(false);
     148        rc.SetDepthFunc(DepthFunc::Disabled);
    149149
    150150        glViewport(0, 0, m_fbo_size.x, m_fbo_size.y);
  • trunk/tutorial/08_fbo.cpp

    r2753 r2762  
    9191        /* FIXME: we should just disable depth test in the shader */
    9292        RenderContext rc;
    93         rc.SetDepthTest(false);
     93        rc.SetDepthFunc(DepthFunc::Disabled);
    9494
    9595        m_fbo->Bind();
Note: See TracChangeset for help on using the changeset viewer.