Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2017 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "tools/viewer/SkottieSlide.h" |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 9 | |
Florin Malita | 3d856bd | 2018-05-26 09:49:28 -0400 | [diff] [blame] | 10 | #if defined(SK_ENABLE_SKOTTIE) |
| 11 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 12 | #include "include/core/SkCanvas.h" |
| 13 | #include "include/core/SkFont.h" |
Florin Malita | 15ee970 | 2019-12-10 14:23:32 -0500 | [diff] [blame] | 14 | #include "include/core/SkTime.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 15 | #include "modules/skottie/include/Skottie.h" |
Florin Malita | fbddfbb | 2020-05-06 15:55:18 -0400 | [diff] [blame] | 16 | #include "modules/skottie/utils/SkottieUtils.h" |
Brian Osman | 849f4d6 | 2019-11-26 08:58:26 -0500 | [diff] [blame] | 17 | #include "modules/skresources/include/SkResources.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 18 | #include "src/utils/SkOSPath.h" |
Hal Canary | 4124807 | 2019-07-11 16:32:53 -0400 | [diff] [blame] | 19 | #include "tools/timer/TimeUtils.h" |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 20 | |
Florin Malita | a33447d | 2018-05-29 13:46:54 -0400 | [diff] [blame] | 21 | #include <cmath> |
| 22 | |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 23 | #include "imgui.h" |
| 24 | |
Florin Malita | 40c3742 | 2018-08-22 20:37:04 -0400 | [diff] [blame] | 25 | static void draw_stats_box(SkCanvas* canvas, const skottie::Animation::Builder::Stats& stats) { |
Florin Malita | 6eb85a1 | 2018-04-30 10:32:18 -0400 | [diff] [blame] | 26 | static constexpr SkRect kR = { 10, 10, 280, 120 }; |
| 27 | static constexpr SkScalar kTextSize = 20; |
| 28 | |
| 29 | SkPaint paint; |
| 30 | paint.setAntiAlias(true); |
| 31 | paint.setColor(0xffeeeeee); |
Hal Canary | df2d27e | 2019-01-08 09:38:02 -0500 | [diff] [blame] | 32 | |
| 33 | SkFont font(nullptr, kTextSize); |
Florin Malita | 6eb85a1 | 2018-04-30 10:32:18 -0400 | [diff] [blame] | 34 | |
| 35 | canvas->drawRect(kR, paint); |
| 36 | |
| 37 | paint.setColor(SK_ColorBLACK); |
| 38 | |
Adlai Holler | 684838f | 2020-05-12 10:41:04 -0400 | [diff] [blame] | 39 | const auto json_size = SkStringPrintf("Json size: %zu bytes", |
Florin Malita | 6eb85a1 | 2018-04-30 10:32:18 -0400 | [diff] [blame] | 40 | stats.fJsonSize); |
Hal Canary | df2d27e | 2019-01-08 09:38:02 -0500 | [diff] [blame] | 41 | canvas->drawString(json_size, kR.x() + 10, kR.y() + kTextSize * 1, font, paint); |
Adlai Holler | 684838f | 2020-05-12 10:41:04 -0400 | [diff] [blame] | 42 | const auto animator_count = SkStringPrintf("Animator count: %zu", |
Florin Malita | 6eb85a1 | 2018-04-30 10:32:18 -0400 | [diff] [blame] | 43 | stats.fAnimatorCount); |
Hal Canary | df2d27e | 2019-01-08 09:38:02 -0500 | [diff] [blame] | 44 | canvas->drawString(animator_count, kR.x() + 10, kR.y() + kTextSize * 2, font, paint); |
Florin Malita | 6eb85a1 | 2018-04-30 10:32:18 -0400 | [diff] [blame] | 45 | const auto json_parse_time = SkStringPrintf("Json parse time: %.3f ms", |
| 46 | stats.fJsonParseTimeMS); |
Hal Canary | df2d27e | 2019-01-08 09:38:02 -0500 | [diff] [blame] | 47 | canvas->drawString(json_parse_time, kR.x() + 10, kR.y() + kTextSize * 3, font, paint); |
Florin Malita | 6eb85a1 | 2018-04-30 10:32:18 -0400 | [diff] [blame] | 48 | const auto scene_parse_time = SkStringPrintf("Scene build time: %.3f ms", |
| 49 | stats.fSceneParseTimeMS); |
Hal Canary | df2d27e | 2019-01-08 09:38:02 -0500 | [diff] [blame] | 50 | canvas->drawString(scene_parse_time, kR.x() + 10, kR.y() + kTextSize * 4, font, paint); |
Florin Malita | 6eb85a1 | 2018-04-30 10:32:18 -0400 | [diff] [blame] | 51 | const auto total_load_time = SkStringPrintf("Total load time: %.3f ms", |
| 52 | stats.fTotalLoadTimeMS); |
Hal Canary | df2d27e | 2019-01-08 09:38:02 -0500 | [diff] [blame] | 53 | canvas->drawString(total_load_time, kR.x() + 10, kR.y() + kTextSize * 5, font, paint); |
Florin Malita | 6eb85a1 | 2018-04-30 10:32:18 -0400 | [diff] [blame] | 54 | |
| 55 | paint.setStyle(SkPaint::kStroke_Style); |
| 56 | canvas->drawRect(kR, paint); |
| 57 | } |
| 58 | |
Florin Malita | 54f65c4 | 2018-01-16 17:04:30 -0500 | [diff] [blame] | 59 | SkottieSlide::SkottieSlide(const SkString& name, const SkString& path) |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 60 | : fPath(path) { |
| 61 | fName = name; |
| 62 | } |
| 63 | |
Florin Malita | c378fdc | 2018-02-09 11:15:32 -0500 | [diff] [blame] | 64 | void SkottieSlide::load(SkScalar w, SkScalar h) { |
Florin Malita | 57b9d40 | 2018-10-02 12:48:00 -0400 | [diff] [blame] | 65 | class Logger final : public skottie::Logger { |
| 66 | public: |
| 67 | struct LogEntry { |
| 68 | SkString fMessage, |
| 69 | fJSON; |
| 70 | }; |
| 71 | |
| 72 | void log(skottie::Logger::Level lvl, const char message[], const char json[]) override { |
| 73 | auto& log = lvl == skottie::Logger::Level::kError ? fErrors : fWarnings; |
| 74 | log.push_back({ SkString(message), json ? SkString(json) : SkString() }); |
| 75 | } |
| 76 | |
| 77 | void report() const { |
| 78 | SkDebugf("Animation loaded with %lu error%s, %lu warning%s.\n", |
| 79 | fErrors.size(), fErrors.size() == 1 ? "" : "s", |
| 80 | fWarnings.size(), fWarnings.size() == 1 ? "" : "s"); |
| 81 | |
| 82 | const auto& show = [](const LogEntry& log, const char prefix[]) { |
| 83 | SkDebugf("%s%s", prefix, log.fMessage.c_str()); |
| 84 | if (!log.fJSON.isEmpty()) |
| 85 | SkDebugf(" : %s", log.fJSON.c_str()); |
| 86 | SkDebugf("\n"); |
| 87 | }; |
| 88 | |
| 89 | for (const auto& err : fErrors) show(err, " !! "); |
| 90 | for (const auto& wrn : fWarnings) show(wrn, " ?? "); |
| 91 | } |
| 92 | |
| 93 | private: |
| 94 | std::vector<LogEntry> fErrors, |
| 95 | fWarnings; |
| 96 | }; |
| 97 | |
| 98 | auto logger = sk_make_sp<Logger>(); |
Florin Malita | 67ff541 | 2020-05-20 17:04:21 -0400 | [diff] [blame] | 99 | |
| 100 | uint32_t flags = 0; |
| 101 | if (fPreferGlyphPaths) { |
| 102 | flags |= skottie::Animation::Builder::kPreferEmbeddedFonts; |
| 103 | } |
| 104 | skottie::Animation::Builder builder(flags); |
Florin Malita | 57b9d40 | 2018-10-02 12:48:00 -0400 | [diff] [blame] | 105 | |
Florin Malita | fbddfbb | 2020-05-06 15:55:18 -0400 | [diff] [blame] | 106 | auto resource_provider = |
| 107 | skresources::DataURIResourceProviderProxy::Make( |
| 108 | skresources::FileResourceProvider::Make(SkOSPath::Dirname(fPath.c_str()), |
| 109 | /*predecode=*/true), |
| 110 | /*predecode=*/true); |
| 111 | |
| 112 | static constexpr char kInterceptPrefix[] = "__"; |
| 113 | auto precomp_interceptor = |
| 114 | sk_make_sp<skottie_utils::ExternalAnimationPrecompInterceptor>(resource_provider, |
| 115 | kInterceptPrefix); |
Florin Malita | a831655 | 2018-11-09 16:19:44 -0500 | [diff] [blame] | 116 | fAnimation = builder |
| 117 | .setLogger(logger) |
Florin Malita | fbddfbb | 2020-05-06 15:55:18 -0400 | [diff] [blame] | 118 | .setResourceProvider(std::move(resource_provider)) |
| 119 | .setPrecompInterceptor(std::move(precomp_interceptor)) |
Florin Malita | a831655 | 2018-11-09 16:19:44 -0500 | [diff] [blame] | 120 | .makeFromFile(fPath.c_str()); |
Florin Malita | 40c3742 | 2018-08-22 20:37:04 -0400 | [diff] [blame] | 121 | fAnimationStats = builder.getStats(); |
| 122 | fWinSize = SkSize::Make(w, h); |
| 123 | fTimeBase = 0; // force a time reset |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 124 | |
| 125 | if (fAnimation) { |
Florin Malita | 8703748 | 2019-12-09 11:09:38 -0500 | [diff] [blame] | 126 | fAnimation->seek(0); |
Florin Malita | 15ee970 | 2019-12-10 14:23:32 -0500 | [diff] [blame] | 127 | fFrameTimes.resize(SkScalarCeilToInt(fAnimation->duration() * fAnimation->fps())); |
Florin Malita | 57b9d40 | 2018-10-02 12:48:00 -0400 | [diff] [blame] | 128 | SkDebugf("Loaded Bodymovin animation v: %s, size: [%f %f]\n", |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 129 | fAnimation->version().c_str(), |
| 130 | fAnimation->size().width(), |
Florin Malita | 911ae40 | 2018-05-31 16:45:29 -0400 | [diff] [blame] | 131 | fAnimation->size().height()); |
Florin Malita | 57b9d40 | 2018-10-02 12:48:00 -0400 | [diff] [blame] | 132 | logger->report(); |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 133 | } else { |
| 134 | SkDebugf("failed to load Bodymovin animation: %s\n", fPath.c_str()); |
| 135 | } |
| 136 | } |
| 137 | |
Florin Malita | 54f65c4 | 2018-01-16 17:04:30 -0500 | [diff] [blame] | 138 | void SkottieSlide::unload() { |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 139 | fAnimation.reset(); |
| 140 | } |
| 141 | |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 142 | void SkottieSlide::resize(SkScalar w, SkScalar h) { |
| 143 | fWinSize = { w, h }; |
| 144 | } |
| 145 | |
Florin Malita | 54f65c4 | 2018-01-16 17:04:30 -0500 | [diff] [blame] | 146 | SkISize SkottieSlide::getDimensions() const { |
Florin Malita | c378fdc | 2018-02-09 11:15:32 -0500 | [diff] [blame] | 147 | // We always scale to fill the window. |
| 148 | return fWinSize.toCeil(); |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 149 | } |
| 150 | |
Florin Malita | 54f65c4 | 2018-01-16 17:04:30 -0500 | [diff] [blame] | 151 | void SkottieSlide::draw(SkCanvas* canvas) { |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 152 | if (fAnimation) { |
Florin Malita | aa4dc62 | 2018-01-02 14:37:37 -0500 | [diff] [blame] | 153 | SkAutoCanvasRestore acr(canvas, true); |
Florin Malita | c378fdc | 2018-02-09 11:15:32 -0500 | [diff] [blame] | 154 | const auto dstR = SkRect::MakeSize(fWinSize); |
Florin Malita | 15ee970 | 2019-12-10 14:23:32 -0500 | [diff] [blame] | 155 | |
| 156 | { |
| 157 | const auto t0 = SkTime::GetNSecs(); |
| 158 | fAnimation->render(canvas, &dstR); |
| 159 | |
| 160 | // TODO: this does not capture GPU flush time! |
Florin Malita | 1bb3a6d | 2019-12-11 08:55:46 -0500 | [diff] [blame] | 161 | const auto frame_index = static_cast<size_t>(fCurrentFrame); |
Florin Malita | 15ee970 | 2019-12-10 14:23:32 -0500 | [diff] [blame] | 162 | fFrameTimes[frame_index] = static_cast<float>((SkTime::GetNSecs() - t0) * 1e-6); |
| 163 | } |
Florin Malita | 6eb85a1 | 2018-04-30 10:32:18 -0400 | [diff] [blame] | 164 | |
| 165 | if (fShowAnimationStats) { |
| 166 | draw_stats_box(canvas, fAnimationStats); |
| 167 | } |
Florin Malita | 00d4f53 | 2019-07-22 12:05:41 -0400 | [diff] [blame] | 168 | if (fShowAnimationInval) { |
| 169 | const auto t = SkMatrix::MakeRectToRect(SkRect::MakeSize(fAnimation->size()), |
| 170 | dstR, |
| 171 | SkMatrix::kCenter_ScaleToFit); |
| 172 | SkPaint fill, stroke; |
| 173 | fill.setAntiAlias(true); |
| 174 | fill.setColor(0x40ff0000); |
| 175 | stroke.setAntiAlias(true); |
| 176 | stroke.setColor(0xffff0000); |
| 177 | stroke.setStyle(SkPaint::kStroke_Style); |
| 178 | |
| 179 | for (const auto& r : fInvalController) { |
| 180 | SkRect bounds; |
| 181 | t.mapRect(&bounds, r); |
| 182 | canvas->drawRect(bounds, fill); |
| 183 | canvas->drawRect(bounds, stroke); |
| 184 | } |
| 185 | } |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 186 | if (fShowUI) { |
| 187 | this->renderUI(); |
| 188 | } |
| 189 | |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 190 | } |
| 191 | } |
| 192 | |
Hal Canary | 4124807 | 2019-07-11 16:32:53 -0400 | [diff] [blame] | 193 | bool SkottieSlide::animate(double nanos) { |
Florin Malita | 1bb3a6d | 2019-12-11 08:55:46 -0500 | [diff] [blame] | 194 | if (!fTimeBase) { |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 195 | // Reset the animation time. |
Florin Malita | 1bb3a6d | 2019-12-11 08:55:46 -0500 | [diff] [blame] | 196 | fTimeBase = nanos; |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 197 | } |
| 198 | |
| 199 | if (fAnimation) { |
Florin Malita | 00d4f53 | 2019-07-22 12:05:41 -0400 | [diff] [blame] | 200 | fInvalController.reset(); |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 201 | |
Florin Malita | 1bb3a6d | 2019-12-11 08:55:46 -0500 | [diff] [blame] | 202 | const auto frame_count = fAnimation->duration() * fAnimation->fps(); |
| 203 | |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 204 | if (!fDraggingProgress) { |
| 205 | // Clock-driven progress: update current frame. |
Florin Malita | 1bb3a6d | 2019-12-11 08:55:46 -0500 | [diff] [blame] | 206 | const double t_sec = (nanos - fTimeBase) * 1e-9; |
| 207 | fCurrentFrame = std::fmod(t_sec * fAnimation->fps(), frame_count); |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 208 | } else { |
| 209 | // Slider-driven progress: update the time origin. |
Florin Malita | 1bb3a6d | 2019-12-11 08:55:46 -0500 | [diff] [blame] | 210 | fTimeBase = nanos - fCurrentFrame / fAnimation->fps() * 1e9; |
| 211 | } |
| 212 | |
| 213 | // Sanitize and rate-lock the current frame. |
| 214 | fCurrentFrame = SkTPin<float>(fCurrentFrame, 0.0f, frame_count - 1); |
| 215 | if (fFrameRate > 0) { |
| 216 | const auto fps_scale = fFrameRate / fAnimation->fps(); |
| 217 | fCurrentFrame = std::trunc(fCurrentFrame * fps_scale) / fps_scale; |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 218 | } |
| 219 | |
Florin Malita | 96d6c6f | 2020-07-29 10:51:28 -0400 | [diff] [blame^] | 220 | fAnimation->seekFrame(fCurrentFrame, fShowAnimationInval ? &fInvalController |
| 221 | : nullptr); |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 222 | } |
| 223 | return true; |
| 224 | } |
| 225 | |
Florin Malita | 54f65c4 | 2018-01-16 17:04:30 -0500 | [diff] [blame] | 226 | bool SkottieSlide::onChar(SkUnichar c) { |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 227 | switch (c) { |
| 228 | case 'I': |
Florin Malita | 6eb85a1 | 2018-04-30 10:32:18 -0400 | [diff] [blame] | 229 | fShowAnimationStats = !fShowAnimationStats; |
Florin Malita | 67ff541 | 2020-05-20 17:04:21 -0400 | [diff] [blame] | 230 | return true; |
| 231 | case 'G': |
| 232 | fPreferGlyphPaths = !fPreferGlyphPaths; |
| 233 | this->load(fWinSize.width(), fWinSize.height()); |
| 234 | return true; |
Florin Malita | 094ccde | 2017-12-30 12:27:00 -0500 | [diff] [blame] | 235 | } |
| 236 | |
| 237 | return INHERITED::onChar(c); |
| 238 | } |
Florin Malita | 60d3bfc | 2018-02-20 16:49:20 -0500 | [diff] [blame] | 239 | |
Hal Canary | b1f411a | 2019-08-29 10:39:22 -0400 | [diff] [blame] | 240 | bool SkottieSlide::onMouse(SkScalar x, SkScalar y, skui::InputState state, skui::ModifierKey) { |
Florin Malita | 60d3bfc | 2018-02-20 16:49:20 -0500 | [diff] [blame] | 241 | switch (state) { |
Hal Canary | b1f411a | 2019-08-29 10:39:22 -0400 | [diff] [blame] | 242 | case skui::InputState::kUp: |
Florin Malita | 60d3bfc | 2018-02-20 16:49:20 -0500 | [diff] [blame] | 243 | fShowAnimationInval = !fShowAnimationInval; |
Florin Malita | 6eb85a1 | 2018-04-30 10:32:18 -0400 | [diff] [blame] | 244 | fShowAnimationStats = !fShowAnimationStats; |
Florin Malita | 60d3bfc | 2018-02-20 16:49:20 -0500 | [diff] [blame] | 245 | break; |
| 246 | default: |
| 247 | break; |
| 248 | } |
| 249 | |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 250 | fShowUI = this->UIArea().contains(x, y); |
| 251 | |
Florin Malita | 83286a0 | 2018-02-21 13:03:41 -0500 | [diff] [blame] | 252 | return false; |
Florin Malita | 60d3bfc | 2018-02-20 16:49:20 -0500 | [diff] [blame] | 253 | } |
Florin Malita | 3d856bd | 2018-05-26 09:49:28 -0400 | [diff] [blame] | 254 | |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 255 | SkRect SkottieSlide::UIArea() const { |
Florin Malita | 1bb3a6d | 2019-12-11 08:55:46 -0500 | [diff] [blame] | 256 | static constexpr float kUIHeight = 120.0f; |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 257 | |
| 258 | return SkRect::MakeXYWH(0, fWinSize.height() - kUIHeight, fWinSize.width(), kUIHeight); |
| 259 | } |
| 260 | |
| 261 | void SkottieSlide::renderUI() { |
Florin Malita | 15ee970 | 2019-12-10 14:23:32 -0500 | [diff] [blame] | 262 | static constexpr auto kUI_opacity = 0.35f, |
Florin Malita | 1bb3a6d | 2019-12-11 08:55:46 -0500 | [diff] [blame] | 263 | kUI_hist_height = 50.0f, |
| 264 | kUI_fps_width = 100.0f; |
| 265 | |
| 266 | auto add_frame_rate_option = [this](const char* label, double rate) { |
| 267 | const auto is_selected = (fFrameRate == rate); |
| 268 | if (ImGui::Selectable(label, is_selected)) { |
| 269 | fFrameRate = rate; |
| 270 | fFrameRateLabel = label; |
| 271 | } |
| 272 | if (is_selected) { |
| 273 | ImGui::SetItemDefaultFocus(); |
| 274 | } |
| 275 | }; |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 276 | |
| 277 | ImGui::SetNextWindowBgAlpha(kUI_opacity); |
| 278 | if (ImGui::Begin("Skottie Controls", nullptr, ImGuiWindowFlags_NoDecoration | |
| 279 | ImGuiWindowFlags_NoResize | |
| 280 | ImGuiWindowFlags_NoMove | |
| 281 | ImGuiWindowFlags_NoSavedSettings | |
| 282 | ImGuiWindowFlags_NoFocusOnAppearing | |
| 283 | ImGuiWindowFlags_NoNav)) { |
| 284 | const auto ui_area = this->UIArea(); |
| 285 | ImGui::SetWindowPos(ImVec2(ui_area.x(), ui_area.y())); |
| 286 | ImGui::SetWindowSize(ImVec2(ui_area.width(), ui_area.height())); |
| 287 | |
| 288 | ImGui::PushItemWidth(-1); |
Florin Malita | 15ee970 | 2019-12-10 14:23:32 -0500 | [diff] [blame] | 289 | ImGui::PlotHistogram("", fFrameTimes.data(), fFrameTimes.size(), |
Florin Malita | 1bb3a6d | 2019-12-11 08:55:46 -0500 | [diff] [blame] | 290 | 0, nullptr, FLT_MAX, FLT_MAX, ImVec2(0, kUI_hist_height)); |
Florin Malita | 15ee970 | 2019-12-10 14:23:32 -0500 | [diff] [blame] | 291 | ImGui::SliderFloat("", &fCurrentFrame, 0, fAnimation->duration() * fAnimation->fps() - 1); |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 292 | fDraggingProgress = ImGui::IsItemActive(); |
Florin Malita | 1bb3a6d | 2019-12-11 08:55:46 -0500 | [diff] [blame] | 293 | ImGui::PopItemWidth(); |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 294 | |
Florin Malita | 1bb3a6d | 2019-12-11 08:55:46 -0500 | [diff] [blame] | 295 | ImGui::PushItemWidth(kUI_fps_width); |
| 296 | if (ImGui::BeginCombo("FPS", fFrameRateLabel)) { |
| 297 | add_frame_rate_option("", 0.0); |
| 298 | add_frame_rate_option("Native", fAnimation->fps()); |
| 299 | add_frame_rate_option( "1", 1.0); |
| 300 | add_frame_rate_option("15", 15.0); |
| 301 | add_frame_rate_option("24", 24.0); |
| 302 | add_frame_rate_option("30", 30.0); |
| 303 | add_frame_rate_option("60", 60.0); |
| 304 | ImGui::EndCombo(); |
| 305 | } |
Florin Malita | c4f6e02 | 2019-12-10 13:38:45 -0500 | [diff] [blame] | 306 | ImGui::PopItemWidth(); |
| 307 | } |
| 308 | ImGui::End(); |
| 309 | } |
| 310 | |
Florin Malita | 3d856bd | 2018-05-26 09:49:28 -0400 | [diff] [blame] | 311 | #endif // SK_ENABLE_SKOTTIE |