void TextControlInnerElement::attachInnerElement(Node* parent, PassRefPtr<RenderStyle> style, RenderArena* arena) { // When adding these elements, create the renderer & style first before adding to the DOM. // Otherwise, the render tree will create some anonymous blocks that will mess up our layout. // Create the renderer with the specified style RenderObject* renderer = createRenderer(arena, style.get()); if (renderer) { setRenderer(renderer); renderer->setStyle(style); } // Set these explicitly since this normally happens during an attach() setAttached(); setInDocument(); // For elements without a shadow parent, add the node to the DOM normally. if (!m_shadowParent) { // FIXME: This code seems very wrong. Why are we magically adding |this| to the DOM here? // We shouldn't be calling parser API methods outside of the parser! parent->deprecatedParserAddChild(this); } // Add the renderer to the render tree if (renderer) parent->renderer()->addChild(renderer); }
WindowManager::WindowManager(int window_height, int window_width) : m_window(nullptr) , m_renderer(nullptr) , m_window_id(0) , m_width(window_width) , m_height(window_height) , m_hint_vSync("0") // "0" or "1" Disabled or Enabled , m_hint_textureFilter("0") // "0" or "1", "2" for none or linear, bi-linear , m_hint_acceleration("1") // "0" or "1" Disabled or Enabled , m_is_active_window(false) { std::cout << "WindowManager Created!" << std::endl; static long position_placement = 0; m_position_placement = position_placement; ++position_placement; // Startup create the Window NOT Fullscreen. if(createWindow(false)) { std::cout << "Creating Window and Renderer!" << std::endl; // Set new Render Hints. createHints(); // Create the Renderer createRenderer(); } }
void FileSystemItem::markIsDefaultFolderCover(bool isDefault) { g_isDefaultFolderCover.insert(coverCacheKey(), new bool(isDefault)); m_useDefaultFolderCover = isDefault; // Re-create render here to refresh "m_useDefaultFolderCover" createRenderer(); }
void SDLWrapper::createWindow(const char *title, int w, int h, unsigned int flags) { mWindow = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, flags); if (mWindow == NULL) { sdlPrintError(); } createRenderer(); }
void BaseRenderer::swapRendererIfNeeded(BaseRenderer*& renderer) { if (renderer->getType() == g_currentType) return; delete renderer; renderer = createRenderer(); }
sp<IOMXRenderer> IOMX::createRenderer( const sp<Surface> &surface, const char *componentName, OMX_COLOR_FORMATTYPE colorFormat, size_t encodedWidth, size_t encodedHeight, size_t displayWidth, size_t displayHeight) { return createRenderer( surface->getISurface(), componentName, colorFormat, encodedWidth, encodedHeight, displayWidth, displayHeight); }
void LegacyCACFLayerTreeHost::paint() { createRenderer(); if (!m_d3dDevice) { if (m_mightBeAbleToCreateDeviceLater) renderSoon(); return; } CACFLayerTreeHost::paint(); }
int main(int argc, char *argv[]) { SDL_Window *wind; SDL_Renderer *rend; grad **gradients; SDL_Event end; int x,y,z; char filename[70]; int success = SUCCESS; srand(time(NULL)); wind = init(&success); rend = createRenderer(wind, &success); gradients = generateRandomGradients(); z = 0; while(success == SUCCESS) { srand(time(NULL)); for(x = 0; x < SCREEN_WIDTH - 2; x++) { for(y = 0; y < SCREEN_HEIGHT - 2; y++) { drawPlasma(x,y,gradients,rend); while(SDL_PollEvent(&end) != 0 ) { if(end.type == SDL_QUIT) { success = FAIL; break; } } } if(end.type == SDL_QUIT) { success = FAIL; break; } } SDL_RenderPresent(rend); free(gradients); gradients = generateRandomGradients(); sprintf(filename, "Output %d.bmp", z); saveToBitmap(filename, wind, rend); z++; } SDL_DestroyRenderer(rend); SDL_DestroyWindow(wind); free(gradients); SDL_Quit(); return 0; }
RiXBackend::RiXBackend( const char* renderer, const char* options ) { m_rixLib = util::DynamicLibrary::createFromFile(renderer); DP_ASSERT(m_rixLib); dp::rix::core::PFNCREATERENDERER createRenderer = (dp::rix::core::PFNCREATERENDERER)m_rixLib->getSymbol("createRenderer"); DP_ASSERT(createRenderer); m_rix = createRenderer( options ); DP_ASSERT(m_rix); }
FileSystemItem::FileSystemItem(const QString &path, AbstractRendererFactory *rendererFactory, QGraphicsItem *parent) : GalleryItem(rendererFactory, parent) , m_pathInfo(QFileInfo(path)) , m_coverImage(0) , m_useDefaultFolderCover(true) { setFlag(QGraphicsItem::ItemIsSelectable); setToolTip(m_pathInfo.fileName()); createRenderer(); }
PlayListGalleryItem::PlayListGalleryItem(PlayListRecord *record, AbstractRendererFactory *rendererFactory, QGraphicsItem *parent) : GalleryItem(rendererFactory, parent) , m_record(record) { setFlag(QGraphicsItem::ItemIsSelectable); setToolTip(m_record->name()); createRenderer(); connect(m_record, SIGNAL(saved()), this, SLOT(loadThumbnail())); }
void WCartesianChart::initLayout(const WRectF& rectangle) { WRectF rect = rectangle; if (rect.isEmpty()) rect = WRectF(0, 0, width().toPixels(), height().toPixels()); WPainter painter; WChart2DRenderer *renderer = createRenderer(painter, rect); renderer->initLayout(); delete renderer; }
int Engine::getReady() { if ((init()) or (createWindow(win_width, win_height)) or (createRenderer()) or (createBackground()) or (initializeImageSystem()) or (initializeAudioSystem()) or (initializeFontTTF())) { cout << "Something went wrong! I'm afraid we're going to crash, soldier!" << endl; return 1; } return 0; }
void Control::selectBoundary(int elem_id, int body1_id, int layer1_id, int body2_id, int layer2_id, bool accept_body_change, bool update_gui) { if (theRenderer == NULL) { createRenderer(theModel->getDimension()); } theRenderer->selectBoundary(elem_id, body1_id, layer1_id, body2_id, layer2_id, accept_body_change, update_gui); }
// Draw the whole model in the Renderer window void Control::displayModel() { if (theModel == NULL) { return; } if (theRenderer == NULL) { createRenderer(theModel->getDimension()); } theModel->setWindowTitles(); theRenderer->displayRenderer(); }
void WCartesianChart::paint(WPainter& painter, const WRectF& rectangle) const { if (!painter.isActive()) throw WException("WCartesianChart::paint(): painter is not active."); WRectF rect = rectangle; if (rect.isEmpty()) rect = painter.window(); WChart2DRenderer *renderer = createRenderer(painter, rect); renderer->render(); delete renderer; }
void Control::selectBoundaries(int nof_elems, int* elem_ids, int* body1_ids, int* layer1_ids, int* body2_ids, int* layer2_ids, bool accept_body_change, bool update_gui) { if (theRenderer == NULL) { createRenderer(theModel->getDimension()); } theRenderer->selectBoundaries(nof_elems, elem_ids, body1_ids, layer1_ids, body2_ids, layer2_ids, accept_body_change, update_gui); }
void NodeRendererFactory::createRendererIfNeeded() { Node* node = m_context.node(); Document* document = node->document(); if (!document->shouldCreateRenderers()) return; ASSERT(!node->renderer()); ASSERT(document->shouldCreateRenderers()); // FIXME: This side effect should be visible from attach() code. m_context.hostChildrenChanged(); if (!m_context.shouldCreateRenderer()) return; Element* element = node->isElementNode() ? toElement(node) : 0; if (element) m_context.setStyle(element->styleForRenderer()); else if (RenderObject* parentRenderer = m_context.parentRenderer()) m_context.setStyle(parentRenderer->style()); if (!node->rendererIsNeeded(m_context)) { if (element && m_context.style()->affectedByEmpty()) element->setStyleAffectedByEmpty(); return; } RenderObject* parentRenderer = m_context.hasFlowThreadParent() ? m_context.parentFlowRenderer() : m_context.parentRenderer(); // Do not call m_context.nextRenderer() here in the first clause, because it expects to have // the renderer added to its parent already. RenderObject* nextRenderer = m_context.hasFlowThreadParent() ? m_context.parentFlowRenderer()->nextRendererForNode(node) : m_context.nextRenderer(); RenderObject* newRenderer = createRenderer(); #if ENABLE(FULLSCREEN_API) if (document->webkitIsFullScreen() && document->webkitCurrentFullScreenElement() == node) newRenderer = RenderFullScreen::wrapRenderer(newRenderer, document); #endif if (!newRenderer) return; // Note: Adding newRenderer instead of renderer(). renderer() may be a child of newRenderer. parentRenderer->addChild(newRenderer, nextRenderer); }
void RenderTreeUpdater::updateElementRenderer(Element& element, const Style::ElementUpdate& update) { #if PLATFORM(IOS) CheckForVisibilityChange checkForVisibilityChange(element); #endif bool shouldTearDownRenderers = update.change == Style::Detach && (element.renderer() || element.isNamedFlowContentElement()); if (shouldTearDownRenderers) tearDownRenderers(element, TeardownType::KeepHoverAndActive); bool hasDisplayContents = update.style->display() == CONTENTS; if (hasDisplayContents != element.hasDisplayContents()) { element.setHasDisplayContents(hasDisplayContents); // Render tree position needs to be recomputed as rendering siblings may be found from the display:contents subtree. renderTreePosition().invalidateNextSibling(); } bool shouldCreateNewRenderer = !element.renderer() && !hasDisplayContents; if (shouldCreateNewRenderer) { if (element.hasCustomStyleResolveCallbacks()) element.willAttachRenderers(); createRenderer(element, RenderStyle::clone(*update.style)); invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(element); return; } if (!element.renderer()) return; auto& renderer = *element.renderer(); if (update.recompositeLayer) { renderer.setStyle(RenderStyle::clone(*update.style), StyleDifferenceRecompositeLayer); return; } if (update.change == Style::NoChange) { if (pseudoStyleCacheIsInvalid(&renderer, update.style.get())) { renderer.setStyle(RenderStyle::clone(*update.style), StyleDifferenceEqual); return; } return; } renderer.setStyle(RenderStyle::clone(*update.style), StyleDifferenceEqual); }
void SVGShadowTreeRootElement::attachElement(PassRefPtr<RenderStyle> style, RenderArena* arena) { ASSERT(shadowHost()); // Create the renderer with the specified style RenderObject* renderer = createRenderer(arena, style.get()); if (renderer) { setRenderer(renderer); renderer->setStyle(style); } // Set these explicitly since this normally happens during an attach() setAttached(); // Add the renderer to the render tree if (renderer) shadowHost()->renderer()->addChild(renderer); }
void PlayListGalleryItem::loadThumbnail() { if (!m_rendererFactory) { return; } QString coverFullPath = GlobalConfig::instance()->thumbnailPath() + "/" + m_record->coverPath(); QImage *thumbnail = new QImage(coverFullPath); if (thumbnail->isNull()) { thumbnail->load(":/res/playlist.png"); } setThumbnail(thumbnail); // Replace with new render since cover image has changed createRenderer(); }
void RenderTreeUpdater::updateElementRenderer(Element& element, Style::ElementUpdate& update) { bool shouldTearDownRenderers = update.change == Style::Detach && (element.renderer() || element.isNamedFlowContentNode()); if (shouldTearDownRenderers) tearDownRenderers(element, TeardownType::KeepHoverAndActive); bool hasDisplayContest = update.style && update.style->display() == CONTENTS; if (hasDisplayContest != element.hasDisplayContents()) { element.setHasDisplayContents(hasDisplayContest); // Render tree position needs to be recomputed as rendering siblings may be found from the display:contents subtree. renderTreePosition().invalidateNextSibling(); } bool shouldCreateNewRenderer = !element.renderer() && update.style && !hasDisplayContest; if (shouldCreateNewRenderer) { if (element.hasCustomStyleResolveCallbacks()) element.willAttachRenderers(); createRenderer(element, WTFMove(*update.style)); invalidateWhitespaceOnlyTextSiblingsAfterAttachIfNeeded(element); return; } if (!element.renderer()) return; auto& renderer = *element.renderer(); if (update.isSynthetic) { renderer.setStyle(WTFMove(*update.style), StyleDifferenceRecompositeLayer); return; } if (update.change == Style::NoChange) { if (pseudoStyleCacheIsInvalid(&renderer, update.style.get()) || (parent().styleChange == Style::Force && renderer.requiresForcedStyleRecalcPropagation())) { renderer.setStyle(WTFMove(*update.style), StyleDifferenceEqual); return; } return; } renderer.setStyle(WTFMove(*update.style), StyleDifferenceEqual); }
void WKCACFLayerRenderer::paint() { createRenderer(); if (!m_d3dDevice) { if (m_mightBeAbleToCreateDeviceLater) renderSoon(); return; } if (m_backingStoreDirty) { // If the backing store is still dirty when we are about to draw the // composited content, we need to force the window to paint into the // backing store. The paint will only paint the dirty region that // if being tracked in WebView. UpdateWindow(m_hostWindow); return; } Vector<CGRect> dirtyRects; getDirtyRects(m_hostWindow, dirtyRects); render(dirtyRects); }
void Renderinstance::initRenderer( const UsedRenderer usedrenderer, const Windowmode windowmode, const int windowwidth, const int windowheight, const bool interactive) { if (m_pRenderer!=0) return; m_Usedrenderer=usedrenderer; m_Windowmode=((usedrenderer==UsedRenderer_Opengl) && (windowmode==Window_None)) ? Window_Normal : windowmode; m_Windowwidth=windowwidth; m_Windowheight=windowheight; m_Interactive=interactive; if (usedrenderer==UsedRenderer_Opengl) { startThread(); } else { createRenderer(usedrenderer,windowwidth,windowheight); if (windowmode!=Window_None) startThread(); } }
sp<IOMXRenderer> IOMX::createRendererFromJavaSurface( JNIEnv *env, jobject javaSurface, const char *componentName, OMX_COLOR_FORMATTYPE colorFormat, size_t encodedWidth, size_t encodedHeight, size_t displayWidth, size_t displayHeight) { jclass surfaceClass = env->FindClass("android/view/Surface"); if (surfaceClass == NULL) { LOGE("Can't find android/view/Surface"); return NULL; } jfieldID surfaceID = env->GetFieldID(surfaceClass, "mSurface", "I"); if (surfaceID == NULL) { LOGE("Can't find Surface.mSurface"); return NULL; } sp<Surface> surface = (Surface *)env->GetIntField(javaSurface, surfaceID); return createRenderer( surface, componentName, colorFormat, encodedWidth, encodedHeight, displayWidth, displayHeight); }
void TextControlInnerElement::attachInnerElement(Node* parent, PassRefPtr<RenderStyle> style, RenderArena* arena) { // When adding these elements, create the renderer & style first before adding to the DOM. // Otherwise, the render tree will create some anonymous blocks that will mess up our layout. // Create the renderer with the specified style RenderObject* renderer = createRenderer(arena, style.get()); if (renderer) { setRenderer(renderer); renderer->setStyle(style); } // Set these explicitly since this normally happens during an attach() setAttached(); setInDocument(true); // For elements without a shadow parent, add the node to the DOM normally. if (!m_shadowParent) parent->addChild(this); // Add the renderer to the render tree if (renderer) parent->renderer()->addChild(renderer); }
int main(int, char**) { // Timing unsigned int lastUpdate; unsigned int thisUpdate; unsigned int dt = 0; // FPS int frames = 0; int fps = 0; int lastFPSUpdate; // Pixel buffer PixelBuffer pixelBuffer(width, height); // SDL structures SDL_Event event; SDL_Window* window; SDL_Renderer* renderer; SDL_Texture* renderTexture; // Seed random number generator srand((unsigned int)time(0)); // Initialise SDL SDL_Init(SDL_INIT_EVERYTHING); // Initilialise timing lastUpdate = thisUpdate = SDL_GetTicks(); lastFPSUpdate = lastUpdate; // Create window window = createWindow(TITLE_FORMAT, width, height); // Create renderer renderer = createRenderer(window); // Create render texture renderTexture = createTexture(renderer, width, height); // Set window values //int width = INITIAL_WIDTH; //int height = INITIAL_HEIGHT; // Create and initialise managers BallManager ballManager(width, height); // Create some balls ballManager.createBalls(INITIAL_BALLS); // Start main loop bool running = true; bool rendering_enabled = true; bool movement_enabled = true; while (running) { const SDL_Rect screenRect = {0, 0, width, height}; // Update timer thisUpdate = SDL_GetTicks(); dt = thisUpdate - lastUpdate; // Handle all events while (SDL_PollEvent(&event)) { // End when the user closes the window or presses esc if (event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.scancode == SDL_SCANCODE_ESCAPE)) { running = false; } // Handle keyboard input if (event.type == SDL_KEYDOWN) { // Toggle rendering when player presses R if (event.key.keysym.sym == SDLK_r) { // Disable rendering rendering_enabled = !rendering_enabled; // Clear screen to white pixelBuffer.clear(0xFFFFFFFF); // Update render texture SDL_UpdateTexture(renderTexture, &screenRect, pixelBuffer.getBuffer(), width * 4); // Render texture to screen SDL_RenderCopy(renderer, renderTexture, &screenRect, &screenRect); // Flip screen buffer SDL_RenderPresent(renderer); } // Toggle movement when player presses M else if (event.key.keysym.sym == SDLK_m) { movement_enabled = !movement_enabled; } // Add 10 balls when user presses right arrow else if (event.key.keysym.scancode == SDL_SCANCODE_RIGHT) { ballManager.createBalls(100); } // Remove 10 balls when user presses left arrow else if (event.key.keysym.scancode == SDL_SCANCODE_LEFT) { ballManager.destroyBalls(100); } } } // Update game float delta = dt*GAME_SPEED; if(movement_enabled) { process_collisions(width, height, ballManager.balls()); process_movement(delta, ballManager.balls()); process_gravity(delta, ballManager.balls()); } // Clear window SDL_RenderClear(renderer); if (rendering_enabled) { // Clear buffer pixelBuffer.clear(CLEAR_COLOUR); // Run rendering system process_rendering(&pixelBuffer, ballManager.balls()); // Blit buffer to screen renderer SDL_UpdateTexture(renderTexture, &screenRect, pixelBuffer.getBuffer(), width * 4); // Render texture to screen SDL_RenderCopy(renderer, renderTexture, &screenRect, &screenRect); // Flip screen buffer SDL_RenderPresent(renderer); } // Update last time lastUpdate = thisUpdate; // Average FPS calculations frames++; if (thisUpdate - lastFPSUpdate >= 1000) { // Update FPS counters fps = frames; frames = 0; lastFPSUpdate = thisUpdate; } // Update window title { const int titleBufferLen = 256; char titleBuffer[titleBufferLen]; // Format window title const char* renderingEnabled = (rendering_enabled ? "Enabled" : "Disabled"); const char* movementEnabled = (true ? "Enabled" : "Disabled"); snprintf(titleBuffer, titleBufferLen, TITLE_FORMAT, ballManager.ballCount(), fps, renderingEnabled, movementEnabled); // Set window title SDL_SetWindowTitle(window, titleBuffer); } } // Clean up SDL_DestroyRenderer(renderer); SDL_DestroyWindow(window); SDL_Quit(); return 0; }
///////////////////// //// Main Program int main(int argc, char *argv[]) { tParams params; if (!parseArgs(argc, argv, ¶ms)) { std::cerr << "Failed to parse command line arguments" << std::endl; std::cerr << g_usage << std::endl; return 1; } DBG(params); testPlatform(); DBG_T_START(g_timer, "** Starting point cloud conversion:\n"); /* instantiate the class that can convert the given file to point cloud */ CBasePointCloudRW *rw = g_pcrw_factory.getReaderWriter(params.ifilename); if (rw == NULL) { std::cerr << "The conversion from given file type to point cloud is not supported" << std::endl; return 1; } //rw->setSamplingStep(10e-4); rw->setSamplingStep(params.pc_sampling_step); /* convert to point cloud from a given file type */ CPointCloud pc; if (!rw->read(&pc)) { std::cerr << "Failed to convert the file \"" << params.ifilename << "\" to point cloud: " << rw->getErrorMsg() << std::endl; delete rw; return 1; } delete rw; DBG_T_END(g_timer, "** Point cloud conversion finished: "); std::cout << "Point cloud was loaded successfully" << std::endl; std::cout << "Total number of point sources that have to be rendered: " << pc.size() << std::endl; #ifdef HOLOREN_HEAVY_DEBUG DBG("Loaded point sources:"); DBG(pc); #endif /* set up renderer */ std::cout << "Setting up renderer" << std::endl; DBG_T_START(g_timer, "** Starting renderer setup:\n"); CBaseRenderer *p_ren = createRenderer(params); if (p_ren == NULL) { std::cerr << "Failed to create renderer. No rendering done." << std::endl; return 1; } COpticalField of(params.of_rows, params.of_cols, params.lambda, params.sampling); if (!p_ren->open(params.cl_source)) { std::cerr << "Failed to initialize " << renToStr(params.renderer) << " renderer" << std::endl; std::cerr << p_ren->getError() << std::endl; delete p_ren; return 1; } DBG_T_END(g_timer, "** Finished renderer setup: "); /* render the object wave from scene */ std::cout << "Rendering object wave" << std::endl; DBG_T_START(g_timer, "** Starting rendering:\n"); if (!p_ren->renderObjectWave(pc, &of)) { std::cerr << "Failed to render object wave: " << p_ren->getError() << std::endl; p_ren->close(); delete p_ren; return 1; } DBG_T_END(g_timer, "** Rendering finished: "); /* create a performance log before closing the renderer */ writePerfLog(params, pc, of, p_ren); p_ren->close(); delete p_ren; std::cout << "Point cloud rendered successfully" << std::endl; DBG_T_START(g_timer, "** Starting saving:\n"); /* try to guess the name of the output file if not given */ std::string out_file(params.ofilename); if (Utils::getFileName(out_file) == NULL) { const char *filename = Utils::getFileName(params.ifilename); HOLOREN_ASSERT(filename != NULL); out_file += filename; } /* save computed results */ if (!of.save(params.ofilename)) { std::cerr << "Failed to save the computed results" << std::endl; return 1; } DBG_T_END(g_timer, "** Saving finished: "); std::cout << "Point cloud saved successfully to \"" << params.ofilename << "\"" << std::endl; return 0; }
Renderer::Renderer(std::string name, int width, int height, Uint32 flags) { createRenderer(name, width, height, flags); }
Context::Context(void) { //Initialize SDL if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) { printf( "SDL could not initialize! SDL_Error: %s\n", SDL_GetError() ); } else { //Create window window = SDL_CreateWindow( "Pacman", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN ); if( window == NULL ) { printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() ); } else { //Update the surface SDL_UpdateWindowSurface( window ); } } //The surface contained by the window gScreenSurface = NULL; //The image we will load and show on the screen gHelloWorld = NULL; //Create window if( window == NULL ) { printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() ); } else { //Get window gScreenSurface = SDL_GetWindowSurface( window ); } gHelloWorld = SDL_LoadBMP( "picture/accueil.bmp" ); if( gHelloWorld == NULL ) { printf( "Unable to load image %s! SDL Error: %s\n", "02_getting_an_image_on_the_screen/hello_world.bmp", SDL_GetError() ); } SDL_BlitSurface( gHelloWorld, NULL, gScreenSurface, NULL ); SDL_UpdateWindowSurface( window ); audioEngine=new Audio(); audioEngine->playMenu(); SDL_Delay(3000); gHelloWorld = SDL_LoadBMP( "picture/control.bmp" ); if( gHelloWorld == NULL ) { printf( "Unable to load image %s! SDL Error: %s\n", "02_getting_an_image_on_the_screen/hello_world.bmp", SDL_GetError() ); } SDL_BlitSurface( gHelloWorld, NULL, gScreenSurface, NULL ); SDL_UpdateWindowSurface( window ); SDL_Delay(3000); audioEngine->playGunEffect(); SDL_Delay(500); createRenderer(); physicEngine=new Physic(); graphicEngine=new Graphic(window, gRenderer); audioEngine->start(1); map=new Map(gRenderer); Hero* test = new Hero("ghost", 0, 1, 1, "ghost1.bmp", 0); test->setPosX(0); test->setPosY(0); map->addEntity(test); Pacman* test2 = new Pacman("Pacman", 4, 1, 10, "pacman.bmp", 0); map->addEntity(test2); for(int i = 0; i < 7; i ++){ map->addEntity(new Mob("Pacman", 3, 1, 1, "junior.bmp", 0)); } for(int i = 0; i < 6; i++){ map->addEntity(new Mob("junior", 3, 1, 1, "junior.bmp", 0)); } }