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));
}
}
