LINUX.ORG.RU

Растровое изображение по полярным координатам точек в OpenGL


0

1

Привет всем! Мне необходимо вывести постоянно обновляющееся растровое изображение круга, заданное полярными координатами. Моя программа:

#include <glade/glade.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gtk/gtk.h>
#include <gtk/gtkgl.h>
#include <GL/gl.h>

#define PI          (3.14159265358979323846)
#define DEGRA       (0.01745329251994329547)

#define r_screen  380 	// радиус круга на экране
#define r0	 1024	//количество точек в радиусе
#define fi0	 4096 	//количество углов

int i,r,fi;	// счетчики

GLfloat Polar[fi0][r0];			// матрица с полярными координатами точек
GLfloat Dekart[r_screen*2][r_screen*2]; // матрица с декартовыми координатами точек

int x_coords[fi0][r0];
int y_coords[fi0][r0];

GLint vertices[r_screen*r_screen*4*3]; //вершинный массив
GLfloat colors[r_screen*r_screen*4*4]; //цветовой массив

  GdkGLConfig *glconfig;
  GladeXML *xml;
  GtkWidget *window1;
  GtkWidget *drawingarea1;



//---------------Запонение массивов с координатами------------------//
void coordinates()
{
  for (fi = fi0; fi < fi0; fi++) //вычисляем значения cos и sin для всех углов fi
  {
    double cosinus=cos(2*PI*fi/fi0); 
    double   sinus=sin(2*PI*fi/fi0);
    
    for (r = 0; r < r0; r++)//вычисляем декартовы координаты всех точек на углу fi
    {
     x_coords[fi][r]=(int)round((r*cosinus*r_screen/r0)+r_screen); 
     y_coords[fi][r]=(int)round((r*sinus*r_screen/r0)+r_screen);
    }
  }
}


//-------------------Заполнение массивов для OpenGL-------------------//
void checkImage()
{
if (fi==0) { fi=fi0;}
else {fi--;}
   
    for (r = 0; r < r0; r++)
    {
     Polar[fi][r]=rand()%255;
	int x=x_coords[fi][r];
	int y=y_coords[fi][r];
	Dekart[x][y]=Polar[fi][r];// присвоение элементу массива Dekart[x][y]
							// значения соответствующего элемента массива Polar[fi][r]
	int n=x+y*r_screen*2; //номер точки в массивах для OpenGL
	vertices[n*3]  =x-r_screen;	//x
	vertices[n*3+1]=y-r_screen;	//y
	vertices[n*3+2]=0;		//z

 	colors[n*4] = Dekart[x][y]/255;		//R
	colors[n*4+1]=0;			//G
	colors[n*4+2]=0;			//B
	colors[n*4+3]=1;			//A  
    }

}
//-----------------------Обновление--------------------------------//
static gboolean idle (GtkWidget *widget)
{
  gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
  gdk_window_process_updates (widget->window, FALSE);
  return TRUE;
}


//-----------------------REALISE-------------------------------------//
void on_drawingarea1_realize (GtkWidget *widget, gpointer   user_data)
{ 
coordinates();

  GdkGLContext  *glcontext  = gtk_widget_get_gl_context  (widget);
  GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);

  if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
    return;

	  glViewport (0, 0, 800, 800);
	  glMatrixMode (GL_PROJECTION);
	  glLoadIdentity (); 
	  glOrtho (-800/2, 800/2, -800/2, 800/2, -50, 50);
	  glMatrixMode (GL_MODELVIEW);
	  glLoadIdentity(); 
	  glTranslatef(-10,0,0);
 	  g_timeout_add_full (GDK_PRIORITY_REDRAW,0,
                                 (GSourceFunc) idle,
                                 widget,
                                 NULL);
  gdk_gl_drawable_gl_end (gldrawable);
}
//---------------------EXPOSE-EVENT-----------------------------//
gboolean
on_drawingarea1_expose_event (GtkWidget       *widget,
                              GdkEventExpose  *event,
                              gpointer         user_data)
{  
  GdkGLContext  *glcontext  = gtk_widget_get_gl_context  (widget);
  GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);

  /*** OpenGL BEGIN ***/
  if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
    return FALSE;
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
  checkImage();
  glVertexPointer (3,GL_INT,0,vertices);
  glColorPointer  (4,GL_FLOAT, 0,colors);
  glDrawArrays (GL_POINTS, 0, r_screen*r_screen*4);
glDisableClientState (GL_VERTEX_ARRAY);
glDisableClientState (GL_COLOR_ARRAY);

  /* Swap buffers */
  if (gdk_gl_drawable_is_double_buffered (gldrawable))
  gdk_gl_drawable_swap_buffers (gldrawable);
  else
  glFlush ();

  gdk_gl_drawable_gl_end (gldrawable);
  /*** OpenGL END ***/

  return TRUE;
}

//----------------------------MAIN-----------------------------------//
int main (int   argc,      char *argv[])
{
  gtk_init (&argc, &argv);
  gtk_gl_init (&argc, &argv);
  glconfig = gdk_gl_config_new_by_mode (
					GDK_GL_MODE_RGB    |
                                        GDK_GL_MODE_DEPTH  |
                                        GDK_GL_MODE_DOUBLE
				       );
 xml = glade_xml_new ("simple.glade", NULL, NULL);
 glade_xml_signal_autoconnect (xml);

 window1 = glade_xml_get_widget (xml, "window1");
 gtk_window_set_decorated(GTK_WINDOW (window1), FALSE);
 gtk_window_fullscreen(GTK_WINDOW (window1));
 drawingarea1 = glade_xml_get_widget (xml, "drawingarea1");
 gtk_widget_set_gl_capability (drawingarea1,
                                glconfig,
                                NULL,
                                TRUE,
                                GDK_GL_RGBA_TYPE);
  gtk_widget_show (window1);
  gtk_main ();
  return 0;
}
В функции checkImage() я заполняю массив Polar[fi][r](fi - угол, r - радиус в полярной системе координат) рандомными данными для текущего угла fi. Затем преобразовываю полярные координаты в прямоугольные x и y с помощью заранее посчитанных и округленных до int значений в функции coordinates(). По полученным значениям x и у присваиваем элементам массива Dekart[x][y] соответствующие значения элементов Polar[fi][r]. Потом выводим Dekart[x][y] в OpenGL точками с соответствующими градациями красного.

А проблема в том, что ОпенГЛ ничего не рисует...)

Если тупо забить Dekart[x][y] данными и послать все это на отрисовку, то все нормально рисуется...

void checkImage()
{
for(y=0;y<r_screen*2;y++)
{
  for (x=0;x<r_screen*2;x++)
  {
	Dekart[x][y]=rand()%255;
	int n=x+y*r_screen*2;
	vertices[n*3]  =x-r_screen;	//x
	vertices[n*3+1]=y-r_screen;	//y
	vertices[n*3+2]=0;		//z

 	colors[n*4] = Dekart[x][y]/255;		//R
	colors[n*4+1]=0;			//G
	colors[n*4+2]=0;			//B
	colors[n*4+3]=1;			//A
    }
 }
}

Vitaly1988 ()
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.