Une classe GUIButton pour représenter un bouton cliquable

Intro :

Parfois nous avons besoin d’afficher un bouton pour rendre l’interface utilisateur (GUI) plus dynamique. Le bouton peut afficher une autre image lorsqu’il est reste cliqué dessus !

Prérequis :

– Avoir lu la classe GUIWidget

Contenu :

Voici le fichier GUIButton.h :

#ifndef GUI_BUTTON_H
#define GUI_BUTTON_H

#include <d3dx10math.h>
#include <iostream>

#include "Sprite2D.h"
#include "GUIImage.h"
#include "Defines.h"

class GUIButton : public GUIImage
{
public:
    enum ButtonState
    {
        NON_ACTIVE,
        HOVER,
        CLICKED,
        PUSHED_OUT
    };

    GUIButton(const std::string& sName, const std::string& sTextureName, const std::string& sTextureClickedName = NONE,
        const std::string& sTextureHoverName = NONE);

    virtual ~GUIButton();

    virtual void Update(float fTimeSinceLastFrame);

    ButtonState GetState();
    void SetState(ButtonState state);

    void SetHoverOnImage();
    void SetClickedOnImage();
    void SetNormalImage();

    bool IsClickedOn();
    bool IsPushedOut();
    bool IsNonActive();

private:
    ButtonState m_state;

    std::string m_sNormalTextureFile;
    std::string m_sClickedOnTextureFile;
    std::string m_sHoverOnTextureFile;

    bool m_bClickedOn;
    bool m_bHover;
    bool m_bHasClickedOnImage;
    bool m_bHasHoverdOnImage;

    bool m_bMouseButtonReleased;
};

#endif

#ifndef GUI_BUTTON_H

#define GUI_BUTTON_H

#include <d3dx10math.h>

#include <iostream>

#include "Sprite2D.h"

#include "GUIImage.h"

#include "Defines.h"

class GUIButton : public GUIImage

{

public:

enum ButtonState

{

NON_ACTIVE,

HOVER,

CLICKED,

PUSHED_OUT

};

GUIButton(const std::string& sName, const std::string& sTextureName, const std::string& sTextureClickedName = NONE,

const std::string& sTextureHoverName = NONE);

virtual ~GUIButton();

virtual void Update(float fTimeSinceLastFrame);

ButtonState GetState();

void SetState(ButtonState state);

void SetHoverOnImage();

void SetClickedOnImage();

void SetNormalImage();

bool IsClickedOn();

bool IsPushedOut();

bool IsNonActive();

private:

ButtonState m_state;

std::string m_sNormalTextureFile;

std::string m_sClickedOnTextureFile;

std::string m_sHoverOnTextureFile;

bool m_bClickedOn;

bool m_bHover;

bool m_bHasClickedOnImage;

bool m_bHasHoverdOnImage;

bool m_bMouseButtonReleased;

};

#endif

Voici le fichier GUIButton.cpp :

#include "GUIButton.h"
#include "InputManager.h"
#include "GUIManager.h"
#include "Utils.h"

GUIButton::GUIButton(const std::string& sName, const std::string& sTextureName, const std::string& sTextureClickedName,
                     const std::string& sTextureHoverName) :
GUIImage(sName, sTextureName),
m_state(NON_ACTIVE),
m_sNormalTextureFile(sTextureName),
m_sClickedOnTextureFile(sTextureClickedName),
m_sHoverOnTextureFile(sTextureHoverName),
m_bClickedOn(false),
m_bHover(false),
m_bMouseButtonReleased(false),
m_bHasClickedOnImage(false),
m_bHasHoverdOnImage(false)
{
    // Image quand on appuie
    if (Utils::IsFileReadable(sTextureClickedName))
    {
        m_bHasClickedOnImage = true;
    }

    // Image quand on survole
    if (Utils::IsFileReadable(sTextureHoverName))
    {
        m_bHasHoverdOnImage = true;
    }
}

GUIButton::~GUIButton()
{
}

void GUIButton::Update(float fTimeSinceLastFrame)
{
    if (!IsVisible())
    {
        return;
    }

    int x, y;
    INPUT_MANAGER->GetAbsMouseLocation(x, y);
    
    if (IsActive())
    {
        if (IsCollidingWithMousePointer(x, y)
            && GUI_MANAGER->IsWidgetFirstOverlapping(this))
        {
            SetState(ButtonState::HOVER);
            m_bHover = true;

            SetHoverOnImage();

            if (INPUT_MANAGER->IsMouseButtonDown(MOUSE_LEFT_BUTTON_DOWN))
            {
                m_bClickedOn = true;

                SetState(ButtonState::CLICKED);

                GUIParameters param;
                param << GetState();

                SendEventToListeners(param);

                SetClickedOnImage();
            }
            else if (m_bClickedOn)
            {
                SetNormalImage();    

                m_bClickedOn = false;

                SetState(ButtonState::PUSHED_OUT);
            }
        }
        else if (m_bHover)
        {
            SetState(ButtonState::NON_ACTIVE);

            SetNormalImage();

            m_bHover = false;
        }
        else
        {
            m_bClickedOn = false;
        }
    }

    GUIImage::Update(fTimeSinceLastFrame);
}

GUIButton::ButtonState GUIButton::GetState()
{
    return m_state;
}

void GUIButton::SetState(ButtonState state)
{
    m_state = state;
}

bool GUIButton::IsClickedOn()
{
    return GetState() == GUIButton::ButtonState::CLICKED && IsVisible();
}

bool GUIButton::IsPushedOut()
{
    return GetState() == GUIButton::ButtonState::PUSHED_OUT && IsVisible();
}

bool GUIButton::IsNonActive()
{
    return GetState() == GUIButton::ButtonState::NON_ACTIVE && IsVisible();
}

void GUIButton::SetClickedOnImage()
{
    if (m_bHasClickedOnImage)
    {
        SetTextureImage(m_sClickedOnTextureFile);
    }
}

void GUIButton::SetNormalImage()
{
    SetTextureImage(m_sNormalTextureFile);
}

void GUIButton::SetHoverOnImage()
{
    if (m_bHasHoverdOnImage)
    {
        SetTextureImage(m_sHoverOnTextureFile);
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

#include "GUIButton.h"

#include "InputManager.h"

#include "GUIManager.h"

#include "Utils.h"

GUIButton::GUIButton(const std::string& sName, const std::string& sTextureName, const std::string& sTextureClickedName,

const std::string& sTextureHoverName) :

GUIImage(sName, sTextureName),

m_state(NON_ACTIVE),

m_sNormalTextureFile(sTextureName),

m_sClickedOnTextureFile(sTextureClickedName),

m_sHoverOnTextureFile(sTextureHoverName),

m_bClickedOn(false),

m_bHover(false),

m_bMouseButtonReleased(false),

m_bHasClickedOnImage(false),

m_bHasHoverdOnImage(false)

{

// Image quand on appuie

if (Utils::IsFileReadable(sTextureClickedName))

{

m_bHasClickedOnImage = true;

}

// Image quand on survole

if (Utils::IsFileReadable(sTextureHoverName))

{

m_bHasHoverdOnImage = true;

}

GUIButton::~GUIButton()

{

}

void GUIButton::Update(float fTimeSinceLastFrame)

{

if (!IsVisible())

{

return;

}

int x, y;

INPUT_MANAGER->GetAbsMouseLocation(x, y);

if (IsActive())

{

if (IsCollidingWithMousePointer(x, y)

&& GUI_MANAGER->IsWidgetFirstOverlapping(this))

{

SetState(ButtonState::HOVER);

m_bHover = true;

SetHoverOnImage();

if (INPUT_MANAGER->IsMouseButtonDown(MOUSE_LEFT_BUTTON_DOWN))

{

m_bClickedOn = true;

SetState(ButtonState::CLICKED);

GUIParameters param;

param << GetState();

SendEventToListeners(param);

SetClickedOnImage();

}

else if (m_bClickedOn)

{

SetNormalImage();

m_bClickedOn = false;

SetState(ButtonState::PUSHED_OUT);

}

else if (m_bHover)

{

SetState(ButtonState::NON_ACTIVE);

SetNormalImage();

m_bHover = false;

}

else

{

m_bClickedOn = false;

}

GUIImage::Update(fTimeSinceLastFrame);

}

GUIButton::ButtonState GUIButton::GetState()

{

return m_state;

}

void GUIButton::SetState(ButtonState state)

{

m_state = state;

}

bool GUIButton::IsClickedOn()

{

return GetState() == GUIButton::ButtonState::CLICKED && IsVisible();

}

bool GUIButton::IsPushedOut()

{

return GetState() == GUIButton::ButtonState::PUSHED_OUT && IsVisible();

}

bool GUIButton::IsNonActive()

{

return GetState() == GUIButton::ButtonState::NON_ACTIVE && IsVisible();

}

void GUIButton::SetClickedOnImage()

{

if (m_bHasClickedOnImage)

{

SetTextureImage(m_sClickedOnTextureFile);

}

void GUIButton::SetNormalImage()

{

SetTextureImage(m_sNormalTextureFile);

}

void GUIButton::SetHoverOnImage()

{

if (m_bHasHoverdOnImage)

{

SetTextureImage(m_sHoverOnTextureFile);

}

Résumé :

Voici une classe qui permet d’afficher un bouton cliquable.

Une classe GUIImage pour afficher une image

Intro :

Parfois nous avons besoin d’afficher une image pour rendre l’interface utilisateur (GUI) plus jolie.

Prérequis :

– Avoir lu la classe GUIWidget

Contenu :

Voici le fichier GUIImage.h :

#ifndef GUI_IMAGE_H
#define GUI_IMAGE_H

#include "GUIWidget.h"

class GUIImage : public GUIWidget
{
public:
    GUIImage(const std::string& sName, const std::string& sTextureFileName);
    virtual ~GUIImage();

    virtual void SetTextureImage(const std::string& sTextureName);

    virtual void Update(float fTimeSinceLastFrame);

    virtual void SetPosition(unsigned int x, unsigned int y);

    virtual void SetSize(unsigned int iWidth, unsigned int iHeight);

    virtual void SetVisible(bool bVisible);

    Sprite2D* GetImage();

private:
    Sprite2D* m_pImage;
};

#endif

#ifndef GUI_IMAGE_H

#define GUI_IMAGE_H

#include "GUIWidget.h"

class GUIImage : public GUIWidget

{

public:

GUIImage(const std::string& sName, const std::string& sTextureFileName);

virtual ~GUIImage();

virtual void SetTextureImage(const std::string& sTextureName);

virtual void Update(float fTimeSinceLastFrame);

virtual void SetPosition(unsigned int x, unsigned int y);

virtual void SetSize(unsigned int iWidth, unsigned int iHeight);

virtual void SetVisible(bool bVisible);

Sprite2D* GetImage();

private:

Sprite2D* m_pImage;

};

#endif

Voici le fichier GUIImage.cpp :

#include "GUIImage.h"
#include "Sprite2D.h"
#include "Defines.h"

GUIImage::GUIImage(const std::string& sName, const std::string& sTextureFileName) :
GUIWidget(sName),
m_pImage(nullptr)
{
    m_pImage = new Sprite2D(sTextureFileName);
    m_pImage->Initialize();

    unsigned int iImageWidth = m_pImage->GetWidth();
    unsigned int iImageHeight = m_pImage->GetHeight();

    SetSize(iImageWidth, iImageHeight);
}

GUIImage::~GUIImage()
{
    SAFE_DELETE(m_pImage);
}

void GUIImage::Update(float fTimeSinceLastFrame)
{
    if (IsVisible())
    {
        m_pImage->Render();
    }

    GUIWidget::Update(fTimeSinceLastFrame);
}

void GUIImage::SetTextureImage(const std::string& sTextureName)
{
    m_pImage->SetTextureImage(sTextureName);

    // On restaure les dimensions d'avant
    unsigned int iWidth = 0;
    unsigned int iHeight = 0;

    GetSize(iWidth, iHeight);

    m_pImage->SetImageSize(iWidth, iHeight);
}

void GUIImage::SetPosition(unsigned int x, unsigned int y)
{
    m_pImage->SetPosition(x, y);

    GUIWidget::SetPosition(x, y);
}

void GUIImage::SetSize(unsigned int iWidth, unsigned int iHeight)
{
    m_pImage->SetImageSize(iWidth, iHeight);

    GUIWidget::SetSize(iWidth, iHeight);
}

void GUIImage::SetVisible(bool bVisible)
{
    if (bVisible)
    {
        m_pImage->Show();
    }
    else
    {
        m_pImage->Hide();
    }

    GUIWidget::SetVisible(bVisible);
}

Sprite2D* GUIImage::GetImage()
{
    return m_pImage;
}

#include "GUIImage.h"

#include "Sprite2D.h"

#include "Defines.h"

GUIImage::GUIImage(const std::string& sName, const std::string& sTextureFileName) :

GUIWidget(sName),

m_pImage(nullptr)

{

m_pImage = new Sprite2D(sTextureFileName);

m_pImage->Initialize();

unsigned int iImageWidth = m_pImage->GetWidth();

unsigned int iImageHeight = m_pImage->GetHeight();

SetSize(iImageWidth, iImageHeight);

}

GUIImage::~GUIImage()

{

SAFE_DELETE(m_pImage);

}

void GUIImage::Update(float fTimeSinceLastFrame)

{

if (IsVisible())

{

m_pImage->Render();

}

GUIWidget::Update(fTimeSinceLastFrame);

}

void GUIImage::SetTextureImage(const std::string& sTextureName)

{

m_pImage->SetTextureImage(sTextureName);

// On restaure les dimensions d'avant

unsigned int iWidth = 0;

unsigned int iHeight = 0;

GetSize(iWidth, iHeight);

m_pImage->SetImageSize(iWidth, iHeight);

}

void GUIImage::SetPosition(unsigned int x, unsigned int y)

{

m_pImage->SetPosition(x, y);

GUIWidget::SetPosition(x, y);

}

void GUIImage::SetSize(unsigned int iWidth, unsigned int iHeight)

{

m_pImage->SetImageSize(iWidth, iHeight);

GUIWidget::SetSize(iWidth, iHeight);

}

void GUIImage::SetVisible(bool bVisible)

{

if (bVisible)

{

m_pImage->Show();

}

else

{

m_pImage->Hide();

}

GUIWidget::SetVisible(bVisible);

}

Sprite2D* GUIImage::GetImage()

{

return m_pImage;

}

Résumé :

Une classe GUIWidget pour gérer les objets graphiques

Intro :

Dans un jeu vidéo, nous avons besoin de créer des interfaces graphiques afin que le joueur puisse communiquer ou sélectionner des items, cliquer sur des boutons, déplacer une armure, etc…

Prérequis :

– Savoir initialiser DirectX 10

– Savoir lire du C++

– Connaître la classe Sprite2D

Contenu :

Voici le fichier GUIWidget.h :

#ifndef GUI_WIDGET_H
#define GUI_WIDGET_H

#include <iostream>
#include <vector>

#include <d3dx10math.h>
#include "DataParameters.h"

class Sprite2D;

typedef DataParameters GUIParameters; 

struct AABB
{
    unsigned int x;
    unsigned int y;
    unsigned int w;
    unsigned int h;
};

class GUIEventListener
{
public:
    GUIEventListener() {}
    virtual ~GUIEventListener() {}

    virtual void OnGUIEvent(GUIParameters& param) = 0;
};

class GUIWidget
{
public:
    GUIWidget(const std::string& sName);
    virtual ~GUIWidget();

    virtual void Update(float fTimeSinceLastFrame);

    D3DXVECTOR2 GetPosition();
    virtual void SetPosition(unsigned int x, unsigned int  y);
    void SetRelativePosition(unsigned int  x, unsigned int  y);

    bool IsCollidingWithMousePointer(unsigned int x, unsigned int y);

    void SetVisible(bool bVisible);
    bool IsVisible();

    void AddEventListener(GUIEventListener* pEventListener);

    virtual void SetSize(unsigned int iWidth, unsigned int iHeight);
    void GetSize(unsigned int& iWidth, unsigned int& iHeight);

    std::string GetName();

    void AddChild(GUIWidget* pChild);
    void SetParent(GUIWidget* pParent);

    bool HasParent();

    void SetCanBeOverlaped(bool bCanBeOverlaped);
    bool CanOverlap();

    void GetChildren(std::map<std::string, GUIWidget*>& children);
    GUIWidget* GetParent();

    bool HasChildren();

    virtual void SetActive(bool bActive);
    bool IsActive();

    bool IsChildrenLocked();
    void SetChildrenLocked(bool bActive);

protected:
    std::vector<GUIEventListener*> m_eventListeners;

    void SendEventToListeners(GUIParameters& param);

private:
    AABB m_aabox;

    bool m_bVisible;

    unsigned int m_iPosX;
    unsigned int m_iPosY;

    std::string m_sName;

    GUIWidget* m_pParent;

    std::map<std::string, GUIWidget*> m_children;

    bool m_bCanBeOverlaped;
    bool m_bActive;
    bool m_bIsChildrenLocked;
};

#endif

#ifndef GUI_WIDGET_H

#define GUI_WIDGET_H

#include <iostream>

#include <vector>

#include <d3dx10math.h>

#include "DataParameters.h"

class Sprite2D;

typedef DataParameters GUIParameters;

struct AABB

{

unsigned int x;

unsigned int y;

unsigned int w;

unsigned int h;

};

class GUIEventListener

{

public:

GUIEventListener() {}

virtual ~GUIEventListener() {}

virtual void OnGUIEvent(GUIParameters& param) = 0;

};

class GUIWidget

{

public:

GUIWidget(const std::string& sName);

virtual ~GUIWidget();

virtual void Update(float fTimeSinceLastFrame);

D3DXVECTOR2 GetPosition();

virtual void SetPosition(unsigned int x, unsigned int y);

void SetRelativePosition(unsigned int x, unsigned int y);

bool IsCollidingWithMousePointer(unsigned int x, unsigned int y);

void SetVisible(bool bVisible);

bool IsVisible();

void AddEventListener(GUIEventListener* pEventListener);

virtual void SetSize(unsigned int iWidth, unsigned int iHeight);

void GetSize(unsigned int& iWidth, unsigned int& iHeight);

std::string GetName();

void AddChild(GUIWidget* pChild);

void SetParent(GUIWidget* pParent);

bool HasParent();

void SetCanBeOverlaped(bool bCanBeOverlaped);

bool CanOverlap();

void GetChildren(std::map<std::string, GUIWidget*>& children);

GUIWidget* GetParent();

bool HasChildren();

virtual void SetActive(bool bActive);

bool IsActive();

bool IsChildrenLocked();

void SetChildrenLocked(bool bActive);

protected:

std::vector<GUIEventListener*> m_eventListeners;

void SendEventToListeners(GUIParameters& param);

private:

AABB m_aabox;

bool m_bVisible;

unsigned int m_iPosX;

unsigned int m_iPosY;

std::string m_sName;

GUIWidget* m_pParent;

std::map<std::string, GUIWidget*> m_children;

bool m_bCanBeOverlaped;

bool m_bActive;

bool m_bIsChildrenLocked;

};

#endif

Voici le fichier GUIWidget.cpp :

#include "GUIWidget.h"

#include "Sprite2D.h"
#include "Defines.h"

#include "GUIManager.h"

#include "System.h"
#include "InputManager.h"
#include "GUIManager.h"

GUIWidget::GUIWidget(const std::string& sName) :
m_iPosX(0),
m_iPosY(0),
m_sName(sName),
m_pParent(nullptr),
m_bCanBeOverlaped(true),
m_bVisible(true),
m_bActive(true),
m_bIsChildrenLocked(false)
{
    ZeroMemory(&m_aabox, sizeof(AABB));
}

GUIWidget::~GUIWidget()
{
}

void GUIWidget::Update(float fTimeSinceLastFrame)
{
}

void GUIWidget::SetCanBeOverlaped(bool bCanBeOverlaped)
{
    m_bCanBeOverlaped = bCanBeOverlaped;

    if (HasChildren())
    {
        for (auto it = m_children.begin(); it != m_children.end(); it++)
        {
            GUIWidget* pChild = it->second;

            pChild->SetCanBeOverlaped(bCanBeOverlaped);
        }
    }
}

bool GUIWidget::CanOverlap()
{
    return m_bCanBeOverlaped;
}

std::string GUIWidget::GetName()
{
    return m_sName;
}

D3DXVECTOR2 GUIWidget::GetPosition()
{
    return D3DXVECTOR2(m_iPosX, m_iPosY);
}

void GUIWidget::SetPosition(unsigned int x, unsigned int  y)
{
    m_iPosX = x;
    m_iPosY = y;

    m_aabox.x = x;
    m_aabox.y = y;
}

bool GUIWidget::IsCollidingWithMousePointer(unsigned int x, unsigned int  y)
{
    return (x >= m_aabox.x) && (x < (m_aabox.x + m_aabox.w))
        && (y >= m_aabox.y) && (y < (m_aabox.y + m_aabox.h));
}

void GUIWidget::SetVisible(bool bVisible)
{
    m_bVisible = bVisible;

    if (HasChildren())
    {
        for (auto it = m_children.begin(); it != m_children.end(); it++)
        {
            GUIWidget* pChild = it->second;

            pChild->SetVisible(bVisible);

            if (!bVisible)
            {
                SetActive(false);
            }
        }
    }
}

bool GUIWidget::IsVisible()
{
    return m_bVisible;
}

void GUIWidget::AddEventListener(GUIEventListener* pEventListener)
{
    m_eventListeners.push_back(pEventListener);
}

void GUIWidget::SendEventToListeners(GUIParameters& param)
{
    for (unsigned int i = 0; i < m_eventListeners.size(); i++)
    {
        GUIEventListener* pEventListener = m_eventListeners[i];
        pEventListener->OnGUIEvent(param);
    }
}

void GUIWidget::SetSize(unsigned int iWidth, unsigned int iHeight)
{
    m_aabox.w = iWidth;
    m_aabox.h = iHeight;
}

void GUIWidget::GetSize(unsigned int& iWidth, unsigned int& iHeight)
{
    iWidth = m_aabox.w;
    iHeight = m_aabox.h;
}

void GUIWidget::AddChild(GUIWidget* pChild)
{
    pChild->SetParent(this);

    m_children[pChild->GetName()] = pChild;
}

void GUIWidget::SetParent(GUIWidget* pParent)
{
    m_pParent = pParent;
}

void GUIWidget::GetChildren(std::map<std::string, GUIWidget*>& children)
{
    children = m_children;
}

GUIWidget* GUIWidget::GetParent()
{
    return m_pParent;
}

bool GUIWidget::HasParent()
{
    return m_pParent != nullptr;
}

void GUIWidget::SetRelativePosition(unsigned int  x, unsigned int  y)
{
    if (HasParent())
    {
        GUIWidget* pParent = GetParent();

        D3DXVECTOR2 pos = pParent->GetPosition();

        SetPosition(pos.x + x, pos.y + y);
    }
}

bool GUIWidget::HasChildren()
{
    return m_children.size() > 0;
}

void GUIWidget::SetActive(bool bActive)
{
    if (HasChildren())
    {
        for (auto it = m_children.begin(); it != m_children.end(); it++)
        {
            GUIWidget* pChild = it->second;

            pChild->SetActive(bActive);
        }
    }

    m_bActive = bActive;
}

bool GUIWidget::IsActive()
{
    return m_bActive;
}

bool GUIWidget::IsChildrenLocked()
{
    return m_bIsChildrenLocked;
}

void GUIWidget::SetChildrenLocked(bool bActive)
{
    m_bIsChildrenLocked = bActive;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

#include "GUIWidget.h"

#include "Sprite2D.h"

#include "Defines.h"

#include "GUIManager.h"

#include "System.h"

#include "InputManager.h"

#include "GUIManager.h"

GUIWidget::GUIWidget(const std::string& sName) :

m_iPosX(0),

m_iPosY(0),

m_sName(sName),

m_pParent(nullptr),

m_bCanBeOverlaped(true),

m_bVisible(true),

m_bActive(true),

m_bIsChildrenLocked(false)

{

ZeroMemory(&m_aabox, sizeof(AABB));

}

GUIWidget::~GUIWidget()

{

}

void GUIWidget::Update(float fTimeSinceLastFrame)

{

}

void GUIWidget::SetCanBeOverlaped(bool bCanBeOverlaped)

{

m_bCanBeOverlaped = bCanBeOverlaped;

if (HasChildren())

{

for (auto it = m_children.begin(); it != m_children.end(); it++)

{

GUIWidget* pChild = it->second;

pChild->SetCanBeOverlaped(bCanBeOverlaped);

}

bool GUIWidget::CanOverlap()

{

return m_bCanBeOverlaped;

}

std::string GUIWidget::GetName()

{

return m_sName;

}

D3DXVECTOR2 GUIWidget::GetPosition()

{

return D3DXVECTOR2(m_iPosX, m_iPosY);

}

void GUIWidget::SetPosition(unsigned int x, unsigned int y)

{

m_iPosX = x;

m_iPosY = y;

m_aabox.x = x;

m_aabox.y = y;

}

bool GUIWidget::IsCollidingWithMousePointer(unsigned int x, unsigned int y)

{

return (x >= m_aabox.x) && (x < (m_aabox.x + m_aabox.w))

&& (y >= m_aabox.y) && (y < (m_aabox.y + m_aabox.h));

}

void GUIWidget::SetVisible(bool bVisible)

{

m_bVisible = bVisible;

if (HasChildren())

{

for (auto it = m_children.begin(); it != m_children.end(); it++)

{

GUIWidget* pChild = it->second;

pChild->SetVisible(bVisible);

if (!bVisible)

{

SetActive(false);

}

bool GUIWidget::IsVisible()

{

return m_bVisible;

}

void GUIWidget::AddEventListener(GUIEventListener* pEventListener)

{

m_eventListeners.push_back(pEventListener);

}

void GUIWidget::SendEventToListeners(GUIParameters& param)

{

for (unsigned int i = 0; i < m_eventListeners.size(); i++)

{

GUIEventListener* pEventListener = m_eventListeners[i];

pEventListener->OnGUIEvent(param);

}

void GUIWidget::SetSize(unsigned int iWidth, unsigned int iHeight)

{

m_aabox.w = iWidth;

m_aabox.h = iHeight;

}

void GUIWidget::GetSize(unsigned int& iWidth, unsigned int& iHeight)

{

iWidth = m_aabox.w;

iHeight = m_aabox.h;

}

void GUIWidget::AddChild(GUIWidget* pChild)

{

pChild->SetParent(this);

m_children[pChild->GetName()] = pChild;

}

void GUIWidget::SetParent(GUIWidget* pParent)

{

m_pParent = pParent;

}

void GUIWidget::GetChildren(std::map<std::string, GUIWidget*>& children)

{

children = m_children;

}

GUIWidget* GUIWidget::GetParent()

{

return m_pParent;

}

bool GUIWidget::HasParent()

{

return m_pParent != nullptr;

}

void GUIWidget::SetRelativePosition(unsigned int x, unsigned int y)

{

if (HasParent())

{

GUIWidget* pParent = GetParent();

D3DXVECTOR2 pos = pParent->GetPosition();

SetPosition(pos.x + x, pos.y + y);

}

bool GUIWidget::HasChildren()

{

return m_children.size() > 0;

}

void GUIWidget::SetActive(bool bActive)

{

if (HasChildren())

{

for (auto it = m_children.begin(); it != m_children.end(); it++)

{

GUIWidget* pChild = it->second;

pChild->SetActive(bActive);

}

m_bActive = bActive;

}

bool GUIWidget::IsActive()

{

return m_bActive;

}

bool GUIWidget::IsChildrenLocked()

{

return m_bIsChildrenLocked;

}

void GUIWidget::SetChildrenLocked(bool bActive)

{

m_bIsChildrenLocked = bActive;

}

Résumé :

Nous avons présenter la première classe nommée GUIWidget qui servira de base à toutes les autres classes graphiques (GUI).

Une simple classe D3D10Renderer

Intro :

Pour utiliser DirectX, il nous faut une classe D3D10Renderer afin d’initialiser le rendu graphique 3D.

Prérequis :

– Aucun

Explications :

Voici le code du fichier D3D10Renderer.h :

#ifndef D3D10_RENDERER_H
#define D3D10_RENDERER_H

#include <windows.h>
#include <d3dx10math.h>
#include <DxErr.h>

#include "Defines.h"
#include "Singleton.h"
#include "Types.h"

#include "InputManager.h"

#pragma comment(lib, "d3d10.lib")
#pragma comment(lib, "d3dx10.lib")
#pragma comment(lib, "dxerr.lib")

class D3D10Renderer : public Singleton<D3D10Renderer>
{
public:
    D3D10Renderer(HWND hWnd);
    virtual ~D3D10Renderer();

    bool Initialize(bool bFullScreen);

    void Shutdown();

    void Render();

    ID3D10Device* GetDevice();

    uint32 GetViewportWidth();
    uint32 GetViewportHeight();
    
    void EnableZBuffer(bool bEnable);

    bool CreateSwapChain();
    bool CreateDepthStencilView();
    bool CreateRasterizerState();
    bool CreateDepthStencil();
    void CreateViewport();

    void UpdateWindowTitle();

    std::string Formater(const std::wstring& src);

    void SetFSAAMaximumLevel();

private:
    HWND m_hWnd;
    ID3D10Device* m_pd3dDevice;
    IDXGISwapChain* m_pSwapChain;        
    ID3D10RenderTargetView* m_pRenderTargetView;

    ID3D10Texture2D* m_pDepthStencil;
    ID3D10DepthStencilView* m_pDepthStencilView;
    ID3D10DepthStencilState* m_pDSState;
    ID3D10RasterizerState* m_pRasterizerState;

    uint32 m_iWidth;
    uint32 m_iHeight;

    bool m_bFullscreen;

    uint32 m_iFSAALevel;
};

#endif

#ifndef D3D10_RENDERER_H

#define D3D10_RENDERER_H

#include <windows.h>

#include <d3dx10math.h>

#include <DxErr.h>

#include "Defines.h"

#include "Singleton.h"

#include "Types.h"

#include "InputManager.h"

#pragma comment(lib, "d3d10.lib")

#pragma comment(lib, "d3dx10.lib")

#pragma comment(lib, "dxerr.lib")

class D3D10Renderer : public Singleton<D3D10Renderer>

{

public:

D3D10Renderer(HWND hWnd);

virtual ~D3D10Renderer();

bool Initialize(bool bFullScreen);

void Shutdown();

void Render();

ID3D10Device* GetDevice();

uint32 GetViewportWidth();

uint32 GetViewportHeight();

void EnableZBuffer(bool bEnable);

bool CreateSwapChain();

bool CreateDepthStencilView();

bool CreateRasterizerState();

bool CreateDepthStencil();

void CreateViewport();

void UpdateWindowTitle();

std::string Formater(const std::wstring& src);

void SetFSAAMaximumLevel();

private:

HWND m_hWnd;

ID3D10Device* m_pd3dDevice;

IDXGISwapChain* m_pSwapChain;

ID3D10RenderTargetView* m_pRenderTargetView;

ID3D10Texture2D* m_pDepthStencil;

ID3D10DepthStencilView* m_pDepthStencilView;

ID3D10DepthStencilState* m_pDSState;

ID3D10RasterizerState* m_pRasterizerState;

uint32 m_iWidth;

uint32 m_iHeight;

bool m_bFullscreen;

uint32 m_iFSAALevel;

};

#endif

Voici le code du fichier D3D10Renderer.cpp :

#include "D3D10Renderer.h"
#include "System.h"

#define WIN32_LEAN_AND_MEAN
#include <Windows.h>

template<> D3D10Renderer* Singleton<D3D10Renderer>::ms_instance = nullptr;

D3D10Renderer::D3D10Renderer(HWND hWnd) :
m_hWnd(hWnd),
m_pd3dDevice(nullptr),
m_pSwapChain(nullptr),
m_pRenderTargetView(nullptr),
m_pDepthStencil(nullptr),
m_pDSState(nullptr),
m_pDepthStencilView(nullptr),
m_iWidth(0),
m_iHeight(0),
m_bFullscreen(false),
m_iFSAALevel(8)
{
}

D3D10Renderer::~D3D10Renderer()
{
    if (m_pd3dDevice)
    {
        m_pd3dDevice->ClearState();
    }

    SAFE_RELEASE(m_pRenderTargetView);
    SAFE_RELEASE(m_pSwapChain);
    SAFE_RELEASE(m_pd3dDevice);
}

bool D3D10Renderer::Initialize(bool bFullscreen)
{
    m_bFullscreen = bFullscreen;

    // Variable pour stocker l'état erreur / succès
    HRESULT hr = S_OK;;

    if (!CreateSwapChain())
    {
        return false;
    }

    // Créé le back buffer
    ID3D10Texture2D* pBackBuffer;
    hr = m_pSwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&pBackBuffer);
    if (FAILED(hr))
    {
        return false;
    }

    // Créé la render target
    hr = m_pd3dDevice->CreateRenderTargetView(pBackBuffer, nullptr, &m_pRenderTargetView);
    pBackBuffer->Release();
    if (FAILED(hr))
    {
        return false;
    }

    if (!CreateDepthStencilView())
    {
        return false;
    }

    if (!CreateRasterizerState())
    {
        return false;
    }

    if (!CreateDepthStencil())
    {
        return false;
    }

    CreateViewport();

    ShowCursor(false);

    return true;
}

void D3D10Renderer::Render()
{
    __int64 cntsPerSec = 0;
    QueryPerformanceFrequency((LARGE_INTEGER*)&cntsPerSec);

    __int64 currTimeStamp = 0;
    QueryPerformanceCounter((LARGE_INTEGER*)&currTimeStamp);

    static __int64 prevTimeStamp = currTimeStamp;

    float secsPerCnt = 1.0f / (float)cntsPerSec;   

    float fTimeSinceLastFrame = (currTimeStamp - prevTimeStamp) * secsPerCnt;

    static float afClearColor[4] = {0.85f, 1.0f, 1.0f, 1.0f}; 

    // Efface la surface de rendu
    m_pd3dDevice->ClearDepthStencilView(m_pDepthStencilView, D3D10_CLEAR_DEPTH, 1.0f, 0 );
    m_pd3dDevice->ClearRenderTargetView(m_pRenderTargetView, afClearColor);

    UpdateWindowTitle();

    m_pSwapChain->Present(0, 0);

    prevTimeStamp = currTimeStamp;
}

ID3D10Device* D3D10Renderer::GetDevice()
{
    return m_pd3dDevice;
}

uint32 D3D10Renderer::GetViewportWidth()
{
    DXGI_SWAP_CHAIN_DESC swapChainDesc;
    ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));

    m_pSwapChain->GetDesc(&swapChainDesc);

    return swapChainDesc.BufferDesc.Width;
}

uint32 D3D10Renderer::GetViewportHeight()
{
    DXGI_SWAP_CHAIN_DESC swapChainDesc;
    ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));

    m_pSwapChain->GetDesc(&swapChainDesc);

    return swapChainDesc.BufferDesc.Height;
}

void D3D10Renderer::EnableZBuffer(bool bEnable)
{
    D3D10_DEPTH_STENCIL_DESC pDesc;

    m_pDSState->GetDesc(&pDesc);
    pDesc.DepthEnable = bEnable;

    m_pd3dDevice->OMSetDepthStencilState(m_pDSState, 1);
}

void D3D10Renderer::CreateViewport()
{
    // Création du viewport
    D3D10_VIEWPORT vp;

    vp.Width = m_iWidth;
    vp.Height = m_iHeight;
    vp.MinDepth = 0.0f;
    vp.MaxDepth = 1.0f;
    vp.TopLeftX = 0;
    vp.TopLeftY = 0;

    m_pd3dDevice->RSSetViewports( 1, &vp );
}

bool D3D10Renderer::CreateSwapChain()
{
    // Rectangle 2D pour les dimensions de la fenêtre
    RECT rc;

    // On obtient les dimensions de la fenêtre courante
    GetClientRect(m_hWnd, &rc);
    // Largeur de la fenêtre
    m_iWidth = rc.right - rc.left;
    // Hauteur de la fenêtre
    m_iHeight = rc.bottom - rc.top;

    // Paramètres de création du device
    UINT createDeviceFlags = 0;

    // Permet d'afficher les éventuelles erreurs de la création du device
    createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG;

    // Création de la Swap Chain
    // c'est-à-dire création du front buffer et du back buffer
    DXGI_SWAP_CHAIN_DESC sd;
    ZeroMemory(&sd, sizeof(sd));
    sd.BufferCount = 1;
    // Taille de la surface en pixels
    sd.BufferDesc.Width = m_iWidth;
    sd.BufferDesc.Height = m_iHeight;
    sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    // Format des couleurs
    sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    sd.BufferDesc.RefreshRate.Numerator = 0;
    sd.BufferDesc.RefreshRate.Denominator = 1;
    sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    // L'handle de la fenêtre que l'on va afficher dessus
    sd.OutputWindow = m_hWnd;
    sd.SampleDesc.Count = m_iFSAALevel;
    sd.SampleDesc.Quality = 0;
    // Fenêtré ou non
    sd.Windowed = !m_bFullscreen;
    sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;

    // On créé le device DirectX 10 et la Swap Chain
    HRESULT hr = D3D10CreateDeviceAndSwapChain(nullptr, D3D10_DRIVER_TYPE_HARDWARE, nullptr, createDeviceFlags,
                                               D3D10_SDK_VERSION, &sd, &m_pSwapChain, &m_pd3dDevice);
    if (FAILED(hr))
    {
        ShowMessageBoxDXError(hr);
        return false;
    }

    SetFSAAMaximumLevel();

    return true;
}

void D3D10Renderer::SetFSAAMaximumLevel()
{
    HRESULT hr = S_OK;
    UINT maxQualityLevel = 1;
    for (uint32 iSampleCount = 1; iSampleCount <= D3D10_MAX_MULTISAMPLE_SAMPLE_COUNT; iSampleCount++)
    {
        hr = m_pd3dDevice->CheckMultisampleQualityLevels(
            DXGI_FORMAT_R8G8B8A8_UNORM, iSampleCount, &maxQualityLevel);

        if (hr != S_OK)
        {
            fastprint(Formater(L"CheckMultisampleQualityLevels a échoué."));
        }
                                 
        if (maxQualityLevel > 0)
        {
            fastprint("MSAA " << iSampleCount << Formater(L"X supportée par la carte vidéo avec ") <<
                maxQualityLevel << Formater(L" niveau(x) de qualité."));
        }
    }
}

bool D3D10Renderer::CreateDepthStencilView()
{
    HRESULT hr = S_OK;

    D3D10_TEXTURE2D_DESC descDepth;
    ZeroMemory(&descDepth, sizeof(descDepth));
    descDepth.Width = m_iWidth;
    descDepth.Height = m_iHeight;
    descDepth.MipLevels = 1;
    descDepth.ArraySize = 1;
    descDepth.Format = DXGI_FORMAT_D32_FLOAT;
    descDepth.SampleDesc.Count = m_iFSAALevel;
    descDepth.SampleDesc.Quality = 0;
    descDepth.Usage = D3D10_USAGE_DEFAULT;
    descDepth.BindFlags = D3D10_BIND_DEPTH_STENCIL;
    descDepth.CPUAccessFlags = 0;
    descDepth.MiscFlags = 0;

    hr = m_pd3dDevice->CreateTexture2D(&descDepth, nullptr, &m_pDepthStencil);

    if (FAILED(hr))
    {
        ShowMessageBoxDXError(hr);
        return false;
    }
        
    D3D10_DEPTH_STENCIL_VIEW_DESC descDSV;
    descDSV.Format = descDepth.Format;

    if (m_iFSAALevel > 1)
    {
        descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2DMS;
    }
    else
    {
        descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D;
    }

    descDSV.Texture2D.MipSlice = 0;

    hr = m_pd3dDevice->CreateDepthStencilView(m_pDepthStencil, &descDSV, &m_pDepthStencilView);

    if (FAILED(hr))
    {
        ShowMessageBoxDXError(hr);
        return false;
    }

    m_pd3dDevice->OMSetRenderTargets(1, &m_pRenderTargetView, m_pDepthStencilView);

    return true;
}

bool D3D10Renderer::CreateRasterizerState()
{
    D3D10_RASTERIZER_DESC rasterizerState;

    rasterizerState.CullMode = D3D10_CULL_NONE;
    rasterizerState.FillMode = D3D10_FILL_SOLID;
    rasterizerState.FrontCounterClockwise = true;
    rasterizerState.DepthBias = false;
    rasterizerState.DepthBiasClamp = 0;
    rasterizerState.SlopeScaledDepthBias = 0;
    rasterizerState.DepthClipEnable = true;
    rasterizerState.ScissorEnable = false;
    rasterizerState.MultisampleEnable = true;
    rasterizerState.AntialiasedLineEnable = true;

    HRESULT hr = m_pd3dDevice->CreateRasterizerState(&rasterizerState, &m_pRasterizerState);    

    m_pd3dDevice->RSSetState(m_pRasterizerState);

    if (FAILED(hr))
    {
        ShowMessageBoxDXError(hr);
        return false;
    }

    return true;
}

bool D3D10Renderer::CreateDepthStencil()
{
    D3D10_DEPTH_STENCIL_DESC pDesc;

    pDesc.DepthEnable = true;
    pDesc.DepthWriteMask = D3D10_DEPTH_WRITE_MASK_ALL;
    pDesc.DepthFunc = D3D10_COMPARISON_LESS;
    pDesc.StencilEnable = true;
    pDesc.StencilReadMask = 0xFF;
    pDesc.StencilWriteMask = 0xFF;
    pDesc.FrontFace.StencilFailOp = D3D10_STENCIL_OP_KEEP;
    pDesc.FrontFace.StencilDepthFailOp = D3D10_STENCIL_OP_INCR;
    pDesc.FrontFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;
    pDesc.FrontFace.StencilFunc = D3D10_COMPARISON_ALWAYS;
    pDesc.BackFace.StencilFailOp = D3D10_STENCIL_OP_KEEP;
    pDesc.BackFace.StencilDepthFailOp = D3D10_STENCIL_OP_DECR;
    pDesc.BackFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;
    pDesc.BackFace.StencilFunc = D3D10_COMPARISON_ALWAYS;

    HRESULT hr = m_pd3dDevice->CreateDepthStencilState(&pDesc, &m_pDSState);

    if (FAILED(hr))
    {
        ShowMessageBoxDXError(hr);
        return false;
    }

    m_pd3dDevice->OMSetDepthStencilState(m_pDSState, 1);

    return true;
}

FPSCamera* D3D10Renderer::GetCamera()
{
    return m_pCamera;
}

void D3D10Renderer::OnKeyPressed(const KeyEvent& arg)
{
    if (arg.keyCode == VK_ESCAPE)
    {
        SYSTEM->Quit();
    }
}

void D3D10Renderer::OnKeyReleased(const KeyEvent& arg)
{
}

void D3D10Renderer::UpdateWindowTitle()
{
    static char buffer[256];
    D3DXVECTOR3 camPos = D3DXVECTOR3(1.0f, 1.0f, 1.0f);

    sprintf(buffer, "Position de la caméra : X = %.2f Y = %.2f Z = %.2f", camPos.x, camPos.y, camPos.z);
 
    // On met à jour le titre de la fenêtre
    SetWindowTextA(m_hWnd, buffer);
}

std::string D3D10Renderer::Formater(const std::wstring& src)
{
    char outString[512];
    CharToOemW(src.c_str(), outString);
 
    return std::string(outString);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

#include "D3D10Renderer.h"

#include "System.h"

#define WIN32_LEAN_AND_MEAN

#include <Windows.h>

template<> D3D10Renderer* Singleton<D3D10Renderer>::ms_instance = nullptr;

D3D10Renderer::D3D10Renderer(HWND hWnd) :

m_hWnd(hWnd),

m_pd3dDevice(nullptr),

m_pSwapChain(nullptr),

m_pRenderTargetView(nullptr),

m_pDepthStencil(nullptr),

m_pDSState(nullptr),

m_pDepthStencilView(nullptr),

m_iWidth(0),

m_iHeight(0),

m_bFullscreen(false),

m_iFSAALevel(8)

{

}

D3D10Renderer::~D3D10Renderer()

{

if (m_pd3dDevice)

{

m_pd3dDevice->ClearState();

}

SAFE_RELEASE(m_pRenderTargetView);

SAFE_RELEASE(m_pSwapChain);

SAFE_RELEASE(m_pd3dDevice);

}

bool D3D10Renderer::Initialize(bool bFullscreen)

{

m_bFullscreen = bFullscreen;

// Variable pour stocker l'état erreur / succès

HRESULT hr = S_OK;;

if (!CreateSwapChain())

{

return false;

}

// Créé le back buffer

ID3D10Texture2D* pBackBuffer;

hr = m_pSwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&pBackBuffer);

if (FAILED(hr))

{

return false;

}

// Créé la render target

hr = m_pd3dDevice->CreateRenderTargetView(pBackBuffer, nullptr, &m_pRenderTargetView);

pBackBuffer->Release();

if (FAILED(hr))

{

return false;

}

if (!CreateDepthStencilView())

{

return false;

}

if (!CreateRasterizerState())

{

return false;

}

if (!CreateDepthStencil())

{

return false;

}

CreateViewport();

ShowCursor(false);

return true;

}

void D3D10Renderer::Render()

{

__int64 cntsPerSec = 0;

QueryPerformanceFrequency((LARGE_INTEGER*)&cntsPerSec);

__int64 currTimeStamp = 0;

QueryPerformanceCounter((LARGE_INTEGER*)&currTimeStamp);

static __int64 prevTimeStamp = currTimeStamp;

float secsPerCnt = 1.0f / (float)cntsPerSec;

float fTimeSinceLastFrame = (currTimeStamp - prevTimeStamp) * secsPerCnt;

static float afClearColor[4] = {0.85f, 1.0f, 1.0f, 1.0f};

// Efface la surface de rendu

m_pd3dDevice->ClearDepthStencilView(m_pDepthStencilView, D3D10_CLEAR_DEPTH, 1.0f, 0 );

m_pd3dDevice->ClearRenderTargetView(m_pRenderTargetView, afClearColor);

UpdateWindowTitle();

m_pSwapChain->Present(0, 0);

prevTimeStamp = currTimeStamp;

}

ID3D10Device* D3D10Renderer::GetDevice()

{

return m_pd3dDevice;

}

uint32 D3D10Renderer::GetViewportWidth()

{

DXGI_SWAP_CHAIN_DESC swapChainDesc;

ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));

m_pSwapChain->GetDesc(&swapChainDesc);

return swapChainDesc.BufferDesc.Width;

}

uint32 D3D10Renderer::GetViewportHeight()

{

DXGI_SWAP_CHAIN_DESC swapChainDesc;

ZeroMemory(&swapChainDesc, sizeof(swapChainDesc));

m_pSwapChain->GetDesc(&swapChainDesc);

return swapChainDesc.BufferDesc.Height;

}

void D3D10Renderer::EnableZBuffer(bool bEnable)

{

D3D10_DEPTH_STENCIL_DESC pDesc;

m_pDSState->GetDesc(&pDesc);

pDesc.DepthEnable = bEnable;

m_pd3dDevice->OMSetDepthStencilState(m_pDSState, 1);

}

void D3D10Renderer::CreateViewport()

{

// Création du viewport

D3D10_VIEWPORT vp;

vp.Width = m_iWidth;

vp.Height = m_iHeight;

vp.MinDepth = 0.0f;

vp.MaxDepth = 1.0f;

vp.TopLeftX = 0;

vp.TopLeftY = 0;

m_pd3dDevice->RSSetViewports( 1, &vp );

}

bool D3D10Renderer::CreateSwapChain()

{

// Rectangle 2D pour les dimensions de la fenêtre

RECT rc;

// On obtient les dimensions de la fenêtre courante

GetClientRect(m_hWnd, &rc);

// Largeur de la fenêtre

m_iWidth = rc.right - rc.left;

// Hauteur de la fenêtre

m_iHeight = rc.bottom - rc.top;

// Paramètres de création du device

UINT createDeviceFlags = 0;

// Permet d'afficher les éventuelles erreurs de la création du device

createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG;

// Création de la Swap Chain

// c'est-à-dire création du front buffer et du back buffer

DXGI_SWAP_CHAIN_DESC sd;

ZeroMemory(&sd, sizeof(sd));

sd.BufferCount = 1;

// Taille de la surface en pixels

sd.BufferDesc.Width = m_iWidth;

sd.BufferDesc.Height = m_iHeight;

sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;

// Format des couleurs

sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;

sd.BufferDesc.RefreshRate.Numerator = 0;

sd.BufferDesc.RefreshRate.Denominator = 1;

sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;

// L'handle de la fenêtre que l'on va afficher dessus

sd.OutputWindow = m_hWnd;

sd.SampleDesc.Count = m_iFSAALevel;

sd.SampleDesc.Quality = 0;

// Fenêtré ou non

sd.Windowed = !m_bFullscreen;

sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;

// On créé le device DirectX 10 et la Swap Chain

HRESULT hr = D3D10CreateDeviceAndSwapChain(nullptr, D3D10_DRIVER_TYPE_HARDWARE, nullptr, createDeviceFlags,

D3D10_SDK_VERSION, &sd, &m_pSwapChain, &m_pd3dDevice);

if (FAILED(hr))

{

ShowMessageBoxDXError(hr);

return false;

}

SetFSAAMaximumLevel();

return true;

}

void D3D10Renderer::SetFSAAMaximumLevel()

{

HRESULT hr = S_OK;

UINT maxQualityLevel = 1;

for (uint32 iSampleCount = 1; iSampleCount <= D3D10_MAX_MULTISAMPLE_SAMPLE_COUNT; iSampleCount++)

{

hr = m_pd3dDevice->CheckMultisampleQualityLevels(

DXGI_FORMAT_R8G8B8A8_UNORM, iSampleCount, &maxQualityLevel);

if (hr != S_OK)

{

fastprint(Formater(L"CheckMultisampleQualityLevels a échoué."));

}

if (maxQualityLevel > 0)

{

fastprint("MSAA " << iSampleCount << Formater(L"X supportée par la carte vidéo avec ") <<

maxQualityLevel << Formater(L" niveau(x) de qualité."));

}

bool D3D10Renderer::CreateDepthStencilView()

{

HRESULT hr = S_OK;

D3D10_TEXTURE2D_DESC descDepth;

ZeroMemory(&descDepth, sizeof(descDepth));

descDepth.Width = m_iWidth;

descDepth.Height = m_iHeight;

descDepth.MipLevels = 1;

descDepth.ArraySize = 1;

descDepth.Format = DXGI_FORMAT_D32_FLOAT;

descDepth.SampleDesc.Count = m_iFSAALevel;

descDepth.SampleDesc.Quality = 0;

descDepth.Usage = D3D10_USAGE_DEFAULT;

descDepth.BindFlags = D3D10_BIND_DEPTH_STENCIL;

descDepth.CPUAccessFlags = 0;

descDepth.MiscFlags = 0;

hr = m_pd3dDevice->CreateTexture2D(&descDepth, nullptr, &m_pDepthStencil);

if (FAILED(hr))

{

ShowMessageBoxDXError(hr);

return false;

}

D3D10_DEPTH_STENCIL_VIEW_DESC descDSV;

descDSV.Format = descDepth.Format;

if (m_iFSAALevel > 1)

{

descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2DMS;

}

else

{

descDSV.ViewDimension = D3D10_DSV_DIMENSION_TEXTURE2D;

}

descDSV.Texture2D.MipSlice = 0;

hr = m_pd3dDevice->CreateDepthStencilView(m_pDepthStencil, &descDSV, &m_pDepthStencilView);

if (FAILED(hr))

{

ShowMessageBoxDXError(hr);

return false;

}

m_pd3dDevice->OMSetRenderTargets(1, &m_pRenderTargetView, m_pDepthStencilView);

return true;

}

bool D3D10Renderer::CreateRasterizerState()

{

D3D10_RASTERIZER_DESC rasterizerState;

rasterizerState.CullMode = D3D10_CULL_NONE;

rasterizerState.FillMode = D3D10_FILL_SOLID;

rasterizerState.FrontCounterClockwise = true;

rasterizerState.DepthBias = false;

rasterizerState.DepthBiasClamp = 0;

rasterizerState.SlopeScaledDepthBias = 0;

rasterizerState.DepthClipEnable = true;

rasterizerState.ScissorEnable = false;

rasterizerState.MultisampleEnable = true;

rasterizerState.AntialiasedLineEnable = true;

HRESULT hr = m_pd3dDevice->CreateRasterizerState(&rasterizerState, &m_pRasterizerState);

m_pd3dDevice->RSSetState(m_pRasterizerState);

if (FAILED(hr))

{

ShowMessageBoxDXError(hr);

return false;

}

return true;

}

bool D3D10Renderer::CreateDepthStencil()

{

D3D10_DEPTH_STENCIL_DESC pDesc;

pDesc.DepthEnable = true;

pDesc.DepthWriteMask = D3D10_DEPTH_WRITE_MASK_ALL;

pDesc.DepthFunc = D3D10_COMPARISON_LESS;

pDesc.StencilEnable = true;

pDesc.StencilReadMask = 0xFF;

pDesc.StencilWriteMask = 0xFF;

pDesc.FrontFace.StencilFailOp = D3D10_STENCIL_OP_KEEP;

pDesc.FrontFace.StencilDepthFailOp = D3D10_STENCIL_OP_INCR;

pDesc.FrontFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;

pDesc.FrontFace.StencilFunc = D3D10_COMPARISON_ALWAYS;

pDesc.BackFace.StencilFailOp = D3D10_STENCIL_OP_KEEP;

pDesc.BackFace.StencilDepthFailOp = D3D10_STENCIL_OP_DECR;

pDesc.BackFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;

pDesc.BackFace.StencilFunc = D3D10_COMPARISON_ALWAYS;

HRESULT hr = m_pd3dDevice->CreateDepthStencilState(&pDesc, &m_pDSState);

if (FAILED(hr))

{

ShowMessageBoxDXError(hr);

return false;

}

m_pd3dDevice->OMSetDepthStencilState(m_pDSState, 1);

return true;

}

FPSCamera* D3D10Renderer::GetCamera()

{

return m_pCamera;

}

void D3D10Renderer::OnKeyPressed(const KeyEvent& arg)

{

if (arg.keyCode == VK_ESCAPE)

{

SYSTEM->Quit();

}

void D3D10Renderer::OnKeyReleased(const KeyEvent& arg)

{

}

void D3D10Renderer::UpdateWindowTitle()

{

static char buffer[256];

D3DXVECTOR3 camPos = D3DXVECTOR3(1.0f, 1.0f, 1.0f);

sprintf(buffer, "Position de la caméra : X = %.2f Y = %.2f Z = %.2f", camPos.x, camPos.y, camPos.z);

// On met à jour le titre de la fenêtre

SetWindowTextA(m_hWnd, buffer);

}

std::string D3D10Renderer::Formater(const std::wstring& src)

{

char outString[512];

CharToOemW(src.c_str(), outString);

return std::string(outString);

}

Résumé :

Nous avons présenté les deux fichiers nécessaire à l’initialiser du rendu graphique de DirectX !

Le texture mapping

Intro :

Le texture mapping est une opération qui consiste à ajouter, avec une image, du détail de couleur à un modèle 3D.

Ce procédé est réalisé par l’étape Pixel Shader de la pipeline graphique du GPU.

Prérequis :

Explications :

Résumé :

Références :

– https://takinginitiative.files.wordpress.com/2010/08/6.pdf

Les différents espaces de rendu graphique

Intro :

Avant d’effectuer un rendu en deux dimensions à l’écran (qui est une matrice de pixels), il est nécessaire d’effectuer certaines conversions de coordonnées entre des repères bien spécifiques.

DirectX a besoin de 3 matrices pour effectuer ce rendu.

Prérequis :

– Savoir ce qu’est une matrice

– Savoir ce qu’est un vecteur

– Savoir ce qu’est une transformation d’un système coordonnées dans un autre

Explications :

Tous les objets 3D sont composés d’un ensemble de triangles. Ces triangles sont composés de vertices. Ce qui fait que les objets 3D (appelés aussi meshes) sont représentés simplement une liste de vertices.

Model Space :

[image bonhomme avec axe model space]

Pour repérer correctement les vertices d’un modèle, nous avons besoin d’un repère ou d’un système de coordonnées.

Chaque modèle (ou mesh) a un système de coordonnée appelé en anglais « Space » .

L’artiste qui a créé ce modèle avec un logiciel de modélisation 3D (comme Maya, Blender ou 3D Studio Max)
a défini ses vertices dans cet espace (qui se nomme comme le Model Space).

World Space :

Notre scène a aussi un système de coordonnées (ou repère) qui se nomme le « World Space » et chaque modèle / objet a une position relative à ce dernier repère.

C’est dans cet espace que nous pouvons effectuer des translations, des rotations et des agrandissements.

View Space :

Nous avons besoin que la scène soit vue d’une certaine position dans celle-ci. Cette position s’appelle l’œil (the eye en anglais) ou la caméra.

Projection Space :

Nous avons besoin d’afficher le contenu de la scène en fonction de la position de la caméra à l’écran ou au framebuffer.

Résumé :

Références :

– https://fr.wikipedia.org/wiki/Rast%C3%A9risation

– https://en.wikipedia.org/wiki/Rasterisation

– https://takinginitiative.files.wordpress.com/2010/08/2.pdf

La technique du back-face culling

Intro :

La technique du back-face culling permet d’ignorer le rendu des triangles qui ne sont pas visible par l’observateur ou la caméra.

Prérequis :

– Savoir ce qu’est un produit scalaire

Explications :

Par exemple, les triangles de l’intérieur d’un modèle ou personnage ne seront pas rendu si l’on rentre et se positionne dedans !

Dans DirectX, les vertices d’un triangle sont définis dans un certain ordre (il existe deux sens : le sens « counter clockwise » et le sens « closewise»). Cet ordre va définir dans quel sens est orienté la normale du triangle en question (voir l’article sur la normale).

Comment ça fonctionne ?

Soit le vecteur représentant la position de la caméra $\vec{c} $ ; et le vecteur représentant la position du centre du polygone à tester $\vec{p} $.

On calcule donc le vecteur $\vec{v} = \vec{p} – \vec{c} $

On a aussi le vecteur normal à ce même polygone $\vec{n} $

Mathématiquement :

$k = \vec{v} \cdot \vec{n} $

Si le produit scalaire $k $ est positif (en fait cela dépend du type de culling) alors cela signifie que le triangle est orienté dans le même sens que la vue (il nous tourne le dos), et il peut donc être éliminé du rendu.

Voilà c’est tout simple !

Il faut savoir aussi que cet algorithme est géré automatiquement par DirectX et la carte graphique.

On peut le configurer comme suit :

D3D10_RASTERIZER_DESC rasterizerState;

rasterizerState.CullMode = D3D10_CULL_NONE;
rasterizerState.FillMode = D3D10_FILL_SOLID;
rasterizerState.FrontCounterClockwise = true;

m_pd3dDevice->CreateRasterizerState(&rasterizerState, &m_pRasterizerState);    
m_pd3dDevice->RSSetState(m_pRasterizerState);

D3D10_RASTERIZER_DESC rasterizerState;

rasterizerState.CullMode = D3D10_CULL_NONE;

rasterizerState.FillMode = D3D10_FILL_SOLID;

rasterizerState.FrontCounterClockwise = true;

m_pd3dDevice->CreateRasterizerState(&rasterizerState, &m_pRasterizerState);

m_pd3dDevice->RSSetState(m_pRasterizerState);

Résumé :

Pour conclure, le backface culling est l’élimination des faces qui « tournent le dos » à la caméra et que l’on ne voit donc pas.

Références :

– http://jeux.developpez.com/faq/3d/?page=culling

– http://stackoverflow.com/questions/3595087/opengl-newbie-question-what-is-back-face-culling

– http://www.gamedev.net/page/resources/_/technical/graphics-programming-and-theory/3d-backface-culling-r1088

– https://en.wikipedia.org/wiki/Back-face_culling

– https://fr.wikipedia.org/wiki/D%C3%A9termination_des_surfaces_cach%C3%A9es

Le Frustum de la caméra

Intro :

Appelé aussi « view frustum », ce volume décrit la façon dont la caméra effectue le rendu 2D.

En effet, pour effectuer du rendu 3D à l’écran, il faut définir une « camera » virtuelle qui pourra se mouvoir et se déplacer dans la scène.

Prérequis :

– Savoir initialiser DirectX 10.1

Explications :

Cette caméra spécifie quel volume, depuis l’observateur de la scène, elle peut observer.

L’espace compartimenté entre le « near clip plane » et le « far clip plane » définit le volume que la caméra peut voir. Cet espace s’appelle le « frustum » de la caméra, et comme on peut le voir c’est une sorte de pyramide tronquée.

Le clipping :

Les objets (ou les parties d’objets) qui ne sont pas à l’intérieur de ce volume doivent être ignorés avant d’être traités vers le rendu 2D. Ce procédé s’appelle le « clipping » (ou coupage en français).

Le « near clip plane » définit jusqu’à quelle distance les objets les plus proches de la caméra sont ignorés, en effet les objets situés entre le « near clip plane » et la caméra sont « coupés » (clipped).

Le « fear clip plane » définit jusqu’à quelle distance les objets les plus loins de la caméra sont ignorés, en effet les objets situés au delà du « far clip plane » sont « coupés » (clipped).

Les triangles situés en partie dans ce volume sont séparés en deux parties.

Les propriétés de ce volume « frustum » dépendent du FOV (Field of View) et des positions des near clip plane et fear clip plane.

La nature du frustum va modifier la façon dont le rendu sera effectué à l’écran 2D. C’est-à-dire depuis l’espace de la caméra 3D vers l’espace de projection 2D.

Composition :

Le frustum est composé de 6 plans formant une pyramide tronquée.

Pour savoir savoir si un point est dans le volume on utilise le produit scalaire sur ces 6 plans. Si les valeurs correspondent après avoir calculer les produits scalaire, le point est à l’intérieur du frustum.

Résumé :

Le frustum de la caméra représente le volume de vue que l’observateur peut voir dans la scène (graphe qui est formée de tous les modèles visibles).

Référence :

– https://msdn.microsoft.com/en-us/library/ff634570.aspx

– https://en.wikipedia.org/wiki/Viewing_frustum

– Shader Approach – Franck D.Luna

Kit basique d’initialisation DirectX 10.1

Intro :

Voici un kit formé d’un ensemble de fichiers qui pourra servir de base pour vos programmes graphiques ou essais 3D. Le kit comprend à peu près 4000 lignes de code.

Prérequis :

– Savoir lire du C++

Explications :

[rajouter : ]

[fullscreen switch]

[shadermanager]

Il comprend :

– le support de la transparence

– une caméra classique

– une caméra de type FPS (First Person Shooter) avec laquelle on peut voler partout

– une énumération de couleurs

– un gestionnaire D3D10Renderer – quasi complet

– la possibilité de lancer l’application en plein-écran ou non

– la possibilité d’afficher du texte

– des gestionnaires en design-pattern Singleton (classe Singleton)

– un ensemble de macros toutes utiles

– un gestionnaire InputManager pour gérer les entrées clavier et souris de l’utilisateur

– une classe SceneNode pour représenter vos entités sur la scène

– avec fonctions de translation, rotation et agrandissement

– un gestionnaire de fichier effet Shader avec gestion automatique des variables shader

– quelques définitions de shaders (ex : simple, lumière)

– une classe SkyDomeSceneNode (pour afficher un ciel avec une TextureCube)

– une classe SphereMeshSceneNode pour générer une sphère de façon procédurale

– une classe System

– une classe TextureManager pour charger les fichiers textures rapidement

– une liste complète de déclaration de vertex (avec les Vertex Input Layout)

– une classe Utils avec fonctions toutes très utiles

Résumé :

Voici l’archive contenant le kit et tous ses fichiers associés.

Références :

– stackoverflow.com

Utilisation du type TextureArray

Intro :

Souvent à l’étape pixel shader, on a besoin d’accéder à plusieurs textures en même temps.

Prérequis :

– Savoir lire du C++

– Savoir initialiser DirectX

Explications :

Voici une fonction qui créé un objet Texture2D :

ID3D10Texture2D* CreateTexture(const std::string& sImageFileName)
{
    ID3D10Texture2D* pLoadedTexture = nullptr;

    D3DX10_IMAGE_LOAD_INFO loadinfo;
    ZeroMemory(&loadinfo, sizeof(D3DX10_IMAGE_LOAD_INFO));

    loadinfo.Width = D3DX10_FROM_FILE;
    loadinfo.Height = D3DX10_FROM_FILE;
    loadinfo.Depth = D3DX10_FROM_FILE;

    loadinfo.FirstMipLevel = 0;
    loadinfo.MipLevels = D3DX10_FROM_FILE;
    loadinfo.Usage = D3D10_USAGE_STAGING;

    loadinfo.BindFlags = 0;
    loadinfo.CpuAccessFlags = D3D10_CPU_ACCESS_READ | D3D10_CPU_ACCESS_WRITE;
    loadinfo.MiscFlags = 0;

    loadinfo.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    loadinfo.Filter = D3DX10_FILTER_NONE;
    loadinfo.MipFilter = D3DX10_FILTER_NONE;
    loadinfo.pSrcInfo = 0;

    D3DX10CreateTextureFromFileA(D3D10_RENDERER->GetDevice(),
        sImageFileName.c_str(), &loadinfo, 0, (ID3D10Resource**)&pLoadedTexture, 0);

    return pLoadedTexture;
}

ID3D10Texture2D* CreateTexture(const std::string& sImageFileName)

{

ID3D10Texture2D* pLoadedTexture = nullptr;

D3DX10_IMAGE_LOAD_INFO loadinfo;

ZeroMemory(&loadinfo, sizeof(D3DX10_IMAGE_LOAD_INFO));

loadinfo.Width = D3DX10_FROM_FILE;

loadinfo.Height = D3DX10_FROM_FILE;

loadinfo.Depth = D3DX10_FROM_FILE;

loadinfo.FirstMipLevel = 0;

loadinfo.MipLevels = D3DX10_FROM_FILE;

loadinfo.Usage = D3D10_USAGE_STAGING;

loadinfo.BindFlags = 0;

loadinfo.CpuAccessFlags = D3D10_CPU_ACCESS_READ | D3D10_CPU_ACCESS_WRITE;

loadinfo.MiscFlags = 0;

loadinfo.Format = DXGI_FORMAT_R8G8B8A8_UNORM;

loadinfo.Filter = D3DX10_FILTER_NONE;

loadinfo.MipFilter = D3DX10_FILTER_NONE;

loadinfo.pSrcInfo = 0;

D3DX10CreateTextureFromFileA(D3D10_RENDERER->GetDevice(),

sImageFileName.c_str(), &loadinfo, 0, (ID3D10Resource**)&pLoadedTexture, 0);

return pLoadedTexture;

}

Voici une fonction qui créé un objet Texture2D assemblé et combiné de plusieurs Texture2D :

ID3D10Texture2D* CreateTextureArray(std::vector<ID3D10Texture2D*>& textures)
{
    if (textures.size() == 0)
    {
        return nullptr;
    }

    ID3D10Texture2D* pTexturesArray = nullptr;

    D3D10_TEXTURE2D_DESC textElementDesc;
    ZeroMemory(&textElementDesc, sizeof(D3D10_TEXTURE2D_DESC));

    textures[0]->GetDesc(&textElementDesc);

    D3D10_TEXTURE2D_DESC textArrayDesc;

    textArrayDesc.Width = textElementDesc.Width;
    textArrayDesc.Height = textElementDesc.Height;
    textArrayDesc.MipLevels = textElementDesc.MipLevels;
    textArrayDesc.ArraySize = textures.size();
    textArrayDesc.Format = textElementDesc.Format;
    textArrayDesc.SampleDesc.Count = 1;
    textArrayDesc.SampleDesc.Quality = 0;
    textArrayDesc.Usage = D3D10_USAGE_DEFAULT;
    textArrayDesc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
    textArrayDesc.CPUAccessFlags = 0;
    textArrayDesc.MiscFlags = 0;

    D3D10_RENDERER->GetDevice()->CreateTexture2D(&textArrayDesc, 0, &pTexturesArray);

    // On copie toutes les textures dans le tableau !
    for (uint16 i = 0; i < textures.size(); i++)
    {
        for (uint16 j = 0; j < textElementDesc.MipLevels; j++)
        {
            D3D10_MAPPED_TEXTURE2D mappedTex2D;

            ID3D10Texture2D* pCurrentTexture = textures[i];

            pCurrentTexture->Map(j, D3D10_MAP_READ, 0, &mappedTex2D);

            uint32 c = D3D10CalcSubresource(j, i, textElementDesc.MipLevels);

            D3D10_RENDERER->GetDevice()->UpdateSubresource(pTexturesArray, c,
                0, mappedTex2D.pData, mappedTex2D.RowPitch, 0);

            pCurrentTexture->Unmap(j);
        }
    }

    return pTexturesArray;
}

ID3D10Texture2D* CreateTextureArray(std::vector<ID3D10Texture2D*>& textures)

{

if (textures.size() == 0)

{

return nullptr;

}

ID3D10Texture2D* pTexturesArray = nullptr;

D3D10_TEXTURE2D_DESC textElementDesc;

ZeroMemory(&textElementDesc, sizeof(D3D10_TEXTURE2D_DESC));

textures[0]->GetDesc(&textElementDesc);

D3D10_TEXTURE2D_DESC textArrayDesc;

textArrayDesc.Width = textElementDesc.Width;

textArrayDesc.Height = textElementDesc.Height;

textArrayDesc.MipLevels = textElementDesc.MipLevels;

textArrayDesc.ArraySize = textures.size();

textArrayDesc.Format = textElementDesc.Format;

textArrayDesc.SampleDesc.Count = 1;

textArrayDesc.SampleDesc.Quality = 0;

textArrayDesc.Usage = D3D10_USAGE_DEFAULT;

textArrayDesc.BindFlags = D3D10_BIND_SHADER_RESOURCE;

textArrayDesc.CPUAccessFlags = 0;

textArrayDesc.MiscFlags = 0;

D3D10_RENDERER->GetDevice()->CreateTexture2D(&textArrayDesc, 0, &pTexturesArray);

// On copie toutes les textures dans le tableau !

for (uint16 i = 0; i < textures.size(); i++)

{

for (uint16 j = 0; j < textElementDesc.MipLevels; j++)

{

D3D10_MAPPED_TEXTURE2D mappedTex2D;

ID3D10Texture2D* pCurrentTexture = textures[i];

pCurrentTexture->Map(j, D3D10_MAP_READ, 0, &mappedTex2D);

uint32 c = D3D10CalcSubresource(j, i, textElementDesc.MipLevels);

D3D10_RENDERER->GetDevice()->UpdateSubresource(pTexturesArray, c,

0, mappedTex2D.pData, mappedTex2D.RowPitch, 0);

pCurrentTexture->Unmap(j);

}

return pTexturesArray;

}

Voici la fonction qui créée une texture ressource shader pour le programme HLSL :

ID3D10ShaderResourceView* FontTextManager::GetTextureRVArray(ID3D10Texture2D* pTexArray)
{
    if (pTexArray == nullptr)
    {
        return nullptr;
    }

    ID3D10ShaderResourceView* pArrayRV = nullptr;

    D3D10_SHADER_RESOURCE_VIEW_DESC viewDesc;
    ZeroMemory(&viewDesc, sizeof(D3D10_SHADER_RESOURCE_VIEW_DESC));

    D3D10_TEXTURE2D_DESC textArrayDesc;
    pTexArray->GetDesc(&textArrayDesc);

    viewDesc.Format = textArrayDesc.Format;
    viewDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2DARRAY;
    viewDesc.Texture1DArray.MostDetailedMip = 0;
    viewDesc.Texture1DArray.MipLevels = textArrayDesc.MipLevels;
    viewDesc.Texture1DArray.FirstArraySlice = 0;
    viewDesc.Texture1DArray.ArraySize = textArrayDesc.ArraySize;

    D3D10_RENDERER->GetDevice()->CreateShaderResourceView(pTexArray, &viewDesc, &pArrayRV);

    return pArrayRV;
}

ID3D10ShaderResourceView* FontTextManager::GetTextureRVArray(ID3D10Texture2D* pTexArray)

{

if (pTexArray == nullptr)

{

return nullptr;

}

ID3D10ShaderResourceView* pArrayRV = nullptr;

D3D10_SHADER_RESOURCE_VIEW_DESC viewDesc;

ZeroMemory(&viewDesc, sizeof(D3D10_SHADER_RESOURCE_VIEW_DESC));

D3D10_TEXTURE2D_DESC textArrayDesc;

pTexArray->GetDesc(&textArrayDesc);

viewDesc.Format = textArrayDesc.Format;

viewDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2DARRAY;

viewDesc.Texture1DArray.MostDetailedMip = 0;

viewDesc.Texture1DArray.MipLevels = textArrayDesc.MipLevels;

viewDesc.Texture1DArray.FirstArraySlice = 0;

viewDesc.Texture1DArray.ArraySize = textArrayDesc.ArraySize;

D3D10_RENDERER->GetDevice()->CreateShaderResourceView(pTexArray, &viewDesc, &pArrayRV);

return pArrayRV;

}

Utilisation :

std::vector&lt;ID3D10Texture2D*&gt; textures;

textures.push_back( CreateTexture(&quot;UneImage.png&quot;) ) ;
textures.push_back( CreateTexture(&quot;UneAutreImage.png&quot;) ) ;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;
ID3D10Texture2D* pTextureArray = CreateTextureArray(textures);

// On lib&egrave;re la m&eacute;moire
for (uint32 i = 0; i &lt; textures.size(); i++)
{
&nbsp;&nbsp; &nbsp;ID3D10Texture2D* pCurrentTexture = textures[i];
&nbsp;&nbsp; &nbsp;SAFE_RELEASE(pCurrentTexture);
}

// Cette ressource est pr&ecirc;te &agrave; &ecirc;tre utilis&eacute;e par un programme HLSL
ID3D10ShaderResourceView* pRVArray = GetTextureRVArray(pTextureArray);

SAFE_RELEASE(pTextureArray);

std::vector<ID3D10Texture2D*> textures;

textures.push_back( CreateTexture("UneImage.png") ) ;

textures.push_back( CreateTexture("UneAutreImage.png") ) ;

ID3D10Texture2D* pTextureArray = CreateTextureArray(textures);

// On libère la mémoire

for (uint32 i = 0; i < textures.size(); i++)

{

    ID3D10Texture2D* pCurrentTexture = textures[i];

    SAFE_RELEASE(pCurrentTexture);

}

// Cette ressource est prête à être utilisée par un programme HLSL

ID3D10ShaderResourceView* pRVArray = GetTextureRVArray(pTextureArray);

SAFE_RELEASE(pTextureArray);

Résumé :

Nous avons présenté une façon d’accéder à une variable représentant un tableau de textures directement dans le shader !

Références :

– Franck D.Luna – DirectX 10

Générer une sphère MeshSceneNode

Intro :

Il peut être utile de savoir générer une sphère à la volée par la définition de ses vertices et de ses indices.

Prérequis :

– Savoir lire du C++

– Savoir initialiser DirectX 10

– Savoir utiliser et comprendre un peu de trigonométrie

– Savoir utiliser la classe Renderable

– Savoir utiliser la classe MeshSceneNode

– Savoir utiliser la classe ShaderTechnique

Explications :

Voici l’implémentation de la classe shader :

//------------------------------------------------------
// Simple shader avec texturage
//------------------------------------------------------
class ShaderTechnique_BasicTexture : public ShaderTechnique
{
public:
    ShaderTechnique_BasicTexture(const std::string& sTextureFileName);
    virtual ~ShaderTechnique_BasicTexture();

    virtual bool Initialize();

    virtual void SetupShaderVariables();

    virtual void Update(float fTimeSinceLastFrame);

private:
    std::string m_sTextureFileName;
};

//------------------------------------------------------

// Simple shader avec texturage

//------------------------------------------------------

class ShaderTechnique_BasicTexture : public ShaderTechnique

{

public:

ShaderTechnique_BasicTexture(const std::string& sTextureFileName);

virtual ~ShaderTechnique_BasicTexture();

virtual bool Initialize();

virtual void SetupShaderVariables();

virtual void Update(float fTimeSinceLastFrame);

private:

std::string m_sTextureFileName;

};

Voici le fichier ShaderTechnique_BasicTexture.cpp :

#include "ShaderTechnique_Declarations.h"

ShaderTechnique_BasicTexture::ShaderTechnique_BasicTexture(const std::string& sTextureFileName) :
ShaderTechnique("SimpleTextureEffect.fx", "Render", VertexLayoutType::PTN_VERTEX),
m_sTextureFileName(sTextureFileName)
{
}

ShaderTechnique_BasicTexture::~ShaderTechnique_BasicTexture()
{
}

bool ShaderTechnique_BasicTexture::Initialize()
{
    if (ShaderTechnique::Initialize() == false)
    {
        return false;
    }

    SetupShaderVariables();

    return true;
}

void ShaderTechnique_BasicTexture::SetupShaderVariables()
{
    RegisterMatrixVariable("World", ShaderVariableType::WORLD);
    RegisterMatrixVariable("View", ShaderVariableType::VIEW);
    RegisterMatrixVariable("Projection", ShaderVariableType::PROJECTION);

    RegisterTextureVariable("txDiffuse");

    AddTexture(m_sTextureFileName.c_str());

    SetTexture("txDiffuse", 0);
}

void ShaderTechnique_BasicTexture::Update(float fTimeSinceLastFrame)
{
    // On fait tourner la sphère / planète
    D3DXMATRIX mat;
    static float r = 0.0f;

    r += fTimeSinceLastFrame * 0.3f;

    D3DXMatrixRotationY(&mat, r);

    SetMatrix("World", &mat);

    SetAutoMatrix(ShaderVariableType::VIEW);
    SetAutoMatrix(ShaderVariableType::PROJECTION);
}

#include "ShaderTechnique_Declarations.h"

ShaderTechnique_BasicTexture::ShaderTechnique_BasicTexture(const std::string& sTextureFileName) :

ShaderTechnique("SimpleTextureEffect.fx", "Render", VertexLayoutType::PTN_VERTEX),

m_sTextureFileName(sTextureFileName)

{

}

ShaderTechnique_BasicTexture::~ShaderTechnique_BasicTexture()

{

}

bool ShaderTechnique_BasicTexture::Initialize()

{

if (ShaderTechnique::Initialize() == false)

{

return false;

}

SetupShaderVariables();

return true;

}

void ShaderTechnique_BasicTexture::SetupShaderVariables()

{

RegisterMatrixVariable("World", ShaderVariableType::WORLD);

RegisterMatrixVariable("View", ShaderVariableType::VIEW);

RegisterMatrixVariable("Projection", ShaderVariableType::PROJECTION);

RegisterTextureVariable("txDiffuse");

AddTexture(m_sTextureFileName.c_str());

SetTexture("txDiffuse", 0);

}

void ShaderTechnique_BasicTexture::Update(float fTimeSinceLastFrame)

{

// On fait tourner la sphère / planète

D3DXMATRIX mat;

static float r = 0.0f;

r += fTimeSinceLastFrame * 0.3f;

D3DXMatrixRotationY(&mat, r);

SetMatrix("World", &mat);

SetAutoMatrix(ShaderVariableType::VIEW);

SetAutoMatrix(ShaderVariableType::PROJECTION);

}

Voici le fichier SphereMeshSceneNode.h :

#ifndef SPHERE_MESH_SCENE_NODE_H
#define SPHERE_MESH_SCENE_NODE_H

#include "MeshSceneNode.h"
#include "Types.h"

class SphereMeshSceneNode : public MeshSceneNode
{
public:
    SphereMeshSceneNode();
    virtual ~SphereMeshSceneNode();

    void CreateSphere(uint16 iRings, uint16 iSectors, uint16 iRadius);

private:

};

#endif

#ifndef SPHERE_MESH_SCENE_NODE_H

#define SPHERE_MESH_SCENE_NODE_H

#include "MeshSceneNode.h"

#include "Types.h"

class SphereMeshSceneNode : public MeshSceneNode

{

public:

SphereMeshSceneNode();

virtual ~SphereMeshSceneNode();

void CreateSphere(uint16 iRings, uint16 iSectors, uint16 iRadius);

private:

};

#endif

Voici le fichier SphereMeshSceneNode.cpp :

#include <vector>

#include "SphereMeshSceneNode.h"
#include "Types.h"
#include "ShaderTechnique_Declarations.h"

SphereMeshSceneNode::SphereMeshSceneNode()
{
    // Chercher sur Google Image d'autres textures sphériques
    SetShaderTechnique( new ShaderTechnique_BasicTexture("earth.jpg") );
    CreateSphere(40, 40, 4);
}

SphereMeshSceneNode::~SphereMeshSceneNode()
{
}

// Voilà la méthode qui créer la sphère
void SphereMeshSceneNode::CreateSphere(uint16 iRings, uint16 iSectors, uint16 iRadius)
{
    std::vector<PTNVertex> vertices;
    std::vector<uint16> indices;
    
    float R = 1.f/(float)(iRings-1);
    float S = 1.f/(float)(iSectors-1);

    for (uint32 r = 0; r < iRings; r++)
    {
        for (uint32 s = 0; s < iSectors; s++)
        {
#define MATH_PI 3.141592653589793f
#define MATH_PI_2 MATH_PI / 2
            float const y = sin( -MATH_PI_2 + MATH_PI * r * R );
            float const x = cos(2*MATH_PI * s * S) * sin( MATH_PI * r * R );
            float const z = sin(2*MATH_PI * s * S) * sin( MATH_PI * r * R );

            PTNVertex v;

            v.position.x = x * iRadius;
            v.position.y = y * iRadius;
            v.position.z = z * iRadius;

            v.texture.x = 1 - s*S;
            v.texture.y = r*R;

            v.normal.x = -x;
            v.normal.y = -y;
            v.normal.z = -z;

            vertices.push_back(v);
        }
    }

    for (uint16 y = 0; y < iRings - 1; y++)
    {
        for (uint16 x = 0; x < iSectors - 1; x++)
        {
            indices.push_back( ((y + 0) * iSectors + x) );
            indices.push_back( ((y + 1) * iSectors + x) );
            indices.push_back( ((y + 1) * iSectors + x + 1) );
 
            indices.push_back( ((y + 1) * iSectors + x + 1) );
            indices.push_back( ((y + 0) * iSectors + x + 1) );
            indices.push_back( ((y + 0) * iSectors + x) );
        }
    }
    
    Build(vertices, indices);
}

#include <vector>

#include "SphereMeshSceneNode.h"

#include "Types.h"

#include "ShaderTechnique_Declarations.h"

SphereMeshSceneNode::SphereMeshSceneNode()

{

// Chercher sur Google Image d'autres textures sphériques

SetShaderTechnique( new ShaderTechnique_BasicTexture("earth.jpg") );

CreateSphere(40, 40, 4);

}

SphereMeshSceneNode::~SphereMeshSceneNode()

{

}

// Voilà la méthode qui créer la sphère

void SphereMeshSceneNode::CreateSphere(uint16 iRings, uint16 iSectors, uint16 iRadius)

{

std::vector<PTNVertex> vertices;

std::vector<uint16> indices;

float R = 1.f/(float)(iRings-1);

float S = 1.f/(float)(iSectors-1);

for (uint32 r = 0; r < iRings; r++)

{

for (uint32 s = 0; s < iSectors; s++)

{

#define MATH_PI 3.141592653589793f

#define MATH_PI_2 MATH_PI / 2

float const y = sin( -MATH_PI_2 + MATH_PI * r * R );

float const x = cos(2*MATH_PI * s * S) * sin( MATH_PI * r * R );

float const z = sin(2*MATH_PI * s * S) * sin( MATH_PI * r * R );

PTNVertex v;

v.position.x = x * iRadius;

v.position.y = y * iRadius;

v.position.z = z * iRadius;

v.texture.x = 1 - s*S;

v.texture.y = r*R;

v.normal.x = -x;

v.normal.y = -y;

v.normal.z = -z;

vertices.push_back(v);

}

for (uint16 y = 0; y < iRings - 1; y++)

{

for (uint16 x = 0; x < iSectors - 1; x++)

{

indices.push_back( ((y + 0) * iSectors + x) );

indices.push_back( ((y + 1) * iSectors + x) );

indices.push_back( ((y + 1) * iSectors + x + 1) );

indices.push_back( ((y + 0) * iSectors + x + 1) );

indices.push_back( ((y + 0) * iSectors + x) );

}

Build(vertices, indices);

}

Résumé :

Nous avons appris comment générer une sphère en 3D avec ses coordonnées de texture et normales.

Référénces :

– http://stackoverflow.com/questions/5988686/creating-a-3d-sphere-in-opengl-using-visual-c

Quelques notions de l’API système Windows 32

Intro :

Prérequis :

– Savoir lire du C++

Explications :

La structure RECT :

typedef struct _RECT {
  LONG left;
  LONG top;
  LONG right;
  LONG bottom;
} RECT, *PRECT;

typedef struct _RECT {

LONG left;

LONG top;

LONG right;

LONG bottom;

} RECT, *PRECT;

Cette structure permet de définir un rectangle.

Résumé :

Références :

– https://msdn.microsoft.com/fr-fr/library/windows/desktop/dd162897%28v=vs.85%29.aspx

Les processus légers (threads) avec std::thread (C++11)

Intro :

Les threads sont utilisés dans ce qu’on nomme « la programmation concurrente », qui consiste en l’exécution des processus légers. Cela représente une séquence d’exécution du code d’un programme au sein d’un processus. Quelque part, les threads sont des processus légers qui sont exécutés « à l’intérieur » d’un processus.

Les threads d’un même processus partagent la même mémoire et leurs variables. La pile de chaque thread est cependant unique pour chacun d’entre-eux.

Un processus habituel possède un seul thread et ce dernier correspond tout simplement au processus lui-même.

Soit c’est le noyau du système d’exploitation qui s’occupe des threads, soit ils sont gérés dans l’espace utilisateur à travers un gestionnaire spécial !

Prérequis :

– Savoir lire du C++

Explications :

Exemple d’utilisation d’un std::thread :

#include <iostream>
#include <thread>

void f()
{
    std::cout << "Un thread C++11" << std::endl;
}

int main()
{
    std::thread t(f);

    t.join();

    return 0;
}

#include <iostream>

#include <thread>

void f()

{

std::cout << "Un thread C++11" << std::endl;

}

int main()

{

std::thread t(f);

t.join();

return 0;

}

La méthode .join() permet d’assurer que le thread se termine avant de quitter le programme ou la portée du code. Cet appel est bloquant !

Un thread est dans l’état « joignable » s’il est est créé avec une tâche à réaliser.

Le type std::thread (C++11) a une méthode get_id() afin d’obtenir l’id du thread en question.

Il peut exister un problème de synchronisation entre deux threads ! On doit protéger l’accès à certaines ressources si deux threads distincts sont en train d’y accéder en écriture.

Un thread peut être aussi détaché :

#include <iostream>
#include <thread>

void f()
{
    std::cout<< "Un thread C++11" << std::endl;
}

int main()
{
    std::thread t(f);
    t.join();
    t.detach();

    return 0;
}

#include <iostream>

#include <thread>

void f()

{

std::cout<< "Un thread C++11" << std::endl;

}

int main()

{

std::thread t(f);

t.join();

t.detach();

return 0;

}

Qu’est-ce qu’un sémaphore ?

Il permet de synchroniser l’accès à une ressource partagée. Cette ressource peut aussi bien être un bout de code !

Les threads accèdent aux ressources par le biais de ce sémaphore.

Pendant que le thread exécute cette ressource partagée aucun autre thread ne peut y accéder. Dès qu’il a terminé son travail, il libère le sémaphore (qui est nommé aussi « moniteur »).

Qu’est-ce qu’un mutex ?

Le mot « mutex » provient de l’abréviation « Mutual Exclusion ». Il assure que les données partagées sont « mutuellement exclusives ». Il s’agit juste d’une variable qui peut être soit dans l’état « verrouillé » ou soit dans l’état « déverrouillé » !

Pour verrouiller un mutex on utilise la méthode lock().

Dès qu’un thread a fini de travailler avec une donnée / ressource partagée il doit libérer le mutex ! Il faut utiliser la méthode unlock().

On peut déclarer le mutex en même temps que la variable à protéger !

struct Data
{
    int var;
    std::mutex mutex;
};

struct Data

{

int var;

std::mutex mutex;

};

Qu’est-ce qu’une condition ?

Une condition est nécessaire d’être utilisée si l’on veut qu’un thread patiente à l’événement d’un autre thread.

Lorsqu’un thread est en attente d’une condition, il reste bloqué jusqu’à ce que la condition soit réaliser par un autre thread.

Résumé :

Nous avons présenter l’utilisation des thread (processus léger) afin de répartir l’exécution des bouts de code d’un jeu-vidéo.

En effet, les programmes utilisant des threads sur des architectures de type multi-processeurs sont plus rapides que les programmes plus classiques !

Références :

– http://www.iro.umontreal.ca/~dift1169/cours/ift1169/communs/Cours/2P/C12_1169_2P.pdf

– https://fr.wikipedia.org/wiki/Thread_(informatique)

Transformations géométriques des objets par les matrices

Intro :

Les transformations géométriques opérées sur des objets 3D sont de 3 types : translation, rotation et mise à l’échelle (agrandissement). Grâce à ces trois transformations, on peut mettre un mouvement un ensemble de points (ou un modèle).

Mais de quoi s’agit-il ?

Une translation est un changement de position d’un point ou de plusieurs points.

Une rotation permet de faire pivoter un point (ou plusieurs points) autour d’un axe par un certain angle.

Une mise à l’échelle permet d’agrandir ou de diminuer la taille d’un objet.

Prérequis :

– Savoir ce qu’est un vecteur

– Savoir ce qu’est une matrice

Explications :

Il existe deux manières de représenter un système de coordonnées : de type gauche ou de type droit.

DirectX utilise un système de coordonnées de type droit tandis que OpenGL utilise un système de coordonnées de type gauche.

On peut se servir des matrices pour représenter une transformation d’un objet dans l’espace de coordonnées 3D.

L’intérêt de la représentation matricielle est principalement qu’on peut combiner à la suite n’importe quelle transformation en une et seule matrice de transformation finale.

Une transformation est une opération qui prend en entrée un vecteur et qui en sortie le converti autrement.

Transformation linéaire :

On précise que mathématiquement une transformation (en l’occurrence linéaire) représente :

Soit la fonction $\tau(v) = \tau{(x , y , z)} = (x^{\prime}, y^{\prime}, z^{\prime}) $

respectant les propriétés suivantes :

$\tau(u+v) = \tau(u) +\tau(v) $ et $\tau(ku) = k\tau (u) $

avec ${u} $ et ${v} $ deux vecteurs à 3 composantes.

Ces transformations sont nommées « linéaires » car elles préservent l’addition de vecteurs et la multiplication par un scalaire.

Toutes les transformations linéaires peuvent être représentées par une matrice 3×3 (ou plus).

Pensez que les opérations de rotation ou d’agrandissement sont toutes des transformations linéaires respectant ce dernier principe.

Quant à la transformation de translation, elle n’est pas une transformation linéaire mais une transformation affine.
Une transformation affine est une transformation linéaire qui est suivie d’une translation, elle préserve la colinéarité des vecteurs (caractéristique des vecteurs qui ont la même direction). Ces dernières sont peuvent être représentées par une matrice 4×4.

On remarque que les matrices de rotation et d’agrandissement sont aussi, par quant à elles, des transformations affines !

Pour s’en servir, on multiplie un vecteur qui a besoin d’être transformé par une matrice 4×4 de translation. Ce dernier vecteur doit être en notation « homogeneous » (voir l’article sur les transformations de coordonnées) pour être multiplié par une matrice 4×4.

L’avantage de ces matrices affines, est qu’elles peuvent être combinées les une à la suite des autres en une seule matrice finale qui peut représenter la somme de ces transformations.

La translation :

[schéma / dessin]

Voici la matrice de transformation affine représentant une translation :

$\textbf{T}(\textbf{t}) = \textbf{T}(t_{x}, t_{y},t_{z}) = \begin{pmatrix} 1 & 0 & 0 & t_{x} \\ 0 & 1 & 0 & t_{y} \\ 0 & 0 & 1 & t_{z} \\ 0 & 0 & 0 & 1 \end{pmatrix} $

Le vecteur $\textbf{t} $ représente la valeur de déplacement de la matrice.

Pour changer la position d’un vecteur $p $ par cette matrice on fait :

$Translation = \textbf{T}(\textbf{t})p $

L’inverse de cette matrice (opération inverse) :

$\textbf{T}^{-1}(\textbf{t}) = \textbf{T}^{-1}(t_{x}, t_{y},t_{z}) = \textbf{T}(-t_{x}, -t_{y},-t_{z}) = \begin{pmatrix} 1 & 0 & 0 & -t_{x} \\ 0 & 1 & 0 & -t_{y} \\ 0 & 0 & 1 & -t_{z} \\ 0 & 0 & 0 & 1 \end{pmatrix} $

L’agrandissement :

Une matrice d’agrandissement permet de faire grossir ou de diminuer un modèle.

Voici la matrice de transformation affine représentant une mise à l’échelle :

$\textbf{S}(\textbf{s}) = \textbf{S}(s_{x}, s_{y}, s_{z}) = \begin{pmatrix} s_{x} & 0 & 0 & 0 \\ 0 & s_{y} & 0 & 0 \\ 0 & 0 & s_{z} & 0 \\ 0 & 0 & 0 & 1 \end{pmatrix} $

Le vecteur $\textbf{s} $ représente la grandeur d’agrandissement.

Pour agrandir ou minimiser un vecteur $p $ par cette matrice on fait :

$Agrandissement = \textbf{S}(\textbf{s})p $

L’inverse de cette matrice (opération inverse) :

$\textbf{S}^{-1}(\textbf{s}) = \textbf{S}(1/s_{x}, 1/s_{y}, 1/s_{z}) = \begin{pmatrix} 1/s_{x} & 0 & 0 & 0 \\ 0 & 1/s_{y} & 0 & 0 \\ 0 & 0 & 1/s_{z} & 0 \\ 0 & 0 & 0 & 1 \end{pmatrix} $

Si $s_{x} = s_{y} = s_{z} $ alors la matrice d’agrandissement est dite « uniforme ».

La rotation :

Cette transformation opère une rotation sur un vecteur avec un angle donné $\theta $ et autour d’un axe donné $i $

La matrice de transformation affine sur l’axe des x :

$\textbf{R}_{x}(\theta) = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & \cos \theta & -\sin \theta & 0 \\ 0 & \sin \theta & \cos \theta & 0 \\ 0 & 0 & 0 & 1 \end{pmatrix} $

La matrice de transformation affine sur l’axe des y est :

$\textbf{R}_{y}(\theta) = \begin{pmatrix} \cos \theta & 0 & \sin \theta & 0 \\ 0 & 1 & 0 & 0 \\ -\sin \theta & 0 & \cos \theta & 0 \\ 0 & 0 & 0 & 1 \end{pmatrix} $

La matrice de transformation affine sur l’axe des z est :

$\textbf{R}_{z}(\theta) = \begin{pmatrix} \cos \theta & -\sin \theta & 0 & 0 \\ \sin \theta & \cos \theta & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{pmatrix} $

Pour faire pivoter un vecteur $p$ par cette matrice on fait :

$Rotation = R_{x/y/z}(\theta)p $

L’inverse de cette matrice (opération inverse) :

$\textbf{R}^{-1}(\theta) = \textbf{R}(-\theta) $

Faire une rotation autour d’un point quelconque :

[image / schéma avec un bonhomme]

On remarque qu’une rotation autour d’un axe $i $ d’un point $p $ ne change en rien la position du point $p $ sur l’axe $i $.

En utilisant ce principe, on déplace le point $p $ de façon à ce qu’il coïncide autour de l’origine : la matrice de translation $\textbf{T}(-p) $ le permet.
On opère ensuite la rotation sur l’axe $i $ par la matrice de rotation $\textbf{R}{_i}(\theta) $.
Finalement le point $p $ doit être remis à sa position initiale par la matrice de translation $\textbf{T}(p) $.

La transformation finale correspond à cette égalité : $\textbf{X} = \textbf{T}(p)\textbf{R}{_i}(\theta)\textbf{T}(-p) $

Résumé :

Nous avons présenté les matrices de transformations affines qui permettent de mouvoir les modèles (ensemble de points / vecteurs d’un objet / modèle) à travers la translation, la rotation, et la mise à l’échelle.

Références :

– https://takinginitiative.files.wordpress.com/2010/08/2.pdf

– Shader Approach DirectX 9

– Real Time Rendering – Third edition

Récupérer le nombre de cœurs et d’autres informations de votre processeur

Intro :

Il peut être utile de connaître le nombre de cœur de votre processeur afin d’optimiser vos applications utilisant des processus légers.

On peut obtenir aussi les information des caches associés au CPU.

Prérequis :

– Savoir lire du C++

Explications :

Voici le fichier d’en-tête CPUInfo.h :

#ifndef CPU_INFO_H
#define CPU_INFO_H

#include <Windows.h>
#include <iostream>

#include "Defines.h"
#include "Types.h"

typedef bool (WINAPI *LPFN_GLPI)(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD);

class CPUInfo    
{
public:
    CPUInfo();
    virtual ~CPUInfo();
    
    bool Initialize();

    uint16 GetLogicalProcessorCount();
    uint16 GetPhysicalProcessorCount();

    uint16 GetSystemProcessorCount();

    uint16 GetL1CacheCount();
    uint16 GetL2CacheCount();
    uint16 GetL3CacheCount();

private:
    void ParseSystemProcessorCount();
    bool ParseProcessorData();
    uint32 CountBits(uint64 bitMask);

private:
    uint16 m_iPhysicalProcessorCount;
    uint16 m_iLogicalProcessorCount;
    uint16 m_iProcessorCoreCount;

    uint16 m_iProcessorL1CacheCount;
    uint16 m_iProcessorL2CacheCount;
    uint16 m_iProcessorL3CacheCount;

    size_t m_iProcessorL1CacheSize;
    size_t m_iProcessorL2CacheSize;
    size_t m_iProcessorL3CacheSize;
};

#endif

#ifndef CPU_INFO_H

#define CPU_INFO_H

#include <Windows.h>

#include <iostream>

#include "Defines.h"

#include "Types.h"

typedef bool (WINAPI *LPFN_GLPI)(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION, PDWORD);

class CPUInfo

{

public:

CPUInfo();

virtual ~CPUInfo();

bool Initialize();

uint16 GetLogicalProcessorCount();

uint16 GetPhysicalProcessorCount();

uint16 GetSystemProcessorCount();

uint16 GetL1CacheCount();

uint16 GetL2CacheCount();

uint16 GetL3CacheCount();

private:

void ParseSystemProcessorCount();

bool ParseProcessorData();

uint32 CountBits(uint64 bitMask);

private:

uint16 m_iPhysicalProcessorCount;

uint16 m_iLogicalProcessorCount;

uint16 m_iProcessorCoreCount;

uint16 m_iProcessorL1CacheCount;

uint16 m_iProcessorL2CacheCount;

uint16 m_iProcessorL3CacheCount;

size_t m_iProcessorL1CacheSize;

size_t m_iProcessorL2CacheSize;

size_t m_iProcessorL3CacheSize;

};

#endif

Voici le fichier source CPUInfo.cpp :

#include "CPUInfo.h"

CPUInfo::CPUInfo() :
m_iProcessorCoreCount(0),
m_iPhysicalProcessorCount(0),
m_iLogicalProcessorCount(0),
m_iProcessorL1CacheCount(0),
m_iProcessorL2CacheCount(0),
m_iProcessorL3CacheCount(0),
m_iProcessorL1CacheSize(0),
m_iProcessorL2CacheSize(0),
m_iProcessorL3CacheSize(0)
{
}

CPUInfo::~CPUInfo()
{
}

bool CPUInfo::Initialize()
{
    if (!ParseProcessorData())
    {
        return false;
    }

    ParseSystemProcessorCount();

    return true;
}

bool CPUInfo::ParseProcessorData()
{
    m_iLogicalProcessorCount = 0;
    m_iPhysicalProcessorCount = 0;

    LPFN_GLPI Glpi;

    Glpi = (LPFN_GLPI) GetProcAddress(GetModuleHandle(TEXT("kernel32")),
        "GetLogicalProcessorInformation");
    
    if (Glpi == nullptr)
    {
        /* La fonction qui permet d'obtenir les informations
           du CPU n'est pas supportée */
        return false;
    }

    bool bDone = false;

    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pBuffer = nullptr;
    DWORD iReturnLength = 0;

    while (!bDone)
    {
        bool bSucess = Glpi(pBuffer, &iReturnLength);

        if (!bSucess)
        {
            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
            {
                if (pBuffer)
                {
                    free(pBuffer);
                }

                pBuffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION) malloc(iReturnLength);

                if (pBuffer == nullptr)
                {
                    // Echec de l'allocation
                    return false;
                }
            }
            else
            {
                // Erreur inconnu
                return false;
            }
        }
        else
        {
            bDone = true;
        }
    }

    DWORD iByteOffset = 0;
    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = pBuffer;
    PCACHE_DESCRIPTOR pCache = nullptr;

    while (iByteOffset + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) <= iReturnLength)
    {
        switch (ptr->Relationship)
        {
            case RelationProcessorCore:
                {
                    // Nombre de processeurs physiques
                    m_iPhysicalProcessorCount++;

                    // Nombre de processeurs logiques (ceux utilisable par le système)
                    m_iLogicalProcessorCount += CountBits(ptr->ProcessorMask);

                    break;
                }
            case RelationCache:
                {
                    pCache = &ptr->Cache;

                    if (pCache->Level == 1)
                    {
                        m_iProcessorL1CacheCount++;

                        m_iProcessorL1CacheSize = pCache->Size;
                    }
                    else if (pCache->Level == 2)
                    {
                        m_iProcessorL2CacheCount++;

                        m_iProcessorL2CacheSize = pCache->Size;
                    }
                    else if (pCache->Level == 3)
                    {
                        m_iProcessorL3CacheCount++;

                        m_iProcessorL3CacheSize = pCache->Size;
                    }

                    break;
                }
        }

        iByteOffset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
        ptr++;
    }

    free (pBuffer);

    return true;
}

uint32 CPUInfo::CountBits(uint64 bitMask)
{
    DWORD c = 0;

    while (bitMask != 0)
    {
        c += (bitMask & 1L);
        bitMask >>= 1;
    }

    return c;
}

void CPUInfo::ParseSystemProcessorCount()
{
    SYSTEM_INFO si;
    GetSystemInfo(&si);

    m_iProcessorCoreCount = (uint16) si.dwNumberOfProcessors;
}

uint16 CPUInfo::GetSystemProcessorCount()
{
    return m_iProcessorCoreCount;
}

uint16 CPUInfo::GetPhysicalProcessorCount()
{
    return m_iPhysicalProcessorCount;
}

uint16 CPUInfo::GetLogicalProcessorCount()
{
    return m_iLogicalProcessorCount;
}

uint16 CPUInfo::GetL1CacheCount()
{
    return m_iProcessorL1CacheCount;
}

uint16 CPUInfo::GetL2CacheCount()
{
    return m_iProcessorL2CacheCount;
}

uint16 CPUInfo::GetL3CacheCount()
{
    return m_iProcessorL3CacheCount;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

#include "CPUInfo.h"

CPUInfo::CPUInfo() :

m_iProcessorCoreCount(0),

m_iPhysicalProcessorCount(0),

m_iLogicalProcessorCount(0),

m_iProcessorL1CacheCount(0),

m_iProcessorL2CacheCount(0),

m_iProcessorL3CacheCount(0),

m_iProcessorL1CacheSize(0),

m_iProcessorL2CacheSize(0),

m_iProcessorL3CacheSize(0)

{

}

CPUInfo::~CPUInfo()

{

}

bool CPUInfo::Initialize()

{

if (!ParseProcessorData())

{

return false;

}

ParseSystemProcessorCount();

return true;

}

bool CPUInfo::ParseProcessorData()

{

m_iLogicalProcessorCount = 0;

m_iPhysicalProcessorCount = 0;

LPFN_GLPI Glpi;

Glpi = (LPFN_GLPI) GetProcAddress(GetModuleHandle(TEXT("kernel32")),

"GetLogicalProcessorInformation");

if (Glpi == nullptr)

{

/* La fonction qui permet d'obtenir les informations

du CPU n'est pas supportée */

return false;

}

bool bDone = false;

PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pBuffer = nullptr;

DWORD iReturnLength = 0;

while (!bDone)

{

bool bSucess = Glpi(pBuffer, &iReturnLength);

if (!bSucess)

{

if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)

{

if (pBuffer)

{

free(pBuffer);

}

pBuffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION) malloc(iReturnLength);

if (pBuffer == nullptr)

{

// Echec de l'allocation

return false;

}

else

{

// Erreur inconnu

return false;

}

else

{

bDone = true;

}

DWORD iByteOffset = 0;

PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = pBuffer;

PCACHE_DESCRIPTOR pCache = nullptr;

while (iByteOffset + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) <= iReturnLength)

{

switch (ptr->Relationship)

{

case RelationProcessorCore:

{

// Nombre de processeurs physiques

m_iPhysicalProcessorCount++;

// Nombre de processeurs logiques (ceux utilisable par le système)

m_iLogicalProcessorCount += CountBits(ptr->ProcessorMask);

break;

}

case RelationCache:

{

pCache = &ptr->Cache;

if (pCache->Level == 1)

{

m_iProcessorL1CacheCount++;

m_iProcessorL1CacheSize = pCache->Size;

}

else if (pCache->Level == 2)

{

m_iProcessorL2CacheCount++;

m_iProcessorL2CacheSize = pCache->Size;

}

else if (pCache->Level == 3)

{

m_iProcessorL3CacheCount++;

m_iProcessorL3CacheSize = pCache->Size;

}

break;

}

iByteOffset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);

ptr++;

}

free (pBuffer);

return true;

}

uint32 CPUInfo::CountBits(uint64 bitMask)

{

DWORD c = 0;

while (bitMask != 0)

{

c += (bitMask & 1L);

bitMask >>= 1;

}

return c;

}

void CPUInfo::ParseSystemProcessorCount()

{

SYSTEM_INFO si;

GetSystemInfo(&si);

m_iProcessorCoreCount = (uint16) si.dwNumberOfProcessors;

}

uint16 CPUInfo::GetSystemProcessorCount()

{

return m_iProcessorCoreCount;

}

uint16 CPUInfo::GetPhysicalProcessorCount()

{

return m_iPhysicalProcessorCount;

}

uint16 CPUInfo::GetLogicalProcessorCount()

{

return m_iLogicalProcessorCount;

}

uint16 CPUInfo::GetL1CacheCount()

{

return m_iProcessorL1CacheCount;

}

uint16 CPUInfo::GetL2CacheCount()

{

return m_iProcessorL2CacheCount;

}

uint16 CPUInfo::GetL3CacheCount()

{

return m_iProcessorL3CacheCount;

}

Résumé :

Nous avons présenter une méthode pour obtenir le nombre de cœur(s) de votre CPU.

Références :

– http://blogs.media-tips.com/bernard.opic/2007/09/03/compter-le-nombre-de-1-dans-la-forme-binaire-d-un-nombre/

– https://msdn.microsoft.com/fr-fr/library/windows/desktop/ms683194%28v=vs.85%29.aspx

Obtenir les informations de votre CG avec les interfaces DXGI*

Intro :

Il peut être utile d’obtenir le nom de la carte vidéo, sa mémoire vive maximum et tous ses modes d’affichage possibles pour un jeu vidéo.

Prérequis :

– Savoir initialiser DirectX 10

Explications :

Avant tout, voici deux petites macros affichant les erreurs tout en retournant false s’il y a en une !

#define ShowMessageBoxDXError(hr) char buf[2048]; \
       sprintf(buf, "Error : %s\nDescription : %s\n\nFile : %s\n\nLine : %d\n\nFunction : %s", DXGetErrorStringA(hr), DXGetErrorDescriptionA(hr), __FILE__, __LINE__, __FUNCTION__); \
       MessageBoxA(nullptr, buf, "Erreur", MB_ICONHAND | MB_OK);

#if defined(DEBUG) | defined(_DEBUG)
    #ifndef HR_FAILED_RETURN_FALSE
    #define HR_FAILED_RETURN_FALSE(x)                  \
    {                                                  \
        if (FAILED(x))                                \
        {                                              \
            ShowMessageBoxDXError(x)                  \
            return false;                              \
        }                                              \
    }
    #endif
 
#else
    #ifndef HR_FAILED_RETURN_FALSE
    #define HR_FAILED_RETURN_FALSE(x) x;
    #endif
#endif

#define ShowMessageBoxDXError(hr) char buf[2048]; \

sprintf(buf, "Error : %s\nDescription : %s\n\nFile : %s\n\nLine : %d\n\nFunction : %s", DXGetErrorStringA(hr), DXGetErrorDescriptionA(hr), __FILE__, __LINE__, __FUNCTION__); \

MessageBoxA(nullptr, buf, "Erreur", MB_ICONHAND | MB_OK);

#if defined(DEBUG) | defined(_DEBUG)

#ifndef HR_FAILED_RETURN_FALSE

#define HR_FAILED_RETURN_FALSE(x) \

{ \

if (FAILED(x)) \

{ \

ShowMessageBoxDXError(x) \

return false; \

} \

}

#endif

#else

#ifndef HR_FAILED_RETURN_FALSE

#define HR_FAILED_RETURN_FALSE(x) x;

#endif

Voici la fonction qui affiche les informations sur la carte graphique :

bool GetGPUInfo()
{
    HRESULT hr = S_OK;

    uint32 iNumModes;

    IDXGIFactory* pDXGIFactory = nullptr;
    IDXGIAdapter* pDXGIAdapter = nullptr;
    IDXGIOutput* pDXGIAdapterOutput = nullptr;

    DXGI_MODE_DESC* pDisplayModeList = nullptr;

    DXGI_ADAPTER_DESC adapterDesc;

    // Créée une interface métier "factory" DirectX
    hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&pDXGIFactory);

    HR_FAILED_RETURN_FALSE(hr);

    // Utilise la "factory"
    hr = pDXGIFactory->EnumAdapters(0, &pDXGIAdapter);

    HR_FAILED_RETURN_FALSE(hr);

    // Enumère l'adpatateur principal de l'écran
    hr = pDXGIAdapter->EnumOutputs(0, &pDXGIAdapterOutput);

    HR_FAILED_RETURN_FALSE(hr);

    // Obtient le nombre de modes d'affichage qui corresppond à DXGI_FORMAT_R8G8B8A8_UNORM  
    hr = pDXGIAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &iNumModes, nullptr);

    HR_FAILED_RETURN_FALSE(hr);

    /* Créé une liste qui détient tous les modes d'affichage possibles pour cette carte graphique et
       le format d'affichage */
    pDisplayModeList = new DXGI_MODE_DESC[iNumModes];

    if (!pDisplayModeList)
    {
        return false;
    }

    // Remplie la précédente structure
    hr = pDXGIAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &iNumModes, pDisplayModeList);
    
    HR_FAILED_RETURN_FALSE(hr);

    /* On parcourt tous les modes d'affichages possibles
       et on trouve celui qui correspond à la taille spécifiée
       en paramètre ; puis on enregistre le numérateur et le dénominateur
       du taux de rafraichissement de l'écran
    */
    std::cout << "Modes d'affichage pour le format : DXGI_FORMAT_R8G8B8A8_UNORM" << std::endl << std::endl;

    for (uint32 i = 0; i < iNumModes; i++)
    {
        DXGI_MODE_DESC desc = pDisplayModeList[i];
        
        std::string sRefreshRate = std::to_string(desc.RefreshRate.Numerator / desc.RefreshRate.Denominator) + "Hz";

        std::cout << desc.Width << "x" << desc.Height << " " << sRefreshRate << std::endl;
    }

    std::cout << std::endl;

    hr = pDXGIAdapter->GetDesc(&adapterDesc);

    HR_FAILED_RETURN_FALSE(hr);

    // On enregistre la taille de la mémoire vidéo en mégabytes
    m_iVideoCardMemory = (adapterDesc.DedicatedVideoMemory / 1024 / 1024);

    size_t iStringLength = 0;
    // Convertie le nom la carte vidéo dans une chaîne de caractères
    int iError = wcstombs_s(&iStringLength, m_sVideoCardDescription, 128, adapterDesc.Description, 128);

    if (iError != 0)
    {
        return false;
    }

    std::cout << std::endl;

    std::cout << m_sVideoCardDescription << std::endl;

    std::cout << "Video memory = " << std::to_string(m_iVideoCardMemory) << " MB" << std::endl;

    std::cout << std::endl;

    SAFE_DELETE_ARRAY(pDisplayModeList);

    SAFE_RELEASE(pDXGIAdapterOutput);
    SAFE_RELEASE(pDXGIAdapter);
    SAFE_RELEASE(pDXGIFactory);

    return true;
}

bool GetGPUInfo()

{

HRESULT hr = S_OK;

uint32 iNumModes;

IDXGIFactory* pDXGIFactory = nullptr;

IDXGIAdapter* pDXGIAdapter = nullptr;

IDXGIOutput* pDXGIAdapterOutput = nullptr;

DXGI_MODE_DESC* pDisplayModeList = nullptr;

DXGI_ADAPTER_DESC adapterDesc;

// Créée une interface métier "factory" DirectX

hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&pDXGIFactory);

HR_FAILED_RETURN_FALSE(hr);

// Utilise la "factory"

hr = pDXGIFactory->EnumAdapters(0, &pDXGIAdapter);

HR_FAILED_RETURN_FALSE(hr);

// Enumère l'adpatateur principal de l'écran

hr = pDXGIAdapter->EnumOutputs(0, &pDXGIAdapterOutput);

HR_FAILED_RETURN_FALSE(hr);

// Obtient le nombre de modes d'affichage qui corresppond à DXGI_FORMAT_R8G8B8A8_UNORM

hr = pDXGIAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &iNumModes, nullptr);

HR_FAILED_RETURN_FALSE(hr);

/* Créé une liste qui détient tous les modes d'affichage possibles pour cette carte graphique et

le format d'affichage */

pDisplayModeList = new DXGI_MODE_DESC[iNumModes];

if (!pDisplayModeList)

{

return false;

}

// Remplie la précédente structure

hr = pDXGIAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &iNumModes, pDisplayModeList);

HR_FAILED_RETURN_FALSE(hr);

/* On parcourt tous les modes d'affichages possibles

et on trouve celui qui correspond à la taille spécifiée

en paramètre ; puis on enregistre le numérateur et le dénominateur

du taux de rafraichissement de l'écran

std::cout << "Modes d'affichage pour le format : DXGI_FORMAT_R8G8B8A8_UNORM" << std::endl << std::endl;

for (uint32 i = 0; i < iNumModes; i++)

{

DXGI_MODE_DESC desc = pDisplayModeList[i];

std::string sRefreshRate = std::to_string(desc.RefreshRate.Numerator / desc.RefreshRate.Denominator) + "Hz";

std::cout << desc.Width << "x" << desc.Height << " " << sRefreshRate << std::endl;

}

std::cout << std::endl;

hr = pDXGIAdapter->GetDesc(&adapterDesc);

HR_FAILED_RETURN_FALSE(hr);

// On enregistre la taille de la mémoire vidéo en mégabytes

m_iVideoCardMemory = (adapterDesc.DedicatedVideoMemory / 1024 / 1024);

size_t iStringLength = 0;

// Convertie le nom la carte vidéo dans une chaîne de caractères

int iError = wcstombs_s(&iStringLength, m_sVideoCardDescription, 128, adapterDesc.Description, 128);

if (iError != 0)

{

return false;

}

std::cout << std::endl;

std::cout << m_sVideoCardDescription << std::endl;

std::cout << "Video memory = " << std::to_string(m_iVideoCardMemory) << " MB" << std::endl;

std::cout << std::endl;

SAFE_DELETE_ARRAY(pDisplayModeList);

SAFE_RELEASE(pDXGIAdapterOutput);

SAFE_RELEASE(pDXGIAdapter);

SAFE_RELEASE(pDXGIFactory);

return true;

}

Voici la fonction qui affiche les capacités de la carte graphique en matière d’anti-aliasing (déjà présentée dans les articles précédents) :

void PrintFSAAMaximumLevel()
{
    HRESULT hr = S_OK;
    UINT maxQualityLevel = 1;
    
    for (uint32 iSampleCount = 1; iSampleCount <= D3D10_MAX_MULTISAMPLE_SAMPLE_COUNT; iSampleCount++)
    {
        hr = m_pd3dDevice->CheckMultisampleQualityLevels(
            DXGI_FORMAT_R8G8B8A8_UNORM, iSampleCount, &maxQualityLevel);

        if (hr != S_OK)
        {
            std::cout << "CheckMultisampleQualityLevels a échoue." << std::endl;
        }
                                 
        if (maxQualityLevel > 0)
        {
            std::cout << "MSAA " << iSampleCount << "X supportee par la carte video avec " <<
                maxQualityLevel << " niveau(x) de qualite." << std::endl;
        }
    }
}

void PrintFSAAMaximumLevel()

{

HRESULT hr = S_OK;

UINT maxQualityLevel = 1;

for (uint32 iSampleCount = 1; iSampleCount <= D3D10_MAX_MULTISAMPLE_SAMPLE_COUNT; iSampleCount++)

{

hr = m_pd3dDevice->CheckMultisampleQualityLevels(

DXGI_FORMAT_R8G8B8A8_UNORM, iSampleCount, &maxQualityLevel);

if (hr != S_OK)

{

std::cout << "CheckMultisampleQualityLevels a échoue." << std::endl;

}

if (maxQualityLevel > 0)

{

std::cout << "MSAA " << iSampleCount << "X supportee par la carte video avec " <<

maxQualityLevel << " niveau(x) de qualite." << std::endl;

}

Voici la sortie de la console une fois affichés les modes d’affichage :

Résumé :

Nous avons appris comment obtenir les informations à partir de la carte graphique.

Introduction à DirectX 10 – Écrire du texte à l’écran (système de polices) – partie 7

Utilisation de BMFont :

Intro :

Pour afficher du texte dans une application DirectX il faut procéder comme suit.

Prérequis :

– Savoir initialiser DirectX 10

– Savoir comment afficher une image 2D à l’écran

Septième partie :

Afficher du texte à l’écran.

Explications :

Il vous faudra plusieurs images bitmap pour supporter les différentes résolutions de l’écran de l’utilisateur.

« Their source rect will form our texture coordinates, and their destination rect will form our vertexcoordinates. »

Voici le fichier FontTextManager.h :

#ifndef FONT_TEXT_MANAGER_H
#define FONT_TEXT_MANAGER_H

#include <d3dx10math.h>
#include <vector>
#include <map>
#include <string>
#include <fstream>

#include "Singleton.h"
#include "Defines.h"
#include "Types.h"

namespace FontSystem
{
    struct FontTextFileCharacter
    {
        FontTextFileCharacter() :
        iXPos(0),
        iYPos(0),
        iWidth(0),
        iHeight(0),
        iXOffset(0),
        iYOffset(0),
        iXAdvance(0),
        iPage(0)
        {
        }

        uint16 iXPos, iYPos;
        uint16 iWidth, iHeight;
        float iXOffset, iYOffset;
        float iXAdvance;
        uint16 iPage;
    };

    struct PTPVertex
    {
        D3DXVECTOR3 position;
        D3DXVECTOR2 texture;
        int page;
    };

    struct Font
    {
        std::string sFontTextName;
        uint16 iLineHeight;
        uint16 iBase;
        uint16 iWidth; // Taille en largeur de l'image de la police
        uint16 iHeight; // Taille en hauteur de l'image de la police
        uint16 iPagesCount;
        int16 iSize;

        // Un tableau de caractères constituants la police de font
        FontTextFileCharacter* aCharacters;
        // Un tableau contenant les fichiers shader ressources  (les pages !) en l'occurence les textures de la police de font
        ID3D10ShaderResourceView* texturesArray;
    };

    class Text
    {
    public:
        Text(const std::wstring m_sText, const D3DXCOLOR& color, float fPosX, float fPosY);
        virtual ~Text();
    
        void SetFont(Font* pFont);
        Font* GetFont();

        float GetPosX();
        float GetPosY();

        std::wstring GetText();
    
        void SetVertexBuffer(ID3D10Buffer* pBuffer);
        void SetIndexBuffer(ID3D10Buffer* pBuffer);

        ID3D10Buffer* GetVertexBuffer();
        ID3D10Buffer* GetIndexBuffer();

        D3DXCOLOR GetColor();

        size_t GetVertexCount();
        size_t GetIndexCount();

        void SetVertexCount(size_t iCount);
        void SetIndexCount(size_t iCount);

        void SetTransparency(float fAlpha);

    private:
        std::wstring m_sText;

        float m_fPosX;
        float m_fPosY;

        D3DXCOLOR m_color;

        Font* m_pFont;

        // Un vertex / index buffer par page
        ID3D10Buffer* m_pVertexBuffer;
        ID3D10Buffer* m_pIndexBuffer;

        size_t m_iVertexCount;
        size_t m_iIndexCount;
    };
}

using namespace FontSystem;

class FontTextManager : public Singleton<FontTextManager>
{
public : // todo : mettre des commentaires partout ; utiliser AlphaTransparencyPass
    FontTextManager();
    virtual ~FontTextManager();
    
    bool Initialize();

    void Render(Text* pText);

    bool LoadFontTextFile(const std::string& sFileName, const std::string& sFontTextName);
    bool IsFontTextLoaded(const std::string& sFontTextName);

    Text* CreateText(const std::wstring& sText, const std::string& sFontTextName, const float fPosX, const float fPosY,
        const D3DXCOLOR& color);

    float GetGlyphAspectRatio(const wchar_t* c, const std::string& sFontTextName);
    RECT GetGlyphTexCoords(const wchar_t* c, const std::string& sFontTextName);
    uint16 GetCharacterPage(const wchar_t* c, const std::string& sFontTextName);

private:
    void CreateVertexInputLayout();
    void SetupMatrix();
    bool BuildTextBuffers(Text* text);
    bool InitializeShader();

    ID3D10Texture2D* CreateTexture(const std::string& sBitmapFileName);
    ID3D10Texture2D* CreateTextureArray(std::vector<ID3D10Texture2D*>& textures);
    ID3D10ShaderResourceView* GetTextureRVArray(ID3D10Texture2D* pTexArray);

private:
    D3D10_INPUT_ELEMENT_DESC* m_pLayoutPT; // todo : enlever
    ID3D10InputLayout* m_pVertexLayout;

    std::map<std::string, Font*> m_fonts;

    ID3D10Effect* m_pEffect;
    ID3D10EffectTechnique* m_pTechnique;

    ID3D10EffectShaderResourceVariable* m_pBitmapVariable;

    ID3D10EffectMatrixVariable* m_pWorldVariable;
    ID3D10EffectMatrixVariable* m_pViewVariable;
    ID3D10EffectMatrixVariable* m_pProjVariable;
    ID3D10EffectVectorVariable* m_pColorVariable;

    D3DXMATRIX m_worldMatrix;
    D3DXMATRIX m_viewMatrix;
    D3DXMATRIX m_projMatrix;
};

#endif

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

#ifndef FONT_TEXT_MANAGER_H

#define FONT_TEXT_MANAGER_H

#include <d3dx10math.h>

#include <vector>

#include <map>

#include <string>

#include <fstream>

#include "Singleton.h"

#include "Defines.h"

#include "Types.h"

namespace FontSystem

{

struct FontTextFileCharacter

{

FontTextFileCharacter() :

iXPos(0),

iYPos(0),

iWidth(0),

iHeight(0),

iXOffset(0),

iYOffset(0),

iXAdvance(0),

iPage(0)

{

}

uint16 iXPos, iYPos;

uint16 iWidth, iHeight;

float iXOffset, iYOffset;

float iXAdvance;

uint16 iPage;

};

struct PTPVertex

{

D3DXVECTOR3 position;

D3DXVECTOR2 texture;

int page;

};

struct Font

{

std::string sFontTextName;

uint16 iLineHeight;

uint16 iBase;

uint16 iWidth; // Taille en largeur de l'image de la police

uint16 iHeight; // Taille en hauteur de l'image de la police

uint16 iPagesCount;

int16 iSize;

// Un tableau de caractères constituants la police de font

FontTextFileCharacter* aCharacters;

// Un tableau contenant les fichiers shader ressources (les pages !) en l'occurence les textures de la police de font

ID3D10ShaderResourceView* texturesArray;

};

class Text

{

public:

Text(const std::wstring m_sText, const D3DXCOLOR& color, float fPosX, float fPosY);

virtual ~Text();

void SetFont(Font* pFont);

Font* GetFont();

float GetPosX();

float GetPosY();

std::wstring GetText();

void SetVertexBuffer(ID3D10Buffer* pBuffer);

void SetIndexBuffer(ID3D10Buffer* pBuffer);

ID3D10Buffer* GetVertexBuffer();

ID3D10Buffer* GetIndexBuffer();

D3DXCOLOR GetColor();

size_t GetVertexCount();

size_t GetIndexCount();

void SetVertexCount(size_t iCount);

void SetIndexCount(size_t iCount);

void SetTransparency(float fAlpha);

private:

std::wstring m_sText;

float m_fPosX;

float m_fPosY;

D3DXCOLOR m_color;

Font* m_pFont;

// Un vertex / index buffer par page

ID3D10Buffer* m_pVertexBuffer;

ID3D10Buffer* m_pIndexBuffer;

size_t m_iVertexCount;

size_t m_iIndexCount;

};

}

using namespace FontSystem;

class FontTextManager : public Singleton<FontTextManager>

{

public : // todo : mettre des commentaires partout ; utiliser AlphaTransparencyPass

FontTextManager();

virtual ~FontTextManager();

bool Initialize();

void Render(Text* pText);

bool LoadFontTextFile(const std::string& sFileName, const std::string& sFontTextName);

bool IsFontTextLoaded(const std::string& sFontTextName);

Text* CreateText(const std::wstring& sText, const std::string& sFontTextName, const float fPosX, const float fPosY,

const D3DXCOLOR& color);

float GetGlyphAspectRatio(const wchar_t* c, const std::string& sFontTextName);

RECT GetGlyphTexCoords(const wchar_t* c, const std::string& sFontTextName);

uint16 GetCharacterPage(const wchar_t* c, const std::string& sFontTextName);

private:

void CreateVertexInputLayout();

void SetupMatrix();

bool BuildTextBuffers(Text* text);

bool InitializeShader();

ID3D10Texture2D* CreateTexture(const std::string& sBitmapFileName);

ID3D10Texture2D* CreateTextureArray(std::vector<ID3D10Texture2D*>& textures);

ID3D10ShaderResourceView* GetTextureRVArray(ID3D10Texture2D* pTexArray);

private:

D3D10_INPUT_ELEMENT_DESC* m_pLayoutPT; // todo : enlever

ID3D10InputLayout* m_pVertexLayout;

std::map<std::string, Font*> m_fonts;

ID3D10Effect* m_pEffect;

ID3D10EffectTechnique* m_pTechnique;

ID3D10EffectShaderResourceVariable* m_pBitmapVariable;

ID3D10EffectMatrixVariable* m_pWorldVariable;

ID3D10EffectMatrixVariable* m_pViewVariable;

ID3D10EffectMatrixVariable* m_pProjVariable;

ID3D10EffectVectorVariable* m_pColorVariable;

D3DXMATRIX m_worldMatrix;

D3DXMATRIX m_viewMatrix;

D3DXMATRIX m_projMatrix;

};

#endif

Voici le fichier FontTextManager.cpp :

#include "FontTextManager.h"
#include "D3D10Renderer.h"
#include "AlphaPass.h"

Text::Text(const std::wstring sText, const D3DXCOLOR& color, float fPosX, float fPosY) :
m_sText(sText),
m_color(color),
m_fPosX(fPosX),
m_fPosY(fPosY),
m_pFont(nullptr),
m_pIndexBuffer(nullptr),
m_pVertexBuffer(nullptr),
m_iIndexCount(0),
m_iVertexCount(0)
{
}

Text::~Text()
{
    SAFE_RELEASE(m_pVertexBuffer);
    SAFE_RELEASE(m_pIndexBuffer);
}

void Text::SetFont(Font* pFont)
{
    m_pFont = pFont;
}

Font* Text::GetFont()
{
    return m_pFont;
}

std::wstring Text::GetText()
{
    return m_sText;
}

void Text::SetVertexBuffer(ID3D10Buffer* pBuffer)
{
    m_pVertexBuffer = pBuffer;
}

void Text::SetIndexBuffer(ID3D10Buffer* pBuffer)
{
    m_pIndexBuffer = pBuffer;
}

ID3D10Buffer* Text::GetVertexBuffer()
{
    return m_pVertexBuffer;
}

ID3D10Buffer* Text::GetIndexBuffer()
{
    return m_pIndexBuffer;
}

size_t Text::GetVertexCount()
{
    return m_iVertexCount;
}

size_t Text::GetIndexCount()
{
    return m_iIndexCount;
}

void Text::SetVertexCount(size_t iCount)
{
    m_iVertexCount = iCount;
}

void Text::SetIndexCount(size_t iCount)
{
    m_iIndexCount = iCount;
}

D3DXCOLOR Text::GetColor()
{
    return m_color;
}

float Text::GetPosX()
{
    return m_fPosX;
}

float Text::GetPosY()
{
    return m_fPosY;
}

void Text::SetTransparency(float fAlpha)
{
    m_color.a = fAlpha;
}

// ---------------------------------------------//

template<> FontTextManager* Singleton<FontTextManager>::ms_instance = nullptr;

FontTextManager::FontTextManager() :
m_pLayoutPT(nullptr),
m_pBitmapVariable(nullptr),
m_pEffect(nullptr),
m_pTechnique(nullptr),
m_pVertexLayout(nullptr),
m_pWorldVariable(nullptr),
m_pViewVariable(nullptr),
m_pProjVariable(nullptr),
m_pColorVariable(nullptr)
{
}

FontTextManager::~FontTextManager()
{
    SAFE_DELETE(m_pLayoutPT);

    SAFE_RELEASE(m_pVertexLayout);
    SAFE_RELEASE(m_pEffect);
}

bool FontTextManager::Initialize()
{
    CreateVertexInputLayout();

    if (!InitializeShader())
    {
        return false;
    }

    SetupMatrix();

    return true;
}

bool FontTextManager::InitializeShader()
{
    HRESULT hr = S_OK;

    ID3D10Blob* pBlob = nullptr;
 
    hr = D3DX10CreateEffectFromFile(FONT_TEXT_FX_FILE_NAME, nullptr, nullptr, "fx_4_0",
        D3D10_SHADER_ENABLE_STRICTNESS | D3D10_SHADER_DEBUG, 0,
        D3D10_RENDERER->GetDevice(), nullptr, nullptr, &m_pEffect, &pBlob, nullptr);

    if (FAILED(hr))
    {
        if (pBlob)
        {
            // Affiche l'erreur de compilation du shader
            MessageBoxA(nullptr, (PCSTR)pBlob->GetBufferPointer(), "Erreur dans le fichier shader", MB_ICONHAND | MB_OK);
        }
        else
        {
            ShowMessageBoxDXError(hr);
        }
 
        return false;
    }
  

    m_pTechnique = m_pEffect->GetTechniqueByName("FontTechnique");

    m_pWorldVariable = m_pEffect->GetVariableByName("World")->AsMatrix();
    m_pViewVariable = m_pEffect->GetVariableByName("View")->AsMatrix();
    m_pProjVariable = m_pEffect->GetVariableByName("Projection")->AsMatrix();
    m_pBitmapVariable = m_pEffect->GetVariableByName("gTextures")->AsShaderResource();
    m_pColorVariable = m_pEffect->GetVariableByName("BlendColor")->AsVector();

    D3D10_PASS_DESC PassDesc;
    m_pTechnique->GetPassByIndex(0)->GetDesc(&PassDesc);
    hr = D3D10_RENDERER->GetDevice()->CreateInputLayout(m_pLayoutPT, 3, PassDesc.pIAInputSignature,
                                         PassDesc.IAInputSignatureSize, &m_pVertexLayout);

    VR_RETURN(hr);

    return true;
}

void FontTextManager::SetupMatrix()
{
    D3DXMatrixIdentity(&m_worldMatrix);
 
    D3DXVECTOR3 Eye(0.0f, 0.0f, -1.0f);
    D3DXVECTOR3 At(0.0f, 0.0f, 0.0f);
    D3DXVECTOR3 Up(0.0f, 1.0f, 0.0f);
 
    D3DXMatrixLookAtLH(&m_viewMatrix, &Eye, &At, &Up);

    D3DXMatrixOrthoLH(&m_projMatrix, (float) D3D10_RENDERER->GetViewportWidth(), (float) D3D10_RENDERER->GetViewportHeight(),
        1.0f, 20.0f);
}

void FontTextManager::CreateVertexInputLayout()
{    
    m_pLayoutPT = new D3D10_INPUT_ELEMENT_DESC[3];

    D3D10_INPUT_ELEMENT_DESC layoutPT[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "PAGE", 0, DXGI_FORMAT_R16_UINT, 0, 20, D3D10_INPUT_PER_VERTEX_DATA, 0 },
    };

    memcpy(m_pLayoutPT, layoutPT, sizeof(D3D10_INPUT_ELEMENT_DESC) * 3);
}

bool FontTextManager::IsFontTextLoaded(const std::string& sFontTextName)
{
    return m_fonts.count(sFontTextName) != 0;
}
/*
    http://www.angelcode.com/products/bmfont/doc/render_text.html
*/
bool FontTextManager::BuildTextBuffers(Text* pText)
{
    std::string sFontTextName = pText->GetFont()->sFontTextName;

    std::wstring sText = pText->GetText();
    float fPosX = pText->GetPosX();
    float fPosY = -pText->GetPosY();

    // Décalage en fonction de la taille de l'écran
    fPosX -= (float)((D3D10_RENDERER->GetViewportWidth() / 2 ));
    fPosY += (float)((D3D10_RENDERER->GetViewportHeight() / 2 ));

    // On vérifie si l'on a bien la police chargée en mémoire
    if (m_fonts.count(sFontTextName) == 0)
    {
        return false;
    }

    // On obtient la police spécifiée
    Font* pFont = m_fonts[sFontTextName];

    // Tableau de tous les caractères de la police de font
    FontTextFileCharacter* aCharacters = pFont->aCharacters;

    D3D10_BUFFER_DESC vertexBufferDesc, indexBufferDesc;
    D3D10_SUBRESOURCE_DATA vertexData, indexData;

    HRESULT hr;

    std::vector<PTPVertex> vertices;

    for (uint32 i = 0; i < sText.length(); i++)
    {
        // Chaque lettre
        uint32 iLetter = (uint32)sText[i];

        FontTextFileCharacter character = pFont->aCharacters[iLetter];

        if (iLetter == SPACE_ASCII_CODE) // Espace !
        {
            fPosX += character.iXAdvance;

            continue;
        }

        if (iLetter == '\n')
        {
            fPosX = 0;
        }

        float x = 0;
        float y = 0;

        float tu = 0;
        float tv = 0;

        uint32 iCharX = character.iXPos; // Abscisse du caractère dans la texture
        uint32 iCharY = character.iYPos; // Ordonnée du caractère dans la texture
        uint32 iWidth = character.iWidth; // Largeur du caractère dans la texture
        uint32 iHeight = character.iHeight; // Hauteur du caractère dans la texture
        float iOffsetX = character.iXOffset;
        float iOffsetY = character.iYOffset;
        float iXAdvance = character.iXAdvance;
        uint16 iPage = character.iPage;

         //----------------- 1er triangle de la face du caractère -----------------//

        // ---- Bottom left ---- //
        iOffsetY = - iOffsetY - iHeight;
        //iOffsetY = (- iOffsetY - pFont->iLineHeight
        //iOffsetY -= pFont->iLineHeight;
        //iOffsetY -= pFont->iLineHeight;

        x = fPosX + iOffsetX;
        y = fPosY + iOffsetY;

        tu = (float) (iCharX) / pFont->iWidth;
        tv = (float) (iCharY + iHeight) / pFont->iHeight;

        PTPVertex vertex;

        vertex.position = D3DXVECTOR3(x, y, 0.0f);
        vertex.texture = D3DXVECTOR2(tu, tv);
        vertex.page = iPage;

        vertices.push_back(vertex);

        // ---- Top left ---- //

        x = fPosX + iOffsetX;
        y = fPosY + iOffsetY + iHeight;

        tu = (float) iCharX / pFont->iWidth;
        tv = (float) iCharY / pFont->iHeight;

        vertex.position = D3DXVECTOR3(x, y, 0.0f);  
        vertex.texture = D3DXVECTOR2(tu, tv);
        vertex.page = iPage;

        vertices.push_back(vertex);

        // ---- Top right ---- //

        x = fPosX + iOffsetX + iWidth;
        y = fPosY + iOffsetY + iHeight;

        tu = (float) (iCharX + iWidth) / pFont->iWidth;
        tv = (float) iCharY / pFont->iHeight;

        vertex.position = D3DXVECTOR3(x, y, 0.0f);  
        vertex.texture = D3DXVECTOR2(tu, tv);
        vertex.page = iPage;

        vertices.push_back(vertex);

        //----------------- 2ème triangle de la face du caractère -----------------//

        // ---- Top right ---- //

        x = fPosX + iOffsetX + iWidth;
        y = fPosY + iOffsetY + iHeight;

        tu = (float) (iCharX + iWidth) / pFont->iWidth;
        tv = (float) iCharY / pFont->iHeight;

        vertex.position = D3DXVECTOR3(x, y, 0.0f);  
        vertex.texture = D3DXVECTOR2(tu, tv);
        vertex.page = iPage;

        vertices.push_back(vertex);

        // ---- Bottom right ---- //

        x = fPosX + iOffsetX + iWidth;
        y = fPosY + iOffsetY;

        tu = (float) (iCharX + iWidth) / pFont->iWidth;
        tv = (float) (iCharY + iHeight) / pFont->iHeight;

        vertex.position = D3DXVECTOR3(x, y, 0.0f);  
        vertex.texture = D3DXVECTOR2(tu, tv);
        vertex.page = iPage;

        vertices.push_back(vertex);

        // ---- Bottom left ---- //

        x = fPosX + iOffsetX;
        y = fPosY + iOffsetY;

        tu = (float) (iCharX) / pFont->iWidth;
        tv = (float) (iCharY + iHeight) / pFont->iHeight;

        vertex.position = D3DXVECTOR3(x, y, 0.0f);  
        vertex.texture = D3DXVECTOR2(tu, tv);
        vertex.page = iPage;

        vertices.push_back(vertex);

        // On décale de quelques pixels vers la gauche après chaque lettre
        fPosX += iXAdvance;
    }

    pText->SetVertexCount(vertices.size());
    pText->SetIndexCount( pText->GetVertexCount() );

    std::vector<uint16> indices;
    for (uint16 i = 0; i < pText->GetIndexCount(); i++)
    {
        indices.push_back(i);
    }

    vertexBufferDesc.Usage = D3D10_USAGE_DYNAMIC;
    vertexBufferDesc.ByteWidth = sizeof(PTPVertex) * pText->GetVertexCount();
    vertexBufferDesc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
    vertexBufferDesc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
    vertexBufferDesc.MiscFlags = 0;

    vertexData.pSysMem = vertices.data();

    ID3D10Buffer* pVB = nullptr;

    hr = D3D10_RENDERER->GetDevice()->CreateBuffer(&vertexBufferDesc, &vertexData, &pVB);
    VR_RETURN(hr);

    pText->SetVertexBuffer(pVB);
        
    indexBufferDesc.Usage = D3D10_USAGE_DEFAULT;
    indexBufferDesc.ByteWidth = sizeof(uint16) * pText->GetIndexCount();
    indexBufferDesc.BindFlags = D3D10_BIND_INDEX_BUFFER;
    indexBufferDesc.CPUAccessFlags = 0;
    indexBufferDesc.MiscFlags = 0;

    indexData.pSysMem = indices.data();

    ID3D10Buffer* pIB = nullptr;
    hr = D3D10_RENDERER->GetDevice()->CreateBuffer(&indexBufferDesc, &indexData, &pIB);
    VR_RETURN(hr);

    pText->SetIndexBuffer(pIB);

    return true;
}

void FontTextManager::Render(Text* pText)
{
    if (!pText)
    {
        return;
    } 

    uint32 iStride = sizeof(PTPVertex);
    uint32 iOffset = 0;

    D3D10_RENDERER->EnableZBuffer(false);

    m_pWorldVariable->SetMatrix((float*)&m_worldMatrix);
    m_pViewVariable->SetMatrix((float*)&m_viewMatrix);
    m_pProjVariable->SetMatrix((float*)&m_projMatrix);
    m_pColorVariable->SetFloatVector((float*)pText->GetColor());

    ID3D10Buffer* pVertexBuffer = pText->GetVertexBuffer();
    ID3D10Buffer* pIndexBuffer = pText->GetIndexBuffer();

    size_t iVertexCount = pText->GetVertexCount();
    size_t iIndexCount = pText->GetIndexCount();

    D3D10_RENDERER->GetDevice()->IASetVertexBuffers(0, 1, &pVertexBuffer, &iStride, &iOffset);
    D3D10_RENDERER->GetDevice()->IASetIndexBuffer(pIndexBuffer, DXGI_FORMAT_R16_UINT, 0);
    D3D10_RENDERER->GetDevice()->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

    ID3D10ShaderResourceView* pRV = pText->GetFont()->texturesArray;

    if (pRV)
    {
        m_pBitmapVariable->SetResource(pRV);
    }

    D3D10_TECHNIQUE_DESC techniqueDesc;
    D3D10_RENDERER->GetDevice()->IASetInputLayout(m_pVertexLayout);

    m_pTechnique->GetDesc(&techniqueDesc);

    AlphaPass TransparencyPass;

    for (uint32 i = 0; i < techniqueDesc.Passes; i++)
    {
        m_pTechnique->GetPassByIndex(i)->Apply(0);

        D3D10_RENDERER->GetDevice()->Draw(iVertexCount, 0);
    }

    D3D10_RENDERER->EnableZBuffer(true);
}

Text* FontTextManager::CreateText(const std::wstring& sText, const std::string& sFontTextName,
                                  const float fPosX, const float fPosY, const D3DXCOLOR& color)
{
    Text* pText = new Text(sText, color, fPosX, fPosY);

    if (!IsFontTextLoaded(sFontTextName)) // todo : add dummy text
    {
        PRINT_ERROR("Police de caractere non reconnu");

        return nullptr;
    }

    pText->SetFont(m_fonts[sFontTextName]);

    if (!BuildTextBuffers(pText))
    {
        PRINT_ERROR("Echec lors du la construction des buffers d'un texte speficie");

        return nullptr;
    }

    return pText;
}

/* Voir la documentation sur
    http://www.angelcode.com/products/bmfont/doc/file_format.html
*/
bool FontTextManager::LoadFontTextFile(const std::string& sFileName, const std::string& sFontTextName)
{
    std::vector<ID3D10Texture2D*> textures;

    std::string sLine;
    std::string sRead, sKey, sValue;

    std::ifstream file(sFileName);

    if (!file.is_open())
    {
        PRINT_ERROR("Impossible de charger un fichier font");

        return false;
    }

    std::string sBitmapFileName = "";

    FontTextFileCharacter* aCharacters = new FontTextFileCharacter[256];

    Font* pFont = new Font;
    pFont->sFontTextName = sFontTextName;
    pFont->aCharacters = aCharacters;

    while (!file.eof())
    {
        std::stringstream sLineStream;
        std::getline( file, sLine );
        sLineStream << sLine;

        // Lit le type de la ligne
        sLineStream >> sRead;

        if (sRead == "info")
        {
            while (!sLineStream.eof())
            {
                std::stringstream Converter;
                sLineStream >> sRead;

                uint32 i = sRead.find('=');
                sKey = sRead.substr(0, i);
                sValue = sRead.substr(i + 1);

                Converter << sValue;

                if (sKey == "size")
                {
                    Converter >> pFont->iSize;
                }
            }
        }
        else if (sRead == "common")
        {
            while (!sLineStream.eof())
            {
                std::stringstream Converter;
                sLineStream >> sRead;

                uint32 i = sRead.find('=');
                sKey = sRead.substr(0, i);
                sValue = sRead.substr(i + 1);

                Converter << sValue;

                if (sKey == "lineHeight")
                {
                    Converter >> pFont->iLineHeight;
                }
                else if (sKey == "base")
                {
                    Converter >> pFont->iBase;
                }
                else if (sKey == "scaleW")
                {
                    Converter >> pFont->iWidth;
                }
                else if (sKey == "scaleH")
                {
                    Converter >> pFont->iHeight;
                }
                else if (sKey == "pages")
                {
                    Converter >> pFont->iPagesCount;
                }
            }
        }
        else if (sRead == "page")
        {
            while (!sLineStream.eof())
            {
                std::stringstream Converter;
                sLineStream >> sRead;

                uint32 i = sRead.find('=');
                sKey = sRead.substr(0, i);
                sValue = sRead.substr(i + 1);

                Converter << sValue;
    
                if (sKey == "file")
                {
                    Converter >> sBitmapFileName;

                    // On supprime les guillemets entre le nom du fichier
                    sBitmapFileName.pop_back();    
                    sBitmapFileName.erase(0, 1);

                    fastprint("Chargement de " << sBitmapFileName << " pour " << pFont->sFontTextName);
                
                    ID3D10Texture2D* pTexture = CreateTexture(sBitmapFileName);

                    if (pTexture)
                    {
                        textures.push_back(pTexture);
                    }
                }

            }
        }
        else if (sRead == "char")
        {
            uint16 iCharID = 0;

            while (!sLineStream.eof())
            {
                std::stringstream Converter;
                sLineStream >> sRead;

                uint32 i = sRead.find('=');
                sKey = sRead.substr(0, i);
                sValue = sRead.substr(i + 1);
                Converter << sValue;

                if (sKey == "id")
                {
                    Converter >> iCharID;
                }
                else if (sKey == "x")
                {
                    Converter >> pFont->aCharacters[iCharID].iXPos;
                }
                else if (sKey == "y" )
                {
                    Converter >> pFont->aCharacters[iCharID].iYPos;
                }
                else if (sKey == "width")
                {
                    Converter >> pFont->aCharacters[iCharID].iWidth;
                }
                else if (sKey == "height")
                {
                    Converter >> pFont->aCharacters[iCharID].iHeight;
                }
                else if (sKey == "xoffset")
                {
                    Converter >> pFont->aCharacters[iCharID].iXOffset;
                }
                else if (sKey == "yoffset")
                {
                    Converter >> pFont->aCharacters[iCharID].iYOffset;
                }
                else if (sKey == "xadvance")
                {
                    Converter >> pFont->aCharacters[iCharID].iXAdvance;
                }
                else if (sKey == "page")
                {
                    Converter >> pFont->aCharacters[iCharID].iPage;
                }
            }
        }
    }
    
    m_fonts[sFontTextName] = pFont;

    debugprint(pFont->sFontTextName.c_str());
    debugprint(pFont->iBase);
    debugprint(pFont->iHeight);
    debugprint(pFont->iLineHeight);
    debugprint(pFont->iPagesCount);
    debugprint(pFont->iWidth);

    if (textures.size() == 0)
    {
        PRINT_ERROR("Aucune textures chargees");
    }

    fastprint("\n---------------------------\n");

    ID3D10Texture2D* pTextureArray = CreateTextureArray(textures);

    for (uint32 i = 0; i < textures.size(); i++)
    {
        ID3D10Texture2D* pCurrentTexture = textures[i];

        SAFE_RELEASE(pCurrentTexture);
    }

    ID3D10ShaderResourceView* pRVArray = GetTextureRVArray(pTextureArray);

    SAFE_RELEASE(pTextureArray);

    pFont->texturesArray = pRVArray;

    return true;
}

float FontTextManager::GetGlyphAspectRatio(const wchar_t* c, const std::string& sFontTextName)
{
    // On obtient la police spécifiée
    Font* pFont = m_fonts[sFontTextName];

    if (pFont)
    {
        return 0;
    }

    // Tableau de tous les caractères de la police de font
    FontTextFileCharacter* aCharacters = pFont->aCharacters;

    FontTextFileCharacter character = aCharacters[(uint32)c];

    uint32 iWidth = character.iWidth;
    uint32 iHeight = character.iHeight;

    return (float) (iWidth / iHeight);
}

RECT FontTextManager::GetGlyphTexCoords(const wchar_t* c, const std::string& sFontTextName)
{
    RECT rect;
    ZeroMemory(&rect, sizeof(RECT));

    // On obtient la police spécifiée
    Font* pFont = m_fonts[sFontTextName];

    if (!pFont)
    {
        return rect;
    }

    // Tableau de tous les caractères de la police de font
    FontTextFileCharacter* aCharacters = pFont->aCharacters;

    FontTextFileCharacter character = aCharacters[(uint32)c];

    uint32 iCharX = character.iXPos;
    uint32 iCharY = character.iYPos;
    uint32 iWidth = character.iWidth;
    uint32 iHeight = character.iHeight;

    rect.left = iCharX;
    rect.top = iCharY;
    rect.right = iWidth;
    rect.bottom = iHeight;

    return rect;
}

uint16 FontTextManager::GetCharacterPage(const wchar_t* c, const std::string& sFontTextName)
{
    // On obtient la police spécifiée
    Font* pFont = m_fonts[sFontTextName];

    if (!pFont)
    {
        return 0;
    }

    // Tableau de tous les caractères de la police de font
    FontTextFileCharacter* aCharacters = pFont->aCharacters;

    FontTextFileCharacter character = aCharacters[(uint32)c];

    return character.iPage;
}

ID3D10Texture2D* FontTextManager::CreateTexture(const std::string& sBitmapFileName)
{
    ID3D10Texture2D* pLoadedTexture = nullptr;

    D3DX10_IMAGE_LOAD_INFO loadinfo;
    ZeroMemory(&loadinfo, sizeof(D3DX10_IMAGE_LOAD_INFO));

    loadinfo.Width = D3DX10_FROM_FILE;
    loadinfo.Height = D3DX10_FROM_FILE;
    loadinfo.Depth = D3DX10_FROM_FILE;

    loadinfo.FirstMipLevel = 0;
    loadinfo.MipLevels = D3DX10_FROM_FILE;
    loadinfo.Usage = D3D10_USAGE_STAGING;

    loadinfo.BindFlags = 0;
    loadinfo.CpuAccessFlags = D3D10_CPU_ACCESS_READ | D3D10_CPU_ACCESS_WRITE;
    loadinfo.MiscFlags = 0;

    loadinfo.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    loadinfo.Filter = D3DX10_FILTER_NONE;
    loadinfo.MipFilter = D3DX10_FILTER_NONE;
    loadinfo.pSrcInfo = 0;

    D3DX10CreateTextureFromFileA(D3D10_RENDERER->GetDevice(),
        sBitmapFileName.c_str(), &loadinfo, 0, (ID3D10Resource**)&pLoadedTexture, 0);

    return pLoadedTexture;
}

ID3D10Texture2D* FontTextManager::CreateTextureArray(std::vector<ID3D10Texture2D*>& textures)
{
    if (textures.size() == 0)
    {
        return nullptr;
    }

    ID3D10Texture2D* pTexturesArray = nullptr;

    D3D10_TEXTURE2D_DESC textElementDesc;
    ZeroMemory(&textElementDesc, sizeof(D3D10_TEXTURE2D_DESC));

    textures[0]->GetDesc(&textElementDesc);

    D3D10_TEXTURE2D_DESC textArrayDesc;

    textArrayDesc.Width = textElementDesc.Width;
    textArrayDesc.Height = textElementDesc.Height;
    textArrayDesc.MipLevels = textElementDesc.MipLevels;
    textArrayDesc.ArraySize = textures.size();
    textArrayDesc.Format = textElementDesc.Format;
    textArrayDesc.SampleDesc.Count = 1;
    textArrayDesc.SampleDesc.Quality = 0;
    textArrayDesc.Usage = D3D10_USAGE_DEFAULT;
    textArrayDesc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
    textArrayDesc.CPUAccessFlags = 0;
    textArrayDesc.MiscFlags = 0;

    D3D10_RENDERER->GetDevice()->CreateTexture2D(&textArrayDesc, 0, &pTexturesArray);

    // On copie toutes les textures dans le tableau !
    for (uint16 i = 0; i < textures.size(); i++)
    {
        for (uint16 j = 0; j < textElementDesc.MipLevels; j++)
        {
            D3D10_MAPPED_TEXTURE2D mappedTex2D;

            ID3D10Texture2D* pCurrentTexture = textures[i];

            pCurrentTexture->Map(j, D3D10_MAP_READ, 0, &mappedTex2D);

            uint32 c = D3D10CalcSubresource(j, i, textElementDesc.MipLevels);

            D3D10_RENDERER->GetDevice()->UpdateSubresource(pTexturesArray, c,
                0, mappedTex2D.pData, mappedTex2D.RowPitch, 0);

            pCurrentTexture->Unmap(j);
        }
    }

    return pTexturesArray;
}

ID3D10ShaderResourceView* FontTextManager::GetTextureRVArray(ID3D10Texture2D* pTexArray)
{
    if (pTexArray == nullptr)
    {
        return nullptr;
    }

    ID3D10ShaderResourceView* pArrayRV = nullptr;

    D3D10_SHADER_RESOURCE_VIEW_DESC viewDesc;
    ZeroMemory(&viewDesc, sizeof(D3D10_SHADER_RESOURCE_VIEW_DESC));

    D3D10_TEXTURE2D_DESC textArrayDesc;
    pTexArray->GetDesc(&textArrayDesc);

    viewDesc.Format = textArrayDesc.Format;
    viewDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2DARRAY;
    viewDesc.Texture1DArray.MostDetailedMip = 0;
    viewDesc.Texture1DArray.MipLevels = textArrayDesc.MipLevels;
    viewDesc.Texture1DArray.FirstArraySlice = 0;
    viewDesc.Texture1DArray.ArraySize = textArrayDesc.ArraySize;

    D3D10_RENDERER->GetDevice()->CreateShaderResourceView(pTexArray, &viewDesc, &pArrayRV);

    return pArrayRV;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

#include "FontTextManager.h"

#include "D3D10Renderer.h"

#include "AlphaPass.h"

Text::Text(const std::wstring sText, const D3DXCOLOR& color, float fPosX, float fPosY) :

m_sText(sText),

m_color(color),

m_fPosX(fPosX),

m_fPosY(fPosY),

m_pFont(nullptr),

m_pIndexBuffer(nullptr),

m_pVertexBuffer(nullptr),

m_iIndexCount(0),

m_iVertexCount(0)

{

}

Text::~Text()

{

SAFE_RELEASE(m_pVertexBuffer);

SAFE_RELEASE(m_pIndexBuffer);

}

void Text::SetFont(Font* pFont)

{

m_pFont = pFont;

}

Font* Text::GetFont()

{

return m_pFont;

}

std::wstring Text::GetText()

{

return m_sText;

}

void Text::SetVertexBuffer(ID3D10Buffer* pBuffer)

{

m_pVertexBuffer = pBuffer;

}

void Text::SetIndexBuffer(ID3D10Buffer* pBuffer)

{

m_pIndexBuffer = pBuffer;

}

ID3D10Buffer* Text::GetVertexBuffer()

{

return m_pVertexBuffer;

}

ID3D10Buffer* Text::GetIndexBuffer()

{

return m_pIndexBuffer;

}

size_t Text::GetVertexCount()

{

return m_iVertexCount;

}

size_t Text::GetIndexCount()

{

return m_iIndexCount;

}

void Text::SetVertexCount(size_t iCount)

{

m_iVertexCount = iCount;

}

void Text::SetIndexCount(size_t iCount)

{

m_iIndexCount = iCount;

}

D3DXCOLOR Text::GetColor()

{

return m_color;

}

float Text::GetPosX()

{

return m_fPosX;

}

float Text::GetPosY()

{

return m_fPosY;

}

void Text::SetTransparency(float fAlpha)

{

m_color.a = fAlpha;

}

// ---------------------------------------------//

template<> FontTextManager* Singleton<FontTextManager>::ms_instance = nullptr;

FontTextManager::FontTextManager() :

m_pLayoutPT(nullptr),

m_pBitmapVariable(nullptr),

m_pEffect(nullptr),

m_pTechnique(nullptr),

m_pVertexLayout(nullptr),

m_pWorldVariable(nullptr),

m_pViewVariable(nullptr),

m_pProjVariable(nullptr),

m_pColorVariable(nullptr)

{

}

FontTextManager::~FontTextManager()

{

SAFE_DELETE(m_pLayoutPT);

SAFE_RELEASE(m_pVertexLayout);

SAFE_RELEASE(m_pEffect);

}

bool FontTextManager::Initialize()

{

CreateVertexInputLayout();

if (!InitializeShader())

{

return false;

}

SetupMatrix();

return true;

}

bool FontTextManager::InitializeShader()

{

HRESULT hr = S_OK;

ID3D10Blob* pBlob = nullptr;

hr = D3DX10CreateEffectFromFile(FONT_TEXT_FX_FILE_NAME, nullptr, nullptr, "fx_4_0",

D3D10_SHADER_ENABLE_STRICTNESS | D3D10_SHADER_DEBUG, 0,

D3D10_RENDERER->GetDevice(), nullptr, nullptr, &m_pEffect, &pBlob, nullptr);

if (FAILED(hr))

{

if (pBlob)

{

// Affiche l'erreur de compilation du shader

MessageBoxA(nullptr, (PCSTR)pBlob->GetBufferPointer(), "Erreur dans le fichier shader", MB_ICONHAND | MB_OK);

}

else

{

ShowMessageBoxDXError(hr);

}

return false;

}

m_pTechnique = m_pEffect->GetTechniqueByName("FontTechnique");

m_pWorldVariable = m_pEffect->GetVariableByName("World")->AsMatrix();

m_pViewVariable = m_pEffect->GetVariableByName("View")->AsMatrix();

m_pProjVariable = m_pEffect->GetVariableByName("Projection")->AsMatrix();

m_pBitmapVariable = m_pEffect->GetVariableByName("gTextures")->AsShaderResource();

m_pColorVariable = m_pEffect->GetVariableByName("BlendColor")->AsVector();

D3D10_PASS_DESC PassDesc;

m_pTechnique->GetPassByIndex(0)->GetDesc(&PassDesc);

hr = D3D10_RENDERER->GetDevice()->CreateInputLayout(m_pLayoutPT, 3, PassDesc.pIAInputSignature,

PassDesc.IAInputSignatureSize, &m_pVertexLayout);

VR_RETURN(hr);

return true;

}

void FontTextManager::SetupMatrix()

{

D3DXMatrixIdentity(&m_worldMatrix);

D3DXVECTOR3 Eye(0.0f, 0.0f, -1.0f);

D3DXVECTOR3 At(0.0f, 0.0f, 0.0f);

D3DXVECTOR3 Up(0.0f, 1.0f, 0.0f);

D3DXMatrixLookAtLH(&m_viewMatrix, &Eye, &At, &Up);

D3DXMatrixOrthoLH(&m_projMatrix, (float) D3D10_RENDERER->GetViewportWidth(), (float) D3D10_RENDERER->GetViewportHeight(),

1.0f, 20.0f);

}

void FontTextManager::CreateVertexInputLayout()

{

m_pLayoutPT = new D3D10_INPUT_ELEMENT_DESC[3];

D3D10_INPUT_ELEMENT_DESC layoutPT[] =

{

{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },

{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },

{ "PAGE", 0, DXGI_FORMAT_R16_UINT, 0, 20, D3D10_INPUT_PER_VERTEX_DATA, 0 },

};

memcpy(m_pLayoutPT, layoutPT, sizeof(D3D10_INPUT_ELEMENT_DESC) * 3);

}

bool FontTextManager::IsFontTextLoaded(const std::string& sFontTextName)

{

return m_fonts.count(sFontTextName) != 0;

}

http://www.angelcode.com/products/bmfont/doc/render_text.html

bool FontTextManager::BuildTextBuffers(Text* pText)

{

std::string sFontTextName = pText->GetFont()->sFontTextName;

std::wstring sText = pText->GetText();

float fPosX = pText->GetPosX();

float fPosY = -pText->GetPosY();

// Décalage en fonction de la taille de l'écran

fPosX -= (float)((D3D10_RENDERER->GetViewportWidth() / 2 ));

fPosY += (float)((D3D10_RENDERER->GetViewportHeight() / 2 ));

// On vérifie si l'on a bien la police chargée en mémoire

if (m_fonts.count(sFontTextName) == 0)

{

return false;

}

// On obtient la police spécifiée

Font* pFont = m_fonts[sFontTextName];

// Tableau de tous les caractères de la police de font

FontTextFileCharacter* aCharacters = pFont->aCharacters;

D3D10_BUFFER_DESC vertexBufferDesc, indexBufferDesc;

D3D10_SUBRESOURCE_DATA vertexData, indexData;

HRESULT hr;

std::vector<PTPVertex> vertices;

for (uint32 i = 0; i < sText.length(); i++)

{

// Chaque lettre

uint32 iLetter = (uint32)sText[i];

FontTextFileCharacter character = pFont->aCharacters[iLetter];

if (iLetter == SPACE_ASCII_CODE) // Espace !

{

fPosX += character.iXAdvance;

continue;

}

if (iLetter == '\n')

{

fPosX = 0;

}

float x = 0;

float y = 0;

float tu = 0;

float tv = 0;

uint32 iCharX = character.iXPos; // Abscisse du caractère dans la texture

uint32 iCharY = character.iYPos; // Ordonnée du caractère dans la texture

uint32 iWidth = character.iWidth; // Largeur du caractère dans la texture

uint32 iHeight = character.iHeight; // Hauteur du caractère dans la texture

float iOffsetX = character.iXOffset;

float iOffsetY = character.iYOffset;

float iXAdvance = character.iXAdvance;

uint16 iPage = character.iPage;

//----------------- 1er triangle de la face du caractère -----------------//

// ---- Bottom left ---- //

iOffsetY = - iOffsetY - iHeight;

//iOffsetY = (- iOffsetY - pFont->iLineHeight

//iOffsetY -= pFont->iLineHeight;

x = fPosX + iOffsetX;

y = fPosY + iOffsetY;

tu = (float) (iCharX) / pFont->iWidth;

tv = (float) (iCharY + iHeight) / pFont->iHeight;

PTPVertex vertex;

vertex.position = D3DXVECTOR3(x, y, 0.0f);

vertex.texture = D3DXVECTOR2(tu, tv);

vertex.page = iPage;

vertices.push_back(vertex);

// ---- Top left ---- //

x = fPosX + iOffsetX;

y = fPosY + iOffsetY + iHeight;

tu = (float) iCharX / pFont->iWidth;

tv = (float) iCharY / pFont->iHeight;

vertex.position = D3DXVECTOR3(x, y, 0.0f);

vertex.texture = D3DXVECTOR2(tu, tv);

vertex.page = iPage;

vertices.push_back(vertex);

// ---- Top right ---- //

x = fPosX + iOffsetX + iWidth;

y = fPosY + iOffsetY + iHeight;

tu = (float) (iCharX + iWidth) / pFont->iWidth;

tv = (float) iCharY / pFont->iHeight;

vertex.position = D3DXVECTOR3(x, y, 0.0f);

vertex.texture = D3DXVECTOR2(tu, tv);

vertex.page = iPage;

vertices.push_back(vertex);

//----------------- 2ème triangle de la face du caractère -----------------//

// ---- Top right ---- //

x = fPosX + iOffsetX + iWidth;

y = fPosY + iOffsetY + iHeight;

tu = (float) (iCharX + iWidth) / pFont->iWidth;

tv = (float) iCharY / pFont->iHeight;

vertex.position = D3DXVECTOR3(x, y, 0.0f);

vertex.texture = D3DXVECTOR2(tu, tv);

vertex.page = iPage;

vertices.push_back(vertex);

// ---- Bottom right ---- //

x = fPosX + iOffsetX + iWidth;

y = fPosY + iOffsetY;

tu = (float) (iCharX + iWidth) / pFont->iWidth;

tv = (float) (iCharY + iHeight) / pFont->iHeight;

vertex.position = D3DXVECTOR3(x, y, 0.0f);

vertex.texture = D3DXVECTOR2(tu, tv);

vertex.page = iPage;

vertices.push_back(vertex);

// ---- Bottom left ---- //

x = fPosX + iOffsetX;

y = fPosY + iOffsetY;

tu = (float) (iCharX) / pFont->iWidth;

tv = (float) (iCharY + iHeight) / pFont->iHeight;

vertex.position = D3DXVECTOR3(x, y, 0.0f);

vertex.texture = D3DXVECTOR2(tu, tv);

vertex.page = iPage;

vertices.push_back(vertex);

// On décale de quelques pixels vers la gauche après chaque lettre

fPosX += iXAdvance;

}

pText->SetVertexCount(vertices.size());

pText->SetIndexCount( pText->GetVertexCount() );

std::vector<uint16> indices;

for (uint16 i = 0; i < pText->GetIndexCount(); i++)

{

indices.push_back(i);

}

vertexBufferDesc.Usage = D3D10_USAGE_DYNAMIC;

vertexBufferDesc.ByteWidth = sizeof(PTPVertex) * pText->GetVertexCount();

vertexBufferDesc.BindFlags = D3D10_BIND_VERTEX_BUFFER;

vertexBufferDesc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;

vertexBufferDesc.MiscFlags = 0;

vertexData.pSysMem = vertices.data();

ID3D10Buffer* pVB = nullptr;

hr = D3D10_RENDERER->GetDevice()->CreateBuffer(&vertexBufferDesc, &vertexData, &pVB);

VR_RETURN(hr);

pText->SetVertexBuffer(pVB);

indexBufferDesc.Usage = D3D10_USAGE_DEFAULT;

indexBufferDesc.ByteWidth = sizeof(uint16) * pText->GetIndexCount();

indexBufferDesc.BindFlags = D3D10_BIND_INDEX_BUFFER;

indexBufferDesc.CPUAccessFlags = 0;

indexBufferDesc.MiscFlags = 0;

indexData.pSysMem = indices.data();

ID3D10Buffer* pIB = nullptr;

hr = D3D10_RENDERER->GetDevice()->CreateBuffer(&indexBufferDesc, &indexData, &pIB);

VR_RETURN(hr);

pText->SetIndexBuffer(pIB);

return true;

}

void FontTextManager::Render(Text* pText)

{

if (!pText)

{

return;

}

uint32 iStride = sizeof(PTPVertex);

uint32 iOffset = 0;

D3D10_RENDERER->EnableZBuffer(false);

m_pWorldVariable->SetMatrix((float*)&m_worldMatrix);

m_pViewVariable->SetMatrix((float*)&m_viewMatrix);

m_pProjVariable->SetMatrix((float*)&m_projMatrix);

m_pColorVariable->SetFloatVector((float*)pText->GetColor());

ID3D10Buffer* pVertexBuffer = pText->GetVertexBuffer();

ID3D10Buffer* pIndexBuffer = pText->GetIndexBuffer();

size_t iVertexCount = pText->GetVertexCount();

size_t iIndexCount = pText->GetIndexCount();

D3D10_RENDERER->GetDevice()->IASetVertexBuffers(0, 1, &pVertexBuffer, &iStride, &iOffset);

D3D10_RENDERER->GetDevice()->IASetIndexBuffer(pIndexBuffer, DXGI_FORMAT_R16_UINT, 0);

D3D10_RENDERER->GetDevice()->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

ID3D10ShaderResourceView* pRV = pText->GetFont()->texturesArray;

if (pRV)

{

m_pBitmapVariable->SetResource(pRV);

}

D3D10_TECHNIQUE_DESC techniqueDesc;

D3D10_RENDERER->GetDevice()->IASetInputLayout(m_pVertexLayout);

m_pTechnique->GetDesc(&techniqueDesc);

AlphaPass TransparencyPass;

for (uint32 i = 0; i < techniqueDesc.Passes; i++)

{

m_pTechnique->GetPassByIndex(i)->Apply(0);

D3D10_RENDERER->GetDevice()->Draw(iVertexCount, 0);

}

D3D10_RENDERER->EnableZBuffer(true);

}

Text* FontTextManager::CreateText(const std::wstring& sText, const std::string& sFontTextName,

const float fPosX, const float fPosY, const D3DXCOLOR& color)

{

Text* pText = new Text(sText, color, fPosX, fPosY);

if (!IsFontTextLoaded(sFontTextName)) // todo : add dummy text

{

PRINT_ERROR("Police de caractere non reconnu");

return nullptr;

}

pText->SetFont(m_fonts[sFontTextName]);

if (!BuildTextBuffers(pText))

{

PRINT_ERROR("Echec lors du la construction des buffers d'un texte speficie");

return nullptr;

}

return pText;

}

/* Voir la documentation sur

http://www.angelcode.com/products/bmfont/doc/file_format.html

bool FontTextManager::LoadFontTextFile(const std::string& sFileName, const std::string& sFontTextName)

{

std::vector<ID3D10Texture2D*> textures;

std::string sLine;

std::string sRead, sKey, sValue;

std::ifstream file(sFileName);

if (!file.is_open())

{

PRINT_ERROR("Impossible de charger un fichier font");

return false;

}

std::string sBitmapFileName = "";

FontTextFileCharacter* aCharacters = new FontTextFileCharacter[256];

Font* pFont = new Font;

pFont->sFontTextName = sFontTextName;

pFont->aCharacters = aCharacters;

while (!file.eof())

{

std::stringstream sLineStream;

std::getline( file, sLine );

sLineStream << sLine;

// Lit le type de la ligne

sLineStream >> sRead;

if (sRead == "info")

{

while (!sLineStream.eof())

{

std::stringstream Converter;

sLineStream >> sRead;

uint32 i = sRead.find('=');

sKey = sRead.substr(0, i);

sValue = sRead.substr(i + 1);

Converter << sValue;

if (sKey == "size")

{

Converter >> pFont->iSize;

}

else if (sRead == "common")

{

while (!sLineStream.eof())

{

std::stringstream Converter;

sLineStream >> sRead;

uint32 i = sRead.find('=');

sKey = sRead.substr(0, i);

sValue = sRead.substr(i + 1);

Converter << sValue;

if (sKey == "lineHeight")

{

Converter >> pFont->iLineHeight;

}

else if (sKey == "base")

{

Converter >> pFont->iBase;

}

else if (sKey == "scaleW")

{

Converter >> pFont->iWidth;

}

else if (sKey == "scaleH")

{

Converter >> pFont->iHeight;

}

else if (sKey == "pages")

{

Converter >> pFont->iPagesCount;

}

else if (sRead == "page")

{

while (!sLineStream.eof())

{

std::stringstream Converter;

sLineStream >> sRead;

uint32 i = sRead.find('=');

sKey = sRead.substr(0, i);

sValue = sRead.substr(i + 1);

Converter << sValue;

if (sKey == "file")

{

Converter >> sBitmapFileName;

// On supprime les guillemets entre le nom du fichier

sBitmapFileName.pop_back();

sBitmapFileName.erase(0, 1);

fastprint("Chargement de " << sBitmapFileName << " pour " << pFont->sFontTextName);

ID3D10Texture2D* pTexture = CreateTexture(sBitmapFileName);

if (pTexture)

{

textures.push_back(pTexture);

}

else if (sRead == "char")

{

uint16 iCharID = 0;

while (!sLineStream.eof())

{

std::stringstream Converter;

sLineStream >> sRead;

uint32 i = sRead.find('=');

sKey = sRead.substr(0, i);

sValue = sRead.substr(i + 1);

Converter << sValue;

if (sKey == "id")

{

Converter >> iCharID;

}

else if (sKey == "x")

{

Converter >> pFont->aCharacters[iCharID].iXPos;

}

else if (sKey == "y" )

{

Converter >> pFont->aCharacters[iCharID].iYPos;

}

else if (sKey == "width")

{

Converter >> pFont->aCharacters[iCharID].iWidth;

}

else if (sKey == "height")

{

Converter >> pFont->aCharacters[iCharID].iHeight;

}

else if (sKey == "xoffset")

{

Converter >> pFont->aCharacters[iCharID].iXOffset;

}

else if (sKey == "yoffset")

{

Converter >> pFont->aCharacters[iCharID].iYOffset;

}

else if (sKey == "xadvance")

{

Converter >> pFont->aCharacters[iCharID].iXAdvance;

}

else if (sKey == "page")

{

Converter >> pFont->aCharacters[iCharID].iPage;

}

m_fonts[sFontTextName] = pFont;

debugprint(pFont->sFontTextName.c_str());

debugprint(pFont->iBase);

debugprint(pFont->iHeight);

debugprint(pFont->iLineHeight);

debugprint(pFont->iPagesCount);

debugprint(pFont->iWidth);

if (textures.size() == 0)

{

PRINT_ERROR("Aucune textures chargees");

}

fastprint("\n---------------------------\n");

ID3D10Texture2D* pTextureArray = CreateTextureArray(textures);

for (uint32 i = 0; i < textures.size(); i++)

{

ID3D10Texture2D* pCurrentTexture = textures[i];

SAFE_RELEASE(pCurrentTexture);

}

ID3D10ShaderResourceView* pRVArray = GetTextureRVArray(pTextureArray);

SAFE_RELEASE(pTextureArray);

pFont->texturesArray = pRVArray;

return true;

}

float FontTextManager::GetGlyphAspectRatio(const wchar_t* c, const std::string& sFontTextName)

{

// On obtient la police spécifiée

Font* pFont = m_fonts[sFontTextName];

if (pFont)

{

return 0;

}

// Tableau de tous les caractères de la police de font

FontTextFileCharacter* aCharacters = pFont->aCharacters;

FontTextFileCharacter character = aCharacters[(uint32)c];

uint32 iWidth = character.iWidth;

uint32 iHeight = character.iHeight;

return (float) (iWidth / iHeight);

}

RECT FontTextManager::GetGlyphTexCoords(const wchar_t* c, const std::string& sFontTextName)

{

RECT rect;

ZeroMemory(&rect, sizeof(RECT));

// On obtient la police spécifiée

Font* pFont = m_fonts[sFontTextName];

if (!pFont)

{

return rect;

}

// Tableau de tous les caractères de la police de font

FontTextFileCharacter* aCharacters = pFont->aCharacters;

FontTextFileCharacter character = aCharacters[(uint32)c];

uint32 iCharX = character.iXPos;

uint32 iCharY = character.iYPos;

uint32 iWidth = character.iWidth;

uint32 iHeight = character.iHeight;

rect.left = iCharX;

rect.top = iCharY;

rect.right = iWidth;

rect.bottom = iHeight;

return rect;

}

uint16 FontTextManager::GetCharacterPage(const wchar_t* c, const std::string& sFontTextName)

{

// On obtient la police spécifiée

Font* pFont = m_fonts[sFontTextName];

if (!pFont)

{

return 0;

}

// Tableau de tous les caractères de la police de font

FontTextFileCharacter* aCharacters = pFont->aCharacters;

FontTextFileCharacter character = aCharacters[(uint32)c];

return character.iPage;

}

ID3D10Texture2D* FontTextManager::CreateTexture(const std::string& sBitmapFileName)

{

ID3D10Texture2D* pLoadedTexture = nullptr;

D3DX10_IMAGE_LOAD_INFO loadinfo;

ZeroMemory(&loadinfo, sizeof(D3DX10_IMAGE_LOAD_INFO));

loadinfo.Width = D3DX10_FROM_FILE;

loadinfo.Height = D3DX10_FROM_FILE;

loadinfo.Depth = D3DX10_FROM_FILE;

loadinfo.FirstMipLevel = 0;

loadinfo.MipLevels = D3DX10_FROM_FILE;

loadinfo.Usage = D3D10_USAGE_STAGING;

loadinfo.BindFlags = 0;

loadinfo.CpuAccessFlags = D3D10_CPU_ACCESS_READ | D3D10_CPU_ACCESS_WRITE;

loadinfo.MiscFlags = 0;

loadinfo.Format = DXGI_FORMAT_R8G8B8A8_UNORM;

loadinfo.Filter = D3DX10_FILTER_NONE;

loadinfo.MipFilter = D3DX10_FILTER_NONE;

loadinfo.pSrcInfo = 0;

D3DX10CreateTextureFromFileA(D3D10_RENDERER->GetDevice(),

sBitmapFileName.c_str(), &loadinfo, 0, (ID3D10Resource**)&pLoadedTexture, 0);

return pLoadedTexture;

}

ID3D10Texture2D* FontTextManager::CreateTextureArray(std::vector<ID3D10Texture2D*>& textures)

{

if (textures.size() == 0)

{

return nullptr;

}

ID3D10Texture2D* pTexturesArray = nullptr;

D3D10_TEXTURE2D_DESC textElementDesc;

ZeroMemory(&textElementDesc, sizeof(D3D10_TEXTURE2D_DESC));

textures[0]->GetDesc(&textElementDesc);

D3D10_TEXTURE2D_DESC textArrayDesc;

textArrayDesc.Width = textElementDesc.Width;

textArrayDesc.Height = textElementDesc.Height;

textArrayDesc.MipLevels = textElementDesc.MipLevels;

textArrayDesc.ArraySize = textures.size();

textArrayDesc.Format = textElementDesc.Format;

textArrayDesc.SampleDesc.Count = 1;

textArrayDesc.SampleDesc.Quality = 0;

textArrayDesc.Usage = D3D10_USAGE_DEFAULT;

textArrayDesc.BindFlags = D3D10_BIND_SHADER_RESOURCE;

textArrayDesc.CPUAccessFlags = 0;

textArrayDesc.MiscFlags = 0;

D3D10_RENDERER->GetDevice()->CreateTexture2D(&textArrayDesc, 0, &pTexturesArray);

// On copie toutes les textures dans le tableau !

for (uint16 i = 0; i < textures.size(); i++)

{

for (uint16 j = 0; j < textElementDesc.MipLevels; j++)

{

D3D10_MAPPED_TEXTURE2D mappedTex2D;

ID3D10Texture2D* pCurrentTexture = textures[i];

pCurrentTexture->Map(j, D3D10_MAP_READ, 0, &mappedTex2D);

uint32 c = D3D10CalcSubresource(j, i, textElementDesc.MipLevels);

D3D10_RENDERER->GetDevice()->UpdateSubresource(pTexturesArray, c,

0, mappedTex2D.pData, mappedTex2D.RowPitch, 0);

pCurrentTexture->Unmap(j);

}

return pTexturesArray;

}

ID3D10ShaderResourceView* FontTextManager::GetTextureRVArray(ID3D10Texture2D* pTexArray)

{

if (pTexArray == nullptr)

{

return nullptr;

}

ID3D10ShaderResourceView* pArrayRV = nullptr;

D3D10_SHADER_RESOURCE_VIEW_DESC viewDesc;

ZeroMemory(&viewDesc, sizeof(D3D10_SHADER_RESOURCE_VIEW_DESC));

D3D10_TEXTURE2D_DESC textArrayDesc;

pTexArray->GetDesc(&textArrayDesc);

viewDesc.Format = textArrayDesc.Format;

viewDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2DARRAY;

viewDesc.Texture1DArray.MostDetailedMip = 0;

viewDesc.Texture1DArray.MipLevels = textArrayDesc.MipLevels;

viewDesc.Texture1DArray.FirstArraySlice = 0;

viewDesc.Texture1DArray.ArraySize = textArrayDesc.ArraySize;

D3D10_RENDERER->GetDevice()->CreateShaderResourceView(pTexArray, &viewDesc, &pArrayRV);

return pArrayRV;

}

Résumé :

Nous avons présenter une méthode générique pour afficher du texte à l’écran ! Pas besoin d’utiliser D3DXFont !

Références :

– http://www.rastertek.com/dx10tut12.html

– http://kvazars.com/littera/

– http://www.angelcode.com/products/bmfont/

– http://www.angelcode.com/products/bmfont/doc/file_format.html

– http://www.gamedev.net/topic/330742-quick-tutorial-variable-width-bitmap-fonts/

Bugs et problèmes courants – solutions

Intro :

Voici la liste des bugs et problèmes courants rencontrés lors du développement d’un jeu.

Je met à jour petit à petit mes bugs rencontrés.

Prérequis :

Explications :

Résumé :

Références :

Apprendre à apprendre – méthode de travail

Intro :

La conception de jeu vidéo est un domaine vraiment dur à maitriser et à apprendre. Pour être compétent, il faut travailler régulièrement et sans relâche. Il faut donc être armé de méthodes pour y parvenir.

Prérequis :

– Être motivé pour apprendre

Explications :

Voici quelques méthodes pour vous aider à progresser dans l’apprentissage de la conception de jeux vidéo ou celle du rendu 3D.

Méthodes :

1) Lors de la lecture d’un texte plus ou moins compliqué, il faut absolument noter tout les mots inconnus et prendre le temps de les définir avec un dictionnaire ou un lexique cherché par exemple sur un moteur de recherche.

2) Ne pas hésiter à essayer la méthode Coué pour suggestionner votre mental afin de faire émerger beaucoup d’idées dans votre esprit.

Répéter 15 fois 3 fois par jour : « Je suis très fort en programmation graphique et de jeux vidéo » à voix haute.

3) Ne faites qu’une chose à la fois ; apprenez qu’un seul thème à la fois. Par exemple « en ce moment j’apprend l’utilisation des quaternions ». Si vous n’avancez pas (ou si vous ne comprenez pas) un thème, passer au suivant.

4) Tenez à jour un mémo journalier où vous indiquez ce que vous apprenez petit à petit.
Il vous sera utile pour observer et identifier vos lacunes sur les sujets que vous n’avez pas assez travaillés ; à l’inverse, il vous sera aussi utile pour vous rappeler les sujets que vous maitrisez.

5) Travaillez par tranche de 1 heure 30 minimum sur un sujet, en effet mon expérience démontre qu’il n’est pas rentable de travailler moins d’une heure d’affilée. C’est pour cela que les cours à l’école durent plus de deux heures !

6) Comprendre avant d’apprendre. En effet il ne sert à rien d’apprendre par cœur des formules si vous ne savez pas à quoi elles servent.

7) Rejoignez un projet de jeu vidéo open source cherché sur le net. En effet le travail en équipe vous motivera et la communication avec les autres programmeurs enrichira vos connaissances.
C’est le même principe qu’avec un guitariste qui prendra peut-être plaisir à jouer seul, mais s’il jouait en groupe il progressera plus vite étant donné la motivation de travailler en groupe.

8) Faites des fiches en notant l’essentiel de chaque sujet où définissez vos mots inconnus.

9) Relisez vos fiches ou vos notes avant de vous coucher ou dans les transports en commun.

10) Ne lisez jamais du contenu que vous connaissez et maîtrisez déjà.

11) Lisez plus que vous n’écrivez !

12) Apprendre un langage de programmation est comme apprendre une langue étrangère : plus vous la pratiquez, mieux vous la comprenez.

13) Sélectionnez efficacement les documents / pages web que vous comptez lire, tout en évaluant la pertinence de ceux-ci.

En effet, le prix nobéliste de mathématiques C. Villani a dit : « […] maintenant, pour comprendre le monde, il ne s’agit plus d’avoir accès à l’information, mais bien de la trier ! »

14) Utilisez le principe de lecture « front to back and back to front ». Lisez d’abord de manière descendante et relisez de manière ascendante vos documents préférés.

15) Lisez de préférence du contenu qui vous semble facile. Lisez de préférence du contenu dont vous êtes susceptible de mieux retenir.

16) Je sais que c’est dur, mais essayer d’apprendre le plus rapidement possible !

Résumé :

Pour progresser dans l’étude de la programmation graphique, j’ai énuméré 4 idées :

Sur le net, il existe beaucoup de bonnes idées sur des blogs de développement personnel, n’hésitez pas à jeter un oeil !

Références :

– https://fr.wikipedia.org/wiki/M%C3%A9thode_Cou%C3%A9

– Mon expérience

Introduction à DirectX 10 – Redimensionner la fenêtre de rendu – partie 6

Intro :

Dans une application DirectX, l’utilisateur peut vouloir redimensionner la fenêtre à sa guise ou passer le jeu en mettre en mode plein écran.

Il faut implémenter et coder cette fonctionnalité.

Prérequis :

– Avoir suivi la cinquième partie de ce tutoriel.

Sixième partie :

Redimensionnement et plein écran de la fenêtre de rendu.

Explications :

Avant tout, juste pour énoncer un petit point mis à part :

L’appel à D3D11DeviceContext::ClearState réinitialise par défaut toutes les configurations du contexte d’affichage (remet à zéro les shaders, les inputs layout, les viewports, etc..)

Avec les interfaces DXGI* on peut obtenir les informations sur la carte graphique :

bool D3D10Renderer::GetGPUInfo()
{
    HRESULT hr = S_OK;

    uint32 iNumModes;

    IDXGIFactory* pDXGIFactory = nullptr;
    IDXGIAdapter* pDXGIAdapter = nullptr;
    IDXGIOutput* pDXGIAdapterOutput = nullptr;

    DXGI_MODE_DESC* pDisplayModeList = nullptr;

    DXGI_ADAPTER_DESC adapterDesc;

    // Créée une interface métier "factory" DirectX
    hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&pDXGIFactory);

    HR_FAILED_RETURN_FALSE(hr);

    // Utilise la "factory"
    hr = pDXGIFactory->EnumAdapters(0, &pDXGIAdapter);

    HR_FAILED_RETURN_FALSE(hr);

    // Enumère l'adpatateur principal de l'écran
    hr = pDXGIAdapter->EnumOutputs(0, &pDXGIAdapterOutput);

    HR_FAILED_RETURN_FALSE(hr);

    // Obtient le nombre de modes d'affichage qui corresppond à DXGI_FORMAT_R8G8B8A8_UNORM  
    hr = pDXGIAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &iNumModes, nullptr);

    HR_FAILED_RETURN_FALSE(hr);

    /* Créé une liste qui détient tous les modes d'affichage possibles pour cette carte graphique et
       le format d'affichage */
    pDisplayModeList = new DXGI_MODE_DESC[iNumModes];

    if (!pDisplayModeList)
    {
        return false;
    }

    // Remplie la précédente structure
    hr = pDXGIAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &iNumModes, pDisplayModeList);
    
    HR_FAILED_RETURN_FALSE(hr);

    /* On parcourt tous les modes d'affichages possibles
       et on trouve celui qui correspond à la taille spécifiée
       en paramètre ; puis on enregistre le numérateur et le dénominateur
       du taux de rafraichissement de l'écran
    */
    for (uint32 i = 0; i < iNumModes; i++)
    {
        if (pDisplayModeList[i].Width == (uint32)m_iWidth)
        {
            if (pDisplayModeList[i].Height == (uint32)m_iHeight)
            {
                m_iNumerator = pDisplayModeList[i].RefreshRate.Numerator;
                m_iDenominator = pDisplayModeList[i].RefreshRate.Denominator;
            }
        }

        DXGI_MODE_DESC desc = pDisplayModeList[i];

        // On vérifie que ce mode n'a pas déjà été ajouté
        bool bAlreadyExist = false;
        for (uint32 i = 0; i < m_modes.size(); i++)
        {
            if (m_modes[i].Width == desc.Width &&
                m_modes[i].Height == desc.Height)
            {
                bAlreadyExist = true;
                break;
            }
        }

        if (!bAlreadyExist)
        {
            m_modes.push_back(desc);
        }
    }

    hr = pDXGIAdapter->GetDesc(&adapterDesc);

    HR_FAILED_RETURN_FALSE(hr);

    // On enregistre la taille de la mémoire vidéo en mégabytes
    m_iVideoCardMemory = (adapterDesc.DedicatedVideoMemory / 1024 / 1024);

    size_t iStringLength = 0;
    // Convertie le nom la carte vidéo dans une chaîne de caractères
    int iError = wcstombs_s(&iStringLength, m_sVideoCardDescription, 128, adapterDesc.Description, 128);

    if (iError != 0)
    {
        return false;
    }

    // On supprime les objets dont a plus besoin !
    SAFE_DELETE_ARRAY(pDisplayModeList);

    SAFE_RELEASE(pDXGIAdapterOutput);
    SAFE_RELEASE(pDXGIAdapter);
    SAFE_RELEASE(pDXGIFactory);

    return true;
}

100

101

102

103

104

105

106

107

108

109

bool D3D10Renderer::GetGPUInfo()

{

HRESULT hr = S_OK;

uint32 iNumModes;

IDXGIFactory* pDXGIFactory = nullptr;

IDXGIAdapter* pDXGIAdapter = nullptr;

IDXGIOutput* pDXGIAdapterOutput = nullptr;

DXGI_MODE_DESC* pDisplayModeList = nullptr;

DXGI_ADAPTER_DESC adapterDesc;

// Créée une interface métier "factory" DirectX

hr = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&pDXGIFactory);

HR_FAILED_RETURN_FALSE(hr);

// Utilise la "factory"

hr = pDXGIFactory->EnumAdapters(0, &pDXGIAdapter);

HR_FAILED_RETURN_FALSE(hr);

// Enumère l'adpatateur principal de l'écran

hr = pDXGIAdapter->EnumOutputs(0, &pDXGIAdapterOutput);

HR_FAILED_RETURN_FALSE(hr);

// Obtient le nombre de modes d'affichage qui corresppond à DXGI_FORMAT_R8G8B8A8_UNORM

hr = pDXGIAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &iNumModes, nullptr);

HR_FAILED_RETURN_FALSE(hr);

/* Créé une liste qui détient tous les modes d'affichage possibles pour cette carte graphique et

le format d'affichage */

pDisplayModeList = new DXGI_MODE_DESC[iNumModes];

if (!pDisplayModeList)

{

return false;

}

// Remplie la précédente structure

hr = pDXGIAdapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &iNumModes, pDisplayModeList);

HR_FAILED_RETURN_FALSE(hr);

/* On parcourt tous les modes d'affichages possibles

et on trouve celui qui correspond à la taille spécifiée

en paramètre ; puis on enregistre le numérateur et le dénominateur

du taux de rafraichissement de l'écran

for (uint32 i = 0; i < iNumModes; i++)

{

if (pDisplayModeList[i].Width == (uint32)m_iWidth)

{

if (pDisplayModeList[i].Height == (uint32)m_iHeight)

{

m_iNumerator = pDisplayModeList[i].RefreshRate.Numerator;

m_iDenominator = pDisplayModeList[i].RefreshRate.Denominator;

}

DXGI_MODE_DESC desc = pDisplayModeList[i];

// On vérifie que ce mode n'a pas déjà été ajouté

bool bAlreadyExist = false;

for (uint32 i = 0; i < m_modes.size(); i++)

{

if (m_modes[i].Width == desc.Width &&

m_modes[i].Height == desc.Height)

{

bAlreadyExist = true;

break;

}

if (!bAlreadyExist)

{

m_modes.push_back(desc);

}

hr = pDXGIAdapter->GetDesc(&adapterDesc);

HR_FAILED_RETURN_FALSE(hr);

// On enregistre la taille de la mémoire vidéo en mégabytes

m_iVideoCardMemory = (adapterDesc.DedicatedVideoMemory / 1024 / 1024);

size_t iStringLength = 0;

// Convertie le nom la carte vidéo dans une chaîne de caractères

int iError = wcstombs_s(&iStringLength, m_sVideoCardDescription, 128, adapterDesc.Description, 128);

if (iError != 0)

{

return false;

}

// On supprime les objets dont a plus besoin !

SAFE_DELETE_ARRAY(pDisplayModeList);

SAFE_RELEASE(pDXGIAdapterOutput);

SAFE_RELEASE(pDXGIAdapter);

SAFE_RELEASE(pDXGIFactory);

return true;

}

Voici le programme de cet article une fois compilé et lancé :

La fonction qui redimensionne les buffers :

bool D3D10Renderer::ResizeSwapChain(const size_t iWidth, const size_t iHeight)
{
    /* On décharge les précédents objets de rendu */
    SAFE_RELEASE(m_pRenderTargetView);
    SAFE_RELEASE(m_pDepthStencilView);

    HRESULT hr = S_OK;
    hr = m_pSwapChain->ResizeBuffers(2, iWidth, iHeight, DXGI_FORMAT_R8G8B8A8_UNORM, 0);

    HR_FAILED_RETURN_FALSE(hr);

    m_iWidth = iWidth;
    m_iHeight = iHeight;

    /* Puis on les recréer */
    CreateRenderTarget();
    CreateDepthStencilView();

    //m_pCube->SetLens()
    SetViewport();

    return true;
}

bool D3D10Renderer::ResizeSwapChain(const size_t iWidth, const size_t iHeight)

{

/* On décharge les précédents objets de rendu */

SAFE_RELEASE(m_pRenderTargetView);

SAFE_RELEASE(m_pDepthStencilView);

HRESULT hr = S_OK;

hr = m_pSwapChain->ResizeBuffers(2, iWidth, iHeight, DXGI_FORMAT_R8G8B8A8_UNORM, 0);

HR_FAILED_RETURN_FALSE(hr);

m_iWidth = iWidth;

m_iHeight = iHeight;

/* Puis on les recréer */

CreateRenderTarget();

CreateDepthStencilView();

//m_pCube->SetLens()

SetViewport();

return true;

}

La fonction qui gère les entrées clavier :

void D3D10Renderer::OnKeyPressed(const KeyEvent& arg)
{
    if (arg.keyCode == VK_ESCAPE)
    {
        SYSTEM->Quit();
    }
    else if (arg.keyCode == VK_F1)
    {
        m_bFullscreen = !m_bFullscreen;

        if (m_bFullscreen)
        {
            ResizeSwapChain(m_iWidth, m_iHeight);
        }

        m_pSwapChain->SetFullscreenState(m_bFullscreen, nullptr);
    }
    else if (arg.keyCode == VK_F2)
    {
        static uint32 iMode = 0;

        // Largeur de la fenêtre
        uint32 iWidth = m_modes[iMode].Width;
        // Hauteur de la fenêtre
        uint32 iHeight = m_modes[iMode].Height;

        ResizeSwapChain(iWidth, iHeight);

        RECT rc;

        GetWindowRect(m_hWnd, &rc);

        SetWindowPos(m_hWnd, 0, rc.left, rc.top, iWidth, iHeight, SWP_SHOWWINDOW);

        iMode++;

        if (iMode >= m_modes.size())
        {
            iMode = 0;
        }
    }
}

void D3D10Renderer::OnKeyPressed(const KeyEvent& arg)

{

if (arg.keyCode == VK_ESCAPE)

{

SYSTEM->Quit();

}

else if (arg.keyCode == VK_F1)

{

m_bFullscreen = !m_bFullscreen;

if (m_bFullscreen)

{

ResizeSwapChain(m_iWidth, m_iHeight);

}

m_pSwapChain->SetFullscreenState(m_bFullscreen, nullptr);

}

else if (arg.keyCode == VK_F2)

{

static uint32 iMode = 0;

// Largeur de la fenêtre

uint32 iWidth = m_modes[iMode].Width;

// Hauteur de la fenêtre

uint32 iHeight = m_modes[iMode].Height;

ResizeSwapChain(iWidth, iHeight);

RECT rc;

GetWindowRect(m_hWnd, &rc);

SetWindowPos(m_hWnd, 0, rc.left, rc.top, iWidth, iHeight, SWP_SHOWWINDOW);

iMode++;

if (iMode >= m_modes.size())

{

iMode = 0;

}

Résumé :

Depuis DirectX 10 il est plus facile et aisé de changer de résolution et de passer en mode plein écran.

Voici les fichiers source – Partie 6

Références :

– https://msdn.microsoft.com/en-us/library/windows/desktop/ff476389%28v=vs.85%29.aspx

– https://msdn.microsoft.com/en-us/library/windows/desktop/bb174577%28v=vs.85%29.aspx