File: ICanvas.h

package info (click to toggle)
lsp-plugins 1.2.5-1
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 91,856 kB
  • sloc: cpp: 427,831; xml: 57,779; makefile: 9,961; php: 1,005; sh: 18
file content (233 lines) | stat: -rw-r--r-- 7,748 bytes parent folder | download
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
/*
 * Copyright (C) 2020 Linux Studio Plugins Project <https://lsp-plug.in/>
 *           (C) 2020 Vladimir Sadovnikov <sadko4u@gmail.com>
 *
 * This file is part of lsp-plugin-fw
 * Created on: 24 нояб. 2020 г.
 *
 * lsp-plugin-fw is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * lsp-plugin-fw 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with lsp-plugin-fw. If not, see <https://www.gnu.org/licenses/>.
 */

#ifndef LSP_PLUG_IN_PLUG_FW_PLUG_ICANVAS_H_
#define LSP_PLUG_IN_PLUG_FW_PLUG_ICANVAS_H_

#ifndef LSP_PLUG_IN_PLUG_FW_PLUG_IMPL_H_
    #error "Use #include <lsp-plug.in/plug-fw/plug.h>"
#endif /* LSP_PLUG_IN_PLUG_FW_PLUG_IMPL_H_ */

#include <lsp-plug.in/plug-fw/version.h>
#include <lsp-plug.in/runtime/Color.h>

namespace lsp
{
    namespace plug
    {
        typedef struct canvas_data_t
        {
            size_t      nWidth;         // Width in pixels
            size_t      nHeight;        // Height in pixels
            size_t      nStride;        // Stride in bytes
            uint8_t    *pData;          // ARGB32 data, 4 bytes per pixel
        } canvas_data_t;

        /**
         * Canvas interface for drawing inline-display
         */
        class ICanvas
        {
            private:
                ICanvas & operator = (const ICanvas &);
                ICanvas(const ICanvas &);

            protected:
                canvas_data_t       sData;

            public:
                explicit ICanvas();
                virtual ~ICanvas();

            public:
                /** Get canvas width
                 *
                 * @return canvas width
                 */
                inline size_t width() const     { return sData.nWidth;      }

                /** Get canvas height
                 *
                 * @return canvas height
                 */
                inline size_t height() const    { return sData.nHeight;     }

                /** Return difference (in bytes) between two sequential rows
                 *
                 * @return stride between rows
                 */
                inline size_t stride() const    { return sData.nStride;     }

            public:
                /** Initialize canvas
                 *
                 * @param width canvas width
                 * @param height canvas height
                 */
                virtual bool init(size_t width, size_t height);

                /** Destroy canvas
                 *
                 *
                 */
                virtual void destroy();

                /** Set current color
                 *
                 * @param r red
                 * @param g green
                 * @param b blue
                 * @param a alpha
                 */
                virtual void set_color(float r, float g, float b, float a=1.0f);

                /** Set current color
                 *
                 * @param rgb RGB value
                 */
                virtual void set_color_rgb(uint32_t rgb);

                /** Set current color
                 *
                 * @param rgb RGB value
                 * @param a alpha value
                 */
                virtual void set_color_rgb(uint32_t rgb, float a);

                /** Set current color
                 *
                 * @param argb ARGB value
                 */
                virtual void set_color_argb(uint32_t argb);

                /** Set current color
                 *
                 * @param c color objet
                 */
                virtual void set_color(const Color &c);

                /** Set line width
                 *
                 * @param w width
                 */
                virtual void set_line_width(float w);

                /** Draw line
                 *
                 * @param x1 point 1 x coordinate
                 * @param y1 point 1 y coordinate
                 * @param x2 point 2 x coordinate
                 * @param y2 point 2 y coordinate
                 */
                virtual void line(float x1, float y1, float x2, float y2);

                /** Draw poly
                 *
                 * @param x x coordinates
                 * @param y y coordinates
                 * @param count number of dots
                 * @param stroke stroke color
                 * @param fill fill color
                 */
                virtual void draw_poly(float *x, float *y, size_t count, const Color &stroke, const Color &fill);

                /** Perform painting
                 *
                 */
                virtual void paint();

                /** Enable/disable anti-aliasing
                 *
                 * @param enable flag that enables anti-aliasing
                 * @return previous anti-aliasing state
                 */
                virtual bool set_anti_aliasing(bool enable);

                /** Draw lines
                 *
                 * @param x x coordinates
                 * @param y y coordinates
                 * @param count number of dots
                 */
                virtual void draw_lines(float *x, float *y, size_t count);

                /** Draw circle
                 *
                 * @param x circle center x
                 * @param y circle center y
                 * @param r radius
                 */
                virtual void circle(ssize_t x, ssize_t y, ssize_t r);

                /** Draw radial gradient
                 *
                 * @param x center of gradient x
                 * @param y center of gradient y
                 * @param c1 color 1
                 * @param c2 color 2
                 * @param r radius of gradient
                 */
                virtual void radial_gradient(ssize_t x, ssize_t y, const Color &c1, const Color &c2, ssize_t r);

                /**
                 * Draw another surface with applied alpha channel
                 * @param s source surface to draw
                 * @param x x-axis position
                 * @param y y-axis poisition
                 * @param sx x-axis scale
                 * @param sy y-axis scale
                 * @param a alpha
                 */
                virtual void draw_alpha(ICanvas *s, float x, float y, float sx, float sy, float a);

                /**
                 * Return raw buffer data for direct rendering
                 *
                 * @return raw buffer data
                 */
                virtual canvas_data_t *data();

                /**
                 * Return pointer to the beginning of the specified row
                 * @param row row number
                 */
                virtual void *row(size_t row);

                /**
                 * Start direct access to the surface
                 * @return pointer to surface buffer or NULL if error/not possible
                 */
                virtual void *start_direct();

                /**
                 * End direct access to the surface
                 */
                virtual void end_direct();

                /**
                 * Synchronize canvas drawing buffer
                 */
                virtual void sync();
        };
    }
} /* namespace lsp */

#endif /* LSP_PLUG_IN_PLUG_FW_PLUG_ICANVAS_H_ */