~ubuntu-branches/ubuntu/precise/frogatto/precise

« back to all changes in this revision

Viewing changes to src/surface_formula.cpp

Committer: Bazaar Package Importer
Author(s): Dmitry E. Oboukhov
Date: 2010-07-21 16:21:45 UTC
Revision ID: james.westby@ubuntu.com-20100721162145-zid0u93fm3xz73gh

Tags: upstream-1.0+dfsg1

Import upstream version 1.0+dfsg1

files added:

INSTALL

LICENSE

Makefile

src/IMG_savepng.cpp

src/IMG_savepng.h

src/LICENSE

src/asserts.hpp

src/background.cpp

src/background.hpp

src/blur.cpp

src/blur.hpp

src/border_widget.cpp

src/border_widget.hpp

src/button.cpp

src/button.hpp

src/character_editor_dialog.cpp

src/character_editor_dialog.hpp

src/collision_utils.cpp

src/collision_utils.hpp

src/color_utils.cpp

src/color_utils.hpp

src/colorshift_hash_table.cpp

src/colorshift_hash_table.hpp

src/concurrent_cache.hpp

src/controls.cpp

src/controls.hpp

src/current_generator.cpp

src/current_generator.hpp

src/custom_object.cpp

src/custom_object.hpp

src/custom_object_callable.cpp

src/custom_object_callable.hpp

src/custom_object_functions.cpp

src/custom_object_functions.hpp

src/custom_object_type.cpp

src/custom_object_type.hpp

src/debug_console.cpp

src/debug_console.hpp

src/dialog.cpp

src/dialog.hpp

src/draw_number.cpp

src/draw_number.hpp

src/draw_scene.cpp

src/draw_scene.hpp

src/draw_tile.cpp

src/draw_tile.hpp

src/editor.cpp

src/editor.hpp

src/editor_dialogs.cpp

src/editor_dialogs.hpp

src/editor_formula_functions.cpp

src/editor_formula_functions.hpp

src/editor_layers_dialog.cpp

src/editor_layers_dialog.hpp

src/editor_level_properties_dialog.cpp

src/editor_level_properties_dialog.hpp

src/editor_stats_dialog.cpp

src/editor_stats_dialog.hpp

src/editor_variable_info.cpp

src/editor_variable_info.hpp

src/entity.cpp

src/entity.hpp

src/entity_fwd.hpp

src/filesystem.cpp

src/filesystem.hpp

src/font.cpp

src/font.hpp

src/foreach.hpp

src/formatter.hpp

src/formula.cpp

src/formula.hpp

src/formula_callable.hpp

src/formula_callable_definition.cpp

src/formula_callable_definition.hpp

src/formula_callable_definition_fwd.hpp

src/formula_callable_utils.hpp

src/formula_constants.cpp

src/formula_constants.hpp

src/formula_function.cpp

src/formula_function.hpp

src/formula_fwd.hpp

src/formula_profiler.cpp

src/formula_profiler.hpp

src/formula_test.cpp

src/formula_tokenizer.cpp

src/formula_tokenizer.hpp

src/formula_variable_storage.cpp

src/formula_variable_storage.hpp

src/frame.cpp

src/frame.hpp

src/framed_gui_element.cpp

src/framed_gui_element.hpp

src/functional.hpp

src/geometry.cpp

src/geometry.hpp

src/graphical_font.cpp

src/graphical_font.hpp

src/graphical_font_label.cpp

src/graphical_font_label.hpp

src/grid_widget.cpp

src/grid_widget.hpp

src/grid_widget_fwd.hpp

src/group_property_editor_dialog.cpp

src/group_property_editor_dialog.hpp

src/gui_formula_functions.cpp

src/gui_formula_functions.hpp

src/gui_section.cpp

src/gui_section.hpp

src/hi_res_timer.hpp

src/image_widget.cpp

src/image_widget.hpp

src/image_widget_fwd.hpp

src/input.cpp

src/input.hpp

src/inventory.cpp

src/inventory.hpp

src/iphone_controls.cpp

src/iphone_controls.hpp

src/iphone_device_info.h

src/iphone_device_info.m

src/iphone_sound.h

src/iphone_sound.m

src/joystick.cpp

src/joystick.hpp

src/key.cpp

src/key.hpp

src/label.cpp

src/label.hpp

src/level.cpp

src/level.hpp

src/level_logic.cpp

src/level_logic.hpp

src/level_object.cpp

src/level_object.hpp

src/level_runner.cpp

src/level_runner.hpp

src/level_solid_map.cpp

src/level_solid_map.hpp

src/load_level.cpp

src/load_level.hpp

src/load_level_nothread.cpp

src/loading_screen.cpp

src/loading_screen.hpp

src/main.cpp

src/map_utils.hpp

src/message_dialog.cpp

src/message_dialog.hpp

src/movement_script.cpp

src/movement_script.hpp

src/multi_tile_pattern.cpp

src/multi_tile_pattern.hpp

src/multiplayer.cpp

src/multiplayer.hpp

src/object_events.cpp

src/object_events.hpp

src/options_dialog.cpp

src/options_dialog.hpp

src/particle_system.cpp

src/particle_system.hpp

src/pause_game_dialog.cpp

src/pause_game_dialog.hpp

src/playable_custom_object.cpp

src/playable_custom_object.hpp

src/player_info.cpp

src/player_info.hpp

src/point_map.hpp

src/powerup.cpp

src/powerup.hpp

src/powerup_fwd.hpp

src/preferences.cpp

src/preferences.hpp

src/preprocessor.cpp

src/preprocessor.hpp

src/preview_tileset_widget.cpp

src/preview_tileset_widget.hpp

src/property_editor_dialog.cpp

src/property_editor_dialog.hpp

src/random.cpp

src/random.hpp

src/raster.cpp

src/raster.hpp

src/raster_distortion.cpp

src/raster_distortion.hpp

src/rectangle_rotator.cpp

src/rectangle_rotator.hpp

src/reference_counted_object.hpp

src/scoped_resource.hpp

src/server.cpp

src/settings_dialog.cpp

src/settings_dialog.hpp

src/simple_wml.cpp

src/simple_wml.hpp

src/solid_map.cpp

src/solid_map.hpp

src/solid_map_fwd.hpp

src/sound.cpp

src/sound.hpp

src/speech_dialog.cpp

src/speech_dialog.hpp

src/stats.cpp

src/stats.hpp

src/string_utils.cpp

src/string_utils.hpp

src/surface.cpp

src/surface.hpp

src/surface_cache.cpp

src/surface_cache.hpp

src/surface_formula.cpp

src/surface_formula.hpp

src/surface_palette.cpp

src/surface_palette.hpp

src/surface_scaling.cpp

src/text_entry_widget.cpp

src/text_entry_widget.hpp

src/texture.cpp

src/texture.hpp

src/thread.cpp

src/thread.hpp

src/tile_map.cpp

src/tile_map.hpp

src/tileset_editor_dialog.cpp

src/tileset_editor_dialog.hpp

src/tooltip.cpp

src/tooltip.hpp

src/translate.cpp

src/translate.hpp

src/unit_test.cpp

src/unit_test.hpp

src/userevents.h

src/utility_object_compiler.cpp

src/utility_object_editor.cpp

src/utils.cpp

src/utils.hpp

src/variant.cpp

src/variant.hpp

src/water.cpp

src/water.hpp

src/water_particle_system.cpp

src/water_particle_system.hpp

src/weather_particle_system.cpp

src/weather_particle_system.hpp

src/widget.cpp

src/widget.hpp

src/wml_formula_adapter.cpp

src/wml_formula_adapter.hpp

src/wml_formula_callable.cpp

src/wml_formula_callable.hpp

src/wml_modify.cpp

src/wml_modify.hpp

src/wml_node.cpp

src/wml_node.hpp

src/wml_node_fwd.hpp

src/wml_parser.cpp

src/wml_parser.hpp

src/wml_parser_test.cpp

src/wml_preprocessor.cpp

src/wml_preprocessor.hpp

src/wml_schema.cpp

src/wml_schema.hpp

src/wml_utils.cpp

src/wml_utils.hpp

src/wml_value.hpp

src/wml_writer.cpp

src/wml_writer.hpp

Show diffs side-by-side

added added

removed removed

src/surface_formula.cpp

#include <iostream>

#include <map>

#include <SDL.h>

#ifndef SDL_VIDEO_OPENGL_ES

#include <GL/glew.h>

#endif

#include "asserts.hpp"

#include "concurrent_cache.hpp"

#include "filesystem.hpp"

#include "foreach.hpp"

#include "formula.hpp"

#include "formula_callable.hpp"

#include "formula_function.hpp"

#include "hi_res_timer.hpp"

#include "surface.hpp"

#include "surface_cache.hpp"

#include "surface_formula.hpp"

#include "unit_test.hpp"

using namespace graphics;

using namespace game_logic;

namespace {

typedef std::pair<surface, std::string> cache_key;

typedef concurrent_cache<cache_key, surface> cache_map;

cache_map& cache() {

static cache_map instance;

return instance;

}

class rgba_function : public function_expression {

public:

explicit rgba_function(surface surf, const args_list& args)

: function_expression("rgba", args, 4), surf_(surf) {

}

private:

variant execute(const formula_callable& variables) const {

return variant(SDL_MapRGBA(surf_->format,

Uint8(args()[0]->evaluate(variables).as_int()),

Uint8(args()[1]->evaluate(variables).as_int()),

Uint8(args()[2]->evaluate(variables).as_int()),

Uint8(args()[3]->evaluate(variables).as_int())));

}

surface surf_;

};

class surface_formula_symbol_table : public function_symbol_table

{

public:

explicit surface_formula_symbol_table(surface surf) : surf_(surf)

{}

expression_ptr create_function(

const std::string& fn,

const std::vector<expression_ptr>& args,

const formula_callable_definition* callable_def) const;

private:

surface surf_;

};

expression_ptr surface_formula_symbol_table::create_function(

const std::string& fn,

const std::vector<expression_ptr>& args,

const formula_callable_definition* callable_def) const

{

if(fn == "rgba") {

return expression_ptr(new rgba_function(surf_, args));

} else {

return function_symbol_table::create_function(fn, args, callable_def);

}

class pixel_callable : public game_logic::formula_callable {

public:

pixel_callable(const surface& surf, Uint32 pixel)

{

SDL_GetRGBA(pixel, surf->format, &r, &g, &b, &a);

static const unsigned char AlphaPixel[] = {0x6f, 0x6d, 0x51};

if(r == AlphaPixel[0] && g == AlphaPixel[1] && b == AlphaPixel[2]) {

a = 0;

}

bool is_alpha() const { return a == 0; }

private:

variant get_value(const std::string& key) const {

switch(*key.c_str()) {

case 'r': return variant(r);

case 'g': return variant(g);

case 'b': return variant(b);

case 'a': return variant(a);

default: return variant();

}

Uint8 r, g, b, a;

100

};

101

102

void run_formula(surface surf, const std::string& algo)

103

{

104

const hi_res_timer timer("run_formula");

105

106

const int ticks = SDL_GetTicks();

107

surface_formula_symbol_table table(surf);

108

game_logic::formula f(algo, &table);

109

bool locked = false;

110

if(SDL_MUSTLOCK(surf.get())) {

111

const int res = SDL_LockSurface(surf.get());

112

if(res == 0) {

113

locked = true;

114

}

115

}

116

117

std::map<Uint32, Uint32> pixel_map;

118

119

Uint32* pixels = reinterpret_cast<Uint32*>(surf->pixels);

120

Uint32* end_pixels = pixels + surf->w*surf->h;

121

122

Uint32 AlphaPixel = SDL_MapRGBA(surf->format, 0x6f, 0x6d, 0x51, 0x0);

123

124

int skip = 0;

125

while(pixels != end_pixels) {

126

if(((*pixels)&(~surf->format->Amask)) == AlphaPixel) {

127

++pixels;

128

continue;

129

}

130

std::map<Uint32, Uint32>::const_iterator itor = pixel_map.find(*pixels);

131

if(itor == pixel_map.end()) {

132

pixel_callable p(surf, *pixels);

133

Uint32 result = f.execute(p).as_int();

134

pixel_map[*pixels] = result;

135

*pixels = result;

136

} else {

137

*pixels = itor->second;

138

}

139

++pixels;

140

}

141

142

if(locked) {

143

SDL_UnlockSurface(surf.get());

144

}

145

}

146

147

}

148

149

surface get_surface_formula(surface input, const std::string& algo)

150

{

151

if(algo.empty()) {

152

return input;

153

}

154

155

cache_key key(input, algo);

156

surface surf = cache().get(key);

157

if(surf.get() == NULL) {

158

surf = input.clone();

159

run_formula(surf, algo);

160

cache().put(key, surf);

161

}

162

163

return surf;

164

}

165

166

namespace {

167

typedef std::map<std::pair<std::string, GLuint>, GLuint> shader_object_map;

168

shader_object_map shader_object_cache;

169

170

typedef std::map<std::pair<std::vector<std::string>,std::vector<std::string> >, GLuint> shader_map;

171

shader_map shader_cache;

172

173

void check_shader_errors(const std::string& fname, GLuint shader)

174

{

175

#ifndef SDL_VIDEO_OPENGL_ES

176

GLint value = 0;

177

glGetShaderiv(shader, GL_COMPILE_STATUS, &value);

178

if(value == GL_FALSE) {

179

char buf[1024*16];

180

GLint len;

181

glGetShaderInfoLog(shader, sizeof(buf), &len, buf);

182

std::string errors(buf, buf + len);

183

ASSERT_LOG(false, "COMPILE ERROR IN SHADER " << fname << ": " << errors);

184

}

185

#endif

186

}

187

188

GLuint compile_shader(const std::string& shader_file, GLuint type)

189

{

190

GLuint& id = shader_object_cache[std::make_pair(shader_file, type)];

191

if(id) {

192

return id;

193

}

194

#ifndef SDL_VIDEO_OPENGL_ES

195

id = glCreateShader(type);

196

197

const std::string file_data = sys::read_file("data/shaders/" + shader_file);

198

199

const char* file_str = file_data.c_str();

200

glShaderSource(id, 1, &file_str, NULL);

201

202

glCompileShader(id);

203

check_shader_errors(shader_file, id);

204

205

return id;

206

#else

207

return 0;

208

#endif

209

}

210

211

}

212

213

GLuint get_gl_shader(const std::vector<std::string>& vertex_shader_file,

214

const std::vector<std::string>& fragment_shader_file)

215

{

216

#ifndef SDL_VIDEO_OPENGL_ES

217

if(vertex_shader_file.empty() || fragment_shader_file.empty()) {

218

return 0;

219

}

220

221

shader_map::iterator itor = shader_cache.find(std::make_pair(vertex_shader_file, fragment_shader_file));

222

if(itor != shader_cache.end()) {

223

return itor->second;

224

}

225

226

std::vector<GLuint> shader_objects;

227

foreach(const std::string& shader_file, vertex_shader_file) {

228

shader_objects.push_back(compile_shader(shader_file, GL_VERTEX_SHADER));

229

}

230

231

foreach(const std::string& shader_file, fragment_shader_file) {

232

shader_objects.push_back(compile_shader(shader_file, GL_FRAGMENT_SHADER));

233

}

234

235

GLuint program_id = glCreateProgram();

236

237

foreach(GLuint shader_id, shader_objects) {

238

glAttachShader(program_id, shader_id);

239

}

240

241

glLinkProgram(program_id);

242

243

GLint link_status = 0;

244

glGetProgramiv(program_id, GL_LINK_STATUS, &link_status);

245

if(link_status != GL_TRUE) {

246

char buf[1024*16];

247

GLint len;

248

glGetProgramInfoLog(program_id, sizeof(buf), &len, buf);

249

std::string errors(buf, buf + len);

250

ASSERT_LOG(false, "LINK ERROR IN SHADER PROGRAM: " << errors);

251

}

252

253

shader_cache[std::make_pair(vertex_shader_file, fragment_shader_file)] = program_id;

254

255

glUseProgram(0);

256

257

return program_id;

258

#else

259

return 0;

260

#endif

261

}

262

263

BENCHMARK(surface_formula)

264

{

265

surface s(graphics::surface_cache::get("characters/frogatto-spritesheet1.png"));

266

assert(s.get());

267

268

surface target(SDL_CreateRGBSurface(SDL_SWSURFACE,s->w,s->h,32,SURFACE_MASK));

269

SDL_BlitSurface(s.get(), NULL, target.get(), NULL);

270

271

const std::string algo("rgba(b,r,g,a)");

272

BENCHMARK_LOOP {

273

run_formula(target, algo);

274

}

275

}

276

277

BENCHMARK(pixel_table)

278

{

279

//This is some hard coded test data. It gives the set of pixels in

280

//the input image, and the pixels we want to map to.

281

const Uint32 PixelsFrom[] = {0xFF00FFFF, 0xFFFFFFFF, 0x9772FF13, 0xFF002145, 0x00FFFFFF, 0x94FF28FF };

282

const Uint32 PixelsTo[] = {0x00FF0000, 0xFF00FFFF, 0xFFFFFFFF, 0x9772FF13, 0xFF002145, 0x00FFFFFF };

283

const int NumColors = sizeof(PixelsFrom)/sizeof(*PixelsFrom);

284

285

//Set up an image of a million pixels in size. Set all values to values

286

//in the 'pixels from' range.

287

std::vector<Uint32> image(1000000);

288

for(int n = 0; n != image.size(); ++n) {

289

image[n] = PixelsFrom[n%NumColors];

290

}

291

292

//set up our table mapping pixels from -> pixels to.

293

typedef std::map<Uint32, Uint32> PixelTable;

294

PixelTable table;

295

for(int n = 0; n != NumColors; ++n) {

296

table.insert(std::pair<Uint32, Uint32>(PixelsFrom[n], PixelsTo[n]));

297

}

298

299

//now go over the image and map all source pixels to their destinations.

300

//this is the part that we want to benchmark.

301

BENCHMARK_LOOP {

302

for(int n = 0; n != image.size(); ++n) {

303

image[n] = table[image[n]];

304

}

305

}

306

}

Older »