#include 
#include 
#include 
// ...
struct
ColorState
{
uint8_t
r
,
g
,
b
;
double
duration
;
ColorState
(
)
{
}
ColorState
(
uint8_t
r
,
uint8_t
g
,
uint8_t
b
,
double
duration
)
:
r
(
r
)
,
g
(
g
)
,
b
(
b
)
,
duration
(
duration
)
{
assert
(
duration
>
0.0
)
;
}
}
;
class
ColorController
{
public
:
ColorController
(
const
std
::
vector

&
data
)
:
m_data
(
data
)
,
m_state
(
0U
)
,
m_time
(
0.0
)
,
m_cycle
(
0.0
)
{
for
(
const
auto
&
x
:
m_data
)
m_cycle
+=
x
.
duration
;
}
void
update
(
double
delta
)
{
m_time
+=
delta
;
#define _CC_NEXT_STATE(x) (((x)+1U)%m_data.size())
while
(
m_time
>=
m_data
[
m_state
]
.
duration
)
{
m_time
-=
m_data
[
m_state
]
.
duration
;
m_state
=
_CC_NEXT_STATE
(
m_state
)
;
}
const
auto
&
cur
=
m_data
[
m_state
]
;
const
auto
&
nxt
=
m_data
[
_CC_NEXT_STATE
(
m_state
)
]
;
const
double
t1
=
m_time
,
t2
=
cur
.
duration
-
m_time
;
#undef _CC_NEXT_STATE
m_r
=
static_cast

(
(
t2
*
cur
.
r
+
t1
*
nxt
.
r
)
/
cur
.
duration
)
;
m_g
=
static_cast

(
(
t2
*
cur
.
g
+
t1
*
nxt
.
g
)
/
cur
.
duration
)
;
m_b
=
static_cast

(
(
t2
*
cur
.
b
+
t1
*
nxt
.
b
)
/
cur
.
duration
)
;
}
uint8_t
get_r
(
)
const
{
return
m_r
;
}
uint8_t
get_g
(
)
const
{
return
m_g
;
}
uint8_t
get_b
(
)
const
{
return
m_b
;
}
COLORREF
get_color
(
)
const
{
return
RGB
(
m_r
,
m_g
,
m_b
)
;
}
private
:
size_t m_state
;
double
m_time
,
m_cycle
;
uint8_t
m_r
,
m_g
,
m_b
;
std
::
vector

m_data
;
}
;

// инициализация в отдельной функции (чтобы не засорять код в месте использования)
ColorController
create_my_cc
(
)
{
std
::
vector

data
(
6
)
;
data
[
0
]
=
ColorState
(
255
,
0
,
0
,
0.5
)
;
data
[
1
]
=
ColorState
(
0
,
0
,
0
,
0.3
)
;
data
[
2
]
=
ColorState
(
0
,
255
,
0
,
0.5
)
;
data
[
3
]
=
ColorState
(
0
,
0
,
0
,
0.3
)
;
data
[
4
]
=
ColorState
(
0
,
0
,
255
,
0.5
)
;
data
[
5
]
=
ColorState
(
0
,
0
,
0
,
0.3
)
;
return
ColorController
(
data
)
;
}
// инициализация на месте (производится один раз!)
auto
my_cc
=
create_my_cc
(
)
;
// использование
my_cc
.
update
(
dt
)
;
COLORREF color
=
my_cc
.
get_color
(
)