1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
/*
* SDL_PixelAccess.h, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#pragma once
#include "SDL_Extensions.h"
#include <SDL_endian.h>
#include <SDL_pixels.h>
// for accessing channels from pixel in format-independent way
//should be as fast as accessing via pointer at least for 3-4 bytes per pixel
namespace Channels
{
// channel not present in this format
struct channel_empty
{
static STRONG_INLINE void set(uint8_t*, uint8_t) {}
static STRONG_INLINE uint8_t get(const uint8_t *) { return 255;}
};
// channel which uses whole pixel
template<int offset>
struct channel_pixel
{
static STRONG_INLINE void set(uint8_t *ptr, uint8_t value)
{
ptr[offset] = value;
}
static STRONG_INLINE uint8_t get(const uint8_t *ptr)
{
return ptr[offset];
}
};
// channel which uses part of pixel
template <int bits, int mask, int shift>
struct channel_subpx
{
static void STRONG_INLINE set(uint8_t *ptr, uint8_t value)
{
auto * const pixel = (uint16_t *)ptr;
uint8_t subpx = value >> (8 - bits);
*pixel = (*pixel & ~mask) | ((subpx << shift) & mask );
}
static uint8_t STRONG_INLINE get(const uint8_t *ptr)
{
uint8_t subpx = (*((uint16_t *)ptr) & mask) >> shift;
return (subpx << (8 - bits)) | (subpx >> (2*bits - 8));
}
};
template<int bpp>
struct px
{
static channel_empty r;
static channel_empty g;
static channel_empty b;
static channel_empty a;
};
#ifdef VCMI_ENDIAN_BIG
template<>
struct px<4>
{
static channel_pixel<1> r;
static channel_pixel<2> g;
static channel_pixel<3> b;
static channel_pixel<0> a;
};
template<>
struct px<3>
{
static channel_pixel<0> r;
static channel_pixel<1> g;
static channel_pixel<2> b;
static channel_empty a;
};
#else
template<>
struct px<4>
{
static channel_pixel<2> r;
static channel_pixel<1> g;
static channel_pixel<0> b;
static channel_pixel<3> a;
};
template<>
struct px<3>
{
static channel_pixel<2> r;
static channel_pixel<1> g;
static channel_pixel<0> b;
static channel_empty a;
};
#endif
}
template<int bpp>
struct ColorPutter
{
static STRONG_INLINE void PutColor(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B);
static STRONG_INLINE void PutColor(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A);
static STRONG_INLINE void PutColorAlphaSwitch(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A);
static STRONG_INLINE void PutColorAlpha(uint8_t *&ptr, const SDL_Color & Color);
};
template<int bpp>
STRONG_INLINE void ColorPutter<bpp>::PutColorAlpha(uint8_t *&ptr, const SDL_Color & Color)
{
PutColor(ptr, Color.r, Color.g, Color.b, Color.a);
}
template<int bpp>
STRONG_INLINE void ColorPutter<bpp>::PutColorAlphaSwitch(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A)
{
switch (A)
{
case 0:
return;
case 255:
PutColor(ptr, R, G, B);
return;
case 128: // optimized
PutColor(ptr,
((uint16_t)R + Channels::px<bpp>::r.get(ptr)) >> 1,
((uint16_t)G + Channels::px<bpp>::g.get(ptr)) >> 1,
((uint16_t)B + Channels::px<bpp>::b.get(ptr)) >> 1);
return;
default:
PutColor(ptr, R, G, B, A);
return;
}
}
template<int bpp>
STRONG_INLINE void ColorPutter<bpp>::PutColor(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B, const uint8_t & A)
{
PutColor(ptr, ((((uint32_t)R - (uint32_t)Channels::px<bpp>::r.get(ptr))*(uint32_t)A) >> 8 ) + (uint32_t)Channels::px<bpp>::r.get(ptr),
((((uint32_t)G - (uint32_t)Channels::px<bpp>::g.get(ptr))*(uint32_t)A) >> 8 ) + (uint32_t)Channels::px<bpp>::g.get(ptr),
((((uint32_t)B - (uint32_t)Channels::px<bpp>::b.get(ptr))*(uint32_t)A) >> 8 ) + (uint32_t)Channels::px<bpp>::b.get(ptr));
}
template<int bpp>
STRONG_INLINE void ColorPutter<bpp>::PutColor(uint8_t *&ptr, const uint8_t & R, const uint8_t & G, const uint8_t & B)
{
Channels::px<bpp>::r.set(ptr, R);
Channels::px<bpp>::g.set(ptr, G);
Channels::px<bpp>::b.set(ptr, B);
Channels::px<bpp>::a.set(ptr, 255);
}
|
