void Slider::draw(NVGcontext* ctx) {
Vector2f center = mPos.cast<float>() + mSize.cast<float>() * 0.5f;
Vector2f knobPos(mPos.x() + mValue * mSize.x(), center.y() + 0.5f);
float kr = (int)(mSize.y()*0.5f);
NVGpaint bg = nvgBoxGradient(ctx,
mPos.x(), center.y() - 3 + 1, mSize.x(), 6, 3, 3, Color(0, mEnabled ? 32 : 10), Color(0, mEnabled ? 128 : 210));
nvgBeginPath(ctx);
nvgRoundedRect(ctx, mPos.x(), center.y() - 3 + 1, mSize.x(), 6, 2);
nvgFillPaint(ctx, bg);
nvgFill(ctx);
if (mHighlightedRange.second != mHighlightedRange.first) {
nvgBeginPath(ctx);
nvgRoundedRect(ctx, mPos.x() + mHighlightedRange.first * mSize.x(), center.y() - 3 + 1, mSize.x() * (mHighlightedRange.second-mHighlightedRange.first), 6, 2);
nvgFillColor(ctx, mHighlightColor);
nvgFill(ctx);
}
NVGpaint knobShadow = nvgRadialGradient(ctx,
knobPos.x(), knobPos.y(), kr-3, kr+3, Color(0, 64), mTheme->mTransparent);
nvgBeginPath(ctx);
nvgRect(ctx, knobPos.x() - kr - 5, knobPos.y() - kr - 5, kr*2+10, kr*2+10+3);
nvgCircle(ctx, knobPos.x(), knobPos.y(), kr);
nvgPathWinding(ctx, NVG_HOLE);
nvgFillPaint(ctx, knobShadow);
nvgFill(ctx);
NVGpaint knob = nvgLinearGradient(ctx,
mPos.x(), center.y() - kr, mPos.x(), center.y() + kr,
mTheme->mBorderLight, mTheme->mBorderMedium);
NVGpaint knobReverse = nvgLinearGradient(ctx,
mPos.x(), center.y() - kr, mPos.x(), center.y() + kr,
mTheme->mBorderMedium,
mTheme->mBorderLight);
nvgBeginPath(ctx);
nvgCircle(ctx, knobPos.x(), knobPos.y(), kr);
nvgStrokeColor(ctx, mTheme->mBorderDark);
nvgFillPaint(ctx, knob);
nvgStroke(ctx);
nvgFill(ctx);
nvgBeginPath(ctx);
nvgCircle(ctx, knobPos.x(), knobPos.y(), kr/2);
nvgFillColor(ctx, Color(150, mEnabled ? 255 : 100));
nvgStrokePaint(ctx, knobReverse);
nvgStroke(ctx);
nvgFill(ctx);
}
void Renderer2D::drawCircle( const attributes_2d& attributes, const float32_t& radius,
const float32_t& border, const color_argb& color, const color_argb& borderColor,
const Image2D& image, const float32_t& image_alpha, const float32_t& image_pos_x,
const float32_t& image_pos_y, const float32_t& image_width, const float32_t& image_height,
const float32_t& image_rotation )
{
Context2D* context = _context2D;
nvgSave( context );
nvgBeginPath( context );
nvgTranslate( context, attributes.position[0], attributes.position[1]);
nvgSave( context );
nvgRotate( context, attributes.rotation );
nvgCircle( context, 0, 0, radius * attributes.scale );
if( image != 0 )
{
NVGpaint paint = nvgImagePattern( context, image_pos_x-image_width/2,
image_pos_y - image_height/2, image_width, image_height, image_rotation,
image, image_alpha );
nvgFillPaint( context, paint);
}
else
{
nvgFillColor( context, nvgRGBA( color.r, color.g, color.b, color.a) );
}
nvgFill(context);
nvgStrokeColor( context, nvgRGBA( borderColor.r, borderColor.g, borderColor.b, borderColor.a) );
nvgStrokeWidth( context, border );
nvgStroke( context );
nvgRestore( context );
nvgRestore( context );
}
virtual void updateGL( osg::State* state ) const
{
// Some test drawings...
nvgBeginPath( _vg );
nvgRect( _vg, 300, 300, 120, 30 );
nvgFillColor( _vg, nvgRGBA(255, 192, 0, 255) );
nvgFill( _vg );
nvgClosePath( _vg );
nvgBeginPath( _vg );
nvgCircle( _vg, 400, 500, 50 );
nvgFillColor( _vg, nvgRGBA(0, 192, 255, 100) );
nvgFill( _vg );
nvgClosePath( _vg );
if ( _loadedImages.size()>0 )
{
NVGpaint imgPaint = nvgImagePattern( _vg, 600, 150, 300, 400, 0.0f,
_loadedImages[0], 1.0f );
nvgBeginPath( _vg );
nvgRoundedRect( _vg, 600, 150, 300, 400, 5 );
nvgFillPaint( _vg, imgPaint );
nvgFill( _vg );
nvgClosePath( _vg );
}
}
void draw<circle_t>(circle_t& circle, NVGcolor& color)
{
nvgBeginPath(graphics::vg);
nvgCircle(graphics::vg, circle.x, circle.y, circle.r);
nvgFillColor(graphics::vg, color);
nvgFill(graphics::vg);
}
static void
draw_circle(NVGcontext *ctx, float x, float y, float r, const gui_byte *c)
{
nvgBeginPath(ctx);
nvgCircle(ctx, x + r, y + r, r);
nvgFillColor(ctx, nvgRGBA(c[0], c[1], c[2], c[3]));
nvgFill(ctx);
}
static void
draw_circle(NVGcontext *ctx, float x, float y, float r, struct gui_color c)
{
nvgBeginPath(ctx);
nvgCircle(ctx, x + r, y + r, r);
nvgFillColor(ctx, nvgRGBA(c.r, c.g, c.b, c.a));
nvgFill(ctx);
}
void drawSlider(struct NVGcontext* vg, float pos, float x, float y, float w, float h)
{
struct NVGpaint bg, knob;
float cy = y+(int)(h*0.5f);
float kr = (float)( (int)(h*0.25f) );
nvgSave(vg);
// nvgClearState(vg);
// Slot
bg = nvgBoxGradient(vg, x,cy-2+1, w,4, 2,2, nvgRGBA(0,0,0,32), nvgRGBA(0,0,0,128) );
nvgBeginPath(vg);
nvgRoundedRect(vg, x,cy-2, w,4, 2);
nvgFillPaint(vg, bg);
nvgFill(vg);
// Knob Shadow
bg = nvgRadialGradient(vg, x+(int)(pos*w),cy+1, kr-3,kr+3, nvgRGBA(0,0,0,64), nvgRGBA(0,0,0,0) );
nvgBeginPath(vg);
nvgRect(vg, x+(int)(pos*w)-kr-5,cy-kr-5,kr*2+5+5,kr*2+5+5+3);
nvgCircle(vg, x+(int)(pos*w),cy, kr);
nvgPathWinding(vg, NVG_HOLE);
nvgFillPaint(vg, bg);
nvgFill(vg);
// Knob
knob = nvgLinearGradient(vg, x,cy-kr,x,cy+kr, nvgRGBA(255,255,255,16), nvgRGBA(0,0,0,16) );
nvgBeginPath(vg);
nvgCircle(vg, x+(int)(pos*w),cy, kr-1);
nvgFillColor(vg, nvgRGBA(40,43,48,255) );
nvgFill(vg);
nvgFillPaint(vg, knob);
nvgFill(vg);
nvgBeginPath(vg);
nvgCircle(vg, x+(int)(pos*w),cy, kr-0.5f);
nvgStrokeColor(vg, nvgRGBA(0,0,0,92) );
nvgStroke(vg);
nvgRestore(vg);
}
void Material::update(NVGcontext* vg, double time)
{
if (m_framebufferObject == nullptr)
return;
if (m_initialized == true && m_animate == false)
return;
float circle_size = float((cos(time) + 1.0) * 128.0);
nvgluBindFramebuffer(m_framebufferObject);
glViewport(0, 0, m_width, m_height);
// Any alpha other than zero will fail for some FBO reason
glClearColor(m_color.r, m_color.g, m_color.b, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
nvgBeginFrame(vg, m_width, m_height, /*pixelRatio*/1.0f);
nvgBeginPath(vg);
if (m_animate)
nvgCircle(vg, float(m_width) * 0.5f, float(m_height) * 0.5f, circle_size);
if(m_type == 2)
nvgFillColor(vg, nvgRGBA(220, 45, 0, 200));
else if(m_type == 1)
nvgFillColor(vg, nvgRGBA(0, 220, 45, 200));
else nvgFillColor(vg, nvgRGBA(10, 145, 200, 200));
nvgFill(vg);
if(m_type == 2)
{
nvgFontFace(vg, "sans");
nvgFontSize(vg, 80.0f);
nvgTextAlign(vg, NVG_ALIGN_CENTER);
nvgFillColor(vg, nvgRGBA(255, 255, 255, 255));
nvgText(vg, float(m_width) * 0.5f, (float(m_height) * 0.5f) + 20.0f, "Add Object", nullptr);
}
nvgEndFrame(vg);
nvgluBindFramebuffer(NULL);
m_initialized = true;
}
void draw<vec_field_t>(vec_field_t& vf, NVGcolor& color)
{
vf.foreach_element([&](size_t i, size_t j, vec_t& v){
vec_t pos = vf.get_coordinates(i, j), to = pos + v;
nvgBeginPath(vg);
nvgCircle(vg, pos.x, pos.y, .2);
nvgFillColor(vg, color);
nvgFill(vg);
nvgBeginPath(vg);
nvgMoveTo(vg, pos.x, pos.y);
nvgLineTo(vg, to.x, to.y);
nvgStrokeColor(vg, color);
nvgStrokeWidth(vg, one_pixel);
nvgStroke(vg);
});
}
void t2Image::drawInCircle(int x, int y, float radius, int angle /*= 0*/, int alpha /*= 255*/, bool bFill /*= true*/)
{
NVGpaint imgPaint = nvgImagePattern(t2GetContext(), x, y, width, height, angle / 255.0f, img, alpha / 255.0f);
nvgBeginPath(t2GetContext());
nvgCircle(t2GetContext(), x, y, radius);
if(bFill)
{
nvgFillPaint(t2GetContext(), imgPaint);
nvgFill(t2GetContext());
}
else
{
nvgStrokePaint(t2GetContext(), imgPaint);
nvgStroke(t2GetContext());
}
}
void renderPattern(NVGcontext* vg, NVGLUframebuffer* fb, float t, float pxRatio)
{
int winWidth, winHeight;
int fboWidth, fboHeight;
int pw, ph, x, y;
float s = 20.0f;
float sr = (cosf(t)+1)*0.5f;
float r = s * 0.6f * (0.2f + 0.8f * sr);
if (fb == NULL) return;
nvgImageSize(vg, fb->image, &fboWidth, &fboHeight);
winWidth = (int)(fboWidth / pxRatio);
winHeight = (int)(fboHeight / pxRatio);
// Draw some stuff to an FBO as a test
nvgluBindFramebuffer(fb);
glViewport(0, 0, fboWidth, fboHeight);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
nvgBeginFrame(vg, winWidth, winHeight, pxRatio);
pw = (int)ceilf(winWidth / s);
ph = (int)ceilf(winHeight / s);
nvgBeginPath(vg);
for (y = 0; y < ph; y++) {
for (x = 0; x < pw; x++) {
float cx = (x+0.5f) * s;
float cy = (y+0.5f) * s;
nvgCircle(vg, cx,cy, r);
}
}
nvgFillColor(vg, nvgRGBA(220,160,0,200));
nvgFill(vg);
nvgEndFrame(vg);
nvgluBindFramebuffer(NULL);
}
void NanoVG::circle( float cx, float cy, float r )
{
nvgCircle( m_context(), cx, cy, r );
}
void GraphPane::draw(AlloyContext* context) {
Region::draw(context);
box2px rbounds = getBounds();
NVGcontext* nvg = context->nvgContext;
box2px gbounds = rbounds;
const float LARGE_TEXT = 18.0f;
const float MEDIUM_TEXT = 16.0f;
const float SMALL_TEXT = 12.0f;
float2 gpos(-1, -1);
gbounds.position = pixel2(rbounds.position.x + GRAPH_PADDING,
rbounds.position.y + GRAPH_PADDING);
gbounds.dimensions = pixel2(rbounds.dimensions.x - GRAPH_PADDING * 2,
rbounds.dimensions.y - GRAPH_PADDING * 2);
if (graphBounds.dimensions.x < 0 || graphBounds.dimensions.y < 0) {
updateGraphBounds();
}
nvgBeginPath(nvg);
nvgRoundedRect(nvg, gbounds.position.x - 2, gbounds.position.y - 2,
gbounds.dimensions.x + 4, gbounds.dimensions.y + 4,
context->theme.CORNER_RADIUS);
nvgFillColor(nvg, context->theme.LIGHTEST);
nvgFill(nvg);
//Draw vertical line for x=0
if (graphBounds.position.x < 0
&& graphBounds.position.x + graphBounds.dimensions.x > 0) {
float xpos = -graphBounds.position.x / graphBounds.dimensions.x;
nvgBeginPath(nvg);
nvgMoveTo(nvg, xpos * gbounds.dimensions.x + gbounds.position.x,
gbounds.position.y);
nvgLineTo(nvg, xpos * gbounds.dimensions.x + gbounds.position.x,
gbounds.position.y + gbounds.dimensions.y);
nvgStrokeWidth(nvg, 2.0f);
nvgStrokeColor(nvg, context->theme.DARK.toSemiTransparent(0.75f));
nvgStroke(nvg);
}
//Draw horizontal line for y=0
if (graphBounds.position.y < 0
&& graphBounds.position.y + graphBounds.dimensions.y > 0) {
float ypos = -graphBounds.position.y / graphBounds.dimensions.y;
nvgBeginPath(nvg);
nvgMoveTo(nvg, gbounds.position.x,
ypos * gbounds.dimensions.y + gbounds.position.y);
nvgLineTo(nvg, gbounds.position.x + gbounds.dimensions.x,
ypos * gbounds.dimensions.y + gbounds.position.y);
nvgStrokeWidth(nvg, 2.0f);
nvgStrokeColor(nvg, context->theme.DARK.toSemiTransparent(0.75f));
nvgStroke(nvg);
}
if (gbounds.contains(cursorPosition)) {
context->setCursor(&Cursor::CrossHairs);
gpos = (cursorPosition - gbounds.position) / gbounds.dimensions;
gpos.y = 1 - gpos.y;
gpos = gpos * graphBounds.dimensions + graphBounds.position;
nvgBeginPath(nvg);
nvgMoveTo(nvg, cursorPosition.x, gbounds.position.y);
nvgLineTo(nvg, cursorPosition.x,
gbounds.position.y + gbounds.dimensions.y);
nvgStrokeWidth(nvg, 1.0f);
nvgStrokeColor(nvg, context->theme.DARK.toSemiTransparent(0.25f));
nvgStroke(nvg);
nvgBeginPath(nvg);
nvgMoveTo(nvg, gbounds.position.x, cursorPosition.y);
nvgLineTo(nvg, gbounds.position.x + gbounds.dimensions.x,
cursorPosition.y);
nvgStrokeWidth(nvg, 1.0f);
nvgStrokeColor(nvg, context->theme.DARK.toSemiTransparent(0.25f));
nvgStroke(nvg);
}
for (GraphDataPtr& curve : curves) {
std::vector<float2> points = curve->points;
if (points.size() > 1 && graphBounds.dimensions.x > 0.0f
&& graphBounds.dimensions.y > 0.0f) {
NVGcontext* nvg = context->nvgContext;
float2 last = points[0];
last = (last - graphBounds.position) / graphBounds.dimensions;
last.y = 1.0f - last.y;
last = last * gbounds.dimensions + gbounds.position;
nvgBeginPath(nvg);
nvgMoveTo(nvg, last.x, last.y);
for (int i = 1; i < (int)points.size(); i++) {
float2 pt = points[i];
pt = (pt - graphBounds.position) / graphBounds.dimensions;
pt.y = 1.0f - pt.y;
pt = pt * gbounds.dimensions + gbounds.position;
nvgLineTo(nvg, pt.x, pt.y);
last = pt;
}
nvgStrokeWidth(nvg, 2.0f);
nvgStrokeColor(nvg, curve->color);
nvgStroke(nvg);
}
}
nvgFontFaceId(nvg, context->getFontHandle(FontType::Bold));
nvgFontSize(nvg, LARGE_TEXT);
nvgTextAlign(nvg, NVG_ALIGN_CENTER | NVG_ALIGN_TOP);
drawText(nvg, rbounds.position + float2(rbounds.dimensions.x / 2, 2.0f),
name, FontStyle::Outline, context->theme.LIGHTEST,
context->theme.DARK);
nvgFontSize(nvg, MEDIUM_TEXT);
nvgFontFaceId(nvg, context->getFontHandle(FontType::Bold));
nvgTextAlign(nvg, NVG_ALIGN_CENTER | NVG_ALIGN_BOTTOM);
drawText(nvg,
rbounds.position
+ float2(rbounds.dimensions.x / 2,
rbounds.dimensions.y - 4.0f), xAxisLabel,
FontStyle::Outline, context->theme.LIGHTEST, context->theme.DARK);
nvgTextAlign(nvg, NVG_ALIGN_CENTER | NVG_ALIGN_TOP);
nvgSave(nvg);
pixel2 center = rbounds.position
+ float2(2.0f, rbounds.dimensions.y * 0.5f);
nvgTranslate(nvg, center.x, center.y);
nvgRotate(nvg, -ALY_PI * 0.5f);
drawText(nvg, pixel2(0, 2), yAxisLabel, FontStyle::Outline,
context->theme.LIGHTEST, context->theme.DARK);
nvgRestore(nvg);
nvgFontSize(nvg, SMALL_TEXT);
nvgTextAlign(nvg, NVG_ALIGN_RIGHT | NVG_ALIGN_TOP);
drawText(nvg, rbounds.position + float2(GRAPH_PADDING, GRAPH_PADDING),
MakeString() << std::setprecision(2)
<< (graphBounds.position.y + graphBounds.dimensions.y),
FontStyle::Outline, context->theme.LIGHTER, context->theme.DARK);
nvgTextAlign(nvg, NVG_ALIGN_RIGHT | NVG_ALIGN_BOTTOM);
drawText(nvg,
rbounds.position
+ float2(GRAPH_PADDING,
rbounds.dimensions.y - GRAPH_PADDING),
MakeString() << std::setprecision(2) << graphBounds.position.y,
FontStyle::Outline, context->theme.LIGHTER, context->theme.DARK);
nvgTextAlign(nvg, NVG_ALIGN_RIGHT | NVG_ALIGN_TOP);
drawText(nvg,
rbounds.position
+ float2(rbounds.dimensions.x - GRAPH_PADDING,
rbounds.dimensions.y - GRAPH_PADDING + 2),
MakeString() << std::setprecision(2)
<< (graphBounds.position.x + graphBounds.dimensions.x),
FontStyle::Outline, context->theme.LIGHTER, context->theme.DARK);
nvgTextAlign(nvg, NVG_ALIGN_LEFT | NVG_ALIGN_TOP);
drawText(nvg,
rbounds.position
+ float2(GRAPH_PADDING,
rbounds.dimensions.y - GRAPH_PADDING + 2),
MakeString() << std::setprecision(2) << graphBounds.position.x,
FontStyle::Outline, context->theme.LIGHTER, context->theme.DARK);
if (cursorPosition.x >= 0) {
float minDist = 1E30f;
float bestY = 0;
GraphDataPtr closestCurve;
for (GraphDataPtr& curve : curves) {
float y = curve->interpolate(gpos.x);
if (y != GraphData::NO_INTERSECT) {
if (std::abs(y - gpos.y) < minDist) {
minDist = std::abs(y - gpos.y);
bestY = y;
closestCurve = curve;
}
}
}
if (closestCurve.get() != nullptr) {
nvgBeginPath(nvg);
nvgStrokeWidth(nvg, 2.0f);
nvgFillColor(nvg, closestCurve->color);
nvgStrokeColor(nvg, context->theme.LIGHTER);
float2 pt(gpos.x, bestY);
pt = (pt - graphBounds.position) / graphBounds.dimensions;
pt.y = 1.0f - pt.y;
pt = pt * gbounds.dimensions + gbounds.position;
nvgCircle(nvg, pt.x, pt.y, 4);
nvgFill(nvg);
nvgStroke(nvg);
nvgBeginPath(nvg);
nvgFillColor(nvg, context->theme.DARK);
nvgCircle(nvg, cursorPosition.x, cursorPosition.y, 2);
nvgFill(nvg);
nvgTextAlign(nvg, NVG_ALIGN_RIGHT | NVG_ALIGN_MIDDLE);
nvgFontSize(nvg, MEDIUM_TEXT);
drawText(nvg, float2(pt.x - 8, pt.y), closestCurve->name,
FontStyle::Outline, context->theme.LIGHTEST,
context->theme.DARK);
nvgTextAlign(nvg, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE);
drawText(nvg, float2(pt.x + 8, pt.y),
MakeString() << "(" << std::setprecision(2) << gpos.x
<< ", " << std::setprecision(2) << bestY << ")",
FontStyle::Outline, context->theme.LIGHTEST,
context->theme.DARK);
}
else {
nvgBeginPath(nvg);
nvgFillColor(nvg, context->theme.DARK);
nvgCircle(nvg, cursorPosition.x, cursorPosition.y, 2);
nvgFill(nvg);
}
}
}
void NVGRenderer::circle(float x, float y, float r)
{
nvgCircle(m_context, x, y, r);
}
void ColorWheel::draw(NVGcontext *ctx) {
Widget::draw(ctx);
if (!mVisible)
return;
float x = mPos.x(),
y = mPos.y(),
w = mSize.x(),
h = mSize.y();
NVGcontext* vg = ctx;
int i;
float r0, r1, ax,ay, bx,by, cx,cy, aeps, r;
float hue = mHue;
NVGpaint paint;
nvgSave(vg);
cx = x + w*0.5f;
cy = y + h*0.5f;
r1 = (w < h ? w : h) * 0.5f - 5.0f;
r0 = r1 * .75f;
aeps = 0.5f / r1; // half a pixel arc length in radians (2pi cancels out).
for (i = 0; i < 6; i++) {
float a0 = (float)i / 6.0f * NVG_PI * 2.0f - aeps;
float a1 = (float)(i+1.0f) / 6.0f * NVG_PI * 2.0f + aeps;
nvgBeginPath(vg);
nvgArc(vg, cx,cy, r0, a0, a1, NVG_CW);
nvgArc(vg, cx,cy, r1, a1, a0, NVG_CCW);
nvgClosePath(vg);
ax = cx + cosf(a0) * (r0+r1)*0.5f;
ay = cy + sinf(a0) * (r0+r1)*0.5f;
bx = cx + cosf(a1) * (r0+r1)*0.5f;
by = cy + sinf(a1) * (r0+r1)*0.5f;
paint = nvgLinearGradient(vg, ax, ay, bx, by,
nvgHSLA(a0 / (NVG_PI * 2), 1.0f, 0.55f, 255),
nvgHSLA(a1 / (NVG_PI * 2), 1.0f, 0.55f, 255));
nvgFillPaint(vg, paint);
nvgFill(vg);
}
nvgBeginPath(vg);
nvgCircle(vg, cx,cy, r0-0.5f);
nvgCircle(vg, cx,cy, r1+0.5f);
nvgStrokeColor(vg, nvgRGBA(0,0,0,64));
nvgStrokeWidth(vg, 1.0f);
nvgStroke(vg);
// Selector
nvgSave(vg);
nvgTranslate(vg, cx,cy);
nvgRotate(vg, hue*NVG_PI*2);
// Marker on
float u = std::max(r1/50, 1.5f);
u = std::min(u, 4.f);
nvgStrokeWidth(vg, u);
nvgBeginPath(vg);
nvgRect(vg, r0-1,-2*u,r1-r0+2,4*u);
nvgStrokeColor(vg, nvgRGBA(255,255,255,192));
nvgStroke(vg);
paint = nvgBoxGradient(vg, r0-3,-5,r1-r0+6,10, 2,4, nvgRGBA(0,0,0,128), nvgRGBA(0,0,0,0));
nvgBeginPath(vg);
nvgRect(vg, r0-2-10,-4-10,r1-r0+4+20,8+20);
nvgRect(vg, r0-2,-4,r1-r0+4,8);
nvgPathWinding(vg, NVG_HOLE);
nvgFillPaint(vg, paint);
nvgFill(vg);
// Center triangle
r = r0 - 6;
ax = cosf(120.0f/180.0f*NVG_PI) * r;
ay = sinf(120.0f/180.0f*NVG_PI) * r;
bx = cosf(-120.0f/180.0f*NVG_PI) * r;
by = sinf(-120.0f/180.0f*NVG_PI) * r;
nvgBeginPath(vg);
nvgMoveTo(vg, r,0);
nvgLineTo(vg, ax, ay);
nvgLineTo(vg, bx, by);
nvgClosePath(vg);
paint = nvgLinearGradient(vg, r, 0, ax, ay, nvgHSLA(hue, 1.0f, 0.5f, 255),
nvgRGBA(255, 255, 255, 255));
nvgFillPaint(vg, paint);
nvgFill(vg);
paint = nvgLinearGradient(vg, (r + ax) * 0.5f, (0 + ay) * 0.5f, bx, by,
nvgRGBA(0, 0, 0, 0), nvgRGBA(0, 0, 0, 255));
nvgFillPaint(vg, paint);
nvgFill(vg);
nvgStrokeColor(vg, nvgRGBA(0, 0, 0, 64));
nvgStroke(vg);
// Select circle on triangle
float sx = r*(1 - mWhite - mBlack) + ax*mWhite + bx*mBlack;
float sy = ay*mWhite + by*mBlack;
nvgStrokeWidth(vg, u);
nvgBeginPath(vg);
nvgCircle(vg, sx,sy,2*u);
nvgStrokeColor(vg, nvgRGBA(255,255,255,192));
nvgStroke(vg);
nvgRestore(vg);
nvgRestore(vg);
}
void drawGraph(struct NVGcontext* vg, float x, float y, float w, float h, float t)
{
struct NVGpaint bg;
float samples[6];
float sx[6], sy[6];
float dx = w/5.0f;
int i;
samples[0] = (1+sinf(t*1.2345f+cosf(t*0.33457f)*0.44f) )*0.5f;
samples[1] = (1+sinf(t*0.68363f+cosf(t*1.3f)*1.55f) )*0.5f;
samples[2] = (1+sinf(t*1.1642f+cosf(t*0.33457f)*1.24f) )*0.5f;
samples[3] = (1+sinf(t*0.56345f+cosf(t*1.63f)*0.14f) )*0.5f;
samples[4] = (1+sinf(t*1.6245f+cosf(t*0.254f)*0.3f) )*0.5f;
samples[5] = (1+sinf(t*0.345f+cosf(t*0.03f)*0.6f) )*0.5f;
for (i = 0; i < 6; i++) {
sx[i] = x+i*dx;
sy[i] = y+h*samples[i]*0.8f;
}
// Graph background
bg = nvgLinearGradient(vg, x,y,x,y+h, nvgRGBA(0,160,192,0), nvgRGBA(0,160,192,64) );
nvgBeginPath(vg);
nvgMoveTo(vg, sx[0], sy[0]);
for (i = 1; i < 6; i++)
nvgBezierTo(vg, sx[i-1]+dx*0.5f,sy[i-1], sx[i]-dx*0.5f,sy[i], sx[i],sy[i]);
nvgLineTo(vg, x+w, y+h);
nvgLineTo(vg, x, y+h);
nvgFillPaint(vg, bg);
nvgFill(vg);
// Graph line
nvgBeginPath(vg);
nvgMoveTo(vg, sx[0], sy[0]+2);
for (i = 1; i < 6; i++)
nvgBezierTo(vg, sx[i-1]+dx*0.5f,sy[i-1]+2, sx[i]-dx*0.5f,sy[i]+2, sx[i],sy[i]+2);
nvgStrokeColor(vg, nvgRGBA(0,0,0,32) );
nvgStrokeWidth(vg, 3.0f);
nvgStroke(vg);
nvgBeginPath(vg);
nvgMoveTo(vg, sx[0], sy[0]);
for (i = 1; i < 6; i++)
nvgBezierTo(vg, sx[i-1]+dx*0.5f,sy[i-1], sx[i]-dx*0.5f,sy[i], sx[i],sy[i]);
nvgStrokeColor(vg, nvgRGBA(0,160,192,255) );
nvgStrokeWidth(vg, 3.0f);
nvgStroke(vg);
// Graph sample pos
for (i = 0; i < 6; i++) {
bg = nvgRadialGradient(vg, sx[i],sy[i]+2, 3.0f,8.0f, nvgRGBA(0,0,0,32), nvgRGBA(0,0,0,0) );
nvgBeginPath(vg);
nvgRect(vg, sx[i]-10, sy[i]-10+2, 20,20);
nvgFillPaint(vg, bg);
nvgFill(vg);
}
nvgBeginPath(vg);
for (i = 0; i < 6; i++)
nvgCircle(vg, sx[i], sy[i], 4.0f);
nvgFillColor(vg, nvgRGBA(0,160,192,255) );
nvgFill(vg);
nvgBeginPath(vg);
for (i = 0; i < 6; i++)
nvgCircle(vg, sx[i], sy[i], 2.0f);
nvgFillColor(vg, nvgRGBA(220,220,220,255) );
nvgFill(vg);
nvgStrokeWidth(vg, 1.0f);
}
void VectorRenderer::circle(float x, float y, float radius) {
nvgCircle(nvg, x, y, radius);
}
static void
draw(NVGcontext *nvg, struct zr_command_queue *queue, int width, int height)
{
const struct zr_command *cmd;
glPushAttrib(GL_ENABLE_BIT|GL_COLOR_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
glEnable(GL_TEXTURE_2D);
nvgBeginFrame(nvg, width, height, ((float)width/(float)height));
zr_foreach_command(cmd, queue) {
switch (cmd->type) {
case ZR_COMMAND_NOP: break;
case ZR_COMMAND_SCISSOR: {
const struct zr_command_scissor *s = zr_command(scissor, cmd);
nvgScissor(nvg, s->x, s->y, s->w, s->h);
} break;
case ZR_COMMAND_LINE: {
const struct zr_command_line *l = zr_command(line, cmd);
nvgBeginPath(nvg);
nvgMoveTo(nvg, l->begin.x, l->begin.y);
nvgLineTo(nvg, l->end.x, l->end.y);
nvgFillColor(nvg, nvgRGBA(l->color.r, l->color.g, l->color.b, l->color.a));
nvgFill(nvg);
} break;
case ZR_COMMAND_CURVE: {
const struct zr_command_curve *q = zr_command(curve, cmd);
nvgBeginPath(nvg);
nvgMoveTo(nvg, q->begin.x, q->begin.y);
nvgBezierTo(nvg, q->ctrl[0].x, q->ctrl[0].y, q->ctrl[1].x, q->ctrl[1].y, q->end.x, q->end.y);
nvgStrokeColor(nvg, nvgRGBA(q->color.r, q->color.g, q->color.b, q->color.a));
nvgStroke(nvg);
} break;
case ZR_COMMAND_RECT: {
const struct zr_command_rect *r = zr_command(rect, cmd);
nvgBeginPath(nvg);
nvgRoundedRect(nvg, r->x, r->y, r->w, r->h, r->rounding);
nvgFillColor(nvg, nvgRGBA(r->color.r, r->color.g, r->color.b, r->color.a));
nvgFill(nvg);
} break;
case ZR_COMMAND_CIRCLE: {
const struct zr_command_circle *c = zr_command(circle, cmd);
nvgBeginPath(nvg);
nvgCircle(nvg, c->x + (c->w/2.0f), c->y + c->w/2.0f, c->w/2.0f);
nvgFillColor(nvg, nvgRGBA(c->color.r, c->color.g, c->color.b, c->color.a));
nvgFill(nvg);
} break;
case ZR_COMMAND_TRIANGLE: {
const struct zr_command_triangle *t = zr_command(triangle, cmd);
nvgBeginPath(nvg);
nvgMoveTo(nvg, t->a.x, t->a.y);
nvgLineTo(nvg, t->b.x, t->b.y);
nvgLineTo(nvg, t->c.x, t->c.y);
nvgLineTo(nvg, t->a.x, t->a.y);
nvgFillColor(nvg, nvgRGBA(t->color.r, t->color.g, t->color.b, t->color.a));
nvgFill(nvg);
} break;
case ZR_COMMAND_TEXT: {
const struct zr_command_text *t = zr_command(text, cmd);
nvgBeginPath(nvg);
nvgRoundedRect(nvg, t->x, t->y, t->w, t->h, 0);
nvgFillColor(nvg, nvgRGBA(t->background.r, t->background.g,
t->background.b, t->background.a));
nvgFill(nvg);
nvgBeginPath(nvg);
nvgFillColor(nvg, nvgRGBA(t->foreground.r, t->foreground.g,
t->foreground.b, t->foreground.a));
nvgTextAlign(nvg, NVG_ALIGN_MIDDLE);
nvgText(nvg, t->x, t->y + t->h * 0.5f, t->string, &t->string[t->length]);
nvgFill(nvg);
} break;
case ZR_COMMAND_IMAGE: {
const struct zr_command_image *i = zr_command(image, cmd);
NVGpaint imgpaint;
imgpaint = nvgImagePattern(nvg, i->x, i->y, i->w, i->h, 0, i->img.handle.id, 1.0f);
nvgBeginPath(nvg);
nvgRoundedRect(nvg, i->x, i->y, i->w, i->h, 0);
nvgFillPaint(nvg, imgpaint);
nvgFill(nvg);
} break;
case ZR_COMMAND_ARC:
default: break;
}
}
zr_command_queue_clear(queue);
nvgResetScissor(nvg);
nvgEndFrame(nvg);
glPopAttrib();
}
void Application::drawDebugUI() {
NVGcontext* nvg = context->nvgContext;
nvgBeginFrame(nvg, context->getScreenWidth(), context->getScreenHeight(),1.0f);
nvgResetScissor(nvg);
rootRegion.drawDebug(context.get());
Region* onTop = context->getOnTopRegion();
if (onTop != nullptr) {
onTop->drawDebug(context.get());
}
float cr = context->theme.CORNER_RADIUS;
if (context->getViewport().contains(context->cursorPosition)) {
nvgFontSize(nvg, 15);
nvgFontFaceId(nvg, context->getFontHandle(FontType::Bold));
/*
int alignment = 0;
if (context->cursorPosition.x < context->width() * 0.5f) {
alignment = NVG_ALIGN_LEFT;
} else {
alignment = NVG_ALIGN_RIGHT;
}
if (context->cursorPosition.y < context->height() * 0.5f) {
alignment |= NVG_ALIGN_TOP;
} else {
alignment |= NVG_ALIGN_BOTTOM;
}
std::string txt = MakeString() << std::setprecision(4) << " "
<< context->cursorPosition;
nvgTextAlign(nvg, alignment);
nvgFillColor(nvg, Color(0, 0, 0, 128));
if (context->hasFocus) {
drawText(nvg, context->cursorPosition, txt, FontStyle::Outline,
Color(255), Color(64, 64, 64));
}
*/
nvgTextAlign(nvg, NVG_ALIGN_TOP);
float yoffset = 5;
std::string txt = context->hasFocus ? "Window Has Focus" : "Window Lost Focus";
drawText(nvg, 5, yoffset, txt.c_str(), FontStyle::Outline, Color(255),
Color(64, 64, 64));
yoffset += 16;
if (context->mouseOverRegion != nullptr) {
txt = MakeString() << "Mouse Over ["
<< context->mouseOverRegion->name << "] "
<< context->cursorPosition;
drawText(nvg, 5, yoffset, txt.c_str(), FontStyle::Outline,
Color(255), Color(64, 64, 64));
yoffset += 16;
}
if (context->mouseDownRegion != nullptr) {
txt = MakeString() << "Mouse Down ["
<< context->mouseDownRegion->name << "] "
<< context->cursorDownPosition;
drawText(nvg, 5, yoffset, txt.c_str(), FontStyle::Outline,
Color(255), Color(64, 64, 64));
yoffset += 16;
}
if (context->mouseFocusRegion != nullptr) {
txt = MakeString() << "Mouse Focus ["
<< context->mouseFocusRegion->name << "]";
drawText(nvg, 5, yoffset, txt.c_str(), FontStyle::Outline,
Color(255), Color(64, 64, 64));
yoffset += 16;
}
if (context->onTopRegion != nullptr) {
txt =
MakeString() << "On Top [" << context->onTopRegion->name
<< ": "
<< (context->onTopRegion->isVisible() ?
"Visible" : "Hidden") << "]";
drawText(nvg, 5, yoffset, txt.c_str(), FontStyle::Outline,
Color(255), Color(64, 64, 64));
yoffset += 16;
}
if (context->leftMouseButton) {
txt = "Left Mouse Button Down";
drawText(nvg, 5, yoffset, txt.c_str(), FontStyle::Outline,
Color(255), Color(64, 64, 64));
yoffset += 16;
}
if (context->rightMouseButton) {
txt = "Right Mouse Button Down";
drawText(nvg, 5, yoffset, txt.c_str(), FontStyle::Outline,
Color(255), Color(64, 64, 64));
yoffset += 16;
}
if (context->hasFocus) {
nvgBeginPath(nvg);
nvgLineCap(nvg, NVG_ROUND);
nvgStrokeWidth(nvg, 2.0f);
nvgStrokeColor(nvg, Color(255, 255, 255, 255));
nvgMoveTo(nvg, context->cursorPosition.x - cr,
context->cursorPosition.y);
nvgLineTo(nvg, context->cursorPosition.x + cr,
context->cursorPosition.y);
nvgMoveTo(nvg, context->cursorPosition.x,
context->cursorPosition.y - cr);
nvgLineTo(nvg, context->cursorPosition.x,
context->cursorPosition.y + cr);
nvgStroke(nvg);
nvgBeginPath(nvg);
nvgFillColor(nvg, Color(255, 255, 255, 255));
nvgCircle(nvg, context->cursorPosition.x, context->cursorPosition.y,
3.0f);
nvgFill(nvg);
nvgBeginPath(nvg);
nvgFillColor(nvg, Color(255, 64, 32, 255));
nvgCircle(nvg, context->cursorPosition.x, context->cursorPosition.y,
1.5f);
nvgFill(nvg);
}
}
nvgEndFrame(nvg);
}
JNIEXPORT void JNICALL Java_firststep_internal_NVG_circle
(JNIEnv *e, jclass c, jlong ctx, jfloat cx, jfloat cy, jfloat r)
{
nvgCircle((NVGcontext*)ctx, cx, cy, r);
}
void drawColorwheel(struct NVGcontext* vg, float x, float y, float w, float h, float t)
{
int i;
float r0, r1, ax,ay, bx,by, cx,cy, aeps, r;
float hue = sinf(t * 0.12f);
struct NVGpaint paint;
nvgSave(vg);
/* nvgBeginPath(vg);
nvgRect(vg, x,y,w,h);
nvgFillColor(vg, nvgRGBA(255,0,0,128) );
nvgFill(vg);*/
cx = x + w*0.5f;
cy = y + h*0.5f;
r1 = (w < h ? w : h) * 0.5f - 5.0f;
r0 = r1 - 20.0f;
aeps = 0.5f / r1; // half a pixel arc length in radians (2pi cancels out).
for (i = 0; i < 6; i++)
{
float a0 = (float)i / 6.0f * NVG_PI * 2.0f - aeps;
float a1 = (float)(i+1.0f) / 6.0f * NVG_PI * 2.0f + aeps;
nvgBeginPath(vg);
nvgArc(vg, cx,cy, r0, a0, a1, NVG_CW);
nvgArc(vg, cx,cy, r1, a1, a0, NVG_CCW);
nvgClosePath(vg);
ax = cx + cosf(a0) * (r0+r1)*0.5f;
ay = cy + sinf(a0) * (r0+r1)*0.5f;
bx = cx + cosf(a1) * (r0+r1)*0.5f;
by = cy + sinf(a1) * (r0+r1)*0.5f;
paint = nvgLinearGradient(vg, ax,ay, bx,by, nvgHSLA(a0/(NVG_PI*2),1.0f,0.55f,255), nvgHSLA(a1/(NVG_PI*2),1.0f,0.55f,255) );
nvgFillPaint(vg, paint);
nvgFill(vg);
}
nvgBeginPath(vg);
nvgCircle(vg, cx,cy, r0-0.5f);
nvgCircle(vg, cx,cy, r1+0.5f);
nvgStrokeColor(vg, nvgRGBA(0,0,0,64) );
nvgStrokeWidth(vg, 1.0f);
nvgStroke(vg);
// Selector
nvgSave(vg);
nvgTranslate(vg, cx,cy);
nvgRotate(vg, hue*NVG_PI*2);
// Marker on
nvgStrokeWidth(vg, 2.0f);
nvgBeginPath(vg);
nvgRect(vg, r0-1,-3,r1-r0+2,6);
nvgStrokeColor(vg, nvgRGBA(255,255,255,192) );
nvgStroke(vg);
paint = nvgBoxGradient(vg, r0-3,-5,r1-r0+6,10, 2,4, nvgRGBA(0,0,0,128), nvgRGBA(0,0,0,0) );
nvgBeginPath(vg);
nvgRect(vg, r0-2-10,-4-10,r1-r0+4+20,8+20);
nvgRect(vg, r0-2,-4,r1-r0+4,8);
nvgPathWinding(vg, NVG_HOLE);
nvgFillPaint(vg, paint);
nvgFill(vg);
// Center triangle
r = r0 - 6;
ax = cosf(120.0f/180.0f*NVG_PI) * r;
ay = sinf(120.0f/180.0f*NVG_PI) * r;
bx = cosf(-120.0f/180.0f*NVG_PI) * r;
by = sinf(-120.0f/180.0f*NVG_PI) * r;
nvgBeginPath(vg);
nvgMoveTo(vg, r,0);
nvgLineTo(vg, ax,ay);
nvgLineTo(vg, bx,by);
nvgClosePath(vg);
paint = nvgLinearGradient(vg, r,0, ax,ay, nvgHSLA(hue,1.0f,0.5f,255), nvgRGBA(255,255,255,255) );
nvgFillPaint(vg, paint);
nvgFill(vg);
paint = nvgLinearGradient(vg, (r+ax)*0.5f,(0+ay)*0.5f, bx,by, nvgRGBA(0,0,0,0), nvgRGBA(0,0,0,255) );
nvgFillPaint(vg, paint);
nvgFill(vg);
nvgStrokeColor(vg, nvgRGBA(0,0,0,64) );
nvgStroke(vg);
// Select circle on triangle
ax = cosf(120.0f/180.0f*NVG_PI) * r*0.3f;
ay = sinf(120.0f/180.0f*NVG_PI) * r*0.4f;
nvgStrokeWidth(vg, 2.0f);
nvgBeginPath(vg);
nvgCircle(vg, ax,ay,5);
nvgStrokeColor(vg, nvgRGBA(255,255,255,192) );
nvgStroke(vg);
paint = nvgRadialGradient(vg, ax,ay, 7,9, nvgRGBA(0,0,0,64), nvgRGBA(0,0,0,0) );
nvgBeginPath(vg);
nvgRect(vg, ax-20,ay-20,40,40);
nvgCircle(vg, ax,ay,7);
nvgPathWinding(vg, NVG_HOLE);
nvgFillPaint(vg, paint);
nvgFill(vg);
nvgRestore(vg);
nvgRestore(vg);
}
void QNanoPainter::circle(float centerX, float centerY, float radius)
{
_checkAlignPixelsAdjust(¢erX, ¢erX);
nvgCircle(nvgCtx(), centerX, centerY, radius);
}
void drawClock(NVGcontext* vg, int screenWidth, int screenHeight) {
int clockRadius = (fmin(screenWidth, screenHeight) - 10) / 2;
NVGcolor baseColor = nvgRGB(145, 100, 0);
NVGcolor lighterColor = nvgRGB(200, 140, 0);
NVGcolor dblLighterColor = nvgRGB(255, 177, 0);
NVGcolor lightestColor = nvgRGB(255, 195, 60);
int widthLight = fmax(clockRadius * 0.0075, 1);
int widthMedium = fmax(clockRadius * 0.013, 1);
int widthHeavy = fmax(clockRadius * 0.025, 1);
time_t t = time(NULL);
struct tm localTime = *localtime(&t);
nvgTranslate(vg, screenWidth / 2, screenHeight / 2);
nvgStrokeColor(vg, baseColor);
// Frame
nvgSave(vg);
nvgBeginPath(vg);
nvgCircle(vg, 0, 0, clockRadius);
nvgStrokeWidth(vg, widthMedium);
nvgStroke(vg);
nvgBeginPath(vg);
nvgStrokeColor(vg, lighterColor);
for (int i = 0; i < 12; i++) {
nvgMoveTo(vg, 0, -clockRadius * 0.98);
nvgLineTo(vg, 0, -clockRadius * 0.90);
for (int j = 0; j < 5; j++) {
nvgRotate(vg, 2 * M_PI / 12 / 5);
nvgMoveTo(vg, 0, -clockRadius * 0.98);
nvgLineTo(vg, 0, -clockRadius * 0.95);
}
}
nvgStroke(vg);
nvgBeginPath(vg);
nvgFontFace(vg, "bold");
int digitsRadius = clockRadius * 0.79;
int digitLargeSize = clockRadius * 0.29;
int digitSmallSize = clockRadius * 0.2;
int clockTitleSize = clockRadius * 0.06;
nvgFillColor(vg, dblLighterColor);
char* nineTitle = "9";
nvgFontSize(vg, digitLargeSize);
nvgTranslate(vg, -digitsRadius, 0);
nvgRotate(vg, - 3 * 2 * M_PI / 12);
//nvgTranslate(vg, 0, -digitsRadius);
drawTextCenter(vg, nineTitle, 0, 0);
nvgFill(vg);
nvgFillColor(vg, lighterColor);
char* tenTitle = "10";
nvgFontSize(vg, digitSmallSize);
nvgTranslate(vg, 0, digitsRadius);
nvgRotate(vg, 2 * M_PI / 12);
nvgTranslate(vg, 0, -digitsRadius);
drawTextCenter(vg, tenTitle, 0, 0);
nvgFill(vg);
char* elevenTitle = "11";
nvgTranslate(vg, 0, digitsRadius);
nvgRotate(vg, 2 * M_PI / 12);
nvgTranslate(vg, 0, -digitsRadius);
drawTextCenter(vg, elevenTitle, 0, 0);
nvgFill(vg);
nvgFillColor(vg, dblLighterColor);
char* twelveTitle = "12";
nvgFontSize(vg, digitLargeSize);
nvgTranslate(vg, 0, digitsRadius);
nvgRotate(vg, 2 * M_PI / 12);
nvgTranslate(vg, 0, -digitsRadius);
drawTextCenter(vg, twelveTitle, 0, 0);
nvgFill(vg);
nvgFillColor(vg, lighterColor);
char* oneTitle = "1";
nvgFontSize(vg, digitSmallSize);
nvgTranslate(vg, 0, digitsRadius);
nvgRotate(vg, 2 * M_PI / 12);
nvgTranslate(vg, 0, -digitsRadius);
drawTextCenter(vg, oneTitle, 0, 0);
nvgFill(vg);
char* twoTitle = "2";
nvgTranslate(vg, 0, digitsRadius);
nvgRotate(vg, 2 * M_PI / 12);
nvgTranslate(vg, 0, -digitsRadius);
drawTextCenter(vg, twoTitle, 0, 0);
nvgFill(vg);
nvgFillColor(vg, dblLighterColor);
char* threeTitle = "3";
nvgFontSize(vg, digitLargeSize);
nvgTranslate(vg, 0, digitsRadius);
nvgRotate(vg, 2 * M_PI / 12);
nvgTranslate(vg, 0, -digitsRadius);
drawTextCenter(vg, threeTitle, 0, 0);
nvgFill(vg);
nvgFillColor(vg, lighterColor);
char* fourTitle = "4";
nvgFontSize(vg, digitSmallSize);
nvgTranslate(vg, 0, digitsRadius);
nvgRotate(vg, 2 * M_PI / 12 - M_PI);
nvgTranslate(vg, 0, digitsRadius);
drawTextCenter(vg, fourTitle, 0, 0);
nvgFill(vg);
char* fiveTitle = "5";
nvgTranslate(vg, 0, -digitsRadius);
nvgRotate(vg, 2 * M_PI / 12);
nvgTranslate(vg, 0, digitsRadius);
drawTextCenter(vg, fiveTitle, 0, 0);
nvgFill(vg);
nvgFillColor(vg, dblLighterColor);
char* sixTitle = "6";
nvgFontSize(vg, digitLargeSize);
nvgTranslate(vg, 0, -digitsRadius);
nvgRotate(vg, 2 * M_PI / 12);
nvgTranslate(vg, 0, digitsRadius);
drawTextCenter(vg, sixTitle, 0, 0);
nvgFill(vg);
nvgFillColor(vg, lighterColor);
char* sevenTitle = "7";
nvgFontSize(vg, digitSmallSize);
nvgTranslate(vg, 0, -digitsRadius);
nvgRotate(vg, 2 * M_PI / 12);
nvgTranslate(vg, 0, digitsRadius);
drawTextCenter(vg, sevenTitle, 0, 0);
nvgFill(vg);
char* eightTitle = "8";
nvgTranslate(vg, 0, -digitsRadius);
nvgRotate(vg, 2 * M_PI / 12);
nvgTranslate(vg, 0, digitsRadius);
drawTextCenter(vg, eightTitle, 0, 0);
nvgFill(vg);
nvgRestore(vg);
nvgSave(vg);
nvgFontFace(vg, "black");
char* clockTitle = "ALPHA";
nvgFontSize(vg, clockTitleSize);
nvgFillColor(vg, baseColor);
nvgTranslate(vg, 0, clockTitleSize);
nvgTextLetterSpacing(vg, clockTitleSize);
drawTextCenter(vg, clockTitle, 0, -2 * clockTitleSize);
nvgFill(vg);
nvgRestore(vg);
double secAngle = 2 * M_PI / 60 * localTime.tm_sec;
double minAngle = 2 * M_PI / 60 * localTime.tm_min + secAngle / 60;
double hrAngle = 2 * M_PI / 12 * localTime.tm_hour + minAngle / 60;
// Hour hand
nvgStrokeColor(vg, lighterColor);
nvgSave(vg);
nvgRotate(vg, hrAngle);
nvgBeginPath(vg);
nvgMoveTo(vg, 0, clockRadius * 0.02);
nvgLineTo(vg, 0, -clockRadius * 0.5);
nvgStrokeWidth(vg, widthHeavy);
nvgStroke(vg);
nvgRestore(vg);
// Minute hand
nvgStrokeColor(vg, lighterColor);
nvgSave(vg);
nvgRotate(vg, minAngle);
nvgBeginPath(vg);
nvgMoveTo(vg, 0, clockRadius * 0.04);
nvgLineTo(vg, 0, -clockRadius * 0.8);
nvgStrokeWidth(vg, widthMedium);
nvgStroke(vg);
nvgRestore(vg);
// Second hand
nvgStrokeColor(vg, lightestColor);
nvgSave(vg);
nvgRotate(vg, secAngle);
nvgBeginPath(vg);
nvgMoveTo(vg, 0, clockRadius * 0.05);
nvgLineTo(vg, 0, -clockRadius * 0.9);
nvgStrokeWidth(vg, widthLight);
nvgStroke(vg);
nvgRestore(vg);
}
