static void render(void *priv, float lerp)
{
struct _world *world = priv;
renderer_t r = world->render;
vec3_t cpos;
int mins;
renderer_render_3d(r);
renderer_clear_color(r, 0.8, 0.8, 1.0);
glPushMatrix();
view_transform(world);
light_render(world->light);
render_unlit(world, lerp);
render_shadow_volumes(world, lerp);
render_lit(world, lerp);
glPopMatrix();
renderer_render_2d(r);
chopper_get_pos(world->apache, lerp, cpos);
font_printf(world->font, 8, 4, "A madman strikes again! (%.0f fps)",
renderer_fps(r));
font_printf(world->font, 8, 24, "x: %.3f y: %.3f", cpos[0], cpos[2]);
mins = (world->fcnt * (M_PI / (world->lightRate * world->light_ticks))) * (1440.0 / (2 * M_PI));
mins += 6 * 60;
mins %= 1440;
font_printf(world->font, 8, 44, "local time: %02d:%02d",
mins / 60, mins % 60);
}
/* test functions */
void test1()
{
av = 10.0;
bv = 10.0;
cv = 10.0;
lx = ly = lz = 0.0;
view_transform();
persp_transform();
win_transform();
float point[4] = {2.0, 5.0, 1.0, 1.0};
float vV[4] = {0, 0, 0, 0};
multiply2(point, V, vV);
printf("(2, 5, 1)V = [%f, %f, %f, %f]\n", vV[0], vV[1], vV[2], vV[3]);
float vVP[4] = {0, 0, 0, 0};
multiply2(vV, P, vVP);
printf("(2, 5, 1)VP = [%f, %f, %f, %f]\n", vVP[0], vVP[1], vVP[2], vVP[3]);
float prod1[4] = {0, 0, 0, 0};
multiply2(vVP, W, prod1);
printf("(2, 5, 1)VPW = [%f, %f, %f, %f]\n", prod1[0], prod1[1], prod1[2], prod1[3]);
// homogenize result of <p1>*VPW
int i;
for (i = 0; i < 4; i++) {
prod1[i] /= prod1[3];
}
printf("(2, 5, 1)VPW<homogenize> = [%f, %f, %f, %f]\n", prod1[0], prod1[1], prod1[2], prod1[3]);
}
featureset_ptr Map::query_map_point(unsigned index, double x, double y) const
{
if ( index< layers_.size())
{
mapnik::layer const& layer = layers_[index];
CoordTransform tr = view_transform();
tr.backward(&x,&y);
try
{
mapnik::projection dest(srs_);
mapnik::projection source(layer.srs());
proj_transform prj_trans(source,dest);
double z = 0;
prj_trans.backward(x,y,z);
double minx = current_extent_.minx();
double miny = current_extent_.miny();
double maxx = current_extent_.maxx();
double maxy = current_extent_.maxy();
prj_trans.backward(minx,miny,z);
prj_trans.backward(maxx,maxy,z);
double tol = (maxx - minx) / width_ * 3;
mapnik::datasource_ptr ds = layer.datasource();
if (ds)
{
#ifdef MAPNIK_DEBUG
std::clog << " query at point tol = " << tol << " (" << x << "," << y << ")\n";
#endif
featureset_ptr fs = ds->features_at_point(mapnik::coord2d(x,y));
if (fs)
return boost::make_shared<filter_featureset<hit_test_filter> >(fs,
hit_test_filter(x,y,tol));
}
}
catch (...)
{
#ifdef MAPNIK_DEBUG
std::clog << "exception caught in \"query_map_point\"\n";
#endif
}
}
return featureset_ptr();
}
void d3d_control::render_frame(void)
{
// clear the window to a deep blue
d3ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
d3ddev->Clear(0, NULL, D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
//change wireframe mode
if( fillmode_changed ){
if( !is_solid ){
d3ddev->SetRenderState(D3DRS_FILLMODE,D3DFILL_SOLID);
}
else{
d3ddev->SetRenderState(D3DRS_FILLMODE,D3DFILL_WIREFRAME);
}
is_solid = !is_solid;
fillmode_changed=false;
}
d3ddev->BeginScene(); // begins the 3D scene
// select which vertex format we are using
d3ddev->SetFVF(CUSTOMFVF);
//set transform
view_transform();
projection_transform();
// set the world transform
D3DXMATRIX matLocal;
D3DXMatrixIdentity(&matLocal);
draw_axis( matLocal );
draw_text();
rs.draw();
d3ddev->EndScene(); // ends the 3D scene
d3ddev->Present(NULL, NULL, NULL, NULL); // displays the created frame on the screen
}
void init()
{
glClearColor(1.0, 1.0, 1.0, 0.0); // set the background color to white
glColor3f(1.0, 0.0, 0.0);
// initialize V, P, and W
view_transform();
persp_transform();
win_transform();
// prints out the values of V, P, and W for debugging
//printf("V matrix:\n");
//for (int i = 0; i < 16; i++) {
// if (i%4 == 0) {
// printf("\n");
// }
// printf("[%f],\t", V[i]);
//}
//printf("\n");
//printf("P matrix:\n");
//for (int i = 0; i < 16; i++) {
// if (i%4 == 0) {
// printf("\n");
// }
// printf("[%f],\t", P[i]);
//}
//printf("\n");
//printf("W matrix:\n");
//for (int i = 0; i < 16; i++) {
// if (i%4 == 0) {
// printf("\n");
// }
// printf("[%f],\t", W[i]);
//}
//printf("\n");
setupViewport(520, 520); // setup our initial window
}
featureset_ptr Map::query_map_point(unsigned index, double x, double y) const
{
CoordTransform tr = view_transform();
tr.backward(&x,&y);
return query_point(index,x,y);
}
// Select
void bwindow_pick(BWindow self){
static GLuint selectionBuffer[256];
GLuint *ptr, *selection, num_obj, z1,z2,z;
GLint hits;
int num, i,j;
raster_hit =0;
current_window = self;
draw_status = SELECT;
self->event.pos.y = self->height - self->event.pos.y;
self->event.dpos.y *=-1;
pick_dx = self->event.pos.x - pick_x;
pick_dy = self->event.pos.y - pick_y;
pick_x = self->event.pos.x;
pick_y = self->event.pos.y;
// initialize selection buffer
glSelectBuffer(256,selectionBuffer);
//--------------------------------------------------------------------------------------------
glViewport(0,0,self->width,self->height);
current_viewport[0] = 0;
current_viewport[1] = 0;
current_viewport[2] = self->width;
current_viewport[3] = self->height;
//--------------------------------------------------------------------------------------------
/*
* Hit stack looks like this:
*
* num_obj (GLuint)- number of objects on stack
* z1 (GLuint) - value of closest point in hit
* z2 (GLuint) - value of farthest point in hit
* first object in hit - this is the id (or in this case pointer) of the first object in hit
* .
* .
* n object in hit - this is the id (or in this case pointer) of the n object in hit
*/
ptr = selectionBuffer;
num_obj = z1 = z2 = z=0;
selection=NULL;
glRenderMode(GL_SELECT);
glInitNames();
// iterate window's items and draw them
im_draw( self->items);
hits = glRenderMode(GL_RENDER); //number of hit stacks
if (hits){
// initialize values for first hit
num_obj = num = *ptr++; // number of objects in stack
z = z1 = *ptr++; // min depth of hit
z2 = *ptr++; // max depth of hit
selection = ptr; // selection remembers closest hit
// if there is more than one hit selection will be the one with the nearest point
for (i = 1; i<hits ; i++){
ptr+=num; // increment ahead to next hit
num = *ptr++;
z1 = *ptr++;
z2 = *ptr++;
if (z1 < z){
selection = ptr;
z = z1;
num_obj=num;
}
}
// num is the number of hits in this stack
// j = 0 is the view
Layer lay = NULL;
Link child = NULL;
Binding binding = NULL;
view_transform(current_view);
for (j = 0 ; j< num_obj ; j++){
child=(Link) index_get(bound_layers, *selection++);
lay = child->value.vptr;
layer_transform(child->value.vptr);
binding = lay->bindings;
while(binding){
if( ((binding->event.state & current_window->event.state) == binding->event.state) &&
(binding->event.key == current_window->event.key))
{
callback(child,binding->callback);
}
binding = binding->next;
}
}
}
if (self->update) bwindow_paint(self);
}
int main(int argc, char *argv[]) {
SDL_Surface *screen;
GError *error = NULL;
RsvgHandle *handle;
struct svgviewer_view vw;
char *filename;
//const char *output_filename = argv[2];
cairo_surface_t *surface;
cairo_t *cr;
cairo_t *cr2;
cairo_status_t status;
int c;
int rerender = 0;
SDL_VideoInfo* info;
vw.zoom = 1;
/* Process options */
while (1) {
int option_index = 0;
c = getopt_long (argc, argv, "d:v:",
long_options, &option_index);
/* Detect the end of the options. */
if (c == -1) break;
switch (c) {
case 0:
break;
case 'z':
errno = 0;
vw.zoom = strtod(optarg, NULL);
DEBUG("Zoom set to %g\n", vw.zoom);
if (errno) FAIL("Usage: -z or --zoom requires a floating point argument");
break;
default:
abort();
};
}
if (argc != optind+1) FAIL("Usage: %s OPTIONS input_file.svg\n", argv[0]);
filename = argv[optind];
g_type_init();
rsvg_set_default_dpi(72.0);
handle = rsvg_handle_new_from_file(filename, &error);
if (error != NULL)
FAIL(error->message);
rsvg_handle_get_dimensions(handle, &dim);
vw.x = 0; vw.y = 0;
vw.zoom = 1;
/* Initialize SDL */
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0) {
fprintf(stderr, "Unable to initialize SDL: %s\n",
SDL_GetError());
exit(1);
}
int videomodeflags;
if (fullscreen_flag) {
screen = SDL_SetVideoMode(0, 0, 32,
videomodeflags =
SDL_FULLSCREEN | SDL_SWSURFACE | SDL_RESIZABLE);
} else {
const SDL_VideoInfo* info = SDL_GetVideoInfo();
if ((dim.width >= info->current_w) ||
(dim.height >= info->current_h)) {
screen = SDL_SetVideoMode(0, 0, 32,
videomodeflags =
SDL_SWSURFACE | SDL_RESIZABLE);
} else {
screen = SDL_SetVideoMode(dim.width, dim.height, 32,
videomodeflags =
SDL_SWSURFACE | SDL_RESIZABLE);
}
}
if (screen == NULL) {
fprintf(stderr, "Unable to set video mode: %s\n", SDL_GetError());
exit(1);
}
vw.pixel_width = screen->w;
vw.pixel_height = screen->h;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, vw.pixel_width, vw.pixel_height);
cr2 = cairo_create (surface);
//cairo_translate(cr2, ((double)dim.width)/-2, ((double)dim.height)/-2);
//surface = cairo_pdf_surface_create (output_filename, width, height);
// SDL_LockSurface(screen);
//cairo_scale (cr, screen->w, screen->h);
cairo_save(cr2);
view_transform(cr2, &vw);
rsvg_handle_render_cairo(handle, cr2);
status = cairo_status(cr2);
if (status) FAIL(cairo_status_to_string(status));
cairo_restore(cr2);
cr = cairosdl_create(screen);
// cairo_set_source_rgb(cr, 1, 1, 1);
// cairo_paint(cr);
cairo_save(cr);
//cairo_scale(cr, .5, .5);
//cairo_translate(cr, width/2, height/2 );
//cairo_rotate( cr, 3.14/2 );
//cairo_translate(cr, -width/2, -height/2 );
cairo_set_source_surface (cr, surface, 0, 0);
cairo_paint(cr);
cairo_restore(cr);
status = cairo_status(cr);
if (status)
FAIL(cairo_status_to_string(status));
// SDL_UnlockSurface(screen);
SDL_UpdateRect(screen, 0, 0, 0, 0);
{
SDL_Event event;
while (SDL_WaitEvent(&event)) {
switch (event.type) {
case SDL_KEYDOWN:
switch (event.key.keysym.sym) {
case SDLK_UP:
vw.y -= 0.1 / vw.zoom;
rerender = 1;
break;
case SDLK_DOWN:
vw.y += 0.1 / vw.zoom;
rerender = 1;
break;
case SDLK_LEFT:
vw.x -= 0.1 / vw.zoom;
rerender = 1;
break;
case SDLK_RIGHT:
vw.x += 0.1 / vw.zoom;
rerender = 1;
break;
case SDLK_a:
vw.zoom *= 1.025;
rerender = 1;
break;
case SDLK_z:
vw.zoom /= 1.025;
rerender = 1;
break;
case SDLK_ESCAPE:
goto exit;
default:
break;
}
break;
case SDL_VIDEORESIZE:
{
vw.pixel_width = event.resize.w;
vw.pixel_height = event.resize.h;
cairo_destroy(cr2);
cairo_surface_destroy(surface);
surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, vw.pixel_width, vw.pixel_height);
cr2 = cairo_create(surface);
//cairo_translate(cr2, ((double)dim.width)/-2, ((double)dim.height)/-2);
cairo_save(cr2);
view_transform(cr2, &vw);
rsvg_handle_render_cairo(handle, cr2);
cairo_restore(cr2);
screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 32, videomodeflags);
cairosdl_destroy(cr);
cr = cairosdl_create(screen);
cairo_save(cr);
cairo_set_source_surface(cr, surface, 0, 0);
cairo_paint(cr);
cairo_restore(cr);
};
break;
case SDL_QUIT:
goto exit;
default:
break;
}
if (rerender) {
cairo_save(cr2);
view_transform(cr2, &vw);
rsvg_handle_render_cairo(handle, cr2);
status = cairo_status(cr2);
if (status) FAIL(cairo_status_to_string(status));
cairo_restore(cr2);
cairo_set_source_surface(cr, surface, 0, 0);
cairo_paint(cr);
rerender = 0;
}
SDL_UpdateRect(screen, 0, 0, 0, 0);
};
};
exit:
cairosdl_destroy(cr);
if (status)
FAIL(cairo_status_to_string(status));
cairo_destroy (cr2);
cairo_surface_destroy(surface);
SDL_Quit();
exit(EXIT_SUCCESS);
}
std::shared_ptr<Texture> RenderPass::
get_buffer(std::string const& name, CameraMode mode, bool draw_fps) {
// check for existance of desired buffer
if ((mode == CENTER
&& center_eye_buffers_.find(name) == center_eye_buffers_.end())
|| (mode == LEFT
&& left_eye_buffers_.find(name) == left_eye_buffers_.end())
|| (mode == RIGHT
&& right_eye_buffers_.find(name) == right_eye_buffers_.end())) {
WARNING("Failed to get buffer \"%s\" from pass \"%s\": "
"A buffer with this name does not exist!",
name.c_str(), get_name().c_str());
return NULL;
}
// return appropriate buffer if it has been rendered already
if (mode == CENTER && rendererd_center_eye_)
return center_eye_buffers_[name];
if (mode == LEFT && rendererd_left_eye_)
return left_eye_buffers_[name];
if (mode == RIGHT && rendererd_right_eye_)
return right_eye_buffers_[name];
// serialize the scenegraph
Optimizer optimizer;
optimizer.check(pipeline_->get_current_graph(), render_mask_);
// if there are dynamic texture inputs for this render pass, get the
// according buffers recursively
for (auto& node: optimizer.get_data().nodes_) {
auto material(inputs_.find(node.material_));
if (material != inputs_.end()) {
for (auto& uniform: material->second) {
overwrite_uniform_texture(material->first, uniform.first,
pipeline_->get_render_pass(uniform.second.first)->
get_buffer(uniform.second.second, mode));
}
}
}
// we'll need these two very often now...
OptimizedScene const& scene(optimizer.get_data());
RenderContext const& ctx(pipeline_->get_context());
// get the fbo which should be rendered to
FrameBufferObject* fbo(NULL);
switch (mode) {
case CENTER:
fbo = ¢er_eye_fbo_;
break;
case LEFT:
fbo = &left_eye_fbo_;
break;
case RIGHT:
fbo = &right_eye_fbo_;
break;
}
fbo->bind(ctx);
fbo->clear_color_buffers(ctx);
fbo->clear_depth_stencil_buffer(ctx);
ctx.render_context->set_viewport(scm::gl::viewport(math::vec2(0,0),
math::vec2(fbo->width(),
fbo->height())));
auto camera_it(scene.cameras_.find(camera_));
auto screen_it(scene.screens_.find(screen_));
if (camera_it != scene.cameras_.end()
&& screen_it != scene.screens_.end()) {
auto camera(camera_it->second);
auto screen(screen_it->second);
math::mat4 camera_transform(camera.transform_);
if (mode == LEFT) {
scm::math::translate(camera_transform,
-camera.stereo_width_*0.5f, 0.f, 0.f);
} else if (mode == RIGHT) {
scm::math::translate(camera_transform,
camera.stereo_width_*0.5f, 0.f, 0.f);
}
auto projection(math::compute_frustum(camera_transform.column(3),
screen.transform_,
0.1, 100000.f));
math::mat4 view_transform(screen.transform_);
view_transform[12] = 0.f;
view_transform[13] = 0.f;
view_transform[14] = 0.f;
view_transform[15] = 1.f;
math::vec3 camera_position(camera_transform.column(3)[0],
camera_transform.column(3)[1],
camera_transform.column(3)[2]);
view_transform = scm::math::make_translation(camera_position)
* view_transform;
math::mat4 view_matrix(scm::math::inverse(view_transform));
// update light data uniform block
if (scene.lights_.size() > 0) {
if (!light_information_) {
light_information_ =
new scm::gl::uniform_block<LightInformation>(ctx.render_device);
}
light_information_->begin_manipulation(ctx.render_context);
LightInformation light;
light.light_count = math::vec4i(scene.lights_.size(),
scene.lights_.size(),
scene.lights_.size(),
scene.lights_.size());
for (unsigned i(0); i < scene.lights_.size(); ++i) {
math::mat4 transform(scene.lights_[i].transform_);
// calc light radius and position
light.position[i] = math::vec4(transform[12], transform[13],
transform[14], transform[15]);
float radius = scm::math::length(light.position[i] - transform
* math::vec4(0.f, 0.f, 1.f, 1.f));
light.color_radius[i] = math::vec4(scene.lights_[i].color_.r(),
scene.lights_[i].color_.g(),
scene.lights_[i].color_.b(),
radius);
}
**light_information_ = light;
light_information_->end_manipulation();
ctx.render_context->bind_uniform_buffer(
light_information_->block_buffer(), 0);
}
for (auto& core: scene.nodes_) {
auto geometry = GeometryBase::instance()->get(core.geometry_);
auto material = MaterialBase::instance()->get(core.material_);
if (material && geometry) {
material->use(ctx);
if (float_uniforms_.find(core.material_)
!= float_uniforms_.end()) {
for (auto val : float_uniforms_[core.material_])
material->get_shader()->set_float(ctx, val.first,
val.second);
}
if (texture_uniforms_.find(core.material_)
!= texture_uniforms_.end()) {
for (auto val : texture_uniforms_[core.material_])
material->get_shader()->set_sampler2D(ctx, val.first,
*val.second);
}
material->get_shader()->set_mat4(ctx, "projection_matrix",
projection);
material->get_shader()->set_mat4(ctx, "view_matrix",
view_matrix);
material->get_shader()->set_mat4(ctx, "model_matrix",
core.transform_);
material->get_shader()->set_mat4(ctx, "normal_matrix",
scm::math::transpose(
scm::math::inverse(core.transform_)));
geometry->draw(ctx);
material->unuse(ctx);
} else if (material) {
WARNING("Cannot render geometry \"%s\": Undefined geometry "
"name!", core.geometry_.c_str());
} else if (geometry) {
WARNING("Cannot render geometry \"%s\": Undefined material "
"name: \"%s\"!", core.geometry_.c_str(),
core.material_.c_str());
} else {
WARNING("Cannot render geometry \"%s\": Undefined geometry "
"and material name: \"%s\"!", core.geometry_.c_str(),
core.material_.c_str());
}
}
if (scene.lights_.size() > 0) {
ctx.render_context->reset_uniform_buffers();
}
}
fbo->unbind(ctx);
// draw fps on the screen
if (draw_fps) {
if (!text_renderer_)
text_renderer_ = new TextRenderer(pipeline_->get_context());
if (mode == CENTER) {
text_renderer_->render_fps(pipeline_->get_context(), center_eye_fbo_,
pipeline_->get_application_fps(),
pipeline_->get_rendering_fps());
} else if (mode == LEFT) {
text_renderer_->render_fps(pipeline_->get_context(), left_eye_fbo_,
pipeline_->get_application_fps(),
pipeline_->get_rendering_fps());
} else {
text_renderer_->render_fps(pipeline_->get_context(), right_eye_fbo_,
pipeline_->get_application_fps(),
pipeline_->get_rendering_fps());
}
}
// return the buffer and set the already-rendered-flag
if (mode == CENTER) {
rendererd_center_eye_ = true;
return center_eye_buffers_[name];
} else if (mode == LEFT) {
rendererd_left_eye_ = true;
return left_eye_buffers_[name];
} else {
rendererd_right_eye_ = true;
return right_eye_buffers_[name];
}
}
/* whenever viewer controls are changed */
void viewer_callback(int ID)
{
view_transform();
display(); // draw the cube
}
