dev/Modules/FB/FB.h


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

/* -------------------------------------------

	Copyright (C) 2024, ELMH GROUP, all rights reserved.

------------------------------------------- */

#pragma once

#include <NewKit/Defines.h>

#define cg_init() Kernel::SizeT kCGCursor = 0

#define cg_color(R, G, B) RGB(R, G, B)

#define cg_get_clear_clr() cg_color(0xB2, 0xB2, 0xB2)

#define cg_fini() kCGCursor = 0

/// @brief Performs OR drawing on the framebuffer.
#define CGDrawBitMapInRegionA(_BitMp, _Height, _Width, _BaseX, _BaseY)       \
	kCGCursor = 0;                                                           \
                                                                             \
	for (Kernel::SizeT i = _BaseX; i < (_Height + _BaseX); ++i)              \
	{                                                                        \
		for (Kernel::SizeT u = _BaseY; u < (_Width + _BaseY); ++u)           \
		{                                                                    \
			*(((Kernel::UInt32*)(kHandoverHeader->f_GOP.f_The +              \
								 4 * kHandoverHeader->f_GOP.f_PixelPerLine * \
									 i +                                     \
								 4 * u))) |= (_BitMp)[kCGCursor];            \
                                                                             \
			++kCGCursor;                                                     \
		}                                                                    \
	}

/// @brief Draws a resource.
#define CGDrawBitMapInRegion(_BitMp, _Height, _Width, _BaseX, _BaseY)        \
	kCGCursor = 0;                                                           \
                                                                             \
	for (Kernel::SizeT i = _BaseX; i < (_Height + _BaseX); ++i)              \
	{                                                                        \
		for (Kernel::SizeT u = _BaseY; u < (_Width + _BaseY); ++u)           \
		{                                                                    \
			*(((Kernel::UInt32*)(kHandoverHeader->f_GOP.f_The +              \
								 4 * kHandoverHeader->f_GOP.f_PixelPerLine * \
									 i +                                     \
								 4 * u))) = (_BitMp)[kCGCursor];             \
                                                                             \
			++kCGCursor;                                                     \
		}                                                                    \
	}

#define CGDrawBitMapInRegionToRgn(_Rgn, _BitMp, _Height, _Width, _BaseX, _BaseY) \
	kCGCursor = 0;                                                               \
                                                                                 \
	for (Kernel::SizeT i = _BaseX; i < (_Height + _BaseX); ++i)                  \
	{                                                                            \
		for (Kernel::SizeT u = _BaseY; u < (_Width + _BaseY); ++u)               \
		{                                                                        \
			*(((Kernel::UInt32*)(_Rgn +                                          \
								 4 * kHandoverHeader->f_GOP.f_PixelPerLine *     \
									 i +                                         \
								 4 * u))) = (_BitMp)[kCGCursor];                 \
                                                                                 \
			++kCGCursor;                                                         \
		}                                                                        \
	}

/// @brief Cleans a resource.
#define CGClearRegion(_Height, _Width, _BaseX, _BaseY)                                \
                                                                                      \
	for (Kernel::SizeT i = _BaseX; i < _Height + _BaseX; ++i)                         \
	{                                                                                 \
		for (Kernel::SizeT u = _BaseY; u < _Width + _BaseY; ++u)                      \
		{                                                                             \
			*(((volatile Kernel::UInt32*)(kHandoverHeader->f_GOP.f_The +              \
										  4 * kHandoverHeader->f_GOP.f_PixelPerLine * \
											  i +                                     \
										  4 * u))) = cg_get_clear_clr();              \
		}                                                                             \
	}

/// @brief Draws inside a zone.
#define CGDrawInRegion(_Clr, _Height, _Width, _BaseX, _BaseY)                         \
                                                                                      \
	for (Kernel::SizeT x_base = _BaseX; x_base < (_Width + _BaseX); ++x_base)         \
	{                                                                                 \
		for (Kernel::SizeT y_base = _BaseY; y_base < (_Height + _BaseY); ++y_base)    \
		{                                                                             \
			*(((volatile Kernel::UInt32*)(kHandoverHeader->f_GOP.f_The +              \
										  4 * kHandoverHeader->f_GOP.f_PixelPerLine * \
											  x_base +                                \
										  4 * y_base))) = _Clr;                       \
		}                                                                             \
	}

/// @brief Draws inside a zone.
#define CGDrawInRegionToRgn(_Rgn, _Clr, _Height, _Width, _BaseX, _BaseY)              \
	kCGCursor = 0;                                                                    \
                                                                                      \
	for (Kernel::SizeT x_base = _BaseX; x_base < (_Width + _BaseX); ++x_base)         \
	{                                                                                 \
		for (Kernel::SizeT y_base = _BaseY; y_base < (_Height + _BaseY); ++y_base)    \
		{                                                                             \
			*(((volatile Kernel::UInt32*)(_Rgn +                                      \
										  4 * kHandoverHeader->f_GOP.f_PixelPerLine * \
											  x_base +                                \
										  4 * y_base))) = _Clr[kCGCursor];            \
			++kCGCursor;                                                              \
		}                                                                             \
	}

#define CGDrawInRegionToVideoRgn(_VideoRgn, _Clr, _Height, _Width, _BaseX, _BaseY)    \
	kCGCursor = 0;                                                                    \
                                                                                      \
	for (Kernel::SizeT x_base = _BaseX; x_base < (_Width + _BaseX); ++x_base)         \
	{                                                                                 \
		for (Kernel::SizeT y_base = _BaseY; y_base < (_Height + _BaseY); ++y_base)    \
		{                                                                             \
			*(((volatile Kernel::UInt32*)(_VideoRgn +                                 \
										  4 * kHandoverHeader->f_GOP.f_PixelPerLine * \
											  x_base +                                \
										  4 * y_base))) = _Clr;                       \
			++kCGCursor;                                                              \
		}                                                                             \
	}

#define CGDrawInRegionToVideoRgnA(_VideoRgn, _Clr, _Height, _Width, _BaseX, _BaseY)   \
	kCGCursor = 0;                                                                    \
                                                                                      \
	for (Kernel::SizeT x_base = _BaseX; x_base < (_Width + _BaseX); ++x_base)         \
	{                                                                                 \
		for (Kernel::SizeT y_base = _BaseY; y_base < (_Height + _BaseY); ++y_base)    \
		{                                                                             \
			*(((volatile Kernel::UInt32*)(_VideoRgn +                                 \
										  4 * kHandoverHeader->f_GOP.f_PixelPerLine * \
											  x_base +                                \
										  4 * y_base))) |= _Clr;                      \
			++kCGCursor;                                                              \
		}                                                                             \
	}

#define CGDrawInRegionA(_Clr, _Height, _Width, _BaseX, _BaseY)                        \
                                                                                      \
	for (Kernel::SizeT x_base = _BaseX; x_base < (_Width + _BaseX); ++x_base)         \
	{                                                                                 \
		for (Kernel::SizeT y_base = _BaseY; y_base < (_Height + _BaseY); ++y_base)    \
		{                                                                             \
			*(((volatile Kernel::UInt32*)(kHandoverHeader->f_GOP.f_The +              \
										  4 * kHandoverHeader->f_GOP.f_PixelPerLine * \
											  x_base +                                \
										  4 * y_base))) |= _Clr;                      \
		}                                                                             \
	}