kc3-lang/angle/samples/sample_util/SampleApplication.cpp

• Show log

  Commit

• Hash : f83cbc65
  Author :
  Date : 2016-01-22T15:27:21
  

  Use std::random functions for test and samples RNG.
  
  These standard functions are much more powerful than the C random()
  routines. Use them to improve the random utils, and use a class
  to clean things up further.
  
  This fixes a problem I was having using random_utils where I was
  having trouble generating random 32 bit unsigned integers.
  
  BUG=angleproject:1290
  
  Change-Id: I5081764053d0667a4e323553b7dea531256aa778
  Reviewed-on: https://chromium-review.googlesource.com/323440
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Tryjob-Request: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Tested-by: Jamie Madill <jmadill@chromium.org>
  

Download

• samples/sample_util/SampleApplication.cpp

• //
  // Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  #include "SampleApplication.h"
  #include "EGLWindow.h"
  #include "random_utils.h"
  
  SampleApplication::SampleApplication(const std::string &name,
                                       size_t width,
                                       size_t height,
                                       EGLint glesMajorVersion,
                                       EGLint glesMinorVersion,
                                       EGLint requestedRenderer)
      : mName(name), mWidth(width), mHeight(height), mRunning(false)
  {
      mEGLWindow.reset(new EGLWindow(glesMajorVersion, glesMinorVersion,
                                     EGLPlatformParameters(requestedRenderer)));
      mTimer.reset(CreateTimer());
      mOSWindow.reset(CreateOSWindow());
  
      mEGLWindow->setConfigRedBits(8);
      mEGLWindow->setConfigGreenBits(8);
      mEGLWindow->setConfigBlueBits(8);
      mEGLWindow->setConfigAlphaBits(8);
      mEGLWindow->setConfigDepthBits(24);
      mEGLWindow->setConfigStencilBits(8);
  
      // Disable vsync
      mEGLWindow->setSwapInterval(0);
  }
  
  SampleApplication::~SampleApplication()
  {
  }
  
  bool SampleApplication::initialize()
  {
      return true;
  }
  
  void SampleApplication::destroy()
  {
  }
  
  void SampleApplication::step(float dt, double totalTime)
  {
  }
  
  void SampleApplication::draw()
  {
  }
  
  void SampleApplication::swap()
  {
      mEGLWindow->swap();
  }
  
  OSWindow *SampleApplication::getWindow() const
  {
      return mOSWindow.get();
  }
  
  EGLConfig SampleApplication::getConfig() const
  {
      return mEGLWindow->getConfig();
  }
  
  EGLDisplay SampleApplication::getDisplay() const
  {
      return mEGLWindow->getDisplay();
  }
  
  EGLSurface SampleApplication::getSurface() const
  {
      return mEGLWindow->getSurface();
  }
  
  EGLContext SampleApplication::getContext() const
  {
      return mEGLWindow->getContext();
  }
  
  int SampleApplication::run()
  {
      if (!mOSWindow->initialize(mName, mWidth, mHeight))
      {
          return -1;
      }
  
      mOSWindow->setVisible(true);
  
      if (!mEGLWindow->initializeGL(mOSWindow.get()))
      {
          return -1;
      }
  
      mRunning = true;
      int result = 0;
  
      if (!initialize())
      {
          mRunning = false;
          result = -1;
      }
  
      mTimer->start();
      double prevTime = 0.0;
  
      while (mRunning)
      {
          double elapsedTime = mTimer->getElapsedTime();
          double deltaTime = elapsedTime - prevTime;
  
          step(static_cast<float>(deltaTime), elapsedTime);
  
          // Clear events that the application did not process from this frame
          Event event;
          while (popEvent(&event))
          {
              // If the application did not catch a close event, close now
              if (event.Type == Event::EVENT_CLOSED)
              {
                  exit();
              }
          }
  
          if (!mRunning)
          {
              break;
          }
  
          draw();
          swap();
  
          mOSWindow->messageLoop();
  
          prevTime = elapsedTime;
      }
  
      destroy();
      mEGLWindow->destroyGL();
      mOSWindow->destroy();
  
      return result;
  }
  
  void SampleApplication::exit()
  {
      mRunning = false;
  }
  
  bool SampleApplication::popEvent(Event *event)
  {
      return mOSWindow->popEvent(event);
  }
  

Download