Changeset 2751


Ignore:
Timestamp:
Jun 19, 2013, 12:58:54 AM (6 years ago)
Author:
sam
Message:

gpu: handle depth test, alpha blending and face culling in Renderer.

Location:
trunk/src
Files:
7 edited

Legend:

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

    r2750 r2751  
    5959    Scene *m_scene;
    6060
    61     TrackedState m_blend;
     61    TrackedState m_alpha_blend, m_depth_test, m_face_culling;
    6262};
    6363
     
    7474RenderContext::~RenderContext()
    7575{
    76     if (m_data->m_blend.HasChanged())
    77         g_renderer->SetBlendState(m_data->m_blend.GetValue());
     76    if (m_data->m_alpha_blend.HasChanged())
     77        g_renderer->SetAlphaBlend(m_data->m_alpha_blend.GetValue());
     78
     79    if (m_data->m_depth_test.HasChanged())
     80        g_renderer->SetDepthTest(m_data->m_depth_test.GetValue());
     81
     82    if (m_data->m_face_culling.HasChanged())
     83        g_renderer->SetFaceCulling(m_data->m_face_culling.GetValue());
    7884
    7985    delete m_data;
    8086}
    8187
    82 void RenderContext::SetBlendState(bool set)
     88void RenderContext::SetAlphaBlend(bool set)
    8389{
    84     if (!m_data->m_blend.HasChanged())
    85         m_data->m_blend.TrackValue(g_renderer->GetBlendState());
     90    if (!m_data->m_alpha_blend.HasChanged())
     91        m_data->m_alpha_blend.TrackValue(g_renderer->GetAlphaBlend());
    8692
    87     g_renderer->SetBlendState(set);
     93    g_renderer->SetAlphaBlend(set);
     94}
     95
     96void RenderContext::SetDepthTest(bool set)
     97{
     98    if (!m_data->m_depth_test.HasChanged())
     99        m_data->m_depth_test.TrackValue(g_renderer->GetDepthTest());
     100
     101    g_renderer->SetDepthTest(set);
     102}
     103
     104void RenderContext::SetFaceCulling(bool set)
     105{
     106    if (!m_data->m_face_culling.HasChanged())
     107        m_data->m_face_culling.TrackValue(g_renderer->GetFaceCulling());
     108
     109    g_renderer->SetFaceCulling(set);
    88110}
    89111
  • trunk/src/gpu/renderer.cpp

    r2750 r2751  
    1515#include <cstdlib>
    1616
     17#if defined _XBOX
     18#   include <xtl.h>
     19#   undef near /* Fuck Microsoft */
     20#   undef far /* Fuck Microsoft again */
     21#elif defined _WIN32
     22#   if defined USE_D3D9
     23#      include <d3d9.h>
     24#   endif
     25#   define WIN32_LEAN_AND_MEAN
     26#   include <windows.h>
     27#   undef near /* Fuck Microsoft */
     28#   undef far /* Fuck Microsoft again */
     29#endif
     30
    1731#include "core.h"
     32#include "lolgl.h"
    1833
    1934namespace lol
     
    3348
    3449private:
    35     bool m_blend;
     50    bool m_blend, m_depth_test, m_face_culling;
    3651};
    3752
     
    4459{
    4560    m_data->m_blend = false;
     61    SetAlphaBlend(true);
     62
     63    m_data->m_depth_test = false;
     64    SetDepthTest(true);
     65
     66    m_data->m_face_culling = false;
     67    SetFaceCulling(true);
    4668}
    4769
     
    5173}
    5274
    53 void Renderer::SetBlendState(bool set)
     75/*
     76 * Alpha blending
     77 */
     78
     79void Renderer::SetAlphaBlend(bool set)
    5480{
    5581    if (m_data->m_blend == set)
     
    5783
    5884    m_data->m_blend = set;
     85
     86#if defined USE_D3D9 || defined _XBOX
     87#   define STR0(x) #x
     88#   define STR(x) STR0(x)
     89#   pragma message(__FILE__ "(" STR(__LINE__) "): warning: Renderer::SetAlphaBlend() not implemented")
     90#else
    5991    if (set)
    60     {
    61 
    62     }
     92        glEnable(GL_BLEND);
    6393    else
    64     {
    65 
    66     }
     94        glDisable(GL_BLEND);
     95#endif
    6796}
    6897
    69 bool Renderer::GetBlendState() const
     98bool Renderer::GetAlphaBlend() const
    7099{
    71100    return m_data->m_blend;
    72101}
    73102
     103/*
     104 * Depth test
     105 */
     106
     107void Renderer::SetDepthTest(bool set)
     108{
     109    if (m_data->m_depth_test == set)
     110        return;
     111
     112    m_data->m_depth_test = set;
     113
     114#if defined USE_D3D9 || defined _XBOX
     115#   define STR0(x) #x
     116#   define STR(x) STR0(x)
     117#   pragma message(__FILE__ "(" STR(__LINE__) "): warning: Renderer::SetDepthTest() not implemented")
     118#else
     119    if (set)
     120        glEnable(GL_DEPTH_TEST);
     121    else
     122        glDisable(GL_DEPTH_TEST);
     123#endif
     124}
     125
     126bool Renderer::GetDepthTest() const
     127{
     128    return m_data->m_depth_test;
     129}
     130
     131/*
     132 * Face culling
     133 */
     134
     135void Renderer::SetFaceCulling(bool set)
     136{
     137    if (m_data->m_face_culling == set)
     138        return;
     139
     140    m_data->m_face_culling = set;
     141
     142#if defined USE_D3D9 || defined _XBOX
     143#   define STR0(x) #x
     144#   define STR(x) STR0(x)
     145#   pragma message(__FILE__ "(" STR(__LINE__) "): warning: Renderer::SetFaceCulling() not implemented")
     146#else
     147    if (set)
     148        glEnable(GL_CULL_FACE);
     149    else
     150        glDisable(GL_CULL_FACE);
     151#endif
     152}
     153
     154bool Renderer::GetFaceCulling() const
     155{
     156    return m_data->m_face_culling;
     157}
     158
    74159} /* namespace lol */
    75160
  • trunk/src/lol/gpu/rendercontext.h

    r2750 r2751  
    2828    ~RenderContext();
    2929
    30     void SetBlendState(bool set);
     30    void SetAlphaBlend(bool set);
     31    void SetDepthTest(bool set);
     32    void SetFaceCulling(bool set);
    3133
    3234private:
  • trunk/src/lol/gpu/renderer.h

    r2750 r2751  
    2828    ~Renderer();
    2929
    30     void SetBlendState(bool set);
    31     bool GetBlendState() const;
     30    void SetAlphaBlend(bool set);
     31    bool GetAlphaBlend() const;
     32
     33    void SetDepthTest(bool set);
     34    bool GetDepthTest() const;
     35
     36    void SetFaceCulling(bool set);
     37    bool GetFaceCulling() const;
    3238
    3339private:
  • trunk/src/ticker.cpp

    r2740 r2751  
    390390            Video::Clear(ClearMask::All);
    391391            break;
    392         case Entity::DRAWGROUP_HUD:
    393             Video::SetDepth(false);
    394             break;
    395392        default:
    396             Video::SetDepth(true);
    397393            break;
    398394        }
  • trunk/src/video.cpp

    r2750 r2751  
    5353    static ivec2 saved_viewport;
    5454    static DebugRenderMode render_mode;
    55     static bool face_culling;
    56     static bool alpha_blend;
    5755#if defined USE_D3D9 || defined _XBOX
    5856#   if defined USE_D3D9
     
    7169ivec2 VideoData::saved_viewport(0, 0);
    7270DebugRenderMode VideoData::render_mode = DebugRenderMode::Default;
    73 bool VideoData::face_culling = true;
    74 bool VideoData::alpha_blend = true;
    7571
    7672#if defined USE_D3D9 || defined _XBOX
     
    9288void Video::Setup(ivec2 size)
    9389{
    94     g_renderer = new Renderer();
    95 
    9690#if defined USE_D3D9 || defined _XBOX
    9791    VideoData::d3d_ctx = Direct3DCreate9(D3D_SDK_VERSION);
     
    159153#endif
    160154
     155    g_renderer = new Renderer();
     156
    161157    /* Initialise reasonable scene default properties */
    162158    SetClearColor(vec4(0.1f, 0.2f, 0.3f, 1.0f));
    163159    SetClearDepth(1.f);
    164     SetAlphaBlend(true);
    165160    SetDebugRenderMode(DebugRenderMode::Default);
    166161}
     
    239234}
    240235
    241 void Video::SetDepth(bool set)
    242 {
    243 #if defined USE_D3D9 || defined _XBOX
    244 #   define STR0(x) #x
    245 #   define STR(x) STR0(x)
    246 #   pragma message(__FILE__ "(" STR(__LINE__) "): warning: Video::SetDepth() not implemented")
    247 #else
    248     if (set)
    249         glEnable(GL_DEPTH_TEST);
    250     else
    251         glDisable(GL_DEPTH_TEST);
    252 #endif
    253 }
    254 
    255 void Video::SetFaceCulling(bool set)
    256 {
    257 #if defined USE_D3D9 || defined _XBOX
    258 #   define STR0(x) #x
    259 #   define STR(x) STR0(x)
    260 #   pragma message(__FILE__ "(" STR(__LINE__) "): warning: Video::SetFaceCulling() not implemented")
    261 #else
    262     VideoData::face_culling = set;
    263     if (set)
    264         glEnable(GL_CULL_FACE);
    265     else
    266         glDisable(GL_CULL_FACE);
    267 #endif
    268 }
    269 
    270 bool Video::HasFaceCulling()
    271 {
    272     return VideoData::face_culling;
    273 }
    274 
    275 void Video::SetAlphaBlend(bool set)
    276 {
    277 #if defined USE_D3D9 || defined _XBOX
    278 #   define STR0(x) #x
    279 #   define STR(x) STR0(x)
    280 #   pragma message(__FILE__ "(" STR(__LINE__) "): warning: Video::SetAlphaBlend() not implemented")
    281 #else
    282     VideoData::alpha_blend = set;
    283     if (set)
    284         glEnable(GL_BLEND);
    285     else
    286         glDisable(GL_BLEND);
    287 #endif
    288 }
    289 
    290 bool Video::HasAlphaBlend()
    291 {
    292     return VideoData::alpha_blend;
    293 }
    294 
    295236void Video::SetClearColor(vec4 color)
    296237{
     
    329270            glEnable(GL_CULL_FACE);
    330271#else
    331             if (VideoData::render_mode == d && glIsEnabled(GL_CULL_FACE) == GL_TRUE)
    332                 SetFaceCulling(false);
    333             else
    334                 SetFaceCulling(true);
     272//            if (VideoData::render_mode == d && glIsEnabled(GL_CULL_FACE) == GL_TRUE)
     273//                SetFaceCulling(false);
     274//            else
     275//                SetFaceCulling(true);
    335276            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    336277#endif
     
    343284#if defined USE_D3D9 || defined _XBOX
    344285#else
    345                 SetFaceCulling(!VideoData::face_culling);
     286//                SetFaceCulling(!VideoData::face_culling);
    346287#endif
    347288            }
     
    350291#if defined USE_D3D9 || defined _XBOX
    351292#else
    352                 SetFaceCulling(false);
     293//                SetFaceCulling(false);
    353294#endif
    354295            }
  • trunk/src/video.h

    r2750 r2751  
    7272    static void RestoreSize();
    7373    static void SetFov(float theta);
    74     static void SetDepth(bool set);
    75     static void SetFaceCulling(bool set);
    76     static bool HasFaceCulling();
    77     static void SetAlphaBlend(bool set);
    78     static bool HasAlphaBlend();
    7974    static void SetClearColor(vec4 color);
    8075    static void SetClearDepth(float f);
Note: See TracChangeset for help on using the changeset viewer.