void osint_render(void){ int v; SDL_FillRect(screen, NULL, 0); for(v = 0; v < vector_draw_cnt; v++){ Uint8 c = vectors_draw[v].color * 256 / VECTREX_COLORS; if (rotatexy) aalineRGBA(screen, (Sint16)(screenx - offx - vectors_draw[v].y0 / scl_factor), (Sint16)(offy + vectors_draw[v].x0 / scl_factor), (Sint16)(screenx - offx - vectors_draw[v].y1 / scl_factor), (Sint16)(offy + vectors_draw[v].x1 / scl_factor), c, c, c, 0xff); else aalineRGBA(screen, (Sint16)(offx + vectors_draw[v].x0 / scl_factor), (Sint16)(offy + vectors_draw[v].y0 / scl_factor), (Sint16)(offx + vectors_draw[v].x1 / scl_factor), (Sint16)(offy + vectors_draw[v].y1 / scl_factor), c, c, c, 0xff); } // Draw overlay image if (overlay != NULL) { SDL_Rect src, dst; dst.x = src.x = 0; dst.y = src.y = 0; dst.w = src.w = (Uint16)screenx; dst.h = src.h = (Uint16)screeny; SDL_BlitSurface(overlay, &src, screen, &dst); } SDL_Flip(screen); }
void Draw_Building(way* w, char* role, RGBA* color, char* type) { Sint16 *vx, *vy; RGBA rgba; node_t* node = NULL; double longitude, latitude, minlat, maxlat, minlon, maxlon; int i, j, k, index, compteur, value_tag; static int policy = 0; maxlat = pBound->maxlat; minlat = pBound->minlat; maxlon = pBound->maxlon; minlon = pBound->minlon; vx = malloc(w->size_ref * sizeof(*vx)); vy = malloc(w->size_ref * sizeof(*vy)); compteur = 0; for(i = 0; i < w->size_ref; i++) { index = search_node_dicho(w->ref[i]); if(index == FAILURE) continue; node = pRoot->arrayNodes[index]; longitude = node->longitude; latitude = node->latitude; vx[i] = (Sint16)(long_to_pix(longitude) * pMap->width * pMap->zoom); vy[i] = (Sint16)(lat_to_pix(latitude) * pMap->height * pMap->zoom); compteur++; } if(type != NULL && !strcmp(type, "barrier")) { for(i = 0; i < compteur - 1; i++) aalineRGBA(pRenderer, vx[i], vy[i], vx[i+1], vy[i+1], color->r, color->g, color->b, color->a); } else { filledPolygonRGBA(pRenderer, vx, vy, compteur, color->r, color->g, color->b, color->a); if(role == NULL) { rgba = colorConverter(BARRIER_COLOR); for(i = 0; i < compteur - 1; i++) aalineRGBA(pRenderer, vx[i], vy[i], vx[i+1], vy[i+1], rgba.r, rgba.g, rgba.b, rgba.a); } } free(vx); free(vy); }
// ML type: surface -> point -> point -> color -> bool -> unit // Draws a line from wStart to wEnd of wColor on wScreen. // If wAntialias is true, then the line will be antialiased. EXTERNML value draw_draw_line(value wScreen, value wStart, value wEnd, value wColor, value wAntiAlias) { SDL_Surface *screen = (SDL_Surface *)Addr_val(wScreen); int startx = Long_val(Field(wStart, 0)), starty = Long_val(Field(wStart, 1)), endx = Long_val(Field(wEnd, 0)), endy = Long_val(Field(wEnd, 1)), colorr = Long_val(Field(wColor, 0)), colorg = Long_val(Field(wColor, 1)), colorb = Long_val(Field(wColor, 2)), colora = Tag_val(wColor) == RGBA ? Long_val(Field(wColor, 3)) : 255; if (colorr < 0 || colorr > 255 || colorg < 0 || colorg > 255 || colorb < 0 || colorb > 255 || colora < 0 || colora > 255) { invalid_argument("Invalid color value given - each value must be between 0 and 255."); } if (Bool_val(wAntiAlias)) { aalineRGBA(screen, startx, starty, endx, endy, colorr, colorg, colorb, 255); } else { lineRGBA(screen, startx, starty, endx, endy, colorr, colorg, colorb, 255); } return Val_unit; }
void ConfigurationMenu::RenderMenu( SDL_Surface *surface ) { if ( visibility ) { boxRGBA( surface, 800 / 2 - 250, 480 / 2 - 150, 800 / 2 + 250, 480 / 2 + 150, 0, 0, 0, 255 ); rectangleRGBA( surface, 800 / 2 - 250, 480 / 2 - 150, 800 / 2 + 250, 480 / 2 + 150, 255, 255, 255, 255 ); rectangleRGBA( surface, 800 / 2 - 250 + 1, 480 / 2 - 150 + 1, 800 / 2 + 250 - 1, 480 / 2 + 150 - 1, 255, 255, 255, 255 ); aalineRGBA( surface, 800 / 2 - 225, 480 / 2 - 100, 800 / 2 + 225, 480 / 2 - 100, 255, 255, 255, 200 ); dialogTitleLabel.Render( surface ); traceLinesLabel.Render( surface ); traceLineBodyLabel.Render( surface ); traceLineSledLabel.Render( surface ); traceLineHatLabel.Render( surface ); traceLineHeadLabel.Render( surface ); traceLineArmLabel.Render( surface ); traceLineLegLabel.Render( surface ); traceLineBodyRadio.Render( surface ); traceLineSledRadio.Render( surface ); traceLineHatRadio.Render( surface ); traceLineHeadRadio.Render( surface ); traceLineArmRadio.Render( surface ); traceLineLegRadio.Render( surface ); lineSnapLabel.Render( surface ); lineSnapRadio.Render( surface ); } }
void Bullet::Render() { double strength = timeLeft/timeMax; int r = 255; int g = 255*strength; int b = 0; int a = 255*strength; aalineRGBA(Surface::Display, startX, startY, endX, endY, r, g, b, a); };
static void drawDIPS(SDL_Surface* surf, state* s, unsigned char r, unsigned char g, unsigned char b, unsigned char a, double ratioPixels) { double distance = (fabs(s->xPosition2 - s->xPosition1) * ratioPixels) - 14; double inter = (distance) / (double)NB_SPRING; unsigned int i = 1; int sign = 1; double x1 = (screenWidth / 4.0) + (s->xPosition1 * ratioPixels); double y1 = screenHeight / 2.0; double x2 = x1 - (ratioPixels * sin(M_PIl - s->angularPosition1) * 2.0 * parameters[2]); double y2 = y1 + (ratioPixels * cos(M_PIl - s->angularPosition1) * 2.0 * parameters[2]); aalineRGBA(surf, x1, y1, x2, y2, r, g, b, a); filledCircleRGBA(surf, x1, y1, 5, r, g, b, a); filledCircleRGBA(surf, x2, y2, 5, r, g, b, a); rectangleRGBA(surf, x1 - 7, y1 - 7, x1 + 7, y1 + 7, r, g, b, a); x1 = (screenWidth / 4.0) + (s->xPosition2 * ratioPixels); y1 = (screenHeight / 2.0); x2 = x1 - (ratioPixels * sin(M_PIl - s->angularPosition2) * 2.0 * parameters[3]); y2 = y1 + (ratioPixels * cos(M_PIl - s->angularPosition2) * 2.0 * parameters[3]); aalineRGBA(surf, x1, y1, x2, y2, r, g, b, a); filledCircleRGBA(surf, x1, y1, 5, r, g, b, a); filledCircleRGBA(surf, x2, y2, 5, r, g, b, a); rectangleRGBA(surf, x1 - 7, y1 - 7, x1 + 7, y1 + 7, r, g, b, a); x1 = (screenWidth / 4.0) + (s->xPosition1 * ratioPixels) + 7; y1 = (screenHeight / 2.0); for(; i <= NB_SPRING; i++) { if(sign > 0) sign = -7; else sign = 7; aalineRGBA(surf, x1+((i-1)*inter), y1+sign, x1+(i*inter), y1-sign, r, g, b, a); } }
CAMLprim value ml_aalineRGBA(value dst,value p1,value p2, value col,value alpha) { SDL_Surface *sur= SDL_SURFACE(dst); SDL_Rect rect1,rect2; SDL_Color c; int r; SDLRect_of_value(&rect1,p1); SDLRect_of_value(&rect2,p2); SDLColor_of_value(&c,col); r=aalineRGBA(sur,rect1.x,rect1.y,rect2.x,rect2.y,c.r,c.g,c.b, Int_val(alpha)); return Val_bool(r); }
void sequential_soo_drawingProcedure(SDL_Surface* screen, int screenWidth, int screenHeight, void* instance) { #if NUMBER_OF_DIMENSIONS_OF_ACTION == 1 sequential_soo_instance* theInstance = (sequential_soo_instance*)instance; if(instance != NULL) { unsigned int H = theInstance->H; unsigned int i = 0; unsigned int heightShift = (H == 1) ? 0 : (screenHeight-20)/(H-1); for(; i < H; i++) { soo* sooInstance = theInstance->instances[i]; depth* crtDepth = sooInstance->list; while(crtDepth != NULL) { leaf* crtLeaf = crtDepth->list; /*double shift = (1.0/(2.0*pow(3.0,crtDepth->depth))) * (WIDTH_TREE - 20);*/ double y = 10 + (i * heightShift); aalineRGBA(screen, (screenWidth / 2.0) + 10, y, screenWidth - 10, y, 0, 0, 0, 255); while(crtLeaf != NULL) { double x = (screenWidth / 2.0) + 10 + (crtLeaf->centerPosition[0]*((screenWidth / 2.0) - 20)); aalineRGBA(screen, x, y + 2, x, y - 2, 0, 0, 0, 255); /*aalineRGBA(screen, x - shift, y - 4, x - shift, y + 4, 0, 0, 0, 255); aalineRGBA(screen, x + shift, y - 4, x + shift, y + 4, 0, 0, 0, 255);*/ crtLeaf = crtLeaf->next; } crtDepth = crtDepth->next; } } } #else (void)screen; (void)screenWidth; (void)screenHeight; (void)instance; #endif }
void Draw_Natural(way* w, char* role, RGBA* color, char* type) { Sint16 *vx, *vy; node_t* node = NULL; double longitude, latitude, minlat, maxlat, minlon, maxlon; int i, index, compteur = 0; maxlat = pBound->maxlat; minlat = pBound->minlat; maxlon = pBound->maxlon; minlon = pBound->minlon; vx = malloc(w->size_ref * sizeof(*vx)); vy = malloc(w->size_ref * sizeof(*vy)); for(i = 0; i < w->size_ref; i++) { index = search_node_dicho(w->ref[i]); if(index == FAILURE) continue; node = pRoot->arrayNodes[index]; longitude = node->longitude; latitude = node->latitude; vx[i] = (Sint16)(long_to_pix(longitude) * pMap->width * pMap->zoom); vy[i] = (Sint16)(lat_to_pix(latitude) * pMap->height * pMap->zoom); compteur++; } if(type != NULL) if(!strcmp(type, "cliff")) for(i = 0; i < compteur - 1; i++) thickLineRGBA(pRenderer, vx[i], vy[i], vx[i + 1], vy[i + 1], CLIFF_LENGTH, color->r, color->g, color->b, color->a); else if(!strcmp(type, "coastline")) for(i = 0; i < compteur - 1; i++) aalineRGBA(pRenderer, vx[i], vy[i], vx[i + 1], vy[i + 1], color->r, color->g, color->b, color->a); else filledPolygonRGBA(pRenderer, vx, vy, compteur, color->r, color->g, color->b, color->a); free(vx); free(vy); }
void osint_render(void){ SDL_FillRect(screen, NULL, 0); int v; for(v = 0; v < vector_draw_cnt; v++){ Uint8 c = vectors_draw[v].color * 256 / VECTREX_COLORS; aalineRGBA(screen, offx + vectors_draw[v].x0 / scl_factor, offy + vectors_draw[v].y0 / scl_factor, offx + vectors_draw[v].x1 / scl_factor, offy + vectors_draw[v].y1 / scl_factor, c, c, c, 0xff); } if(overlay){ SDL_Rect dest_rect = {offx, offy, 0, 0}; SDL_BlitSurface(overlay, NULL, screen, &dest_rect); } SDL_Flip(screen); }
static void drawPendulum(state* s, unsigned char r, unsigned char g, unsigned char b, unsigned char a, double ratioPixels) { double x1 = (screenWidth / 4.0) + (s->xPosition * ratioPixels); double y1 = screenHeight / 2.0; double x2 = x1 - (ratioPixels * sin(M_PIl - s->angularPosition) * 2.0 * parameters[2]); double y2 = y1 + (ratioPixels * cos(M_PIl - s->angularPosition) * 2.0 * parameters[2]); aalineRGBA(screen, x1, y1, x2, y2, r, g, b, a); filledCircleRGBA(screen, x1, y1, 3, r, g, b, a); x2 = x1 - (int)(ratioPixels * sin(M_PIl - s->angularPosition) * ((2.0 * parameters[2]) + (3.0/ratioPixels))); y2 = y1 + (int)(ratioPixels * cos(M_PIl - s->angularPosition) * ((2.0 * parameters[2]) + (3.0/ratioPixels))); filledCircleRGBA(screen, x2, y2, 3, r, g, b, a); rectangleRGBA(screen, x1 - 10, y1 - 5, x1 + 10, y1 + 5, r, g, b, a); }
void Renderer::Line(Point p, Point p2, Uint8 rr, Uint8 gg, Uint8 bb, Uint8 aa){ aalineRGBA(_renderer, p.x(), p.y(), p2.x(), p2.y(), rr, gg, bb, aa); }
/* Calls to commands created via [sdl.surface] are implemented by this * C command. */ static int JimSdlHandlerCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { JimSdlSurface *jss = Jim_CmdPrivData(interp); int option; static const char * const options[] = { "free", "flip", "pixel", "rectangle", "box", "line", "aaline", "circle", "aacircle", "fcircle", NULL }; enum { OPT_FREE, OPT_FLIP, OPT_PIXEL, OPT_RECTANGLE, OPT_BOX, OPT_LINE, OPT_AALINE, OPT_CIRCLE, OPT_AACIRCLE, OPT_FCIRCLE }; if (argc < 2) { Jim_WrongNumArgs(interp, 1, argv, "method ?args ...?"); return JIM_ERR; } if (Jim_GetEnum(interp, argv[1], options, &option, "SDL surface method", JIM_ERRMSG) != JIM_OK) return JIM_ERR; if (option == OPT_PIXEL) { /* PIXEL */ long x, y, red, green, blue, alpha = 255; if (argc != 7 && argc != 8) { Jim_WrongNumArgs(interp, 2, argv, "x y red green blue ?alpha?"); return JIM_ERR; } if (Jim_GetLong(interp, argv[2], &x) != JIM_OK || Jim_GetLong(interp, argv[3], &y) != JIM_OK || Jim_GetLong(interp, argv[4], &red) != JIM_OK || Jim_GetLong(interp, argv[5], &green) != JIM_OK || Jim_GetLong(interp, argv[6], &blue) != JIM_OK) { return JIM_ERR; } if (argc == 8 && Jim_GetLong(interp, argv[7], &alpha) != JIM_OK) return JIM_ERR; pixelRGBA(jss->screen, x, y, red, green, blue, alpha); return JIM_OK; } else if (option == OPT_RECTANGLE || option == OPT_BOX || option == OPT_LINE || option == OPT_AALINE) { /* RECTANGLE, BOX, LINE, AALINE */ long x1, y1, x2, y2, red, green, blue, alpha = 255; if (argc != 9 && argc != 10) { Jim_WrongNumArgs(interp, 2, argv, "x y red green blue ?alpha?"); return JIM_ERR; } if (Jim_GetLong(interp, argv[2], &x1) != JIM_OK || Jim_GetLong(interp, argv[3], &y1) != JIM_OK || Jim_GetLong(interp, argv[4], &x2) != JIM_OK || Jim_GetLong(interp, argv[5], &y2) != JIM_OK || Jim_GetLong(interp, argv[6], &red) != JIM_OK || Jim_GetLong(interp, argv[7], &green) != JIM_OK || Jim_GetLong(interp, argv[8], &blue) != JIM_OK) { return JIM_ERR; } if (argc == 10 && Jim_GetLong(interp, argv[9], &alpha) != JIM_OK) return JIM_ERR; switch (option) { case OPT_RECTANGLE: rectangleRGBA(jss->screen, x1, y1, x2, y2, red, green, blue, alpha); break; case OPT_BOX: boxRGBA(jss->screen, x1, y1, x2, y2, red, green, blue, alpha); break; case OPT_LINE: lineRGBA(jss->screen, x1, y1, x2, y2, red, green, blue, alpha); break; case OPT_AALINE: aalineRGBA(jss->screen, x1, y1, x2, y2, red, green, blue, alpha); break; } return JIM_OK; } else if (option == OPT_CIRCLE || option == OPT_AACIRCLE || option == OPT_FCIRCLE) { /* CIRCLE, AACIRCLE, FCIRCLE */ long x, y, radius, red, green, blue, alpha = 255; if (argc != 8 && argc != 9) { Jim_WrongNumArgs(interp, 2, argv, "x y radius red green blue ?alpha?"); return JIM_ERR; } if (Jim_GetLong(interp, argv[2], &x) != JIM_OK || Jim_GetLong(interp, argv[3], &y) != JIM_OK || Jim_GetLong(interp, argv[4], &radius) != JIM_OK || Jim_GetLong(interp, argv[5], &red) != JIM_OK || Jim_GetLong(interp, argv[6], &green) != JIM_OK || Jim_GetLong(interp, argv[7], &blue) != JIM_OK) { return JIM_ERR; } if (argc == 9 && Jim_GetLong(interp, argv[8], &alpha) != JIM_OK) return JIM_ERR; switch (option) { case OPT_CIRCLE: circleRGBA(jss->screen, x, y, radius, red, green, blue, alpha); break; case OPT_AACIRCLE: aacircleRGBA(jss->screen, x, y, radius, red, green, blue, alpha); break; case OPT_FCIRCLE: filledCircleRGBA(jss->screen, x, y, radius, red, green, blue, alpha); break; } return JIM_OK; } else if (option == OPT_FREE) { /* FREE */ if (argc != 2) { Jim_WrongNumArgs(interp, 2, argv, ""); return JIM_ERR; } Jim_DeleteCommand(interp, Jim_String(argv[0])); return JIM_OK; } else if (option == OPT_FLIP) { /* FLIP */ if (argc != 2) { Jim_WrongNumArgs(interp, 2, argv, ""); return JIM_ERR; } SDL_Flip(jss->screen); return JIM_OK; } return JIM_OK; }
void start_freehand_drawing(void) { FreehandGeometry geometry; int oldmouse_x, oldmouse_y; int offsetx = cxoff + canvas->get_absxpos(); int offsety = cyoff + canvas->get_absypos(); //SDL_Surface *sur = canvas->get_image(canvas->get_active_image_n()); SDL_Surface *behind = SDLGui::createSurface(screen->w, screen->h); blit(screen, behind, 0, 0, 0, 0, screen->w, screen->h); SDL_Event event; oldmouse_x = mouse.x; oldmouse_y = mouse.y; unsigned processed = 0; StlStroke& stroke = *(geometry.currStroke); while(mouse.b == SDL_BUTTON_LEFT) { // Update the screen with the last round of geometry read from the // event queue. SDL_PumpEvents(); for (unsigned i = processed; i < stroke.size(); i++) { if (i == 0) { //putpixel(screen, stroke[i].x + offsetx, // stroke[i].y + offsety, BLACK); continue; } aalineRGBA(screen, (int) stroke[i - 1].x + offsetx, (int) stroke[i - 1].y + offsety, (int) stroke[i].x + offsetx, (int) stroke[i].y + offsety, 0, 0, 0, 128); processed++; } SDL_PumpEvents(); SDL_Flip(screen); // Wait for a new event. SDL_WaitEvent(&event); // Process all events in the queue. do { switch (event.type) { case SDL_MOUSEMOTION: mouse.x = event.motion.x; mouse.y = event.motion.y; if ((oldmouse_x != mouse.x) || (oldmouse_y != mouse.y)) { geometry.addPoint(mouse.x - offsetx, mouse.y - offsety); oldmouse_x = mouse.x; oldmouse_y = mouse.y; } break; case SDL_MOUSEBUTTONUP: mouse.b = 0; break; case SDL_QUIT: mouse.kill_sig = 1; break; default: break; } } while ((mouse.b != 0) && SDL_PollEvent(&event)); } //qDebug("Points: %d", (int) points.size()); SDL_FastBlit(behind, screen, 0, 0, 0, 0, screen->w, screen->h); SDL_FreeSurface(behind); if (lastFreehand == NULL) { strokeTimerID = SDL_AddTimer(strokeTimeout, freehand_timer_callback, NULL); lastFreehand = new Freehand(geometry); // Visibility graph stuff: visalgo->obj_add(lastFreehand); //QT canvas_deselect_shapes(); } else { SDL_RemoveTimer(strokeTimerID); strokeTimerID = SDL_AddTimer(strokeTimeout, freehand_timer_callback, NULL); lastFreehand->addStroke(geometry); visalgo->obj_resize(lastFreehand); } #if defined(__APPLE__) // After using carbon for mouse input, we need to resync the sdl mouse. GUI_DummyMouseEvent(); while(SDL_PollEvent(&event)); // noop; reset_mouse(); mouse.bstate = mouse.b = 0; #endif repaint_canvas(); }
void Viewer::mainloop() { Timer timer; Timer total; if (m_print_perf) fmt::print("Rendering frame {}\n", m_frame); m_scene_changed = false; m_frame++; int current_time = SDL_GetTicks(); double dt = (current_time - m_last_frame_time) / 1000.0; m_last_frame_time = current_time; auto fps = 1. / dt; // Input SDL_Event e; while (SDL_PollEvent(&e)) { if (e.type == SDL_QUIT) { shutdown(); } if (e.type == SDL_KEYDOWN) { if (e.key.keysym.sym == SDLK_ESCAPE) { shutdown(); } if (e.key.keysym.sym == SDLK_b) { m_debug = !m_debug; } if (e.key.keysym.sym == SDLK_n) { m_print_perf = !m_print_perf; } if (e.key.keysym.sym == SDLK_1) { m_stride_x = 1; m_stride_y = 1; m_scene_changed = true; } if (e.key.keysym.sym == SDLK_2) { m_stride_x = 2; m_stride_y = 2; m_scene_changed = true; } if (e.key.keysym.sym == SDLK_3) { m_stride_x = 4; m_stride_y = 4; m_scene_changed = true; } } if (e.type == SDL_MOUSEBUTTONDOWN) { if (e.button.button == SDL_BUTTON_RIGHT) { if (m_look_mode) { m_look_mode = false; SDL_SetRelativeMouseMode(SDL_FALSE); } else if (!m_look_mode) { m_look_mode = true; SDL_SetRelativeMouseMode(SDL_TRUE); } } } } float cam_speed = .8f * dt; // Left/right const uint8_t *keystates = SDL_GetKeyboardState(0); if (keystates[SDL_SCANCODE_A]) { m_scene_changed = true; Camera::set_pos(m_camera, Camera::pos(m_camera) - Camera::right(m_camera) * cam_speed); } else if (keystates[SDL_SCANCODE_D]) { Camera::set_pos(m_camera, Camera::pos(m_camera) + Camera::right(m_camera) * cam_speed); m_scene_changed = true; } // Up/down if (keystates[SDL_SCANCODE_SPACE]) { m_scene_changed = true; Camera::set_pos(m_camera, Camera::pos(m_camera) + glm::vec3{0, 1, 0} * cam_speed); } else if (keystates[SDL_SCANCODE_LCTRL]) { m_scene_changed = true; Camera::set_pos(m_camera, Camera::pos(m_camera) - glm::vec3{0, 1, 0} * cam_speed); } // Roll if (keystates[SDL_SCANCODE_Q]) { m_scene_changed = true; Camera::set_world_up(m_camera, glm::rotateZ(Camera::up(m_camera), 0.1f)); } else if (keystates[SDL_SCANCODE_E]) { m_scene_changed = true; Camera::set_world_up(m_camera, glm::rotateZ(Camera::up(m_camera), -0.1f)); } // Front/back if (keystates[SDL_SCANCODE_W]) { m_scene_changed = true; Camera::set_pos(m_camera, Camera::pos(m_camera) + Camera::dir(m_camera) * cam_speed); } else if (keystates[SDL_SCANCODE_S]) { m_scene_changed = true; Camera::set_pos(m_camera, Camera::pos(m_camera) - Camera::dir(m_camera) * cam_speed); } // Rendering here int width; int height; SDL_GetWindowSize(m_window, &width, &height); glm::ivec2 mouse_pos; if (m_look_mode) { // Yaw SDL_GetRelativeMouseState(&(mouse_pos.x), &(mouse_pos.y)); if (mouse_pos.x != 0) { m_scene_changed = true; Camera::set_dir(m_camera, glm::rotateY(Camera::dir(m_camera), mouse_pos.x * 0.001f)); } // Pitch if (mouse_pos.y != 0) { m_scene_changed = true; Camera::set_dir(m_camera, glm::rotate(Camera::dir(m_camera), mouse_pos.y * 0.001f, glm::cross(Camera::up(m_camera), Camera::dir(m_camera)))); } } else if (!m_look_mode) { SDL_GetMouseState(&(mouse_pos.x), &(mouse_pos.y)); } if (m_scene_changed) { m_samples_accumulated = 0; } if (m_print_perf) fmt::print(" {:<15} {:>10.3f} ms\n", "Input handling", timer.elapsed()); Scene::rebuild(m_scene); if (m_print_perf) fmt::print(" {:<15} {:=10.3f} ms\n", "Scene rebuild", timer.elapsed()); const auto luminance = m_renderer->render(m_scene_changed, m_stride_x, m_stride_y); if (m_print_perf) { m_renderer->print_last_frame_timings(); } m_samples_accumulated += 1; timer.reset(); // This striding is just for speeding up // We're basically drawing really big pixels here #pragma omp parallel for collapse(2) schedule(dynamic, 1024) for (auto x = 0; x < width; x += m_stride_x) { for (auto y = 0; y < height; y += m_stride_y) { glm::vec4 color = luminance[y * width + x] / static_cast<float>(m_samples_accumulated); for (auto u = 0; u < m_stride_x; u++) { for (auto v = 0; v < m_stride_y; v++) { m_pixels[(y + v) * width + (x + u)] = trac0r::pack_color_argb(color); } } } } if (m_print_perf) fmt::print(" {:<15} {:>10.3f} ms\n", "Pixel transfer", timer.elapsed()); // std::vector<uint32_t> m_pixels_filtered; // m_pixels_filtered.resize(m_screen_width * m_screen_height, 0); // trac0r::box_filter(m_pixels, width, height, m_pixels_filtered); // m_pixels = m_pixels_filtered; // // if (m_print_perf) // fmt::print(" {:<15} {:>10.3f} ms\n", "Image filtering", timer.elapsed()); SDL_RenderClear(m_render); SDL_UpdateTexture(m_render_tex, 0, m_pixels.data(), width * sizeof(uint32_t)); SDL_RenderCopy(m_render, m_render_tex, 0, 0); if (m_debug) { // Lots of debug info glm::vec2 mouse_rel_pos = Camera::screenspace_to_camspace(m_camera, mouse_pos.x, mouse_pos.y); glm::vec3 mouse_canvas_pos = Camera::camspace_to_worldspace(m_camera, mouse_rel_pos); auto fps_debug_info = "FPS: " + std::to_string(int(fps)); auto scene_changing_info = "Samples : " + std::to_string(m_samples_accumulated); scene_changing_info += " Scene Changing: " + std::to_string(m_scene_changed); auto cam_look_debug_info = "Cam Look Mode: " + std::to_string(m_look_mode); auto cam_pos_debug_info = "Cam Pos: " + glm::to_string(Camera::pos(m_camera)); auto cam_dir_debug_info = "Cam Dir: " + glm::to_string(Camera::dir(m_camera)); auto cam_up_debug_info = "Cam Up: " + glm::to_string(Camera::up(m_camera)); auto cam_fov_debug_info = "Cam FOV (H/V): " + std::to_string(int(glm::degrees(Camera::horizontal_fov(m_camera)))) + "/"; cam_fov_debug_info += std::to_string(int(glm::degrees(Camera::vertical_fov(m_camera)))); auto cam_canvas_center_pos_info = "Cam Canvas Center: " + glm::to_string(Camera::canvas_center_pos(m_camera)); auto mouse_pos_screen_info = "Mouse Pos Screen Space: " + glm::to_string(mouse_pos); auto mouse_pos_relative_info = "Mouse Pos Cam Space: " + glm::to_string(mouse_rel_pos); auto mouse_pos_canvas_info = "Mouse Pos Canvas World Space: " + glm::to_string(mouse_canvas_pos); auto fps_debug_tex = trac0r::make_text(m_render, m_font, fps_debug_info, {200, 100, 100, 200}); auto scene_changing_tex = trac0r::make_text(m_render, m_font, scene_changing_info, {200, 100, 100, 200}); auto cam_look_debug_tex = trac0r::make_text(m_render, m_font, cam_look_debug_info, {200, 100, 100, 200}); auto cam_pos_debug_tex = trac0r::make_text(m_render, m_font, cam_pos_debug_info, {200, 100, 100, 200}); auto cam_dir_debug_tex = trac0r::make_text(m_render, m_font, cam_dir_debug_info, {200, 100, 100, 200}); auto cam_up_debug_tex = trac0r::make_text(m_render, m_font, cam_up_debug_info, {200, 100, 100, 200}); auto cam_fov_debug_tex = trac0r::make_text(m_render, m_font, cam_fov_debug_info, {200, 100, 100, 200}); auto cam_canvas_center_pos_tex = trac0r::make_text(m_render, m_font, cam_canvas_center_pos_info, {200, 100, 100, 200}); auto mouse_pos_screen_tex = trac0r::make_text(m_render, m_font, mouse_pos_screen_info, {200, 100, 100, 200}); auto mouse_pos_relative_tex = trac0r::make_text(m_render, m_font, mouse_pos_relative_info, {200, 100, 100, 200}); auto mouse_pos_canvas_tex = trac0r::make_text(m_render, m_font, mouse_pos_canvas_info, {200, 100, 100, 200}); trac0r::render_text(m_render, fps_debug_tex, 10, 10); trac0r::render_text(m_render, scene_changing_tex, 10, 25); trac0r::render_text(m_render, cam_look_debug_tex, 10, 40); trac0r::render_text(m_render, cam_pos_debug_tex, 10, 55); trac0r::render_text(m_render, cam_dir_debug_tex, 10, 70); trac0r::render_text(m_render, cam_up_debug_tex, 10, 85); trac0r::render_text(m_render, cam_fov_debug_tex, 10, 100); trac0r::render_text(m_render, cam_canvas_center_pos_tex, 10, 115); trac0r::render_text(m_render, mouse_pos_screen_tex, 10, 130); trac0r::render_text(m_render, mouse_pos_relative_tex, 10, 145); trac0r::render_text(m_render, mouse_pos_canvas_tex, 10, 160); // Let's draw some debug to the display (such as AABBs) if (m_debug) { auto &accel_struct = Scene::accel_struct(m_scene); for (auto &shape : FlatStructure::shapes(accel_struct)) { auto &aabb = Shape::aabb(shape); const auto &verts = AABB::vertices(aabb); std::array<glm::i8vec2, 12> pairs; pairs[0] = {0, 1}; pairs[1] = {1, 3}; pairs[2] = {2, 3}; pairs[3] = {0, 2}; pairs[4] = {4, 5}; pairs[5] = {5, 7}; pairs[6] = {6, 7}; pairs[7] = {4, 6}; pairs[8] = {0, 4}; pairs[9] = {1, 5}; pairs[10] = {2, 6}; pairs[11] = {3, 7}; for (auto pair : pairs) { auto ws1 = Camera::worldpoint_to_worldspace(m_camera, verts[pair[0]]); auto ss1 = glm::i32vec2(0); if (ws1 != glm::vec3(0)) { auto cs1 = Camera::worldspace_to_camspace(m_camera, ws1); ss1 = Camera::camspace_to_screenspace(m_camera, cs1); } auto ws2 = Camera::worldpoint_to_worldspace(m_camera, verts[pair[1]]); auto ss2 = glm::i32vec2(0); if (ws2 != glm::vec3(0)) { auto cs2 = Camera::worldspace_to_camspace(m_camera, ws2); ss2 = Camera::camspace_to_screenspace(m_camera, cs2); } if (ss1 != glm::i32vec2(0) && ss2 != glm::i32vec2(0)) { aalineRGBA(m_render, ss1.x, ss1.y, ss2.x, ss2.y, 255, 255, 0, 200); } } } } SDL_DestroyTexture(fps_debug_tex); SDL_DestroyTexture(scene_changing_tex); SDL_DestroyTexture(cam_look_debug_tex); SDL_DestroyTexture(cam_pos_debug_tex); SDL_DestroyTexture(cam_dir_debug_tex); SDL_DestroyTexture(cam_up_debug_tex); SDL_DestroyTexture(cam_fov_debug_tex); SDL_DestroyTexture(cam_canvas_center_pos_tex); SDL_DestroyTexture(mouse_pos_screen_tex); SDL_DestroyTexture(mouse_pos_relative_tex); SDL_DestroyTexture(mouse_pos_canvas_tex); } SDL_RenderPresent(m_render); if (m_print_perf) { fmt::print(" {:<15} {:>10.3f} ms\n", "Rendering", timer.elapsed()); fmt::print(" {:<15} {:>10.3f} ms\n", "=> Budget", 1000.f / 60.f - total.peek()); fmt::print(" {:<15} {:>10.3f} ms\n\n", "=> Total", total.peek()); } m_frame_total += total.elapsed(); if (m_benchmark_mode < 0 && m_max_frames != 0 && m_frame > m_max_frames) { auto filename = std::string("trac0r-") + std::to_string(m_max_frames) + std::string(".bmp"); SDL_Surface *sshot = SDL_CreateRGBSurface(0, m_screen_width, m_screen_height, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000); SDL_RenderReadPixels(m_render, NULL, SDL_PIXELFORMAT_ARGB8888, sshot->pixels, sshot->pitch); SDL_SaveBMP(sshot, filename.c_str()); SDL_FreeSurface(sshot); shutdown(); } else if (m_benchmark_mode > 0 && m_max_frames != 0 && m_frame > m_max_frames) { fmt::print("Benchmark results:\n"); fmt::print(" {:<15} {:>10}\n", "Frames rendered", m_max_frames); fmt::print(" {:<15} {:>10.3f} ms\n", "Total runtime", m_frame_total); fmt::print(" {:<15} {:>10.3f} ms\n", "Avg. frame", m_frame_total / m_max_frames); fmt::print(" {:<15} {:>10.3f} FPS\n", "Avg. FPS", 1.f / ((m_frame_total / 1000.f) / m_max_frames)); shutdown(); } }