25template<std::
unsigned_
integral Pixel>
27 VDP& vdp_, std::span<const Pixel, 16> palFg_, std::span<const Pixel, 16> palBg_)
28 : vdp(vdp_), vram(vdp.getVRAM()), palFg(palFg_), palBg(palBg_)
32template<std::
unsigned_
integral Pixel>
36 assert(modeBase < 0x0C);
39template<std::
unsigned_
integral Pixel>
45 renderGraphic1(subspan<256>(buf), line);
48 renderText1(subspan<256>(buf), line);
51 renderMulti(subspan<256>(buf), line);
54 renderGraphic2(subspan<256>(buf), line);
57 renderGraphic2(subspan<256>(buf), line);
60 renderText2(subspan<512>(buf), line);
63 if (vdp.isMSX1VDP()) {
64 renderText1Q(subspan<256>(buf), line);
66 renderBlank (subspan<256>(buf));
70 if (vdp.isMSX1VDP()) {
71 renderMultiQ(subspan<256>(buf), line);
73 renderBlank (subspan<256>(buf));
77 if (vdp.isMSX1VDP()) {
78 renderBogus(subspan<256>(buf));
80 renderBlank(subspan<256>(buf));
87static inline __m128i select(__m128i a0, __m128i a1, __m128i mask)
89 return _mm_xor_si128(_mm_and_si128(_mm_xor_si128(a0, a1), mask), a0);
93template<std::
unsigned_
integral Pixel>
static inline void draw6(
96 pixelPtr[0] = (pattern & 0x80) ? fg : bg;
97 pixelPtr[1] = (pattern & 0x40) ? fg : bg;
98 pixelPtr[2] = (pattern & 0x20) ? fg : bg;
99 pixelPtr[3] = (pattern & 0x10) ? fg : bg;
100 pixelPtr[4] = (pattern & 0x08) ? fg : bg;
101 pixelPtr[5] = (pattern & 0x04) ? fg : bg;
105template<std::
unsigned_
integral Pixel>
static inline void draw8(
110 if constexpr (
sizeof(
Pixel) == 4) {
111 const __m128i m74 = _mm_set_epi32(0x10, 0x20, 0x40, 0x80);
112 const __m128i m30 = _mm_set_epi32(0x01, 0x02, 0x04, 0x08);
113 const __m128i zero = _mm_setzero_si128();
115 __m128i fg4 = _mm_set1_epi32(fg);
116 __m128i bg4 = _mm_set1_epi32(bg);
117 __m128i pat = _mm_set1_epi32(pattern);
119 __m128i b74 = _mm_cmpeq_epi32(_mm_and_si128(pat, m74), zero);
120 __m128i b30 = _mm_cmpeq_epi32(_mm_and_si128(pat, m30), zero);
122 auto* out =
reinterpret_cast<__m128i*
>(pixelPtr);
123 _mm_storeu_si128(out + 0, select(fg4, bg4, b74));
124 _mm_storeu_si128(out + 1, select(fg4, bg4, b30));
131 pixelPtr[0] = (pattern & 0x80) ? fg : bg;
132 pixelPtr[1] = (pattern & 0x40) ? fg : bg;
133 pixelPtr[2] = (pattern & 0x20) ? fg : bg;
134 pixelPtr[3] = (pattern & 0x10) ? fg : bg;
135 pixelPtr[4] = (pattern & 0x08) ? fg : bg;
136 pixelPtr[5] = (pattern & 0x04) ? fg : bg;
137 pixelPtr[6] = (pattern & 0x02) ? fg : bg;
138 pixelPtr[7] = (pattern & 0x01) ? fg : bg;
142template<std::
unsigned_
integral Pixel>
143void CharacterConverter<Pixel>::renderText1(std::span<Pixel, 256> buf,
int line)
145 Pixel fg = palFg[vdp.getForegroundColor()];
146 Pixel bg = palFg[vdp.getBackgroundColor()];
149 auto patternArea = vram.patternTable.getReadArea<256 * 8>(0);
150 auto l = (line + vdp.getVerticalScroll()) & 7;
155 unsigned nameStart = (line / 8) * 40;
156 unsigned nameEnd = nameStart + 40;
157 Pixel* __restrict pixelPtr = buf.data();
158 for (
auto name :
xrange(nameStart, nameEnd)) {
159 unsigned charCode = vram.nameTable.readNP((name + 0xC00) | (~0u << 12));
160 auto pattern = patternArea[l + charCode * 8];
161 draw6(pixelPtr, fg, bg, pattern);
165template<std::
unsigned_
integral Pixel>
166void CharacterConverter<Pixel>::renderText1Q(std::span<Pixel, 256> buf,
int line)
168 Pixel fg = palFg[vdp.getForegroundColor()];
169 Pixel bg = palFg[vdp.getBackgroundColor()];
171 unsigned patternBaseLine = (~0u << 13) | ((line + vdp.getVerticalScroll()) & 7);
176 unsigned nameStart = (line / 8) * 40;
177 unsigned nameEnd = nameStart + 40;
178 unsigned patternQuarter = (line & 0xC0) << 2;
179 Pixel* __restrict pixelPtr = buf.data();
180 for (
auto name :
xrange(nameStart, nameEnd)) {
181 unsigned charCode = vram.nameTable.readNP((name + 0xC00) | (~0u << 12));
182 unsigned patternNr = patternQuarter | charCode;
183 auto pattern = vram.patternTable.readNP(
184 patternBaseLine | (patternNr * 8));
185 draw6(pixelPtr, fg, bg, pattern);
189template<std::
unsigned_
integral Pixel>
190void CharacterConverter<Pixel>::renderText2(std::span<Pixel, 512> buf,
int line)
192 Pixel plainFg = palFg[vdp.getForegroundColor()];
193 Pixel plainBg = palFg[vdp.getBackgroundColor()];
194 Pixel blinkFg, blinkBg;
195 if (vdp.getBlinkState()) {
196 int fg = vdp.getBlinkForegroundColor();
197 blinkFg = palBg[fg ? fg : vdp.getBlinkBackgroundColor()];
198 blinkBg = palBg[vdp.getBlinkBackgroundColor()];
205 auto patternArea = vram.patternTable.getReadArea<256 * 8>(0);
206 auto l = (line + vdp.getVerticalScroll()) & 7;
208 unsigned colorStart = (line / 8) * (80 / 8);
209 unsigned nameStart = (line / 8) * 80;
210 Pixel* __restrict pixelPtr = buf.data();
211 for (
auto i :
xrange(80 / 8)) {
212 unsigned colorPattern = vram.colorTable.readNP(
213 (colorStart + i) | (~0u << 9));
214 auto nameArea = vram.nameTable.getReadArea<8>(
215 (nameStart + 8 * i) | (~0u << 12));
217 (colorPattern & 0x80) ? blinkFg : plainFg,
218 (colorPattern & 0x80) ? blinkBg : plainBg,
219 patternArea[l + nameArea[0] * 8]);
221 (colorPattern & 0x40) ? blinkFg : plainFg,
222 (colorPattern & 0x40) ? blinkBg : plainBg,
223 patternArea[l + nameArea[1] * 8]);
225 (colorPattern & 0x20) ? blinkFg : plainFg,
226 (colorPattern & 0x20) ? blinkBg : plainBg,
227 patternArea[l + nameArea[2] * 8]);
229 (colorPattern & 0x10) ? blinkFg : plainFg,
230 (colorPattern & 0x10) ? blinkBg : plainBg,
231 patternArea[l + nameArea[3] * 8]);
233 (colorPattern & 0x08) ? blinkFg : plainFg,
234 (colorPattern & 0x08) ? blinkBg : plainBg,
235 patternArea[l + nameArea[4] * 8]);
237 (colorPattern & 0x04) ? blinkFg : plainFg,
238 (colorPattern & 0x04) ? blinkBg : plainBg,
239 patternArea[l + nameArea[5] * 8]);
241 (colorPattern & 0x02) ? blinkFg : plainFg,
242 (colorPattern & 0x02) ? blinkBg : plainBg,
243 patternArea[l + nameArea[6] * 8]);
245 (colorPattern & 0x01) ? blinkFg : plainFg,
246 (colorPattern & 0x01) ? blinkBg : plainBg,
247 patternArea[l + nameArea[7] * 8]);
251template<std::
unsigned_
integral Pixel>
252std::span<const byte, 32> CharacterConverter<Pixel>::getNamePtr(
int line,
int scroll)
256 return vram.nameTable.getReadArea<32>(
257 ((line / 8) * 32) | ((scroll & 0x20) ? 0x8000 : 0));
259template<std::
unsigned_
integral Pixel>
260void CharacterConverter<Pixel>::renderGraphic1(std::span<Pixel, 256> buf,
int line)
262 auto patternArea = vram.patternTable.getReadArea<256 * 8>(0);
264 auto colorArea = vram.colorTable.getReadArea<256 / 8>(0);
266 int scroll = vdp.getHorizontalScrollHigh();
267 auto namePtr = getNamePtr(line, scroll);
268 Pixel* __restrict pixelPtr = buf.data();
270 auto charCode = namePtr[scroll & 0x1F];
271 auto pattern = patternArea[l + charCode * 8];
272 auto color = colorArea[charCode / 8];
273 Pixel fg = palFg[color >> 4];
274 Pixel bg = palFg[color & 0x0F];
275 draw8(pixelPtr, fg, bg, pattern);
276 if (!(++scroll & 0x1F)) namePtr = getNamePtr(line, scroll);
280template<std::
unsigned_
integral Pixel>
281void CharacterConverter<Pixel>::renderGraphic2(std::span<Pixel, 256> buf,
int line)
283 int quarter8 = (((line / 8) * 32) & ~0xFF) * 8;
284 int line7 = line & 7;
285 int scroll = vdp.getHorizontalScrollHigh();
286 auto namePtr = getNamePtr(line, scroll);
288 Pixel* __restrict pixelPtr = buf.data();
289 if (vram.colorTable .isContinuous((8 * 256) - 1) &&
290 vram.patternTable.isContinuous((8 * 256) - 1) &&
291 ((scroll & 0x1f) == 0)) {
295 auto patternArea = vram.patternTable.getReadArea<256 * 8>(quarter8);
296 auto colorArea = vram.colorTable .getReadArea<256 * 8>(quarter8);
297 for (
auto n :
xrange(32)) {
298 auto charCode8 = namePtr[n] * 8;
299 auto pattern = patternArea[line7 + charCode8];
300 auto color = colorArea [line7 + charCode8];
301 Pixel fg = palFg[color >> 4];
302 Pixel bg = palFg[color & 0x0F];
303 draw8(pixelPtr, fg, bg, pattern);
310 unsigned baseLine = (~0u << 13) | quarter8 | line7;
312 unsigned charCode8 = namePtr[scroll & 0x1F] * 8;
313 unsigned index = charCode8 | baseLine;
314 auto pattern = vram.patternTable.readNP(index);
315 auto color = vram.colorTable .readNP(index);
316 Pixel fg = palFg[color >> 4];
317 Pixel bg = palFg[color & 0x0F];
318 draw8(pixelPtr, fg, bg, pattern);
319 if (!(++scroll & 0x1F)) namePtr = getNamePtr(line, scroll);
324template<std::
unsigned_
integral Pixel>
325void CharacterConverter<Pixel>::renderMultiHelper(
326 Pixel* __restrict pixelPtr,
int line,
327 unsigned mask,
unsigned patternQuarter)
329 unsigned baseLine = mask | ((line / 4) & 7);
330 unsigned scroll = vdp.getHorizontalScrollHigh();
331 auto namePtr = getNamePtr(line, scroll);
333 unsigned patternNr = patternQuarter | namePtr[scroll & 0x1F];
334 unsigned color = vram.patternTable.readNP((patternNr * 8) | baseLine);
335 Pixel cl = palFg[color >> 4];
336 Pixel cr = palFg[color & 0x0F];
337 pixelPtr[0] = cl; pixelPtr[1] = cl;
338 pixelPtr[2] = cl; pixelPtr[3] = cl;
339 pixelPtr[4] = cr; pixelPtr[5] = cr;
340 pixelPtr[6] = cr; pixelPtr[7] = cr;
342 if (!(++scroll & 0x1F)) namePtr = getNamePtr(line, scroll);
345template<std::
unsigned_
integral Pixel>
346void CharacterConverter<Pixel>::renderMulti(std::span<Pixel, 256> buf,
int line)
348 unsigned mask = (~0u << 11);
349 renderMultiHelper(buf.data(), line, mask, 0);
352template<std::
unsigned_
integral Pixel>
353void CharacterConverter<Pixel>::renderMultiQ(
354 std::span<Pixel, 256> buf,
int line)
356 unsigned mask = (~0u << 13);
357 unsigned patternQuarter = (line * 4) & ~0xFF;
358 renderMultiHelper(buf.data(), line, mask, patternQuarter);
361template<std::
unsigned_
integral Pixel>
362void CharacterConverter<Pixel>::renderBogus(std::span<Pixel, 256> buf)
364 Pixel* __restrict pixelPtr = buf.data();
365 Pixel fg = palFg[vdp.getForegroundColor()];
366 Pixel bg = palFg[vdp.getBackgroundColor()];
367 auto draw = [&](
int n,
Pixel col) {
368 pixelPtr = std::fill_n(pixelPtr, n, col);
378template<std::
unsigned_
integral Pixel>
379void CharacterConverter<Pixel>::renderBlank(std::span<Pixel, 256> buf)
388template class CharacterConverter<uint16_t>;
390#if HAVE_32BPP || COMPONENT_GL
391template class CharacterConverter<uint32_t>;
void convertLine(std::span< Pixel > buf, int line)
Convert a line of V9938 VRAM to 256 or 512 host pixels.
CharacterConverter(VDP &vdp, std::span< const Pixel, 16 > palFg, std::span< const Pixel, 16 > palBg)
Create a new bitmap scanline converter.
void setDisplayMode(DisplayMode mode)
Select the display mode to use for scanline conversion.
Represents a VDP display mode.
constexpr byte getBase() const
Get the base display mode as an integer: M5..M1 combined.
Unified implementation of MSX Video Display Processors (VDPs).
This file implemented 3 utility functions:
constexpr void fill(ForwardRange &&range, const T &value)
constexpr void repeat(T n, Op op)
Repeat the given operation 'op' 'n' times.
constexpr auto xrange(T e)