Peter M. Groen / dali-demo

Commit f638920616aff93ba6f8fb81ad5bb25390bd5889

Authored by David Steele
1 parent 14514f29

Added 2d physics benchmark 

First 30s, runs N balls using Animation & property notification that don't
interact,
Second 30s, runs N balls using 2D Physics and collisions.

N by default is 500, but can be changed on the command line.
FPS tracking is automatically switched on for this benchmark

(Also changed CMakeLists.txt to be able to work as a subdirectory
in a multi-repo build)

Change-Id: Iccee1d40650563e3f45e021b4fb3fff871cc393e
Inline Side-by-side
Showing 9 changed files with 438 additions and 2 deletions
build/tizen/CMakeLists.txt
  View file @f638920
... ... @@ -21,8 +21,8 @@ OPTION(ENABLE_TRACE "Enable Trace" OFF)
21 21 OPTION(ENABLE_PKG_CONFIGURE "Use pkgconfig" ON)
22 22 OPTION(INTERNATIONALIZATION "Internationalization demo string names" ON)
23 23  
24   -SET(ROOT_SRC_DIR ${CMAKE_SOURCE_DIR}/../..)
25   -SET(DEMO_SHARED ${CMAKE_SOURCE_DIR}/../../shared)
  24 +SET(ROOT_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../..)
  25 +SET(DEMO_SHARED ${CMAKE_CURRENT_SOURCE_DIR}/../../shared)
26 26  
27 27 SET(PREFIX ${CMAKE_INSTALL_PREFIX})
28 28  
... ...
com.samsung.dali-demo.xml
  View file @f638920
... ... @@ -43,6 +43,9 @@
43 43 <ui-application appid="benchmark.example" exec="/usr/apps/com.samsung.dali-demo/bin/benchmark.example" nodisplay="true" multiple="false" type="c++app" taskmanage="true">
44 44 <label>Benchmark</label>
45 45 </ui-application>
  46 + <ui-application appid="benchmark-2dphysics.example" exec="/usr/apps/com.samsung.dali-demo/bin/benchmark-2dphysics.example" nodisplay="true" multiple="false" type="c++app" taskmanage="true">
  47 + <label>Benchmark 2D Physics</label>
  48 + </ui-application>
46 49 <ui-application appid="bezier-curve.example" exec="/usr/apps/com.samsung.dali-demo/bin/bezier-curve.example" nodisplay="true" multiple="false" type="c++app" taskmanage="true">
47 50 <label>Alpha Function Curve</label>
48 51 </ui-application>
... ...
examples/benchmark-2dphysics/README.md 0 → 100644
  View file @f638920
  1 +# 2d Physics benchmark Example
  2 +
  3 +This is an example to test the performance of DALI with and without physics enabled.
  4 +It first measures performance with physics and collisions off, by animating motion using
  5 +property notifications for 30 seconds. Uses N ImageViews, where N defaults to 500
  6 +
  7 +Then, it creates a PhysicsAdaptor and uses zero gravity and a bounding box to achieve a
  8 +similar visual result with N ImageViews attached to physics bodies.
  9 +
  10 +N can be changed on the command line.
  11 +
  12 +
  13 +
... ...
examples/benchmark-2dphysics/benchmark-2d-physics-controller.cpp 0 → 100644
  View file @f638920
  1 +/*
  2 + * Copyright (c) 2023 Samsung Electronics Co., Ltd.
  3 + *
  4 + * Licensed under the Apache License, Version 2.0 (the "License");
  5 + * you may not use this file except in compliance with the License.
  6 + * You may obtain a copy of the License at
  7 + *
  8 + * http://www.apache.org/licenses/LICENSE-2.0
  9 + *
  10 + * Unless required by applicable law or agreed to in writing, software
  11 + * distributed under the License is distributed on an "AS IS" BASIS,
  12 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 + * See the License for the specific language governing permissions and
  14 + * limitations under the License.
  15 + */
  16 +
  17 +#include <dali-physics/dali-physics.h>
  18 +#include <dali-toolkit/dali-toolkit.h>
  19 +
  20 +#include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  21 +#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
  22 +#include <dali/devel-api/adaptor-framework/key-devel.h>
  23 +#include <dali/devel-api/events/hit-test-algorithm.h>
  24 +#include <dali/integration-api/debug.h>
  25 +
  26 +#include <chipmunk/chipmunk.h>
  27 +#include <cstdlib>
  28 +#include <iostream>
  29 +#include <string>
  30 +
  31 +using namespace Dali;
  32 +using namespace Dali::Toolkit::Physics;
  33 +using namespace Dali::ParentOrigin;
  34 +using namespace Dali::AnchorPoint;
  35 +
  36 +#if defined(DEBUG_ENABLED)
  37 +Debug::Filter* gPhysicsDemo = Debug::Filter::New(Debug::Concise, false, "LOG_PHYSICS_EXAMPLE");
  38 +#endif
  39 +
  40 +const float MAX_ANIMATION_DURATION{60.0f};
  41 +const uint32_t ANIMATION_TIME{30000};
  42 +const uint32_t DEFAULT_BALL_COUNT{500};
  43 +
  44 +#if defined(_ARCH_ARM_)
  45 +#define DEMO_ICON_DIR "/usr/share/icons"
  46 +#else
  47 +#define DEMO_ICON_DIR DEMO_IMAGE_DIR
  48 +#endif
  49 +
  50 +const std::string BALL_IMAGES[] = {DEMO_IMAGE_DIR "/blocks-ball.png",
  51 + DEMO_ICON_DIR "/dali-tests.png",
  52 + DEMO_ICON_DIR "/dali-examples.png",
  53 + DEMO_ICON_DIR "/com.samsung.dali-demo.png"};
  54 +
  55 +const Vector2 BALL_SIZE{26.0f, 26.0f};
  56 +
  57 +// Groups that can collide with each other:
  58 +const cpGroup BALL_GROUP{1 << 0};
  59 +const cpGroup BOUNDS_GROUP{1 << 1};
  60 +
  61 +const cpBitmask COLLISION_MASK{0xfF};
  62 +
  63 +const cpBitmask BALL_COLLIDES_WITH{BALL_GROUP | BOUNDS_GROUP};
  64 +
  65 +/**
  66 + * @brief The physics demo using Chipmunk2D APIs.
  67 + */
  68 +class Physics2dBenchmarkController : public ConnectionTracker
  69 +{
  70 +public:
  71 + Physics2dBenchmarkController(Application& app, int numberOfBalls)
  72 + : mApplication(app),
  73 + mBallNumber(numberOfBalls)
  74 + {
  75 + app.InitSignal().Connect(this, &Physics2dBenchmarkController::OnInit);
  76 + app.TerminateSignal().Connect(this, &Physics2dBenchmarkController::OnTerminate);
  77 + }
  78 +
  79 + ~Physics2dBenchmarkController() = default;
  80 +
  81 + void OnInit(Application& application)
  82 + {
  83 + mWindow = application.GetWindow();
  84 + mWindow.ResizeSignal().Connect(this, &Physics2dBenchmarkController::OnWindowResize);
  85 + mWindow.KeyEventSignal().Connect(this, &Physics2dBenchmarkController::OnKeyEv);
  86 + mWindow.GetRootLayer().TouchedSignal().Connect(this, &Physics2dBenchmarkController::OnTouched);
  87 + mWindow.SetBackgroundColor(Color::DARK_SLATE_GRAY);
  88 +
  89 + CreateAnimationSimulation();
  90 +
  91 + mTimer = Timer::New(ANIMATION_TIME);
  92 + mTimer.TickSignal().Connect(this, &Physics2dBenchmarkController::AnimationSimFinished);
  93 + mTimer.Start();
  94 + }
  95 +
  96 + void CreateAnimationSimulation()
  97 + {
  98 + Window::WindowSize windowSize = mWindow.GetSize();
  99 + mBallActors.resize(mBallNumber);
  100 + mBallVelocity.resize(mBallNumber);
  101 +
  102 + mAnimationSimRootActor = Layer::New();
  103 + mAnimationSimRootActor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
  104 + mAnimationSimRootActor[Actor::Property::PARENT_ORIGIN] = Dali::ParentOrigin::CENTER;
  105 + mAnimationSimRootActor[Actor::Property::ANCHOR_POINT] = Dali::AnchorPoint::CENTER;
  106 +
  107 + mWindow.Add(mAnimationSimRootActor);
  108 + std::ostringstream oss;
  109 + oss << "Animation simulation of " << mBallNumber << " balls";
  110 + auto title = Toolkit::TextLabel::New(oss.str());
  111 + mAnimationSimRootActor.Add(title);
  112 + title[Toolkit::TextLabel::Property::TEXT_COLOR] = Color::WHITE;
  113 + title[Actor::Property::PARENT_ORIGIN] = Dali::ParentOrigin::TOP_CENTER;
  114 + title[Actor::Property::ANCHOR_POINT] = Dali::AnchorPoint::TOP_CENTER;
  115 + title[Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT] = HorizontalAlignment::CENTER;
  116 + title.SetResizePolicy(ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS);
  117 +
  118 + const float margin(BALL_SIZE.width * 0.5f);
  119 +
  120 + for(int i = 0; i < mBallNumber; ++i)
  121 + {
  122 + Actor ball = mBallActors[i] = Toolkit::ImageView::New(BALL_IMAGES[rand() % 4]);
  123 + ball[Actor::Property::PARENT_ORIGIN] = Dali::ParentOrigin::CENTER;
  124 + ball[Actor::Property::ANCHOR_POINT] = Dali::AnchorPoint::CENTER;
  125 +
  126 + ball[Actor::Property::NAME] = "Ball";
  127 + ball[Actor::Property::SIZE] = BALL_SIZE; // Halve the image size
  128 + int width = windowSize.GetWidth() / 2;
  129 + int height = windowSize.GetHeight() / 2;
  130 + ball[Actor::Property::POSITION] = Vector3(Random::Range(margin - width, width - margin), Random::Range(margin - height, height - margin), 0.0f);
  131 + ball.RegisterProperty("index", i);
  132 + mAnimationSimRootActor.Add(ball);
  133 +
  134 + mBallVelocity[i] = Vector3(Random::Range(-25.0f, 25.0f), Random::Range(-25.0f, 25.0f), 0.0f);
  135 + mBallVelocity[i].Normalize();
  136 + mBallVelocity[i] = mBallVelocity[i] * Random::Range(15.0f, 50.0f);
  137 +
  138 + PropertyNotification leftNotify = mBallActors[i].AddPropertyNotification(Actor::Property::POSITION_X, LessThanCondition(margin - width));
  139 + leftNotify.NotifySignal().Connect(this, &Physics2dBenchmarkController::OnHitLeftWall);
  140 +
  141 + PropertyNotification rightNotify = mBallActors[i].AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(width - margin));
  142 + rightNotify.NotifySignal().Connect(this, &Physics2dBenchmarkController::OnHitRightWall);
  143 +
  144 + PropertyNotification topNotify = mBallActors[i].AddPropertyNotification(Actor::Property::POSITION_Y, LessThanCondition(margin - height));
  145 + topNotify.NotifySignal().Connect(this, &Physics2dBenchmarkController::OnHitTopWall);
  146 +
  147 + PropertyNotification bottomNotify = mBallActors[i].AddPropertyNotification(Actor::Property::POSITION_Y, GreaterThanCondition(height - margin));
  148 + bottomNotify.NotifySignal().Connect(this, &Physics2dBenchmarkController::OnHitBottomWall);
  149 + }
  150 +
  151 + title.RaiseToTop();
  152 + ContinueAnimation();
  153 + }
  154 +
  155 + bool AnimationSimFinished()
  156 + {
  157 + static bool first = true;
  158 + if(first)
  159 + {
  160 + UnparentAndReset(mAnimationSimRootActor);
  161 + mBallAnimation.Stop();
  162 + mBallAnimation.Clear();
  163 + first = false;
  164 +
  165 + CreatePhysicsSimulation();
  166 + return true;
  167 + }
  168 +
  169 + mApplication.Quit();
  170 + return false;
  171 + }
  172 +
  173 + void ContinueAnimation()
  174 + {
  175 + if(mBallAnimation)
  176 + {
  177 + mBallAnimation.Clear();
  178 + }
  179 + mBallAnimation = Animation::New(MAX_ANIMATION_DURATION);
  180 + for(int i = 0; i < mBallNumber; ++i)
  181 + {
  182 + mBallAnimation.AnimateBy(Property(mBallActors[i], Actor::Property::POSITION), mBallVelocity[i] * MAX_ANIMATION_DURATION);
  183 + }
  184 + mBallAnimation.Play();
  185 + }
  186 +
  187 + void OnHitLeftWall(PropertyNotification& source)
  188 + {
  189 + auto actor = Actor::DownCast(source.GetTarget());
  190 + if(actor)
  191 + {
  192 + int index = actor["index"];
  193 + mBallVelocity[index].x = fabsf(mBallVelocity[index].x);
  194 + ContinueAnimation();
  195 + }
  196 + }
  197 +
  198 + void OnHitRightWall(PropertyNotification& source)
  199 + {
  200 + auto actor = Actor::DownCast(source.GetTarget());
  201 + if(actor)
  202 + {
  203 + int index = actor["index"];
  204 + mBallVelocity[index].x = -fabsf(mBallVelocity[index].x);
  205 + ContinueAnimation();
  206 + }
  207 + }
  208 +
  209 + void OnHitBottomWall(PropertyNotification& source)
  210 + {
  211 + auto actor = Actor::DownCast(source.GetTarget());
  212 + if(actor)
  213 + {
  214 + int index = actor["index"];
  215 + mBallVelocity[index].y = -fabsf(mBallVelocity[index].y);
  216 + ContinueAnimation();
  217 + }
  218 + }
  219 +
  220 + void OnHitTopWall(PropertyNotification& source)
  221 + {
  222 + auto actor = Actor::DownCast(source.GetTarget());
  223 + if(actor)
  224 + {
  225 + int index = actor["index"];
  226 + mBallVelocity[index].y = fabsf(mBallVelocity[index].y);
  227 + ContinueAnimation();
  228 + }
  229 + }
  230 +
  231 + void CreatePhysicsSimulation()
  232 + {
  233 + Window::WindowSize windowSize = mWindow.GetSize();
  234 +
  235 + // Map Physics space (origin bottom left, +ve Y up)
  236 + // to DALi space (origin center, +ve Y down)
  237 + mPhysicsTransform.SetIdentityAndScale(Vector3(1.0f, -1.0f, 1.0f));
  238 + mPhysicsTransform.SetTranslation(Vector3(windowSize.GetWidth() * 0.5f,
  239 + windowSize.GetHeight() * 0.5f,
  240 + 0.0f));
  241 +
  242 + mPhysicsAdaptor = PhysicsAdaptor::New(mPhysicsTransform, windowSize);
  243 + mPhysicsRoot = mPhysicsAdaptor.GetRootActor();
  244 + mWindow.Add(mPhysicsRoot);
  245 +
  246 + auto scopedAccessor = mPhysicsAdaptor.GetPhysicsAccessor();
  247 + cpSpace* space = scopedAccessor->GetNative().Get<cpSpace*>();
  248 + cpSpaceSetGravity(space, cpv(0, 0));
  249 +
  250 + CreateBounds(space, windowSize);
  251 +
  252 + for(int i = 0; i < mBallNumber; ++i)
  253 + {
  254 + mBalls.push_back(CreateBall(space));
  255 + }
  256 +
  257 + // Process any async queued methods next frame
  258 + mPhysicsAdaptor.CreateSyncPoint();
  259 +
  260 + std::ostringstream oss;
  261 + oss << "Physics simulation of " << mBallNumber << " balls";
  262 + auto title = Toolkit::TextLabel::New(oss.str());
  263 + mPhysicsRoot.Add(title);
  264 + title[Toolkit::TextLabel::Property::TEXT_COLOR] = Color::WHITE;
  265 + title[Actor::Property::PARENT_ORIGIN] = Dali::ParentOrigin::TOP_CENTER;
  266 + title[Actor::Property::ANCHOR_POINT] = Dali::AnchorPoint::TOP_CENTER;
  267 + title[Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT] = HorizontalAlignment::CENTER;
  268 + title.SetResizePolicy(ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS);
  269 + title.RaiseToTop();
  270 + }
  271 +
  272 + PhysicsActor CreateBall(cpSpace* space)
  273 + {
  274 + const float BALL_MASS = 10.0f;
  275 + const float BALL_RADIUS = BALL_SIZE.x * 0.25f;
  276 + const float BALL_ELASTICITY = 1.0f;
  277 + const float BALL_FRICTION = 0.0f;
  278 +
  279 + auto ball = Toolkit::ImageView::New(BALL_IMAGES[rand() % 4]);
  280 + ball[Actor::Property::NAME] = "Ball";
  281 + ball[Actor::Property::SIZE] = BALL_SIZE * 0.5f;
  282 + cpBody* body = cpSpaceAddBody(space, cpBodyNew(BALL_MASS, cpMomentForCircle(BALL_MASS, 0.0f, BALL_RADIUS, cpvzero)));
  283 +
  284 + cpShape* shape = cpSpaceAddShape(space, cpCircleShapeNew(body, BALL_RADIUS, cpvzero));
  285 + cpShapeSetElasticity(shape, BALL_ELASTICITY);
  286 + cpShapeSetFriction(shape, BALL_FRICTION);
  287 +
  288 + PhysicsActor physicsBall = mPhysicsAdaptor.AddActorBody(ball, body);
  289 +
  290 + Window::WindowSize windowSize = mWindow.GetSize();
  291 +
  292 + const float fw = 0.5f * (windowSize.GetWidth() - BALL_RADIUS);
  293 + const float fh = 0.5f * (windowSize.GetHeight() - BALL_RADIUS);
  294 +
  295 + // Example of setting physics property on update thread
  296 + physicsBall.AsyncSetPhysicsPosition(Vector3(Random::Range(-fw, fw), Random::Range(-fh, -fh * 0.5), 0.0f));
  297 +
  298 + // Example of queuing a chipmunk method to run on the update thread
  299 + mPhysicsAdaptor.Queue([body]() {
  300 + cpBodySetVelocity(body, cpv(Random::Range(-100.0, 100.0), Random::Range(-100.0, 100.0)));
  301 + });
  302 + return physicsBall;
  303 + }
  304 +
  305 + void CreateBounds(cpSpace* space, Window::WindowSize size)
  306 + {
  307 + // We're working in physics space here - coords are: origin: bottom left, +ve Y: up
  308 + int32_t xBound = static_cast<int32_t>(static_cast<uint32_t>(size.GetWidth()));
  309 + int32_t yBound = static_cast<int32_t>(static_cast<uint32_t>(size.GetHeight()));
  310 +
  311 + cpBody* staticBody = cpSpaceGetStaticBody(space);
  312 +
  313 + if(mLeftBound)
  314 + {
  315 + cpSpaceRemoveShape(space, mLeftBound);
  316 + cpSpaceRemoveShape(space, mRightBound);
  317 + cpSpaceRemoveShape(space, mTopBound);
  318 + cpSpaceRemoveShape(space, mBottomBound);
  319 + cpShapeFree(mLeftBound);
  320 + cpShapeFree(mRightBound);
  321 + cpShapeFree(mTopBound);
  322 + cpShapeFree(mBottomBound);
  323 + }
  324 + mLeftBound = AddBound(space, staticBody, cpv(0, 0), cpv(0, yBound));
  325 + mRightBound = AddBound(space, staticBody, cpv(xBound, 0), cpv(xBound, yBound));
  326 + mTopBound = AddBound(space, staticBody, cpv(0, 0), cpv(xBound, 0));
  327 + mBottomBound = AddBound(space, staticBody, cpv(0, yBound), cpv(xBound, yBound));
  328 + }
  329 +
  330 + cpShape* AddBound(cpSpace* space, cpBody* staticBody, cpVect start, cpVect end)
  331 + {
  332 + cpShape* shape = cpSpaceAddShape(space, cpSegmentShapeNew(staticBody, start, end, 0.0f));
  333 + cpShapeSetElasticity(shape, 1.0f);
  334 + cpShapeSetFriction(shape, 1.0f);
  335 +
  336 + cpShapeSetFilter(shape, cpShapeFilterNew(BOUNDS_GROUP, COLLISION_MASK, COLLISION_MASK));
  337 + return shape;
  338 + }
  339 +
  340 + void OnTerminate(Application& application)
  341 + {
  342 + UnparentAndReset(mPhysicsRoot);
  343 + }
  344 +
  345 + void OnWindowResize(Window window, Window::WindowSize newSize)
  346 + {
  347 + auto scopedAccessor = mPhysicsAdaptor.GetPhysicsAccessor();
  348 + cpSpace* space = scopedAccessor->GetNative().Get<cpSpace*>();
  349 +
  350 + CreateBounds(space, newSize);
  351 + }
  352 +
  353 + bool OnTouched(Dali::Actor actor, const Dali::TouchEvent& touch)
  354 + {
  355 + mApplication.Quit();
  356 + return false;
  357 + }
  358 +
  359 + void OnKeyEv(const Dali::KeyEvent& event)
  360 + {
  361 + if(event.GetState() == KeyEvent::DOWN)
  362 + {
  363 + if(IsKey(event, Dali::DALI_KEY_ESCAPE) || IsKey(event, Dali::DALI_KEY_BACK))
  364 + {
  365 + mApplication.Quit();
  366 + }
  367 + }
  368 + }
  369 +
  370 +private:
  371 + Application& mApplication;
  372 + Window mWindow;
  373 +
  374 + PhysicsAdaptor mPhysicsAdaptor;
  375 + std::vector<PhysicsActor> mBalls;
  376 + Matrix mPhysicsTransform;
  377 + Actor mPhysicsRoot;
  378 + Layer mPhysicsDebugLayer;
  379 + Layer mAnimationSimRootActor;
  380 + cpShape* mLeftBound{nullptr};
  381 + cpShape* mRightBound{nullptr};
  382 + cpShape* mTopBound{nullptr};
  383 + cpShape* mBottomBound{nullptr};
  384 +
  385 + std::vector<Actor> mBallActors;
  386 + std::vector<Vector3> mBallVelocity;
  387 + int mBallNumber;
  388 + Animation mBallAnimation;
  389 + Timer mTimer;
  390 +};
  391 +
  392 +int DALI_EXPORT_API main(int argc, char** argv)
  393 +{
  394 + setenv("DALI_FPS_TRACKING", "5", 1);
  395 + Application application = Application::New(&argc, &argv);
  396 +
  397 + int numberOfBalls = DEFAULT_BALL_COUNT;
  398 + if(argc > 1)
  399 + {
  400 + numberOfBalls = atoi(argv[1]);
  401 + }
  402 +
  403 + Physics2dBenchmarkController controller(application, numberOfBalls);
  404 + application.MainLoop();
  405 + return 0;
  406 +}
... ...
examples/benchmark-2dphysics/dependencies.cmake 0 → 100644
  View file @f638920
  1 +TARGET_COMPILE_OPTIONS(${EXAMPLE}.example PUBLIC ${DALI_PHYSICS_2D_CFLAGS})
  2 +TARGET_LINK_LIBRARIES(${EXAMPLE}.example ${DALI_PHYSICS_2D_LDFLAGS})
  3 +MESSAGE(STATUS "Included dependencies for ${EXAMPLE}")
  4 +MESSAGE(STATUS " Compile options: ${DALI_PHYSICS_2D_CFLAGS}")
  5 +MESSAGE(STATUS " Link options: ${DALI_PHYSICS_2D_LDFLAGS}")
... ...
resources/po/en_GB.po
  View file @f638920
... ... @@ -16,6 +16,9 @@ msgstr &quot;Basic Light&quot;
16 16 msgid "DALI_DEMO_STR_TITLE_BENCHMARK"
17 17 msgstr "ImageView Benchmark"
18 18  
  19 +msgid "DALI_DEMO_STR_TITLE_BENCHMARK_2D_PHYSICS"
  20 +msgstr "2D Physics Benchmark"
  21 +
19 22 msgid "DALI_DEMO_STR_TITLE_BEZIER_CURVE"
20 23 msgstr "Bezier Curve"
21 24  
... ...
resources/po/en_US.po
  View file @f638920
... ... @@ -16,6 +16,9 @@ msgstr &quot;Basic Light&quot;
16 16 msgid "DALI_DEMO_STR_TITLE_BENCHMARK"
17 17 msgstr "ImageView Benchmark"
18 18  
  19 +msgid "DALI_DEMO_STR_TITLE_BENCHMARK_2D_PHYSICS"
  20 +msgstr "2D Physics Benchmark"
  21 +
19 22 msgid "DALI_DEMO_STR_TITLE_BEZIER_CURVE"
20 23 msgstr "Bezier Curve"
21 24  
... ...
shared/dali-demo-strings.h
  View file @f638920
... ... @@ -41,6 +41,7 @@ extern &quot;C&quot;
41 41 #define DALI_DEMO_STR_TITLE_ARC_VISUAL dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_ARC_VISUAL")
42 42 #define DALI_DEMO_STR_TITLE_BASIC_LIGHT dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_BASIC_LIGHT")
43 43 #define DALI_DEMO_STR_TITLE_BENCHMARK dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_BENCHMARK")
  44 +#define DALI_DEMO_STR_TITLE_BENCHMARK_2D_PHYSICS dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_BENCHMARK_2D_PHYSICS")
44 45 #define DALI_DEMO_STR_TITLE_BEZIER_CURVE dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_BEZIER_CURVE")
45 46 #define DALI_DEMO_STR_TITLE_BLOCKS dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_BLOCKS")
46 47 #define DALI_DEMO_STR_TITLE_BLOOM_VIEW dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_BLOOM_VIEW")
... ... @@ -163,6 +164,7 @@ extern &quot;C&quot;
163 164 #define DALI_DEMO_STR_TITLE_ARC_VISUAL "Arc Visual"
164 165 #define DALI_DEMO_STR_TITLE_BASIC_LIGHT "Basic Light"
165 166 #define DALI_DEMO_STR_TITLE_BENCHMARK "ImageView Benchmark"
  167 +#define DALI_DEMO_STR_TITLE_BENCHMARK_2D_PHYSICS "2D Physics Benchmark"
166 168 #define DALI_DEMO_STR_TITLE_BEZIER_CURVE "Alpha Function Bezier Curve"
167 169 #define DALI_DEMO_STR_TITLE_BLOCKS "Blocks"
168 170 #define DALI_DEMO_STR_TITLE_BLOOM_VIEW "Bloom"
... ...
tests-reel/dali-tests-reel.cpp
  View file @f638920
... ... @@ -38,6 +38,7 @@ int DALI_EXPORT_API main(int argc, char** argv)
38 38 DaliTableView demo(app);
39 39  
40 40 demo.AddExample(Example("benchmark.example", DALI_DEMO_STR_TITLE_BENCHMARK));
  41 + demo.AddExample(Example("benchmark-2dphysics.example", DALI_DEMO_STR_TITLE_BENCHMARK_2D_PHYSICS));
41 42 demo.AddExample(Example("camera-test.example", DALI_DEMO_STR_TITLE_CAMERA_TEST));
42 43 demo.AddExample(Example("compressed-texture-formats.example", DALI_DEMO_STR_TITLE_COMPRESSED_TEXTURE_FORMATS));
43 44 demo.AddExample(Example("homescreen-benchmark.example", DALI_DEMO_STR_TITLE_HOMESCREEN));
... ...