-
-
Notifications
You must be signed in to change notification settings - Fork 1
/
graphics.d
2465 lines (2333 loc) · 163 KB
/
graphics.d
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
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Copyright 2020 - 2021 Michael D. Parker
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
module bindbc.sfml.graphics;
import bindbc.sfml.config;
static if(bindSFMLGraphics):
import bindbc.sfml.system;
import bindbc.sfml.window;
// Graphics/Types.h
struct sfCircleShape;
struct sfConvexShape;
struct sfFont;
struct sfImage;
struct sfShader;
struct sfRectangleShape;
struct sfRenderTexture;
struct sfRenderWindow;
struct sfShape;
struct sfSprite;
struct sfText;
struct sfTexture;
struct sfTransformable;
struct sfVertexArray;
struct sfView;
static if(sfmlSupport >= SFMLSupport.sfml250) {
struct sfVertexBuffer;
}
// Graphics/BlendMode.h
static if(sfmlSupport >= SFMLSupport.sfml220) {
enum sfBlendFactor {
sfBlendFactorZero,
sfBlendFactorOne,
sfBlendFactorSrcColor,
sfBlendFactorOneMinusSrcColor,
sfBlendFactorDstColor,
sfBlendFactorOneMinusDstColor,
sfBlendFactorSrcAlpha,
sfBlendFactorOneMinusSrcAlpha,
sfBlendFactorDstAlpha,
sfBlendFactorOneMinusDstAlpha,
}
mixin(expandEnum!sfBlendFactor);
static if(sfmlSupport >= SFMLSupport.sfml240) {
enum sfBlendEquation {
sfBlendEquationAdd,
sfBlendEquationSubtract,
sfBlendEquationReverseSubtract,
}
}
else {
enum sfBlendEquation {
sfBlendEquationAdd,
sfBlendEquationSubtract,
}
}
mixin(expandEnum!sfBlendEquation);
struct sfBlendMode {
sfBlendFactor colorSrcFactor;
sfBlendFactor colorDstFactor;
sfBlendEquation colorEquation;
sfBlendFactor alphaSrcFactor;
sfBlendFactor alphaDstFactor;
sfBlendEquation alphaEquation;
}
immutable(sfBlendMode) sfBlendAlpha = sfBlendMode(sfBlendFactorSrcAlpha, sfBlendFactorOneMinusSrcAlpha, sfBlendEquationAdd,
sfBlendFactorOne, sfBlendFactorOneMinusSrcAlpha, sfBlendEquationAdd);
immutable(sfBlendMode) sfBlendAdd = sfBlendMode(sfBlendFactorSrcAlpha, sfBlendFactorOne, sfBlendEquationAdd,
sfBlendFactorOne, sfBlendFactorOne, sfBlendEquationAdd);
immutable(sfBlendMode) sfBlendMultiply = sfBlendMode(sfBlendFactorDstColor, sfBlendFactorZero, sfBlendEquationAdd,
sfBlendFactorDstColor, sfBlendFactorZero, sfBlendEquationAdd);
immutable(sfBlendMode) sfBlendNone = sfBlendMode(sfBlendFactorOne, sfBlendFactorZero, sfBlendEquationAdd,
sfBlendFactorOne, sfBlendFactorZero, sfBlendEquationAdd);
}
else {
enum sfBlendMode {
sfBlendAlpha,
sfBlendAdd,
sfBlendMultiply,
sfBlendNone,
}
mixin(expandEnum!sfBlendMode);
}
// Graphics/Color.h
struct sfColor {
sfUint8 r;
sfUint8 g;
sfUint8 b;
sfUint8 a;
}
immutable(sfColor) sfBlack = sfColor(0, 0, 0, 255);
immutable(sfColor) sfWhite = sfColor(255, 255, 255, 255);
immutable(sfColor) sfRed = sfColor(255, 0, 0, 255);
immutable(sfColor) sfGreen = sfColor(0, 255, 0, 255);
immutable(sfColor) sfBlue = sfColor(0, 0, 255, 255);
immutable(sfColor) sfYellow = sfColor(255, 255, 0, 255);
immutable(sfColor) sfMagenta = sfColor(255, 0, 255, 255);
immutable(sfColor) sfCyan = sfColor(0, 255, 255, 255);
immutable(sfColor) sfTransparent = sfColor(0, 0, 0, 0);
static if(sfmlSupport >= SFMLSupport.sfml220) {
// Graphics/FontInfo.h
struct sfFontInfo {
const(char)* family;
}
}
// Graphics/Glsl.h
alias sfGlslVec2 = sfVector2f;
alias sfGlslIvec2 = sfVector2i;
struct sfGlslBvec2 {
sfBool x;
sfBool y;
}
alias sfGlslVec3 = sfVector3f;
struct sfGlslIvec3 {
int x;
int y;
int z;
}
struct sfGlslBvec3 {
sfBool x;
sfBool y;
sfBool z;
}
struct sfGlslVec4 {
float x;
float y;
float z;
float w;
}
struct sfGlslIvec4 {
int x;
int y;
int z;
int w;
}
struct sfGlslBvec4 {
sfBool x;
sfBool y;
sfBool z;
sfBool w;
}
struct sfGlslMat3 {
float* array;
}
struct sfGlslMat4 {
float* array;
}
// Graphics/Glyph.h
static if(sfmlSupport >= SFMLSupport.sfml220) {
struct sfGlyph {
float advance;
sfFloatRect bounds;
sfIntRect textureRect;
}
}
else {
struct sfGlyph {
int advance;
sfIntRect bounds;
sfIntRect textureRect;
}
}
// Graphics/PrimitiveType
enum sfPrimitiveType {
sfPoints,
sfLines,
sfLineStrip,
sfTriangles,
sfTriangleStrip,
sfTriangleFan,
sfQuads,
sfLinesStrip = sfLineStrip,
sfTrianglesStrip = sfTriangleStrip,
sfTrianglesFan = sfTriangleFan,
}
mixin(expandEnum!sfPrimitiveType);
// Graphics/Rect.h
struct sfFloatRect {
float left;
float top;
float width;
float height;
}
struct sfIntRect {
int left;
int top;
int width;
int height;
}
// Graphics/RenderStates.h
struct sfRenderStates {
sfBlendMode blendMode;
sfTransform transform;
const(sfTexture)* texture;
const(sfShader)* shader;
}
// Graphics/Text.h
static if(sfmlSupport >= SFMLSupport.sfml220) {
enum sfTextStyle {
sfTextRegular = 0,
sfTextBold = 1 << 0,
sfTextItalic = 1 << 1,
sfTextUnderlined = 1 << 2,
sfTextStrikeThrough = 1 << 3
}
}
else {
enum sfTextStyle {
sfTextRegular = 0,
sfTextBold = 1 << 0,
sfTextItalic = 1 << 1,
sfTextUnderlined = 1 << 2,
}
}
mixin(expandEnum!sfTextStyle);
// Graphics/Shape.h
extern(C) nothrow {
static if(sfmlSupport >= SFMLSupport.sfml230) {
alias sfShapeGetPointCountCallback = size_t function(void*);
alias sfShapeGetPointCallback = sfVector2f function(size_t, void*);
}
else {
alias sfShapeGetPointCountCallback = uint function(void*);
alias sfShapeGetPointCallback = sfVector2f function(uint, void*);
}
}
// Graphics/Transform
struct sfTransform {
float[9] matrix;
};
const(sfTransform) sfTransform_Identity = sfTransform(
[1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f]
);
// Graphics/Vertex.h
struct sfVertex {
sfVector2f position;
sfColor color;
sfVector2f texCoords;
}
static if(sfmlSupport >= SFMLSupport.sfml250) {
// Graphics/VertexBuffer.h
enum sfVertexBufferUsage {
sfVertexBufferStream,
sfVertexBufferDynamic,
sfVertexBufferStatic
}
mixin(expandEnum!sfVertexBufferUsage);
}
static if(staticSFML) {
extern(C) @nogc nothrow {
// Graphics/CircleShape.h
sfCircleShape* sfCircleShape_create();
sfCircleShape* sfCircleShape_copy(const(sfCircleShape)* shape);
void sfCircleShape_destroy(sfCircleShape* shape);
void sfCircleShape_setPosition(sfCircleShape* shape, sfVector2f position);
void sfCircleShape_setRotation(sfCircleShape* shape, float angle);
void sfCircleShape_setScale(sfCircleShape* shape, sfVector2f scale);
void sfCircleShape_setOrigin(sfCircleShape* shape, sfVector2f origin);
sfVector2f sfCircleShape_getPosition(const(sfCircleShape)* shape);
float sfCircleShape_getRotation(const(sfCircleShape)* shape);
sfVector2f sfCircleShape_getScale(const(sfCircleShape)* shape);
sfVector2f sfCircleShape_getOrigin(const(sfCircleShape)* shape);
void sfCircleShape_move(sfCircleShape* shape, sfVector2f offset);
void sfCircleShape_rotate(sfCircleShape* shape, float angle);
void sfCircleShape_scale(sfCircleShape* shape, sfVector2f factors);
sfTransform sfCircleShape_getTransform(const(sfCircleShape)* shape);
sfTransform sfCircleShape_getInverseTransform(const(sfCircleShape)* shape);
void sfCircleShape_setTexture(sfCircleShape* shape, const(sfTexture)* texture, sfBool resetRect);
void sfCircleShape_setTextureRect(sfCircleShape* shape, sfIntRect rect);
void sfCircleShape_setFillColor(sfCircleShape* shape, sfColor color);
void sfCircleShape_setOutlineColor(sfCircleShape* shape, sfColor color);
void sfCircleShape_setOutlineThickness(sfCircleShape* shape, float thickness);
const(sfTexture)* sfCircleShape_getTexture(const(sfCircleShape)* shape);
sfIntRect sfCircleShape_getTextureRect(const(sfCircleShape)* shape);
sfColor sfCircleShape_getFillColor(const(sfCircleShape)* shape);
sfColor sfCircleShape_getOutlineColor(const(sfCircleShape)* shape);
float sfCircleShape_getOutlineThickness(const(sfCircleShape)* shape);
void sfCircleShape_setRadius(sfCircleShape* shape, float radius);
float sfCircleShape_getRadius(const(sfCircleShape)* shape);
void sfCircleShape_setPointCount(sfCircleShape* shape, uint count);
sfFloatRect sfCircleShape_getLocalBounds(const(sfCircleShape)* shape);
sfFloatRect sfCircleShape_getGlobalBounds(const(sfCircleShape)* shape);
static if(sfmlSupport >= SFMLSupport.sfml230) {
size_t sfCircleShape_getPointCount(const(sfCircleShape)* shape);
sfVector2f sfCircleShape_getPoint(const(sfCircleShape)* shape, size_t index);
void sfCircleShape_setPointCount(sfCircleShape* shape, size_t count);
}
else {
uint sfCircleShape_getPointCount(const(sfCircleShape)* shape);
sfVector2f sfCircleShape_getPoint(const(sfCircleShape)* shape, uint index);
void sfCircleShape_setPointCount(sfCircleShape* shape, uint count);
}
// Graphics/Color.h
sfColor sfColor_fromRGB(sfUint8 red, sfUint8 green, sfUint8 blue);
sfColor sfColor_fromRGBA(sfUint8 red, sfUint8 green, sfUint8 blue, sfUint8 alpha);
sfColor sfColor_add(sfColor color1, sfColor color2);
sfColor sfColor_modulate(sfColor color1, sfColor color2);
// Graphics/ConvexShape.h
sfConvexShape* sfConvexShape_create();
sfConvexShape* sfConvexShape_copy(const(sfConvexShape)* shape);
void sfConvexShape_destroy(sfConvexShape* shape);
void sfConvexShape_setPosition(sfConvexShape* shape, sfVector2f position);
void sfConvexShape_setRotation(sfConvexShape* shape, float angle);
void sfConvexShape_setScale(sfConvexShape* shape, sfVector2f scale);
void sfConvexShape_setOrigin(sfConvexShape* shape, sfVector2f origin);
sfVector2f sfConvexShape_getPosition(const(sfConvexShape)* shape);
float sfConvexShape_getRotation(const(sfConvexShape)* shape);
sfVector2f sfConvexShape_getScale(const(sfConvexShape)* shape);
sfVector2f sfConvexShape_getOrigin(const(sfConvexShape)* shape);
void sfConvexShape_move(sfConvexShape* shape, sfVector2f offset);
void sfConvexShape_rotate(sfConvexShape* shape, float angle);
void sfConvexShape_scale(sfConvexShape* shape, sfVector2f factors);
sfTransform sfConvexShape_getTransform(const(sfConvexShape)* shape);
sfTransform sfConvexShape_getInverseTransform(const(sfConvexShape)* shape);
void sfConvexShape_setTexture(sfConvexShape* shape, const(sfTexture)* texture, sfBool resetRect);
void sfConvexShape_setTextureRect(sfConvexShape* shape, sfIntRect rect);
void sfConvexShape_setFillColor(sfConvexShape* shape, sfColor color);
void sfConvexShape_setOutlineColor(sfConvexShape* shape, sfColor color);
void sfConvexShape_setOutlineThickness(sfConvexShape* shape, float thickness);
const(sfTexture)* sfConvexShape_getTexture(const(sfConvexShape)* shape);
sfIntRect sfConvexShape_getTextureRect(const(sfConvexShape)* shape);
sfColor sfConvexShape_getFillColor(const(sfConvexShape)* shape);
sfColor sfConvexShape_getOutlineColor(const(sfConvexShape)* shape);
float sfConvexShape_getOutlineThickness(const(sfConvexShape)* shape);
sfFloatRect sfConvexShape_getLocalBounds(const(sfConvexShape)* shape);
sfFloatRect sfConvexShape_getGlobalBounds(const(sfConvexShape)* shape);
static if(sfmlSupport >= SFMLSupport.sfml230) {
size_t sfConvexShape_getPointCount(const(sfConvexShape)* shape);
sfVector2f sfConvexShape_getPoint(const(sfConvexShape)* shape, size_t index);
void sfConvexShape_setPointCount(sfConvexShape* shape, size_t count);
void sfConvexShape_setPoint(sfConvexShape* shape, size_t index, sfVector2f point);
}
else {
uint sfConvexShape_getPointCount(const(sfConvexShape)* shape);
sfVector2f sfConvexShape_getPoint(const(sfConvexShape)* shape, uint index);
void sfConvexShape_setPointCount(sfConvexShape* shape, uint count);
void sfConvexShape_setPoint(sfConvexShape* shape, uint index, sfVector2f point);
}
// Graphics/Font.h
sfFont* sfFont_createFromFile(const(char)* filename);
sfFont* sfFont_createFromMemory(const(void)* data, size_t sizeInBytes);
sfFont* sfFont_createFromStream(sfInputStream* stream);
sfFont* sfFont_copy(const(sfFont)* font);
void sfFont_destroy(sfFont* font);
const(sfTexture)* sfFont_getTexture(sfFont* font, uint characterSize);
static if(sfmlSupport >= SFMLSupport.sfml220) {
float sfFont_getKerning(const(sfFont)* font, sfUint32 first, sfUint32 second, uint characterSize);
float sfFont_getLineSpacing(const(sfFont)* font, uint characterSize);
}
else {
int sfFont_getKerning(sfFont* font, sfUint32 first, sfUint32 second, uint characterSize);
int sfFont_getLineSpacing(sfFont* font, uint characterSize);
}
static if(sfmlSupport >= SFMLSupport.sfml240) {
sfGlyph sfFont_getGlyph(const(sfFont)* font, sfUint32 codePoint, uint characterSize, sfBool bold, float outlineThickness);
}
else sfGlyph sfFont_getGlyph(sfFont* font, sfUint32 codePoint, uint characterSize, sfBool bold);
// Graphics/Image.h
sfImage* sfImage_create(uint width, uint height);
sfImage* sfImage_createFromColor(uint width, uint height, sfColor color);
sfImage* sfImage_createFromPixels(uint width, uint height, const(sfUint8)* pixels);
sfImage* sfImage_createFromFile(const(char)* filename);
sfImage* sfImage_createFromMemory(const(void)* data, size_t size);
sfImage* sfImage_createFromStream(sfInputStream* stream);
sfImage* sfImage_copy(const(sfImage)* image);
void sfImage_destroy(sfImage* image);
sfBool sfImage_saveToFile(const(sfImage)* image, const(char)* filename);
sfVector2u sfImage_getSize(const(sfImage)* image);
void sfImage_createMaskFromColor(sfImage* image, sfColor color, sfUint8 alpha);
void sfImage_copyImage(sfImage* image, const(sfImage)* source, uint destX, uint destY, sfIntRect sourceRect, sfBool applyAlpha);
void sfImage_setPixel(sfImage* image, uint x, uint y, sfColor color);
sfColor sfImage_getPixel(const(sfImage)* image, uint x, uint y);
const(sfUint8)* sfImage_getPixelsPtr(const(sfImage)* image);
void sfImage_flipHorizontally(sfImage* image);
void sfImage_flipVertically(sfImage* image);
// Graphics/Rect.h
sfBool sfFloatRect_contains(const(sfFloatRect)* rect, float x, float y);
sfBool sfIntRect_contains(const(sfIntRect)* rect, int x, int y);
sfBool sfFloatRect_intersects(const(sfFloatRect)* rect1, const(sfFloatRect)* rect2, sfFloatRect* intersection);
sfBool sfIntRect_intersects(const(sfIntRect)* rect1, const(sfIntRect)* rect2, sfIntRect* intersection);
// Graphics/RectangleShape.h
sfRectangleShape* sfRectangleShape_create();
sfRectangleShape* sfRectangleShape_copy(const(sfRectangleShape)* shape);
void sfRectangleShape_destroy(sfRectangleShape* shape);
void sfRectangleShape_setPosition(sfRectangleShape* shape, sfVector2f position);
void sfRectangleShape_setRotation(sfRectangleShape* shape, float angle);
void sfRectangleShape_setScale(sfRectangleShape* shape, sfVector2f scale);
void sfRectangleShape_setOrigin(sfRectangleShape* shape, sfVector2f origin);
sfVector2f sfRectangleShape_getPosition(const(sfRectangleShape)* shape);
float sfRectangleShape_getRotation(const(sfRectangleShape)* shape);
sfVector2f sfRectangleShape_getScale(const(sfRectangleShape)* shape);
sfVector2f sfRectangleShape_getOrigin(const(sfRectangleShape)* shape);
void sfRectangleShape_move(sfRectangleShape* shape, sfVector2f offset);
void sfRectangleShape_rotate(sfRectangleShape* shape, float angle);
void sfRectangleShape_scale(sfRectangleShape* shape, sfVector2f factors);
sfTransform sfRectangleShape_getTransform(const(sfRectangleShape)* shape);
sfTransform sfRectangleShape_getInverseTransform(const(sfRectangleShape)* shape);
void sfRectangleShape_setTexture(sfRectangleShape* shape, const(sfTexture)* texture, sfBool resetRect);
void sfRectangleShape_setTextureRect(sfRectangleShape* shape, sfIntRect rect);
void sfRectangleShape_setFillColor(sfRectangleShape* shape, sfColor color);
void sfRectangleShape_setOutlineColor(sfRectangleShape* shape, sfColor color);
void sfRectangleShape_setOutlineThickness(sfRectangleShape* shape, float thickness);
const(sfTexture)* sfRectangleShape_getTexture(const(sfRectangleShape)* shape);
sfIntRect sfRectangleShape_getTextureRect(const(sfRectangleShape)* shape);
sfColor sfRectangleShape_getFillColor(const(sfRectangleShape)* shape);
sfColor sfRectangleShape_getOutlineColor(const(sfRectangleShape)* shape);
float sfRectangleShape_getOutlineThickness(const(sfRectangleShape)* shape);
void sfRectangleShape_setSize(sfRectangleShape* shape, sfVector2f size);
sfVector2f sfRectangleShape_getSize(const(sfRectangleShape)* shape);
sfFloatRect sfRectangleShape_getLocalBounds(const(sfRectangleShape)* shape);
sfFloatRect sfRectangleShape_getGlobalBounds(const(sfRectangleShape)* shape);
static if(sfmlSupport >= SFMLSupport.sfml230) {
size_t sfRectangleShape_getPointCount(const(sfRectangleShape)* shape);
sfVector2f sfRectangleShape_getPoint(const(sfRectangleShape)* shape, size_t index);
}
else {
uint sfRectangleShape_getPointCount(const(sfRectangleShape)* shape);
sfVector2f sfRectangleShape_getPoint(const(sfRectangleShape)* shape, uint index);
}
// Graphics/RenderTexture.h
sfRenderTexture* sfRenderTexture_create(uint width, uint height, sfBool depthBuffer);
void sfRenderTexture_destroy(sfRenderTexture* renderTexture);
sfVector2u sfRenderTexture_getSize(const(sfRenderTexture)* renderTexture);
sfBool sfRenderTexture_setActive(sfRenderTexture* renderTexture, sfBool active);
void sfRenderTexture_display(sfRenderTexture* renderTexture);
void sfRenderTexture_clear(sfRenderTexture* renderTexture, sfColor color);
void sfRenderTexture_setView(sfRenderTexture* renderTexture, const(sfView)* view);
const(sfView)* sfRenderTexture_getView(const(sfRenderTexture)* renderTexture);
const(sfView)* sfRenderTexture_getDefaultView(const(sfRenderTexture)* renderTexture);
sfIntRect sfRenderTexture_getViewport(const(sfRenderTexture)* renderTexture, const(sfView)* view);
sfVector2f sfRenderTexture_mapPixelToCoords(const(sfRenderTexture)* renderTexture, sfVector2i point, const(sfView)* view);
sfVector2i sfRenderTexture_mapCoordsToPixel(const(sfRenderTexture)* renderTexture, sfVector2f point, const(sfView)* view);
void sfRenderTexture_drawSprite(sfRenderTexture* renderTexture, const(sfSprite)* object, const(sfRenderStates)* states);
void sfRenderTexture_drawText(sfRenderTexture* renderTexture, const(sfText)* object, const(sfRenderStates)* states);
void sfRenderTexture_drawShape(sfRenderTexture* renderTexture, const(sfShape)* object, const(sfRenderStates)* states);
void sfRenderTexture_drawCircleShape(sfRenderTexture* renderTexture, const(sfCircleShape)* object, const(sfRenderStates)* states);
void sfRenderTexture_drawConvexShape(sfRenderTexture* renderTexture, const(sfConvexShape)* object, const(sfRenderStates)* states);
void sfRenderTexture_drawRectangleShape(sfRenderTexture* renderTexture, const(sfRectangleShape)* object, const(sfRenderStates)* states);
void sfRenderTexture_drawVertexArray(sfRenderTexture* renderTexture, const(sfVertexArray)* object, const(sfRenderStates)* states);
void sfRenderTexture_pushGLStates(sfRenderTexture* renderTexture);
void sfRenderTexture_popGLStates(sfRenderTexture* renderTexture);
void sfRenderTexture_resetGLStates(sfRenderTexture* renderTexture);
const(sfTexture)* sfRenderTexture_getTexture(const(sfRenderTexture)* renderTexture);
void sfRenderTexture_setSmooth(sfRenderTexture* renderTexture, sfBool smooth);
sfBool sfRenderTexture_isSmooth(const(sfRenderTexture)* renderTexture);
static if(sfmlSupport >= SFMLSupport.sfml230) {
void sfRenderTexture_drawPrimitives(sfRenderTexture* renderTexture, const(sfVertex)* vertices, size_t vertexCount, sfPrimitiveType type, const(sfRenderStates)* states);
}
else void sfRenderTexture_drawPrimitives(sfRenderTexture* renderTexture, const(sfVertex)* vertices, uint vertexCount, sfPrimitiveType type, const(sfRenderStates)* states);
// Graphics/RenderWindow.h
sfRenderWindow* sfRenderWindow_create(sfVideoMode mode, const(char)* title, sfUint32 style, const(sfContextSettings)* settings);
sfRenderWindow* sfRenderWindow_createUnicode(sfVideoMode mode, const(sfUint32)* title, sfUint32 style, const(sfContextSettings)* settings);
sfRenderWindow* sfRenderWindow_createFromHandle(sfWindowHandle handle, const(sfContextSettings)* settings);
void sfRenderWindow_destroy(sfRenderWindow* window);
void sfRenderWindow_close(sfRenderWindow* window);
sfBool sfRenderWindow_isOpen(const(sfRenderWindow)* window);
sfContextSettings sfRenderWindow_getSettings(const(sfRenderWindow)* window);
sfBool sfRenderWindow_pollEvent(sfRenderWindow* window, sfEvent* event);
sfBool sfRenderWindow_waitEvent(sfRenderWindow* window, sfEvent* event);
sfVector2i sfRenderWindow_getPosition(const(sfRenderWindow)* window);
void sfRenderWindow_setPosition(sfRenderWindow* window, sfVector2i position);
sfVector2u sfRenderWindow_getSize(const(sfRenderWindow)* window);
void sfRenderWindow_setSize(sfRenderWindow* window, sfVector2u size);
void sfRenderWindow_setTitle(sfRenderWindow* window, const(char)* title);
void sfRenderWindow_setUnicodeTitle(sfRenderWindow* window, const(sfUint32)* title);
void sfRenderWindow_setIcon(sfRenderWindow* window, uint width, uint height, const(sfUint8)* pixels);
void sfRenderWindow_setVisible(sfRenderWindow* window, sfBool visible);
void sfRenderWindow_setMouseCursorVisible(sfRenderWindow* window, sfBool visible);
void sfRenderWindow_setVerticalSyncEnabled(sfRenderWindow* window, sfBool enabled);
void sfRenderWindow_setKeyRepeatEnabled(sfRenderWindow* window, sfBool enabled);
sfBool sfRenderWindow_setActive(sfRenderWindow* window, sfBool active);
void sfRenderWindow_display(sfRenderWindow* window);
void sfRenderWindow_setFramerateLimit(sfRenderWindow* window, uint limit);
void sfRenderWindow_setJoystickThreshold(sfRenderWindow* window, float threshold);
sfWindowHandle sfRenderWindow_getSystemHandle(const(sfRenderWindow)* window);
void sfRenderWindow_clear(sfRenderWindow* renderWindow, sfColor color);
void sfRenderWindow_setView(sfRenderWindow* renderWindow, const(sfView)* view);
const(sfView)* sfRenderWindow_getView(const(sfRenderWindow)* renderWindow);
const(sfView)* sfRenderWindow_getDefaultView(const(sfRenderWindow)* renderWindow);
sfIntRect sfRenderWindow_getViewport(const(sfRenderWindow)* renderWindow, const(sfView)* view);
sfVector2f sfRenderWindow_mapPixelToCoords(const(sfRenderWindow)* renderWindow, sfVector2i point, const(sfView)* view);
sfVector2i sfRenderWindow_mapCoordsToPixel(const(sfRenderWindow)* renderWindow, sfVector2f point, const(sfView)* view);
void sfRenderWindow_drawSprite(sfRenderWindow* renderWindow, const(sfSprite)* object, const(sfRenderStates)* states);
void sfRenderWindow_drawText(sfRenderWindow* renderWindow, const(sfText)* object, const(sfRenderStates)* states);
void sfRenderWindow_drawShape(sfRenderWindow* renderWindow, const(sfShape)* object, const(sfRenderStates)* states);
void sfRenderWindow_drawCircleShape(sfRenderWindow* renderWindow, const(sfCircleShape)* object, const(sfRenderStates)* states);
void sfRenderWindow_drawConvexShape(sfRenderWindow* renderWindow, const(sfConvexShape)* object, const(sfRenderStates)* states);
void sfRenderWindow_drawRectangleShape(sfRenderWindow* renderWindow, const(sfRectangleShape)* object, const(sfRenderStates)* states);
void sfRenderWindow_drawVertexArray(sfRenderWindow* renderWindow, const(sfVertexArray)* object, const(sfRenderStates)* states);
void sfRenderWindow_pushGLStates(sfRenderWindow* renderWindow);
void sfRenderWindow_popGLStates(sfRenderWindow* renderWindow);
void sfRenderWindow_resetGLStates(sfRenderWindow* renderWindow);
sfImage* sfRenderWindow_capture(const(sfRenderWindow)* renderWindow);
sfVector2i sfMouse_getPositionRenderWindow(const(sfRenderWindow)* relativeTo);
void sfMouse_setPositionRenderWindow(sfVector2i position, const(sfRenderWindow)* relativeTo);
static if(sfmlSupport >= SFMLSupport.sfml230) {
void sfRenderWindow_drawPrimitives(sfRenderWindow* renderWindow, const(sfVertex)* vertices, size_t vertexCount, sfPrimitiveType type, const(sfRenderStates)* states);
}
else void sfRenderWindow_drawPrimitives(sfRenderWindow* renderWindow, const(sfVertex)* vertices, uint vertexCount, sfPrimitiveType type, const(sfRenderStates)* states);
// Graphics/Shader.h
void sfShader_destroy(sfShader* shader);
void sfShader_setFloatParameter(sfShader* shader, const(char)* name, float x);
void sfShader_setFloat2Parameter(sfShader* shader, const(char)* name, float x, float y);
void sfShader_setFloat3Parameter(sfShader* shader, const(char)* name, float x, float y, float z);
void sfShader_setFloat4Parameter(sfShader* shader, const(char)* name, float x, float y, float z, float w);
void sfShader_setVector2Parameter(sfShader* shader, const(char)* name, sfVector2f vector);
void sfShader_setVector3Parameter(sfShader* shader, const(char)* name, sfVector3f vector);
void sfShader_setColorParameter(sfShader* shader, const(char)* name, sfColor color);
void sfShader_setTransformParameter(sfShader* shader, const(char)* name, sfTransform transform);
void sfShader_setTextureParameter(sfShader* shader, const(char)* name, const(sfTexture)* texture);
void sfShader_setCurrentTextureParameter(sfShader* shader, const(char)* name);
void sfShader_bind(const(sfShader)* shader);
sfBool sfShader_isAvailable();
static if(sfmlSupport >= SFMLSupport.sfml240) {
sfShader* sfShader_createFromFile(const(char)* vertexShaderFilename, const(char)* geometryShaderFilename, const(char)* fragmentShaderFilename);
sfShader* sfShader_createFromMemory(const(char)* vertexShader, const(char)* geometryShader, const(char)* fragmentShader);
sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputStream* geometryShaderStream, sfInputStream* fragmentShaderStream);
}
else {
sfShader* sfShader_createFromStream(sfInputStream* vertexShaderStream, sfInputStream* fragmentShaderStream);
sfShader* sfShader_createFromFile(const(char)* vertexShaderFilename, const(char)* fragmentShaderFilename);
sfShader* sfShader_createFromMemory(const(char)* vertexShader, const(char)* fragmentShader);
}
// Graphics/Shape.h
sfShape* sfShape_create(sfShapeGetPointCountCallback getPointCount, sfShapeGetPointCallback getPoint, void* userData);
void sfShape_destroy(sfShape* shape);
void sfShape_setPosition(sfShape* shape, sfVector2f position);
void sfShape_setRotation(sfShape* shape, float angle);
void sfShape_setScale(sfShape* shape, sfVector2f scale);
void sfShape_setOrigin(sfShape* shape, sfVector2f origin);
sfVector2f sfShape_getPosition(const(sfShape)* shape);
float sfShape_getRotation(const(sfShape)* shape);
sfVector2f sfShape_getScale(const(sfShape)* shape);
sfVector2f sfShape_getOrigin(const(sfShape)* shape);
void sfShape_move(sfShape* shape, sfVector2f offset);
void sfShape_rotate(sfShape* shape, float angle);
void sfShape_scale(sfShape* shape, sfVector2f factors);
sfTransform sfShape_getTransform(const(sfShape)* shape);
sfTransform sfShape_getInverseTransform(const(sfShape)* shape);
void sfShape_setTexture(sfShape* shape, const(sfTexture)* texture, sfBool resetRect);
void sfShape_setTextureRect(sfShape* shape, sfIntRect rect);
void sfShape_setFillColor(sfShape* shape, sfColor color);
void sfShape_setOutlineColor(sfShape* shape, sfColor color);
void sfShape_setOutlineThickness(sfShape* shape, float thickness);
const(sfTexture)* sfShape_getTexture(const(sfShape)* shape);
sfIntRect sfShape_getTextureRect(const(sfShape)* shape);
sfColor sfShape_getFillColor(const(sfShape)* shape);
sfColor sfShape_getOutlineColor(const(sfShape)* shape);
float sfShape_getOutlineThickness(const(sfShape)* shape);
sfFloatRect sfShape_getLocalBounds(const(sfShape)* shape);
sfFloatRect sfShape_getGlobalBounds(const(sfShape)* shape);
void sfShape_update(sfShape* shape);
static if(sfmlSupport >= SFMLSupport.sfml230) {
size_t sfShape_getPointCount(const(sfShape)* shape);
sfVector2f sfShape_getPoint(const(sfShape)* shape, size_t index);
}
else {
uint sfShape_getPointCount(const(sfShape)* shape);
sfVector2f sfShape_getPoint(const(sfShape)* shape, uint index);
}
// Graphics/Sprite.h
sfSprite* sfSprite_create();
sfSprite* sfSprite_copy(const(sfSprite)* sprite);
void sfSprite_destroy(sfSprite* sprite);
void sfSprite_setPosition(sfSprite* sprite, sfVector2f position);
void sfSprite_setRotation(sfSprite* sprite, float angle);
void sfSprite_setScale(sfSprite* sprite, sfVector2f scale);
void sfSprite_setOrigin(sfSprite* sprite, sfVector2f origin);
sfVector2f sfSprite_getPosition(const(sfSprite)* sprite);
float sfSprite_getRotation(const(sfSprite)* sprite);
sfVector2f sfSprite_getScale(const(sfSprite)* sprite);
sfVector2f sfSprite_getOrigin(const(sfSprite)* sprite);
void sfSprite_move(sfSprite* sprite, sfVector2f offset);
void sfSprite_rotate(sfSprite* sprite, float angle);
void sfSprite_scale(sfSprite* sprite, sfVector2f factors);
sfTransform sfSprite_getTransform(const(sfSprite)* sprite);
sfTransform sfSprite_getInverseTransform(const(sfSprite)* sprite);
void sfSprite_setTexture(sfSprite* sprite, const(sfTexture)* texture, sfBool resetRect);
void sfSprite_setTextureRect(sfSprite* sprite, sfIntRect rectangle);
void sfSprite_setColor(sfSprite* sprite, sfColor color);
const(sfTexture)* sfSprite_getTexture(const(sfSprite)* sprite);
sfIntRect sfSprite_getTextureRect(const(sfSprite)* sprite);
sfColor sfSprite_getColor(const(sfSprite)* sprite);
sfFloatRect sfSprite_getLocalBounds(const(sfSprite)* sprite);
sfFloatRect sfSprite_getGlobalBounds(const(sfSprite)* sprite);
// Graphics/Text.h
sfText* sfText_create();
sfText* sfText_copy(const(sfText)* text);
void sfText_destroy(sfText* text);
void sfText_setPosition(sfText* text, sfVector2f position);
void sfText_setRotation(sfText* text, float angle);
void sfText_setScale(sfText* text, sfVector2f scale);
void sfText_setOrigin(sfText* text, sfVector2f origin);
sfVector2f sfText_getPosition(const(sfText)* text);
float sfText_getRotation(const(sfText)* text);
sfVector2f sfText_getScale(const(sfText)* text);
sfVector2f sfText_getOrigin(const(sfText)* text);
void sfText_move(sfText* text, sfVector2f offset);
void sfText_rotate(sfText* text, float angle);
void sfText_scale(sfText* text, sfVector2f factors);
sfTransform sfText_getTransform(const(sfText)* text);
sfTransform sfText_getInverseTransform(const(sfText)* text);
void sfText_setString(sfText* text, const(char)* string);
void sfText_setUnicodeString(sfText* text, const(sfUint32)* string);
void sfText_setFont(sfText* text, const(sfFont)* font);
void sfText_setCharacterSize(sfText* text, uint size);
void sfText_setStyle(sfText* text, sfUint32 style);
void sfText_setColor(sfText* text, sfColor color);
const(char)* sfText_getString(const(sfText)* text);
const(sfUint32)* sfText_getUnicodeString(const(sfText)* text);
const(sfFont)* sfText_getFont(const(sfText)* text);
uint sfText_getCharacterSize(const(sfText)* text);
sfUint32 sfText_getStyle(const(sfText)* text);
sfColor sfText_getColor(const(sfText)* text);
sfVector2f sfText_findCharacterPos(const(sfText)* text, size_t index);
sfFloatRect sfText_getLocalBounds(const(sfText)* text);
sfFloatRect sfText_getGlobalBounds(const(sfText)* text);
// Graphics/Texture.h
sfTexture* sfTexture_create(uint width, uint height);
sfTexture* sfTexture_createFromFile(const(char)* filename, const(sfIntRect)* area);
sfTexture* sfTexture_createFromMemory(const(void)* data, size_t sizeInBytes, const(sfIntRect)* area);
sfTexture* sfTexture_createFromStream(sfInputStream* stream, const(sfIntRect)* area);
sfTexture* sfTexture_createFromImage(const(sfImage)* image, const(sfIntRect)* area);
sfTexture* sfTexture_copy(const(sfTexture)* texture);
void sfTexture_destroy(sfTexture* texture);
sfVector2u sfTexture_getSize(const(sfTexture)* texture);
sfImage* sfTexture_copyToImage(const(sfTexture)* texture);
void sfTexture_updateFromPixels(sfTexture* texture, const(sfUint8)* pixels, uint width, uint height, uint x, uint y);
void sfTexture_updateFromImage(sfTexture* texture, const(sfImage)* image, uint x, uint y);
void sfTexture_updateFromWindow(sfTexture* texture, const(sfWindow)* window, uint x, uint y);
void sfTexture_updateFromRenderWindow(sfTexture* texture, const(sfRenderWindow)* renderWindow, uint x, uint y);
sfBool sfTexture_isSmooth(const(sfTexture)* texture);
void sfTexture_setSmooth(sfTexture* texture, sfBool smooth);
void sfTexture_setRepeated(sfTexture* texture, sfBool repeated);
sfBool sfTexture_isRepeated(const(sfTexture)* texture);
void sfTexture_bind(const(sfTexture)* texture);
uint sfTexture_getMaximumSize();
// Graphics/Transform.h
sfTransform sfTransform_fromMatrix(float a00, float a01, float a02, float a10, float a11, float a12, float a20, float a21, float a22);
void sfTransform_getMatrix(const(sfTransform)* transform, float* matrix);
sfTransform sfTransform_getInverse(const(sfTransform)* transform);
sfVector2f sfTransform_transformPoint(const(sfTransform)* transform, sfVector2f point);
sfFloatRect sfTransform_transformRect(const(sfTransform)* transform, sfFloatRect rectangle);
void sfTransform_combine(sfTransform* transform, const(sfTransform)* other);
void sfTransform_translate(sfTransform* transform, float x, float y);
void sfTransform_rotate(sfTransform* transform, float angle);
void sfTransform_rotateWithCenter(sfTransform* transform, float angle, float centerX, float centerY);
void sfTransform_scale(sfTransform* transform, float scaleX, float scaleY);
void sfTransform_scaleWithCenter(sfTransform* transform, float scaleX, float scaleY, float centerX, float centerY);
// Graphics/Transformable.h
sfTransformable* sfTransformable_create();
sfTransformable* sfTransformable_copy(const(sfTransformable)* transformable);
void sfTransformable_destroy(sfTransformable* transformable);
void sfTransformable_setPosition(sfTransformable* transformable, sfVector2f position);
void sfTransformable_setRotation(sfTransformable* transformable, float angle);
void sfTransformable_setScale(sfTransformable* transformable, sfVector2f scale);
void sfTransformable_setOrigin(sfTransformable* transformable, sfVector2f origin);
sfVector2f sfTransformable_getPosition(const(sfTransformable)* transformable);
float sfTransformable_getRotation(const(sfTransformable)* transformable);
sfVector2f sfTransformable_getScale(const(sfTransformable)* transformable);
sfVector2f sfTransformable_getOrigin(const(sfTransformable)* transformable);
void sfTransformable_move(sfTransformable* transformable, sfVector2f offset);
void sfTransformable_rotate(sfTransformable* transformable, float angle);
void sfTransformable_scale(sfTransformable* transformable, sfVector2f factors);
sfTransform sfTransformable_getTransform(const(sfTransformable)* transformable);
sfTransform sfTransformable_getInverseTransform(const(sfTransformable)* transformable);
// Graphics/VertexArray.h
sfVertexArray* sfVertexArray_create();
sfVertexArray* sfVertexArray_copy(const(sfVertexArray)* vertexArray);
void sfVertexArray_destroy(sfVertexArray* vertexArray);
void sfVertexArray_clear(sfVertexArray* vertexArray);
void sfVertexArray_append(sfVertexArray* vertexArray, sfVertex vertex);
void sfVertexArray_setPrimitiveType(sfVertexArray* vertexArray, sfPrimitiveType type);
sfPrimitiveType sfVertexArray_getPrimitiveType(sfVertexArray* vertexArray);
sfFloatRect sfVertexArray_getBounds(sfVertexArray* vertexArray);
static if(sfmlSupport >= SFMLSupport.sfml230) {
size_t sfVertexArray_getVertexCount(const(sfVertexArray)* vertexArray);
sfVertex* sfVertexArray_getVertex(sfVertexArray* vertexArray, size_t index);
void sfVertexArray_resize(sfVertexArray* vertexArray, size_t vertexCount);
}
else {
uint sfVertexArray_getVertexCount(const(sfVertexArray)* vertexArray);
sfVertex* sfVertexArray_getVertex(sfVertexArray* vertexArray, uint index);
void sfVertexArray_resize(sfVertexArray* vertexArray, uint vertexCount);
}
// Graphics/View.h
sfView* sfView_create();
sfView* sfView_createFromRect(sfFloatRect rectangle);
sfView* sfView_copy(const(sfView)* view);
void sfView_destroy(sfView* view);
void sfView_setCenter(sfView* view, sfVector2f center);
void sfView_setSize(sfView* view, sfVector2f size);
void sfView_setRotation(sfView* view, float angle);
void sfView_setViewport(sfView* view, sfFloatRect viewport);
void sfView_reset(sfView* view, sfFloatRect rectangle);
sfVector2f sfView_getCenter(const(sfView)* view);
sfVector2f sfView_getSize(const(sfView)* view);
float sfView_getRotation(const(sfView)* view);
sfFloatRect sfView_getViewport(const(sfView)* view);
void sfView_move(sfView* view, sfVector2f offset);
void sfView_rotate(sfView* view, float angle);
void sfView_zoom(sfView* view, float factor);
static if(sfmlSupport >= SFMLSupport.sfml220) {
// Graphics/Font.h
float sfFont_getUnderlinePosition(const(sfFont)* font, uint characterSize);
float sfFont_getUnderlineThickness(const(sfFont)* font, uint characterSize);
sfFontInfo sfFont_getInfo(const(sfFont)* font);
// Graphics/RenderWindow.h
void sfRenderWindow_requestFocus(sfRenderWindow* renderWindow);
sfBool sfRenderWindow_hasFocus(const(sfRenderWindow)* renderWindow);
sfVector2i sfTouch_getPositionRenderWindow(uint finger, const(sfRenderWindow)* relativeTo);
}
static if(sfmlSupport >= SFMLSupport.sfml230) {
// Graphics/Color.h
sfColor sfColor_fromInteger(sfUint32 color);
sfUint32 sfColor_toInteger(sfColor color);
sfColor sfColor_subtract(sfColor color1, sfColor color2);
// Graphics/Shader.h
uint sfShader_getNativeHandle(const(sfShader)* shader);
// Graphics/Texture.h
uint sfTexture_getNativeHandle(const(sfTexture)* texture);
}
static if(sfmlSupport >= SFMLSupport.sfml240) {
// Graphics/RenderTexture.h
sfBool sfRenderTexture_generateMipmap(sfRenderTexture* renderTexture);
// Graphics/RenderWindow.h
void sfRenderWindow_setMouseCursorGrabbed(sfRenderWindow* renderWindow, sfBool grabbed);
// Graphics/Shader.h
void sfShader_setFloatUniform(sfShader* shader, const(char)* name, float x);
void sfShader_setVec2Uniform(sfShader* shader, const(char)* name, sfGlslVec2 vector);
void sfShader_setVec3Uniform(sfShader* shader, const(char)* name, sfGlslVec3 vector);
void sfShader_setVec4Uniform(sfShader* shader, const(char)* name, sfGlslVec4 vector);
void sfShader_setColorUniform(sfShader* shader, const(char)* name, sfColor color);
void sfShader_setIntUniform(sfShader* shader, const(char)* name, int x);
void sfShader_setIvec2Uniform(sfShader* shader, const(char)* name, sfGlslIvec2 vector);
void sfShader_setIvec3Uniform(sfShader* shader, const(char)* name, sfGlslIvec3 vector);
void sfShader_setIvec4Uniform(sfShader* shader, const(char)* name, sfGlslIvec4 vector);
void sfShader_setIntColorUniform(sfShader* shader, const(char)* name, sfColor color);
void sfShader_setBoolUniform(sfShader* shader, const(char)* name, sfBool x);
void sfShader_setBvec2Uniform(sfShader* shader, const(char)* name, sfGlslBvec2 vector);
void sfShader_setBvec3Uniform(sfShader* shader, const(char)* name, sfGlslBvec3 vector);
void sfShader_setBvec4Uniform(sfShader* shader, const(char)* name, sfGlslBvec4 vector);
void sfShader_setMat3Uniform(sfShader* shader, const(char)* name, const(sfGlslMat3)* matrix);
void sfShader_setMat4Uniform(sfShader* shader, const(char)* name, const(sfGlslMat4)* matrix);
void sfShader_setTextureUniform(sfShader* shader, const(char)* name, const(sfTexture)* texture);
void sfShader_setCurrentTextureUniform(sfShader* shader, const(char)* name);
void sfShader_setFloatUniformArray(sfShader* shader, const(char)* name, const(float)* scalarArray, size_t length);
void sfShader_setVec2UniformArray(sfShader* shader, const(char)* name, const(sfGlslVec2)* vectorArray, size_t length);
void sfShader_setVec3UniformArray(sfShader* shader, const(char)* name, const(sfGlslVec3)* vectorArray, size_t length);
void sfShader_setVec4UniformArray(sfShader* shader, const(char)* name, const(sfGlslVec4)* vectorArray, size_t length);
void sfShader_setMat3UniformArray(sfShader* shader, const(char)* name, const(sfGlslMat3)* matrixArray, size_t length);
void sfShader_setMat4UniformArray(sfShader* shader, const(char)* name, const(sfGlslMat4)* matrixArray, size_t length);
sfBool sfShader_isGeometryAvailable();
// Graphics/Text.h
void sfText_setFillColor(sfText* text, sfColor color);
void sfText_setOutlineColor(sfText* text, sfColor color);
void sfText_setOutlineThickness(sfText* text, float thickness);
sfColor sfText_getFillColor(const(sfText)* text);
sfColor sfText_getOutlineColor(const(sfText)* text);
float sfText_getOutlineThickness(const(sfText)* text);
// Graphics/Texture.h
void sfTexture_setSrgb(sfTexture* texture, sfBool sRgb);
sfBool sfTexture_isSrgb(const(sfTexture)* texture);
sfBool sfTexture_generateMipmap(sfTexture* texture);
}
static if(sfmlSupport >= SFMLSupport.sfml250) {
// Graphics/RenderTexture.h
sfRenderTexture* sfRenderTexture_createWithSettings(uint width, uint height, sfContextSettings settings);
void sfRenderTexture_drawVertexBuffer(sfRenderTexture* renderTexture, const(sfVertexBuffer)* object, const(sfRenderStates)* states);
uint sfRenderTexture_getMaximumAntialiasingLevel();
// Graphics/RenderWindow.h
void sfRenderWindow_setMouseCursor(sfRenderWindow* window, const(sfCursor)* cursor);
void sfRenderWindow_drawVertexBuffer(sfRenderWindow* renderWindow, const(sfVertexBuffer)* object, const(sfRenderStates)* states);
// Graphics/Text.h
void sfText_setLineSpacing(sfText* text, float spacingFactor);
void sfText_setLetterSpacing(sfText* text, float spacingFactor);
float sfText_getLetterSpacing(const(sfText)* text);
float sfText_getLineSpacing(const(sfText)* text);
// Graphics/Texture.h
void sfTexture_updateFromTexture(sfTexture* destination, const(sfTexture)* source, uint x, uint y);
void sfTexture_swap(sfTexture* left, sfTexture* right);
// Graphics/Transform.h
sfBool sfTransform_equal(sfTransform* left, sfTransform* right);
// Graphics/VertexBuffer.h
sfVertexBuffer* sfVertexBuffer_create(uint vertexCount, sfPrimitiveType type, sfVertexBufferUsage usage);
sfVertexBuffer* sfVertexBuffer_copy(const(sfVertexBuffer)* vertexBuffer);
void sfVertexBuffer_destroy(sfVertexBuffer* vertexBuffer);
uint sfVertexBuffer_getVertexCount(const(sfVertexBuffer)* vertexBuffer);
sfBool sfVertexBuffer_update(sfVertexBuffer* vertexBuffer, const(sfVertex)* vertices, uint vertexCount, uint offset);
sfBool sfVertexBuffer_updateFromVertexBuffer(sfVertexBuffer* vertexBuffer, const(sfVertexBuffer)* other);
void sfVertexBuffer_swap(sfVertexBuffer* left, sfVertexBuffer* right);
uint sfVertexBuffer_getNativeHandle(sfVertexBuffer* vertexBuffer);
void sfVertexBuffer_setPrimitiveType(sfVertexBuffer* vertexBuffer, sfPrimitiveType type);
sfPrimitiveType sfVertexBuffer_getPrimitiveType(const(sfVertexBuffer)* vertexBuffer);
void sfVertexBuffer_setUsage(sfVertexBuffer* vertexBuffer, sfVertexBufferUsage usage);
sfVertexBufferUsage sfVertexBuffer_getUsage(const(sfVertexBuffer)* vertexBuffer);
void sfVertexBuffer_bind(const(sfVertexBuffer)* vertexBuffer);
sfBool sfVertexBuffer_isAvailable();
}
}
}
else {
import bindbc.loader;
extern(C) @nogc nothrow {
// Graphics/CircleShape.h
alias psfCircleShape_create = sfCircleShape* function();
alias psfCircleShape_copy = sfCircleShape* function(const(sfCircleShape)* shape);
alias psfCircleShape_destroy = void function(sfCircleShape* shape);
alias psfCircleShape_setPosition = void function(sfCircleShape* shape, sfVector2f position);
alias psfCircleShape_setRotation = void function(sfCircleShape* shape, float angle);
alias psfCircleShape_setScale = void function(sfCircleShape* shape, sfVector2f scale);
alias psfCircleShape_setOrigin = void function(sfCircleShape* shape, sfVector2f origin);
alias psfCircleShape_getPosition = sfVector2f function(const(sfCircleShape)* shape);
alias psfCircleShape_getRotation = float function(const(sfCircleShape)* shape);
alias psfCircleShape_getScale = sfVector2f function(const(sfCircleShape)* shape);
alias psfCircleShape_getOrigin = sfVector2f function(const(sfCircleShape)* shape);
alias psfCircleShape_move = void function(sfCircleShape* shape, sfVector2f offset);
alias psfCircleShape_rotate = void function(sfCircleShape* shape, float angle);
alias psfCircleShape_scale = void function(sfCircleShape* shape, sfVector2f factors);
alias psfCircleShape_getTransform = sfTransform function(const(sfCircleShape)* shape);
alias psfCircleShape_getInverseTransform = sfTransform function(const(sfCircleShape)* shape);
alias psfCircleShape_setTexture = void function(sfCircleShape* shape, const(sfTexture)* texture, sfBool resetRect);
alias psfCircleShape_setTextureRect = void function(sfCircleShape* shape, sfIntRect rect);
alias psfCircleShape_setFillColor = void function(sfCircleShape* shape, sfColor color);
alias psfCircleShape_setOutlineColor = void function(sfCircleShape* shape, sfColor color);
alias psfCircleShape_setOutlineThickness = void function(sfCircleShape* shape, float thickness);
alias psfCircleShape_getTexture = const(sfTexture)* function(const(sfCircleShape)* shape);
alias psfCircleShape_getTextureRect = sfIntRect function(const(sfCircleShape)* shape);
alias psfCircleShape_getFillColor = sfColor function(const(sfCircleShape)* shape);
alias psfCircleShape_getOutlineColor = sfColor function(const(sfCircleShape)* shape);
alias psfCircleShape_getOutlineThickness = float function(const(sfCircleShape)* shape);
alias psfCircleShape_setRadius = void function(sfCircleShape* shape, float radius);
alias psfCircleShape_getRadius = float function(const(sfCircleShape)* shape);
alias psfCircleShape_getLocalBounds = sfFloatRect function(const(sfCircleShape)* shape);
alias psfCircleShape_getGlobalBounds = sfFloatRect function(const(sfCircleShape)* shape);
static if(sfmlSupport >= SFMLSupport.sfml230) {
alias psfCircleShape_getPointCount = size_t function(const(sfCircleShape)* shape);
alias psfCircleShape_getPoint = sfVector2f function(const(sfCircleShape)* shape, size_t index);
alias psfCircleShape_setPointCount = void function(sfCircleShape* shape, size_t count);
}
else {
alias psfCircleShape_getPointCount = uint function(const(sfCircleShape)* shape);
alias psfCircleShape_getPoint = sfVector2f function(const(sfCircleShape)* shape, uint index);
alias psfCircleShape_setPointCount = void function(sfCircleShape* shape, uint count);
}
// Graphics/Color.h
alias psfColor_fromRGB = sfColor function(sfUint8 red, sfUint8 green, sfUint8 blue);
alias psfColor_fromRGBA = sfColor function(sfUint8 red, sfUint8 green, sfUint8 blue, sfUint8 alpha);
alias psfColor_add = sfColor function(sfColor color1, sfColor color2);
alias psfColor_modulate = sfColor function(sfColor color1, sfColor color2);
// Graphics/ConvexShape.h
alias psfConvexShape_create = sfConvexShape* function();
alias psfConvexShape_copy = sfConvexShape* function(const(sfConvexShape)* shape);
alias psfConvexShape_destroy = void function(sfConvexShape* shape);
alias psfConvexShape_setPosition = void function(sfConvexShape* shape, sfVector2f position);
alias psfConvexShape_setRotation = void function(sfConvexShape* shape, float angle);
alias psfConvexShape_setScale = void function(sfConvexShape* shape, sfVector2f scale);
alias psfConvexShape_setOrigin = void function(sfConvexShape* shape, sfVector2f origin);
alias psfConvexShape_getPosition = sfVector2f function(const(sfConvexShape)* shape);
alias psfConvexShape_getRotation = float function(const(sfConvexShape)* shape);
alias psfConvexShape_getScale = sfVector2f function(const(sfConvexShape)* shape);
alias psfConvexShape_getOrigin = sfVector2f function(const(sfConvexShape)* shape);
alias psfConvexShape_move = void function(sfConvexShape* shape, sfVector2f offset);
alias psfConvexShape_rotate = void function(sfConvexShape* shape, float angle);
alias psfConvexShape_scale = void function(sfConvexShape* shape, sfVector2f factors);
alias psfConvexShape_getTransform = sfTransform function(const(sfConvexShape)* shape);
alias psfConvexShape_getInverseTransform = sfTransform function(const(sfConvexShape)* shape);
alias psfConvexShape_setTexture = void function(sfConvexShape* shape, const(sfTexture)* texture, sfBool resetRect);
alias psfConvexShape_setTextureRect = void function(sfConvexShape* shape, sfIntRect rect);
alias psfConvexShape_setFillColor = void function(sfConvexShape* shape, sfColor color);
alias psfConvexShape_setOutlineColor = void function(sfConvexShape* shape, sfColor color);
alias psfConvexShape_setOutlineThickness = void function(sfConvexShape* shape, float thickness);
alias psfConvexShape_getTexture = const(sfTexture)* function(const(sfConvexShape)* shape);
alias psfConvexShape_getTextureRect = sfIntRect function(const(sfConvexShape)* shape);
alias psfConvexShape_getFillColor = sfColor function(const(sfConvexShape)* shape);
alias psfConvexShape_getOutlineColor = sfColor function(const(sfConvexShape)* shape);
alias psfConvexShape_getOutlineThickness = float function(const(sfConvexShape)* shape);
alias psfConvexShape_getLocalBounds = sfFloatRect function(const(sfConvexShape)* shape);
alias psfConvexShape_getGlobalBounds = sfFloatRect function(const(sfConvexShape)* shape);
static if(sfmlSupport >= SFMLSupport.sfml230) {
alias psfConvexShape_getPointCount = size_t function(const(sfConvexShape)* shape);
alias psfConvexShape_getPoint = sfVector2f function(const(sfConvexShape)* shape, size_t index);
alias psfConvexShape_setPointCount = void function(sfConvexShape* shape, size_t count);
alias psfConvexShape_setPoint = void function(sfConvexShape* shape, size_t index, sfVector2f point);
}
else {
alias psfConvexShape_getPointCount = uint function(const(sfConvexShape)* shape);
alias psfConvexShape_getPoint = sfVector2f function(const(sfConvexShape)* shape, uint index);
alias psfConvexShape_setPointCount = void function(sfConvexShape* shape, uint count);
alias psfConvexShape_setPoint = void function(sfConvexShape* shape, uint index, sfVector2f point);
}
// Graphics/Font.h
alias psfFont_createFromFile = sfFont* function(const(char)* filename);
alias psfFont_createFromMemory = sfFont* function(const(void)* data, size_t sizeInBytes);
alias psfFont_createFromStream = sfFont* function(sfInputStream* stream);
alias psfFont_copy = sfFont* function(const(sfFont)* font);
alias psfFont_destroy = void function(sfFont* font);
alias psfFont_getTexture = const(sfTexture)* function(sfFont* font, uint characterSize);
static if(sfmlSupport >= SFMLSupport.sfml220) {
alias psfFont_getKerning = float function(const(sfFont)* font, sfUint32 first, sfUint32 second, uint characterSize);
alias psfFont_getLineSpacing = float function(const(sfFont)* font, uint characterSize);
}
else {
alias psfFont_getKerning = int function(sfFont* font, sfUint32 first, sfUint32 second, uint characterSize);
alias psfFont_getLineSpacing = int function(sfFont* font, uint characterSize);
}
static if(sfmlSupport >= SFMLSupport.sfml240) {
alias psfFont_getGlyph = sfGlyph function(const(sfFont)* font, sfUint32 codePoint, uint characterSize, sfBool bold, float outlineThickness);
}
else alias psfFont_getGlyph = sfGlyph function(sfFont* font, sfUint32 codePoint, uint characterSize, sfBool bold);
// Graphics/Image.h
alias psfImage_create = sfImage* function(uint width, uint height);
alias psfImage_createFromColor = sfImage* function(uint width, uint height, sfColor color);
alias psfImage_createFromPixels = sfImage* function(uint width, uint height, const(sfUint8)* pixels);
alias psfImage_createFromFile = sfImage* function(const(char)* filename);