Redmi Note 8

Redmi Note 8 y Redmi Note 8 Pro:  64 megapíxeles de la mano de la cuádruple cámara trasera

El nuevo redmi 8 presentado por la familia de "xiaomi" viene con Sistema operativo: Android,Tamaño de pantalla:6,3" en cuanto diseño tiene Alto:158,3 mm,Ancho:75,3 mm,Grosor:8,4 mm,Peso:190 g,Lector de huellas:SI -Trasero, y en Colores:Verde, Azul.

En cuanto a las Cámaras tenemos:

Cámara principal: Resolución: 48 MP,Apertura:f/1.8,Flash: Flash LED,Vídeo: UHD 4K

Cámara dual: Resolución: 8.0,Apertura:f/2.2

Cámara frontal: Resolución: 13.0,Apertura:f/2.0,Vídeo:Full HD 1080p

La batería viene con una capacidad de 4.000 mAh algo bastante bueno y que se destaca en un buen celular y a la cual ya estamos acostumbradas en la familia redmi, la batería es interna osea que no se puede extraer y viene con carga rapida de: Power Delivery 18W.

Bueno pasando al apartado de conectividad este móvil viene con USB: tipo C algo que se destaca a diferencia de sus hermanos menores o anteriores y tambien cuenta con un jack de audífonos, en la parte delantera viene con un sensor  de proximidad y de luz. Acepta tarjeta nano SIM y tiene compatibilidad con redes 4G algo seria su punto mas debil ya que se espera al ser un móvil de gama alta una conectividad de 5G a pesar que esta tecnología aun no se a aplicado en todas partes del mundo y solo algunos países la cuentan ,pero de todas maneras para este punto ya se esperaba una conectividad de 5G para este movil.

Read More

Películas Gratis

Hola aquí les traigo un tutorial de un sitio web donde pueden ver películas en alta definición  y audio latino..

Y lo mejor es que son películas en estreno y totalmente gratis no necesita registrarse ni usar ningún medio de pago..

Read More

iPhone 11

iPhone 11

Amor a primera, segunda, tercera, cuarta, quinta y sexta vista. Así es como apple decidió denominar a su nuevo teléfono que busca marcar un hito en los móviles. 

"Un sistema de dos cámaras para capturar más de lo que te gusta. El chip más rápido en un smartphone y una batería que dura todo el día para cargarlo menos y usarlo más. Y la máxima calidad de video en un smartphone para que tus recuerdos se vean espectaculares. El iPhone 11 lo tiene todo." Eso es todo lo que dijo apple en su presentación.

El nuevo iPhone 11 viene en seis variantes de color: púrpura, amarillo, verde, negro, blanco y producto ROJO.

Las dimensiones del iPhone 11 son 150.9 mm x 75.7 mm x 8.3 mm (H x W x D). Pesa alrededor de 194 gramos (6.84 onzas). Cuenta con una pantalla LCD de pantalla completa de 6.1 pulgadas y está alimentado por el nuevo chip biónico A13 de Apple con motor neuronal de tercera generación. La pantalla es la pantalla Liquid Retina HD patentada de la compañía que tiene capacidad Multi-Touch con tecnología IPS.

La resolución es de 1792x828 píxeles uno a 326 ppi con una relación de contraste de 1400: 1 (típica). Otras características especiales de la pantalla son True Tone, Wide color (P3) y Haptic touch. Viene recubierto con un recubrimiento oleofóbico resistente a huellas dactilares. 

En cuanto al segmento de la cámara, el iPhone 11 viene equipado con una cámara trasera doble de lente ancha de seis elementos de 12 MP y una lente ultra ancha de cinco elementos. La lente Ultra Wide viene con una apertura de ƒ / 2.4 y un campo de visión de 120 °, mientras que la cámara Wide tiene una apertura de ƒ / 1.8. El iPhone 11, junto con los otros dos modelos, tiene un modo nocturno para hacer clic en mejores imágenes en condiciones de poca luz. Algunas de las otras características de la cámara trasera son 2x de zoom óptico; zoom digital de hasta 5x, modo vertical con bokeh avanzado y control de profundidad, iluminación vertical con seis efectos, estabilización óptica de imagen (gran angular).

Ademas Apple ha actualizado la cámara selfie en los tres modelos de iPhones, desde una cámara de 7MP de profundidad real a un sensor TrueDepth de 12MP con apertura de ƒ / 2.2. Algunas de las otras características de la cámara frontal son el modo vertical con bokeh avanzado y control de profundidad, iluminación vertical con seis efectos, grabación de video 4K a 24 fps, 30 fps o 60 fps, grabación de video HD 1080p a 30 fps o 60 fps, etc.

En el apartado de los diversos sensores son Face ID, barómetro, giroscopio de tres ejes, acelerómetro, sensor de proximidad y sensor de luz ambiental para un reconocimiento facial avanzado. El iPhone 11 viene en tres variantes de almacenamiento: 64 GB, 128 GB y 256 GB.

créditos: Isa Marcial

  

Read More

Pixel 4

GOOGLE PIXEL 4 Y 4 XL: LO NUEVO DE GOOGLE CON LO CUAL ESPERA HACERLE LA COMPETENCIA A HUAWEI Y SANSUNG

Los últimos teléfonos inteligentes de Google están finalmente, realmente, oficialmente aquí: la compañía acaba de anunciar los Pixel 4 y Pixel 4 XL en su evento de hardware en la ciudad de Nueva York.

El Pixel 4 viene en tres nuevos colores: blanco, negro y una opción naranja de edición limitada.

El Pixel 4 XL tiene una pantalla Quad HD de 6.3 pulgadas, mientras que la pantalla del Pixel 4 de 5.7 pulgadas es 1080p. Ambos cuentan con una frecuencia de actualización máxima de 90Hz para un desplazamiento y una respuesta ultra suaves, pero la frecuencia de actualización se ajusta automáticamente a los 60Hz habituales en algunas circunstancias (donde ni siquiera lo notarías) para optimizar la duración de la batería.

Además del tamaño de la pantalla y la capacidad de la batería, los dos nuevos píxeles ofrecen especificaciones de hardware idénticas. Están alimentados por el procesador Snapdragon 855 de Qualcomm, vienen con 64 GB o 128 GB de almacenamiento y tienen 6 GB de RAM.

En el área del bisel superior del Pixel 4, Google ha alojado una serie de sensores que permiten dos nuevas funciones. Uno es el propio sistema de desbloqueo facial de Google, que es la respuesta de la compañía al Face ID de Apple. El otro es un nuevo método de interacción llamado Motion Sense. Esto permite que el Pixel 4 se controle con gestos con las manos, sin necesidad de tocar el teléfono. Motion Sense utiliza la tecnología Project Soli de Google. Con Motion Sense, puede hacer cosas como controlar la música o descartar una llamada entrante con un movimiento de su mano cerca de la pantalla del teléfono. El procesamiento de Motion Sense se realiza localmente en el dispositivo, y Google señaló que la función se puede desactivar en cualquier momento.

Read More

Huawei mate 30

Huawei Mate 30 Pro: el primer celular de Huawei con Android a medias estrena su cuádruple cámara y pantalla súper curvada y un reconocimiento facial avanzado 

El teléfono inteligente Huawei Mate 30 Pro se ejecuta en el sistema operativo Android v10 (Q). El teléfono funciona con procesador Octa core (2.86 GHz, Dual core, Cortex A76 + 2.09 GHz, Dual core, Cortex A76 + 1.86 GHz, Quad core, Cortex A55). Se ejecuta en el chipset HiSilicon Kirin 990. Tiene 8 GB de RAM y 256 GB de almacenamiento interno.

Y también  tiene una pantalla OLED. Mide 158.1 mm x 73.1 mm x 8.8 mm y pesa 198 gramos. La pantalla tiene una resolución de 1176 x 2400 píxeles y 409 ppi de densidad de píxeles. Tiene una relación de aspecto de 18.4: 9 y una relación pantalla-cuerpo de 94.06%. En el frente de la cámara, los compradores obtienen una cámara frontal de 32 MP y en la parte trasera, hay una cámara de 40MP + 40MP + 8MP con características como 30 x Zoom digital, 3 x Zoom óptico, Flash automático, Detección de rostros, Toque para enfocar. Está respaldado por una batería de 4500 mAh. Las características de conectividad en el teléfono inteligente incluyen WiFi, Bluetooth, GPS, Volte, NFC y más.

En cuanto a las opciones de color, el teléfono inteligente Huawei Mate 30 Pro puede venir en colores negro, verde esmeralda, plata espacial y púrpura cósmico.

A continuación el Review para mayor detalle.

Creditos: Isa Marcial

Read More

cubo de Colores en Ejes OPenGL

====Codigo==========
#include <windows.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <stdlib.h>

static void display(void)
{
    glClearColor(0,0,0,1);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glShadeModel(GL_FLAT);
    glLineStipple(1, 0x00FF);
    glEnable(GL_LINE_STIPPLE);

    glBegin(GL_LINES);
    {
//EJE X ROJO
        glColor3f(1.0,0.0,0.0);
        glVertex3f(-0.7,0.3,0.0);
        glVertex3f(0.7,-0.3,0.0);
//EJE Y VERDE
        glColor3f(0.0,1.0,0.0);
        glVertex3f(0.0,-0.7,0.0);
        glVertex3f(0.0,0.7,0.0);
//EJE Z AZUL
        glColor3f(0.0,0.0,1.0);
        glVertex3f(-0.7,-0.4,0.0);
        glVertex3f(0.7,0.4,0.0);
    }
    glEnd();

    //CUBO SOLIDO
    glPushMatrix();
        glColor3f(1.0,1.0,0.0);
        glRotatef(120.0,9.0,-12.0,0.0);
        glutSolidCube(0.3);
    glPopMatrix();

    //ESFERA VERDE SOLIDO
    glPushMatrix();
        glColor3f(0.0,1.0,0.0);
        glTranslatef(0.0,-0.33,0.0);
        glutSolidSphere(0.08,16,16);
    glPopMatrix();

    //ESFERA ROJO SOLIDO
    glPushMatrix();
        glColor3f(1.0,0.0,0.0);
        glTranslatef(-0.29,0.13,0.0);
        glutSolidSphere(0.08,16,16);
    glPopMatrix();

    //ESFERA AZUL SOLIDO
    glPushMatrix();
        glColor3f(0.0,0.0,1.0);
        glTranslatef(0.28,0.15,0.0);
        glutSolidSphere(0.08,16,16);
    glPopMatrix();

    //TORO VERDE
    glPushMatrix();
        glColor3f(0.0,1.0,0.0);
        glTranslatef(0.009,0.6,0.0);
        glRotatef(-60,-0.0001,0.003,0.0);
        glutSolidTorus(0.05,0.18,16,16);
    glPushMatrix();

    //TORO ROJO
    glPushMatrix();
        glColor3f(1.0,0.0,0.0);
        glTranslatef(1.03,-0.81,0.0);
        glRotatef(60,0.015,0.009,0.0);
        glutSolidTorus(0.05,0.18,16,16);
    glPushMatrix();

    //TORO AZUL
    glPushMatrix();
        glColor3f(0.0,0.0,1.0);
        glTranslatef(-1.05,0.3,0.0);
        glRotatef(-50,-0.00005,0.4,0.0);
        glutSolidTorus(0.06,0.14,12,12);
    glPushMatrix();

    glutSwapBuffers();
}

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowSize(512,512);
    glutInitWindowPosition(20,20);
    glutCreateWindow("Plano Cartesiano");

    glutDisplayFunc(display);

    glutMainLoop();
    return EXIT_SUCCESS;
}

Read More

CLISP Ejercicios IA

Hola aquí les dejo algunos ejercicios en  GNU CLISP

LINK DE DESCARGA DE ARCHIVO   https://drive.google.com/file/d/14E_i0gUpCmcgwNYvKg_74JpLSwHhZXjc/view?usp=sharing

Read More

Iniciales 2D OpenGL

Hola aquí les traigo las iniciales en 2D

====código=====
#include <windows.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

#include <stdlib.h>


static void display(void)
{
    glClearColor(1,1,1,0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    typedef GLfloat point2[2];
      point2 vertice[54] = {
      {100.0,100.0},    //v0
      {200.0,100.0},    //v1
      {320.0,400.0},    //v2
      {250.0,400.0},    //v3

      {200.0,300.0},    //v4
      {150.0,400.0},    //v5
      {80.0,400.0},    //v6
      {150.0,200.0},    //v7

      {100.0,380.0},    //v8
      {180.0,320.0},    //v9
      {40.0,350.0},    //v10
      {100.0,200.0},    //v11
      {50.0,130.0}, //v12

      //vertices para la letra s

      {400.0,100.0},    //v13
      {700.0,100.0},    //v14
      {700.0,260.0},    //v15
      {500.0,260.0},    //v16
      {500.0,320.0},   //v17
      {700.0,320.0},    //v18
      {700.0,370.0},    //v19
      {400.0,370.0},    //v20
      {400.0,210.0},    //v21
      {600.0,210.0},   //v22
      {600.0,150.0},    //v23
      {400.0,150.0},    //v24
      //FONDO
      {500.0,400.0},   //v25
      {750.0,400.0},    //v26
      {750.0,350.0},    //v27
      {580.0,280.0},   //v28
      {750.0,280.0},    //v29
      {750.0,150.0},    //v30
      {580.0,320.0},   //v31
      {480.0,180.0},    //v32
      {600.0,180.0},   //v33

      //Letra Q

      {880.0,370.0},    //v34
      {1400.0,370.0},   //35

      {880.0,330.0},   //v36
      {1400.0,330.0},    //v37

      {1100.0,330},   //v38
      {1250.0,330},    //v39  --

      {1100.0,180},   //v40
      {1250.0,100},    //v41--

      {880.0,100},   //42
      {880.0,180},    //v43

      //FONDO
      {780.0,390.0},    //V44
      {1300.0,390.0},   //V45

      {780.0,350.0},   //V46
      {780.0,200.0},    //V47

      {1000.0,330},   //V48  ---
      {1000.0,200},    //V49

      {780.0,150},   //V50



      };

    glColor3f(0.0,0.0,1.0);
    gluOrtho2D(0.0, 1800.0, 0.0, 500.0);



    //Letra S

    glColor3f(1.0,0.0,0.0);
  glBegin(GL_LINES);

  glVertex2fv(vertice[13]);
  glVertex2fv(vertice[14]);

  glVertex2fv(vertice[14]);
  glVertex2fv(vertice[15]);

  glVertex2fv(vertice[15]);
  glVertex2fv(vertice[16]);

  glVertex2fv(vertice[16]);
  glVertex2fv(vertice[17]);

  glVertex2fv(vertice[17]);
  glVertex2fv(vertice[18]);

  glVertex2fv(vertice[18]);
  glVertex2fv(vertice[19]);

  glVertex2fv(vertice[19]);
  glVertex2fv(vertice[20]);

   glVertex2fv(vertice[20]);
  glVertex2fv(vertice[21]);

  glVertex2fv(vertice[21]);
  glVertex2fv(vertice[22]);

  glVertex2fv(vertice[22]);
  glVertex2fv(vertice[23]);

  glVertex2fv(vertice[23]);
  glVertex2fv(vertice[24]);

  glVertex2fv(vertice[24]);
  glVertex2fv(vertice[13]);
  //fondo

  glVertex2fv(vertice[20]);
  glVertex2fv(vertice[25]);

  glVertex2fv(vertice[25]);
  glVertex2fv(vertice[26]);

  glVertex2fv(vertice[26]);
  glVertex2fv(vertice[27]);

  glVertex2fv(vertice[26]);
  glVertex2fv(vertice[19]);

  glVertex2fv(vertice[27]);
  glVertex2fv(vertice[18]);

  glVertex2fv(vertice[27]);
  glVertex2fv(vertice[18]);

  glVertex2fv(vertice[28]);
  glVertex2fv(vertice[29]);

  glVertex2fv(vertice[28]);
  glVertex2fv(vertice[31]);

  glVertex2fv(vertice[28]);
  glVertex2fv(vertice[16]);

  glVertex2fv(vertice[15]);
  glVertex2fv(vertice[29]);

  glVertex2fv(vertice[29]);
  glVertex2fv(vertice[30]);

  glVertex2fv(vertice[30]);
  glVertex2fv(vertice[14]);

  glVertex2fv(vertice[24]);
  glVertex2fv(vertice[32]);

  glVertex2fv(vertice[32]);
  glVertex2fv(vertice[33]);
  glEnd();

  //Letra J

   glLineStipple(1,0x00FF);
    glEnable(GL_LINE_STIPPLE);  //esto es la linea entrecortada

  glColor3f(0.0,0.0,1.0);
  glBegin(GL_LINES);
  glVertex2fv(vertice[34]);
  glVertex2fv(vertice[35]);

  glVertex2fv(vertice[35]);
  glVertex2fv(vertice[37]);

  glVertex2fv(vertice[37]);
  glVertex2fv(vertice[39]);

  glVertex2fv(vertice[34]);
  glVertex2fv(vertice[36]);

  glVertex2fv(vertice[36]);
  glVertex2fv(vertice[38]);  //

  glVertex2fv(vertice[38]);
  glVertex2fv(vertice[40]);

  glVertex2fv(vertice[39]);
  glVertex2fv(vertice[41]);

  glVertex2fv(vertice[41]);
  glVertex2fv(vertice[42]); //

  glVertex2fv(vertice[42]);
  glVertex2fv(vertice[43]);

  glVertex2fv(vertice[43]);
  glVertex2fv(vertice[40]);

    //FONDO
  glVertex2fv(vertice[35]);
  glVertex2fv(vertice[45]);

  glVertex2fv(vertice[45]);
  glVertex2fv(vertice[44]);

  glVertex2fv(vertice[44]);
  glVertex2fv(vertice[46]);

  glVertex2fv(vertice[44]);
  glVertex2fv(vertice[34]);

  glVertex2fv(vertice[46]);
  glVertex2fv(vertice[36]);

  glVertex2fv(vertice[48]);
  glVertex2fv(vertice[49]);

  glVertex2fv(vertice[49]);
  glVertex2fv(vertice[40]);

  glVertex2fv(vertice[49]);
  glVertex2fv(vertice[47]);

  glVertex2fv(vertice[47]);
  glVertex2fv(vertice[43]);

  glVertex2fv(vertice[47]);
  glVertex2fv(vertice[50]);

  glVertex2fv(vertice[50]);
  glVertex2fv(vertice[42]);

  glEnd();
      glutSwapBuffers();
}
int main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowSize(512,512);
    glutInitWindowPosition(20,20);
    glutCreateWindow("Letras 2D");
    glutDisplayFunc(display);
    glutMainLoop();
    return EXIT_SUCCESS;
}

Read More

Iniciales Arco iris OpenGL

Hola aquí les traigo las iniciales de ingeniería informática y sistemas de colores al igual que un arco iris

=====codigo===========
#include <windows.h>
#ifdef __APPLE__
#else
#include <GL/glut.h>
#endif

#include <stdlib.h>

static void display(void)
{
    glClearColor(0,0,0,0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glShadeModel (GL_SMOOTH);

    //I1
    glBegin(GL_QUADS);
        glColor3f(1.0,0.0,0.0);
        glVertex2f(-0.8,-0.8);
        glColor3f(0.0,1.0,0.0);
        glVertex2f(-0.8,0.8);
        glColor3f(0.0,0.0,1.0);
        glVertex2f(-0.4,0.8);
        glColor3f(1.0,0.0,0.0);
        glVertex2f(-0.4,-0.8);
    glEnd();

    //I2
    glBegin(GL_QUADS);
        glColor3f(1.0,0.2,0.0);
        glVertex2f(-0.2,-0.8);
        glColor3f(0.0,1.0,0.0);
        glVertex2f(-0.2,0.8);
        glColor3f(0.0,0.0,1.0);
        glVertex2f(0.2,0.8);
        glColor3f(1.0,0.0,0.0);
        glVertex2f(0.2,-0.8);
    glEnd();

    //S
    //barra horizontal arriba
    glBegin(GL_QUADS);
        glColor3f(1.0,0.0,0.0);
        glVertex2f(0.4,0.8);
        glColor3f(0.0,1.0,0.0);
        glVertex2f(0.8,0.8);
        glColor3f(0.0,0.0,1.0);
        glVertex2f(0.8,0.6);
        glColor3f(1.0,0.0,0.0);
        glVertex2f(0.4,0.6);
    glEnd();

    glBegin(GL_QUADS);
        glColor3f(1.0,0.0,0.0);
        glVertex2f(0.4,0.6);
        glColor3f(0.0,1.0,0.0);
        glVertex2f(0.6,0.6);
        glColor3f(0.0,0.0,1.0);
        glVertex2f(0.6,0.0);
        glColor3f(1.0,0.0,1.0);
        glVertex2f(0.4,0.0);
    glEnd();



    glBegin(GL_QUADS);
        glColor3f(1.0,0.0,0.0);
        glVertex2f(0.6,0.0);
        glColor3f(0.0,1.0,0.0);
        glVertex2f(0.8,0.0);
        glColor3f(0.0,0.0,1.0);
        glVertex2f(0.8,-0.6);
        glColor3f(1.0,0.0,1.0);
        glVertex2f(0.6,-0.6);
    glEnd();



    //barra horizontal debajo
    glBegin(GL_QUADS);
        glColor3f(1.0,0.0,0.0);
        glVertex2f(0.4,-0.8);
        glColor3f(0.0,1.0,0.0);
        glVertex2f(0.4,-0.6);
        glColor3f(0.0,0.0,1.0);
        glVertex2f(0.8,-0.6);
        glColor3f(1.0,0.0,1.0);
        glVertex2f(0.8,-0.8);
    glEnd();

    //barra del centro
    glBegin(GL_QUADS);
        glColor3f(1.0,0.0,0.0);
        glVertex2f(0.4,0.1);
        glColor3f(0.0,1.0,0.0);
        glVertex2f(0.4,-0.1);
        glColor3f(0.0,0.0,1.0);
        glVertex2f(0.8,-0.1);
        glColor3f(1.0,0.0,1.0);
        glVertex2f(0.8,0.1);
    glEnd();

    glutSwapBuffers();
}

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowSize(640,480);
    glutInitWindowPosition(10,10);
    glutCreateWindow("Cubo");

    //glutReshapeFunc(resize);
    glutDisplayFunc(display);

    glutMainLoop();

    return EXIT_SUCCESS;
}

Read More

Formación de Cubos OpennGL

Hola aquí les traigo la formación de cubos de colores en los tres ejes de forma vertical y circular

====codigo========
/*
 * GLUT Shapes Demo
 *
 * Written by Nigel Stewart November 2003
 *
 * This program is test harness for the sphere, cone
 * and torus shapes in GLUT.
 *
 * Spinning wireframe and smooth shaded shapes are
 * displayed until the ESC or q key is pressed.  The
 * number of geometry stacks and slices can be adjusted
 * using the + and - keys.
 */
#include<windows.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

#include <stdlib.h>

static int slices = 16;
static int stacks = 16;

/* GLUT callback Handlers */

static void display(void)
{
glClearColor(0,0,0,1);//pantalla color negro
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  //Dibujando ejes
 glBegin(GL_LINES);
 glColor3f(1.0f, 0.0f, 0.0f);//Rojo Eje X
 glVertex3f(0.0f, 0.0f, 0.0f);
 glVertex3f(2.0f, 0.0f, 0.0f);
 glColor3f(0.0f, 1.0f, 0.0f);//verde Eje Y
 glVertex3f(0.0f, 0.0f, 0.0f);
 glVertex3f(0.0f, 2.0f, 0.0f);
 glColor3f(0.0f, 0.0f, 1.0f);//azul Eje Z
 glVertex3f(0.0f, 0.0f, 0.0f);
 glVertex3f(0.0f, 0.0f, 2.0f);
 glEnd();

glColor3f(0.0f, 0.0f, 1.0f); //dibujos en color gris
 //Dibujando el objeto
 for (GLint i=0; i<10; i++) {
 glPushMatrix();
 glRotatef(i * 360 / 10, 0.0f, 1.0f, 0.0f);
 glTranslatef(0.3f, 0.0f, 0.0f);
 glutSolidSphere(0.1, 30, 30);
 //glutWireTeapot(0.25);
 glPopMatrix();
 }
glColor3f(1.0f, 0.0f, 0.0f); //dibujos en color gris
 //Dibujando el objeto
 for (GLint i=0; i<10; i++) {
 glPushMatrix();
 glRotatef(i * 360 / 10, 0.0f, 1.0f, 0.0f);
 glTranslatef(0.7f, 0.0f, 0.0f);
 glTranslatef(0.0f, 1.0f, 0.0f);
 //glutWireTeapot(0.25);
 glutWireCube(0.2);
 glutSolidCube(0.2);
 //glColor3b(1.0f, 0.0f, 0.0f);
 glPopMatrix();

 }

glColor3f(0.0f, 1.0f, 0.0f); //dibujos en color verde
 //Dibujando el objeto
 for (GLint i=0; i<10; i++) {
 glPushMatrix();
 glRotatef(i * 360 / 10, 0.0f, 1.0f, 0.0f);
 glTranslatef(0.8f, 0.0f, 1.0f);
 glTranslatef(0.0f, 2.0f, 0.0f);
 //glutWireTeapot(0.25);
 glutWireCube(0.2);
 glutSolidCube(0.2);
 glPopMatrix();

 }
 //glutWireTeapot(0.5);
 glutSwapBuffers();
}


// Funcion que actua sobre la Pantalla
void reshape(int width, int height){
 glViewport(0,0,width,height);
 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 gluPerspective(90.0,1,1.0,128.0);
 glMatrixMode(GL_MODELVIEW);
 glLoadIdentity();
 gluLookAt(2.5,3.5,2.0,0.0,0.0,0.0,0.0,1.0,0.0);
}
int main(int argc, char *argv[])
{
 glutInit(&argc, argv);
 glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
 glutInitWindowPosition(20,20);
 glutInitWindowSize(500,500);
 glutCreateWindow("Transformaciones OpenGL");
 glutDisplayFunc(display);
 glutReshapeFunc(reshape);
 glutMainLoop();
 return EXIT_SUCCESS;
}

Read More

Formación de cubos OpenGL

Hola aquí les dejo el código que como pueden agregar un grupo de cubos en una circunferencia y formar una figura

====codigo====

/*

 * GLUT Shapes Demo

 *

 * Written by Nigel Stewart November 2003

 *

 * This program is test harness for the sphere, cone

 * and torus shapes in GLUT.

 *

 * Spinning wireframe and smooth shaded shapes are

 * displayed until the ESC or q key is pressed.  The

 * number of geometry stacks and slices can be adjusted

 * using the + and - keys.

 */

#include<windows.h>

#ifdef __APPLE__

#include <GLUT/glut.h>

#else

#include <GL/glut.h>

#endif

#include <stdlib.h>

static int slices = 16;

static int stacks = 16;

/* GLUT callback Handlers */

static void display(void)

{

glClearColor(0,0,0,1);//pantalla color negro

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  //Dibujando ejes

 glBegin(GL_LINES);

 glColor3f(1.0f, 0.0f, 0.0f);//Rojo Eje X

 glVertex3f(0.0f, 0.0f, 0.0f);

 glVertex3f(2.0f, 0.0f, 0.0f);

 glColor3f(0.0f, 1.0f, 0.0f);//verde Eje Y

 glVertex3f(0.0f, 0.0f, 0.0f);

 glVertex3f(0.0f, 2.0f, 0.0f);

 glColor3f(0.0f, 0.0f, 1.0f);//azul Eje Z

 glVertex3f(0.0f, 0.0f, 0.0f);

 glVertex3f(0.0f, 0.0f, 2.0f);

 glEnd();

glColor3f(0.0f, 0.0f, 1.0f); //dibujos en color gris

 //Dibujando el objeto

 for (GLint i=0; i<10; i++) {

 glPushMatrix();

 glRotatef(i * 360 / 10, 0.0f, 1.0f, 0.0f);

 glTranslatef(0.3f, 0.0f, 0.0f);

 glutSolidSphere(0.1, 30, 30);

 //glutWireTeapot(0.25);

 glPopMatrix();

 }

glColor3f(1.0f, 0.0f, 0.0f); //dibujos en color gris

 //Dibujando el objeto

 for (GLint i=0; i<10; i++) {

 glPushMatrix();

 glRotatef(i * 360 / 10, 0.0f, 1.0f, 0.0f);

 glTranslatef(0.8f, 0.0f, 0.0f);

 //glTranslatef(0.0f, 1.0f, 0.0f);

 //glutWireTeapot(0.25);

 glutWireCube(0.2);

 glutSolidCube(0.2);

 //glColor3b(1.0f, 0.0f, 0.0f);

 glPopMatrix();

 }

glColor3f(0.0f, 1.0f, 0.0f); //dibujos en color verde

 //Dibujando el objeto

 for (GLint i=0; i<10; i++) {

 glPushMatrix();

 glRotatef(i * 360 / 10, 0.0f, 1.0f, 0.0f);

 glTranslatef(0.9f, 0.0f, 1.0f);

 //glTranslatef(0.0f, 1.0f, 0.0f);

 //glutWireTeapot(0.25);

 glutWireCube(0.2);

 glutSolidCube(0.2);

 glPopMatrix();

 }

 //glutWireTeapot(0.5);

 glutSwapBuffers();

}

// Funcion que actua sobre la Pantalla

void reshape(int width, int height){

 glViewport(0,0,width,height);

 glMatrixMode(GL_PROJECTION);

 glLoadIdentity();

 gluPerspective(90.0,1,1.0,128.0);

 glMatrixMode(GL_MODELVIEW);

 glLoadIdentity();

 gluLookAt(2.5,2.5,2.0,0.0,0.0,0.0,0.0,1.0,0.0);

}

int main(int argc, char *argv[])

{

 glutInit(&argc, argv);

 glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

 glutInitWindowPosition(20,20);

 glutInitWindowSize(500,500);

 glutCreateWindow("Transformaciones OpenGL");

 glutDisplayFunc(display);

 glutReshapeFunc(reshape);

 glutMainLoop();

 return EXIT_SUCCESS;

}

Read More