Mercurial > fracter
view src/Fractal.cpp @ 5:d691ce98f406
OK. This is the first release. Honest.
| author | Eris Caffee <discordia@eldalin.com> |
|---|---|
| date | Fri, 12 Nov 2010 23:58:48 -0600 |
| parents | df02a7de7fe2 |
| children |
line source
1 ////////////////////////////////////////////////////////////////////////////////
2 //
3 // Fracter - A simple Mandelbrot Set viewer.
4 //
5 // Copyright (C) 2010 Sarah Eris Horsley Caffee
6 //
7 // This file is part of Fracter.
8 //
9 // Fracter is free software: you can redistribute it and/or modify
10 // it under the terms of the GNU General Public License as published by
11 // the Free Software Foundation, either version 3 of the License, or
12 // (at your option) any later version.
13 //
14 // This program is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 // GNU General Public License for more details.
18 //
19 // You should have received a copy of the GNU General Public License
20 // along with this program. If not, see <http://www.gnu.org/licenses/>.
21 //
22 //
23 //
24 // Fractal.cpp
25 // Fractal calculator virtual class implementation. Actual fractals should
26 // implement this.
27 //
28 ////////////////////////////////////////////////////////////////////////////////
30 #include "Fractal.h"
32 ////////////////////////////////////////////////////////////////////////////////
33 View::View(std::string t,
34 double re, double im, double s,
35 unsigned int max) :
36 type (t),
37 re_min (re),
38 im_max (im),
39 size (s),
40 max_iter (max)
41 {
42 }
44 ////////////////////////////////////////////////////////////////////////////////
45 View::~View()
46 {
47 }
49 ////////////////////////////////////////////////////////////////////////////////
50 std::string const & View::get_type() const
51 {
52 return type;
53 }
55 ////////////////////////////////////////////////////////////////////////////////
57 Fractal::Fractal() :
58 display_name ("No fractal"),
59 fractal_name ("No fractal"),
60 re_min (0),
61 im_max (0),
62 size (0),
63 max_iter (0),
64 calc_needed (false),
65 surface (NULL)
66 {
67 }
70 ////////////////////////////////////////////////////////////////////////////////
71 Fractal::~Fractal()
72 {
73 }
76 ////////////////////////////////////////////////////////////////////////////////
77 bool Fractal::init(SDL_Surface * surf)
78 {
79 if (!surf)
80 {
81 return false;
82 }
83 else
84 {
85 surface = surf;
86 }
87 calc_needed = true;
88 return true;
89 }
92 ////////////////////////////////////////////////////////////////////////////////
93 double Fractal::get_re_min() const
94 {
95 return re_min;
96 }
99 ////////////////////////////////////////////////////////////////////////////////
100 double Fractal::set_re_min(const double r_min)
101 {
102 double t = re_min;
103 re_min = r_min;
104 return t;
105 }
108 ////////////////////////////////////////////////////////////////////////////////
109 double Fractal::get_im_max() const
110 {
111 return im_max;
112 }
115 ////////////////////////////////////////////////////////////////////////////////
116 double Fractal::set_im_max(const double i_max)
117 {
118 double t = im_max;
119 im_max = i_max;
120 return t;
121 }
124 ////////////////////////////////////////////////////////////////////////////////
125 double Fractal::get_size() const
126 {
127 return size;
128 }
131 ////////////////////////////////////////////////////////////////////////////////
132 double Fractal::set_size(const double s)
133 {
134 double t = size;
135 if (s > 0.0)
136 size = s;
137 else
138 size = 1.0;
139 return t;
140 }
143 ////////////////////////////////////////////////////////////////////////////////
144 unsigned int Fractal::get_max_iter() const
145 {
146 return max_iter;
147 }
150 ////////////////////////////////////////////////////////////////////////////////
151 unsigned int Fractal::set_max_iter(const unsigned int iter)
152 {
153 unsigned int t = max_iter;
154 if (iter > 0)
155 max_iter = iter;
156 else
157 max_iter = 1;
158 return t;
159 }
162 ////////////////////////////////////////////////////////////////////////////////
163 unsigned int Fractal::inc_max_iter()
164 {
165 unsigned int t = max_iter;
166 max_iter++;
167 return t;
168 }
171 ////////////////////////////////////////////////////////////////////////////////
172 unsigned int Fractal::dec_max_iter()
173 {
174 unsigned int t = max_iter;
175 if (max_iter > 0)
176 max_iter--;
177 return t;
178 }
181 ////////////////////////////////////////////////////////////////////////////////
182 void Fractal::set_calc_needed()
183 {
184 calc_needed = true;
185 }
188 ////////////////////////////////////////////////////////////////////////////////
189 std::string const & Fractal::get_display_name() const
190 {
191 return display_name;
192 }
195 ////////////////////////////////////////////////////////////////////////////////
196 std::string const & Fractal::get_fractal_name() const
197 {
198 return fractal_name;
199 }
202 ////////////////////////////////////////////////////////////////////////////////
203 bool Fractal::get_option(std::string option, void * value) const
204 {
205 return false;
206 }
208 ////////////////////////////////////////////////////////////////////////////////
209 bool Fractal::set_option(std::string option, void * value)
210 {
211 return false;
212 }
214 ////////////////////////////////////////////////////////////////////////////////
215 View * Fractal::save_view()
216 {
217 return new View(typeid(*this).name(), re_min, im_max, size, max_iter);
218 }
220 ////////////////////////////////////////////////////////////////////////////////
221 void Fractal::restore_view(View * v)
222 {
223 fractal_name = v->type;
224 re_min = v->re_min;
225 im_max = v->im_max;
226 size = v->size;
227 max_iter = v->max_iter;
228 calc_needed = true;
229 }
232 ////////////////////////////////////////////////////////////////////////////////
233 void Fractal::draw_pixel(int x, int y, Uint32 * color)
234 {
235 static char * data;
237 if (SDL_MUSTLOCK(surface)) SDL_LockSurface(surface);
239 data = (char *) surface->pixels
240 + y * surface->pitch
241 + x * surface->format->BytesPerPixel;
242 memcpy(data, color, surface->format->BytesPerPixel);
244 if (SDL_MUSTLOCK(surface)) SDL_UnlockSurface(surface);
245 }
248 ////////////////////////////////////////////////////////////////////////////////
249 FractalFactory::~FractalFactory()
250 {
251 get_Fractal_map().clear();
252 }
255 ////////////////////////////////////////////////////////////////////////////////
257 std::map <std::string, FractalFactory *> & get_Fractal_map()
258 {
259 static std::map <std::string, FractalFactory *> the_Fractal_map;
260 return the_Fractal_map;
261 }