예제 #1
0
/* carrega uma nova cena */
int load_cb(void) {
	char* filename = get_file_name();  /* chama o dialogo de abertura de arquivo */
	char buffer[30];

	if (filename==NULL) return 0;

	/* Le a cena especificada */
	scene = sceLoad( filename );
	if( scene == NULL ) return IUP_DEFAULT;

	camera = sceGetCamera( scene );
	eye = camGetEye( camera );
	width = camGetScreenWidth( camera );
	height = camGetScreenHeight( camera );
	yc=0;

	if (image) imgDestroy(image);
	image = imgCreate( width, height );
	IupSetfAttribute(label, "TITLE", "%3dx%3d", width, height);
	sprintf(buffer,"%3dx%3d", width, height);
	IupSetAttribute(canvas,IUP_RASTERSIZE,buffer);
	IupSetFunction (IUP_IDLE_ACTION, (Icallback) idle_cb);
	start_time  = clock(); 

	IupGLMakeCurrent(canvas);
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClear(GL_COLOR_BUFFER_BIT);
	glEnd();
	glFlush();
	IupGLSwapBuffers(canvas);  /* change the back buffer with the front buffer */

	return IUP_DEFAULT;
}
예제 #2
0
/* calcula uma linha da imagem a cada camada de idle */
int idle_cb(void)
{
	int x;
	/* Faz uma linha de pixels por vez */
	if (yc<height) {
		IupGLMakeCurrent(canvas);
		glBegin(GL_POINTS);
		for( x = 0; x < width; ++x ) {
			Color pixel;
			Vector ray;				

			ray = camGetRay( camera, x, yc );
			pixel = rayTrace( scene, eye, ray, 0 );

			imageSetPixel( image, x, yc, pixel );
			glColor3f((float)pixel.red,(float)pixel.green,(float)pixel.blue);
			glVertex2i(x,yc);

		}
		glEnd();
		glFlush();
		IupGLSwapBuffers(canvas);  /* change the back buffer with the front buffer */
		yc++;
	}
	else {
		IupSetFunction (IUP_IDLE_ACTION, (Icallback) NULL); /* a imagem ja' esta' completa */
		finish_time = clock();
		duration = (double)(finish_time - start_time)/CLOCKS_PER_SEC;
		IupSetfAttribute(label, "TITLE", "tempo=%.3lf s", duration);
	}

	return IUP_DEFAULT;
}
예제 #3
0
/* function called when the canvas is exposed in the screen.  self is the iuphandle of the canvas */
int repaint_cb(Ihandle *self) 
{
  int x,y;
  IupGLMakeCurrent(self);                /* all OpenGL primitives will be directed to this canvas */
  glClearColor(0.3f, 0.3f, 0.3f, 1.0f);  /* dark grey color in the RGBA mode A is the alpha channel (ignore) */
  glClear(GL_COLOR_BUFFER_BIT);          /* clear the color buffer */

  if (gc.image!=NULL) 
  {
	  int h = imgGetHeight(gc.image);
	  int w = imgGetWidth(gc.image);
	  /* assing to each pixel of the canvas the color of the corresponding pixel in the image */
	  glBegin(GL_POINTS);   
	  for (y=0;y<h;y++) {
		  for (x=0;x<w;x++) {
			  float r,g,b;
			  imgGetPixel3f(gc.image,x,y,&r,&g,&b); /* gets the RGB value the pixel (x,y) */ 
			  glColor3f(r,g,b);        /* define a current color in OpenGL */
			  glVertex2i(x,y);         /* paint the pixel */
		  }

	  }
	  glEnd();
  }
  IupGLSwapBuffers(self);  /* change the back buffer with the front buffer */
  return IUP_DEFAULT; /* returns the control to the main loop */
}
예제 #4
0
static void drawTestGL(Ihandle* ih)
{
  Ihandle* glcanvas = IupGetAttributeHandle(ih, "PREVIEWGLCANVAS");
  if (glcanvas)
  {
    int w = IupGetInt(ih, "PREVIEWWIDTH");
    int h = IupGetInt(ih, "PREVIEWHEIGHT");

    IupGLMakeCurrent(glcanvas);
    glViewport(0,0,w,h);

    glClearColor(1.0, 0.0, 1.0, 1.f);  /* pink */
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glColor3f(1.0,0.0,0.0);  /* red */
    glBegin(GL_QUADS); 
    glVertex2f(0.9f,0.9f); 
    glVertex2f(0.9f,-0.9f); 
    glVertex2f(-0.9f,-0.9f); 
    glVertex2f(-0.9f,0.9f); 
    glEnd();

    IupGLSwapBuffers(glcanvas);
  }
  else
    drawTest(ih);
}
예제 #5
0
int ERN2DViewMethod::Idle_Action_CB (Ihandle* cnv_renderer)
{
  IupGLMakeCurrent (cnv_renderer);
  if (m_redisplay || m_auto_redisplay)
  {
    if (m_outdated)
    {
      if (!m_renderer.m_glsl_preintegrated_texture || Viewer::Instance ()->m_volumename.compare (m_volumename) != 0)
      {
        m_volumename = Viewer::Instance ()->m_volumename;
        m_renderer.ReloadVolume (Viewer::Instance ()->m_volume, Viewer::Instance ()->m_transfer_function);
      }

      UpdateIupUserInterface ();
      m_outdated = false;
    }

    if (m_renderer.m_glsl_preintegrated_texture)
    {
      m_renderer.Render (Viewer::Instance ()->m_CurrentWidth, Viewer::Instance ()->m_CurrentHeight);
      IupGLSwapBuffers (cnv_renderer);
    }
    m_redisplay = false;
  }
  return IUP_DEFAULT;
}
예제 #6
0
static int motion_cb(Ihandle *ih,int x,int y,char* status)
{
  (void)status;

  if (move)
  {
    double dif_x, dif_y;
    double dx, dy, dz;
    double x1, y1, z1;
    double x2, y2, z2;
    double angle, norma;
    int height = IupGetInt2(ih, "RASTERSIZE");
    double mv[16];
    double pm[16];
    int    vp[4];

    IupGLMakeCurrent(ih);

    glGetDoublev(GL_MODELVIEW_MATRIX, mv);
    glGetDoublev(GL_PROJECTION_MATRIX, pm);
    glGetIntegerv(GL_VIEWPORT, vp);

    dif_x = x - pos_x;
    dif_y = y - pos_y;

    if (dif_x == 0 && dif_y == 0)
      return IUP_DEFAULT;

    pos_x = x;
    pos_y = y;

    angle = sqrt(dif_x*dif_x + dif_y*dif_y);

    gluUnProject(pos_x, INVERT_Y(pos_y), 0.0,
      mv, pm, vp,
      &x1, &y1, &z1);
    gluUnProject((double)(dif_y + pos_x), (double)(dif_x + INVERT_Y(pos_y)), 0.0,
      mv, pm, vp,
      &x2, &y2, &z2);
    dx = x2-x1; dy = y2-y1; dz = z2-z1;
    norma = sqrt(dx*dx + dy*dy + dz*dz);
    dx /= norma; dy /= norma; dz /= norma;

    glMatrixMode(GL_MODELVIEW);
    glTranslated(0.5, 0.5, 0.5);
    glRotated (angle, dx, dy, dz);
    glTranslated(-0.5, -0.5, -0.5);
    glGetDoublev(GL_MODELVIEW_MATRIX, model_view_matrix);
    use_model_matrix = 1;

    draw_cube();
  
    IupGLSwapBuffers(ih); 
  }
  return IUP_DEFAULT;
}
예제 #7
0
static int action(Ihandle *ih)
{
  IupGLMakeCurrent(ih);

  init();

  draw_cube();

  IupGLSwapBuffers(ih); 

  return IUP_DEFAULT;
}
예제 #8
0
/* - Callback de repaint do canvas  */
int repaint_cb(Ihandle *self)
{
	int w,h;
	int x,y;
	Color rgb;

	if (yc==0){  /* e' a primeira vez: limpa o canvas */
		IupGLMakeCurrent(self);
		glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		IupGLSwapBuffers(self);  /* change the back buffer with the front buffer */
		glFlush();
	}

	if (yc!=height) { /* esta callback so'desenha depois que o algoritmo termina a imagem */
		return IUP_DEFAULT; 
	}

	w = imgGetWidth(image);
	h = imgGetHeight(image);
	IupGLMakeCurrent(self);
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClear(GL_COLOR_BUFFER_BIT);

	glBegin(GL_POINTS);
	for (y=0;y<h;y++) {
		for (x=0; x<w; x++) {
			rgb = imageGetPixel(image, x, y);
			glColor3f((float)rgb.red,(float)rgb.green,(float)rgb.blue);
			glVertex2i(x,y);
		}
	}
	glEnd();

	IupGLSwapBuffers(self);  /* change the back buffer with the front buffer */

	glFlush();
	return IUP_DEFAULT; /* retorna o controle para o gerenciador de eventos */
} 
예제 #9
0
파일: iupglview.c 프로젝트: LuaDist/im
int app_repaint_cb(Ihandle* self)
{
  unsigned char* gl_data = (unsigned char*)IupGetAttribute(self, "APP_GL_DATA");
  int width = IupGetInt(self, "APP_GL_WIDTH");
  int height = IupGetInt(self, "APP_GL_HEIGHT");
  IupGLMakeCurrent(self);        /* activates this GL Canvas as the current drawing area. */
  glClear(GL_COLOR_BUFFER_BIT);  /* clears the back buffer */

  if (gl_data)
  {
    /* Draws the captured image at (0,0) */
    glRasterPos2f(0.f, 0.f); 
    glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, gl_data);
  }

  IupGLSwapBuffers(self);        /* swap data from back buffer to front buffer */
  return IUP_DEFAULT;
} 
예제 #10
0
파일: example4_2.c 프로젝트: sanikoyes/iup
int canvas_action_cb(Ihandle* canvas)
{
  int x, y, canvas_width, canvas_height;
  void* gldata;
  unsigned int ri, gi, bi;
  imImage* image;
  Ihandle* config = (Ihandle*)IupGetAttribute(canvas, "CONFIG");
  const char* background = IupConfigGetVariableStrDef(config, "MainWindow", "Background", "255 255 255");

  IupGetIntInt(canvas, "DRAWSIZE", &canvas_width, &canvas_height);

  IupGLMakeCurrent(canvas);

  /* OpenGL configuration */
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);           /* image data alignment is 1 */

  glViewport(0, 0, canvas_width, canvas_height);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(0, canvas_width, 0, canvas_height, -1, 1);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  /* draw the background */
  sscanf(background, "%u %u %u", &ri, &gi, &bi);
  glClearColor(ri / 255.f, gi / 255.f, bi / 255.f, 1);
  glClear(GL_COLOR_BUFFER_BIT);

  /* draw the image at the center of the canvas */
  image = (imImage*)IupGetAttribute(canvas, "IMAGE");
  if (image)
  {
    x = (canvas_width - image->width) / 2;
    y = (canvas_height - image->height) / 2;
    gldata = (void*)imImageGetAttribute(image, "GLDATA", NULL, NULL);
    glRasterPos2i(x, y);  /* this will not work for negative values, OpenGL limitation */
    glDrawPixels(image->width, image->height, GL_RGB, GL_UNSIGNED_BYTE, gldata);  /* no zoom support, must use texture */
  }

  IupGLSwapBuffers(canvas);
  return IUP_DEFAULT;
}
예제 #11
0
파일: glcube.c 프로젝트: defdef/iup
/* function called when the canvas is exposed in the screen */
static int repaint_cb(Ihandle *self) 
{
  IupGLMakeCurrent(self);
  glClearColor(0.3f, 0.3f, 0.3f, 1.0f);  /* White */
  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  glEnable(GL_DEPTH_TEST);

  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();  /* saves current model view in a stack */
      glTranslatef( 0.0f, 0.0f , 0.0f );
      glScalef( 1.0f, 1.0f, 1.0f );
      glRotatef(t,0,0,1);
      colorCube();
   glPopMatrix();
 
  IupGLSwapBuffers(self);  /* change the back buffer with the front buffer */

  return IUP_DEFAULT; /* returns the control to the main loop */
}
예제 #12
0
/* calcula uma linha da imagem a cada camada de idle */
int idle_cb(void)
{
	int x;
	double ray[VECTOR];
	float pixel[COLOR];

  /* Faz uma linha de pixels por vez */
  if (yc < height) {

    IupGLMakeCurrent(canvas);
    glBegin(GL_POINTS);
    {
      for (x = 0; x < width; ++x) {

        camGetRay(camera, x, yc, ray);
        rayTrace(scene, eye, ray, 0, pixel);

        imageSetPixel(image, x, yc, pixel);
        glColor3f((float) pixel[RED], (float) pixel[GREEN], (float) pixel[BLUE]);
        glVertex2i(x, yc);

      }
    }
    glEnd();

    glFlush();

    IupGLSwapBuffers(canvas);
    
    yc++;
  } else {

		IupSetFunction (IUP_IDLE_ACTION, (Icallback) NULL); /* a imagem ja' esta' completa */
		finish_time = clock();
		duration = (double)(finish_time - start_time)/CLOCKS_PER_SEC;
		IupSetfAttribute(label, "TITLE", "tempo=%.3lf s", duration);

		glFlush();
	}


	return IUP_DEFAULT;
}
예제 #13
0
static int action(Ihandle *ih)
{
  static int first = 1;
  IupGLMakeCurrent(ih);

  if (first)
  {
    init();
    first = 0;
  }

  glClear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

  draw_cube();

  glFlush();
  IupGLSwapBuffers(ih); 

  return IUP_DEFAULT;
}
예제 #14
0
static int motion_cb(Ihandle *ih,int x,int y,char* status)
{
  (void)status;

  if (move)
  {
    double dif_x, dif_y;
    double dx, dy, dz;
    double x1, y1, z1;
    double x2, y2, z2;
    double angle, norma;
    int height = IupGetInt2(ih, "RASTERSIZE");

    IupGLMakeCurrent(ih);

    dif_x = x - pos_x;
    dif_y = y - pos_y;

    pos_x = x;
    pos_y = y;

    angle = sqrt(dif_x*dif_x + dif_y*dif_y);

    unproject (pos_x, INVERT_Y(pos_y), &x1, &y1, &z1);
    unproject ((double)(dif_y+pos_x), (double)(dif_x+INVERT_Y(pos_y)), &x2, &y2, &z2);
    dx = x2-x1; dy = y2-y1; dz = z2-z1;
    norma = sqrt(dx*dx + dy*dy + dz*dz);
    dx /= norma; dy /= norma; dz /= norma;

    glTranslated(0.5, 0.5, 0.5);
    glRotated (angle, dx, dy, dz);
    glTranslated(-0.5, -0.5, -0.5);

    draw_cube();
  
    glFlush();
    IupGLSwapBuffers(ih); 
  }
  return IUP_DEFAULT;
}
예제 #15
0
void TransferFunctionsViewer::Redraw ()
{
  IupGLMakeCurrent (m_iup_canvas);
  
  vr::TransferFunction *tf = Viewer::Instance ()->m_transfer_function;
  if (tf)
  {
    for (int i = 0; i < 256; i++)
    {
      lqc::Vector4d c = tf->Get (i);
      for (int j = 0; j < 50; j++)
      {
        if (id < 2)
        {
          m_pixels[i * 4 + j * 258 * 4] = c.x;
          m_pixels[i * 4 + j * 258 * 4 + 1] = c.y;
          m_pixels[i * 4 + j * 258 * 4 + 2] = c.z;
          m_pixels[i * 4 + j * 258 * 4 + 3] = 1.0;
        }
        else
        {
          m_pixels[i * 4 + j * 258 * 4] = c.w;
          m_pixels[i * 4 + j * 258 * 4 + 1] = c.w;
          m_pixels[i * 4 + j * 258 * 4 + 2] = c.w;
          m_pixels[i * 4 + j * 258 * 4 + 3] = 1.0;
        }
      }
    }
  }
  
  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glDrawPixels (258, 50, GL_RGBA, GL_FLOAT, m_pixels);
  
  id = (id + 1) % 4;


  IupGLSwapBuffers (m_iup_canvas);
}
예제 #16
0
int redraw(Ihandle *self, float x, float y)
{
  int w, h;
  char *size = IupGetAttribute(self, "RASTERSIZE");
  sscanf(size, "%dx%d", &w, &h);

  IupGLMakeCurrent(self);
  
  glViewport(0, 0, w, h);
  glClearColor(1.0, 1.0, 1.0, 1.f);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glColor3f(1.0,0.0,0.0);
  glBegin(GL_QUADS); 
    glVertex2f( 0.9f,  0.9f); 
    glVertex2f( 0.9f, -0.9f); 
    glVertex2f(-0.9f, -0.9f); 
    glVertex2f(-0.9f,  0.9f); 
  glEnd();

  IupGLSwapBuffers(self); 

  return IUP_DEFAULT;
}
예제 #17
0
파일: iupmain.c 프로젝트: Vulcanior/IUP
void SimpleFlush(void)
{
  IupGLSwapBuffers(IupGetHandle("SimpleCanvas"));
}
예제 #18
0
static int GLSwapBuffers(lua_State *L)
{  
   IupGLSwapBuffers(iuplua_checkihandle(L,1));
   return 0;
}