File: NstVideoRenderer.hpp

package info (click to toggle)
libretro-nestopia 1.52.0%2B20230102.gitcb1e24e-1
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 12,960 kB
  • sloc: cpp: 107,513; xml: 27,221; python: 1,329; ansic: 772; makefile: 634
file content (400 lines) | stat: -rw-r--r-- 8,429 bytes parent folder | download | duplicates (4)
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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
////////////////////////////////////////////////////////////////////////////////////////
//
// Nestopia - NES/Famicom emulator written in C++
//
// Copyright (C) 2003-2008 Martin Freij
//
// This file is part of Nestopia.
//
// Nestopia is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Nestopia is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Nestopia; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
////////////////////////////////////////////////////////////////////////////////////////

#ifndef NST_VIDEO_RENDERER_H
#define NST_VIDEO_RENDERER_H

#include <cstdlib>
#include "api/NstApiVideo.hpp"
#include "NstVideoScreen.hpp"

#ifdef NST_PRAGMA_ONCE
#pragma once
#endif

namespace Nes
{
	namespace Core
	{
		namespace Video
		{
			class Renderer
			{
				typedef Api::Video::RenderState RenderState;
				typedef Api::Video::Decoder Decoder;
				typedef Screen Input;

			public:

				Renderer();
				~Renderer();

				enum PaletteType
				{
					PALETTE_YUV,
					PALETTE_PC10,
					PALETTE_VS1,
					PALETTE_VS2,
					PALETTE_VS3,
					PALETTE_VS4,
					PALETTE_CUSTOM
				};

				enum
				{
					WIDTH = Input::WIDTH,
					HEIGHT = Input::HEIGHT,
					PIXELS = Input::PIXELS,
					PALETTE = Input::PALETTE,
					NST_DEFAULT_PALETTE = PALETTE_YUV
				};

				Result SetState(const RenderState&);
				Result GetState(RenderState&) const;
				Result SetHue(int);
				void Blit(Output&,Input&,uint);

				Result SetDecoder(const Decoder&);

				Result SetPaletteType(PaletteType);
				Result LoadCustomPalette(const byte (*)[3],bool);
				void   ResetCustomPalette();

				void EnableFieldMerging(bool);
				void EnableForcedFieldMerging(bool);

				typedef byte PaletteEntries[PALETTE][3];

				const PaletteEntries& GetPalette();

			private:

				void UpdateFilter(Input&);

				class Palette
				{
				public:

					Palette();
					~Palette();

					Result SetType(PaletteType);
					Result LoadCustom(const byte (*)[3],bool);
					uint   SaveCustom(byte (*)[3],bool) const;
					bool   ResetCustom();
					void   Update(int,int,int,int);
					Result SetDecoder(const Decoder&);

					inline const PaletteEntries& Get() const;

				private:

					struct Constants
					{
						static const double pi;
						static const double deg;
						static const double levels[2][4];
					};

					struct Custom
					{
						inline Custom();
						inline ~Custom();

						bool EnableEmphasis(bool);

						byte palette[64][3];
						byte (*emphasis)[64][3];
					};

					void Generate(int,int,int,int);
					void Build(int,int,int,int);

					static void GenerateEmphasis(uint,double,double&,double&,double&);
					static void Store(const double (&)[3],byte (&)[3]);

					PaletteType type;
					Custom* custom;
					Decoder decoder;
					byte palette[64*8][3];

					static const byte pc10Palette[64][3];
					static const byte vsPalette[4][64][3];

				public:

					PaletteType GetType() const
					{
						return type;
					}

					const Decoder& GetDecoder() const
					{
						return decoder;
					}

					bool HasCustomEmphasis() const
					{
						return custom && custom->emphasis;
					}
				};

				class FilterNone;
				class FilterNtsc;

				#ifndef NST_NO_SCALEX
				class FilterScaleX;
				#endif

				#ifndef NST_NO_HQ2X
				class FilterHqX;
				#endif

				#ifndef NST_NO_2XSAI
				class Filter2xSaI;
				#endif
				
				#ifndef NST_NO_XBR
				class FilterxBR;
				#endif

				class NST_NO_VTABLE Filter
				{
					struct Format
					{
						explicit Format(const RenderState&);

						dword masks[3];
						byte shifts[3];
						const byte bpp;
					};

				protected:

					explicit Filter(const RenderState&);

				public:

					virtual ~Filter() {}

					virtual void Blit(const Input&,const Output&,uint) = 0;
					virtual void Transform(const byte (&)[PALETTE][3],Input::Palette&) const;

					const Format format;
					
					uint bgColor;
				};

				struct State
				{
					State();

					enum
					{
						UPDATE_PALETTE = 0x1,
						UPDATE_FILTER = 0x2,
						UPDATE_NTSC = 0x4,
						UPDATE_FILTER_STATE = 0x8,
						FIELD_MERGING_USER = 0x1,
						FIELD_MERGING_FORCED = 0x2
					};

					word width;
					word height;
					byte filter;
					byte update;
					byte fieldMerging;
					schar brightness;
					schar saturation;
					schar hue;
					schar contrast;
					schar sharpness;
					schar resolution;
					schar bleed;
					schar artifacts;
					schar fringing;
					schar blendPixels;
					schar xbr_corner_rounding;
					RenderState::Bits::Mask mask;
				};

				Result SetLevel(schar&,int,uint=State::UPDATE_PALETTE|State::UPDATE_FILTER);

				Filter* filter;
				State state;
				Palette palette;

			public:

				uint bgColor;
				
				Result SetBrightness(int brightness)
				{
					return SetLevel( state.brightness, brightness );
				}

				Result SetSaturation(int saturation)
				{
					return SetLevel( state.saturation, saturation );
				}

				Result SetContrast(int contrast)
				{
					return SetLevel( state.contrast, contrast );
				}

				Result SetSharpness(int sharpness)
				{
					return SetLevel( state.sharpness, sharpness, State::UPDATE_NTSC );
				}

				Result SetColorResolution(int resolution)
				{
					return SetLevel( state.resolution, resolution, State::UPDATE_NTSC );
				}

				Result SetColorBleed(int bleed)
				{
					return SetLevel( state.bleed, bleed, State::UPDATE_NTSC );
				}

				Result SetColorArtifacts(int artifacts)
				{
					return SetLevel( state.artifacts, artifacts, State::UPDATE_NTSC );
				}

				Result SetColorFringing(int fringing)
				{
					return SetLevel( state.fringing, fringing, State::UPDATE_NTSC );
				}
				
				Result SetBlend(bool correct)
				{
					return SetLevel( state.blendPixels, correct, State::UPDATE_FILTER_STATE );
				}

				Result SetCornerRounding(int mode)
				{
					return SetLevel( state.xbr_corner_rounding, mode, State::UPDATE_FILTER_STATE );
				}

				/**
				 * Workaround for black screen issue if this flag is set while the emulator is loading settings
				 */
				void ClearFilterUpdateFlag()
				{
					//state.update ^= State::UPDATE_FILTER_STATE;
					state.update = 1;
				}

				int GetBlend() const
				{
					return state.blendPixels;
				}

				int GetCornerRounding() const
				{
					return state.xbr_corner_rounding;
				}

				int GetBrightness() const
				{
					return state.brightness;
				}

				int GetSaturation() const
				{
					return state.saturation;
				}

				int GetContrast() const
				{
					return state.contrast;
				}

				int GetSharpness() const
				{
					return state.sharpness;
				}

				int GetColorResolution() const
				{
					return state.resolution;
				}

				int GetColorBleed() const
				{
					return state.bleed;
				}

				int GetColorArtifacts() const
				{
					return state.artifacts;
				}

				int GetColorFringing() const
				{
					return state.fringing;
				}

				int GetHue() const
				{
					return state.hue;
				}

				bool IsFieldMergingEnabled() const
				{
					return state.fieldMerging & uint(State::FIELD_MERGING_USER);
				}

				PaletteType GetPaletteType() const
				{
					return palette.GetType();
				}

				bool HasCustomPaletteEmphasis() const
				{
					return palette.HasCustomEmphasis();
				}

				uint SaveCustomPalette(byte (*colors)[3],bool emphasis) const
				{
					return palette.SaveCustom( colors, emphasis );
				}

				const Decoder& GetDecoder() const
				{
					return palette.GetDecoder();
				}

				bool IsReady() const
				{
					return filter;
				}
			};
		}
	}
}

#endif