1430 lines
51 KiB
C++
1430 lines
51 KiB
C++
//----------------------------------------------------------------------------//
|
|
// //
|
|
// ozz-animation is hosted at http://github.com/guillaumeblanc/ozz-animation //
|
|
// and distributed under the MIT License (MIT). //
|
|
// //
|
|
// Copyright (c) Guillaume Blanc //
|
|
// //
|
|
// Permission is hereby granted, free of charge, to any person obtaining a //
|
|
// copy of this software and associated documentation files (the "Software"), //
|
|
// to deal in the Software without restriction, including without limitation //
|
|
// the rights to use, copy, modify, merge, publish, distribute, sublicense, //
|
|
// and/or sell copies of the Software, and to permit persons to whom the //
|
|
// Software is furnished to do so, subject to the following conditions: //
|
|
// //
|
|
// The above copyright notice and this permission notice shall be included in //
|
|
// all copies or substantial portions of the Software. //
|
|
// //
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR //
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, //
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL //
|
|
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER //
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING //
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER //
|
|
// DEALINGS IN THE SOFTWARE. //
|
|
// //
|
|
//----------------------------------------------------------------------------//
|
|
|
|
#define OZZ_INCLUDE_PRIVATE_HEADER // Allows to include private headers.
|
|
|
|
#include "imgui_impl.h"
|
|
|
|
#include <cassert>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
|
|
#include "ozz/base/maths/math_constant.h"
|
|
#include "ozz/base/maths/math_ex.h"
|
|
#include "ozz/base/memory/allocator.h"
|
|
|
|
#include "immediate.h"
|
|
#include "renderer_impl.h"
|
|
|
|
namespace ozz {
|
|
namespace sample {
|
|
namespace internal {
|
|
|
|
const GLubyte kPanelBackgroundColor[4] = {0x30, 0x30, 0x30, 0x80};
|
|
const GLubyte kPanelBorderColor[4] = {0x20, 0x20, 0x20, 0xff};
|
|
const GLubyte kPanelTitleColor[4] = {0x20, 0x20, 0x20, 0xf0};
|
|
const GLubyte kPanelTitleTextColor[4] = {0xa0, 0xa0, 0xa0, 0xff};
|
|
|
|
const GLubyte kWidgetBackgroundColor[4] = {0x20, 0x20, 0x20, 0xff};
|
|
const GLubyte kWidgetBorderColor[4] = {0x70, 0x70, 0x70, 0xff};
|
|
|
|
const GLubyte kWidgetDisabledBackgroundColor[4] = {0x30, 0x30, 0x30, 0xff};
|
|
const GLubyte kWidgetDisabledBorderColor[4] = {0x50, 0x50, 0x50, 0xff};
|
|
|
|
const GLubyte kWidgetHotBackgroundColor[4] = {0x40, 0x40, 0x40, 0xff};
|
|
const GLubyte kWidgetHotBorderColor[4] = {0xc7, 0x9a, 0x40, 0xff};
|
|
|
|
const GLubyte kWidgetActiveBackgroundColor[4] = {0xc7, 0x9a, 0x40, 0xff};
|
|
const GLubyte kWidgetActiveBorderColor[4] = {0x30, 0x30, 0x30, 0xff};
|
|
|
|
const GLubyte kWidgetTextColor[4] = {0xa0, 0xa0, 0xa0, 0xff};
|
|
const GLubyte kWidgetDisabledTextColor[4] = {0x60, 0x60, 0x60, 0xff};
|
|
|
|
const GLubyte kGraphBackgroundColor[4] = {0x20, 0x20, 0x20, 0xff};
|
|
const GLubyte kGraphPlotColor[4] = {0xc7, 0x9a, 0x40, 0xff};
|
|
|
|
const GLubyte kSliderBackgroundColor[4] = {0x20, 0x20, 0x20, 0xff};
|
|
const GLubyte kSliderCursorColor[4] = {0x70, 0x70, 0x70, 0xff};
|
|
const GLubyte kSliderCursorHotColor[4] = {0x80, 0x80, 0x80, 0xff};
|
|
const GLubyte kSliderDisabledCursorColor[4] = {0x70, 0x70, 0x70, 0xff};
|
|
|
|
const GLubyte kCursorColor[4] = {0xf0, 0xf0, 0xf0, 0xff};
|
|
const float kCursorSize = 16.f;
|
|
|
|
const float kGraphHeightFactor = 3.f;
|
|
const int kGraphLabelDigits = 5;
|
|
|
|
const float kTextMarginX = 2.f;
|
|
const float kWidgetRoundRectRadius = 2.f;
|
|
const float kWidgetCursorWidth = 8.f;
|
|
const float kWidgetHeight = 13.f;
|
|
const float kWidgetMarginX = 6.f;
|
|
const float kWidgetMarginY = 4.f;
|
|
const float kSliderRoundRectRadius = 1.f;
|
|
const float kButtonRoundRectRadius = 4.f;
|
|
const float kPanelRoundRectRadius = 1.f;
|
|
const float kPanelMarginX = 2.f;
|
|
const float kPanelTitleMarginY = 1.f;
|
|
|
|
// The radius of the precomputed circle.
|
|
const float kCircleRadius = 32.f;
|
|
|
|
bool FormatFloat(float _value, char* _string, const char* _string_end) {
|
|
// Requires 8 fixed characters count + digits of precision + \0.
|
|
static const int precision = 2;
|
|
if (!_string || _string_end - _string < 8 + precision + 1) {
|
|
return false;
|
|
}
|
|
std::sprintf(_string, "%.2g\n", _value);
|
|
|
|
// Removes unnecessary '0' digits in the exponent.
|
|
char* exponent = strchr(_string, 'e');
|
|
char* last_zero = strrchr(_string, '0');
|
|
if (exponent && last_zero > exponent) {
|
|
memmove(exponent + 2, // After exponent and exponent's sign.
|
|
last_zero + 1, // From the first character after the exponent.
|
|
strlen(last_zero + 1) + 1); // The remaining characters count.
|
|
}
|
|
return true;
|
|
}
|
|
|
|
ImGuiImpl::ImGuiImpl()
|
|
: hot_item_(0),
|
|
active_item_(0),
|
|
auto_gen_id_(0),
|
|
glyph_texture_(0),
|
|
renderer_(nullptr) {
|
|
InitializeCircle();
|
|
InitalizeFont();
|
|
}
|
|
|
|
ImGuiImpl::~ImGuiImpl() { DestroyFont(); }
|
|
|
|
void ImGuiImpl::BeginFrame(const Inputs& _inputs, const math::RectInt& _rect,
|
|
RendererImpl* _renderer) {
|
|
if (!containers_.empty()) {
|
|
return;
|
|
}
|
|
|
|
// Stores renderer
|
|
renderer_ = _renderer;
|
|
|
|
// Store inputs.
|
|
inputs_ = _inputs;
|
|
|
|
// Sets no widget to hot for the current frame.
|
|
hot_item_ = 0;
|
|
|
|
// Regenerates widgets ids from scratch.
|
|
auto_gen_id_ = 0;
|
|
|
|
// Reset container stack info.
|
|
const math::RectFloat rect(
|
|
static_cast<float>(_rect.left), static_cast<float>(_rect.bottom),
|
|
static_cast<float>(_rect.width), static_cast<float>(_rect.height));
|
|
Container container = {rect, rect.height - kWidgetHeight, false};
|
|
containers_.push_back(container);
|
|
|
|
// Setup GL context in order to render layered the widgets.
|
|
GL(Clear(GL_DEPTH_BUFFER_BIT));
|
|
|
|
// Enables blending
|
|
GL(Enable(GL_BLEND));
|
|
GL(BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
|
|
}
|
|
|
|
void ImGuiImpl::EndFrame() {
|
|
// Pops the frame container.
|
|
containers_.pop_back();
|
|
|
|
if (inputs_.lmb_pressed == false) {
|
|
// Clear the active item if the mouse isn't down.
|
|
active_item_ = 0;
|
|
} else {
|
|
// If the mouse is clicked, but no widget is active, we need to mark the
|
|
// active item unavailable so that we won't activate the next widget we drag
|
|
// the cursor onto.
|
|
if (active_item_ == 0) {
|
|
active_item_ = -1;
|
|
}
|
|
}
|
|
|
|
// Renders mouse cursor.
|
|
{
|
|
GlImmediatePC im(renderer_->immediate_renderer(), GL_LINE_LOOP,
|
|
ozz::math::Float4x4::identity());
|
|
GlImmediatePC::Vertex v = {
|
|
{0.f, 0.f, 0.f},
|
|
{kCursorColor[0], kCursorColor[1], kCursorColor[2], kCursorColor[3]}};
|
|
|
|
v.pos[0] = static_cast<float>(inputs_.mouse_x);
|
|
v.pos[1] = static_cast<float>(inputs_.mouse_y);
|
|
im.PushVertex(v);
|
|
v.pos[0] = static_cast<float>(inputs_.mouse_x) + kCursorSize;
|
|
v.pos[1] = static_cast<float>(inputs_.mouse_y) - kCursorSize / 2.f;
|
|
im.PushVertex(v);
|
|
v.pos[0] = static_cast<float>(inputs_.mouse_x) + kCursorSize / 2.f;
|
|
v.pos[1] = static_cast<float>(inputs_.mouse_y) - kCursorSize / 2.f;
|
|
im.PushVertex(v);
|
|
v.pos[0] = static_cast<float>(inputs_.mouse_x) + kCursorSize / 2.f;
|
|
v.pos[1] = static_cast<float>(inputs_.mouse_y) - kCursorSize;
|
|
im.PushVertex(v);
|
|
}
|
|
|
|
// Restores blending
|
|
GL(Disable(GL_BLEND));
|
|
|
|
// Release renderer.
|
|
renderer_ = nullptr;
|
|
}
|
|
|
|
bool ImGuiImpl::AddWidget(float _height, math::RectFloat* _rect) {
|
|
if (containers_.empty()) {
|
|
return false;
|
|
}
|
|
|
|
// Get current container.
|
|
Container& container = containers_.back();
|
|
|
|
// Early out if outside of the container.
|
|
// But don't modify current container's state.
|
|
if (container.offset_y < kWidgetMarginY + _height) {
|
|
return false;
|
|
}
|
|
|
|
// Computes widget rect and update internal offset in the container.
|
|
container.offset_y -= _height;
|
|
|
|
_rect->left = container.rect.left + kWidgetMarginX;
|
|
_rect->bottom = container.rect.bottom + container.offset_y;
|
|
_rect->width = container.rect.width - kWidgetMarginX * 2.f;
|
|
_rect->height = _height;
|
|
|
|
// Includes margin for the next widget.
|
|
container.offset_y -= kWidgetMarginY;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ImGuiImpl::ButtonLogic(const math::RectFloat& _rect, int _id, bool* _hot,
|
|
bool* _active) {
|
|
// Checks whether the button should be hot.
|
|
if (_rect.is_inside(static_cast<float>(inputs_.mouse_x),
|
|
static_cast<float>(inputs_.mouse_y))) {
|
|
// Becomes hot if no other item is active.
|
|
hot_item_ = active_item_ <= 0 || active_item_ == _id ? _id : 0;
|
|
|
|
// If the mouse button is down and no other widget is active,
|
|
// then this one becomes active.
|
|
if (active_item_ == 0 && inputs_.lmb_pressed) {
|
|
active_item_ = _id;
|
|
}
|
|
}
|
|
|
|
// Update button state.
|
|
const bool hot = hot_item_ == _id;
|
|
*_hot = hot;
|
|
const bool active = active_item_ == _id;
|
|
*_active = active;
|
|
|
|
// Finally checks if the button has been triggered. If button is hot and
|
|
// active, but mouse button is not down, the user must have clicked the
|
|
// button.
|
|
return !inputs_.lmb_pressed && hot && active;
|
|
}
|
|
|
|
void ImGuiImpl::BeginContainer(const char* _title, const math::RectFloat* _rect,
|
|
bool* _open, bool _constrain) {
|
|
if (containers_.empty()) {
|
|
return;
|
|
}
|
|
|
|
// Adds the new container to the stack.
|
|
containers_.resize(containers_.size() + 1);
|
|
const Container& parent = containers_[containers_.size() - 2];
|
|
Container& container = containers_[containers_.size() - 1];
|
|
|
|
// Does the container have a header to render ?
|
|
const bool header = _title || _open;
|
|
const float header_height = header ? kWidgetHeight + kPanelTitleMarginY : 0.f;
|
|
|
|
if (_rect) {
|
|
// Crops _rect in parent's rect.
|
|
container.rect.left = parent.rect.left + _rect->left;
|
|
container.rect.bottom = parent.rect.bottom + _rect->bottom;
|
|
container.rect.width = math::Max(
|
|
0.f, math::Min(parent.rect.width - _rect->left, _rect->width));
|
|
container.rect.height = math::Max(
|
|
0.f, math::Min(parent.rect.height - _rect->bottom, _rect->height));
|
|
} else {
|
|
// Concatenate to the parent's rect.
|
|
container.rect.left = parent.rect.left + kPanelMarginX;
|
|
container.rect.bottom = parent.rect.bottom;
|
|
container.rect.width =
|
|
math::Max(0.f, parent.rect.width - kPanelMarginX * 2.f);
|
|
container.rect.height = parent.offset_y;
|
|
}
|
|
|
|
// Shrinks rect if the container is closed.
|
|
if (_open && !*_open) {
|
|
const float closed_height = header_height;
|
|
container.rect.bottom = container.rect.top() - closed_height;
|
|
container.rect.height = closed_height;
|
|
}
|
|
|
|
container.offset_y = container.rect.height;
|
|
container.constrain = _constrain;
|
|
|
|
// Early out if there's not enough space for a container.
|
|
// Includes top panel margins.
|
|
if (container.offset_y < header_height) {
|
|
container.offset_y = 0;
|
|
return;
|
|
}
|
|
|
|
// Early out if there's no container title.
|
|
if (!header) {
|
|
// Adds margin before the new widget.
|
|
container.offset_y -= kWidgetMarginY;
|
|
return;
|
|
}
|
|
|
|
++auto_gen_id_;
|
|
|
|
// Inserts header.
|
|
container.offset_y -= header_height;
|
|
|
|
const math::RectFloat title_rect(container.rect.left,
|
|
container.rect.bottom + container.offset_y,
|
|
container.rect.width, header_height);
|
|
|
|
// Don't display any arrow if _open is nullptr.
|
|
const float arrow_size = _open != nullptr ? kWidgetHeight : 0;
|
|
const math::RectFloat open_close_rect(title_rect.left, title_rect.bottom,
|
|
arrow_size, kWidgetHeight);
|
|
|
|
const math::RectFloat label_rect(
|
|
title_rect.left + arrow_size + kTextMarginX, title_rect.bottom,
|
|
title_rect.width - arrow_size - kTextMarginX, kWidgetHeight);
|
|
|
|
// Adds a margin before the next widget only if it is opened.
|
|
if (!_open || *_open) {
|
|
container.offset_y -= kWidgetMarginY;
|
|
}
|
|
|
|
// Renders title background.
|
|
FillRect(title_rect, kPanelRoundRectRadius, kPanelTitleColor);
|
|
if (_title) {
|
|
Print(_title, label_rect, kWest, kPanelTitleTextColor);
|
|
}
|
|
|
|
// Handles open close button.
|
|
bool hot = false, active = false;
|
|
if (_open) {
|
|
if (ButtonLogic(title_rect, auto_gen_id_, &hot, &active)) {
|
|
// Swap open/close state if button was clicked.
|
|
*_open = !*_open;
|
|
}
|
|
|
|
// Renders arrow.
|
|
{
|
|
GlImmediatePC im(renderer_->immediate_renderer(), GL_TRIANGLES,
|
|
ozz::math::Float4x4::identity());
|
|
GlImmediatePC::Vertex v = {
|
|
{0.f, 0.f, 0.f},
|
|
{kPanelTitleTextColor[0], kPanelTitleTextColor[1],
|
|
kPanelTitleTextColor[2], kPanelTitleTextColor[3]}};
|
|
|
|
if (*_open) {
|
|
v.pos[0] = open_close_rect.left + 3.f;
|
|
v.pos[1] = open_close_rect.bottom + 3.f;
|
|
im.PushVertex(v);
|
|
v.pos[0] = open_close_rect.left + 11.f;
|
|
v.pos[1] = open_close_rect.bottom + 7.f;
|
|
im.PushVertex(v);
|
|
v.pos[0] = open_close_rect.left + 3.f;
|
|
v.pos[1] = open_close_rect.bottom + 11.f;
|
|
im.PushVertex(v);
|
|
} else {
|
|
v.pos[0] = open_close_rect.left + 3.f;
|
|
v.pos[1] = open_close_rect.bottom + 11.f;
|
|
im.PushVertex(v);
|
|
v.pos[0] = open_close_rect.left + 7.f;
|
|
v.pos[1] = open_close_rect.bottom + 3.f;
|
|
im.PushVertex(v);
|
|
v.pos[0] = open_close_rect.left + 11.f;
|
|
v.pos[1] = open_close_rect.bottom + 11.f;
|
|
im.PushVertex(v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ImGuiImpl::EndContainer() {
|
|
// Get current container. Copy it as it's going to be remove from the vector.
|
|
Container container = containers_.back();
|
|
containers_.pop_back();
|
|
Container& parent = containers_.back();
|
|
|
|
// Shrinks container rect.
|
|
if (container.constrain) {
|
|
float final_height =
|
|
math::Max(0.f, container.rect.height - container.offset_y);
|
|
container.rect.bottom += container.offset_y;
|
|
container.rect.height = final_height;
|
|
}
|
|
|
|
// Renders container background.
|
|
if (container.rect.height > 0.f) {
|
|
const ozz::math::SimdFloat4 translation =
|
|
ozz::math::simd_float4::Load(0.f, 0.f, -.1f, 0.f);
|
|
const ozz::math::Float4x4 transform =
|
|
ozz::math::Float4x4::Translation(translation);
|
|
FillRect(container.rect, kPanelRoundRectRadius, kPanelBackgroundColor,
|
|
transform);
|
|
StrokeRect(container.rect, kPanelRoundRectRadius, kPanelBorderColor);
|
|
}
|
|
|
|
// Applies changes to the parent container.
|
|
parent.offset_y -= container.rect.height + kWidgetMarginY;
|
|
}
|
|
|
|
bool ImGuiImpl::DoButton(const char* _label, bool _enabled, bool* _state) {
|
|
math::RectFloat rect;
|
|
if (!AddWidget(kWidgetHeight, &rect)) {
|
|
return false;
|
|
}
|
|
|
|
++auto_gen_id_;
|
|
|
|
// Do button logic.
|
|
bool hot = false, active = false, clicked = false;
|
|
if (_enabled) {
|
|
clicked = ButtonLogic(rect, auto_gen_id_, &hot, &active);
|
|
}
|
|
|
|
// Changes state if it was clicked.
|
|
if (_state) {
|
|
if (clicked) {
|
|
*_state = !*_state;
|
|
}
|
|
active |= *_state; // Considered active if state is true.
|
|
}
|
|
|
|
// Renders the button.
|
|
const GLubyte* background_color = kWidgetBackgroundColor;
|
|
const GLubyte* border_color = kWidgetBorderColor;
|
|
const GLubyte* text_color = kWidgetTextColor;
|
|
|
|
float active_offset = 0.f;
|
|
if (!_enabled) {
|
|
background_color = kWidgetDisabledBackgroundColor;
|
|
border_color = kWidgetDisabledBorderColor;
|
|
text_color = kWidgetDisabledTextColor;
|
|
} else if (active) { // Button is 'active'.
|
|
background_color = kWidgetActiveBackgroundColor;
|
|
border_color = kWidgetActiveBorderColor;
|
|
active_offset = 1.f;
|
|
} else if (hot) { // Hot but not 'active'.
|
|
// Button is merely 'hot'.
|
|
background_color = kWidgetHotBackgroundColor;
|
|
border_color = kWidgetHotBorderColor;
|
|
} else {
|
|
// button is not hot, but it may be active. Use default colors.
|
|
}
|
|
|
|
FillRect(rect, kButtonRoundRectRadius, background_color);
|
|
StrokeRect(rect, kButtonRoundRectRadius, border_color);
|
|
|
|
// Renders button label.
|
|
const math::RectFloat text_rect(
|
|
rect.left + kButtonRoundRectRadius, rect.bottom - active_offset,
|
|
rect.width - kButtonRoundRectRadius * 2.f, rect.height - active_offset);
|
|
Print(_label, text_rect, kMiddle, text_color);
|
|
|
|
return clicked;
|
|
}
|
|
|
|
bool ImGuiImpl::DoCheckBox(const char* _label, bool* _state, bool _enabled) {
|
|
math::RectFloat widget_rect;
|
|
if (!AddWidget(kWidgetHeight, &widget_rect)) {
|
|
return false;
|
|
}
|
|
|
|
math::RectFloat check_rect(widget_rect.left, widget_rect.bottom,
|
|
kWidgetHeight, // The check box is square.
|
|
widget_rect.height);
|
|
|
|
++auto_gen_id_;
|
|
|
|
// Do button logic.
|
|
bool hot = false, active = false, clicked = false;
|
|
if (_enabled) {
|
|
clicked = ButtonLogic(widget_rect, auto_gen_id_, &hot, &active);
|
|
}
|
|
|
|
// Changes check box state if it was clicked.
|
|
if (clicked) {
|
|
*_state = !*_state;
|
|
}
|
|
|
|
// Renders the check box.
|
|
const GLubyte* background_color = kWidgetBackgroundColor;
|
|
const GLubyte* border_color = kWidgetBorderColor;
|
|
const GLubyte* check_color = kWidgetTextColor;
|
|
const GLubyte* text_color = kWidgetTextColor;
|
|
|
|
if (!_enabled) {
|
|
background_color = kWidgetDisabledBackgroundColor;
|
|
border_color = kWidgetDisabledBorderColor;
|
|
check_color = kWidgetDisabledBorderColor;
|
|
text_color = kWidgetDisabledTextColor;
|
|
} else if (hot) {
|
|
if (active) {
|
|
// Button is both 'hot' and 'active'.
|
|
background_color = kWidgetActiveBackgroundColor;
|
|
border_color = kWidgetActiveBorderColor;
|
|
check_color = kWidgetActiveBorderColor;
|
|
} else {
|
|
// Button is merely 'hot'.
|
|
background_color = kWidgetHotBackgroundColor;
|
|
border_color = kWidgetHotBorderColor;
|
|
check_color = kWidgetHotBorderColor;
|
|
}
|
|
} else {
|
|
// button is not hot, but it may be active. Use default colors.
|
|
}
|
|
|
|
FillRect(check_rect, 0, background_color);
|
|
StrokeRect(check_rect, 0, border_color);
|
|
|
|
// Renders the "check" mark.
|
|
if (*_state) {
|
|
GlImmediatePC im(renderer_->immediate_renderer(), GL_TRIANGLES,
|
|
ozz::math::Float4x4::identity());
|
|
GlImmediatePC::Vertex v = {
|
|
{0.f, 0.f, 0.f},
|
|
{check_color[0], check_color[1], check_color[2], check_color[3]}};
|
|
v.pos[0] = check_rect.left + check_rect.width / 8.f;
|
|
v.pos[1] = check_rect.bottom + check_rect.height / 2.f;
|
|
im.PushVertex(v);
|
|
v.pos[0] = check_rect.left + check_rect.width / 2.f;
|
|
v.pos[1] = check_rect.bottom + check_rect.height / 8.f;
|
|
im.PushVertex(v);
|
|
v.pos[0] = check_rect.left + check_rect.width / 2.f;
|
|
v.pos[1] = check_rect.bottom + check_rect.height / 2.f;
|
|
im.PushVertex(v);
|
|
|
|
v.pos[0] = check_rect.left + check_rect.width / 3.f;
|
|
v.pos[1] = check_rect.bottom + check_rect.height / 2.f;
|
|
im.PushVertex(v);
|
|
v.pos[0] = check_rect.left + check_rect.width / 2.f;
|
|
v.pos[1] = check_rect.bottom + check_rect.height / 8.f;
|
|
im.PushVertex(v);
|
|
v.pos[0] = check_rect.right() - check_rect.width / 6.f;
|
|
v.pos[1] = check_rect.top() - check_rect.height / 6.f;
|
|
im.PushVertex(v);
|
|
}
|
|
|
|
// Renders button label.
|
|
const math::RectFloat text_rect(
|
|
check_rect.right() + kTextMarginX, widget_rect.bottom,
|
|
widget_rect.width - check_rect.width - kTextMarginX, widget_rect.height);
|
|
Print(_label, text_rect, kWest, text_color);
|
|
|
|
return clicked;
|
|
}
|
|
|
|
bool ImGuiImpl::DoRadioButton(int _ref, const char* _label, int* _value,
|
|
bool _enabled) {
|
|
math::RectFloat widget_rect;
|
|
if (!AddWidget(kWidgetHeight, &widget_rect)) {
|
|
return false;
|
|
}
|
|
|
|
math::RectFloat radio_rect(widget_rect.left, widget_rect.bottom,
|
|
kWidgetHeight, // The check box is square.
|
|
widget_rect.height);
|
|
|
|
++auto_gen_id_;
|
|
|
|
// Do button logic.
|
|
bool hot = false, active = false, clicked = false;
|
|
if (_enabled) {
|
|
clicked = ButtonLogic(widget_rect, auto_gen_id_, &hot, &active);
|
|
}
|
|
|
|
// Changes check box state if it was clicked.
|
|
if (clicked) {
|
|
*_value = _ref;
|
|
}
|
|
|
|
// Renders the check box.
|
|
const GLubyte* background_color = kWidgetBackgroundColor;
|
|
const GLubyte* border_color = kWidgetBorderColor;
|
|
const GLubyte* check_color = kWidgetBorderColor;
|
|
const GLubyte* text_color = kWidgetTextColor;
|
|
|
|
if (!_enabled) {
|
|
background_color = kWidgetDisabledBackgroundColor;
|
|
border_color = kWidgetDisabledBorderColor;
|
|
check_color = kWidgetDisabledBorderColor;
|
|
text_color = kWidgetDisabledBackgroundColor;
|
|
} else if (hot) {
|
|
if (active) {
|
|
// Button is both 'hot' and 'active'.
|
|
background_color = kWidgetActiveBackgroundColor;
|
|
border_color = kWidgetActiveBorderColor;
|
|
check_color = kWidgetActiveBorderColor;
|
|
} else {
|
|
// Button is merely 'hot'.
|
|
background_color = kWidgetHotBackgroundColor;
|
|
border_color = kWidgetHotBorderColor;
|
|
check_color = kWidgetHotBorderColor;
|
|
}
|
|
} else {
|
|
// button is not hot, but it may be active. Use default colors.
|
|
}
|
|
|
|
FillRect(radio_rect, kWidgetRoundRectRadius, background_color);
|
|
StrokeRect(radio_rect, kWidgetRoundRectRadius, border_color);
|
|
|
|
// Renders the "checked" button.
|
|
if (*_value == _ref) {
|
|
const math::RectFloat checked_rect(
|
|
radio_rect.left + 1.f, radio_rect.bottom + 1.f, radio_rect.width - 3.f,
|
|
radio_rect.height - 3.f);
|
|
FillRect(checked_rect, kWidgetRoundRectRadius, check_color);
|
|
}
|
|
|
|
// Renders button label.
|
|
const math::RectFloat text_rect(
|
|
radio_rect.right() + kTextMarginX, widget_rect.bottom,
|
|
widget_rect.width - radio_rect.width - kTextMarginX, widget_rect.height);
|
|
Print(_label, text_rect, kWest, text_color);
|
|
|
|
return clicked;
|
|
}
|
|
|
|
namespace {
|
|
float FindMax(float _value) {
|
|
if (_value == 0.f) {
|
|
return 0.f;
|
|
}
|
|
const float mexp = floor(log10(_value));
|
|
const float mpow = pow(10.f, mexp);
|
|
return ceil(_value / mpow) * 1.5f * mpow;
|
|
}
|
|
} // namespace
|
|
|
|
void ImGuiImpl::DoGraph(const char* _label, float _min, float _max, float _mean,
|
|
const float* _value_cursor, const float* _value_begin,
|
|
const float* _value_end) {
|
|
// Computes widget rect.
|
|
math::RectFloat widget_rect;
|
|
const float label_height =
|
|
_label ? (kWidgetMarginY + font_.glyph_height) : 0.f;
|
|
const float height = kWidgetHeight * kGraphHeightFactor + label_height;
|
|
if (!AddWidget(height, &widget_rect)) {
|
|
return;
|
|
}
|
|
|
|
const float label_width =
|
|
static_cast<float>(kGraphLabelDigits * font_.glyph_width);
|
|
|
|
const math::RectFloat graph_rect(
|
|
widget_rect.left, widget_rect.bottom,
|
|
widget_rect.width - label_width - kTextMarginX,
|
|
kWidgetHeight * kGraphHeightFactor);
|
|
|
|
// Renders background and borders.
|
|
FillRect(graph_rect, 0, kGraphBackgroundColor);
|
|
StrokeRect(graph_rect, 0, kWidgetBorderColor);
|
|
|
|
// Render labels.
|
|
char sz[16];
|
|
const char* sz_end = sz + OZZ_ARRAY_SIZE(sz);
|
|
const math::RectFloat max_rect(
|
|
widget_rect.left, graph_rect.top() - font_.glyph_height,
|
|
widget_rect.width, static_cast<float>(font_.glyph_height));
|
|
if (FormatFloat(_max, sz, sz_end)) {
|
|
Print(sz, max_rect, kEst, kWidgetTextColor);
|
|
}
|
|
|
|
const math::RectFloat mean_rect(
|
|
widget_rect.left,
|
|
graph_rect.bottom + graph_rect.height / 2.f - font_.glyph_height / 2.f,
|
|
widget_rect.width, static_cast<float>(font_.glyph_height));
|
|
if (FormatFloat(_mean, sz, sz_end)) {
|
|
Print(sz, mean_rect, kEst, kWidgetTextColor);
|
|
}
|
|
|
|
const math::RectFloat min_rect(widget_rect.left, graph_rect.bottom,
|
|
widget_rect.width,
|
|
static_cast<float>(font_.glyph_height));
|
|
if (FormatFloat(_min, sz, sz_end)) {
|
|
Print(sz, min_rect, kEst, kWidgetTextColor);
|
|
}
|
|
|
|
// Prints title on the left.
|
|
if (_label) {
|
|
const math::RectFloat label_rect(
|
|
widget_rect.left, widget_rect.top() - font_.glyph_height,
|
|
widget_rect.width, static_cast<float>(font_.glyph_height));
|
|
Print(_label, label_rect, kNorthWest, kWidgetTextColor);
|
|
}
|
|
|
|
// Renders the graph.
|
|
if (_value_end - _value_begin >= 2) { // Reject invalid or to small inputs.
|
|
const float abscissa_min = graph_rect.bottom + 1.f;
|
|
const float abscissa_max = graph_rect.top() - 1.f;
|
|
// Computes a new max value, rounded up to be more stable.
|
|
const float graph_max = FindMax(_max);
|
|
const float abscissa_scale =
|
|
(abscissa_max - abscissa_min) / (graph_max - _min);
|
|
const float abscissa_begin = graph_rect.bottom + 1.f;
|
|
const float ordinate_inc =
|
|
-(graph_rect.width - 2.f) / (_value_end - _value_begin - 1.f);
|
|
float ordinate_current = graph_rect.right() - 1.f;
|
|
|
|
GlImmediatePC im(renderer_->immediate_renderer(), GL_LINE_STRIP,
|
|
ozz::math::Float4x4::identity());
|
|
GlImmediatePC::Vertex v = {{0.f, 0.f, 0.f},
|
|
{kGraphPlotColor[0], kGraphPlotColor[1],
|
|
kGraphPlotColor[2], kGraphPlotColor[3]}};
|
|
|
|
const float* current = _value_cursor;
|
|
const float* end = _value_end;
|
|
while (current < end) {
|
|
const float abscissa =
|
|
abscissa_begin + abscissa_scale * (*current - _min);
|
|
const float clamped_abscissa =
|
|
math::Clamp(abscissa_min, abscissa, abscissa_max);
|
|
|
|
v.pos[0] = ordinate_current;
|
|
v.pos[1] = clamped_abscissa;
|
|
im.PushVertex(v);
|
|
ordinate_current += ordinate_inc;
|
|
|
|
++current;
|
|
if (current == _value_end) { // Looping...
|
|
end = _value_cursor;
|
|
current = _value_begin;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ImGuiImpl::DoSlider(const char* _label, float _min, float _max,
|
|
float* _value, float _pow, bool _enabled) {
|
|
math::RectFloat rect;
|
|
if (!AddWidget(kWidgetHeight, &rect)) {
|
|
return false;
|
|
}
|
|
|
|
auto_gen_id_++;
|
|
|
|
// Calculate mouse cursor's relative y offset.
|
|
const float initial_value = *_value;
|
|
const float clamped_value = ozz::math::Clamp(_min, initial_value, _max);
|
|
|
|
// Check for hotness.
|
|
bool hot = false, active = false;
|
|
if (_enabled) {
|
|
// Includes the cursor size in the pick region.
|
|
math::RectFloat pick_rect = rect;
|
|
pick_rect.left -= kWidgetCursorWidth / 2.f;
|
|
pick_rect.width += kWidgetCursorWidth;
|
|
ButtonLogic(pick_rect, auto_gen_id_, &hot, &active);
|
|
|
|
// A slider is active on lmb pressed, not released. It's different to the
|
|
// usual button behavior.
|
|
active &= inputs_.lmb_pressed;
|
|
}
|
|
|
|
// Render the scrollbar
|
|
const GLubyte* background_color = kSliderBackgroundColor;
|
|
const GLubyte* border_color = kWidgetBorderColor;
|
|
const GLubyte* slider_color = kSliderCursorColor;
|
|
const GLubyte* slider_border_color = kWidgetBorderColor;
|
|
const GLubyte* text_color = kWidgetTextColor;
|
|
|
|
if (!_enabled) {
|
|
background_color = kWidgetDisabledBackgroundColor;
|
|
border_color = kWidgetDisabledBorderColor;
|
|
slider_color = kSliderDisabledCursorColor;
|
|
slider_border_color = kWidgetDisabledBorderColor;
|
|
text_color = kWidgetDisabledTextColor;
|
|
} else if (hot) {
|
|
if (active) {
|
|
// Button is both 'hot' and 'active'.
|
|
slider_color = kWidgetActiveBackgroundColor;
|
|
slider_border_color = kWidgetActiveBorderColor;
|
|
} else {
|
|
// Button is merely 'hot'.
|
|
slider_color = kSliderCursorHotColor;
|
|
slider_border_color = kWidgetHotBorderColor;
|
|
}
|
|
} else {
|
|
// button is not hot, but it may be active. Use default colors.
|
|
}
|
|
|
|
// Update widget value.
|
|
const float pow_min = powf(_min, _pow);
|
|
const float pow_max = powf(_max, _pow);
|
|
float pow_value = powf(clamped_value, _pow);
|
|
if (_enabled) {
|
|
if (active) {
|
|
int mousepos = inputs_.mouse_x - static_cast<int>(rect.left);
|
|
if (mousepos < 0) {
|
|
mousepos = 0;
|
|
}
|
|
if (mousepos > rect.width) {
|
|
mousepos = static_cast<int>(rect.width);
|
|
}
|
|
pow_value = (mousepos * (pow_max - pow_min)) / rect.width + pow_min;
|
|
*_value = ozz::math::Clamp(_min, powf(pow_value, 1.f / _pow), _max);
|
|
} else {
|
|
// Clamping is only applied if the widget is enabled.
|
|
*_value = clamped_value;
|
|
}
|
|
}
|
|
|
|
// Renders slider's rail.
|
|
const math::RectFloat rail_rect(rect.left, rect.bottom, rect.width,
|
|
rect.height);
|
|
FillRect(rail_rect, kSliderRoundRectRadius, background_color);
|
|
StrokeRect(rail_rect, kSliderRoundRectRadius, border_color);
|
|
|
|
// Finds cursor position and rect.
|
|
const float cursor =
|
|
floorf((rect.width * (pow_value - pow_min)) / (pow_max - pow_min));
|
|
const math::RectFloat cursor_rect(
|
|
rect.left + cursor - kWidgetCursorWidth / 2.f, rect.bottom - 1.f,
|
|
kWidgetCursorWidth, rect.height + 2.f);
|
|
FillRect(cursor_rect, kSliderRoundRectRadius, slider_color);
|
|
StrokeRect(cursor_rect, kSliderRoundRectRadius, slider_border_color);
|
|
|
|
const math::RectFloat text_rect(
|
|
rail_rect.left + kSliderRoundRectRadius, rail_rect.bottom,
|
|
rail_rect.width - kSliderRoundRectRadius * 2.f, rail_rect.height);
|
|
Print(_label, text_rect, kMiddle, text_color);
|
|
|
|
// Returns true if the value has changed or if it was clamped in _min / _max
|
|
// bounds.
|
|
return initial_value != *_value;
|
|
}
|
|
|
|
bool ImGuiImpl::DoSlider(const char* _label, int _min, int _max, int* _value,
|
|
float _pow, bool _enabled) {
|
|
const float fmin = static_cast<float>(_min);
|
|
const float fmax = static_cast<float>(_max);
|
|
float fvalue = static_cast<float>(*_value);
|
|
bool changed = DoSlider(_label, fmin, fmax, &fvalue, _pow, _enabled);
|
|
*_value = static_cast<int>(fvalue);
|
|
return changed;
|
|
}
|
|
|
|
void ImGuiImpl::DoLabel(const char* _label, Justification _justification,
|
|
bool _single_line) {
|
|
if (containers_.empty()) {
|
|
return;
|
|
}
|
|
// Get current container.
|
|
Container& container = containers_.back();
|
|
|
|
// Computes widget rect and update internal offset in the panel.
|
|
math::RectFloat rect;
|
|
if (!AddWidget(_single_line
|
|
? font_.glyph_height
|
|
: math::Max(0.f, container.offset_y - kWidgetMarginY),
|
|
&rect)) {
|
|
return;
|
|
}
|
|
|
|
PrintLayout layout[] = {kNorthWest, kNorth, kNorthEst};
|
|
const float offset =
|
|
Print(_label, rect, layout[_justification], kWidgetTextColor);
|
|
|
|
if (!_single_line) { // Resume following widgets below the label.
|
|
container.offset_y = offset - kWidgetMarginY;
|
|
}
|
|
}
|
|
|
|
void ImGuiImpl::FillRect(const math::RectFloat& _rect, float _radius,
|
|
const GLubyte _rgba[4]) const {
|
|
FillRect(_rect, _radius, _rgba, ozz::math::Float4x4::identity());
|
|
}
|
|
|
|
void ImGuiImpl::FillRect(const math::RectFloat& _rect, float _radius,
|
|
const GLubyte _rgba[4],
|
|
const ozz::math::Float4x4& _transform) const {
|
|
if (_radius <= 0.f) {
|
|
GlImmediatePC im(renderer_->immediate_renderer(), GL_TRIANGLE_STRIP,
|
|
_transform);
|
|
GlImmediatePC::Vertex v = {{0.f, 0.f, 0.f},
|
|
{_rgba[0], _rgba[1], _rgba[2], _rgba[3]}};
|
|
v.pos[0] = _rect.left;
|
|
v.pos[1] = _rect.top();
|
|
im.PushVertex(v);
|
|
v.pos[1] = _rect.bottom;
|
|
im.PushVertex(v);
|
|
v.pos[0] = _rect.left + _rect.width;
|
|
v.pos[1] = _rect.top();
|
|
im.PushVertex(v);
|
|
v.pos[1] = _rect.bottom;
|
|
im.PushVertex(v);
|
|
} else {
|
|
const float x = _rect.left + _radius;
|
|
const float y = _rect.bottom + _radius;
|
|
const float w = _rect.width - _radius * 2.f;
|
|
const float h = _rect.height - _radius * 2.f;
|
|
const float radius = _radius / kCircleRadius;
|
|
|
|
GlImmediatePC im(renderer_->immediate_renderer(), GL_TRIANGLES, _transform);
|
|
GlImmediatePC::Vertex v = {{0.f, 0.f, 0.f},
|
|
{_rgba[0], _rgba[1], _rgba[2], _rgba[3]}};
|
|
for (int i = 1, j = i - 1; i <= kCircleSegments / 4; j = i++) {
|
|
v.pos[0] = x + w;
|
|
v.pos[1] = y + h;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x + w + circle_[j][0] * radius;
|
|
v.pos[1] = y + h + circle_[j][1] * radius;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x + w + circle_[i][0] * radius;
|
|
v.pos[1] = y + h + circle_[i][1] * radius;
|
|
im.PushVertex(v);
|
|
}
|
|
for (int i = 1 + kCircleSegments / 4, j = i - 1;
|
|
i <= 2 * kCircleSegments / 4; j = i++) {
|
|
v.pos[0] = x;
|
|
v.pos[1] = y + h;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x + circle_[j][0] * radius;
|
|
v.pos[1] = y + h + circle_[j][1] * radius;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x + circle_[i][0] * radius;
|
|
v.pos[1] = y + h + circle_[i][1] * radius;
|
|
im.PushVertex(v);
|
|
}
|
|
for (int i = 1 + 2 * kCircleSegments / 4, j = i - 1;
|
|
i <= 3 * kCircleSegments / 4; j = i++) {
|
|
v.pos[0] = x;
|
|
v.pos[1] = y;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x + circle_[j][0] * radius;
|
|
v.pos[1] = y + circle_[j][1] * radius;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x + circle_[i][0] * radius;
|
|
v.pos[1] = y + circle_[i][1] * radius;
|
|
im.PushVertex(v);
|
|
}
|
|
for (int i = 1 + 3 * kCircleSegments / 4, j = i - 1;
|
|
i <= 4 * kCircleSegments / 4; j = i++) {
|
|
const int index = i % kCircleSegments;
|
|
v.pos[0] = x + w;
|
|
v.pos[1] = y;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x + w + circle_[j][0] * radius;
|
|
v.pos[1] = y + circle_[j][1] * radius;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x + w + circle_[index][0] * radius;
|
|
v.pos[1] = y + circle_[index][1] * radius;
|
|
im.PushVertex(v);
|
|
}
|
|
|
|
v.pos[0] = _rect.left;
|
|
v.pos[1] = y;
|
|
im.PushVertex(v);
|
|
v.pos[0] = _rect.right();
|
|
v.pos[1] = y;
|
|
im.PushVertex(v);
|
|
v.pos[0] = _rect.right();
|
|
v.pos[1] = y + h;
|
|
im.PushVertex(v);
|
|
|
|
v.pos[0] = _rect.right();
|
|
v.pos[1] = y + h;
|
|
im.PushVertex(v);
|
|
v.pos[0] = _rect.left;
|
|
v.pos[1] = y + h;
|
|
im.PushVertex(v);
|
|
v.pos[0] = _rect.left;
|
|
v.pos[1] = y;
|
|
im.PushVertex(v);
|
|
|
|
v.pos[0] = x;
|
|
v.pos[1] = _rect.bottom;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x + w;
|
|
v.pos[1] = _rect.bottom;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x + w;
|
|
v.pos[1] = y;
|
|
im.PushVertex(v);
|
|
|
|
v.pos[0] = x + w;
|
|
v.pos[1] = y;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x;
|
|
v.pos[1] = y;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x;
|
|
v.pos[1] = _rect.bottom;
|
|
im.PushVertex(v);
|
|
|
|
v.pos[0] = x;
|
|
v.pos[1] = _rect.top() - _radius;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x + w;
|
|
v.pos[1] = _rect.top() - _radius;
|
|
im.PushVertex(v);
|
|
v.pos[0] = x + w;
|
|
v.pos[1] = _rect.top();
|
|
im.PushVertex(v);
|
|
|
|
v.pos[0] = x + w;
|
|
v.pos[1] = _rect.top();
|
|
im.PushVertex(v);
|
|
v.pos[0] = x;
|
|
v.pos[1] = _rect.top();
|
|
im.PushVertex(v);
|
|
v.pos[0] = x;
|
|
v.pos[1] = _rect.top() - _radius;
|
|
im.PushVertex(v);
|
|
}
|
|
}
|
|
|
|
void ImGuiImpl::StrokeRect(const math::RectFloat& _rect, float _radius,
|
|
const GLubyte _rgba[4]) const {
|
|
StrokeRect(_rect, _radius, _rgba, ozz::math::Float4x4::identity());
|
|
}
|
|
|
|
void ImGuiImpl::StrokeRect(const math::RectFloat& _rect, float _radius,
|
|
const GLubyte _rgba[4],
|
|
const ozz::math::Float4x4& _transform) const {
|
|
// Lines rendering requires to coordinate to be in the pixel center.
|
|
const ozz::math::SimdFloat4 translation =
|
|
ozz::math::simd_float4::Load(-.5f, -.5f, 0.f, 0.f);
|
|
const ozz::math::Float4x4 transform = Translate(_transform, translation);
|
|
|
|
if (_radius <= 0.f) {
|
|
GlImmediatePC im(renderer_->immediate_renderer(), GL_LINE_LOOP, transform);
|
|
GlImmediatePC::Vertex v = {{0.f, 0.f, 0.f},
|
|
{_rgba[0], _rgba[1], _rgba[2], _rgba[3]}};
|
|
v.pos[0] = _rect.left;
|
|
v.pos[1] = _rect.bottom;
|
|
im.PushVertex(v);
|
|
v.pos[0] = _rect.left + _rect.width;
|
|
im.PushVertex(v);
|
|
v.pos[1] = _rect.top();
|
|
im.PushVertex(v);
|
|
v.pos[0] = _rect.left;
|
|
im.PushVertex(v);
|
|
} else {
|
|
const float x = _rect.left + _radius;
|
|
const float y = _rect.bottom + _radius;
|
|
const float w = _rect.width - _radius * 2;
|
|
const float h = _rect.height - _radius * 2;
|
|
const float radius = _radius / kCircleRadius;
|
|
|
|
GlImmediatePC im(renderer_->immediate_renderer(), GL_LINE_LOOP, transform);
|
|
GlImmediatePC::Vertex v = {{0.f, 0.f, 0.f},
|
|
{_rgba[0], _rgba[1], _rgba[2], _rgba[3]}};
|
|
for (int i = 0; i <= kCircleSegments / 4; ++i) {
|
|
v.pos[0] = x + w + circle_[i][0] * radius;
|
|
v.pos[1] = y + h + circle_[i][1] * radius;
|
|
im.PushVertex(v);
|
|
}
|
|
for (int i = kCircleSegments / 4; i <= 2 * kCircleSegments / 4; ++i) {
|
|
v.pos[0] = x + circle_[i][0] * radius;
|
|
v.pos[1] = y + h + circle_[i][1] * radius;
|
|
im.PushVertex(v);
|
|
}
|
|
for (int i = 2 * kCircleSegments / 4; i <= 3 * kCircleSegments / 4; ++i) {
|
|
v.pos[0] = x + circle_[i][0] * radius;
|
|
v.pos[1] = y + circle_[i][1] * radius;
|
|
im.PushVertex(v);
|
|
}
|
|
for (int i = 3 * kCircleSegments / 4; i < 4 * kCircleSegments / 4; ++i) {
|
|
v.pos[0] = x + w + circle_[i][0] * radius;
|
|
v.pos[1] = y + circle_[i][1] * radius;
|
|
im.PushVertex(v);
|
|
}
|
|
v.pos[0] = x + w + circle_[0][0] * radius;
|
|
v.pos[1] = y + circle_[0][1] * radius;
|
|
im.PushVertex(v);
|
|
}
|
|
}
|
|
|
|
void ImGuiImpl::InitializeCircle() {
|
|
assert((kCircleSegments & 3) == 0); // kCircleSegments must be multiple of 4.
|
|
|
|
for (int i = 0; i < kCircleSegments; ++i) {
|
|
const float angle = i * math::k2Pi / kCircleSegments;
|
|
const float cos = std::cos(angle) * kCircleRadius;
|
|
const float sin = std::sin(angle) * kCircleRadius;
|
|
circle_[i][0] = cos + (cos >= 0.f ? 0.5f : -0.5f);
|
|
circle_[i][1] = sin + (sin >= 0.f ? 0.5f : -0.5f);
|
|
}
|
|
}
|
|
|
|
static const unsigned char kFontPixelRawData[] = {
|
|
0x00, 0x21, 0xb0, 0xa1, 0x04, 0x00, 0x08, 0x08, 0x40, 0x40, 0x00, 0x00,
|
|
0x00, 0x02, 0x38, 0x60, 0xe1, 0xc0, 0xc7, 0x87, 0x3e, 0x38, 0x70, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x38, 0x63, 0xe1, 0xef, 0x1f, 0x9f, 0x9e, 0xee,
|
|
0xf8, 0xf7, 0x77, 0x1d, 0xfb, 0x9c, 0x78, 0x73, 0xe1, 0xaf, 0xfd, 0xfb,
|
|
0xf7, 0xc7, 0xdd, 0xf1, 0xc4, 0x07, 0x04, 0x00, 0x10, 0x03, 0x00, 0x00,
|
|
0xc0, 0x07, 0x00, 0xc0, 0x20, 0x46, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x04, 0x00, 0x00,
|
|
0x00, 0x21, 0x20, 0xa3, 0x8a, 0x00, 0x08, 0x08, 0x41, 0xf0, 0x80, 0x00,
|
|
0x00, 0x02, 0x44, 0x21, 0x12, 0x21, 0x44, 0x08, 0x22, 0x44, 0x88, 0x00,
|
|
0x00, 0xc0, 0x30, 0x0c, 0x44, 0x21, 0x12, 0x24, 0x88, 0x88, 0xa2, 0x44,
|
|
0x20, 0x22, 0x22, 0x0d, 0x99, 0x22, 0x24, 0x89, 0x12, 0x69, 0x28, 0x91,
|
|
0x22, 0x44, 0x89, 0x11, 0x02, 0x01, 0x04, 0x00, 0x08, 0x01, 0x00, 0x00,
|
|
0x40, 0x08, 0x00, 0x40, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x02, 0x00, 0x00,
|
|
0x00, 0x21, 0x21, 0x44, 0x04, 0x06, 0x08, 0x10, 0x20, 0x40, 0x80, 0x00,
|
|
0x00, 0x04, 0x44, 0x20, 0x10, 0x21, 0x44, 0x10, 0x02, 0x44, 0x88, 0xc0,
|
|
0xc1, 0x00, 0x08, 0x12, 0x4c, 0x51, 0x12, 0x04, 0x4a, 0x0a, 0x20, 0x44,
|
|
0x20, 0x22, 0x42, 0x0d, 0x99, 0x22, 0x24, 0x89, 0x12, 0x01, 0x08, 0x91,
|
|
0x22, 0x28, 0x50, 0x21, 0x02, 0x01, 0x0a, 0x00, 0x00, 0x71, 0x61, 0xe3,
|
|
0x47, 0x1f, 0x1b, 0x58, 0xe1, 0xe2, 0xe1, 0x1d, 0x36, 0x1c, 0xd8, 0x6d,
|
|
0xb1, 0xe7, 0xd9, 0xbb, 0xf7, 0xcd, 0xdd, 0xf0, 0x81, 0x02, 0x00, 0x00,
|
|
0x00, 0x20, 0x03, 0xe4, 0x01, 0x88, 0x08, 0x10, 0x20, 0xa0, 0x80, 0x00,
|
|
0x00, 0x04, 0x44, 0x20, 0x20, 0xc2, 0x47, 0x1e, 0x04, 0x38, 0x88, 0xc0,
|
|
0xc6, 0x0f, 0x86, 0x02, 0x54, 0x51, 0xe2, 0x04, 0x4e, 0x0e, 0x20, 0x7c,
|
|
0x20, 0x22, 0x82, 0x0a, 0x95, 0x22, 0x24, 0x89, 0x11, 0xc1, 0x08, 0x8a,
|
|
0x2a, 0x10, 0x50, 0x41, 0x02, 0x01, 0x11, 0x00, 0x00, 0x89, 0x92, 0x24,
|
|
0xc8, 0x88, 0x26, 0x64, 0x20, 0x22, 0x41, 0x0a, 0x99, 0x22, 0x64, 0x98,
|
|
0xc2, 0x22, 0x08, 0x91, 0x22, 0x48, 0x89, 0x20, 0x81, 0x02, 0x00, 0x00,
|
|
0x00, 0x20, 0x01, 0x43, 0x8e, 0x08, 0x00, 0x10, 0x20, 0xa7, 0xf0, 0x0f,
|
|
0x80, 0x08, 0x44, 0x20, 0x40, 0x24, 0x40, 0x91, 0x04, 0x44, 0x78, 0x00,
|
|
0x08, 0x00, 0x01, 0x04, 0x54, 0x51, 0x12, 0x04, 0x4a, 0x0a, 0x27, 0x44,
|
|
0x21, 0x23, 0x82, 0x0a, 0x95, 0x22, 0x38, 0x89, 0xe0, 0x21, 0x08, 0x8a,
|
|
0x2a, 0x10, 0x20, 0x41, 0x01, 0x01, 0x00, 0x00, 0x00, 0x79, 0x12, 0x04,
|
|
0x4f, 0x88, 0x22, 0x44, 0x20, 0x23, 0x81, 0x0a, 0x91, 0x22, 0x44, 0x88,
|
|
0x81, 0xc2, 0x08, 0x91, 0x2a, 0x30, 0x48, 0x40, 0x81, 0x02, 0x09, 0x00,
|
|
0x00, 0x00, 0x03, 0xe4, 0x81, 0x15, 0x00, 0x10, 0x20, 0x00, 0x80, 0x00,
|
|
0x00, 0x08, 0x44, 0x20, 0x80, 0x27, 0xe0, 0x91, 0x04, 0x44, 0x08, 0x00,
|
|
0x06, 0x0f, 0x86, 0x08, 0x4c, 0xf9, 0x12, 0x04, 0x48, 0x08, 0x22, 0x44,
|
|
0x21, 0x22, 0x42, 0x48, 0x95, 0x22, 0x20, 0x89, 0x20, 0x21, 0x08, 0x8a,
|
|
0x2a, 0x28, 0x20, 0x81, 0x01, 0x01, 0x00, 0x00, 0x00, 0x89, 0x12, 0x04,
|
|
0x48, 0x08, 0x22, 0x44, 0x20, 0x22, 0x81, 0x0a, 0x91, 0x22, 0x44, 0x88,
|
|
0x80, 0x22, 0x08, 0x8a, 0x2a, 0x30, 0x50, 0x81, 0x01, 0x01, 0x16, 0x00,
|
|
0x00, 0x00, 0x01, 0x47, 0x02, 0x92, 0x00, 0x10, 0x20, 0x00, 0x81, 0x80,
|
|
0x0c, 0x10, 0x44, 0x21, 0x12, 0x20, 0x48, 0x91, 0x08, 0x44, 0x10, 0xc0,
|
|
0xc1, 0x00, 0x08, 0x00, 0x40, 0x89, 0x12, 0x24, 0x88, 0x88, 0x22, 0x44,
|
|
0x21, 0x22, 0x22, 0x48, 0x93, 0x22, 0x20, 0x89, 0x13, 0x21, 0x08, 0x84,
|
|
0x2a, 0x44, 0x21, 0x11, 0x00, 0x81, 0x00, 0x00, 0x00, 0x89, 0x12, 0x24,
|
|
0x48, 0x08, 0x22, 0x44, 0x20, 0x22, 0x41, 0x0a, 0x91, 0x22, 0x44, 0x88,
|
|
0x82, 0x22, 0x29, 0x8a, 0x2a, 0x48, 0x31, 0x10, 0x81, 0x02, 0x00, 0x00,
|
|
0x00, 0x20, 0x02, 0x81, 0x01, 0x0d, 0x00, 0x10, 0x20, 0x00, 0x81, 0x00,
|
|
0x0c, 0x10, 0x38, 0xf9, 0xf1, 0xc0, 0xe7, 0x0e, 0x08, 0x38, 0xe0, 0xc1,
|
|
0x80, 0xc0, 0x30, 0x18, 0x45, 0xdf, 0xe1, 0xcf, 0x1f, 0x9c, 0x1c, 0xee,
|
|
0xf8, 0xc7, 0x37, 0xdd, 0xfb, 0x1c, 0x70, 0x73, 0x8a, 0xc3, 0x87, 0x04,
|
|
0x14, 0xc6, 0x71, 0xf1, 0x00, 0x81, 0x00, 0x00, 0x00, 0x7f, 0xe1, 0xc3,
|
|
0xe7, 0x9f, 0x1e, 0xee, 0xf8, 0x26, 0xe7, 0xdf, 0xfb, 0x9c, 0x78, 0x79,
|
|
0xf3, 0xc1, 0xc6, 0xc4, 0x14, 0xcc, 0x21, 0xf0, 0x81, 0x02, 0x00, 0x00,
|
|
0x00, 0x00, 0x02, 0x81, 0x00, 0x00, 0x00, 0x08, 0x40, 0x00, 0x03, 0x00,
|
|
0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
|
|
0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x01, 0x00, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x02, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x40, 0x08,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x81, 0x02, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x40, 0x00, 0x02, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x01, 0xc0, 0x07, 0x00, 0x7f, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x1c, 0x00, 0x01, 0xc0, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1c,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x40, 0x04, 0x00, 0x00};
|
|
|
|
// Declares internal font raw data.
|
|
const ImGuiImpl::Font ImGuiImpl::font_ = {
|
|
1024, // texture_width
|
|
16, // texture_height
|
|
672, // image_width
|
|
10, // image_height
|
|
10, // glyph_height
|
|
7, // glyph_width
|
|
95, // glyph_count
|
|
32, // glyph_start
|
|
kFontPixelRawData, // pixels
|
|
sizeof(kFontPixelRawData) // pixels_size
|
|
};
|
|
|
|
void ImGuiImpl::InitalizeFont() {
|
|
// Builds font texture.
|
|
assert(static_cast<size_t>(font_.texture_width * font_.texture_height) >=
|
|
font_.pixels_size * 8);
|
|
|
|
const size_t buffer_size = 4 * font_.texture_width * font_.texture_height;
|
|
uint8_t* pixels = reinterpret_cast<uint8_t*>(
|
|
memory::default_allocator()->Allocate(buffer_size, 4));
|
|
memset(pixels, 0, buffer_size);
|
|
|
|
// Unpack font data font 1 bit per pixel to 8.
|
|
for (int i = 0; i < font_.image_width * font_.image_height; i += 8) {
|
|
for (int j = 0; j < 8; ++j) {
|
|
const int pixel = (i + j) / font_.image_width * font_.texture_width +
|
|
(i + j) % font_.image_width;
|
|
const int bit = 7 - j;
|
|
const uint8_t cpnt = ((font_.pixels[i / 8] >> bit) & 1) * 255;
|
|
pixels[4 * pixel + 0] = cpnt;
|
|
pixels[4 * pixel + 1] = cpnt;
|
|
pixels[4 * pixel + 2] = cpnt;
|
|
pixels[4 * pixel + 3] = cpnt;
|
|
}
|
|
}
|
|
|
|
GL(GenTextures(1, &glyph_texture_));
|
|
GL(BindTexture(GL_TEXTURE_2D, glyph_texture_));
|
|
GL(TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
|
|
GL(TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
|
|
GL(TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, font_.texture_width,
|
|
font_.texture_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels));
|
|
GL(PixelStorei(GL_UNPACK_ALIGNMENT, 1));
|
|
GL(BindTexture(GL_TEXTURE_2D, 0));
|
|
memory::default_allocator()->Deallocate(pixels);
|
|
|
|
// Pre-computes glyphes texture and vertex coordinates.
|
|
const float glyph_uv_width =
|
|
static_cast<float>(font_.glyph_width) / font_.texture_width;
|
|
const float glyph_uv_height =
|
|
static_cast<float>(font_.glyph_height) / font_.texture_height;
|
|
|
|
const int num_glyphes = static_cast<int>(OZZ_ARRAY_SIZE(glyphes_));
|
|
assert(num_glyphes >= font_.glyph_start + font_.glyph_count);
|
|
for (int i = 0; i < num_glyphes; ++i) {
|
|
if (i >= font_.glyph_start && i < font_.glyph_start + font_.glyph_count) {
|
|
Glyph& glyph = glyphes_[i];
|
|
const int index = i - font_.glyph_start;
|
|
glyph.uv[0][0] = index * glyph_uv_width;
|
|
glyph.uv[0][1] = 0.f;
|
|
glyph.pos[0][0] = 0.f;
|
|
glyph.pos[0][1] = static_cast<float>(font_.glyph_height);
|
|
|
|
glyph.uv[1][0] = index * glyph_uv_width;
|
|
glyph.uv[1][1] = glyph_uv_height;
|
|
glyph.pos[1][0] = 0.f;
|
|
glyph.pos[1][1] = 0.f;
|
|
|
|
glyph.uv[2][0] = (index + 1) * glyph_uv_width;
|
|
glyph.uv[2][1] = 0.f;
|
|
glyph.pos[2][0] = static_cast<float>(font_.glyph_width);
|
|
glyph.pos[2][1] = static_cast<float>(font_.glyph_height);
|
|
|
|
glyph.uv[3][0] = (index + 1) * glyph_uv_width;
|
|
glyph.uv[3][1] = glyph_uv_height;
|
|
glyph.pos[3][0] = static_cast<float>(font_.glyph_width);
|
|
glyph.pos[3][1] = 0.f;
|
|
} else {
|
|
memset(&glyphes_[i], 0, sizeof(glyphes_[i]));
|
|
}
|
|
}
|
|
}
|
|
|
|
void ImGuiImpl::DestroyFont() {
|
|
GL(DeleteTextures(1, &glyph_texture_));
|
|
glyph_texture_ = 0;
|
|
}
|
|
|
|
namespace {
|
|
inline bool IsDivisible(char _c) { return _c == ' ' || _c == '\t'; }
|
|
|
|
struct LineSpec {
|
|
const char* begin;
|
|
const char* end;
|
|
};
|
|
} // namespace
|
|
|
|
float ImGuiImpl::Print(const char* _text, const math::RectFloat& _rect,
|
|
PrintLayout _layout, const GLubyte _rgba[4]) const {
|
|
LineSpec line_specs[64];
|
|
int interlign = font_.glyph_height / 4;
|
|
int max_lines = (static_cast<int>(_rect.height) + interlign) /
|
|
(font_.glyph_height + interlign);
|
|
if (max_lines == 0) {
|
|
return _rect.height; // No offset from the bottom.
|
|
}
|
|
const int max_line_specs = OZZ_ARRAY_SIZE(line_specs);
|
|
if (max_lines > max_line_specs) {
|
|
max_lines = max_line_specs;
|
|
}
|
|
int line_count = 0;
|
|
|
|
const int chars_per_line = static_cast<int>(_rect.width) / font_.glyph_width;
|
|
{
|
|
const char* last_div = nullptr;
|
|
LineSpec spec = {_text, _text};
|
|
while (*spec.end) {
|
|
if (IsDivisible(*spec.end)) { // Found a divisible character.
|
|
last_div = spec.end;
|
|
}
|
|
|
|
// Is this the last character of the line.
|
|
if (*spec.end == '\n' || spec.end + 1 > spec.begin + chars_per_line) {
|
|
if (*spec.end != '\n' && last_div != nullptr) {
|
|
// Breaks the line after the last divisible character.
|
|
spec.end = last_div;
|
|
last_div = nullptr;
|
|
}
|
|
|
|
// Trims ' ' left if it is the end of the new line.
|
|
while ((spec.end - 1) >= spec.begin && IsDivisible(*(spec.end - 1))) {
|
|
--spec.end;
|
|
}
|
|
|
|
// Pushes the new line specs.
|
|
line_specs[line_count++] = spec;
|
|
if (line_count == max_lines) {
|
|
break;
|
|
}
|
|
|
|
// Sets specs for the new line.
|
|
spec.begin = spec.end;
|
|
|
|
// Trims ' ' right if it is the beginning of a new line.
|
|
while (IsDivisible(*spec.begin)) {
|
|
++spec.begin;
|
|
}
|
|
// Trims '\n' right if this line was stopped because of a cr.
|
|
if (*spec.begin == '\n') {
|
|
++spec.begin;
|
|
}
|
|
|
|
spec.end = spec.begin;
|
|
} else {
|
|
++spec.end;
|
|
}
|
|
}
|
|
|
|
if (line_count < max_lines) {
|
|
// Trims ' ' left as it is the end of the new line.
|
|
while ((spec.end - 1) >= spec.begin && IsDivisible(*(spec.end - 1))) {
|
|
--spec.end;
|
|
}
|
|
// Pushes the remaining text.
|
|
if (spec.begin != spec.end) {
|
|
line_specs[line_count++] = spec;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (line_count == 0) {
|
|
return _rect.height; // No offset from the bottom.
|
|
}
|
|
|
|
// Default is kNorth*.
|
|
float ly = _rect.bottom + _rect.height - font_.glyph_height;
|
|
switch (_layout) {
|
|
case kWest:
|
|
case kMiddle:
|
|
case kEst: {
|
|
ly = _rect.bottom - font_.glyph_height +
|
|
(_rect.height - 1 + // -1 rounds on the pixel below.
|
|
line_count * font_.glyph_height + (line_count - 1) * interlign) /
|
|
2.f;
|
|
ly = floorf(ly);
|
|
break;
|
|
}
|
|
case kSouthWest:
|
|
case kSouth:
|
|
case kSouthEst: {
|
|
ly = _rect.bottom + (line_count - 1) * (font_.glyph_height + interlign);
|
|
break;
|
|
}
|
|
default: { break; }
|
|
}
|
|
|
|
GL(BindTexture(GL_TEXTURE_2D, glyph_texture_));
|
|
|
|
for (int l = 0; l < line_count; ++l) {
|
|
const int line_char_count =
|
|
static_cast<int>(line_specs[l].end - line_specs[l].begin);
|
|
float lx = _rect.left; // Default value is kWest*.
|
|
switch (_layout) {
|
|
case kNorth:
|
|
case kMiddle:
|
|
case kSouth: {
|
|
lx = _rect.left +
|
|
((_rect.width - (line_char_count * font_.glyph_width)) / 2.f);
|
|
lx = floorf(lx);
|
|
break;
|
|
}
|
|
case kNorthEst:
|
|
case kEst:
|
|
case kSouthEst: {
|
|
lx = _rect.right() - (line_char_count * font_.glyph_width);
|
|
break;
|
|
}
|
|
default: { break; }
|
|
}
|
|
|
|
// Loops through all characters of the current line, and renders them using
|
|
// precomputed texture and vertex coordinates.
|
|
{
|
|
GlImmediatePTC im(renderer_->immediate_renderer(), GL_TRIANGLES,
|
|
ozz::math::Float4x4::identity());
|
|
GlImmediatePTC::Vertex v = {{0.f, 0.f, 0.f},
|
|
{0.f, 0.f},
|
|
{_rgba[0], _rgba[1], _rgba[2], _rgba[3]}};
|
|
|
|
float offset = 0.f;
|
|
for (int i = 0; i < line_char_count; i++, offset += font_.glyph_width) {
|
|
const int char_index = line_specs[l].begin[i];
|
|
const int num_glyphes = static_cast<int>(OZZ_ARRAY_SIZE(glyphes_));
|
|
if (char_index >= 0 && char_index < num_glyphes) {
|
|
const Glyph& glyph = glyphes_[char_index];
|
|
const int indices[] = {0, 1, 2, 2, 1, 3};
|
|
for (size_t j = 0; j < OZZ_ARRAY_SIZE(indices); j++) {
|
|
const int index = indices[j];
|
|
v.uv[0] = glyph.uv[index][0];
|
|
v.uv[1] = glyph.uv[index][1];
|
|
v.pos[0] = lx + glyph.pos[index][0] + offset;
|
|
v.pos[1] = ly + glyph.pos[index][1];
|
|
im.PushVertex(v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Computes next line height.
|
|
ly -= font_.glyph_height + interlign;
|
|
}
|
|
GL(BindTexture(GL_TEXTURE_2D, 0));
|
|
|
|
// Returns the bottom of the last line.
|
|
return ly + font_.glyph_height + interlign - _rect.bottom;
|
|
}
|
|
} // namespace internal
|
|
} // namespace sample
|
|
} // namespace ozz
|