コード例 #1
0
/**
 *  Dibuje el triángulo formado por los vértices [(-1,-1,-2), (1,-1,-2), (0,1,-2)].
 */
int main(int argc, char* argv[])
{
// Crear una ventana de 500x500 pixels:

	int cw = 500;
	int ch = 500;

	cg_init(cw, ch, NULL);

	// Utilizando la función glGetString, imprima por consola el número de versión de OpenGL que utiliza su sistema.
	printf("GL Version: %s\n", glGetString(GL_VERSION));

	// specifies the red, green, blue, and alpha values used by glClear to clear the color buffers.
	glClearColor(1.0f, 1.0f, 1.0f, 0.0f);

	// Actualizar la pantalla:
	glMatrixMode(GL_MODELVIEW);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();
	glMatrixMode(GL_PROJECTION);
	glViewport(0,0,cw, ch);
	glFrustum(-1,1,-1,1,1,1000);

	glClear(GL_COLOR_BUFFER_BIT);
	glPointSize(10.0f);

	glBegin(GL_TRIANGLES);
		glColor3f(0.3f, 0.8f, 0.1f);
		glVertex3f(-1.0f, -1.0f, -2.0f);
		glVertex3f(0.0f,1.0f, -2.0f);
		glVertex3f(-2.0f, 1.0f, -2.0f);
	glEnd();


	cg_repaint();

	int done = 0;

	while (!done)
	{
		SDL_Event event;
		while(SDL_PollEvent(&event))
		{
			switch (event.type)
			{
				case SDL_KEYDOWN:
					if (event.key.keysym.sym != SDLK_ESCAPE)
						break;
				case SDL_QUIT : done = 1;
			}
		}

		cg_repaint();
	}
	// Liberar recursos:
	cg_close();

	return 0;
}
コード例 #2
0
ファイル: kernel_interface.cpp プロジェクト: UoB-HPC/TeaLeaf
// CG solver kernels
void run_cg_init(
        Chunk* chunk, Settings* settings, 
        double rx, double ry, double* rro)
{
    START_PROFILING(settings->kernel_profile);
    cg_init(chunk->ext->raja_lists, chunk->x, chunk->y, 
            settings->halo_depth, settings->coefficient, rx, ry, 
            rro, chunk->density, chunk->energy, chunk->u, 
            chunk->p, chunk->r, chunk->w, 
            chunk->kx, chunk->ky);
    STOP_PROFILING(settings->kernel_profile, __func__);
}
コード例 #3
0
/**
 * 2. Determinación de superficies ocultas por medio de Z-Buffer y optimización por Backface culling.
 */
int main(int argc, char* argv[])
{
	// Crear una ventana de 750x750 pixels.
	int cw = 750;
	int ch = 750;

	cg_init(cw, ch, NULL);

	// Actualizar la pantalla:
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glMatrixMode(GL_PROJECTION);
	glViewport(0,0,cw, ch);
	glFrustum(-1,1,-1,1,1,1000);

	Obj* obj = obj_load("../Models/knight.obj");

	float ang = 0.0f;
	float pitch = 0.0f;
	float ang_vel = 1.0f;

	char done = 0;
	char wireframe = 0;
	char bfc = 0;
	glEnable(GL_DEPTH_TEST);
	char zbuff = 1;
	unsigned char key_pressed[1024];
	memset(key_pressed, 0, 1024);

	while (!done)
	{
		SDL_Event event;
		while(SDL_PollEvent(&event))
		{
			switch (event.type)
			{
				case SDL_KEYDOWN:
					key_pressed[event.key.keysym.sym] = 1;

					if (event.key.keysym.sym == SDLK_z)
					{
						zbuff = !zbuff;
						if(zbuff)
							glEnable(GL_DEPTH_TEST);
						else
							glDisable(GL_DEPTH_TEST);
						break;
					}
					else if (event.key.keysym.sym == SDLK_b)
					{
						bfc = !bfc;
						if(bfc)
						{
							glEnable(GL_CULL_FACE);
							glCullFace(GL_BACK);
							glFrontFace(GL_CW);
						}
						else
							glDisable(GL_CULL_FACE);
						break;
					}
					else if (event.key.keysym.sym == SDLK_m)
					{
						wireframe = !wireframe;
						if(wireframe)
							glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
						else
							glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
						break;
					}
					else if (event.key.keysym.sym != SDLK_ESCAPE)
						break;
				case SDL_QUIT :
					done = 1;
					break;
				case SDL_KEYUP:
					key_pressed[event.key.keysym.sym] = 0;

			}
		}

		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		glTranslatef(0.0f, 0.0f, -50.0f);
		glRotatef(pitch, 1.0f, 0.0f, 0.0f);
		glRotatef(ang, 0.0f, 1.0f, 0.0f);
		glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);

		if(key_pressed[SDLK_RIGHT]) ang += ang_vel;
		if(key_pressed[SDLK_LEFT]) ang -= ang_vel;
		if(key_pressed[SDLK_UP]) pitch += ang_vel;
		if(key_pressed[SDLK_DOWN]) pitch -= ang_vel;

		glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
		obj_render(obj);
		cg_repaint();
	}

	// Liberar recursos:
	obj_free(obj);
	cg_close();

	return 0;
}
コード例 #4
0
ファイル: main2.c プロジェクト: tlazaro/cg-ucu
int main(int argc, char* argv[])
{
    // Crear una ventana de 500x500 pixels:
    int cw = 640;
    int ch = 480;
    cg_init(cw, ch, NULL);
    init_cggl(cw, ch);

    Model* model = model_new("knight");

    int done = 0;
    while (!done)
    {
        SDL_Event event;
        while(SDL_PollEvent(&event))
        {
            switch (event.type)
            {
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                case SDLK_ESCAPE:
                    done = 1;
                    break;
                case SDLK_UP:
                    rot_speed += 5.0f;
                    break;
                case SDLK_DOWN:
                    rot_speed -= 5.0f;
                    break;
                case SDLK_RIGHT:
                    frame += 1;
                    if (frame >= model->md2_model->header.num_frames)
                        frame = 0;
                    break;
                case SDLK_LEFT:
                    frame -= 1;
                    if (frame < 0)
                        frame = model->md2_model->header.num_frames - 1;
                    break;
                case SDLK_m:
                    if (mode == CG_TRIANGLES)
                        mode = CG_LINES;
                    else
                        mode = CG_TRIANGLES;
                    break;
                default:
                    break;
                }
                break;
            case SDL_QUIT :
                done = 1;
                break;
            default:
                break;
            }
        }
        cg_clear();

        paint_model(model);

        // Actualizar la pantalla:
        cg_repaint();

        double delta = get_delta();

        rot_x += rot_speed*delta;
        rot_y += rot_speed*delta;
        rot_z += rot_speed*delta;

    }

    // Liberar recursos:
    model_free(model);
    cgCloseCGGL();
    cg_close();

    return 0;
}
コード例 #5
0
int main(int argc, char* argv[])
{
    int cw = 750;
    int ch = 750;

    cg_init(cw, ch, NULL);

    glClearColor(0,0,1,1);
    // Actualizar la pantalla:
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glMatrixMode(GL_PROJECTION);
    glViewport(0,0,cw, ch);
    glFrustum(-1,1,-1,1,1,1000);

    glEnable(GL_LIGHTING);

    // glEnable(GL_NORMALIZE);
    float l0[] = {1.0f,1.0f,1.0f,1.0f};
    float la[] = {0.10f,0.10f,0.10f,1.0f};
    float l0p[]= {1.0f,1.0f,1.0f,1.0f};
    float ls[] = {1.0f,1.0f,1.0f,1.0f};
    glLightfv(GL_LIGHT0, GL_AMBIENT, la);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, l0);
    glLightfv(GL_LIGHT0, GL_POSITION, l0p);
    glLightfv(GL_LIGHT0, GL_SPECULAR, ls);
    glEnable(GL_LIGHT0);

    float cyan[] = {1.0f, 1.0f, 1.0f, 1.f};
    glMaterialfv(GL_FRONT, GL_DIFFUSE, cyan);
    glMaterialfv(GL_FRONT, GL_SPECULAR, ls);
    glMateriali(GL_FRONT, GL_SHININESS, 16);

    float ang = 0.0f;
    float pitch = 0.0f;
    float ang_vel = 1.0f;


    char done = 0;
    char wireframe = 0;
    char bfc = 0;
    glEnable(GL_DEPTH_TEST);
    char zbuff = 1;
    unsigned char key_pressed[1024];
    memset(key_pressed, 0, 1024);

    char use_shader = 0;
    char specular = 0;
    Shader gouraud = shader_new("shaders/gouraud_vp.glsl", "shaders/gouraud_fp.glsl");
    GLint uniform_especular = shader_get_unif_loc(gouraud, "especular");
    GLint uniform_tex = shader_get_unif_loc(gouraud, "tex");

    Obj* objPtr ;
    int example = atoi(argv[1]);

    if (example==1 || example==3)
        objPtr = obj_load("../Models/knight_texturas.obj");
    else if (example==2)
        objPtr = obj_load("../Models/box_texturas.obj");

    //Cargo la imagen de disco usando SDL_image
    SDL_Surface* surface; // = IMG_Load("../Models/knight.png");

    if (example==1 )
        surface = IMG_Load("../Models/knight.png");
    else if (example==2)
        surface = IMG_Load("../Models/box.jpg");
    else if (example==3)
        surface = IMG_Load("../Models/knight_good.png");


//    Obj* objPtr = obj_load("../Models/knight_texturas.obj");
//    Obj* objPtr = obj_load("../Models/box_texturas.obj");

    //Cargo la imagen de disco usando SDL_image
//    SDL_Surface* surface = IMG_Load("../Models/knight.png");
//    SDL_Surface* surface = IMG_Load("../Models/knight_good.png");
//    SDL_Surface* surface = IMG_Load("../Models/box.jpg");

    if (surface==NULL) { //Si falla la carga de la imagen, despliego el mensaje de error correspondiente y termino el programa.
        printf("Error: \"%s\"\n", SDL_GetError());
        return 1;
    }

    GLuint texture;
    //Creo un espacio para alojar una textura en memoria de video
    glGenTextures(1,&texture);
    //Activo la textura nro 0
    glActiveTexture(GL_TEXTURE0);
    //Habilito la carga para la textura recien creada
    glBindTexture(GL_TEXTURE_2D,texture);

    //Cargo los datos de la imagen en la textura.
    glTexImage2D(GL_TEXTURE_2D,
                 0,
                 GL_RGBA,
                 surface->w,
                 surface->h,
                 0,
                 GL_RGB,GL_UNSIGNED_BYTE,
                 surface->pixels);
    //Luego de copiada la imagen a memoria de video, puedo liberarla sin problemas
    SDL_FreeSurface(surface);

    //Seteo el filtro a usar cuando se mapea la textura a una superficie mas chica (GL_LINEAR = filtro bilineal)
    glTexParameteri(GL_TEXTURE_2D,
                    GL_TEXTURE_MIN_FILTER,
                    GL_LINEAR);
    //Seteo el filtro a usar cuando se mapea la textura a una superficie mas grande (GL_LINEAR = filtro bilineal)
    glTexParameteri(GL_TEXTURE_2D,
                    GL_TEXTURE_MAG_FILTER,
                    GL_LINEAR);

    //Seteo el comportamiento cuando encuentro coordenadas de textura fuera del rango [0,1]
    //GL_REPEAT es el comportamiento por defecto.
    glTexParameteri(GL_TEXTURE_2D,
                    GL_TEXTURE_WRAP_S,
                    GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D,
                    GL_TEXTURE_WRAP_T,
                    GL_REPEAT);

    while (!done)
    {

        SDL_Event event;
        while(SDL_PollEvent(&event))
        {
            switch (event.type)
            {
            case SDL_KEYDOWN:
                key_pressed[event.key.keysym.sym] = 1;
                if (event.key.keysym.sym == SDLK_p)
                {
                    use_shader = !use_shader;
                    break;
                }
                else if (event.key.keysym.sym == SDLK_s)
                {
                    specular = !specular;
                    break;
                }
                else if (event.key.keysym.sym == SDLK_z)
                {
                    zbuff = !zbuff;
                    if(zbuff)
                        glEnable(GL_DEPTH_TEST);
                    else
                        glDisable(GL_DEPTH_TEST);
                    break;
                }
                else if (event.key.keysym.sym == SDLK_m)
                {
                    wireframe = !wireframe;
                    if(wireframe)
                        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
                    else
                        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
                    break;
                }
                else if (event.key.keysym.sym == SDLK_b)
                {
                    bfc = !bfc;
                    if(bfc)
                    {
                        glEnable(GL_CULL_FACE);
                        glCullFace(GL_BACK);
                        glFrontFace(GL_CW);
                    }
                    else
                        glDisable(GL_CULL_FACE);
                    break;
                }
                else if (event.key.keysym.sym != SDLK_ESCAPE)
                    break;
            case SDL_QUIT :
                done = 1;
                break;
            case SDL_KEYUP:
                key_pressed[event.key.keysym.sym] = 0;

            }
        }

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        if (example==1 || example==3)
            glTranslatef(0.0f, 0.0f, -50.0f);
        else if (example==2)
            glTranslatef(0.0f, 0.0f, -2.0f);

//        glTranslatef(0.0f, 0.0f, -50.0f);
//        glTranslatef(0.0f, 0.0f, -2.0f);

        glRotatef(pitch, 1.0f, 0.0f, 0.0f);
        glRotatef(ang, 0.0f, 1.0f, 0.0f);

        glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);

        if(key_pressed[SDLK_RIGHT]) ang += ang_vel;
        if(key_pressed[SDLK_LEFT]) ang -= ang_vel;
        if(key_pressed[SDLK_UP]) pitch += ang_vel;
        if(key_pressed[SDLK_DOWN]) pitch -= ang_vel;

        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

        //Informo a OpenGL que para todas las operaciones a continuaci�n utilice las texturas 2D cargadas
        glEnable(GL_TEXTURE_2D);

        if(use_shader)
        {
            shader_use(gouraud);
            glUniform1i(uniform_especular, specular);
            //Le digo al shader que el sampler2D de nombre "tex" se corresponde con GL_TEXTURE0
            //que es donde cargu� mi textura.
            glUniform1i(uniform_tex, 0);
            //Luego asocio la textura con el id "texture"
            glBindTexture(GL_TEXTURE_2D,texture);
            obj_render2(objPtr);
            shader_stop(gouraud);
        }
        else
        {
            glBindTexture(GL_TEXTURE_2D,texture);
            obj_render2(objPtr);
        }

        cg_repaint();
    } // while

    // Liberar recursos:
    obj_free(objPtr);
    shader_free(gouraud);
    glDeleteTextures(1,&texture);
    cg_close();

    return 0;
}
コード例 #6
0
ファイル: main.c プロジェクト: Amaury/Carta-Genius
int main(int argc, char **argv)
{
  int optch, return_value = 0;
  char *input = NULL, *output = NULL, *inc_paths = NULL;
  char *font_paths = NULL, *img_paths = NULL;
  cg_back_t do_back = BACK_NO;
  cg_paper_t do_paper = A4;
  yvalue_t do_width, do_height, do_margin_width, do_margin_height;
  ybool_t set_back = YFALSE, set_paper = YFALSE, set_pdf = YFALSE;
  ybool_t set_width = YFALSE, set_height = YFALSE, set_margin = YFALSE;
  ybool_t set_margin_width = YFALSE, set_margin_height = YFALSE;
  ybool_t do_reverse = YFALSE, set_reverse = YFALSE;
  ybool_t set_landscape = YFALSE, set_quiet = YFALSE;
  cg_pdf_version_t pdf_version = PDF_14;
  char *author = NULL, *title = NULL, *log_file = NULL;;
  cg_t *carta;

  /* parse the command line */
  while ((optch = getopt(argc, argv,
			 "p:w:h:l:m:x:y:b:v:r:i:o:d:e:t:L:q")) != -1)
    switch (optch)
      {
      case 'p': /* paper type */
	set_paper = YTRUE;
	do_paper = cg_get_paper(optarg);
	do_width = cg_get_paper_width(do_paper);
	do_height = cg_get_paper_height(do_paper);
	break ;
      case 'w': /* paper width */
	set_width = YTRUE;
	do_width = yvalue_read(optarg, YUNIT_MM);
	break ;
      case 'h': /* paper height */
	set_height = YTRUE;
	do_height = yvalue_read(optarg, YUNIT_MM);
	break ;
      case 'l': /* landscape mode */
	if (!strcasecmp(optarg, "yes") || !strcasecmp(optarg, "true"))
	  set_landscape = YTRUE;
	break ;
      case 'm': /* margin size */
	set_margin = YTRUE;
	do_margin_width = yvalue_read(optarg, YUNIT_MM);
	do_margin_height = do_margin_width;
	break ;
      case 'x': /* margin width */
	set_margin_width = YTRUE;
	do_margin_width = yvalue_read(optarg, YUNIT_MM);
	break ;
      case 'y': /* margin height */
	set_margin_height = YTRUE;
	do_margin_height = yvalue_read(optarg, YUNIT_MM);
	break ;
      case 'b': /* cards' back configuration */
	set_back = YTRUE;
	if (!strcasecmp(optarg, "width"))
	  do_back = BACK_WIDTH;
	else if (!strcasecmp(optarg, "height"))
	  do_back = BACK_HEIGHT;
	else if (!strcasecmp(optarg, "no"))
	  do_back = BACK_NO;
	else
	  set_back = YFALSE;
	break ;
      case 'v': /* PDF version */
	set_pdf = YTRUE;
	if (!strcmp(optarg, "1.3"))
	  pdf_version = PDF_13;
	else if (!strcmp(optarg, "1.4"))
	  pdf_version = PDF_14;
	else if (!strcmp(optarg, "1.5"))
	  pdf_version = PDF_15;
	else
	  set_pdf = YFALSE;
	break ;
      case 'r': /* inverse page order */
	if (!strcasecmp(optarg, "yes") || !strcasecmp(optarg, "true"))
	  {
	    set_reverse = YTRUE;
	    do_reverse = YTRUE;
	  }
	else if (!strcasecmp(optarg, "no") || !strcasecmp(optarg, "false"))
	  {
	    set_reverse = YTRUE;
	    do_reverse = YFALSE;
	  }
	break ;
      case 'd': /* include path directories */
	inc_paths = strdup(optarg);
	break ;
      case 'f': /* font path directories */
	font_paths = strdup(optarg);
	break ;
      case 'g': /* image path directories */
	img_paths = strdup(optarg);
	break ;
      case 'i': /* input file */
        input = strdup(optarg);
        break ;
      case 'o': /* output file */
        output = strdup(optarg);
        break ;
      case 'e': /* author */
	author = strdup(optarg);
	break ;
      case 't': /* title */
	title = strdup(optarg);
	break ;
      case 'L': /* log file */
	log_file = strdup(optarg);
	break ;
      case 'q': /* quiet mode */
	set_quiet = YTRUE;
	break ;
      default:
	_usage();
        exit(1);
      }

  if (!input || !output)
    {
      _usage();
      exit(1);
    }

  /* logging init */
  if (set_quiet && log_file)
    YLOG_INIT_FILE(log_file);
  else if (set_quiet && !log_file)
    YLOG_INIT_SYSLOG();
  else if (!set_quiet && log_file)
    YLOG_INIT_STDERR_FILE(log_file);
  else
    YLOG_INIT_STDERR();

  /* read input file */
  if (!(carta = cg_init(input, inc_paths, font_paths, img_paths)))
    {
      YLOG_ADD(YLOG_ERR, "Unable to read input file '%s'", input);
      exit(1);
    }
  /* update with command line options */
  if (set_back)
    carta->do_back = do_back;
  if (set_paper || set_width || set_height || set_landscape ||
      set_margin || set_margin_width || set_margin_height)
    {
      cg_deck_t *deck;
      int i;
      for (i = 0; i < yv_len(carta->decks); ++i)
	{
	  deck = carta->decks[i];
	  if (set_paper || set_width)
	    deck->paper_width = do_width;
	  if (set_paper || set_height)
	    deck->paper_height = do_height;
	  if (set_landscape)
	    {
	      yvalue_t tmp_val = deck->paper_width;
	      deck->paper_width = deck->paper_height;
	      deck->paper_height = tmp_val;
	    }
	  if (set_margin || set_margin_width)
	    deck->paper_margin_w = do_margin_width;
	  if (set_margin || set_margin_height)
	    deck->paper_margin_h = do_margin_height;
	}
    }
  if (set_pdf)
    carta->pdf_version = pdf_version;
  if (set_reverse)
    carta->reverse = do_reverse;
  if (author)
    {
      free0(carta->author);
      carta->author = author;
    }
  if (title)
    {
      free0(carta->title);
      carta->title = title;
    }

  /* compute cols and rows */
  if (cg_compute_cols_rows(carta) == YENOERR)
    {
      /* create the PDF file */
      if (cg_create_document(output, carta) != YENOERR)
	return_value = 2;
    }
  else
    return_value = 3;

  /* free memory */
  yv_del(&carta->xml_doms, free_dom, NULL);
  yv_del(&carta->decks, free_deck, NULL);
  yv_del(&carta->fonts, free_font, NULL);
  yv_del(&carta->images, free_image, NULL);
  yv_del(&carta->masks, free_image, NULL);
  yv_del(&carta->templates, NULL, NULL);
  yv_del(&carta->variables, NULL, NULL);
  yv_del(&carta->inc_paths, free_path, NULL);
  yv_del(&carta->img_paths, free_path, NULL);
  yv_del(&carta->text_defines, free_text_define, NULL);
  if (carta->expr)
    {
      yv_del(&carta->expr->vars, free_var, NULL);
      yv_del(&carta->expr->funcs, free_func, NULL);
      free0(carta->expr);
    }
  free0(carta->author);
  free0(carta->title);
  free0(carta->subject);
  free0(carta->keywords);
  free0(carta->copyright);
  free0(carta->version);
  free0(carta->language);
  free0(carta->note);
  free0(carta->master_password);
  free0(carta->user_password);
  free0(carta);
  return (return_value);
}
コード例 #7
0
/**
 * Dibuje el modelo definido por el archivo knight.obj 1 disponible en webasignatura. El
 * formato del archivo OBJ se encuentra definido en el anexo I de este documento. Cada
 * triángulo del modelo debe ser dibujado usando un tono de gris randómico en sus vértices.
 * Nota: Para parsear el archivo obj, puede utilizar las funciones fgets (definida en stdio.h),
 * strcmp, strtok (definidas en string.h), atof y atoi (definidas en stdlib.h).
 */
int main(int argc, char* argv[])
{
// Crear una ventana de 500x500 pixels:
	int cw = 900;
	int ch = 900;

	cg_init(cw, ch, NULL);

#ifdef WIN32
    freopen( "CON", "w", stdout );
    freopen( "CON", "w", stderr );
#endif

	printf("GL Version: %s\n", glGetString(GL_VERSION));
	// Actualizar la pantalla:
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glMatrixMode(GL_PROJECTION);
	glViewport(0,0,cw, ch);
	glFrustum(-1,1,-1,1,1,1000);

	//Habilito la iluminación del pipeline estático de OpenGL.
	glEnable(GL_LIGHTING);

	//Creo un Vec4 para representar el color (RGBA) y la Intensidad de la luz.
	//P.e.: (1,1,1,1) = Luz Blanca intensa, (0.5,0.5,0.5,1) = Luz blanca tenue, (0.5,0,0,1) = Luz roja tenue.
	float l0[] = {1.0f,1.0f,1.0f,1.0f};
	//Creo un Vec4 para representar el color (RGBA) y la intensidad de la iluminación ambiente de la luz
	float la[] = {0.10f,0.10f,0.10f,1.0f};
	//Creo un Vec4 para representar la posición de la luz. El cuarto elemento representa el tipo de luz: 1=puntual, 0=direccional
	float l0p[]= {1.0f,1.0f,1.0f,1.0f};
	//Creo un Vec4 para representar el color (RGBA) y la intensidad especular de la luz
	float ls[] = {1.0f,1.0f,1.0f,1.0f};
	//Cargo la intesidad ambiente de la Luz Nro 0 del pipline estático.
	glLightfv(GL_LIGHT0, GL_AMBIENT, la);
	//Cargo la intesidad difusa de la Luz Nro 0 del pipline estático.
	glLightfv(GL_LIGHT0, GL_DIFFUSE, l0);
	//Cargo la posición de la Luz Nro 0 del pipline estático.
	glLightfv(GL_LIGHT0, GL_POSITION, l0p);
	//Cargo la intesidad especular de la Luz Nro 0 del pipline estático.
	glLightfv(GL_LIGHT0, GL_SPECULAR, ls);
	//Prendo la Luz nro 0 del pipline estático. Hay 8 luces, representadas por las constantes GL_LIGHT0 a GL_LIGHT7
	//Por defecto está todas apagadas al inicio.
	glEnable(GL_LIGHT0);

	//Creo un Vec4 para representar el color difuso(RGBA) del material del objeto a dibujar.
	float cyan[] = {1.0f, 0.0f, 1.0f, 1.f};
	//Cargo el color difuso del la cara de adelante del objeto a dibujar.
	glMaterialfv(GL_FRONT, GL_DIFFUSE, cyan);
	//Cargo el color especular del la cara de adelante del objeto a dibujar.
	glMaterialfv(GL_FRONT, GL_SPECULAR, ls);
	//Cargo el coeficiente especular de la cara de adelante del objeto a dibujar.
	glMateriali(GL_FRONT, GL_SHININESS, 32);

	float ang = 0.0f;
	float pitch = 0.0f;
	float ang_vel = 1.0f;

	Obj* obj = obj_load("Models/knight.obj");

	printf("num of faces %d\n", obj->numfaces);    // delete
	printf("num of vertices %d\n", obj->numverts);  // delete


	char done = 0;
	char wireframe = 0;
	char bfc = 0;
	glEnable(GL_DEPTH_TEST);
	char zbuff = 1;
	unsigned char key_pressed[1024];
	memset(key_pressed, 0, 1024);

	while (!done)
	{

		SDL_Event event;
		while(SDL_PollEvent(&event))
		{
			switch (event.type)
			{
				case SDL_KEYDOWN:
					key_pressed[event.key.keysym.sym] = 1;
					if (event.key.keysym.sym == SDLK_z)
					{
						zbuff = !zbuff;
						if(zbuff)
							glEnable(GL_DEPTH_TEST);
						else
							glDisable(GL_DEPTH_TEST);
						break;
					}
					else if (event.key.keysym.sym == SDLK_m)
					{
						wireframe = !wireframe;
						if(wireframe)
							glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
						else
							glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
						break;
					}
					else if (event.key.keysym.sym == SDLK_b)
					{
						bfc = !bfc;
						if(bfc)
						{
							glEnable(GL_CULL_FACE);
							glCullFace(GL_BACK);
							glFrontFace(GL_CW);
						}
						else
							glDisable(GL_CULL_FACE);
						break;
					}
					else if (event.key.keysym.sym != SDLK_ESCAPE)
						break;
				case SDL_QUIT : done = 1;break;
				case SDL_KEYUP: key_pressed[event.key.keysym.sym] = 0;

			}
		}

		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		glTranslatef(0.0f, 0.0f, -50.0f);
		glRotatef(pitch, 1.0f, 0.0f, 0.0f);
		glRotatef(ang, 0.0f, 1.0f, 0.0f);

		glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);

		if(key_pressed[SDLK_RIGHT]) ang += ang_vel;
		if(key_pressed[SDLK_LEFT]) ang -= ang_vel;
		if(key_pressed[SDLK_UP]) pitch += ang_vel;
		if(key_pressed[SDLK_DOWN]) pitch -= ang_vel;

		glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

		obj_render(obj);

		cg_repaint();
	}
	obj_free(obj);
	// Liberar recursos:
	cg_close();

	// Ejemplo del modulo de Manejo de Memoria (MM):
	int* pint = (int *)cg_malloc(10*sizeof(int));
	printf("pint is a pointer: %p\n", pint);
	cg_free(pint); // olvidarse de liberar este objeto produce un mensaje


	return 0;
}
コード例 #8
0
ファイル: CGminimal.c プロジェクト: idaohang/GLFGPSSim
void plot_something(char *progname, int use_stdout)
{
int 	rot= 1;			/* Portrait=1, Landscape=0 */
int 	expand= 1;		/* left over from PC version, not used in NeXT Cgraph */
float	scale= 1.0;		/* scaling factor */
float   radius1, radius2;	/* analysis or plot parameters */
char comment[4096];	/* reserve sufficient space for header comments for EPS file */
char strbuff[128];
int i;
float x, y, angle;

	if(use_stdout)
	   cg_use_stdout(use_stdout);	/* decide where to send output */
	cg_useflexcolor(2);		/* let the device capability dictate color/monochrome */

	cg_setboundingbox("0 0 216 216");
	cg_settitle(prog_version);
	cg_setcreator(progname);

	/* Prepare comment block for EPS for data source tracing */
	radius1= 0.8; radius2= 1.2;
	/* PostScript comment lines must start with a % character. */
	sprintf(comment, "%% %s\n", prog_version);
	sprintf(comment+strlen(comment), "%% Original data file: %s\n", progname);
	sprintf(comment+strlen(comment), "%% Analysis parameter-1: %g\n", radius1);
	sprintf(comment+strlen(comment), "%% Analysis parameter-1: %g\n", radius2);
	 /* ... more stuff to record as needed .. */
	cg_set_top_comments(comment); 	/* set the comments for EPS header */

	cg_init(rot, expand, scale);	/* expand is not used in cg_init() but for compatibility */
	cg_aorigin(1.5, 1.5);		/* move origin to center of BoundingBox */


	/* interesting shape */
	sprintf(strbuff, "\n\n%% Radius %g\n", radius1);
	cg_postscript(strbuff);		/* enter comment into file for possible later editing */

	for(i=0; i<=200; i++) {
	    angle = PI*(float)i/100.0;
	    x = radius2 * cos(3.0*angle);
	    y = radius2 * sin(5.0*angle);
	    if(i) cg_line(x, y);
	    else  cg_move(x, y);		/* first point */
	}
	cg_closepath();

/*
	cg_postscript("\n\n%% Demo of falling back on injection of raw PostScript code.\n");
	cg_postscript("\n gsave 0.6 1.0 0.6 0.6 setgrayrgbcolor eofill grestore\n");
*/
	/* 4 lines below will do the same thing as the above raw PS code. */
	cg_gsave();
	cg_grayrgbcolor(0.6, 1.0, 0.6, 0.6);
	cg_eofill();
	cg_grestore();

/* void cg_grayrgbcolor(float gray, float r, float g, float b); */
	cg_grayrgbcolor(0.0,  0.0, 0.0, 1.0);	/* black for gray, and blue for color */
	cg_stroke();	/* strokes the two circles */
	cg_postscript("\n%% End of my plot.\n");

	cg_showpage();
}
コード例 #9
0
ファイル: cgl_view.c プロジェクト: komar007/freecg
int main(int argc, char *argv[])
{
	if (argc != 2) {
		printf("Usage: %s file.cgl\n", argv[0]);
		exit(-1);
	}
	SDL_Surface *screen;
	SDL_Surface *gfx = load_gfx("data/GRAVITY.GFX");
	if (!gfx) {
		fprintf(stderr, "read_gfx: %s\n", SDL_GetError());
		abort();
	}
	SDL_Surface *png = load_png("font.png");
	if (!png) {
		fprintf(stderr, "load_png: %s\n", SDL_GetError());
		abort();
	}
	SDL_Surface *osd = load_png("osd.png");
	if (!osd) {
		fprintf(stderr, "load_png: %s\n", SDL_GetError());
		abort();
	}
	struct cgl *cgl = read_cgl(argv[1], NULL);
	if (!cgl) {
		fprintf(stderr, "read_cgl: %s\n", SDL_GetError());
		abort();
	}
	cgl_preprocess(cgl);
	cg_init(cgl);
	make_collision_map(gfx, cmap);
	if (SDL_Init(SDL_INIT_VIDEO) != 0) {
		fprintf(stderr, "SDL failed: %s\n", SDL_GetError());
		abort();
	}
	screen = SDL_SetVideoMode(SCREEN_W, SCREEN_H, 0, MODE);
	gl_resize_viewport(screen->w, screen->h);
	struct texmgr *ttm = tm_request_texture(gfx);
	struct texmgr *fnt = tm_request_texture(png);
	struct texmgr *otm = tm_request_texture(osd);
	gl_init(cgl, ttm, fnt, otm);
	int t = SDL_GetTicks(),
	    nt = t,
	    time = t,
	    fr = 0;
	running = 1;
	mouse = 0;
	SDL_Event e;
	while (running) {
		while (SDL_PollEvent(&e))
			process_event(&e);
		time = SDL_GetTicks();
		nt = time - t;
		cg_step(cgl, time / 1000.0);
		if (nt > 100) {
			printf("%d frames in %d ms - %.1f fps\n",
					gl.frame - fr, nt, (float)(gl.frame - fr) / nt * 1000);
			if (cgl->status == Lost)
				printf("Dead. Game over!");
			if (cgl->status == Victory)
				printf("You won!");
			fflush(stdout);

			t += nt;
			fr = gl.frame;
		}
		gl.cam.nx = cgl->ship->x + SHIP_W/2.0;
		gl.cam.ny = cgl->ship->y + SHIP_H/2.0;
		gl_update_window(time / 1000.0);
	}
	free_cgl(cgl);
	return 0;
}
コード例 #10
0
/**
 * http://cse.csusb.edu/tongyu/courses/cs420/notes/lighting.php
 * Sombreado por medio de la técnica Gouraud Shading.
 */
int main(int argc, char* argv[])
{
	// Crear una ventana de 750x750 pixels.
	int cw = 750;
	int ch = 750;

	cg_init(cw, ch, NULL);

	// Actualizar la pantalla:
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	glMatrixMode(GL_PROJECTION);
	glViewport(0,0,cw, ch);
	glFrustum(-1,1,-1,1,1,1000);

	//Habilito la iluminación del pipeline estático de OpenGL.
	glEnable(GL_LIGHTING);
    glEnable(GL_DEPTH_TEST);

    // GL_LIGHT0
    Vec4 *vec4La0 = vec4Contructor(0.10f, 0.10f, 0.10f, 1.0f);
    Vec4 *vec4Ld0 = vec4Contructor(1.0f, 1.0f, 1.0f, 1.0f);
    Vec4 *vec4Ls0 = vec4Contructor(1.0f, 1.0f, 1.0f, 1.0f);
    Vec4 *vec4Lp0 = vec4Contructor(1.0f, 1.0f, 1.0f, 0.0f);
    loadLight(GL_LIGHT0, vec4La0, vec4Ld0, vec4Lp0, vec4Ls0);

    // GL_LIGHT1
    Vec4 *vec4La1 = vec4Contructor(0.5f,0.5f,0.5f,1.0f);
    Vec4 *vec4Ld1 = vec4Contructor(0.5f, 0.3f, 0.2f, 1.0f);
    Vec4 *vec4Ls1 = vec4Contructor(1.0f,1.0f,1.0f,1.0f);
    Vec4 *vec4Lp1 = vec4Contructor(1.0f, 1.0f, 1.0f, 0.0f);
    loadLight(GL_LIGHT1, vec4La1, vec4Ld1, vec4Lp1, vec4Ls1);
//    GLfloat spot_direction[] = { -1.0, -1.0, 0.0 };
//    glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 1.5);
//    glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.5);
//    glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.2);
//    glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 45.0);
//    glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, spot_direction);
//    glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 2.0);

    // GL_LIGHT2
    Vec4 *vec4La2 = vec4Contructor( 0.2f, 0.2f, 0.2f, 1.0f);
    Vec4 *vec4Ld2 = vec4Contructor(0.8f, 0.8f, 0.8, 1.0f );
    Vec4 *vec4Lp2 = vec4Contructor(-1.5f, 1.0f, -4.0f, 1.0f );
    Vec4 *vec4Ls2 = vec4Contructor(0.5f, 0.5f, 0.5f, 1.0f );
    loadLight(GL_LIGHT2, vec4La2, vec4Ld2, vec4Lp2, vec4Ls2);


    // TODO, GL_LIGHT3, GL_LIGHT4, GL_LIGHT5, GL_LIGHT6, GL_LIGHT7

    Obj* obj = obj_load("../Models/knight.obj");

	float ang = 0.0f;
	float pitch = 0.0f;
	float ang_vel = 1.0f;

	char done = 0;
	char wireframe = 0;
	char gourandShading = 0;
	char bfc = 0;
	char zbuff = 1;
    char enableLight0 = 0;
    char enableLight1 = 0;
    char enableLight2 = 0;
    char enableLight3 = 0;
    char enableLight4 = 0;
    char enableLight5 = 0;
    char enableLight6 = 0;
    char enableLight7 = 0;
	unsigned char key_pressed[1024];
	memset(key_pressed, 0, 1024);

	while (!done)
	{
		SDL_Event event;
		while(SDL_PollEvent(&event))
		{
			switch (event.type)
			{
				case SDL_KEYDOWN:
					key_pressed[event.key.keysym.sym] = 1;

					if (event.key.keysym.sym == SDLK_z)
					{
						zbuff = !zbuff;
						if(zbuff)
							glEnable(GL_DEPTH_TEST);
						else
							glDisable(GL_DEPTH_TEST);
						break;
					}
					else if (event.key.keysym.sym == SDLK_b)
					{
						bfc = !bfc;
						if(bfc)
						{
							glEnable(GL_CULL_FACE);
							glCullFace(GL_BACK);
							glFrontFace(GL_CW);
						}
						else
							glDisable(GL_CULL_FACE);
						break;
					}
					else if (event.key.keysym.sym == SDLK_m)
					{
						wireframe = !wireframe;
						if(wireframe)
							glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
						else
							glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
						break;
					}
                    else if (event.key.keysym.sym == SDLK_g)
                    {
                        gourandShading = !gourandShading;
                        if(gourandShading)
                            glShadeModel(GL_FLAT);
                        else
                            glShadeModel(GL_SMOOTH);
                        break;
                    }
                    else if (event.key.keysym.sym == SDLK_0)
                    {
                        enableLight0 = !enableLight0;
                        if(enableLight0) glEnable(GL_LIGHT0);
                        else glDisable(GL_LIGHT0);
                        break;
                    }
                    else if (event.key.keysym.sym == SDLK_1)
                    {
                        enableLight1 = !enableLight1;
                        if(enableLight1) glEnable(GL_LIGHT1);
                        else glDisable(GL_LIGHT1);
                        break;
                    }
                    else if (event.key.keysym.sym == SDLK_2)
                    {
                        enableLight2 = !enableLight2;
                        if(enableLight2) glEnable(GL_LIGHT2);
                        else glDisable(GL_LIGHT2);
                        break;
                    }
                    else if (event.key.keysym.sym == SDLK_3)
                    {
                        enableLight3 = !enableLight3;
                        if(enableLight3) glEnable(GL_LIGHT3);
                        else glDisable(GL_LIGHT3);
                        break;
                    }
                    else if (event.key.keysym.sym == SDLK_4)
                    {
                        enableLight4 = !enableLight4;
                        if(enableLight4) glEnable(GL_LIGHT4);
                        else glDisable(GL_LIGHT4);
                        break;
                    }
                    else if (event.key.keysym.sym == SDLK_5)
                    {
                        enableLight5 = !enableLight5;
                        if(enableLight5) glEnable(GL_LIGHT5);
                        else glDisable(GL_LIGHT5);
                        break;
                    }
                    else if (event.key.keysym.sym == SDLK_6)
                    {
                        enableLight6 = !enableLight6;
                        if(enableLight6) glEnable(GL_LIGHT6);
                        else glDisable(GL_LIGHT6);
                        break;
                    }
                    else if (event.key.keysym.sym == SDLK_7)
                    {
                        enableLight7 = !enableLight7;
                        if(enableLight7) glEnable(GL_LIGHT7);
                        else glDisable(GL_LIGHT7);
                        break;
                    }
					else if (event.key.keysym.sym != SDLK_ESCAPE)
						break;
				case SDL_QUIT :
					done = 1;
					break;
				case SDL_KEYUP:
					key_pressed[event.key.keysym.sym] = 0;

			}
		}

		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		glTranslatef(0.0f, 0.0f, -50.0f);
		glRotatef(pitch, 1.0f, 0.0f, 0.0f);
		glRotatef(ang, 0.0f, 1.0f, 0.0f);
		glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);

		if(key_pressed[SDLK_RIGHT]) ang += ang_vel;
		if(key_pressed[SDLK_LEFT]) ang -= ang_vel;
		if(key_pressed[SDLK_UP]) pitch += ang_vel;
		if(key_pressed[SDLK_DOWN]) pitch -= ang_vel;

		glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
		obj_render(obj);
		cg_repaint();
	}

	// Liberar recursos:

    obj_free(obj);
	cg_close();

	return 0;
}