Red de conocimiento informático - Material del sitio web - ¿Cómo escribir software de cálculo de formas en lenguaje C?

¿Cómo escribir software de cálculo de formas en lenguaje C?

Aprenda MFC ~ ~ Su confusión se aliviará de inmediato ~ ~ ~

No es imposible editar la interfaz en lenguaje C puro ~~ Simplemente use la API de WINDOWS ~ ~ Le daré un fragmento de código para prueba ~ ~ Lo hice con el programa OPENGL ~ ~ Compilado en Visual STUDIO.NET 2003 ~ ~ El código es el siguiente ~ ~

# Definir WM _ Alternar pantalla completa (WM _ Usuario 1) //Definir completa mensaje de cambio de pantalla/ventana.

#Definir temporizador 1 101 //Defina el código del reloj y configúrelo en el número 101.

# definetitle "sombreado de color 5dg" //Define el título de la ventana.

#define CLASSNAME "5DG_OPENGL" //Define el nombre de la clase de ventana.

#Definir ancho 640 //Definir ancho de ventana.

#Definir altura 480 //Definir la altura de la ventana.

#Define BPP 16 //Define el número de bits por píxel.

#define NUM 200 //Define el número de vértices utilizados al dibujar un círculo (el círculo se aproxima mediante un segmento de línea compuesto de vértices).

//Cita aquí los archivos de encabezado requeridos por el programa:

# include ltwindows.h gt// Archivos de encabezado de Windows

# include ltgl\gl. h Archivo de encabezado de la biblioteca gtopengl32

# include ltgl \ glu.h Archivo de encabezado de la biblioteca gtGlu32

# include ltmath.h gt//Archivo de encabezado de la biblioteca de funciones matemáticas

//Agregue las bibliotecas requeridas por su programa al vinculador aquí:

# pragma comment (lib, "OpenGL32.lib") //Busque OpenGL 32.lib al vincular.

# pragmacomment (lib, "glu32.lib")//Busque Glu32.lib al vincular.

//Defina la estructura relacionada con la ventana aquí:

Typedef struct {//Defina la estructura para manejar el teclado.

BOOL keyDown[256]; //Matriz para almacenar el estado de las teclas del teclado.

}Clave;

Estructura Typedef {//Define la estructura utilizada para almacenar instancias de aplicaciones.

HINSTANCE hInstance//Instancia de aplicación

const char * className//Nombre de clase de aplicación

}Aplicación;

Estructura Typedef {/ /Definir la información requerida para inicializar la ventana.

Aplicación * aplicación; //La aplicación a la que pertenece

char * título//Título de la ventana

int ancho; >

int height; //alto de la ventana

int bitsPerPixel//bits por píxel

BOOL es isFullScreen//pantalla completa o no

} GL _ WindowInit

Typedef struct {//Define la estructura de la ventana.

Tecla * tecla; //Teclado

HWND hWnd//Manija de ventana

HDC hDC//Tabla de descripción del dispositivo

HGLRC hRC //Tabla de descripción del dibujo

GL _ WindowInit init//Estructura que proporciona información de inicialización de la ventana

} GL _ windows;

//Este módulo de código contiene Forward declaración de la función:

BOOL Inicializar(GL_Window * Window, Keys * Keys //Establecer el valor de inicialización antes de dibujar).

void DrawSceneGL(void); //Termina de dibujar la escena aquí.

void update (void); //Actualiza el funcionamiento del mensaje aquí

void deinitialization (void); //Haz el trabajo final antes de salir aquí

//Defina variables globales aquí:

GL_Window * OGL_windows;//Información de la ventana de almacenamiento

Keith* OGL_Keith; //Contraseña de almacenamiento Información clave

// Defina las variables de usuario aquí:

Void resizewindowgl (int width, int height)//Cambie el tamaño de la ventana.

{

glViewport(0, 0, (GLsizei) (ancho), (GLsizei) (alto)); //Restablecer el tamaño de la ventana gráfica actual

glMatrixMode(GL _ PROJECTION); //Cambiar al modo de matriz de proyección

glload identidad(); //Restablecer matriz de proyección

gluPerspective(45, (float)width/( float) height, 0.1, 100); //Establecer proyección en perspectiva

glMatrixMode(GL_model view); //Cambiar a la matriz de vista del modelo

glload identidad();

}

boolchangscreenssolving(int width, int height, int bitsperpixel)//Modifica la resolución de la pantalla.

{

DEVMODE dmScreenSettings//Modo de configuración del dispositivo

memoria cero(amp; dmScreenSettings, sizeof(DEVMODE));//Vacío

Configuración de pantalla DM. Tamaño DM = sizeof(DEVMODE); el tamaño de la estructura del modo de desarrollo

dmscreensettings. dmpelsheheight; = altura; //Establecer la altura de la pantalla

Configuración de pantalla DM. dmbitsperpel = bitsPerPixel; //Establecer la longitud de bits especificada;

Configuración de pantalla DM = DM _ BITSPERPEL. | DM _ pels width | DM _ pels height;

//Intenta configurar el modo de visualización y devolver el resultado.

Nota: CDS_FULLSCREEN elimina la barra de estado.

if(ChangeDisplaySettings(amp;dmScreenSettings,CDS_FULLSCREEN)!= DISP_change_success)

{

Devuelve FALSE // La modificación de la resolución falla y devuelve False.

}

Devuelve TRUE//Analiza y modifica correctamente, devuelve True

}

Bool crea la ventana GL (GL _ ventana * window )//Crear una ventana OpenGL.

{

Estilo de ventana DWORD = WS _ ventana superpuesta; //Establecer el estilo de la ventana

Ventana DWORDExtendedStyle = WS _ EX _ ventana de la aplicación; la ventana Estilo extendido

PIXELFORMATDESCRIPTOR pfd = //Configuración del descriptor de formato de píxel (pfd)

{

(tamaño del descriptor de formato de píxel), //tamaño de píxel.

1, //Número de versión

PFD_DRAW_TO_WINDOW | // pfd debe admitir el dibujo de ventanas.

PFD_SUPPORT_OPENGL | // pfd debe ser compatible con OPENGL.

PFD_DOUBLEBUFFER, // pfd debe admitir doble almacenamiento en búfer.

PFD_TYPE_RGBA, //El formato de píxel es RGBA.

Ventana->Init.bitsPerPixel, //Establece la profundidad del color.

0, 0, 0, 0, 0, 0, // Ignora el número de bits de color.

0, //Sin caché Alpha

0, //Ignora el bit de desplazamiento.

0, //Sin caché acumulado

0, 0, 0, 0, //Ignora los bits de caché acumulados.

16, //La profundidad del caché es de 16 bits.

0, //Sin caché de plantilla

0, //Sin caché auxiliar

PFD_MAIN_PLANE, //Capa de dibujo principal

0 , //Bits reservados

0, 0, 0 //Ignorar máscara de capa

};

RECT windowRect = {0, 0, window- gt; inicializar ancho, ventana - gt; init height }; // Definir el tamaño de la ventana

GLuint PixelFormat // Guardar el formato de píxeles.

If (Window->Init.isFullScreen == TRUE) //Cambiar a pantalla completa.

{

if(cambiar resolución de pantalla(ventana-gt; ancho de inicialización, ventana-gt; init.height, ventana-gt; init.bitsPerPixel) == FALSO)

{

//Falló el cambio de pantalla completa.

MessageBox(HWND_DESKTOP, "No se puede cambiar al modo de pantalla completa y ejecutar en modo de ventana. \nError al cambiar de modo, se ejecuta en modo de ventana., "Error", MB_OK | MB_icon excluido);

Ventana->;init.es pantalla completa = FALSE //Establece isFullscreen en False.

}

De lo contrario //Cambio de pantalla completa exitoso.

{

show cursor(FALSE); //Ocultar el mouse

windowStyle = WS _ POPUP //Establecer el estilo de la ventana

windowExtendedStyle | = WS _ EX _ TOPMOST; //Establecer estilo de extensión de ventana

}

}

Otros

{

//Cambie el tamaño de la ventana, incluidos los bordes de la ventana.

AdjustWindowRectEx(amp; windowRect, windowStyle, 0, windowExtendedStyle);

}

//Comience a crear la ventana OpenGL.

Ventana->hwnd = createwindowex(windowextendedstyle, //Estilo extendido de ventana.

Ventana->init.application-gt; nombre de clase, //Nombre de clase de aplicación

Ventana->;Init.title, //Título de la ventana

WindowStyle, //Estilo de la ventana

0, 0, //Coordenadas X, Y de la posición de la ventana.

Ventana derecha-Ventana izquierda, // ancho de la ventana

ventana inferior rect . , //La ventana principal es el escritorio.

0, //Sin menú

Ventana->init.application-gt;HInstance, //La instancia de la aplicación pasada.

Ventana);

If (Window->HWnd == 0) //¿La ventana se creó correctamente?

{

Devuelve FALSO // Si falla, devuelve FALSO.

}

Window->;hDC = GetDC(window- gt;hWnd); //Obtiene la tabla de descripción del dispositivo de la ventana actual.

if(Window->HDC == 0) //Si no se obtiene el contexto del dispositivo,

{

DestroyWindow(Window->hWnd) ; //Destruye la ventana

Window->;hWnd = 0;//El identificador de la ventana se borra

Return FALSE //Return FALSE

}

Formato de píxeles = ChoosePixelFormat(window-gt;hDC amp;pfd); //Elija un formato de píxeles compatible.

If (PixelFormat == 0) //Si la selección falla,

{

ReleaseDC(Window-gt; Window-gt; hDC); Liberar contexto del dispositivo

Ventana->;hDC = 0; //Borrar el contexto del dispositivo.

DestroyWindow(window-gt;hWnd); //Destruye la ventana

Window->;hWnd = 0; //El identificador de la ventana se borra

Regresar FALSE //Devuelve FALSE

}

if(SetPixelFormat(window- gt; hDC, formato de píxel y. Pfd) == FALSE) //Establece el formato de píxel y determina si falló.

{

ReleaseDC(window-gt;window-gt;hDC); //Liberar contexto del dispositivo

Ventana->;hDC = 0;/ / Borre la tabla de contexto del dispositivo.

DestroyWindow(window-gt;hWnd); //Destruye la ventana

Window->;hWnd = 0; //El identificador de la ventana se borra

Regresar FALSE //Regresar FALSE

}

Window->;hRC = wglCreateContext(Window-gt;hDC); //Obtener la tabla de contexto del dibujo

if (ventana ->;HRC == 0) //Si no se obtiene el contexto del dibujo,

{

ReleaseDC(Window-gt;Window-gt;hDC); Liberar la tabla de descripción del dispositivo

Window->hDC = 0; //Borrar la tabla de descripción del dispositivo a cero.

DestroyWindow(window-gt;hWnd); //Destruye la ventana

Window->;hWnd = 0; //El identificador de la ventana se borra

Regresar FALSE //Devuelve FALSE

}

if(wglMakeCurrent(window- gt; hDC, window- gt; HRC) == FALSE) //Establece la tabla de descripción del dibujo y determina si falló.

{

wglDeleteContext(Window-gt; hRC); //Eliminar la tabla de descripción del dibujo

Window->; //Eliminar el tabla de descripción del dibujo La tabla está borrada.

ReleaseDC(Window-gt; Window-gt; hDC); //Liberar la tabla de descripción del dispositivo

Window-> //Borrar la tabla de descripción del dispositivo.

DestroyWindow(window-gt;hWnd); //Destruye la ventana

Window->;hWnd = 0; //El identificador de la ventana se borra

Regresar FALSE //Regresar FALSE

}

ShowWindow(window-gt; hWnd, SW _ NORMAL); //Mostrar ventana

cambiar el tamaño de la ventana GL(window- gt; inicializar ancho, ventana - gt; init altura); // restablecer ventana

memoria cero (ventana - gt; teclas, tamaño de(Teclas)); p>Return TRUE//La ventana se creó correctamente.

}

Bool destruir ventana GL (GL _ ventana * ventana) // Destruye la ventana y libera los recursos utilizados por el programa.

{

If (window -> hWnd != 0) // ¿La ventana tiene un identificador?

{

if (window->hDC != 0) //¿La ventana obtiene el contexto del dibujo?

{

wglMakeCurrent(window-gt; hDC, 0); //Establece el puntero de la tabla de descripción actual en 0.

if (ventana->hRC!= 0) //¿La ventana tiene una tabla de contexto de dibujo?

{

wglDeleteContext(window-gt;hRC); //Publicar la tabla de descripción del dibujo

Window->;hRC = 0; tabla de descripción del dibujo La tabla está borrada.

}

ReleaseDC(window-gt;window-gt;hDC); //Liberar contexto del dispositivo

Ventana->;hDC = 0;/ / Borre la tabla de contexto del dispositivo.

}

DestroyWindow(window-gt;hWnd); //Destruye la ventana

Window->;hWnd = 0; //Borrar el identificador de la ventana .

}

If (Window->Init.isFullScreen) //Si la ventana está en modo de pantalla completa,

{

ChangeDisplaySettings( NULL, 0); //Cambiar a la resolución del escritorio

show cursor(TRUE); //Mostrar mouse

}

Devolver TRUE // Devuelve VERDADERO

}

Proceso de ventana de devolución de llamada de resultado (hwnd hwnd, uintumsg, wparam wparam, lparam lparam)//procesamiento de mensajes de ventana

{

GL _ Window * Window =(GL _ Window *)(GetWindowLong(hWnd, GWL _user data)); //Obtener información de la ventana

Switch (uMsg) //Obtener el mensaje de la ventana.

{

Caso WM_SYSCOMMAND: //Intercepta comandos del sistema.

{

Switch (wParam) //Escuche la llamada del sistema

{

Caso SC_SCREENSAVE: //¿Quieres ejecutar el salvapantallas?

Caso SC_MONITORPOWER: //¿El monitor entra en modo de ahorro de energía?

Return 0; //Devuelve 0 por adelantado para evitar que se ejecuten llamadas al sistema.

}

Break; //Salir

}

Caso WM_CREATE: //Crear una ventana

{

crear estructura * creación =(crear estructura *)(lParam); //Guardar puntero de estructura de ventana

ventana = (GL_Window*)(create-gt;lpCreateParams);

SetWindowLong(hWnd, GWL_UserData, (Long)(Window)); //Cambiar propiedades de la ventana

Return 0 //Return

}

Caso WM_TIMER: // Evento TIMER

{

Montaje no válido (Ventana - gt; hWnd, NULL, FALSE); // Invalidar ventana

Break;

}

Caso WM_PAINT: // Procesamiento de mensajes PAINT, dibujando aquí.

{

DrawSceneGL(); //Dibujar aquí

SwapBuffers(window-gt; hDC); //Intercambiar buffers

ValidateRect(window - gt; hWnd, NULL); // Validar la ventana

Break;

}

Case WM_CLOSE: //Cerrar la ventana.

{

PostMessage(window-gt; hWnd, WM_QUIT, 0, 0); //Finalizar programa

Devuelve 0;

}

Case WM_SIZE: //Cambio de tamaño de la ventana

{

ResizeWindowGL(LOWORD(lParam), hi word(lParam) //Cambiar el tamaño de la ventana. ventana El tamaño se modifica a Ancho = LoWord, Alto = HiWord.

Return 0; //Return

}

Case WM_KEYDOWN: //Actualiza el buffer del teclado cuando se presiona una tecla.

if((wParam gt;= 0) amp; amp(wParam lt= 255)) //¿La clave es legal?

{

Ventana->; Key-gt; keyDown[wParam] = TRUE; // Establece la clave correspondiente en True.

Return 0; //Regresar

}

Break; //Salir

Case WM_KEYUP: //Actualiza el teclado cuando el La clave se libera del búfer.

if((wParam gt;= 0) amp; amp(wParam lt= 255)) //¿La clave es legal?

{

Window->; Key-gt; keyDown[wParam] = FALSE; //Establece la clave correspondiente en FALSE.

Return 0; //Return

}

Break; //Salir

Case WM_TOGGLEFULLSCREEN: //Cambiar modo de pantalla completa.

{

de inicialize(); //Hacer el trabajo final

DestroyWindowGL(window); //Destruir la ventana

Ventana - > init.isFullScreen =! ventana -> init es pantalla completa; //Cambiar modo de ventana

CreateWindowGL(ventana); //Recrear ventana

Initialize(ventana, ventana->clave); el programa de dibujo OpenGL

Break; //Salir

}

Valor predeterminado:

Break;

}

Return DefWindowProc(hWnd, uMsg, wParam, lParam); // Pasa los mensajes que no son procesados ​​por este programa a DefWindowProc.

}

BoolRegisterWindowClass(aplicación * aplicación)//Registra una clase para esta aplicación.

{

WNDCLASSEX windowClass//Clase de ventana

memoria cero(amp; windowClass, sizeof(WNDCLASSEX));//Borrar memoria

clase de ventana. CB size = sizeof(WNDCLASSEX); //El tamaño de la clase de ventana

estilo de ventana = CS _ HREDRAW | CS _ VREDRAW | CS _ own DC; la ventana se mueve y se vuelve a dibujar al cambiar el tamaño.

clase de ventana. lpfnwndproc =(WNDPROC)(window proc); //Utiliza la función WindowProc para procesar mensajes.

clase de ventana. h instancia = aplicación-gt; hInstance//Establecer instancia

clase de ventana HBR background = (HBRUSH)(COLOR _ espacio de trabajo de la aplicación); color

clase de ventana. hcursor = cargar cursor(NULL, IDC _ ARROW); //Cargar puntero del mouse

nombre de clase lpsz = nombre de clase de aplicación; /Establece el nombre de clase de la aplicación.

if(register classex( amp; WindowClass) == 0) // ¿No se pudo registrar la clase?

{

MessageBox(HWND_DESKTOP, "¡Error en el registro de la clase de aplicación! \n¡Error en RegisterClassEx!, "Error", MB_OK | excepción MB_icon);

Devuelve FALSO/ /Return False (registro fallido)

}

Return TRUE//Return True (registro exitoso)

}

int WINAPI WinMain (instancia h instancia h, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)

{

Aplicación de aplicación // aplicación

GL_Window Window<; /p>

Tecla clave; //Teclas del teclado

MSG MSG; //Mensaje de ventana

Bull Brett; //Si el guardado se realizó correctamente Recibe el mensaje. p>

//Asignar valor a la aplicación

aplicación. nombre de clase = nombre de clase; // nombre de clase del programa

aplicación. entrada

//Configuración de información relacionada con la ventana

zero Memory(amp; window, sizeof(GL _ Window)); //Borrar el espacio de memoria de la variable de ventana < /p. >

window.keys = amp key; //Establece la clave

window .init application = Aplicación; //Establece el programa de ventana

window . TITLE; //Establecer título

window.init.width =Width; //Establecer ancho de ventana

init .

window.init.bitsperpixel = BPP; //Establece el número de bits por píxel

window es pantalla completa = FALSE;

zero Memory(amp;keys,sizeof(Keys));//Se borra el búfer del teclado.

if(RegisterWindowClass( amp; Application) == FALSE) //¿Falló el registro de la clase?

{

MessageBox(HWND_DESKTOP, "¡Error en el registro de la clase de ventana!\n¡Error al registrar la clase de ventana!", "Error", MB_OK | excepción MB_icon);

return-1; //Finalizar programa

}

if(CreateWindowGL(amp; Window) == TRUE) //¿Se creó la ventana correctamente?

{

If (initialization(amp window ampKeys) == FALSE) //Inicializa el programa de dibujo OpenGL.

{

PostMessage(window.hWnd, WM_QUIT, 0, 0); //Lanzar mensaje WM_QUIT

}

}

Otros

{

Devuelve 0; //Salir del programa

}

while((bRet = GetMessage(amp;msg,NULL,0,0)! = 0)) // Bucle hasta que el mensaje recibido sea WM_QUIT.

{

If (bRet!= -1)

{

update(); //Actualizar evento de mensaje de procesamiento

p>

Traducir mensaje(amp;MSG); //entregar mensaje

mensaje de envío(amp;MSG); //mensaje de envío

}

Otros

{

Romper; //Salir del bucle

}

}

//Salga del bucle de mensajes, prepárese para salir del programa.

de inicialize(); //Realiza el trabajo final antes de salir.

DestroyWindowGL(amp; window); //Destruye la ventana

unregister class(application. class name, application. hinstance); //Anula el registro de la clase de ventana

Return 0; //Salir del programa

}

bool inicializar(GL _ ventana * ventana, teclas * teclas) // Se definen las funciones relacionadas con las escenas dibujadas por el usuario aquí.

{

//Establecer variables globales

OGL _window=window;

OGL _case=case;

p>

//Crear reloj

SetTimer(Window-gt; hWnd, TIMER1, 33, NULL);

//Inicializa la escena de dibujo aquí

glClearColor(0.0f, 0.0f, 0.0f, 0.5f); //Borrar la pantalla negra.

glClearDepth(1.0f); //Establece el caché de profundidad

glDepthFunc(GL_le qual); //Selecciona el método de prueba de profundidad.

glen able(GL_DEPTH_TEST); //Iniciar prueba de profundidad

glShadeModel(GL_SMOOTH); //El sombreado se realiza de forma fluida.

GL HINT(GL _ PERSPECTIVE _ CORRECTION _ HINT, GL _ NICEST); //El cálculo de perspectiva más refinado

Devuelve TRUE //Si la inicialización es exitosa, devuelve TRUE.

}

Void DrawSceneGL(void) //Dibuja la escena

{

GL clear(GL _ COLOR _ BUFFER _ BIT | GL_DEPTH_BUFFER_BIT);//Borrar el caché de color y profundidad

glload Identity();//Restablecer la matriz actual

//Agregar aquí para dibujar Código:

glShadeModel(GL_SMOOTH); //El suavizado se utiliza para sombrear.

glTranslatef(-1.5f, 1.0f, -6.0f); //El origen de las coordenadas se mueve 1.5f hacia la izquierda, 1.0f hacia arriba y 6.0f hacia adentro.

GL comenzar(GL _ TRIANGLES); //Comienza a dibujar triángulos.

glColor3ub(255, 0, 0); //El vértice superior se define como rojo.

glVertex3f(0.0f, 1.0f, 0.0f); //Dibuja el vértice superior

glColor3ub(0, 255, 0); //Define el vértice inferior izquierdo como verde. .

glVertex3f(-1.0f,-1.0f,0.0f); //Dibuja el vértice inferior izquierdo

glColor3ub(255, 255, 0); //Define el vértice inferior derecho; vértice como amarillo.

glVertex3f(1.0f, -1.0f, 0.0f); //Dibuja el vértice en la esquina inferior derecha

glEnd();

glTranslatef( 3.0f, 0.0f, 0.0f); //Traduce 3.0f a la derecha

glColor3ub(0, 255, 255); //Define el color del cuadrado.

GL comenzar(GL _ QUADS); //Comienza a dibujar un cuadrado.

glVertex3f(-1.0f, 1.0f, 0.0f); //Dibuja el vértice superior izquierdo

glVertex3f(-1.0f, -1.0f, 0.0f); En Dibujar vértices en la esquina inferior izquierda

glVertex3f(1.0f, -1.0f, 0.0f); //Dibujar vértices en la esquina inferior derecha

glVertex3f(1.0f, 1.0) f, 0.0f); //Dibuja el vértice en la esquina superior derecha

glEnd();

glTranslatef(-1.5f, -2.0f, 0.0f); Mueve 1.5f hacia la izquierda, baja 2.0f

glColor3f(0.0f, 0.8f, 0.2f); //Verde

GL comenzar(GL _ LINE _ LOOP); //Dibuja un círculo

for(int I = 0; iltNUMi)

{

glVertex3f(1.5f*(punto flotante)sin(2.0f* 3.14f*i/NUM), 0.0f, 1.5f* (punto flotante) cos (2.0f * 3.14f * I/NUM));

}

glEnd() ;

GL flush(); //Actualiza la cola de comandos GL

}

Void Update(void) //Actualiza el funcionamiento del mensaje aquí.

{

If (tecla OGL - gt; KeyDown[VK_ESCAPE] == TRUE) // Determina si se presionó la tecla ESC.

{

PostMessage(OGL window-gt; hWnd, WM_QUIT, 0, 0); //Finalizar programa

}

If (tecla OGL - gt; KeyDown[VK_F1] == TRUE) //Determina si se presiona F1.

{

PostMessage(ventana OGL - gt; hWnd, WM_TOGGLEFULLSCREEN, 0, 0); // Cambiar entre modo de pantalla completa/ventana.

}

}

Void Deinitialize(void) //Haga el trabajo final antes de salir aquí.

{

KillTimer(ventana OGL - gt; hWnd, temporizador 1); //Suelta el reloj

}