¿Cómo escribir software de cálculo de formas en lenguaje C?
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
}