oliczanie kątowe casu wskazówek

SYSTEMTIME stCzas;
double     dGodzina,
           dMinuta,
           dSekunda;
int        iGodzina,
           iMinuta,
           iSekunda;
//
bmp->Canvas->Pen->Color=tcTlo;
bmp->Canvas->Brush->Color=tcTlo;
bmp->Canvas->Ellipse(cx-d/2,cy-d/2,cx+d/2,cy+d/2);  /* Tarcza zegara*/
//
GetLocalTime(&stCzas);
iGodzina=stCzas.wHour;
iMinuta=stCzas.wMinute;
iSekunda=stCzas.wSecond;
//
  if((iMinuta == 0) && (iSekunda == 0))
   PlaySound("WAVE_KUK",HInstance,SND_ASYNC | SND_RESOURCE);
//
dSekunda=iSekunda*2*M_PI/60.0;
dMinuta=iMinuta*2*M_PI/60.0;
dGodzina=(iGodzina*2*M_PI/12.0)+(dMinuta/12);
//
bmp->Canvas->Pen->Color=tcKropki;
bmp->Canvas->Brush->Color=tcKropki;  /* Kropki */
  for(int i=0;i<12;i++)
  {
   double dia,
          pv=(i*(double)(2*M_PI/12.0)),
          px=cx+((d/2-5)*(double)sin(pv)),
          py=cy-((d/2-5)*(double)cos(pv));
   ((i%3) == 0) ? dia=3.5 : dia=2.5;  /* Wielkosc kropek */
   bmp->Canvas->Ellipse((int)(px-dia),(int)(py-dia),(int)(px+dia),(int)(py+dia));
  }
//
bmp->Canvas->Pen->Color=tcWskazowki;  /* Wskazowki */
bmp->Canvas->Pen->Width=2;
int mx=(int)(cx+50*sin(dMinuta)),  /* Dlugosc wskazowki */
    my=(int)(cy-50*cos(dMinuta));  /* Dlugosc wskazowki */
bmp->Canvas->MoveTo(cx,cy);
bmp->Canvas->LineTo(mx,my);
//
bmp->Canvas->Pen->Width=3;
int hx=(int)(cx+30*sin(dGodzina)),
    hy=(int)(cy-30*cos(dGodzina));
bmp->Canvas->MoveTo(cx,cy);
bmp->Canvas->LineTo(hx,hy);
//
bmp->Canvas->Pen->Width=1;
int sx=(int)(cx+55*sin(dSekunda)),
    sy=(int)(cy-55*cos(dSekunda));
bmp->Canvas->MoveTo(cx,cy);
bmp->Canvas->LineTo(sx,sy);
//

// czasWzgledemZero w sekundach

KAT_SEKUND = (czasWzgledemZero % 60)  / 60.0 * 2*PI  
KAT_MINUT = (czasWzgledemZero % 3600)  / 3600 * 2*PI
KAT_GODZIN = (czasWzgledemZero % 43200)  / 43200 * 2*PI

struct ClockHandsInRadians {
    double hours;
    double minutes;
    double seconds;
};

ClockHandsInRadians makeSharpClockHandsFrom(std::tm t)
{
    std::mktime(&t);
    return {
        2 * std::numbers::pi / 12 * (t.tm_hour % 12),
        2 * std::numbers::pi / 60 * (t.tm_min % 60),
        2 * std::numbers::pi / 60 * (t.tm_sec % 60),
    };
}

ClockHandsInRadians makeSmoothClockHandsFrom(std::tm t)
{
    std::mktime(&t);
    return {
        2 * std::numbers::pi / (60 * 12) * ((t.tm_hour * 60 + t.tm_min) % (60 * 12)),
        2 * std::numbers::pi / 3600 * ((t.tm_min * 60 + t.tm_sec) % 3600),
        2 * std::numbers::pi / 60 * t.tm_sec,
    };
}

#include <cmath>
#include <memory>
#include <chrono>
#include <numbers> 

#include <raylib.h>

const Color DARKGREEN_DIM {0, 117, 44, 96};
const Color DARKBLUE_DIM {0, 82, 172, 128};
const Color MAGENTA_DIM {255, 0, 255, 64};

struct Point2D
	{
	double x;
	double y;

	Vector2 toVector2() const
		{
		return Vector2(static_cast<double>(x), static_cast<double>(y));
		}
	};

class Clock
	{
	struct Hand
		{
		Point2D position;
		Point2D guide;
		double angle;
		double length;
		double resolution;
		};

	struct Hands
		{
		Hand hours;
		Hand minutes;
		Hand seconds;
		};

	struct Ticks
		{
		std::vector<Point2D> major {};
		std::vector<Point2D> minor {};
		};

	const Point2D face_origin;
	const double radius;
	std::chrono::microseconds time;
	Ticks ticks;
	Hands hands;

	void calculateHands()
		{
		for(auto hand : {&hands.hours, &hands.minutes, &hands.seconds})
			{
			hand->angle = (std::numbers::pi / hand->resolution) * (time.count() / 1e6);
			hand->position.x = face_origin.x + (radius * hand->length * std::sin(hand->angle));
			hand->position.y = face_origin.y + (radius * hand->length * -std::cos(hand->angle));
			hand->guide.x = face_origin.x + (radius * std::sin(hand->angle));
			hand->guide.y = face_origin.y + (radius * -std::cos(hand->angle));
			}
		}

	void calculateTicks()
		{
		for(double angle {0}; angle <= 2 * std::numbers::pi; angle += std::numbers::pi / 6)
			{
			ticks.major.emplace_back(face_origin.x + (radius * std::sin(angle)), face_origin.y + (radius * -std::cos(angle)));
			}

		for(double angle {0}; angle <= 2 * std::numbers::pi; angle += std::numbers::pi / 30)
			{
			ticks.minor.emplace_back(face_origin.x + (radius * std::sin(angle)), face_origin.y + (radius * -std::cos(angle)));
			}
		}

	void draw() const
		{
		DrawCircleLines(face_origin.x, face_origin.y, radius, RAYWHITE);
		DrawCircleLines(face_origin.x, face_origin.y, radius + 1, RAYWHITE);
		drawTicks();
		drawHands();
		}

	void drawTicks() const
		{
		for(auto& tick : ticks.major)
			{
			DrawCircle(tick.x, tick.y, 5, GOLD);
			}

		for(auto& tick : ticks.minor)
			{
			DrawCircle(tick.x, tick.y, 2.5, GOLD);
			}
		}

	void drawHands() const
		{
		DrawLineEx(face_origin.toVector2(), hands.hours.position.toVector2(), 7, DARKGREEN);
		DrawLineEx(face_origin.toVector2(), hands.hours.guide.toVector2(), 1, DARKGREEN_DIM);
		DrawLineEx(face_origin.toVector2(), hands.minutes.position.toVector2(), 5, DARKBLUE);
		DrawLineEx(face_origin.toVector2(), hands.minutes.guide.toVector2(), 1, DARKBLUE_DIM);
		DrawLineEx(face_origin.toVector2(), hands.seconds.position.toVector2(), 3, MAGENTA);
		DrawLineEx(face_origin.toVector2(), hands.seconds.guide.toVector2(), 1, MAGENTA_DIM);
		}

	public:
	Clock(Point2D origin, double radius) : face_origin(origin), radius(radius)
		{
		calculateTicks();
		hands.hours.length = 0.6;
		hands.hours.resolution = 21600;
		hands.minutes.length = 0.85;
		hands.minutes.resolution = 1800;
		hands.seconds.length = 0.98;
		hands.seconds.resolution = 30;
		}

	void refresh()
		{
		using namespace std::chrono;
		time = floor<microseconds>(zoned_time{current_zone(), system_clock::now()}.get_local_time() - floor<days>(zoned_time{current_zone(), system_clock::now()}.get_local_time()));
		calculateHands();
		draw();
		}
	};

int main()
	{
	SetConfigFlags(FLAG_WINDOW_RESIZABLE);
	InitWindow(50, 50, "raylib - clock");
	SetWindowSize(GetMonitorWidth(0) / 2, GetMonitorHeight(0) / 2);
	SetWindowPosition(GetMonitorWidth(0) / 4, GetMonitorHeight(0) / 4);

	std::unique_ptr<Clock> clock = std::make_unique<Clock>(Point2D(GetScreenWidth() / 2.0, GetScreenHeight() / 2.0), GetScreenHeight() * 0.42);

	while(!WindowShouldClose())
		{
		BeginDrawing();
		ClearBackground(BLACK);
		if(IsWindowResized())
			{
			clock = std::make_unique<Clock>(Point2D(GetScreenWidth() / 2.0, GetScreenHeight() / 2.0), (GetScreenHeight() > GetScreenWidth() ? GetScreenWidth() : GetScreenHeight())  * 0.42);
			}
		if(clock.get() != nullptr) clock->refresh();
		EndDrawing();
		}
	CloseWindow();
	return 0;
	}