gtkseisviewgl.c

segy 显示程序！希望能给正在做这部分朋友提供一部分资料

    private->data_vis.slow_full_size_object = private->ortho_width;
    private->data_vis.fast_full_size_object = private->ortho_height;

    glViewport (0, 0, width, height);
    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
    glOrtho (private->ortho_left_x, private->ortho_left_x + private->ortho_width,
             private->ortho_top_y + private->ortho_height, private->ortho_top_y, -1.0, 1.0);
    glMatrixMode (GL_MODELVIEW);
    glLoadIdentity ();
    glTranslatef (0.0, 0.0, -1.0);

    glGetIntegerv (GL_VIEWPORT, private->data_vis.viewport);
    glGetDoublev (GL_PROJECTION_MATRIX, private->data_vis.projection);
    glGetDoublev (GL_MODELVIEW_MATRIX, private->data_vis.model_view);

    gtk_seis_view_calc_data_visibility_thread (self, width, height);

    for (i = 0; i < G_SEIS_VIEW_AXES_TYPES_NUM; i++) {
        if (private->axes[i])
            g_seis_view_axis_resize_event (private->axes[i], GTK_WIDGET (self), &private->data_vis);
    }
}

static gboolean gtk_seis_view_gl_configure_thread (GtkWidget *widget, GdkEventConfigure *event) {
    GtkSeisViewGl *self = GTK_SEIS_VIEW_GL (widget);
    GtkSeisViewGlPrivate *private = GTK_SEIS_VIEW_GL_GET_PRIVATE (self);

    if (private->is_threaded)
        gdk_threads_enter ();
    GdkGLContext *gl_context = gtk_widget_get_gl_context (widget);
    GdkGLDrawable *gl_drawable = gtk_widget_get_gl_drawable (widget);

    if (!gdk_gl_drawable_gl_begin (gl_drawable, gl_context)) {
        if (private->is_threaded)
            gdk_threads_leave ();
        return TRUE;
    }

    gtk_seis_view_gl_calc_configure_thread (self, widget->allocation.width, widget->allocation.height);

    if (private->active_tool)
        g_seis_view_tool_resize_event (private->active_tool, widget, &private->data_vis);

    glFinish ();

    gdk_gl_drawable_gl_end (gl_drawable);
    if (private->is_threaded)
        gdk_threads_leave ();

    return FALSE;
}

/*
 *
 * Thread launcher wrapper for gtk_seis_view_gl_configure
 *
 *
 */

typedef struct _GtkSeisViewGlConfigureData GtkSeisViewGlConfigureData;
struct _GtkSeisViewGlConfigureData {
    GtkSeisViewGlMessageType type;
    GtkSeisViewGl *seis_view;
    GdkEvent *event;
    guint8 data[MAX_MESSAGE_DATA];
};

static gboolean gtk_seis_view_gl_configure (GtkWidget *widget, GdkEventConfigure *event) {
    GtkSeisViewGlPrivate *private = GTK_SEIS_VIEW_GL_GET_PRIVATE (GTK_SEIS_VIEW_GL (widget));

    if (private->message_queue && NULL == g_private_get (private->message_key)) {
       GtkSeisViewGlConfigureData message_data;
       message_data.type = GTK_SEIS_VIEW_MSG_CONFIGURE;
       message_data.seis_view = GTK_SEIS_VIEW_GL (widget);
       message_data.event = gdk_event_copy ((GdkEvent*)event);
       g_mutex_lock (private->message_mutex);
       g_array_prepend_vals (private->messages, &message_data, 1);
       g_mutex_unlock (private->message_mutex);
       g_async_queue_push (private->message_queue, (gpointer)message_data.type);
       return FALSE;
    } else
       return gtk_seis_view_gl_configure_thread (widget, event);
}

static void gtk_seis_view_gl_redraw_int_thread (GtkSeisViewGl *self, gboolean screen_buffer) {
    GtkSeisViewGlPrivate *private = GTK_SEIS_VIEW_GL_GET_PRIVATE (self);

    if (private->is_threaded)
        gdk_threads_enter ();
    GdkGLContext *gl_context = gtk_widget_get_gl_context (GTK_WIDGET (self));
    GdkGLDrawable *gl_drawable = gtk_widget_get_gl_drawable (GTK_WIDGET (self));
    guint i, j;
    GLdouble tex_slow_start, tex_fast_start, tex_slow_end, tex_fast_end;
    GLdouble tex_slow_step, tex_fast_step;
    guint slow_border_points_num, fast_border_points_num;
    gdouble tex_vertex_top, tex_vertex_bottom;
    gdouble tex_vertex_left, tex_vertex_right;
    gdouble slow_data_to_object_scale, fast_data_to_object_scale;
    gdouble slow_zero_data_scale, fast_zero_data_scale;
    gdouble tex_coord_left, tex_coord_right;
    gdouble tex_coord_top, tex_coord_bottom;
    gdouble tex_coord_offset;

    if (screen_buffer && !gdk_gl_drawable_gl_begin (gl_drawable, gl_context)) {
        if (private->is_threaded)
            gdk_threads_leave ();
        return;
    }

    if (private->is_slave) {
        GtkSeisViewGlPrivate *master_private = GTK_SEIS_VIEW_GL_GET_PRIVATE (private->shared_seis_view);

        if (private->dataccess_mutex)
            g_mutex_lock (private->dataccess_mutex);

        private->palette = master_private->palette;
        private->corner_color = master_private->corner_color;
        private->trace_color = master_private->trace_color;
        private->underlayer_color = master_private->underlayer_color;
        private->highlight_color = master_private->highlight_color;

        private->slow_num = master_private->slow_num;
        private->fast_num = master_private->fast_num;
        private->tex_size = master_private->tex_size;
        private->tex_slow_num = master_private->tex_slow_num;
        private->tex_fast_num = master_private->tex_fast_num;
        private->tex_id = master_private->tex_id;
        private->max_tex_size = master_private->max_tex_size;
        private->wiggle_list_base = master_private->wiggle_list_base;
        private->va_list_neg_base = master_private->va_list_neg_base;
        private->va_list_pos_base = master_private->va_list_pos_base;
        private->tex_pal_id = master_private->tex_pal_id;

        private->display_mode = master_private->display_mode;
        private->va_fill_mode = master_private->va_fill_mode;
        private->minmax_mode = master_private->minmax_mode;
        private->inverse_polarity = master_private->inverse_polarity;
        private->trace_scale = master_private->trace_scale;

        private->show_cross = master_private->show_cross;

        private->use_agc = master_private->use_agc;
        private->agc_window = master_private->agc_window;

        private->traces_wiggle_vbo = master_private->traces_wiggle_vbo;
        private->traces_va_pos_vbo = master_private->traces_va_pos_vbo;
        private->traces_va_neg_vbo = master_private->traces_va_neg_vbo;
        private->wiggle_num = master_private->wiggle_num;
        private->va_pos_num = master_private->va_pos_num;
        private->va_neg_num = master_private->va_neg_num;
        private->has_wiggles = master_private->has_wiggles;

        private->hlight_start_data = master_private->hlight_start_data;
        private->hlight_size_data = master_private->hlight_size_data;

        private->data_is_set = master_private->data_is_set;

        if (private->dataccess_mutex)
            g_mutex_unlock (private->dataccess_mutex);
    }

    glClearColor (private->corner_color.red / (gfloat)G_MAXUINT16,
                  private->corner_color.green / (gfloat)G_MAXUINT16,
                  private->corner_color.blue / (gfloat)G_MAXUINT16, 0);

    glClear (GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

    private->cross_is_drawn = FALSE;

    if (FALSE == private->data_is_set) {
        if (screen_buffer) {
            if (gdk_gl_drawable_is_double_buffered (gl_drawable))
                gdk_gl_drawable_swap_buffers (gl_drawable);
            else
                glFlush ();

            gdk_gl_drawable_gl_end (gl_drawable);
        } else
            glFinish ();
        if (private->is_threaded)
            gdk_threads_leave ();
        return;
    }

    if (private->recalc_data_vis)
        gtk_seis_view_calc_data_visibility_thread (self, GTK_WIDGET (self)->allocation.width, GTK_WIDGET (self)->allocation.height);

    glDisable (GL_ALPHA_TEST);

    /* Enable stencil only and mark the data area with 1 in the stencil buffer */
    glEnable (GL_STENCIL_TEST);
    glColorMask (GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
    glStencilFunc (GL_ALWAYS, 1, 1);
    glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE);

    glBegin (GL_QUADS);
    glVertex2f (private->data_vis.slow_start_object, private->data_vis.fast_start_object);
    glVertex2f (private->data_vis.slow_start_object + private->data_vis.slow_size_object, private->data_vis.fast_start_object);
    glVertex2f (private->data_vis.slow_start_object + private->data_vis.slow_size_object, private->data_vis.fast_start_object + private->data_vis.fast_size_object);
    glVertex2f (private->data_vis.slow_start_object, private->data_vis.fast_start_object + private->data_vis.fast_size_object);
    glEnd ();

    /* Return to ordinary mode */
    glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);

    glStencilFunc (GL_EQUAL, 1, 1);
    glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);

    slow_border_points_num = (private->tex_slow_num - 1);
    fast_border_points_num = (private->tex_fast_num - 1);
    /* Transformation coefs from the data space to the object space */
    slow_data_to_object_scale = private->data_vis.slow_size_object / private->data_vis.slow_size_data;
    fast_data_to_object_scale = private->data_vis.fast_size_object / private->data_vis.fast_size_data;
    /* If there are unused samples in the textures - add another scale coefs to take those empty borders into accout */
    slow_zero_data_scale = (private->tex_slow_num * private->tex_size - slow_border_points_num) / (gfloat)private->slow_num;
    fast_zero_data_scale = (private->tex_fast_num * private->tex_size - fast_border_points_num) / (gfloat)private->fast_num;

    /* Start positions of the first texture in the object space */
    tex_slow_start = private->data_vis.slow_start_object - private->data_vis.slow_start_data * slow_data_to_object_scale;
    tex_fast_start = private->data_vis.fast_start_object - private->data_vis.fast_start_data * fast_data_to_object_scale;
    /* End positions of the first texture in the object space */
    tex_slow_end = tex_slow_start + 1.0 * slow_data_to_object_scale * slow_zero_data_scale;
    tex_fast_end = tex_fast_start + 1.0 * fast_data_to_object_scale * fast_zero_data_scale;
    /* Sizes occupied by the textures in the object space */
    tex_slow_step = (tex_slow_end - tex_slow_start) / (private->tex_slow_num * private->tex_size - slow_border_points_num);
    tex_fast_step = (tex_fast_end - tex_fast_start) / (private->tex_fast_num * private->tex_size - fast_border_points_num);

    tex_coord_offset = 0.5 / (gdouble)(private->tex_size);

    glColor3f (private->underlayer_color.red / (gfloat)G_MAXUINT16,
               private->underlayer_color.green / (gfloat)G_MAXUINT16,
               private->underlayer_color.blue / (gfloat)G_MAXUINT16);
    glNormal3f (0, 0, 1);

    if (private->display_mode & GTK_SEIS_VIEW_VD) {
        if (GTK_SEIS_VIEW_TEX_PALETTED == private->tex_color_mode) {
            glEnable (GL_SHARED_TEXTURE_PALETTE_EXT);
            if (private->reset_palette) {
                g_seis_palette_apply_shared_palette_lookup_tables (private->palette, private->pal_tex);
                private->reset_palette = FALSE;
            }
        } else if (GTK_SEIS_VIEW_TEX_FRAG_COLOR == private->tex_color_mode) {
            private->gl13->glActiveTexture (GL_TEXTURE1);
            glEnable (GL_TEXTURE_1D);
            glBindTexture (GL_TEXTURE_1D, private->tex_pal_id);
            if (private->reset_palette) {
                g_seis_palette_apply_fragment_shader_palette_lookup_tables (private->palette,
                                                                            private->tex_pal_id);
                private->reset_palette = FALSE;
            }
            private->gl13->glActiveTexture (GL_TEXTURE0);
            private->shaders->glUseProgramObjectARB (private->tex_palette_program);
            private->shaders->glUniform1iARB (private->seis_tex_uniform, 0);
            private->shaders->glUniform1iARB (private->palette_tex_uniform, 1);
        }
        glEnable (GL_TEXTURE_2D);
        /* Tile textures */
        for (i = 0; i < private->tex_slow_num; i++) {
            tex_vertex_right = tex_slow_start + (i + 1) * (private->tex_size - 1) * tex_slow_step;
            tex_vertex_right += 0.5 * tex_slow_step;
            if (i == (private->tex_slow_num - 1))
                tex_vertex_right += 0.5 * tex_slow_step;

            if (tex_vertex_right < private->data_vis.slow_start_object)
                continue;

            tex_vertex_left = tex_slow_start + i * (private->tex_size - 1) * tex_slow_step;
            if (i != 0)
                tex_vertex_left += 0.5 * tex_slow_step;

            if (tex_vertex_left > (private->data_vis.slow_start_object + 
                                   private->data_vis.slow_size_object))
                break;

            tex_coord_left = i != 0 ? tex_coord_offset : 0;
            tex_coord_right = i != (private->tex_slow_num - 1) ? 1.0 - tex_coord_offset : 1.0;

            for (j = 0; j < private->tex_fast_num; j++) {
                tex_vertex_bottom = tex_fast_start + (j + 1) * (private->tex_size - 1) * tex_fast_step;
                tex_vertex_bottom += 0.5 * tex_fast_step;
                if (j == (private->tex_fast_num - 1))
                    tex_vertex_bottom += 0.5 * tex_fast_step;

                if (tex_vertex_bottom < private->data_vis.fast_start_object)
                    continue;

                tex_vertex_top = tex_fast_start + j * (private->tex_size - 1) * tex_fast_step;
                if (j != 0)
                    tex_vertex_top += 0.5 * tex_fast_step;

               if (tex_vertex_top > (private->data_vis.fast_start_object + 
                                     private->data_vis.fast_size_object))
                   break;

                tex_coord_top = j != 0 ? tex_coord_offset : 0;