octave: src/gl-render.cc comparison

comparison src/gl-render.cc @ 11586:12df7854fa7c

strip trailing whitespace from source files

author	John W. Eaton <jwe@octave.org>
date	Thu, 20 Jan 2011 17:24:59 -0500
parents	1473d0cf86d2
children	f4689107dd8c

comparison

equal deleted inserted replaced

-:1473d0cf86d2
+:12df7854fa7c
 {
 protected:
 class texture_rep
 {
 public:
 texture_rep (void)
 : id (), w (), h (), tw (), th (), tx (), ty (),
 valid (false), count (1)
 { }
 texture_rep (GLuint id_arg, int w_arg, int h_arg, int tw_arg, int th_arg)
 : id (id_arg), w (w_arg), h (h_arg), tw (tw_arg), th (th_arg),
 tx (double(w)/tw), ty (double(h)/th), valid (true),
 void bind (int mode = GL_TEXTURE_2D) const
 { rep->bind (mode); }
 void tex_coord (double q, double r) const
 { rep->tex_coord (q, r); }
 bool is_valid (void) const
 { return rep->valid; }
 };
 static int
 bool is_filled (void) const { return fill; }
 private:
 static void CALLBACK tess_begin (GLenum type, void *t)
 { reinterpret_cast<opengl_tesselator *> (t)->begin (type); }
 static void CALLBACK tess_end (void *t)
 { reinterpret_cast<opengl_tesselator *> (t)->end (); }
 static void CALLBACK tess_vertex (void *v, void *t)
 { reinterpret_cast<opengl_tesselator *> (t)->vertex (v); }
 static void CALLBACK tess_combine (GLdouble c[3], void *v[4], GLfloat w[4],
 void **out,  void *t)
 { reinterpret_cast<opengl_tesselator *> (t)->combine (c, v, w, out); }
 static void CALLBACK tess_edge_flag (GLboolean flag, void *t)
 { reinterpret_cast<opengl_tesselator *> (t)->edge_flag (flag); }
 static void CALLBACK tess_error (GLenum err, void *t)
 { reinterpret_cast<opengl_tesselator *> (t)->error (err); }
 private:
 GLUtesselator *glu_tess;
 float specular_exp;
 // reference counter
 int count;
 vertex_data_rep (void)
 : coords (), color (), normal (), alpha (),
 ambient (), diffuse (), specular (), specular_exp (),count (1) { }
 vertex_data_rep (const Matrix& c, const Matrix& col, const Matrix& n,
 double a, float as, float ds, float ss, float se)
 vertex_data::vertex_data_rep *v
 = reinterpret_cast<vertex_data::vertex_data_rep *> (data);
 //printf("patch_tesselator::vertex (%g, %g, %g)\n", v->coords(0), v->coords(1), v->coords(2));
 // FIXME: why did I need to keep the first vertex of the face
 // in JHandles? I think it's related to the fact that the
 // tessellation process might re-order the vertices, such that
 // the first one you get here might not be the first one of the face;
 // but I can't figure out the actual reason.
 if (color_mode > 0 && (first || color_mode == 2))
 {
 void
 opengl_renderer::draw (const graphics_object& go)
 {
 if (! go.valid_object ())
 return;
 const base_properties& props = go.get_properties ();
 if (go.isa ("figure"))
 draw_figure (dynamic_cast<const figure::properties&> (props));
 else if (go.isa ("axes"))
 // setup OpenGL transformation
 Matrix x_zlim = props.get_transform_zlim ();
 Matrix x_mat1 = props.get_opengl_matrix_1 ();
 Matrix x_mat2 = props.get_opengl_matrix_2 ();
 xZ1 = x_zlim(0)-(x_zlim(1)-x_zlim(0))/2;
 xZ2 = x_zlim(1)+(x_zlim(1)-x_zlim(0))/2;
 #if defined (HAVE_FRAMEWORK_OPENGL)
 GLint vw[4];
 glClear (GL_DEPTH_BUFFER_BIT);
 // store axes transformation data
 xform = props.get_transform ();
 // draw axes object
 GLboolean antialias;
 glGetBooleanv (GL_LINE_SMOOTH, &antialias);
 glDisable (GL_LINE_SMOOTH);
 Matrix xlim = xform.xscale (props.get_xlim ().matrix_value ());
 Matrix ylim = xform.yscale (props.get_ylim ().matrix_value ());
 Matrix zlim = xform.zscale (props.get_zlim ().matrix_value ());
 double x_min = xlim(0), x_max = xlim(1);
 double y_min = ylim(0), y_max = ylim(1);
 {
 // FIXME: as tick text is transparent, shouldn't be
 //        drawn after axes object, for correct rendering?
 Matrix b = render_text (xticklabels(i),
 tickpos(i,0), tickpos(i,1), tickpos(i,2),
 halign, valign);
 wmax = std::max (wmax, static_cast<int> (b(2)));
 hmax = std::max (hmax, static_cast<int> (b(3)));
 }
 }
 }
 }
 glEnd ();
 set_linestyle ("-", true);
 }
 // minor tick marks
 if (do_xminortick)
 {
 if (tick_along_z)
 {
 {
 gh_manager::get_object (props.get_xlabel ()).set ("visible", "off");
 }
 // Y grid
 if (ystate != AXE_DEPTH_DIR && visible)
 {
 bool do_ygrid = (props.is_ygrid () && (gridstyle != "none"));
 bool do_yminorgrid = (props.is_yminorgrid () && (minorgridstyle != "none"));
 bool do_yminortick = props.is_yminortick ();
 {
 // FIXME: as tick text is transparent, shouldn't be
 //        drawn after axes object, for correct rendering?
 Matrix b = render_text (yticklabels(i),
 tickpos(i,0), tickpos(i,1), tickpos(i,2),
 halign, valign);
 wmax = std::max (wmax, static_cast<int> (b(2)));
 hmax = std::max (hmax, static_cast<int> (b(3)));
 }
 }
 }
 else
 {
 gh_manager::get_object (props.get_ylabel ()).set ("visible", "off");
 }
 // Z Grid
 if (zstate != AXE_DEPTH_DIR && visible)
 {
 bool do_zgrid = (props.is_zgrid () && (gridstyle != "none"));
 {
 // FIXME: as tick text is transparent, shouldn't be
 //        drawn after axes object, for correct rendering?
 Matrix b = render_text (zticklabels(i),
 tickpos(i,0), tickpos(i,1), tickpos(i,2),
 halign, valign);
 wmax = std::max (wmax, static_cast<int> (b(2)));
 hmax = std::max (hmax, static_cast<int> (b(3)));
 }
 }
 // Title
 text::properties& title_props =
 reinterpret_cast<text::properties&> (gh_manager::get_object (props.get_title ()).get_properties ());
 if (! title_props.get_string ().empty () && title_props.positionmode_is("auto"))
 {
 ColumnVector p = xform.untransform (bbox(0)+bbox(2)/2, (bbox(1)-10),
 (x_zlim(0)+x_zlim(1))/2, true);
 title_props.set_position (p.extract_n(0, 3).transpose ());
 }
 if (flag)
 glEnd ();
 }
 set_linewidth (0.5);
 set_linestyle ("-");
 }
 set_clipping (false);
 lc, fc);
 }
 end_marker ();
 }
 set_clipping (props.is_clipping ());
 }
 void
 opengl_renderer::draw_surface (const surface::properties& props)
 if (fl_mode > 0)
 {
 for (int k = 0; k < 3; k++)
 cb[k] *= as;
 glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
 for (int k = 0; k < 3; k++)
 cb[k] = ds * c(j-1, i-1, k);
 glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
 }
 }
 if (fl_mode > 0)
 {
 for (int k = 0; k < 3; k++)
 cb[k] *= as;
 glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
 for (int k = 0; k < 3; k++)
 cb[k] = ds * c(j-1, i, k);
 glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
 }
 }
 + n(j-1,i,2) * n(j-1,i,2));
 glNormal3d (n(j-1,i,0)/d, n(j-1,i,1)/d, n(j-1,i,2)/d);
 }
 glVertex3d (x(j1,i), y(j-1,i2), z(j-1,i));
 // Vertex 3
 if (fc_mode == 3)
 tex.tex_coord (double (i) / (zc-1), double (j) / (zr-1));
 else if (fc_mode == 2)
 {
 if (fl_mode > 0)
 {
 for (int k = 0; k < 3; k++)
 cb[k] *= as;
 glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
 for (int k = 0; k < 3; k++)
 cb[k] = ds * c(j, i, k);
 glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
 }
 }
 if (fl_mode > 0)
 {
 for (int k = 0; k < 3; k++)
 cb[k] *= as;
 glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
 for (int k = 0; k < 3; k++)
 cb[k] = ds * c(j, i-1, k);
 glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
 }
 }
 + n(j,i-1,1) * n(j,i-1,1)
 + n(j,i-1,2) * n(j,i-1,2));
 glNormal3d (n(j,i-1,0)/d, n(j,i-1,1)/d, n(j,i-1,2)/d);
 }
 glVertex3d (x(j2,i-1), y(j,i1), z(j,i-1));
 // Vertex 2
 if (ec_mode == 2)
 {
 for (int k = 0; k < 3; k++)
 cb[k] = c(j, i, k);
 + n(j,i,1) * n(j,i,1)
 + n(j,i,2) * n(j,i,2));
 glNormal3d (n(j,i,0)/d, n(j,i,1)/d, n(j,i,2)/d);
 }
 glVertex3d (x(j2,i), y(j,i2), z(j,i));
 glEnd ();
 }
 }
 }
 for (int i = 0; i < zc; i++)
 {
 if (y_mat)
 i1 = i;
 for (int j = 0; j < zr; j++)
 {
 if (clip(j,i))
 continue;
 bool has_z = (v.columns () > 2);
 bool has_facecolor = false;
 bool has_facealpha = false;
 int fc_mode = ((props.facecolor_is("none")
 || props.facecolor_is_rgb ()) ? 0 :
 (props.facecolor_is("flat") ? 1 : 2));
 int fl_mode = (props.facelighting_is ("none") ? 0 :
 (props.facelighting_is ("flat") ? 1 : 2));
 int fa_mode = (props.facealpha_is_double () ? 0 :
 (props.facealpha_is ("flat") ? 1 : 2));
 int ec_mode = ((props.edgecolor_is("none")
 || props.edgecolor_is_rgb ()) ? 0 :
 (props.edgecolor_is("flat") ? 1 : 2));
 int el_mode = (props.edgelighting_is ("none") ? 0 :
 (props.edgelighting_is ("flat") ? 1 : 2));
 int ea_mode = (props.edgealpha_is_double () ? 0 :
 (props.edgealpha_is ("flat") ? 1 : 2));
 Matrix fcolor = props.get_facecolor_rgb ();
 Matrix ecolor = props.get_edgecolor_rgb ();
 float as = props.get_ambientstrength ();
 float ds = props.get_diffusestrength ();
 float ss = props.get_specularstrength ();
 float se = props.get_specularexponent ();
 c = props.get_color_data ().matrix_value ();
 if (c.rows () == 1)
 {
 // Single color specifications, we can simplify a little bit
 if (fc_mode > 0)
 {
 fcolor = c;
 fc_mode = 0;
 }
 tess.begin_contour ();
 for (int j = 0; j < count_f(i); j++)
 {
 vertex_data::vertex_data_rep *vv = vdata[i+j*fr].get_rep ();
 tess.add_vertex (vv->coords.fortran_vec (), vv);
 }
 tess.end_contour ();
 tess.end_polygon ();
 {
 octave_value cdata = props.get_color_data ();
 dim_vector dv (cdata.dims ());
 int h = dv(0), w = dv(1);
 bool ok = true;
 Matrix x = props.get_xdata ().matrix_value ();
 Matrix y = props.get_ydata ().matrix_value ();
 if (w > 1 && x(1) == x(0))
 x(1) = x(1) + (w-1);
 if (h > 1 && y(1) == y(0))
 y(1) = y(1) + (h-1);
 const ColumnVector p0 = xform.transform (x(0), y(0), 0);
 const ColumnVector p1 = xform.transform (x(1), y(1), 0);
 // image pixel size in screen pixel units
 float pix_dx, pix_dy;
 // image pixel size in normalized units
 float nor_dx, nor_dy;
 if (w > 1)
 {
 pix_dx = (p1(0) - p0(0))/(w-1);
 nor_dx = (x(1) - x(0))/(w-1);
 }
 else
 else // clip to viewport
 {
 GLfloat vp[4];
 glGetFloatv(GL_VIEWPORT, vp);
 // FIXME -- actually add the code to do it!
 }
 if (i0 >= i1 || j0 >= j1)
 return;
 glPixelZoom (pix_dx, -pix_dy);
 glRasterPos3d (im_xmin + nor_dx*j0, im_ymin + nor_dy*i0, 0);
 {
 ok = false;
 warning ("opengl_texture::draw: invalid image data type (expected double, uint16, or uint8)");
 }
 }
 else
 {
 ok = false;
 warning ("opengl_texture::draw: invalid image size (expected n*m*3 or n*m)");
 }
 glPixelZoom (1, 1);
 void
 opengl_renderer::draw_marker (double x, double y, double z,
 const Matrix& lc, const Matrix& fc)
 {
 ColumnVector tmp = xform.transform (x, y, z, false);
 glLoadIdentity ();
 glTranslated (tmp(0), tmp(1), -tmp(2));
 if (filled_marker_id > 0 && fc.numel () > 0)
 {
 case 'p':
 {
 double ang;
 double r;
 double dr = 1.0 - sin(M_PI/10)/sin(3*M_PI/10)*1.02;
 glBegin ((filled ? GL_POLYGON : GL_LINE_LOOP));
 for (int i = 0; i < 2*5; i++)
 {
 ang = (-0.5 + double(i+1)/5) * M_PI;
 r = 1.0 - (dr * fmod(double(i+1), 2.0));
 case 'h':
 {
 double ang;
 double r;
 double dr = 1.0 - 0.5/sin(M_PI/3)*1.02;
 glBegin ((filled ? GL_POLYGON : GL_LINE_LOOP));
 for (int i = 0; i < 2*6; i++)
 {
 ang = (0.5 + double(i+1)/6.0) * M_PI;
 r = 1.0 - (dr * fmod(double(i+1), 2.0));

Mercurial > octave

comparison src/gl-render.cc @ 11586:12df7854fa7c