Bonjour. J'utilise Direct2D et implémente un objet Fen pour me simplifier la vie:

#include <sdkddkver.h>

#include <Windows.h>
class Fen {
private:

	class FenClass
	{
	public:
		static const char* GetName() noexcept;
		static HINSTANCE GetInstance() noexcept;
	private:
		FenClass() noexcept;
		~FenClass();

		FenClass(const FenClass&) = delete;
		FenClass& operator=(const FenClass &) = delete;
		static constexpr const char* wndClassName = "Fenêtre window";
		static FenClass wndClass; 
		HINSTANCE hInst;

	};
public:
	Fen(const Fen&) = delete;
	Fen& operator=(const Fen&) = delete;
	~Fen();
	Fen(int w, int h, const char* nom);

	int h, w;
private:
	static LRESULT CALLBACK HandleMsgSetup(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)noexcept;
	static LRESULT CALLBACK HandleMsgThunk(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
	LRESULT HandleMsg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)noexcept;
public:
	HWND hWnd;
	ID2D1HwndRenderTarget* pRT;
	ID2D1Factory* pD2DFactory;
	void ellipse(int x, int y, int w, int h, ID2D1SolidColorBrush* couleur);
};

#include <sstream>
#include <string>
#include <d2d1.h>


//ooouuuiiiii
Fen::FenClass Fen::FenClass::wndClass;

Fen::FenClass::FenClass() noexcept
	:
	hInst(GetModuleHandle(nullptr))
{
	WNDCLASSEX wc = { 0 };
	wc.cbSize = sizeof(wc);
	wc.style = CS_OWNDC;
	wc.lpfnWndProc = HandleMsgSetup;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = GetInstance();
	wc.hIcon = nullptr;
	wc.hCursor = nullptr;
	wc.hbrBackground = nullptr;
	wc.lpszMenuName = nullptr;
	wc.lpszClassName = GetName();
	wc.hIconSm = nullptr;
	RegisterClassEx(&wc);
}

const char * Fen::FenClass::GetName() noexcept
{
	return wndClassName;
}

HINSTANCE Fen::FenClass::GetInstance() noexcept
{

	return wndClass.hInst;
}

Fen::FenClass::~FenClass()
{
	UnregisterClass(wndClassName,GetInstance());
}


Fen::~Fen()
{	
	//fin du dessinage
	HRESULT hr3 = pRT->EndDraw();
	//desinitialisation du dessinage
	SafeRelease< ID2D1HwndRenderTarget>(&pRT);
	SafeRelease< ID2D1Factory>(&pD2DFactory);

	//destruction de la fenêtre
	DestroyWindow(hWnd);
}

Fen::Fen(int m_w, int m_h, const char * nom)
	:pRT(NULL), pD2DFactory(NULL)
{
	RECT wr;
	wr.left = 100;
	wr.right = m_h + wr.left;
	wr.top = 100;
	wr.bottom = m_h + wr.top;
	if (FAILED(AdjustWindowRect(&wr, WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU, FALSE))) {
		std::ostringstream a;
		a << "Erreur a la ligne " << __LINE__ << " du document " << __FILE__ << " : " << "Echec de l'ouverture de la fenetre";
		std::string b = a.str();
		char* c = (char*)b.c_str();
		MessageBox(hWnd,c, "Erreur", MB_OK);  
	}

	//création de la fenêtre
	hWnd = CreateWindow(FenClass::GetName(), nom,
		WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU,
		CW_USEDEFAULT, CW_USEDEFAULT, wr.right - wr.left, wr.bottom-wr.top,
		nullptr, nullptr, FenClass::GetInstance(), this);
	if (hWnd == nullptr) {
		std::ostringstream a;
		a << "Erreur a la ligne " << __LINE__ << " du document " << __FILE__ << " : " << "Erreur ligne 68 dans Fen.cpp : La creation de la fenetre a echoue";
		std::string b = a.str();
		char* c = (char*)b.c_str();
		MessageBox(hWnd, c, "Erreur", MB_OK);
	}
	//affichage
	ShowWindow(hWnd, SW_SHOWDEFAULT);
	//initialisation du mode dessin
	HRESULT hr2 = D2D1CreateFactory(
		D2D1_FACTORY_TYPE_SINGLE_THREADED,
		&pD2DFactory
	);
	//saisie des dimentions de la fen
	RECT rc;
	GetClientRect(hWnd, &rc);

	//création du rendertarget pRT

	HRESULT hr = pD2DFactory->CreateHwndRenderTarget(
		D2D1::RenderTargetProperties(),
		D2D1::HwndRenderTargetProperties(
			hWnd,
			D2D1::SizeU(
				rc.right - rc.left,
				rc.bottom - rc.top)
		),
		&pRT
	);

	//debut du dessinage
	pRT->BeginDraw();
}

LRESULT WINAPI Fen::HandleMsgSetup(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)noexcept
{
	if (msg == WM_NCCREATE) {
		const CREATESTRUCTW* const pCreate = reinterpret_cast<CREATESTRUCTW*>(lParam);
		Fen* const pWnd = static_cast<Fen*>(pCreate->lpCreateParams);
		SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(pWnd));
		SetWindowLongPtr(hWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(&Fen::HandleMsgThunk));
		return pWnd->HandleMsg(hWnd, msg, wParam, lParam);
	}

	return DefWindowProc(hWnd,msg,wParam,lParam);
}

LRESULT Fen::HandleMsgThunk(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	Fen* const pWnd = reinterpret_cast<Fen*>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
	return pWnd->HandleMsg(hWnd,msg,wParam,lParam); 
}

LRESULT Fen::HandleMsg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) noexcept
{
	switch (msg)
	{
	case WM_CLOSE:
		PostQuitMessage(0);
		return 0;
	}
	return DefWindowProc(hWnd, msg, wParam, lParam);
}

void Fen::ellipse(int x, int y, int w, int h, ID2D1SolidColorBrush * couleur)
{
	D2D1_POINT_2F centre;
	centre.x = 150.0f;
	centre.y = 150.0f;
	pRT->DrawEllipse(
		D2D1::Ellipse(centre, 50.0, 50.0),
		couleur
	);
}




template <class T> void SafeRelease(T **ppT)
{
	if (*ppT)
	{
		(*ppT)->Release();
		*ppT = NULL;
	}
}

J'admet que c'est un gros code pour une insertion de ce type. Ce qui me dérange quand je compile, le fichier (FEN.cpp que j'ai collé au .h) génère l'erreur suivante:

\fen.h(36): error C2143: erreur de syntaxe : absence de ';' avant '*' (compilation du fichier source Fen.cpp)

\error C2143: erreur de syntaxe : absence de ';' avant '*' (compilation du fichier source WinMain.cpp)

Le problème est casse pieds car il est apparu alors que je modifiais les lignes 220, et que retourner en arrière ne règle pas le problème. Si quelqu'un a une idée de ce que je dois faire, je l'en remercie.

-
Edité par BelhouariSéhane 28 janvier 2019 à 14:23:11

Évitez d'inclure des .h fourre-tout dans les .h.

Utilisez les .h qui correspondent à votre spécification d'API/interface.

Je ne fais que lire le message d'erreur :

\fen.h(36): error C2143

=> ligne 36

>ID2D1HwndRenderTarget* pRT;

C'est défini où "ID2D1HwndRenderTarget" ?

https://docs.microsoft.com/en-us/windows/desktop/api/d2d1/nn-d2d1-id2d1hwndrendertarget

Donc, il est où le "#include <d2d1.h>" au début du .h ???

BelhouariSéhane a écrit:

Bonjour. J'utilise Direct2D et implémente un objet Fen pour me simplifier la vie

Direct2D et simplifier dans la même phrase ? Étonnant.

C'est dommage de faire du DirectX, ton application ne sera compatique que Windows. Tu vas réduire considérablement ton audience.

bacelar, tu as raison, le message du deboggeur m'a fait croire que l'erreur se trouvait dans Fen.cpp, donc je regardais ce qui est maintenant à la ligne 75 et restais dans l'incompréhension, ce qui est stupide. L'erreur est sûrment au ID2D1Rendertarget qui est une structure de L'API win32.

L'erreur est en entière:

1>\fen.h(36): error C2143: erreur de syntaxe : absence de ';' avant '*' (compilation du fichier source WinMain.cpp)
1>\fen.h(36): error C2143: erreur de syntaxe : absence de ';' avant '*' (compilation du fichier source Fen.cpp)
1>\fen.h(36): error C4430: spécificateur de type manquant - int est pris en compte par défaut. Remarque : C++ ne prend pas en charge int par défaut (compilation du fichier source WinMain.cpp)
1>\fen.h(36): error C4430: spécificateur de type manquant - int est pris en compte par défaut. Remarque : C++ ne prend pas en charge int par défaut (compilation du fichier source Fen.cpp)
1>\fen.h(36): error C2238: jetons inattendus avant ';' (compilation du fichier source WinMain.cpp)
1>\fen.h(36): error C2238: jetons inattendus avant ';' (compilation du fichier source Fen.cpp)

Ps: Pardon, j'ai trouvé le pb: l'objet ID2D1Rendertarget proviens d'un header que j'avais inclus dans le .cpp et pas dans le .h,sauf que j'utilise ID2D1Rendertarget dans le .h lors de la définition de pTR 

-
Edité par BelhouariSéhane 30 janvier 2019 à 13:21:05

markand a écrit:

C'est dommage de faire du DirectX, ton application ne sera compatique que Windows. Tu vas réduire considérablement ton audience.

Mouais, dans un monde majoritairement Windows, "reduire considérablement l'audience" est relative.

Question de choix.
Inutile d'embrayer sur la guéguerre Microsoft VS le reste du monde.

Il n'y a pas que les PCs, il y a des smartphones aussi. Et eux contrairement aux PCs sont loin d'être majoritairement sur Windows

Utiliser OpenGL/vulkan permet déjà de considérer un portage important.

C'est un bon argument, mais pour l'instant, microsoft est une portée bien suffisante pour mes programmes, et dans le cas (peu probable) où j'aurais besoins de plus de portabilité, je me débrouillerais pour créer une bibliothèque plus portable qui s'accorderais toujours à mes programmes.

Ca c'est du syndrome NIH naissant. Donc tu vas te mettre des années de développement dans la gueule pour juste refaire (en beaucoup plus pourri évidemment) des trucs qui existent déjà depuis des années, qui sont stables, fiables et pérennes?