Changeset 2764


Ignore:
Timestamp:
Jun 22, 2013, 8:33:56 PM (8 years ago)
Author:
sam
Message:

gpu: add full support for alpha test in GL and D3D.

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/gpu/rendercontext.cpp

    r2762 r2764  
    5656
    5757    TrackedState<vec4> m_clear_color;
     58
    5859    TrackedState<float> m_clear_depth;
    59     TrackedState<bool> m_alpha_blend;
    60     TrackedState<BlendFunc> m_blend_src;
    61     TrackedState<BlendFunc> m_blend_dst;
    62     TrackedState<bool> m_alpha_test;
     60
     61    TrackedState<AlphaFunc> m_alpha_func;
     62    TrackedState<float> m_alpha_value;
     63
     64    TrackedState<BlendFunc> m_blend_src, m_blend_dst;
     65
    6366    TrackedState<DepthFunc> m_depth_func;
     67
    6468    TrackedState<CullMode> m_face_culling;
    6569};
     
    8387        g_renderer->SetClearDepth(m_data->m_clear_depth.GetValue());
    8488
    85     if (m_data->m_alpha_blend.HasChanged())
    86         g_renderer->SetAlphaBlend(m_data->m_alpha_blend.GetValue());
     89    if (m_data->m_alpha_func.HasChanged())
     90        g_renderer->SetAlphaFunc(m_data->m_alpha_func.GetValue(),
     91                                 m_data->m_alpha_value.GetValue());
    8792
    8893    if (m_data->m_blend_src.HasChanged())
    8994        g_renderer->SetBlendFunc(m_data->m_blend_src.GetValue(),
    9095                                 m_data->m_blend_dst.GetValue());
    91 
    92     if (m_data->m_alpha_test.HasChanged())
    93         g_renderer->SetAlphaTest(m_data->m_alpha_test.GetValue());
    9496
    9597    if (m_data->m_depth_func.HasChanged())
     
    118120}
    119121
    120 void RenderContext::SetAlphaBlend(bool set)
     122void RenderContext::SetAlphaFunc(AlphaFunc func, float alpha)
    121123{
    122     if (!m_data->m_alpha_blend.HasChanged())
    123         m_data->m_alpha_blend.TrackValue(g_renderer->GetAlphaBlend());
     124    if (!m_data->m_alpha_func.HasChanged())
     125        m_data->m_alpha_func.TrackValue(g_renderer->GetAlphaFunc());
     126    if (!m_data->m_alpha_value.HasChanged())
     127        m_data->m_alpha_value.TrackValue(g_renderer->GetAlphaValue());
    124128
    125     g_renderer->SetAlphaBlend(set);
     129    g_renderer->SetAlphaFunc(func, alpha);
    126130}
    127131
     
    134138
    135139    g_renderer->SetBlendFunc(src, dst);
    136 }
    137 
    138 void RenderContext::SetAlphaTest(bool set)
    139 {
    140     if (!m_data->m_alpha_test.HasChanged())
    141         m_data->m_alpha_test.TrackValue(g_renderer->GetAlphaTest());
    142 
    143     g_renderer->SetAlphaTest(set);
    144140}
    145141
  • trunk/src/gpu/renderer.cpp

    r2762 r2764  
    5656    vec4 m_clear_color;
    5757    float m_clear_depth;
     58    AlphaFunc m_alpha_func;
     59    float m_alpha_value;
    5860    BlendFunc m_blend_src, m_blend_dst;
    5961    DepthFunc m_depth_func;
    6062    CullMode m_face_culling;
    61     bool m_alpha_blend, m_alpha_test;
    6263
    6364#if defined USE_D3D9
     
    9798    SetClearDepth(1.f);
    9899
    99     m_data->m_alpha_blend = false;
    100     SetAlphaBlend(true);
    101 
    102     m_data->m_alpha_test = true;
    103     SetAlphaTest(false);
    104 
    105     m_data->m_blend_src = BlendFunc::Zero;
    106     m_data->m_blend_dst = BlendFunc::Zero;
     100    m_data->m_alpha_func = AlphaFunc::Never;
     101    m_data->m_alpha_value = -1.0f;
     102    SetAlphaFunc(AlphaFunc::Disabled, 0.0f);
     103
     104    m_data->m_blend_src = BlendFunc::Disabled;
     105    m_data->m_blend_dst = BlendFunc::Disabled;
    107106    SetBlendFunc(BlendFunc::SrcAlpha, BlendFunc::OneMinusSrcAlpha);
    108107
     
    171170
    172171/*
    173  * Alpha blending
    174  */
    175 
    176 void Renderer::SetAlphaBlend(bool set)
    177 {
    178     if (m_data->m_alpha_blend == set)
     172 * Alpha testing
     173 */
     174
     175void Renderer::SetAlphaFunc(AlphaFunc func, float alpha)
     176{
     177    if (m_data->m_alpha_func == func && m_data->m_alpha_value == alpha)
    179178        return;
    180179
    181180#if defined USE_D3D9 || defined _XBOX
    182     m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHABLENDENABLE, set ? 1 : 0);
    183 #else
    184     if (set)
    185         glEnable(GL_BLEND);
     181    switch (func)
     182    {
     183        case AlphaFunc::Disabled:
     184            break; /* Nothing to do */
     185        case AlphaFunc::Never:
     186            m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_NEVER);
     187            break;
     188        case AlphaFunc::Less:
     189            m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_LESS);
     190            break;
     191        case AlphaFunc::Equal:
     192            m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_EQUAL);
     193            break;
     194        case AlphaFunc::LessOrEqual:
     195            m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_LESSEQUAL);
     196            break;
     197        case AlphaFunc::Greater:
     198            m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);
     199            break;
     200        case AlphaFunc::NotEqual:
     201            m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_NOTEQUAL);
     202            break;
     203        case AlphaFunc::GreaterOrEqual:
     204            m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL);
     205            break;
     206        case AlphaFunc::Always:
     207            m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_ALWAYS);
     208            break;
     209    }
     210
     211    if (func == AlphaFunc::Disabled)
     212    {
     213        m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
     214    }
    186215    else
    187         glDisable(GL_BLEND);
    188 #endif
    189 
    190     m_data->m_alpha_blend = set;
    191 }
    192 
    193 bool Renderer::GetAlphaBlend() const
    194 {
    195     return m_data->m_alpha_blend;
     216    {
     217        m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
     218        m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHAREF,
     219                                          (DWORD)(alpha * 255.999f));
     220    }
     221#else
     222    switch (func)
     223    {
     224        case AlphaFunc::Disabled:
     225            break; /* Nothing to do */
     226        case AlphaFunc::Never:
     227            glAlphaFunc(GL_NEVER, alpha); break;
     228        case AlphaFunc::Less:
     229            glAlphaFunc(GL_LESS, alpha); break;
     230        case AlphaFunc::Equal:
     231            glAlphaFunc(GL_EQUAL, alpha); break;
     232        case AlphaFunc::LessOrEqual:
     233            glAlphaFunc(GL_LEQUAL, alpha); break;
     234        case AlphaFunc::Greater:
     235            glAlphaFunc(GL_GREATER, alpha); break;
     236        case AlphaFunc::NotEqual:
     237            glAlphaFunc(GL_NOTEQUAL, alpha); break;
     238        case AlphaFunc::GreaterOrEqual:
     239            glAlphaFunc(GL_GEQUAL, alpha); break;
     240        case AlphaFunc::Always:
     241            glAlphaFunc(GL_ALWAYS, alpha); break;
     242    }
     243
     244    if (func == AlphaFunc::Disabled)
     245        glDisable(GL_ALPHA_TEST);
     246    else
     247        glEnable(GL_ALPHA_TEST);
     248#endif
     249
     250    m_data->m_alpha_func = func;
     251    m_data->m_alpha_value = alpha;
     252}
     253
     254AlphaFunc Renderer::GetAlphaFunc() const
     255{
     256    return m_data->m_alpha_func;
     257}
     258
     259float Renderer::GetAlphaValue() const
     260{
     261    return m_data->m_alpha_value;
    196262}
    197263
     
    213279        switch (s2[i])
    214280        {
     281            case BlendFunc::Disabled:
     282                break; /* Nothing to do */
    215283            case BlendFunc::Zero:
    216284                s1[i] = D3DBLEND_ZERO; break;
     
    249317    }
    250318
    251     m_data->m_d3d_dev->SetRenderState(D3DRS_SRCBLEND, s1[0]);
    252     m_data->m_d3d_dev->SetRenderState(D3DRS_DESTBLEND, s1[1]);
     319    if (src == BlendFunc::Disabled)
     320    {
     321        m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHABLENDENABLE, 0);
     322    }
     323    else
     324    {
     325        m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHABLENDENABLE, 1);
     326        m_data->m_d3d_dev->SetRenderState(D3DRS_SRCBLEND, s1[0]);
     327        m_data->m_d3d_dev->SetRenderState(D3DRS_DESTBLEND, s1[1]);
     328    }
    253329#else
    254330    GLenum s1[2] = { GL_ONE, GL_ZERO };
     
    259335        switch (s2[i])
    260336        {
     337            case BlendFunc::Disabled:
     338                break; /* Nothing to do */
    261339            case BlendFunc::Zero:
    262340                s1[i] = GL_ZERO; break;
     
    290368    }
    291369
    292     glBlendFunc(s1[0], s1[1]);
     370    if (src == BlendFunc::Disabled)
     371    {
     372        glDisable(GL_BLEND);
     373    }
     374    else
     375    {
     376        glEnable(GL_BLEND);
     377        glBlendFunc(s1[0], s1[1]);
     378    }
    293379#endif
    294380
     
    305391{
    306392    return m_data->m_blend_dst;
    307 }
    308 
    309 /*
    310  * Alpha testing
    311  */
    312 
    313 void Renderer::SetAlphaTest(bool set)
    314 {
    315     if (m_data->m_alpha_test == set)
    316         return;
    317 
    318 #if defined USE_D3D9 || defined _XBOX
    319     m_data->m_d3d_dev->SetRenderState(D3DRS_ALPHATESTENABLE, set ? 1 : 0);
    320 #else
    321     if (set)
    322         glEnable(GL_ALPHA_TEST);
    323     else
    324         glDisable(GL_ALPHA_TEST);
    325 #endif
    326 
    327     m_data->m_alpha_test = set;
    328 }
    329 
    330 bool Renderer::GetAlphaTest() const
    331 {
    332     return m_data->m_alpha_test;
    333393}
    334394
     
    444504    case CullMode::Clockwise:
    445505        glEnable(GL_CULL_FACE);
     506        glCullFace(GL_BACK);
    446507        glFrontFace(GL_CW);
    447508        break;
    448509    case CullMode::CounterClockwise:
    449510        glEnable(GL_CULL_FACE);
     511        glCullFace(GL_BACK);
    450512        glFrontFace(GL_CCW);
    451513        break;
  • trunk/src/lol/gpu/rendercontext.h

    r2762 r2764  
    3030    void SetClearColor(vec4 color);
    3131    void SetClearDepth(float depth);
    32     void SetAlphaBlend(bool set);
     32    void SetAlphaFunc(AlphaFunc func, float alpha);
    3333    void SetBlendFunc(BlendFunc src, BlendFunc dst);
    34     void SetAlphaTest(bool set);
    3534    void SetDepthFunc(DepthFunc func);
    3635    void SetFaceCulling(CullMode mode);
  • trunk/src/lol/gpu/renderer.h

    r2762 r2764  
    2727    enum Value
    2828    {
     29        Disabled,
    2930        Zero,
    3031        One,
     
    8788};
    8889
     90/* A safe enum to indicate the alpha test mode. */
     91struct AlphaFunc
     92{
     93    enum Value
     94    {
     95        Disabled,
     96        Never,
     97        Less,
     98        Equal,
     99        LessOrEqual,
     100        Greater,
     101        NotEqual,
     102        GreaterOrEqual,
     103        Always,
     104    }
     105    m_value;
     106
     107    inline AlphaFunc() : m_value(Disabled) {}
     108    inline AlphaFunc(Value v) : m_value(v) {}
     109    inline operator Value() { return m_value; }
     110};
     111
    89112class Renderer
    90113{
     
    103126    float GetClearDepth() const;
    104127
    105     void SetAlphaBlend(bool set);
    106     bool GetAlphaBlend() const;
     128    void SetAlphaFunc(AlphaFunc func, float alpha);
     129    AlphaFunc GetAlphaFunc() const;
     130    float GetAlphaValue() const;
    107131
    108132    void SetBlendFunc(BlendFunc src, BlendFunc dst);
    109133    BlendFunc GetBlendFuncSrc() const;
    110134    BlendFunc GetBlendFuncDst() const;
    111 
    112     void SetAlphaTest(bool set);
    113     bool GetAlphaTest() const;
    114135
    115136    void SetDepthFunc(DepthFunc func);
  • trunk/src/scene.cpp

    r2762 r2764  
    194194    RenderContext rc;
    195195    rc.SetDepthFunc(DepthFunc::LessOrEqual);
    196     rc.SetAlphaBlend(true);
    197196    rc.SetBlendFunc(BlendFunc::SrcAlpha, BlendFunc::OneMinusSrcAlpha);
    198 
    199 #if defined USE_D3D9 || defined _XBOX
    200 #else
    201 #if defined HAVE_GL_2X && !defined __APPLE__
    202     glEnable(GL_ALPHA_TEST);
    203     glAlphaFunc(GL_GEQUAL, 0.01f);
    204 #endif
    205 #endif
     197    rc.SetAlphaFunc(AlphaFunc::GreaterOrEqual, 0.01f);
    206198
    207199    /* Early test if nothing needs to be rendered */
     
    345337        delete vb;
    346338    }
    347 
    348 #if defined USE_D3D9 || defined _XBOX
    349     /* TODO */
    350 #else
    351 #   if defined HAVE_GL_2X && !defined __APPLE__
    352     glDisable(GL_ALPHA_TEST);
    353 #   endif
    354 #endif
    355339}
    356340
  • trunk/tools/neercs/video/render.cpp

    r2762 r2764  
    863863{
    864864    glDepthMask(GL_TRUE);     // do not write z-buffer
    865     glEnable(GL_CULL_FACE);   // disable cull face
    866     glCullFace(GL_BACK);      // don't draw front face
     865
    867866    /* initialise framebuffer objects */
    868867    fbo_back = new Framebuffer(screen_size);
     
    14531452
    14541453    RenderContext rc;
    1455     rc.SetAlphaBlend(true);
    14561454    rc.SetBlendFunc(BlendFunc::SrcColor, BlendFunc::DstAlpha);
    14571455
     
    14801478
    14811479    RenderContext rc;
    1482     rc.SetAlphaBlend(false);
     1480    rc.SetBlendFunc(BlendFunc::Disabled, BlendFunc::Disabled);
    14831481    rc.SetDepthFunc(DepthFunc::Disabled);
    14841482
  • trunk/tools/neercs/video/text-render.cpp

    r2762 r2764  
    187187
    188188    RenderContext rc;
    189     rc.SetAlphaBlend(false);
     189    rc.SetBlendFunc(BlendFunc::Disabled, BlendFunc::Disabled);
    190190
    191191    glEnable(GL_TEXTURE_2D);
Note: See TracChangeset for help on using the changeset viewer.