SQUELETTE DE MOTEUR 3D

// Moteur3D - Mon moteur 3D
// Commandé au clavier par les touches flèchées et par les touches z, q, s, d, CapsLock, Ctrl, Insert, f.
// Traite les messages signalant l'appui d'une touche.

#include <windows.h>
#include <math.h>

/********************************* DEFINITIONS ********************************/
#define X 0
#define Y 1
#define Z 2

/***************************** VARIABLES UTILISEES ****************************/

HINSTANCE hInstance;					// Handle du programme

double distance_ecran = 600;			// Distance des yeux à l'écran (mm).
double largeur_ecran_metrique = 375;	// En mm.
double hauteur_ecran_metrique = 300;	// En mm.
double largeur_ecran_pixel = 1280;		// En pixels.
double hauteur_ecran_pixel = 1024;		// En pixels.
double matrice_globale_camera [16]= {	// Matrice de changement de base : base globale -> base camera
	1, 0, 0, 0,
	0, 1, 0, 0,
	0, 0, 1, 0,
	0, 0, 0, 1};   // matrice identité
double coefficient_translation = 1;		// Longueur de la translation élementaire (appui d'une touche) en mm
double coefficient_rotation = 10;		// Angle d'une rotation élementaire (appui d'une touche) en 10^-3 rad
double grille [5*5*5*4];				// Plus tard, une grille de 5 * 5 * 5 points

//  Callback
LRESULT CALLBACK WindowMainProcedure (HWND, UINT, WPARAM, LPARAM);

// Traitement et affichage de l'image.
void ImageTraitement (HWND hwnd);

// Translate la base caméra (pour faire une nouvelle base caméra)
void TranslationCamera (long axe, double longueur);

// Rotationne la base caméra (pour faire une nouvelle base caméra)
void RotationCamera (long axe, double angle);

// Multiplie une matrice 1*4 par une matrice 4*4.
void MatriceMultiplication_14_44 (double matrice_1 [4], double matrice_2 [16], double matrice_s [4]);

// Multiplie une matrice 4*4 par une matrice 4*4.
void MatriceMultiplication_44_44 (double matrice_1 [16], double matrice_2 [16], double matrice_s [16]);


/********************************** FONCTIONS *********************************/

int WINAPI WinMain (HINSTANCE hThisInstance, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nFunsterStil)
{
    MSG messages;
    WNDCLASSEX wincl;
    HWND hwnd;

	hInstance = hThisInstance;
	
    wincl.cbSize = sizeof (WNDCLASSEX);
    wincl.style = CS_HREDRAW | CS_VREDRAW;
    wincl.lpfnWndProc = WindowMainProcedure;
    wincl.cbClsExtra = 0;
    wincl.cbWndExtra = 0;
    wincl.hInstance = hInstance;
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.hbrBackground = GetStockObject (BLACK_BRUSH);
    wincl.lpszMenuName = NULL;
    wincl.lpszClassName = "MainClass";
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);

    if (!RegisterClassEx (&wincl)){
		MessageBox (NULL, "Erreur dans l'enregistrement de la classe \"MainClass\".", 
			"Erreur", MB_OK | MB_ICONWARNING);
        return 0;}

    hwnd = CreateWindowEx (0, "MainClass", "Moteur 3D",
		WS_OVERLAPPEDWINDOW | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT,
		500, 300, HWND_DESKTOP, NULL, hInstance, NULL);

	if (!hwnd){
		MessageBox (NULL, "Erreur dans la création de la fenêtre.", 
			"Erreur", MB_OK | MB_ICONWARNING);
        return 0;}

    while (GetMessage (&messages, NULL, 0, 0))
    {
        DispatchMessage(&messages);
    }

	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpszArgument);
	UNREFERENCED_PARAMETER(nFunsterStil);
    return messages.wParam;
}




LRESULT CALLBACK WindowMainProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message) {
		case WM_CREATE:
			{
				long i, j, k;
				// Initialisation des points.
				for (i=0; i<5; i++){
					for (j=0; j<5; j++){
						for (k=0; k<5; k++){
grille [i*5*5*4 + j*5*4 + k*4] = 5 * i;
grille [i*5*5*4 + j*5*4 + k*4 + 1] = 5 * j;
grille [i*5*5*4 + j*5*4 + k*4 + 2] = 100 + (5 * k);// Calcul des coordonnées
grille [i*5*5*4 + j*5*4 + k*4 + 3] = 1;	// Tous ces points appatiennent à l'espace de
	// coordonnée w=1 dans l'espace homogène (on rajoute cette 4ème dimention pour utiliser les
	// propriétés d'une application linéaire avec la translation (application non linéaire))
						}
					}
				}
			}
			return 0;

		case WM_KEYDOWN:
		{
			BOOL modif = FALSE;
			
			switch (wParam){
				// translations avec les touche fléchées et Ctrl et Insert
				case VK_LEFT:
					TranslationCamera (X, lParam & 0xFFFF);
					modif = TRUE;
					break;

				case VK_RIGHT:
					TranslationCamera (X, -(lParam & 0xFFFF));
					modif = TRUE;
					break;

				case VK_UP:
					TranslationCamera (Y, -(lParam & 0xFFFF));
					modif = TRUE;
					break;

				case VK_DOWN:
					TranslationCamera (Y, lParam & 0xFFFF);
					modif = TRUE;
					break;

				case VK_CONTROL:
					TranslationCamera (Z, lParam & 0xFFFF);
					modif = TRUE;
					break;

				case VK_NUMPAD0:
					TranslationCamera (Z, -(lParam & 0xFFFF));
					modif = TRUE;
					break;

				// rotations avec q, d, z, s, CapsLock et f
				case 'Q':
					RotationCamera (Y, lParam & 0xFFFF);
					modif = TRUE;
					break;

				case 'D':
					RotationCamera (Y, -(lParam & 0xFFFF));
					modif = TRUE;
					break;

				case 'Z':
					RotationCamera (X, lParam & 0xFFFF);
					modif = TRUE;
					break;

				case 'S':
					RotationCamera (X, -(lParam & 0xFFFF));
					modif = TRUE;
					break;

				case VK_CAPITAL:
					RotationCamera (Z, lParam & 0xFFFF);
					modif = TRUE;
					break;

				case 'F':
					RotationCamera (Z, -(lParam & 0xFFFF));
					modif = TRUE;
					break;
			}
			
			if (modif == TRUE){
				// Demande à redessiner l'image.
				InvalidateRect (hwnd, NULL, TRUE);
			}
		}
			return 0;


		case WM_PAINT:
			ImageTraitement (hwnd);
			return 0;
			
        case WM_DESTROY:
            PostQuitMessage (0);       
            break;

        default:                   
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}




void ImageTraitement (HWND hwnd)
{
	HDC hdc;
	PAINTSTRUCT ps;
	RECT ClientRect;
	long i;
	double coord_3d [4];
	double coord_2d [2];

	GetClientRect (hwnd, &ClientRect);
	
	hdc = BeginPaint (hwnd, &ps);
	// Traitement des points un par un.
	for (i=0; i<5*5*5; i++){
		// Calcule les coordonnées du point dans la base caméra.
		MatriceMultiplication_14_44 (grille + (i*4), matrice_globale_camera, coord_3d);

		if (coord_3d [2] > 0){
			// Calcule les coordonnées dans le plan vituel (en mm).
			coord_2d [0] = distance_ecran * (coord_3d [0] / coord_3d [2]);
			coord_2d [1] = distance_ecran * (coord_3d [1] / coord_3d [2]);
			
			// Calcule les coordonnées dans le plan réel (en pixel)
			coord_2d [0] *= largeur_ecran_pixel / largeur_ecran_metrique;
			coord_2d [1] *= hauteur_ecran_pixel / hauteur_ecran_metrique;

			// Centre les cordonnées
			coord_2d [0] += ClientRect.right / 2;
			coord_2d [1] = (ClientRect.bottom / 2) - coord_2d [1];
			
			// Affiche le point
			SetPixel (hdc, (long)(coord_2d [0]), (long)(coord_2d [1]), 0x00FFFFFF);
		}
	}
	EndPaint (hwnd, &ps);
}


void TranslationCamera (long axe, double longueur)
{
	double matrice_translation [16]= {
		1, 0, 0, 0,
		0, 1, 0, 0,
		0, 0, 1, 0,
		0, 0, 0, 1};   // matrice identité
	double matrice_tampon [16];
	long i;

	// Calcule la matrice de translation
	matrice_translation [(axe * 4) + 3] = longueur * coefficient_translation;

	// Effectue la translation
	MatriceMultiplication_44_44 (matrice_globale_camera, matrice_translation, matrice_tampon);

	// Remplace la matrice de changement de base
	for (i=0; i<16; i++){
		matrice_globale_camera [i] = matrice_tampon [i];}
}


void RotationCamera (long axe, double angle)
{
	double matrice_rotation [16]= {
		1, 0, 0, 0,
		0, 1, 0, 0,
		0, 0, 1, 0,
		0, 0, 0, 1};   // matrice identité
	double matrice_tampon [16];
	double sinus, cosinus;
	long i;

	// Calcule la matrice de rotation
	sinus = sin (angle * coefficient_rotation / 1000);
	cosinus = cos (angle * coefficient_rotation / 1000);
	switch (axe) {
		case X:
			matrice_rotation [5] = matrice_rotation [10] = cosinus; 
				// i = (0; 1; 0); j = (0; 0; 1)
			matrice_rotation [6] = -sinus;
			matrice_rotation [9] = sinus;
			break;

		case Y:
			matrice_rotation [0] = matrice_rotation [10] = cosinus; 
				// i = (0; 0; 1); j = (1; 0; 0)
			matrice_rotation [8] = -sinus;
			matrice_rotation [2] = sinus;
			break;

		case Z:
			matrice_rotation [0] = matrice_rotation [5] = cosinus; 
				// i = (1; 0; 0); j = (0; 1; 0)
			matrice_rotation [1] = -sinus;
			matrice_rotation [4] = sinus;
			break;
	}

	// Effectue la rotation
	MatriceMultiplication_44_44 (matrice_globale_camera, matrice_rotation, matrice_tampon);

	// Remplace la matrice de changement de base
	for (i=0; i<16; i++){
		matrice_globale_camera [i] = matrice_tampon [i];}
}


void MatriceMultiplication_14_44 (double matrice_1 [4], double matrice_2 [16], double matrice_s [4])
{
	matrice_s [0] =
		(matrice_1 [0] * matrice_2 [0]) +
		(matrice_1 [1] * matrice_2 [1]) +
		(matrice_1 [2] * matrice_2 [2]) +
		(matrice_1 [3] * matrice_2 [3]);
	matrice_s [1] =
		(matrice_1 [0] * matrice_2 [4]) +
		(matrice_1 [1] * matrice_2 [5]) +
		(matrice_1 [2] * matrice_2 [6]) +
		(matrice_1 [3] * matrice_2 [7]);
	matrice_s [2] =
		(matrice_1 [0] * matrice_2 [8]) +
		(matrice_1 [1] * matrice_2 [9]) +
		(matrice_1 [2] * matrice_2 [10]) +
		(matrice_1 [3] * matrice_2 [11]);
	matrice_s [3] =
		(matrice_1 [0] * matrice_2 [12]) +
		(matrice_1 [1] * matrice_2 [13]) +
		(matrice_1 [2] * matrice_2 [14]) +
		(matrice_1 [3] * matrice_2 [15]);
}


void MatriceMultiplication_44_44 (double matrice_1 [16], double matrice_2 [16], double matrice_s [16])
{
	long i, j;
	
	for (j=0; j<16; j+=4){
		for (i=0; i<4; i++){
			matrice_s [j + i] =
				(matrice_1 [i] 		* matrice_2 [j]) 		+
				(matrice_1 [i + 4] 	* matrice_2 [j + 1])	+
				(matrice_1 [i + 8]	* matrice_2 [j + 2])	+
				(matrice_1 [i + 12]	* matrice_2 [j + 3]);
		}
	}
}

Télécharger le zip

11 novembre 2007 23:52:18 :

Faute d'orthographe; remise en forme.

11 novembre 2007 23:55:49 :

Correction de fautes d'orthographe; remise en forme