ReactOS  r76032
gradient.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS kernel
4  * PURPOSE: GDI Driver Gradient Functions
5  * FILE: win32ss/gdi/eng/gradient.c
6  * PROGRAMER: Thomas Weidenmueller
7  */
8 
9 #include <win32k.h>
10 
11 #define NDEBUG
12 #include <debug.h>
13 
14 /* MACROS *********************************************************************/
15 
16 const LONG LINC[2] = {-1, 1};
17 
18 #define VERTEX(n) (pVertex + gt->n)
19 #define COMPAREVERTEX(a, b) ((a)->x == (b)->x && (a)->y == (b)->y)
20 
21 #define VCMPCLR(a,b,c,color) (a->color != b->color || a->color != c->color)
22 #define VCMPCLRS(a,b,c) \
23  !(!VCMPCLR(a,b,c,Red) || !VCMPCLR(a,b,c,Green) || !VCMPCLR(a,b,c,Blue))
24 
25 /* Horizontal/Vertical gradients */
26 #define HVINITCOL(Col, id) \
27  c[id] = v1->Col >> 8; \
28  dc[id] = abs((v2->Col >> 8) - c[id]); \
29  ec[id] = -(dy >> 1); \
30  ic[id] = LINC[(v2->Col >> 8) > c[id]]
31 #define HVSTEPCOL(id) \
32  ec[id] += dc[id]; \
33  while(ec[id] > 0) \
34  { \
35  c[id] += ic[id]; \
36  ec[id] -= dy; \
37  }
38 
39 /* FUNCTIONS ******************************************************************/
40 
41 BOOL
44  IN SURFOBJ *psoDest,
45  IN CLIPOBJ *pco,
46  IN XLATEOBJ *pxlo,
49  IN PGRADIENT_RECT gRect,
52  IN BOOL Horizontal)
53 {
54  SURFOBJ *psoOutput;
55  TRIVERTEX *v1, *v2;
56  RECTL rcGradient, rcSG;
57  RECT_ENUM RectEnum;
58  BOOL EnumMore;
59  ULONG i;
60  POINTL Translate;
61  INTENG_ENTER_LEAVE EnterLeave;
62  LONG y, dy, c[3], dc[3], ec[3], ic[3];
63 
64  v1 = (pVertex + gRect->UpperLeft);
65  v2 = (pVertex + gRect->LowerRight);
66 
67  rcGradient.left = min(v1->x, v2->x);
68  rcGradient.right = max(v1->x, v2->x);
69  rcGradient.top = min(v1->y, v2->y);
70  rcGradient.bottom = max(v1->y, v2->y);
71  rcSG = rcGradient;
72  RECTL_vOffsetRect(&rcSG, pptlDitherOrg->x, pptlDitherOrg->y);
73 
74  if(Horizontal)
75  {
76  dy = abs(rcGradient.right - rcGradient.left);
77  }
78  else
79  {
80  dy = abs(rcGradient.bottom - rcGradient.top);
81  }
82 
83  if(!IntEngEnter(&EnterLeave, psoDest, &rcSG, FALSE, &Translate, &psoOutput))
84  {
85  return FALSE;
86  }
87 
88  if((v1->Red != v2->Red || v1->Green != v2->Green || v1->Blue != v2->Blue) && dy > 1)
89  {
91  do
92  {
94  ULONG Color;
95 
96  if (Horizontal)
97  {
98  EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
99  for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= rcSG.bottom; i++)
100  {
101  if (RECTL_bIntersectRect(&FillRect, &RectEnum.arcl[i], &rcSG))
102  {
103  HVINITCOL(Red, 0);
104  HVINITCOL(Green, 1);
105  HVINITCOL(Blue, 2);
106 
107  for (y = rcSG.left; y < FillRect.right; y++)
108  {
109  if (y >= FillRect.left)
110  {
111  Color = XLATEOBJ_iXlate(pxlo, RGB(c[0], c[1], c[2]));
113  psoOutput, y + Translate.x, FillRect.top + Translate.y, FillRect.bottom + Translate.y, Color);
114  }
115  HVSTEPCOL(0);
116  HVSTEPCOL(1);
117  HVSTEPCOL(2);
118  }
119  }
120  }
121 
122  continue;
123  }
124 
125  /* vertical */
126  EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
127  for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= rcSG.bottom; i++)
128  {
129  if (RECTL_bIntersectRect(&FillRect, &RectEnum.arcl[i], &rcSG))
130  {
131  HVINITCOL(Red, 0);
132  HVINITCOL(Green, 1);
133  HVINITCOL(Blue, 2);
134 
135  for (y = rcSG.top; y < FillRect.bottom; y++)
136  {
137  if (y >= FillRect.top)
138  {
139  Color = XLATEOBJ_iXlate(pxlo, RGB(c[0], c[1], c[2]));
141  FillRect.left + Translate.x,
142  FillRect.right + Translate.x,
143  y + Translate.y,
144  Color);
145  }
146  HVSTEPCOL(0);
147  HVSTEPCOL(1);
148  HVSTEPCOL(2);
149  }
150  }
151  }
152 
153  }
154  while (EnumMore);
155 
156  return IntEngLeave(&EnterLeave);
157  }
158 
159  /* rectangle has only one color, no calculation required */
161  do
162  {
163  RECTL FillRect;
164  ULONG Color = XLATEOBJ_iXlate(pxlo, RGB(v1->Red >> 8, v1->Green >> 8, v1->Blue >> 8));
165 
166  EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
167  for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= rcSG.bottom; i++)
168  {
169  if (RECTL_bIntersectRect(&FillRect, &RectEnum.arcl[i], &rcSG))
170  {
171  for (; FillRect.top < FillRect.bottom; FillRect.top++)
172  {
174  FillRect.left + Translate.x,
175  FillRect.right + Translate.x,
176  FillRect.top + Translate.y,
177  Color);
178  }
179  }
180  }
181  }
182  while (EnumMore);
183 
184  return IntEngLeave(&EnterLeave);
185 }
186 
187 /* Fill triangle with solid color */
188 #define S_FILLLINE(linefrom,lineto) \
189  if(sx[lineto] < sx[linefrom]) \
190  DibFunctionsForBitmapFormat[psoOutput->iBitmapFormat].DIB_HLine(psoOutput, max(sx[lineto], FillRect.left), min(sx[linefrom], FillRect.right), sy, Color); \
191  else \
192  DibFunctionsForBitmapFormat[psoOutput->iBitmapFormat].DIB_HLine(psoOutput, max(sx[linefrom], FillRect.left), min(sx[lineto], FillRect.right), sy, Color);
193 
194 #define S_DOLINE(a,b,line) \
195  ex[line] += dx[line]; \
196  while(ex[line] > 0 && x[line] != destx[line]) \
197  { \
198  x[line] += incx[line]; \
199  sx[line] += incx[line]; \
200  ex[line] -= dy[line]; \
201  }
202 
203 #define S_GOLINE(a,b,line) \
204  if(y >= a->y && y <= b->y) \
205  {
206 
207 #define S_ENDLINE(a,b,line) \
208  }
209 
210 #define S_INITLINE(a,b,line) \
211  x[line] = a->x; \
212  sx[line] = a->x + pptlDitherOrg->x; \
213  dx[line] = abs(b->x - a->x); \
214  dy[line] = abs(b->y - a->y); \
215  incx[line] = LINC[b->x > a->x]; \
216  ex[line] = -(dy[line]>>1); \
217  destx[line] = b->x
218 
219 /* Fill triangle with gradient */
220 #define INITCOL(a,b,line,col,id) \
221  c[line][id] = a->col >> 8; \
222  dc[line][id] = abs((b->col >> 8) - c[line][id]); \
223  ec[line][id] = -(dy[line]>>1); \
224  ic[line][id] = LINC[(b->col >> 8) > c[line][id]]
225 
226 #define STEPCOL(a,b,line,col,id) \
227  ec[line][id] += dc[line][id]; \
228  while(ec[line][id] > 0) \
229  { \
230  c[line][id] += ic[line][id]; \
231  ec[line][id] -= dy[line]; \
232  }
233 
234 #define FINITCOL(linefrom,lineto,colid) \
235  gc[colid] = c[linefrom][colid]; \
236  gd[colid] = abs(c[lineto][colid] - gc[colid]); \
237  ge[colid] = -(gx >> 1); \
238  gi[colid] = LINC[c[lineto][colid] > gc[colid]]
239 
240 #define FDOCOL(linefrom,lineto,colid) \
241  ge[colid] += gd[colid]; \
242  while(ge[colid] > 0) \
243  { \
244  gc[colid] += gi[colid]; \
245  ge[colid] -= gx; \
246  }
247 
248 #define FILLLINE(linefrom,lineto) \
249  gx = abs(sx[lineto] - sx[linefrom]); \
250  gxi = LINC[sx[linefrom] < sx[lineto]]; \
251  FINITCOL(linefrom, lineto, 0); \
252  FINITCOL(linefrom, lineto, 1); \
253  FINITCOL(linefrom, lineto, 2); \
254  for(g = sx[linefrom]; g != sx[lineto]; g += gxi) \
255  { \
256  if(InY && g >= FillRect.left && g < FillRect.right) \
257  { \
258  Color = XLATEOBJ_iXlate(pxlo, RGB(gc[0], gc[1], gc[2])); \
259  DibFunctionsForBitmapFormat[psoOutput->iBitmapFormat].DIB_PutPixel(psoOutput, g, sy, Color); \
260  } \
261  FDOCOL(linefrom, lineto, 0); \
262  FDOCOL(linefrom, lineto, 1); \
263  FDOCOL(linefrom, lineto, 2); \
264  }
265 
266 #define DOLINE(a,b,line) \
267  STEPCOL(a, b, line, Red, 0); \
268  STEPCOL(a, b, line, Green, 1); \
269  STEPCOL(a, b, line, Blue, 2); \
270  ex[line] += dx[line]; \
271  while(ex[line] > 0 && x[line] != destx[line]) \
272  { \
273  x[line] += incx[line]; \
274  sx[line] += incx[line]; \
275  ex[line] -= dy[line]; \
276  }
277 
278 #define GOLINE(a,b,line) \
279  if(y >= a->y && y <= b->y) \
280  {
281 
282 #define ENDLINE(a,b,line) \
283  }
284 
285 #define INITLINE(a,b,line) \
286  x[line] = a->x; \
287  sx[line] = a->x + pptlDitherOrg->x; \
288  dx[line] = abs(b->x - a->x); \
289  dy[line] = max(abs(b->y - a->y),1); \
290  incx[line] = LINC[b->x > a->x]; \
291  ex[line] = -(dy[line]>>1); \
292  destx[line] = b->x
293 
294 #define DOINIT(a, b, line) \
295  INITLINE(a, b, line); \
296  INITCOL(a, b, line, Red, 0); \
297  INITCOL(a, b, line, Green, 1); \
298  INITCOL(a, b, line, Blue, 2);
299 
300 #define SMALLER(a,b) (a->y < b->y) || (a->y == b->y && a->x < b->x)
301 
302 #define SWAP(a,b,c) c = a;\
303  a = b;\
304  b = c
305 
306 #define NLINES 3
307 
308 BOOL
309 FASTCALL
311  IN SURFOBJ *psoDest,
312  IN CLIPOBJ *pco,
313  IN XLATEOBJ *pxlo,
315  IN ULONG nVertex,
316  IN PGRADIENT_TRIANGLE gTriangle,
319 {
320  SURFOBJ *psoOutput;
321  PTRIVERTEX v1, v2, v3;
322  RECT_ENUM RectEnum;
323  BOOL EnumMore;
324  ULONG i;
325  POINTL Translate;
326  INTENG_ENTER_LEAVE EnterLeave;
327  RECTL FillRect = { 0, 0, 0, 0 };
328  ULONG Color;
329 
330  BOOL sx[NLINES];
331  LONG x[NLINES], dx[NLINES], dy[NLINES], incx[NLINES], ex[NLINES], destx[NLINES];
332  LONG c[NLINES][3], dc[NLINES][3], ec[NLINES][3], ic[NLINES][3]; /* colors on lines */
333  LONG g, gx, gxi, gc[3], gd[3], ge[3], gi[3]; /* colors in triangle */
334  LONG sy, y, bt;
335 
336  v1 = (pVertex + gTriangle->Vertex1);
337  v2 = (pVertex + gTriangle->Vertex2);
338  v3 = (pVertex + gTriangle->Vertex3);
339 
340  /* bubble sort */
341  if (SMALLER(v2, v1))
342  {
343  TRIVERTEX *t;
344  SWAP(v1, v2, t);
345  }
346 
347  if (SMALLER(v3, v2))
348  {
349  TRIVERTEX *t;
350  SWAP(v2, v3, t);
351  if (SMALLER(v2, v1))
352  {
353  SWAP(v1, v2, t);
354  }
355  }
356 
357  DPRINT("Triangle: (%i,%i) (%i,%i) (%i,%i)\n", v1->x, v1->y, v2->x, v2->y, v3->x, v3->y);
358  /* FIXME: commented out because of an endless loop - fix triangles first */
359  DPRINT("FIXME: IntEngGradientFillTriangle is broken\n");
360 
361  if (!IntEngEnter(&EnterLeave, psoDest, &FillRect, FALSE, &Translate, &psoOutput))
362  {
363  return FALSE;
364  }
365 
366  if (VCMPCLRS(v1, v2, v3))
367  {
369  do
370  {
371  EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
372  for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= prclExtents->bottom; i++)
373  {
374  if (RECTL_bIntersectRect(&FillRect, &RectEnum.arcl[i], prclExtents))
375  {
376  BOOL InY;
377 
378  DOINIT(v1, v3, 0);
379  DOINIT(v1, v2, 1);
380  DOINIT(v2, v3, 2);
381 
382  y = v1->y;
383  sy = v1->y + pptlDitherOrg->y;
384  bt = min(v3->y + pptlDitherOrg->y, FillRect.bottom);
385 
386  while (sy < bt)
387  {
388  InY = !(sy < FillRect.top || sy >= FillRect.bottom);
389  GOLINE(v1, v3, 0);
390  DOLINE(v1, v3, 0);
391  ENDLINE(v1, v3, 0);
392 
393  GOLINE(v1, v2, 1);
394  DOLINE(v1, v2, 1);
395  FILLLINE(0, 1);
396  ENDLINE(v1, v2, 1);
397 
398  GOLINE(v2, v3, 2);
399  DOLINE(v2, v3, 2);
400  FILLLINE(0, 2);
401  ENDLINE(23, v3, 2);
402 
403  y++;
404  sy++;
405  }
406  }
407  }
408  } while (EnumMore);
409 
410  return IntEngLeave(&EnterLeave);
411  }
412 
413  /* fill triangle with one solid color */
414 
415  Color = XLATEOBJ_iXlate(pxlo, RGB(v1->Red >> 8, v1->Green >> 8, v1->Blue >> 8));
417  do
418  {
419  EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
420  for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= prclExtents->bottom; i++)
421  {
422  if (RECTL_bIntersectRect(&FillRect, &RectEnum.arcl[i], prclExtents))
423  {
424  S_INITLINE(v1, v3, 0);
425  S_INITLINE(v1, v2, 1);
426  S_INITLINE(v2, v3, 2);
427 
428  y = v1->y;
429  sy = v1->y + pptlDitherOrg->y;
430  bt = min(v3->y + pptlDitherOrg->y, FillRect.bottom);
431 
432  while (sy < bt)
433  {
434  S_GOLINE(v1, v3, 0);
435  S_DOLINE(v1, v3, 0);
436  S_ENDLINE(v1, v3, 0);
437 
438  S_GOLINE(v1, v2, 1);
439  S_DOLINE(v1, v2, 1);
440  S_FILLLINE(0, 1);
441  S_ENDLINE(v1, v2, 1);
442 
443  S_GOLINE(v2, v3, 2);
444  S_DOLINE(v2, v3, 2);
445  S_FILLLINE(0, 2);
446  S_ENDLINE(23, v3, 2);
447 
448  y++;
449  sy++;
450  }
451  }
452  }
453  } while (EnumMore);
454 
455  return IntEngLeave(&EnterLeave);
456 }
457 
458 
459 static
460 BOOL
462 {
463  if(COMPAREVERTEX(VERTEX(Vertex1), VERTEX(Vertex2)))
464  return TRUE;
465  if(COMPAREVERTEX(VERTEX(Vertex1), VERTEX(Vertex3)))
466  return TRUE;
467  if(COMPAREVERTEX(VERTEX(Vertex2), VERTEX(Vertex3)))
468  return TRUE;
469  return FALSE;
470 }
471 
472 
473 BOOL
474 APIENTRY
476  _Inout_ SURFOBJ *psoDest,
477  _In_ CLIPOBJ *pco,
481  _In_ PVOID pMesh,
482  _In_ ULONG nMesh,
485  _In_ ULONG ulMode)
486 {
487  ULONG i;
488  BOOL ret = FALSE;
489 
490  /* Check for NULL clip object */
491  if (pco == NULL)
492  {
493  /* Use the trivial one instead */
494  pco = (CLIPOBJ *)&gxcoTrivial;//.coClient;
495  }
496 
497  switch(ulMode)
498  {
499  case GRADIENT_FILL_RECT_H:
500  case GRADIENT_FILL_RECT_V:
501  {
502  PGRADIENT_RECT gr = (PGRADIENT_RECT)pMesh;
503  for (i = 0; i < nMesh; i++, gr++)
504  {
505  if (!IntEngGradientFillRect(psoDest,
506  pco,
507  pxlo,
508  pVertex,
509  nVertex,
510  gr,
511  prclExtents,
512  pptlDitherOrg,
513  (ulMode == GRADIENT_FILL_RECT_H)))
514  {
515  break;
516  }
517  }
518  ret = TRUE;
519  break;
520  }
521  case GRADIENT_FILL_TRIANGLE:
522  {
524  for (i = 0; i < nMesh; i++, gt++)
525  {
526  if (IntEngIsNULLTriangle(pVertex, gt))
527  {
528  /* skip empty triangles */
529  continue;
530  }
531  if (!IntEngGradientFillTriangle(psoDest,
532  pco,
533  pxlo,
534  pVertex,
535  nVertex,
536  gt,
537  prclExtents,
538  pptlDitherOrg))
539  {
540  break;
541  }
542  }
543  ret = TRUE;
544  break;
545  }
546  }
547 
548  return ret;
549 }
550 
551 BOOL
552 APIENTRY
554  IN SURFOBJ *psoDest,
555  IN CLIPOBJ *pco,
556  IN XLATEOBJ *pxlo,
558  IN ULONG nVertex,
559  IN PVOID pMesh,
560  IN ULONG nMesh,
563  IN ULONG ulMode)
564 {
565  BOOL Ret;
566  SURFACE *psurf;
567  ASSERT(psoDest);
568 
569  psurf = CONTAINING_RECORD(psoDest, SURFACE, SurfObj);
570  ASSERT(psurf);
571 
572  if (psurf->flags & HOOK_GRADIENTFILL)
573  {
574  Ret = GDIDEVFUNCS(psoDest).GradientFill(psoDest,
575  pco,
576  pxlo,
577  pVertex,
578  nVertex,
579  pMesh,
580  nMesh,
581  prclExtents,
582  pptlDitherOrg,
583  ulMode);
584  }
585  else
586  {
587  Ret = EngGradientFill(psoDest,
588  pco,
589  pxlo,
590  pVertex,
591  nVertex,
592  pMesh,
593  nMesh,
594  prclExtents,
595  pptlDitherOrg,
596  ulMode);
597  }
598 
599  return Ret;
600 }
DWORD *typedef PVOID
Definition: winlogon.h:52
#define S_ENDLINE(a, b, line)
Definition: gradient.c:207
#define abs(i)
Definition: fconv.c:206
Definition: bl.h:202
_In_ CLIPOBJ _In_opt_ XLATEOBJ _In_ TRIVERTEX _In_ ULONG _In_ PVOID _In_ ULONG nMesh
Definition: winddi.h:3649
#define HVSTEPCOL(id)
Definition: gradient.c:31
#define IN
Definition: typedefs.h:38
#define max(a, b)
Definition: svc.c:63
_In_ CLIPOBJ _In_opt_ XLATEOBJ _In_ TRIVERTEX _In_ ULONG _In_ PVOID pMesh
Definition: winddi.h:3649
#define TRUE
Definition: types.h:120
Definition: comerr.c:44
XCLIPOBJ gxcoTrivial
Definition: bitblt.c:15
#define FILLLINE(linefrom, lineto)
Definition: gradient.c:248
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel)?(CompletionRoutine!=NULL):TRUE)
#define SWAP(a, b, c)
Definition: gradient.c:302
#define DOINIT(a, b, line)
Definition: gradient.c:294
#define COMPAREVERTEX(a, b)
Definition: gradient.c:19
long bottom
Definition: polytest.cpp:53
GLdouble GLdouble t
Definition: gl.h:2047
#define VERTEX(n)
Definition: gradient.c:18
HDC dc
Definition: cylfrac.c:34
Definition: bl.h:199
ULONG iBitmapFormat
Definition: winddi.h:1215
#define FASTCALL
Definition: nt_native.h:50
_In_ CLIPOBJ _In_opt_ XLATEOBJ _In_ TRIVERTEX _In_ ULONG _In_ PVOID _In_ ULONG _In_ RECTL * prclExtents
Definition: winddi.h:3649
#define _In_opt_
Definition: no_sal2.h:213
struct Color Color
LONG y
Definition: windef.h:343
#define HOOK_GRADIENTFILL
Definition: winddi.h:1436
long right
Definition: polytest.cpp:53
GLenum GLclampf GLint i
Definition: glfuncs.h:14
LONG y
Definition: wingdi.h:2762
FORCEINLINE VOID RECTL_vOffsetRect(_Inout_ RECTL *prcl, _In_ INT cx, _In_ INT cy)
Definition: rect.h:31
#define FALSE
Definition: types.h:117
long LONG
Definition: pedump.c:60
#define CD_RIGHTDOWN
Definition: winddi.h:1320
long top
Definition: polytest.cpp:53
#define VCMPCLRS(a, b, c)
Definition: gradient.c:22
struct _GRADIENT_RECT * PGRADIENT_RECT
#define APIENTRY
Definition: nt_native.h:48
smooth NULL
Definition: ftsmooth.c:557
#define S_FILLLINE(linefrom, lineto)
Definition: gradient.c:188
#define CT_RECTANGLES
Definition: winddi.h:1317
void DPRINT(...)
Definition: polytest.cpp:61
BOOL APIENTRY IntEngGradientFill(IN SURFOBJ *psoDest, IN CLIPOBJ *pco, IN XLATEOBJ *pxlo, IN TRIVERTEX *pVertex, IN ULONG nVertex, IN PVOID pMesh, IN ULONG nMesh, IN RECTL *prclExtents, IN POINTL *pptlDitherOrg, IN ULONG ulMode)
Definition: gradient.c:553
long left
Definition: polytest.cpp:53
#define HVINITCOL(Col, id)
Definition: gradient.c:26
#define S_GOLINE(a, b, line)
Definition: gradient.c:203
_In_ CLIPOBJ _In_opt_ XLATEOBJ _In_ TRIVERTEX * pVertex
Definition: winddi.h:3649
GLboolean GLboolean g
Definition: glext.h:6204
unsigned int BOOL
Definition: ntddk_ex.h:94
ENGAPI ULONG APIENTRY CLIPOBJ_cEnumStart(_Inout_ CLIPOBJ *pco, _In_ BOOL bAll, _In_ ULONG iType, _In_ ULONG iDirection, _In_ ULONG cLimit)
Definition: clip.c:255
LONG x
Definition: wingdi.h:2761
#define GDIDEVFUNCS(SurfObj)
Definition: surface.h:99
#define RGB(r, g, b)
Definition: wingdi.h:2917
const GLubyte * c
Definition: glext.h:8905
LONG x
Definition: windef.h:342
#define _Inout_
Definition: no_sal2.h:244
BOOL APIENTRY IntEngEnter(PINTENG_ENTER_LEAVE EnterLeave, SURFOBJ *psoDest, RECTL *DestRect, BOOL ReadOnly, POINTL *Translate, SURFOBJ **ppsoOutput)
Definition: engmisc.c:15
#define NLINES
Definition: gradient.c:306
Definition: bl.h:200
int ret
#define ENDLINE(a, b, line)
Definition: gradient.c:282
PFN_DIB_VLine DIB_VLine
Definition: dib.h:48
_In_ SURFOBJ _In_ CLIPOBJ * pco
Definition: winddi.h:3414
const LONG LINC[2]
Definition: gradient.c:16
GLfloat GLfloat GLfloat GLfloat v3
Definition: glext.h:6064
PFN_DIB_HLine DIB_HLine
Definition: dib.h:47
#define _In_
Definition: no_sal2.h:204
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
BOOL FASTCALL IntEngGradientFillTriangle(IN SURFOBJ *psoDest, IN CLIPOBJ *pco, IN XLATEOBJ *pxlo, IN TRIVERTEX *pVertex, IN ULONG nVertex, IN PGRADIENT_TRIANGLE gTriangle, IN RECTL *prclExtents, IN POINTL *pptlDitherOrg)
Definition: gradient.c:310
_In_ CLIPOBJ _In_opt_ XLATEOBJ _In_ TRIVERTEX _In_ ULONG _In_ PVOID _In_ ULONG _In_ RECTL _In_ POINTL _In_ ULONG ulMode
Definition: winddi.h:3649
#define DOLINE(a, b, line)
Definition: gradient.c:266
DIB_FUNCTIONS DibFunctionsForBitmapFormat[]
Definition: dib.c:20
INT INT dy
Definition: msvc.h:65
#define S_INITLINE(a, b, line)
Definition: gradient.c:210
FLONG flags
Definition: surface.h:10
#define min(a, b)
Definition: monoChain.cc:55
BOOL FASTCALL IntEngGradientFillRect(IN SURFOBJ *psoDest, IN CLIPOBJ *pco, IN XLATEOBJ *pxlo, IN TRIVERTEX *pVertex, IN ULONG nVertex, IN PGRADIENT_RECT gRect, IN RECTL *prclExtents, IN POINTL *pptlDitherOrg, IN BOOL Horizontal)
Definition: gradient.c:43
BOOL FASTCALL RECTL_bIntersectRect(_Out_ RECTL *prclDst, _In_ const RECTL *prcl1, _In_ const RECTL *prcl2)
Definition: rect.c:55
COLOR16 Red
Definition: wingdi.h:2763
COLOR16 Blue
Definition: wingdi.h:2765
unsigned int ULONG
Definition: retypes.h:1
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:259
_In_ CLIPOBJ _In_opt_ XLATEOBJ _In_ TRIVERTEX _In_ ULONG nVertex
Definition: winddi.h:3649
_In_ CLIPOBJ _In_opt_ XLATEOBJ _In_ TRIVERTEX _In_ ULONG _In_ PVOID _In_ ULONG _In_ RECTL _In_ POINTL * pptlDitherOrg
Definition: winddi.h:3649
COLOR16 Green
Definition: wingdi.h:2764
BOOL APIENTRY IntEngLeave(PINTENG_ENTER_LEAVE EnterLeave)
Definition: engmisc.c:162
#define S_DOLINE(a, b, line)
Definition: gradient.c:194
ENGAPI ULONG APIENTRY XLATEOBJ_iXlate(_In_ XLATEOBJ *pxlo, _In_ ULONG iColor)
Definition: xlateobj.c:664
int WINAPI FillRect(HDC, LPCRECT, HBRUSH)
static BOOL IntEngIsNULLTriangle(TRIVERTEX *pVertex, GRADIENT_TRIANGLE *gt)
Definition: gradient.c:461
INT INT y
Definition: msvc.h:62
BOOL APIENTRY EngGradientFill(_Inout_ SURFOBJ *psoDest, _In_ CLIPOBJ *pco, _In_opt_ XLATEOBJ *pxlo, _In_ TRIVERTEX *pVertex, _In_ ULONG nVertex, _In_ PVOID pMesh, _In_ ULONG nMesh, _In_ RECTL *prclExtents, _In_ POINTL *pptlDitherOrg, _In_ ULONG ulMode)
Definition: gradient.c:475
GLfloat GLfloat v1
Definition: glext.h:6062
#define GOLINE(a, b, line)
Definition: gradient.c:278
ENGAPI BOOL APIENTRY CLIPOBJ_bEnum(_In_ CLIPOBJ *pco, _In_ ULONG cj, _Out_bytecap_(cj) ULONG *pul)
Definition: clip.c:319
struct _GRADIENT_TRIANGLE * PGRADIENT_TRIANGLE
_In_ SURFOBJ _In_ CLIPOBJ _In_opt_ XLATEOBJ * pxlo
Definition: winddi.h:3414
#define SMALLER(a, b)
Definition: gradient.c:300
INT x
Definition: msvc.h:62
INT dx
Definition: msvc.h:65