[gegl/npd-squashed] npd: mark more functions as static
- From: Marek Dvoroznak <dvoromar src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gegl/npd-squashed] npd: mark more functions as static
- Date: Tue, 3 Dec 2013 02:01:18 +0000 (UTC)
commit 2f2f3410fe97f62a852015058def2d703fc7e99f
Author: Marek Dvoroznak <dvoromar gmail com>
Date: Mon Dec 2 02:43:38 2013 +0100
npd: mark more functions as static
libs/npd/graphics.c | 555 ++++++++++++++++++++++++++-------------------------
libs/npd/graphics.h | 61 +-----
2 files changed, 293 insertions(+), 323 deletions(-)
---
diff --git a/libs/npd/graphics.c b/libs/npd/graphics.c
index 4d855a8..8ca26a3 100644
--- a/libs/npd/graphics.c
+++ b/libs/npd/graphics.c
@@ -27,219 +27,7 @@
#include <stdio.h>
#include <string.h>
-void
-npd_create_mesh_from_image (NPDModel *model,
- gint width,
- gint height,
- gint position_x,
- gint position_y)
-{
- gint square_size = model->mesh_square_size;
- NPDImage *image = model->reference_image;
- gint i, cy, cx, y, x, r, c, ow, oh;
- NPDColor pixel_color = { 0, 0, 0, 0 };
- GArray *squares;
- gint *sq2id;
- gboolean *empty_squares;
- GList *tmp_ops = NULL;
- GArray *ops = g_array_new (FALSE, FALSE, sizeof (NPDOverlappingPoints));
- GList **edges;
- NPDHiddenModel *hm = model->hidden_model;
-
- /* create squares above the image */
- width = ceil ((gfloat) width / square_size);
- height = ceil ((gfloat) height / square_size);
-
- squares = g_array_new (FALSE, FALSE, sizeof (NPDBone));
- empty_squares = g_new0 (gboolean, width * height);
- sq2id = g_new0 (gint, width * height);
-
- i = 0;
- for (cy = 0; cy < height; cy++)
- for (cx = 0; cx < width; cx++)
- {
- gboolean is_empty = TRUE;
-
- for (y = cy * square_size; y < (cy + 1) * square_size; y++)
- for (x = cx * square_size; x < (cx + 1) * square_size; x++)
- {
- /* test of emptiness */
- npd_get_pixel_color (image, x, y, &pixel_color);
- if (!npd_is_color_transparent (&pixel_color))
- {
- is_empty = FALSE;
- goto not_empty;
- }
- }
-
-#define NPD_SQ_ID cy * width + cx
-
- not_empty:
- if (!is_empty)
- {
- /* create a square */
- NPDBone square;
- npd_create_square (&square,
- position_x + cx * square_size,
- position_y + cy * square_size,
- square_size, square_size);
- g_array_append_val (squares, square);
- sq2id[NPD_SQ_ID] = i;
- i++;
- }
- else
- empty_squares[NPD_SQ_ID] = TRUE;
- }
-
- /* find empty edges */
- edges = npd_find_edges (model->reference_image, width, height, square_size);
-
- /* create provisional overlapping points */
-#define NPD_ADD_P(op,r,c,point) \
- if ((r) > -1 && (r) < (oh - 1) && (c) > -1 && (c) < (ow - 1) && \
- edges[op] == NULL && !empty_squares[(r) * width + (c)]) \
- { \
- tmp_ops = g_list_append (tmp_ops, GINT_TO_POINTER ((r) * width + (c)));\
- tmp_ops = g_list_append (tmp_ops, GINT_TO_POINTER (point)); \
- num++; \
- }
-
- ow = width + 1; oh = height + 1;
-
- for (r = 0; r < oh; r++)
- for (c = 0; c < ow; c++)
- {
- gint index = r * ow + c, num = 0;
- NPD_ADD_P (index, r - 1, c - 1, 2);
- NPD_ADD_P (index, r - 1, c, 3);
- NPD_ADD_P (index, r, c, 0);
- NPD_ADD_P (index, r, c - 1, 1);
- if (num > 0)
- tmp_ops = g_list_insert_before (tmp_ops,
- g_list_nth_prev (g_list_last (tmp_ops), 2 * num - 1),
- GINT_TO_POINTER (num));
- }
-#undef NPD_ADD_P
-
- /* cut lattice's edges and continue with creating of provisional overlapping points */
- tmp_ops = g_list_concat (tmp_ops, npd_cut_edges (edges, ow, oh));
- for (i = 0; i < ow * oh; i++) g_list_free (edges[i]);
- g_free (edges);
-
- /* create model's bones */
- hm->num_of_bones = squares->len;
- hm->current_bones = (NPDBone*) (gpointer) squares->data;
- g_array_free (squares, FALSE);
-
- /* create model's overlapping points */
- while (g_list_next (tmp_ops))
- {
- GPtrArray *ppts = g_ptr_array_new ();
- gint count = GPOINTER_TO_INT (tmp_ops->data);
- gint j = 0;
-
- for (i = 0; i < count; i++)
- {
- gint sq, p;
- tmp_ops = g_list_next (tmp_ops);
- sq = GPOINTER_TO_INT (tmp_ops->data);
- tmp_ops = g_list_next (tmp_ops);
- p = GPOINTER_TO_INT (tmp_ops->data);
-
- if (!empty_squares[sq])
- {
- g_ptr_array_add (ppts, &hm->current_bones[sq2id[sq]].points[p]);
- j++;
- }
- }
-
- if (j > 0)
- {
- NPDOverlappingPoints op;
- op.num_of_points = j;
- op.points = (NPDPoint**) ppts->pdata;
- g_ptr_array_free (ppts, FALSE);
- op.representative = op.points[0];
- g_array_append_val (ops, op);
- }
- tmp_ops = g_list_next (tmp_ops);
- }
-
- g_list_free (tmp_ops);
- g_free (empty_squares);
- g_free (sq2id);
-
- hm->num_of_overlapping_points = ops->len;
- hm->list_of_overlapping_points = (NPDOverlappingPoints*) (gpointer) ops->data;
- g_array_free (ops, FALSE);
-
- /* create reference bones according to current bones */
- hm->reference_bones = g_new (NPDBone, hm->num_of_bones);
- for (i = 0; i < hm->num_of_bones; i++)
- {
- NPDBone *current_bone = &hm->current_bones[i];
- NPDBone *reference_bone = &hm->reference_bones[i];
- NPDPoint *current_points, *ref_points;
- gint j, n = current_bone->num_of_points;
-
- reference_bone->num_of_points = n;
- reference_bone->points = g_new (NPDPoint, n);
- memcpy (reference_bone->points, current_bone->points, n * sizeof (NPDPoint));
- reference_bone->weights = current_bone->weights;
-
- current_points = current_bone->points;
- ref_points = reference_bone->points;
-
- for (j = 0; j < n; j++)
- {
- current_points[j].current_bone = current_bone;
- current_points[j].reference_bone = reference_bone;
- ref_points[j].current_bone = current_bone;
- ref_points[j].reference_bone = reference_bone;
- ref_points[j].x = current_points[j].x - position_x;
- ref_points[j].y = current_points[j].y - position_y;
- current_points[j].counterpart = &ref_points[j];
- ref_points[j].counterpart = ¤t_points[j];
- }
- }
-
-/*
-// could be useful later
- gint j;
- for (i = 0; i < hm->num_of_overlapping_points; i++)
- for (j = 0; j < hm->list_of_overlapping_points[i].num_of_points; j++)
- {
- NPDPoint *p = hm->list_of_overlapping_points[i].points[j];
- p->overlapping_points = &hm->list_of_overlapping_points[i];
- p->counterpart->overlapping_points = &hm->list_of_overlapping_points[i];
- }
-*/
-}
-
-void
-npd_draw_mesh (NPDModel *model,
- NPDDisplay *display)
-{
- NPDHiddenModel *hm = model->hidden_model;
- gint i, j;
-
- for (i = 0; i < hm->num_of_bones; i++)
- {
- NPDBone *bone = &hm->current_bones[i];
- NPDPoint *first = &bone->points[0];
- NPDPoint *p0, *p1 = NULL;
-
- for (j = 1; j < bone->num_of_points; j++)
- {
- p0 = &bone->points[j - 1];
- p1 = &bone->points[j];
- npd_draw_line (display, p0->x, p0->y, p1->x, p1->y);
- }
- npd_draw_line (display, p1->x, p1->y, first->x, first->y);
- }
-}
-
-gfloat
+static gfloat
npd_bilinear_interpolation (gfloat I0,
gfloat I1,
gfloat I2,
@@ -251,7 +39,7 @@ npd_bilinear_interpolation (gfloat I0,
(I2 * (1 - dx) + I3 * dx) * dy;
}
-void
+static void
npd_bilinear_color_interpolation (NPDColor *I0,
NPDColor *I1,
NPDColor *I2,
@@ -266,7 +54,7 @@ npd_bilinear_color_interpolation (NPDColor *I0,
out->a = npd_bilinear_interpolation (I0->a, I1->a, I2->a, I3->a, dx, dy);
}
-gfloat
+static gfloat
npd_blend_band (gfloat src,
gfloat dst,
gfloat src_alpha,
@@ -277,7 +65,7 @@ npd_blend_band (gfloat src,
dst * dst_alpha * (1 - src_alpha)) * out_alpha_recip;
}
-void
+static void
npd_blend_colors (NPDColor *src,
NPDColor *dst,
NPDColor *out_color)
@@ -302,7 +90,60 @@ npd_blend_colors (NPDColor *src,
#endif
}
-void
+static void
+npd_draw_texture_line (gint x1,
+ gint x2,
+ gint y,
+ NPDMatrix *A,
+ NPDImage *input_image,
+ NPDImage *output_image,
+ NPDSettings settings)
+{
+ gint x, fx, fy;
+ gfloat dx, dy;
+
+ for (x = x1; x <= x2; x++)
+ {
+ NPDPoint p, q;
+ NPDColor I0, interpolated, *final;
+
+ q.x = x; q.y = y;
+ npd_apply_transformation (A, &q, &p);
+
+ fx = floor (p.x);
+ fy = floor (p.y);
+
+ npd_get_pixel_color (input_image, fx, fy, &I0);
+ final = &I0;
+
+ /* bilinear interpolation */
+ if (settings & NPD_BILINEAR_INTERPOLATION)
+ {
+ NPDColor I1, I2, I3;
+
+ dx = p.x - fx;
+ dy = p.y - fy;
+
+ npd_get_pixel_color (input_image, fx + 1, fy, &I1);
+ npd_get_pixel_color (input_image, fx, fy + 1, &I2);
+ npd_get_pixel_color (input_image, fx + 1, fy + 1, &I3);
+ npd_bilinear_color_interpolation (&I0, &I1, &I2, &I3, dx, dy, &interpolated);
+ final = &interpolated;
+ }
+
+ /* alpha blending */
+ if (settings & NPD_ALPHA_BLENDING)
+ {
+ NPDColor dest;
+ npd_get_pixel_color (output_image, x, y, &dest);
+ npd_blend_colors (final, &dest, final);
+ }
+
+ npd_set_pixel_color (output_image, x, y, final);
+ }
+}
+
+static void
npd_texture_fill_triangle (gint x1,
gint y1,
gint x2,
@@ -447,7 +288,7 @@ npd_texture_fill_triangle (gint x1,
}
}
-void
+static void
npd_texture_quadrilateral (NPDBone *reference_bone,
NPDBone *current_bone,
NPDImage *input_image,
@@ -478,76 +319,256 @@ npd_texture_quadrilateral (NPDBone *reference_bone,
}
void
-npd_draw_texture_line (gint x1,
- gint x2,
- gint y,
- NPDMatrix *A,
- NPDImage *input_image,
- NPDImage *output_image,
- NPDSettings settings)
+npd_draw_model_into_image (NPDModel *model,
+ NPDImage *image)
{
- gint x, fx, fy;
- gfloat dx, dy;
-
- for (x = x1; x <= x2; x++)
+ NPDHiddenModel *hm = model->hidden_model;
+ gint i;
+
+ for (i = 0; i < hm->num_of_bones; i++)
{
- NPDPoint p, q;
- NPDColor I0, interpolated, *final;
+ npd_texture_quadrilateral (&hm->reference_bones[i],
+ &hm->current_bones[i],
+ model->reference_image,
+ image,
+ NPD_BILINEAR_INTERPOLATION | NPD_ALPHA_BLENDING);
+ }
+}
- q.x = x; q.y = y;
- npd_apply_transformation (A, &q, &p);
+gboolean
+npd_is_color_transparent (NPDColor *color)
+{
+ if (npd_equal_floats (color->a, 0.0))
+ return TRUE;
- fx = floor (p.x);
- fy = floor (p.y);
+ return FALSE;
+}
- npd_get_pixel_color (input_image, fx, fy, &I0);
- final = &I0;
+static void
+npd_create_mesh (NPDModel *model,
+ gint width,
+ gint height,
+ gint position_x,
+ gint position_y)
+{
+ gint square_size = model->mesh_square_size;
+ NPDImage *image = model->reference_image;
+ gint i, cy, cx, y, x, r, c, ow, oh;
+ NPDColor pixel_color = { 0, 0, 0, 0 };
+ GArray *squares;
+ gint *sq2id;
+ gboolean *empty_squares;
+ GList *tmp_ops = NULL;
+ GArray *ops = g_array_new (FALSE, FALSE, sizeof (NPDOverlappingPoints));
+ GList **edges;
+ NPDHiddenModel *hm = model->hidden_model;
- /* bilinear interpolation */
- if (settings & NPD_BILINEAR_INTERPOLATION)
+ /* create squares above the image */
+ width = ceil ((gfloat) width / square_size);
+ height = ceil ((gfloat) height / square_size);
+
+ squares = g_array_new (FALSE, FALSE, sizeof (NPDBone));
+ empty_squares = g_new0 (gboolean, width * height);
+ sq2id = g_new0 (gint, width * height);
+
+ i = 0;
+ for (cy = 0; cy < height; cy++)
+ for (cx = 0; cx < width; cx++)
+ {
+ gboolean is_empty = TRUE;
+
+ for (y = cy * square_size; y < (cy + 1) * square_size; y++)
+ for (x = cx * square_size; x < (cx + 1) * square_size; x++)
{
- NPDColor I1, I2, I3;
+ /* test of emptiness */
+ npd_get_pixel_color (image, x, y, &pixel_color);
+ if (!npd_is_color_transparent (&pixel_color))
+ {
+ is_empty = FALSE;
+ goto not_empty;
+ }
+ }
- dx = p.x - fx;
- dy = p.y - fy;
+#define NPD_SQ_ID cy * width + cx
- npd_get_pixel_color (input_image, fx + 1, fy, &I1);
- npd_get_pixel_color (input_image, fx, fy + 1, &I2);
- npd_get_pixel_color (input_image, fx + 1, fy + 1, &I3);
- npd_bilinear_color_interpolation (&I0, &I1, &I2, &I3, dx, dy, &interpolated);
- final = &interpolated;
+ not_empty:
+ if (!is_empty)
+ {
+ /* create a square */
+ NPDBone square;
+ npd_create_square (&square,
+ position_x + cx * square_size,
+ position_y + cy * square_size,
+ square_size, square_size);
+ g_array_append_val (squares, square);
+ sq2id[NPD_SQ_ID] = i;
+ i++;
}
+ else
+ empty_squares[NPD_SQ_ID] = TRUE;
+ }
- /* alpha blending */
- if (settings & NPD_ALPHA_BLENDING)
+ /* find empty edges */
+ edges = npd_find_edges (model->reference_image, width, height, square_size);
+
+ /* create provisional overlapping points */
+#define NPD_ADD_P(op,r,c,point) \
+ if ((r) > -1 && (r) < (oh - 1) && (c) > -1 && (c) < (ow - 1) && \
+ edges[op] == NULL && !empty_squares[(r) * width + (c)]) \
+ { \
+ tmp_ops = g_list_append (tmp_ops, GINT_TO_POINTER ((r) * width + (c)));\
+ tmp_ops = g_list_append (tmp_ops, GINT_TO_POINTER (point)); \
+ num++; \
+ }
+
+ ow = width + 1; oh = height + 1;
+
+ for (r = 0; r < oh; r++)
+ for (c = 0; c < ow; c++)
+ {
+ gint index = r * ow + c, num = 0;
+ NPD_ADD_P (index, r - 1, c - 1, 2);
+ NPD_ADD_P (index, r - 1, c, 3);
+ NPD_ADD_P (index, r, c, 0);
+ NPD_ADD_P (index, r, c - 1, 1);
+ if (num > 0)
+ tmp_ops = g_list_insert_before (tmp_ops,
+ g_list_nth_prev (g_list_last (tmp_ops), 2 * num - 1),
+ GINT_TO_POINTER (num));
+ }
+#undef NPD_ADD_P
+
+ /* cut lattice's edges and continue with creating of provisional overlapping points */
+ tmp_ops = g_list_concat (tmp_ops, npd_cut_edges (edges, ow, oh));
+ for (i = 0; i < ow * oh; i++) g_list_free (edges[i]);
+ g_free (edges);
+
+ /* create model's bones */
+ hm->num_of_bones = squares->len;
+ hm->current_bones = (NPDBone*) (gpointer) squares->data;
+ g_array_free (squares, FALSE);
+
+ /* create model's overlapping points */
+ while (g_list_next (tmp_ops))
+ {
+ GPtrArray *ppts = g_ptr_array_new ();
+ gint count = GPOINTER_TO_INT (tmp_ops->data);
+ gint j = 0;
+
+ for (i = 0; i < count; i++)
{
- NPDColor dest;
- npd_get_pixel_color (output_image, x, y, &dest);
- npd_blend_colors (final, &dest, final);
+ gint sq, p;
+ tmp_ops = g_list_next (tmp_ops);
+ sq = GPOINTER_TO_INT (tmp_ops->data);
+ tmp_ops = g_list_next (tmp_ops);
+ p = GPOINTER_TO_INT (tmp_ops->data);
+
+ if (!empty_squares[sq])
+ {
+ g_ptr_array_add (ppts, &hm->current_bones[sq2id[sq]].points[p]);
+ j++;
+ }
}
- npd_set_pixel_color (output_image, x, y, final);
+ if (j > 0)
+ {
+ NPDOverlappingPoints op;
+ op.num_of_points = j;
+ op.points = (NPDPoint**) ppts->pdata;
+ g_ptr_array_free (ppts, FALSE);
+ op.representative = op.points[0];
+ g_array_append_val (ops, op);
+ }
+ tmp_ops = g_list_next (tmp_ops);
+ }
+
+ g_list_free (tmp_ops);
+ g_free (empty_squares);
+ g_free (sq2id);
+
+ hm->num_of_overlapping_points = ops->len;
+ hm->list_of_overlapping_points = (NPDOverlappingPoints*) (gpointer) ops->data;
+ g_array_free (ops, FALSE);
+
+ /* create reference bones according to current bones */
+ hm->reference_bones = g_new (NPDBone, hm->num_of_bones);
+ for (i = 0; i < hm->num_of_bones; i++)
+ {
+ NPDBone *current_bone = &hm->current_bones[i];
+ NPDBone *reference_bone = &hm->reference_bones[i];
+ NPDPoint *current_points, *ref_points;
+ gint j, n = current_bone->num_of_points;
+
+ reference_bone->num_of_points = n;
+ reference_bone->points = g_new (NPDPoint, n);
+ memcpy (reference_bone->points, current_bone->points, n * sizeof (NPDPoint));
+ reference_bone->weights = current_bone->weights;
+
+ current_points = current_bone->points;
+ ref_points = reference_bone->points;
+
+ for (j = 0; j < n; j++)
+ {
+ current_points[j].current_bone = current_bone;
+ current_points[j].reference_bone = reference_bone;
+ ref_points[j].current_bone = current_bone;
+ ref_points[j].reference_bone = reference_bone;
+ ref_points[j].x = current_points[j].x - position_x;
+ ref_points[j].y = current_points[j].y - position_y;
+ current_points[j].counterpart = &ref_points[j];
+ ref_points[j].counterpart = ¤t_points[j];
+ }
}
+
+#if 0
+ /* could be useful later */
+ gint j;
+ for (i = 0; i < hm->num_of_overlapping_points; i++)
+ for (j = 0; j < hm->list_of_overlapping_points[i].num_of_points; j++)
+ {
+ NPDPoint *p = hm->list_of_overlapping_points[i].points[j];
+ p->overlapping_points = &hm->list_of_overlapping_points[i];
+ p->counterpart->overlapping_points = &hm->list_of_overlapping_points[i];
+ }
+#endif
}
-gboolean
-npd_compare_colors (NPDColor *c1,
- NPDColor *c2)
+void
+npd_create_model_from_image (NPDModel *model,
+ NPDImage *image,
+ gint width,
+ gint height,
+ gint position_x,
+ gint position_y,
+ gint square_size)
{
- if (npd_equal_floats (c1->r, c2->r) &&
- npd_equal_floats (c1->g, c2->g) &&
- npd_equal_floats (c1->b, c2->b) &&
- npd_equal_floats (c1->a, c2->a))
- return TRUE;
+ npd_init_model (model);
+ model->reference_image = image;
+ model->mesh_square_size = square_size;
- return FALSE;
+ npd_create_mesh (model, width, height, position_x, position_y);
}
-gboolean
-npd_is_color_transparent (NPDColor *color)
+
+void
+npd_draw_mesh (NPDModel *model,
+ NPDDisplay *display)
{
- if (npd_equal_floats (color->a, 0.0))
- return TRUE;
+ NPDHiddenModel *hm = model->hidden_model;
+ gint i, j;
- return FALSE;
+ for (i = 0; i < hm->num_of_bones; i++)
+ {
+ NPDBone *bone = &hm->current_bones[i];
+ NPDPoint *first = &bone->points[0];
+ NPDPoint *p0, *p1 = NULL;
+
+ for (j = 1; j < bone->num_of_points; j++)
+ {
+ p0 = &bone->points[j - 1];
+ p1 = &bone->points[j];
+ npd_draw_line (display, p0->x, p0->y, p1->x, p1->y);
+ }
+ npd_draw_line (display, p1->x, p1->y, first->x, first->y);
+ }
}
diff --git a/libs/npd/graphics.h b/libs/npd/graphics.h
index 457ac80..69c272d 100644
--- a/libs/npd/graphics.h
+++ b/libs/npd/graphics.h
@@ -48,67 +48,21 @@ typedef enum
void npd_create_model_from_image (NPDModel *model,
NPDImage *image,
- gint square_size);
-void npd_create_mesh_from_image (NPDModel *model,
gint width,
gint height,
gint position_x,
- gint position_y);
-void npd_draw_model (NPDModel *model,
- NPDDisplay *display);
+ gint position_y,
+ gint square_size);
+void npd_draw_model_into_image (NPDModel *model,
+ NPDImage *image);
void npd_draw_mesh (NPDModel *model,
NPDDisplay *display);
-
-void npd_destroy_image (NPDImage *image);
-
-void npd_texture_fill_triangle (gint x1,
- gint y1,
- gint x2,
- gint y2,
- gint x3,
- gint y3,
- NPDMatrix *A,
- NPDImage *input_image,
- NPDImage *output_image,
- NPDSettings settings);
-void npd_texture_quadrilateral (NPDBone *reference_bone,
- NPDBone *current_bone,
- NPDImage *input_image,
- NPDImage *output_image,
- NPDSettings settings);
-void npd_draw_texture_line (gint x1,
- gint x2,
- gint y,
- NPDMatrix *A,
- NPDImage *input_image,
- NPDImage *output_image,
- NPDSettings settings);
+gboolean npd_is_color_transparent (NPDColor *color);
void (*npd_draw_line) (NPDDisplay *display,
gfloat x0,
gfloat y0,
gfloat x1,
gfloat y1);
-gfloat npd_bilinear_interpolation (gfloat I0,
- gfloat I1,
- gfloat I2,
- gfloat I3,
- gfloat dx,
- gfloat dy);
-void npd_bilinear_color_interpolation (NPDColor *I0,
- NPDColor *I1,
- NPDColor *I2,
- NPDColor *I3,
- gfloat dx,
- gfloat dy,
- NPDColor *out);
-gfloat npd_blend_band (gfloat src,
- gfloat dst,
- gfloat src_alpha,
- gfloat dest_alpha,
- gfloat out_alpha);
-void npd_blend_colors (NPDColor *src,
- NPDColor *dst,
- NPDColor *out_color);
void (*npd_get_pixel_color) (NPDImage *image,
gint x,
gint y,
@@ -117,10 +71,5 @@ void (*npd_set_pixel_color) (NPDImage *image,
gint x,
gint y,
NPDColor *color);
-gboolean npd_compare_colors (NPDColor *c1,
- NPDColor *c2);
-gboolean npd_is_color_transparent (NPDColor *color);
-gboolean npd_init_display (NPDDisplay *display);
-void npd_destroy_display (NPDDisplay *display);
#endif /*__NPD_GRAPHICS_H__ */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
