Initial commit

engines/sword25/gfx/image/art.h

@@ -0,0 +1,215 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+/*
+ * This code is based on Libart_LGPL - library of basic graphic primitives
+ *
+ * Copyright (c) 1998 Raph Levien
+ *
+ * Licensed under GNU LGPL v2
+ *
+ */
+
+/* Simple macros to set up storage allocation and basic types for libart
+   functions. */
+
+#ifndef __ART_H__
+#define __ART_H__
+
+#include "common/scummsys.h"
+
+namespace Sword25 {
+
+/* These aren't, strictly speaking, configuration macros, but they're
+   damn handy to have around, and may be worth playing with for
+   debugging. */
+#define art_new(type, n) ((type *)malloc ((n) * sizeof(type)))
+
+#define art_renew(p, type, n) ((type *)realloc (p, (n) * sizeof(type)))
+
+/* This one must be used carefully - in particular, p and max should
+   be variables. They can also be pstruct->el lvalues. */
+#define art_expand(p, type, max) \
+			do { \
+				if (max) {\
+					type *tmp = art_renew(p, type, max <<= 1); \
+					if (!tmp) error("Cannot reallocate memory for art data"); \
+					p = tmp; \
+				} else { \
+					max = 1; \
+					p = art_new(type, 1); \
+					if (!p) error("Cannot allocate memory for art data"); \
+				} \
+			} while (0)
+
+struct ArtDRect {
+	/*< public >*/
+	double x0, y0, x1, y1;
+};
+
+struct ArtPoint {
+	/*< public >*/
+	double x, y;
+};
+
+/* Basic data structures and constructors for sorted vector paths */
+
+struct ArtSVPSeg {
+	int n_points;
+	int dir; /* == 0 for "up", 1 for "down" */
+	ArtDRect bbox;
+	ArtPoint *points;
+};
+
+struct ArtSVP {
+	int n_segs;
+	ArtSVPSeg segs[1];
+};
+
+void art_svp_free(ArtSVP *svp);
+
+/* Basic data structures and constructors for bezier paths */
+
+enum ArtPathcode {
+	ART_MOVETO,
+	ART_MOVETO_OPEN,
+	ART_CURVETO,
+	ART_LINETO,
+	ART_END
+};
+
+struct ArtBpath {
+	/*< public >*/
+	ArtPathcode code;
+	double x1;
+	double y1;
+	double x2;
+	double y2;
+	double x3;
+	double y3;
+};
+
+/* Basic data structures and constructors for simple vector paths */
+
+/* CURVETO is not allowed! */
+struct ArtVpath {
+	ArtPathcode code;
+	double x;
+	double y;
+};
+
+/* Some of the functions need to go into their own modules */
+
+void art_vpath_add_point(ArtVpath **p_vpath, int *pn_points, int *pn_points_max,
+					ArtPathcode code, double x, double y);
+
+ArtVpath *art_bez_path_to_vec(const ArtBpath *bez, double flatness);
+
+/* The funky new SVP intersector. */
+
+#ifndef ART_WIND_RULE_DEFINED
+#define ART_WIND_RULE_DEFINED
+enum ArtWindRule {
+	ART_WIND_RULE_NONZERO,
+	ART_WIND_RULE_INTERSECT,
+	ART_WIND_RULE_ODDEVEN,
+	ART_WIND_RULE_POSITIVE
+};
+#endif
+
+struct ArtSvpWriter {
+	int (*add_segment)(ArtSvpWriter *self, int wind_left, int delta_wind,
+	                   double x, double y);
+	void (*add_point)(ArtSvpWriter *self, int seg_id, double x, double y);
+	void (*close_segment)(ArtSvpWriter *self, int seg_id);
+};
+
+ArtSvpWriter *art_svp_writer_rewind_new(ArtWindRule rule);
+
+ArtSVP *art_svp_writer_rewind_reap(ArtSvpWriter *self);
+
+int art_svp_seg_compare(const void *s1, const void *s2);
+
+void art_svp_intersector(const ArtSVP *in, ArtSvpWriter *out);
+
+
+/* Sort vector paths into sorted vector paths. */
+
+ArtSVP *art_svp_from_vpath(ArtVpath *vpath);
+
+/* Sort vector paths into sorted vector paths. */
+
+enum ArtPathStrokeJoinType {
+	ART_PATH_STROKE_JOIN_MITER,
+	ART_PATH_STROKE_JOIN_ROUND,
+	ART_PATH_STROKE_JOIN_BEVEL
+};
+
+enum ArtPathStrokeCapType {
+	ART_PATH_STROKE_CAP_BUTT,
+	ART_PATH_STROKE_CAP_ROUND,
+	ART_PATH_STROKE_CAP_SQUARE
+};
+
+ArtSVP *art_svp_vpath_stroke(ArtVpath *vpath,
+					 ArtPathStrokeJoinType join,
+					 ArtPathStrokeCapType cap,
+					 double line_width,
+					 double miter_limit,
+					 double flatness);
+
+/* This version may have winding numbers exceeding 1. */
+ArtVpath *art_svp_vpath_stroke_raw(ArtVpath *vpath,
+						 ArtPathStrokeJoinType join,
+						 ArtPathStrokeCapType cap,
+						 double line_width,
+						 double miter_limit,
+						 double flatness);
+
+
+/* The spiffy antialiased renderer for sorted vector paths. */
+
+struct ArtSVPRenderAAStep {
+	int x;
+	int delta; /* stored with 16 fractional bits */
+};
+
+struct ArtSVPRenderAAIter;
+
+ArtSVPRenderAAIter *art_svp_render_aa_iter(const ArtSVP *svp,
+					   int x0, int y0, int x1, int y1);
+
+void art_svp_render_aa_iter_step(ArtSVPRenderAAIter *iter, int *p_start,
+							ArtSVPRenderAAStep **p_steps, int *p_n_steps);
+
+void art_svp_render_aa_iter_done(ArtSVPRenderAAIter *iter);
+
+void art_svp_render_aa(const ArtSVP *svp,
+				  int x0, int y0, int x1, int y1,
+				  void (*callback)(void *callback_data,
+								   int y,
+								   int start,
+								   ArtSVPRenderAAStep *steps, int n_steps),
+				  void *callback_data);
+
+} // End of namespace Sword25
+
+#endif /* __ART_H__ */