mirrors/raylib
1
0
Fork 0
mirror of https://github.com/raysan5/raylib.git synced 2025-10-26 12:27:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reorganize examples folder

Browse Source
This commit is contained in:
Ray
2017-04-04 01:54:49 +02:00
parent 5a230659ef
commit dd4dd0e87d
222 changed files with 55637 additions and 663 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54966
examples/shaders/resources/model/dwarf.obj Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
examples/shaders/resources/model/dwarf_diffuse.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.2 MiB

BIN
examples/shaders/resources/model/dwarf_normal.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 3.9 MiB

BIN
examples/shaders/resources/model/dwarf_specular.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.8 MiB

456
examples/shaders/resources/model/lowpoly-tower.obj Normal file
View File

@@ -0,0 +1,456 @@
# Blender v2.78 (sub 0) OBJ File: 'lowpoly-tower.blend'
# www.blender.org
o Grid
v -4.000000 0.000000 4.000000
v -2.327363 0.000000 4.654725
v 0.000000 0.000000 4.654725
v 2.327363 0.000000 4.654725
v 4.000000 0.000000 4.000000
v -4.654725 0.955085 2.327363
v -2.000000 0.815050 2.000000
v 0.000000 0.476341 2.423448
v 2.000000 0.476341 2.000000
v 4.654725 0.000000 2.327363
v -4.654725 1.649076 0.000000
v -2.423448 1.092402 0.000000
v 2.423448 0.198579 0.000000
v 4.654725 0.000000 0.000000
v -4.654725 1.649076 -2.327363
v -2.000000 1.092402 -2.000000
v 0.000000 0.476341 -2.423448
v 2.000000 -0.012791 -2.000000
v 4.654725 0.000000 -2.612731
v -4.000000 0.955085 -4.000000
v -2.327363 0.955085 -4.654725
v 0.000000 0.955085 -4.654725
v 2.327363 0.000000 -4.654725
v 4.000000 0.000000 -4.000000
v 2.423448 0.682825 0.000000
v 2.000000 0.565423 -2.000000
v -4.654725 -0.020560 2.327363
v -4.654725 0.000000 0.000000
v -4.654725 0.000000 -2.327363
v -4.000000 0.000000 -4.000000
v -2.327363 0.000000 -4.654725
v 0.000000 -0.020560 -4.654725
v 0.000000 0.709880 -1.230535
v -0.000000 7.395413 0.000000
v 0.962071 0.709880 -0.767226
v -0.533909 0.709880 1.108674
v -1.199683 0.709880 0.273820
v -0.962071 0.709880 -0.767226
v 1.506076 0.859071 1.325337
v 1.199683 0.709880 0.273820
v 0.533909 0.709880 1.108674
v 0.000000 1.875340 -1.177842
v -0.000000 2.293973 -0.649884
v -0.000000 4.365648 -0.627970
v 0.000000 6.167194 -0.942957
v 0.000000 6.232434 -1.708677
v 1.335898 6.232434 -1.065343
v 0.737233 6.167195 -0.587924
v 0.490966 4.365648 -0.391533
v 0.508100 2.293973 -0.405196
v 0.920874 1.875340 -0.734372
v -0.741367 6.232434 1.539465
v -0.409133 6.167195 0.849574
v -0.272466 4.365648 0.565781
v -0.281974 2.293973 0.585526
v -0.511047 1.875340 1.061199
v -1.665837 6.232434 0.380217
v -0.919314 6.167195 0.209828
v -0.612225 4.365648 0.139736
v -0.633590 2.293973 0.144613
v -1.148311 1.875340 0.262095
v -1.335898 6.232434 -1.065343
v -0.737233 6.167195 -0.587924
v -0.490967 4.365648 -0.391533
v -0.508100 2.293973 -0.405196
v -0.920874 1.875340 -0.734372
v 1.665837 6.232434 0.380216
v 0.919315 6.167195 0.209828
v 0.612225 4.365648 0.139736
v 0.633590 2.293973 0.144613
v 1.148311 1.875340 0.262095
v 0.741367 6.232434 1.539465
v 0.409133 6.167195 0.849575
v 0.272466 4.365648 0.565781
v 0.281974 2.293973 0.585526
v 0.511046 1.875340 1.061199
v 0.000000 5.012550 -0.969733
v 0.758168 5.012550 -0.604618
v -0.420751 5.012550 0.873699
v -0.945419 5.012550 0.215786
v -0.758168 5.012550 -0.604618
v 0.945419 5.012550 0.215786
v 0.420751 5.012550 0.873699
vt 0.0523 0.5444
vt 0.1817 0.4284
vt 0.1641 0.5859
vt 0.0177 0.4451
vt 0.1526 0.3090
vt 0.0189 0.1737
vt 0.0188 0.3088
vt 0.0561 0.0762
vt 0.1757 0.1924
vt 0.3024 0.4534
vt 0.3071 0.5902
vt 0.3413 0.2459
vt 0.2906 0.1614
vt 0.4116 0.1801
vt 0.2834 0.3774
vt 0.1526 0.0362
vt 0.2917 0.1622
vt 0.4446 0.5865
vt 0.4443 0.2989
vt 0.3711 0.3021
vt 0.4396 0.0275
vt 0.4094 0.1829
vt 0.4219 0.4255
vt 0.5474 0.5381
vt 0.5811 0.4376
vt 0.5715 0.1505
vt 0.5811 0.2997
vt 0.5272 0.0533
vt 0.2208 0.2194
vt 0.3456 0.3610
vt 0.2878 0.0321
vt 0.2321 0.3392
vt 0.4432 0.0177
vt 0.7347 0.7934
vt 0.7382 0.7595
vt 0.8982 0.7768
vt 0.6169 0.7595
vt 0.6139 0.7879
vt 0.4951 0.7634
vt 0.1551 0.6832
vt 0.2925 0.6268
vt 0.2925 0.6832
vt 0.7795 0.6832
vt 0.6421 0.6268
vt 0.7795 0.6255
vt 0.5046 0.7241
vt 0.6421 0.7241
vt 0.3986 0.6268
vt 0.3986 0.6832
vt 0.5046 0.6268
vt 0.0177 0.6268
vt 0.1551 0.6255
vt 0.8856 0.6268
vt 0.1899 0.9579
vt 0.1194 0.8696
vt 0.2324 0.8696
vt 0.1899 0.7813
vt 0.0943 0.7595
vt 0.0177 0.8206
vt 0.0177 0.9186
vt 0.0943 0.9797
vt 0.2793 0.2349
vt 0.2304 0.2758
vt 0.6597 0.0177
vt 0.6954 0.0993
vt 0.6367 0.0768
vt 0.7558 0.0777
vt 0.7238 0.0440
vt 0.8840 0.1330
vt 0.7385 0.1141
vt 0.9157 0.0886
vt 0.9781 0.1232
vt 0.9224 0.1276
vt 0.2677 0.8141
vt 0.3463 0.8037
vt 0.3086 0.8339
vt 0.6387 0.3550
vt 0.7130 0.3801
vt 0.6596 0.4053
vt 0.7245 0.3245
vt 0.6919 0.3383
vt 0.8655 0.3566
vt 0.7351 0.3577
vt 0.9770 0.3365
vt 0.9078 0.3751
vt 0.9174 0.3282
vt 0.2677 0.9018
vt 0.3086 0.8821
vt 0.6803 0.2948
vt 0.6251 0.3035
vt 0.7194 0.2854
vt 0.8764 0.2832
vt 0.9221 0.2861
vt 0.3363 0.9565
vt 0.3464 0.9122
vt 0.6751 0.2482
vt 0.6178 0.2499
vt 0.7179 0.2431
vt 0.9823 0.2484
vt 0.9247 0.2452
vt 0.3935 0.9014
vt 0.6755 0.1996
vt 0.6164 0.1941
vt 0.7201 0.1992
vt 0.8793 0.2446
vt 0.9823 0.2060
vt 0.9257 0.2051
vt 0.4598 0.8580
vt 0.4144 0.8579
vt 0.6819 0.1498
vt 0.6222 0.1361
vt 0.7266 0.1555
vt 0.8831 0.1684
vt 0.9252 0.1659
vt 0.4218 0.7790
vt 0.3934 0.8145
vt 0.3363 0.7595
vt 0.8815 0.2060
vt 0.8720 0.3208
vt 0.8825 0.1012
vt 0.9735 0.0816
vt 0.9718 0.3817
vt 0.9807 0.2918
vt 0.4218 0.9370
vt 0.9810 0.1644
vn 0.1035 0.8806 0.4623
vn 0.0964 0.9481 0.3030
vn 0.0000 0.9780 0.2088
vn 0.0659 0.9835 0.1683
vn 0.2325 0.9320 0.2779
vn 0.0553 0.9960 -0.0702
vn 0.2827 0.9564 0.0728
vn 0.1873 0.9776 -0.0961
vn 0.2421 0.9703 0.0000
vn 0.0921 0.9772 -0.1913
vn -0.0277 0.9947 -0.0993
vn 0.2308 0.9274 -0.2944
vn 0.2771 0.9572 -0.0837
vn 0.3724 0.9074 0.1947
vn 0.0777 0.9770 -0.1985
vn -0.1094 0.9539 0.2794
vn 0.0364 0.9844 0.1721
vn 0.1683 0.9835 0.0659
vn 0.0674 0.9901 0.1230
vn 0.4338 0.8823 0.1829
vn 0.2845 0.9565 0.0649
vn 0.0886 0.9961 0.0000
vn 0.2000 0.9789 0.0424
vn 0.1417 0.9830 0.1171
vn 0.3021 0.9524 0.0412
vn -0.0193 0.9986 -0.0493
vn 0.0000 0.9777 0.2098
vn 0.0005 0.9781 -0.2083
vn 0.1879 0.9782 -0.0887
vn 0.2249 0.0000 0.9744
vn 0.9783 0.0000 -0.2071
vn 0.9783 0.0000 0.2071
vn 0.0000 0.0000 -1.0000
vn -1.0000 0.0000 0.0000
vn -0.3645 0.0000 -0.9312
vn -0.9312 0.0000 -0.3645
vn -0.9312 0.0000 0.3645
vn 0.2615 0.7979 -0.5431
vn 0.5877 0.7979 -0.1341
vn 0.4713 0.7979 0.3758
vn -0.0000 0.7979 0.6028
vn -0.4713 0.7979 0.3758
vn -0.5877 0.7979 -0.1341
vn -0.2615 0.7979 -0.5431
vn -0.1285 0.9864 -0.1025
vn 0.0929 0.8937 0.4389
vn -0.4335 0.0407 -0.9002
vn -0.2867 0.7507 -0.5952
vn -0.4339 0.0095 -0.9009
vn -0.4338 0.0209 -0.9008
vn -0.0408 -0.9956 -0.0848
vn -0.9741 0.0407 -0.2223
vn -0.6441 0.7507 -0.1470
vn -0.9749 0.0095 -0.2225
vn -0.9747 0.0209 -0.2225
vn -0.0918 -0.9956 -0.0209
vn -0.7812 0.0407 0.6230
vn -0.5165 0.7507 0.4119
vn -0.7818 0.0095 0.6235
vn -0.7817 0.0209 0.6234
vn -0.0736 -0.9956 0.0587
vn -0.0000 0.0407 0.9992
vn 0.0000 0.7507 0.6607
vn 0.0000 0.0095 1.0000
vn -0.0000 0.0209 0.9998
vn -0.0000 -0.9956 0.0941
vn 0.7812 0.0407 0.6230
vn 0.5165 0.7507 0.4119
vn 0.7818 0.0095 0.6235
vn 0.7817 0.0209 0.6234
vn 0.0736 -0.9956 0.0587
vn 0.9741 0.0407 -0.2223
vn 0.6441 0.7507 -0.1470
vn 0.9749 0.0095 -0.2225
vn 0.9747 0.0209 -0.2225
vn 0.0918 -0.9956 -0.0209
vn 0.4335 0.0407 -0.9002
vn 0.2867 0.7507 -0.5952
vn 0.4339 0.0095 -0.9009
vn 0.4338 0.0209 -0.9008
vn 0.0408 -0.9956 -0.0848
vn 0.3918 -0.4298 -0.8135
vn 0.8803 -0.4298 -0.2009
vn 0.7059 -0.4298 0.5630
vn -0.0000 -0.4298 0.9029
vn -0.7059 -0.4298 0.5630
vn -0.8803 -0.4298 -0.2009
vn -0.3918 -0.4298 -0.8135
vn 0.0210 0.9998 -0.0048
vn 0.0482 0.9981 -0.0385
vn -0.0166 0.9914 -0.1301
vn -0.0090 0.9904 -0.1379
vn 0.2820 0.9576 0.0597
vn -0.0000 0.9846 0.1749
vn -0.0921 0.9772 -0.1913
vn -0.1734 0.9794 0.1036
s off
f 1/1/1 7/2/1 6/3/1
f 2/4/2 8/5/2 7/2/2
f 4/6/3 8/5/3 3/7/3
f 5/8/4 9/9/4 4/6/4
f 6/3/5 12/10/5 11/11/5
f 35/12/6 25/13/6 26/14/6
f 7/2/7 37/15/7 12/10/7
f 10/16/8 13/17/8 9/9/8
f 12/10/9 15/18/9 11/11/9
f 35/12/10 17/19/10 33/20/10
f 13/17/11 19/21/11 18/22/11
f 16/23/12 20/24/12 15/18/12
f 17/19/13 21/25/13 16/23/13
f 17/19/14 23/26/14 22/27/14
f 26/14/15 24/28/15 23/26/15
f 1/1/16 2/4/16 7/2/16
f 2/4/3 3/7/3 8/5/3
f 4/6/17 9/9/17 8/5/17
f 5/8/18 10/16/18 9/9/18
f 6/3/19 7/2/19 12/10/19
f 25/13/20 39/29/20 9/9/20
f 38/30/21 12/10/21 37/15/21
f 10/16/22 14/31/22 13/17/22
f 12/10/23 16/23/23 15/18/23
f 8/5/24 36/32/24 7/2/24
f 38/30/25 17/19/25 16/23/25
f 13/17/22 14/31/22 19/21/22
f 16/23/26 21/25/26 20/24/26
f 17/19/27 22/27/27 21/25/27
f 17/19/28 26/14/28 23/26/28
f 26/14/29 19/33/29 24/28/29
f 26/34/30 18/35/30 19/36/30
f 26/34/31 13/37/31 18/35/31
f 25/38/32 9/39/32 13/37/32
f 22/40/33 31/41/33 21/42/33
f 6/43/34 28/44/34 27/45/34
f 15/46/34 28/44/34 11/47/34
f 21/42/35 30/48/35 20/49/35
f 20/49/36 29/50/36 15/46/36
f 22/40/33 23/51/33 32/52/33
f 6/43/37 27/45/37 1/53/37
f 46/54/38 34/55/38 47/56/38
f 47/56/39 34/55/39 67/57/39
f 67/57/40 34/55/40 72/58/40
f 72/58/41 34/55/41 52/59/41
f 52/59/42 34/55/42 57/60/42
f 57/60/43 34/55/43 62/61/43
f 62/61/44 34/55/44 46/54/44
f 40/62/45 41/63/45 39/29/45
f 39/29/46 8/5/46 9/9/46
f 38/64/47 42/65/47 33/66/47
f 65/67/48 42/65/48 66/68/48
f 65/67/49 44/69/49 43/70/49
f 81/71/50 45/72/50 77/73/50
f 62/74/51 45/75/51 63/76/51
f 37/77/52 66/78/52 38/79/52
f 60/80/53 66/78/53 61/81/53
f 60/80/54 64/82/54 65/83/54
f 58/84/55 81/85/55 80/86/55
f 57/87/56 63/76/56 58/88/56
f 56/89/57 37/77/57 36/90/57
f 55/91/58 61/81/58 56/89/58
f 54/92/59 60/80/59 55/91/59
f 79/93/60 58/84/60 80/86/60
f 52/94/61 58/88/61 53/95/61
f 76/96/62 36/90/62 41/97/62
f 75/98/63 56/89/63 76/96/63
f 75/98/64 54/92/64 55/91/64
f 73/99/65 79/93/65 83/100/65
f 73/101/66 52/94/66 53/95/66
f 71/102/67 41/97/67 40/103/67
f 70/104/68 76/96/68 71/102/68
f 70/104/69 74/105/69 75/98/69
f 68/106/70 83/100/70 82/107/70
f 67/108/71 73/101/71 68/109/71
f 51/110/72 40/103/72 35/111/72
f 50/112/73 71/102/73 51/110/73
f 49/113/74 70/104/74 50/112/74
f 78/114/75 68/106/75 82/107/75
f 47/115/76 68/109/76 48/116/76
f 42/65/77 35/111/77 33/66/77
f 43/70/78 51/110/78 42/65/78
f 44/69/79 50/112/79 43/70/79
f 45/72/80 78/114/80 77/73/80
f 46/117/81 48/116/81 45/75/81
f 44/69/82 78/114/82 49/113/82
f 49/113/83 82/107/83 69/118/83
f 82/107/84 74/105/84 69/118/84
f 83/100/85 54/92/85 74/105/85
f 79/93/86 59/119/86 54/92/86
f 80/86/87 64/82/87 59/119/87
f 64/120/88 77/73/88 44/69/88
f 35/12/89 40/62/89 25/13/89
f 7/2/90 36/32/90 37/15/90
f 35/12/91 26/14/91 17/19/91
f 25/13/92 40/62/92 39/29/92
f 38/30/93 16/23/93 12/10/93
f 8/5/94 41/63/94 36/32/94
f 38/30/95 33/20/95 17/19/95
f 26/34/31 25/38/31 13/37/31
f 22/40/33 32/52/33 31/41/33
f 6/43/34 11/47/34 28/44/34
f 15/46/34 29/50/34 28/44/34
f 21/42/35 31/41/35 30/48/35
f 20/49/36 30/48/36 29/50/36
f 39/29/96 41/63/96 8/5/96
f 38/64/47 66/68/47 42/65/47
f 65/67/48 43/70/48 42/65/48
f 65/67/49 64/120/49 44/69/49
f 81/71/50 63/121/50 45/72/50
f 62/74/51 46/117/51 45/75/51
f 37/77/52 61/81/52 66/78/52
f 60/80/53 65/83/53 66/78/53
f 60/80/54 59/119/54 64/82/54
f 58/84/55 63/122/55 81/85/55
f 57/87/56 62/74/56 63/76/56
f 56/89/57 61/81/57 37/77/57
f 55/91/58 60/80/58 61/81/58
f 54/92/59 59/119/59 60/80/59
f 79/93/60 53/123/60 58/84/60
f 52/94/61 57/87/61 58/88/61
f 76/96/62 56/89/62 36/90/62
f 75/98/63 55/91/63 56/89/63
f 75/98/64 74/105/64 54/92/64
f 73/99/65 53/123/65 79/93/65
f 73/101/66 72/124/66 52/94/66
f 71/102/67 76/96/67 41/97/67
f 70/104/68 75/98/68 76/96/68
f 70/104/69 69/118/69 74/105/69
f 68/106/70 73/99/70 83/100/70
f 67/108/71 72/124/71 73/101/71
f 51/110/72 71/102/72 40/103/72
f 50/112/73 70/104/73 71/102/73
f 49/113/74 69/118/74 70/104/74
f 78/114/75 48/125/75 68/106/75
f 47/115/76 67/108/76 68/109/76
f 42/65/77 51/110/77 35/111/77
f 43/70/78 50/112/78 51/110/78
f 44/69/79 49/113/79 50/112/79
f 45/72/80 48/125/80 78/114/80
f 46/117/81 47/115/81 48/116/81
f 44/69/82 77/73/82 78/114/82
f 49/113/83 78/114/83 82/107/83
f 82/107/84 83/100/84 74/105/84
f 83/100/85 79/93/85 54/92/85
f 79/93/86 80/86/86 59/119/86
f 80/86/87 81/85/87 64/82/87
f 64/120/88 81/71/88 77/73/88

BIN
examples/shaders/resources/model/lowpoly-tower.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 24 KiB

26
examples/shaders/resources/shaders/glsl100/base.vs Normal file
View File

@@ -0,0 +1,26 @@
#version 100
// Input vertex attributes
attribute vec3 vertexPosition;
attribute vec2 vertexTexCoord;
attribute vec3 vertexNormal;
attribute vec4 vertexColor;
// Input uniform values
uniform mat4 mvpMatrix;
// Output vertex attributes (to fragment shader)
varying vec2 fragTexCoord;
varying vec4 fragColor;
// NOTE: Add here your custom variables
void main()
{
// Send vertex attributes to fragment shader
fragTexCoord = vertexTexCoord;
fragColor = vertexColor;
// Calculate final vertex position
gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
}

39
examples/shaders/resources/shaders/glsl100/bloom.fs Normal file
View File

@@ -0,0 +1,39 @@
#version 100
precision mediump float;
// Input vertex attributes (from vertex shader)
varying vec2 fragTexCoord;
varying vec4 fragColor;
// Input uniform values
uniform sampler2D texture0;
uniform vec4 colDiffuse;
// NOTE: Add here your custom variables
const vec2 size = vec2(800, 450); // render size
const float samples = 5.0; // pixels per axis; higher = bigger glow, worse performance
const float quality = 2.5; // lower = smaller glow, better quality
void main()
{
vec4 sum = vec4(0);
vec2 sizeFactor = vec2(1)/size*quality;
// Texel color fetching from texture sampler
vec4 source = texture2D(texture0, fragTexCoord);
const int range = 2; // should be = (samples - 1)/2;
for (int x = -range; x <= range; x++)
{
for (int y = -range; y <= range; y++)
{
sum += texture2D(texture0, fragTexCoord + vec2(x, y)*sizeFactor);
}
}
// Calculate final fragment color
gl_FragColor = ((sum/(samples*samples)) + source)*colDiffuse;
}

54
examples/shaders/resources/shaders/glsl100/distortion.fs Normal file
View File

@@ -0,0 +1,54 @@
#version 100
precision mediump float;
// Input vertex attributes (from vertex shader)
varying vec2 fragTexCoord;
// Input uniform values
uniform sampler2D texture0;
// NOTE: Default parameters for Oculus Rift DK2 device
const vec2 LeftLensCenter = vec2(0.2863248, 0.5);
const vec2 RightLensCenter = vec2(0.7136753, 0.5);
const vec2 LeftScreenCenter = vec2(0.25, 0.5);
const vec2 RightScreenCenter = vec2(0.75, 0.5);
const vec2 Scale = vec2(0.25, 0.45);
const vec2 ScaleIn = vec2(4.0, 2.5);
const vec4 HmdWarpParam = vec4(1.0, 0.22, 0.24, 0.0);
const vec4 ChromaAbParam = vec4(0.996, -0.004, 1.014, 0.0);
void main()
{
// The following two variables need to be set per eye
vec2 LensCenter = fragTexCoord.x < 0.5 ? LeftLensCenter : RightLensCenter;
vec2 ScreenCenter = fragTexCoord.x < 0.5 ? LeftScreenCenter : RightScreenCenter;
// Scales input texture coordinates for distortion: vec2 HmdWarp(vec2 fragTexCoord, vec2 LensCenter)
vec2 theta = (fragTexCoord - LensCenter)*ScaleIn; // Scales to [-1, 1]
float rSq = theta.x*theta.x + theta.y*theta.y;
vec2 theta1 = theta*(HmdWarpParam.x + HmdWarpParam.y*rSq + HmdWarpParam.z*rSq*rSq + HmdWarpParam.w*rSq*rSq*rSq);
//vec2 tc = LensCenter + Scale*theta1;
// Detect whether blue texture coordinates are out of range since these will scaled out the furthest
vec2 thetaBlue = theta1*(ChromaAbParam.z + ChromaAbParam.w*rSq);
vec2 tcBlue = LensCenter + Scale*thetaBlue;
if (any(bvec2(clamp(tcBlue, ScreenCenter - vec2(0.25, 0.5), ScreenCenter + vec2(0.25, 0.5)) - tcBlue))) gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
else
{
// Do blue texture lookup
float blue = texture2D(texture0, tcBlue).b;
// Do green lookup (no scaling)
vec2 tcGreen = LensCenter + Scale*theta1;
float green = texture2D(texture0, tcGreen).g;
// Do red scale and lookup
vec2 thetaRed = theta1*(ChromaAbParam.x + ChromaAbParam.y*rSq);
vec2 tcRed = LensCenter + Scale*thetaRed;
float red = texture2D(texture0, tcRed).r;
gl_FragColor = vec4(red, green, blue, 1.0);
}
}

25
examples/shaders/resources/shaders/glsl100/grayscale.fs Normal file
View File

@@ -0,0 +1,25 @@
#version 100
precision mediump float;
// Input vertex attributes (from vertex shader)
varying vec2 fragTexCoord;
varying vec4 fragColor;
// Input uniform values
uniform sampler2D texture0;
uniform vec4 colDiffuse;
// NOTE: Add here your custom variables
void main()
{
// Texel color fetching from texture sampler
vec4 texelColor = texture2D(texture0, fragTexCoord)*colDiffuse*fragColor;
// Convert texel color to grayscale using NTSC conversion weights
float gray = dot(texelColor.rgb, vec3(0.299, 0.587, 0.114));
// Calculate final fragment color
gl_FragColor = vec4(gray, gray, gray, texelColor.a);
}

152
examples/shaders/resources/shaders/glsl100/standard.fs Normal file
View File

@@ -0,0 +1,152 @@
#version 100
precision mediump float;
varying vec3 fragPosition;
varying vec2 fragTexCoord;
varying vec4 fragColor;
varying vec3 fragNormal;
uniform sampler2D texture0;
uniform sampler2D texture1;
uniform sampler2D texture2;
uniform vec4 colAmbient;
uniform vec4 colDiffuse;
uniform vec4 colSpecular;
uniform float glossiness;
uniform int useNormal;
uniform int useSpecular;
uniform mat4 modelMatrix;
uniform vec3 viewDir;
struct Light {
int enabled;
int type;
vec3 position;
vec3 direction;
vec4 diffuse;
float intensity;
float radius;
float coneAngle;
};
const int maxLights = 8;
uniform Light lights[maxLights];
vec3 ComputeLightPoint(Light l, vec3 n, vec3 v, float s)
{
vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1.0));
vec3 surfaceToLight = l.position - surfacePos;
// Diffuse shading
float brightness = clamp(float(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n))), 0.0, 1.0);
float diff = 1.0/dot(surfaceToLight/l.radius, surfaceToLight/l.radius)*brightness*l.intensity;
// Specular shading
float spec = 0.0;
if (diff > 0.0)
{
vec3 h = normalize(-l.direction + v);
spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
}
return (diff*l.diffuse.rgb + spec*colSpecular.rgb);
}
vec3 ComputeLightDirectional(Light l, vec3 n, vec3 v, float s)
{
vec3 lightDir = normalize(-l.direction);
// Diffuse shading
float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
// Specular shading
float spec = 0.0;
if (diff > 0.0)
{
vec3 h = normalize(lightDir + v);
spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
}
// Combine results
return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);
}
vec3 ComputeLightSpot(Light l, vec3 n, vec3 v, float s)
{
vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
vec3 lightToSurface = normalize(surfacePos - l.position);
vec3 lightDir = normalize(-l.direction);
// Diffuse shading
float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
// Spot attenuation
float attenuation = clamp(float(dot(n, lightToSurface)), 0.0, 1.0);
attenuation = dot(lightToSurface, -lightDir);
float lightToSurfaceAngle = degrees(acos(attenuation));
if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;
float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;
// Combine diffuse and attenuation
float diffAttenuation = diff*attenuation;
// Specular shading
float spec = 0.0;
if (diffAttenuation > 0.0)
{
vec3 h = normalize(lightDir + v);
spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
}
return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
}
void main()
{
// Calculate fragment normal in screen space
// NOTE: important to multiply model matrix by fragment normal to apply model transformation (rotation and scale)
mat3 normalMatrix = mat3(modelMatrix);
vec3 normal = normalize(normalMatrix*fragNormal);
// Normalize normal and view direction vectors
vec3 n = normalize(normal);
vec3 v = normalize(viewDir);
// Calculate diffuse texture color fetching
vec4 texelColor = texture2D(texture0, fragTexCoord);
vec3 lighting = colAmbient.rgb;
// Calculate normal texture color fetching or set to maximum normal value by default
if (useNormal == 1)
{
n *= texture2D(texture1, fragTexCoord).rgb;
n = normalize(n);
}
// Calculate specular texture color fetching or set to maximum specular value by default
float spec = 1.0;
if (useSpecular == 1) spec = texture2D(texture2, fragTexCoord).r;
for (int i = 0; i < maxLights; i++)
{
// Check if light is enabled
if (lights[i].enabled == 1)
{
// Calculate lighting based on light type
if(lights[i].type == 0) lighting += ComputeLightPoint(lights[i], n, v, spec);
else if(lights[i].type == 1) lighting += ComputeLightDirectional(lights[i], n, v, spec);
else if(lights[i].type == 2) lighting += ComputeLightSpot(lights[i], n, v, spec);
// NOTE: It seems that too many ComputeLight*() operations inside for loop breaks the shader on RPI
}
}
// Calculate final fragment color
gl_FragColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a);
}

23
examples/shaders/resources/shaders/glsl100/standard.vs Normal file
View File

@@ -0,0 +1,23 @@
#version 100
attribute vec3 vertexPosition;
attribute vec3 vertexNormal;
attribute vec2 vertexTexCoord;
attribute vec4 vertexColor;
varying vec3 fragPosition;
varying vec2 fragTexCoord;
varying vec4 fragColor;
varying vec3 fragNormal;
uniform mat4 mvpMatrix;
void main()
{
fragPosition = vertexPosition;
fragTexCoord = vertexTexCoord;
fragColor = vertexColor;
fragNormal = vertexNormal;
gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
}

45
examples/shaders/resources/shaders/glsl100/swirl.fs Normal file
View File

@@ -0,0 +1,45 @@
#version 100
precision mediump float;
// Input vertex attributes (from vertex shader)
varying vec2 fragTexCoord;
varying vec4 fragColor;
// Input uniform values
uniform sampler2D texture0;
uniform vec4 colDiffuse;
// NOTE: Add here your custom variables
const float renderWidth = 800.0; // HARDCODED for example!
const float renderHeight = 480.0; // Use uniforms instead...
float radius = 250.0;
float angle = 0.8;
uniform vec2 center;
void main()
{
vec2 texSize = vec2(renderWidth, renderHeight);
vec2 tc = fragTexCoord*texSize;
tc -= center;
float dist = length(tc);
if (dist < radius)
{
float percent = (radius - dist)/radius;
float theta = percent*percent*angle*8.0;
float s = sin(theta);
float c = cos(theta);
tc = vec2(dot(tc, vec2(c, -s)), dot(tc, vec2(s, c)));
}
tc += center;
vec4 color = texture2D(texture0, tc/texSize)*colDiffuse*fragColor;;
gl_FragColor = vec4(color.rgb, 1.0);;
}

26
examples/shaders/resources/shaders/glsl330/base.vs Normal file
View File

@@ -0,0 +1,26 @@
#version 330
// Input vertex attributes
in vec3 vertexPosition;
in vec2 vertexTexCoord;
in vec3 vertexNormal;
in vec4 vertexColor;
// Input uniform values
uniform mat4 mvpMatrix;
// Output vertex attributes (to fragment shader)
out vec2 fragTexCoord;
out vec4 fragColor;
// NOTE: Add here your custom variables
void main()
{
// Send vertex attributes to fragment shader
fragTexCoord = vertexTexCoord;
fragColor = vertexColor;
// Calculate final vertex position
gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
}

40
examples/shaders/resources/shaders/glsl330/bloom.fs Normal file
View File

@@ -0,0 +1,40 @@
#version 330
// Input vertex attributes (from vertex shader)
in vec2 fragTexCoord;
in vec4 fragColor;
// Input uniform values
uniform sampler2D texture0;
uniform vec4 colDiffuse;
// Output fragment color
out vec4 finalColor;
// NOTE: Add here your custom variables
const vec2 size = vec2(800, 450); // render size
const float samples = 5.0; // pixels per axis; higher = bigger glow, worse performance
const float quality = 2.5; // lower = smaller glow, better quality
void main()
{
vec4 sum = vec4(0);
vec2 sizeFactor = vec2(1)/size*quality;
// Texel color fetching from texture sampler
vec4 source = texture(texture0, fragTexCoord);
const int range = 2; // should be = (samples - 1)/2;
for (int x = -range; x <= range; x++)
{
for (int y = -range; y <= range; y++)
{
sum += texture(texture0, fragTexCoord + vec2(x, y)*sizeFactor);
}
}
// Calculate final fragment color
finalColor = ((sum/(samples*samples)) + source)*colDiffuse;
}

27
examples/shaders/resources/shaders/glsl330/depth.fs Normal file
View File

@@ -0,0 +1,27 @@
#version 330
// Input vertex attributes (from vertex shader)
in vec2 fragTexCoord;
in vec4 fragColor;
// Input uniform values
uniform sampler2D texture0; // Depth texture
uniform vec4 fragTintColor;
// Output fragment color
out vec4 finalColor;
// NOTE: Add here your custom variables
void main()
{
float zNear = 0.01; // camera z near
float zFar = 10.0; // camera z far
float z = texture(texture0, fragTexCoord).x;
// Linearize depth value
float depth = (2.0*zNear)/(zFar + zNear - z*(zFar - zNear));
// Calculate final fragment color
finalColor = vec4(depth, depth, depth, 1.0f);
}

56
examples/shaders/resources/shaders/glsl330/distortion.fs Normal file
View File

@@ -0,0 +1,56 @@
#version 330
// Input vertex attributes (from vertex shader)
in vec2 fragTexCoord;
// Input uniform values
uniform sampler2D texture0;
// Output fragment color
out vec4 finalColor;
// NOTE: Default parameters for Oculus Rift DK2 device
const vec2 LeftLensCenter = vec2(0.2863248, 0.5);
const vec2 RightLensCenter = vec2(0.7136753, 0.5);
const vec2 LeftScreenCenter = vec2(0.25, 0.5);
const vec2 RightScreenCenter = vec2(0.75, 0.5);
const vec2 Scale = vec2(0.25, 0.45);
const vec2 ScaleIn = vec2(4.0, 2.5);
const vec4 HmdWarpParam = vec4(1.0, 0.22, 0.24, 0.0);
const vec4 ChromaAbParam = vec4(0.996, -0.004, 1.014, 0.0);
void main()
{
// The following two variables need to be set per eye
vec2 LensCenter = fragTexCoord.x < 0.5 ? LeftLensCenter : RightLensCenter;
vec2 ScreenCenter = fragTexCoord.x < 0.5 ? LeftScreenCenter : RightScreenCenter;
// Scales input texture coordinates for distortion: vec2 HmdWarp(vec2 fragTexCoord, vec2 LensCenter)
vec2 theta = (fragTexCoord - LensCenter)*ScaleIn; // Scales to [-1, 1]
float rSq = theta.x*theta.x + theta.y*theta.y;
vec2 theta1 = theta*(HmdWarpParam.x + HmdWarpParam.y*rSq + HmdWarpParam.z*rSq*rSq + HmdWarpParam.w*rSq*rSq*rSq);
//vec2 tc = LensCenter + Scale*theta1;
// Detect whether blue texture coordinates are out of range since these will scaled out the furthest
vec2 thetaBlue = theta1*(ChromaAbParam.z + ChromaAbParam.w*rSq);
vec2 tcBlue = LensCenter + Scale*thetaBlue;
if (any(bvec2(clamp(tcBlue, ScreenCenter - vec2(0.25, 0.5), ScreenCenter + vec2(0.25, 0.5)) - tcBlue))) finalColor = vec4(0.0, 0.0, 0.0, 1.0);
else
{
// Do blue texture lookup
float blue = texture(texture0, tcBlue).b;
// Do green lookup (no scaling)
vec2 tcGreen = LensCenter + Scale*theta1;
float green = texture(texture0, tcGreen).g;
// Do red scale and lookup
vec2 thetaRed = theta1*(ChromaAbParam.x + ChromaAbParam.y*rSq);
vec2 tcRed = LensCenter + Scale*thetaRed;
float red = texture(texture0, tcRed).r;
finalColor = vec4(red, green, blue, 1.0);
}
}

26
examples/shaders/resources/shaders/glsl330/grayscale.fs Normal file
View File

@@ -0,0 +1,26 @@
#version 330
// Input vertex attributes (from vertex shader)
in vec2 fragTexCoord;
in vec4 fragColor;
// Input uniform values
uniform sampler2D texture0;
uniform vec4 colDiffuse;
// Output fragment color
out vec4 finalColor;
// NOTE: Add here your custom variables
void main()
{
// Texel color fetching from texture sampler
vec4 texelColor = texture(texture0, fragTexCoord)*colDiffuse*fragColor;
// Convert texel color to grayscale using NTSC conversion weights
float gray = dot(texelColor.rgb, vec3(0.299, 0.587, 0.114));
// Calculate final fragment color
finalColor = vec4(gray, gray, gray, texelColor.a);
}

150
examples/shaders/resources/shaders/glsl330/standard.fs Normal file
View File

@@ -0,0 +1,150 @@
#version 330
in vec3 fragPosition;
in vec2 fragTexCoord;
in vec4 fragColor;
in vec3 fragNormal;
out vec4 finalColor;
uniform sampler2D texture0;
uniform sampler2D texture1;
uniform sampler2D texture2;
uniform vec4 colAmbient;
uniform vec4 colDiffuse;
uniform vec4 colSpecular;
uniform float glossiness;
uniform int useNormal;
uniform int useSpecular;
uniform mat4 modelMatrix;
uniform vec3 viewDir;
struct Light {
int enabled;
int type;
vec3 position;
vec3 direction;
vec4 diffuse;
float intensity;
float radius;
float coneAngle;
};
const int maxLights = 8;
uniform Light lights[maxLights];
vec3 ComputeLightPoint(Light l, vec3 n, vec3 v, float s)
{
vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
vec3 surfaceToLight = l.position - surfacePos;
// Diffuse shading
float brightness = clamp(float(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n))), 0.0, 1.0);
float diff = 1.0/dot(surfaceToLight/l.radius, surfaceToLight/l.radius)*brightness*l.intensity;
// Specular shading
float spec = 0.0;
if (diff > 0.0)
{
vec3 h = normalize(-l.direction + v);
spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
}
return (diff*l.diffuse.rgb + spec*colSpecular.rgb);
}
vec3 ComputeLightDirectional(Light l, vec3 n, vec3 v, float s)
{
vec3 lightDir = normalize(-l.direction);
// Diffuse shading
float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
// Specular shading
float spec = 0.0;
if (diff > 0.0)
{
vec3 h = normalize(lightDir + v);
spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
}
// Combine results
return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);
}
vec3 ComputeLightSpot(Light l, vec3 n, vec3 v, float s)
{
vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
vec3 lightToSurface = normalize(surfacePos - l.position);
vec3 lightDir = normalize(-l.direction);
// Diffuse shading
float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
// Spot attenuation
float attenuation = clamp(float(dot(n, lightToSurface)), 0.0, 1.0);
attenuation = dot(lightToSurface, -lightDir);
float lightToSurfaceAngle = degrees(acos(attenuation));
if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;
float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;
// Combine diffuse and attenuation
float diffAttenuation = diff*attenuation;
// Specular shading
float spec = 0.0;
if (diffAttenuation > 0.0)
{
vec3 h = normalize(lightDir + v);
spec = pow(abs(dot(n, h)), 3.0 + glossiness)*s;
}
return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
}
void main()
{
// Calculate fragment normal in screen space
// NOTE: important to multiply model matrix by fragment normal to apply model transformation (rotation and scale)
mat3 normalMatrix = mat3(modelMatrix);
vec3 normal = normalize(normalMatrix*fragNormal);
// Normalize normal and view direction vectors
vec3 n = normalize(normal);
vec3 v = normalize(viewDir);
// Calculate diffuse texture color fetching
vec4 texelColor = texture(texture0, fragTexCoord);
vec3 lighting = colAmbient.rgb;
// Calculate normal texture color fetching or set to maximum normal value by default
if (useNormal == 1)
{
n *= texture(texture1, fragTexCoord).rgb;
n = normalize(n);
}
// Calculate specular texture color fetching or set to maximum specular value by default
float spec = 1.0;
if (useSpecular == 1) spec = texture(texture2, fragTexCoord).r;
for (int i = 0; i < maxLights; i++)
{
// Check if light is enabled
if (lights[i].enabled == 1)
{
// Calculate lighting based on light type
if (lights[i].type == 0) lighting += ComputeLightPoint(lights[i], n, v, spec);
else if (lights[i].type == 1) lighting += ComputeLightDirectional(lights[i], n, v, spec);
else if (lights[i].type == 2) lighting += ComputeLightSpot(lights[i], n, v, spec);
}
}
// Calculate final fragment color
finalColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a);
}

23
examples/shaders/resources/shaders/glsl330/standard.vs Normal file
View File

@@ -0,0 +1,23 @@
#version 330
in vec3 vertexPosition;
in vec3 vertexNormal;
in vec2 vertexTexCoord;
in vec4 vertexColor;
out vec3 fragPosition;
out vec2 fragTexCoord;
out vec4 fragColor;
out vec3 fragNormal;
uniform mat4 mvpMatrix;
void main()
{
fragPosition = vertexPosition;
fragTexCoord = vertexTexCoord;
fragColor = vertexColor;
fragNormal = vertexNormal;
gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
}

46
examples/shaders/resources/shaders/glsl330/swirl.fs Normal file
View File

@@ -0,0 +1,46 @@
#version 330
// Input vertex attributes (from vertex shader)
in vec2 fragTexCoord;
in vec4 fragColor;
// Input uniform values
uniform sampler2D texture0;
uniform vec4 colDiffuse;
// Output fragment color
out vec4 finalColor;
// NOTE: Add here your custom variables
const float renderWidth = 800.0; // HARDCODED for example!
const float renderHeight = 480.0; // Use uniforms instead...
float radius = 250.0;
float angle = 0.8;
uniform vec2 center = vec2(200.0, 200.0);
void main()
{
vec2 texSize = vec2(renderWidth, renderHeight);
vec2 tc = fragTexCoord*texSize;
tc -= center;
float dist = length(tc);
if (dist < radius)
{
float percent = (radius - dist)/radius;
float theta = percent*percent*angle*8.0;
float s = sin(theta);
float c = cos(theta);
tc = vec2(dot(tc, vec2(c, -s)), dot(tc, vec2(s, c)));
}
tc += center;
vec4 color = texture2D(texture0, tc/texSize)*colDiffuse*fragColor;;
finalColor = vec4(color.rgb, 1.0);;
}

BIN
examples/shaders/resources/sonic.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 114 KiB

121
examples/shaders/shaders_custom_uniform.c Normal file
View File

@@ -0,0 +1,121 @@
/*******************************************************************************************
*
* raylib [shaders] example - Apply a postprocessing shader and connect a custom uniform variable
*
* NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
* OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
*
* NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
* on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
* raylib comes with shaders ready for both versions, check raylib/shaders install folder
*
* This example has been created using raylib 1.3 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
*
* Copyright (c) 2015 Ramon Santamaria (@raysan5)
*
********************************************************************************************/
#include "raylib.h"
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int screenHeight = 450;
SetConfigFlags(FLAG_MSAA_4X_HINT); // Enable Multi Sampling Anti Aliasing 4x (if available)
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - custom uniform variable");
// Define the camera to look into our 3d world
Camera camera = {{ 3.0f, 3.0f, 3.0f }, { 0.0f, 1.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
Model dwarf = LoadModel("resources/model/dwarf.obj"); // Load OBJ model
Texture2D texture = LoadTexture("resources/model/dwarf_diffuse.png"); // Load model texture (diffuse map)
dwarf.material.texDiffuse = texture; // Set dwarf model diffuse texture
Vector3 position = { 0.0f, 0.0f, 0.0f }; // Set model position
Shader shader = LoadShader("resources/shaders/glsl330/base.vs",
"resources/shaders/glsl330/swirl.fs"); // Load postpro shader
// Get variable (uniform) location on the shader to connect with the program
// NOTE: If uniform variable could not be found in the shader, function returns -1
int swirlCenterLoc = GetShaderLocation(shader, "center");
float swirlCenter[2] = { (float)screenWidth/2, (float)screenHeight/2 };
// Create a RenderTexture2D to be used for render to texture
RenderTexture2D target = LoadRenderTexture(screenWidth, screenHeight);
// Setup orbital camera
SetCameraMode(camera, CAMERA_ORBITAL); // Set an orbital camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
Vector2 mousePosition = GetMousePosition();
swirlCenter[0] = mousePosition.x;
swirlCenter[1] = screenHeight - mousePosition.y;
// Send new value to the shader to be used on drawing
SetShaderValue(shader, swirlCenterLoc, swirlCenter, 2);
UpdateCamera(&camera); // Update camera
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(RAYWHITE);
BeginTextureMode(target); // Enable drawing to texture
Begin3dMode(camera);
DrawModel(dwarf, position, 2.0f, WHITE); // Draw 3d model with texture
DrawGrid(10, 1.0f); // Draw a grid
End3dMode();
DrawText("TEXT DRAWN IN RENDER TEXTURE", 200, 10, 30, RED);
EndTextureMode(); // End drawing to texture (now we have a texture available for next passes)
BeginShaderMode(shader);
// NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom)
DrawTextureRec(target.texture, (Rectangle){ 0, 0, target.texture.width, -target.texture.height }, (Vector2){ 0, 0 }, WHITE);
EndShaderMode();
DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY);
DrawFPS(10, 10);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
UnloadShader(shader); // Unload shader
UnloadTexture(texture); // Unload texture
UnloadModel(dwarf); // Unload model
UnloadRenderTexture(target); // Unload render texture
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}

BIN
examples/shaders/shaders_custom_uniform.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 252 KiB

93
examples/shaders/shaders_model_shader.c Normal file
View File

@@ -0,0 +1,93 @@
/*******************************************************************************************
*
* raylib [shaders] example - Apply a shader to a 3d model
*
* NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
* OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
*
* NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
* on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
* raylib comes with shaders ready for both versions, check raylib/shaders install folder
*
* This example has been created using raylib 1.3 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
*
* Copyright (c) 2014 Ramon Santamaria (@raysan5)
*
********************************************************************************************/
#include "raylib.h"
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int screenHeight = 450;
SetConfigFlags(FLAG_MSAA_4X_HINT); // Enable Multi Sampling Anti Aliasing 4x (if available)
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader");
// Define the camera to look into our 3d world
Camera camera = {{ 3.0f, 3.0f, 3.0f }, { 0.0f, 1.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
Model dwarf = LoadModel("resources/model/dwarf.obj"); // Load OBJ model
Texture2D texture = LoadTexture("resources/model/dwarf_diffuse.png"); // Load model texture
Shader shader = LoadShader("resources/shaders/glsl330/base.vs",
"resources/shaders/glsl330/grayscale.fs"); // Load model shader
dwarf.material.shader = shader; // Set shader effect to 3d model
dwarf.material.texDiffuse = texture; // Bind texture to model
Vector3 position = { 0.0f, 0.0f, 0.0f }; // Set model position
SetCameraMode(camera, CAMERA_FREE); // Set an orbital camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update camera
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(RAYWHITE);
Begin3dMode(camera);
DrawModel(dwarf, position, 2.0f, WHITE); // Draw 3d model with texture
DrawGrid(10, 1.0f); // Draw a grid
End3dMode();
DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY);
DrawText(FormatText("Camera position: (%.2f, %.2f, %.2f)", camera.position.x, camera.position.y, camera.position.z), 600, 20, 10, BLACK);
DrawText(FormatText("Camera target: (%.2f, %.2f, %.2f)", camera.target.x, camera.target.y, camera.target.z), 600, 40, 10, GRAY);
DrawFPS(10, 10);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
UnloadShader(shader); // Unload shader
UnloadTexture(texture); // Unload texture
UnloadModel(dwarf); // Unload model
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}

BIN
examples/shaders/shaders_model_shader.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 139 KiB

107
examples/shaders/shaders_postprocessing.c Normal file
View File

@@ -0,0 +1,107 @@
/*******************************************************************************************
*
* raylib [shaders] example - Apply a postprocessing shader to a scene
*
* NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
* OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
*
* NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
* on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
* raylib comes with shaders ready for both versions, check raylib/shaders install folder
*
* This example has been created using raylib 1.3 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
*
* Copyright (c) 2015 Ramon Santamaria (@raysan5)
*
********************************************************************************************/
#include "raylib.h"
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int screenHeight = 450;
SetConfigFlags(FLAG_MSAA_4X_HINT); // Enable Multi Sampling Anti Aliasing 4x (if available)
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - postprocessing shader");
// Define the camera to look into our 3d world
Camera camera = {{ 3.0f, 3.0f, 3.0f }, { 0.0f, 1.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
Model dwarf = LoadModel("resources/model/dwarf.obj"); // Load OBJ model
Texture2D texture = LoadTexture("resources/model/dwarf_diffuse.png"); // Load model texture (diffuse map)
dwarf.material.texDiffuse = texture; // Set dwarf model diffuse texture
Vector3 position = { 0.0f, 0.0f, 0.0f }; // Set model position
Shader shader = LoadShader("resources/shaders/glsl330/base.vs",
"resources/shaders/glsl330/bloom.fs"); // Load postpro shader
// Create a RenderTexture2D to be used for render to texture
RenderTexture2D target = LoadRenderTexture(screenWidth, screenHeight);
// Setup orbital camera
SetCameraMode(camera, CAMERA_ORBITAL); // Set an orbital camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update camera
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(RAYWHITE);
BeginTextureMode(target); // Enable drawing to texture
Begin3dMode(camera);
DrawModel(dwarf, position, 2.0f, WHITE); // Draw 3d model with texture
DrawGrid(10, 1.0f); // Draw a grid
End3dMode();
DrawText("HELLO POSTPROCESSING!", 70, 190, 50, RED);
EndTextureMode(); // End drawing to texture (now we have a texture available for next passes)
BeginShaderMode(shader);
// NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom)
DrawTextureRec(target.texture, (Rectangle){ 0, 0, target.texture.width, -target.texture.height }, (Vector2){ 0, 0 }, WHITE);
EndShaderMode();
DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, DARKGRAY);
DrawFPS(10, 10);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
UnloadShader(shader); // Unload shader
UnloadTexture(texture); // Unload texture
UnloadModel(dwarf); // Unload model
UnloadRenderTexture(target); // Unload render texture
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}

BIN
examples/shaders/shaders_postprocessing.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 232 KiB

112
examples/shaders/shaders_shapes_textures.c Normal file
View File

@@ -0,0 +1,112 @@
/*******************************************************************************************
*
* raylib [shaders] example - Apply a shader to some shape or texture
*
* NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
* OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
*
* NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
* on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
* raylib comes with shaders ready for both versions, check raylib/shaders install folder
*
* This example has been created using raylib 1.3 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
*
* Copyright (c) 2015 Ramon Santamaria (@raysan5)
*
********************************************************************************************/
#include "raylib.h"
#include <stdio.h>
#include <stdlib.h>
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shapes and texture shaders");
Texture2D sonic = LoadTexture("resources/texture_formats/sonic.png");
// NOTE: Using GLSL 330 shader version, on OpenGL ES 2.0 use GLSL 100 shader version
Shader shader = LoadShader("resources/shaders/glsl330/base.vs",
"resources/shaders/glsl330/grayscale.fs");
// Shader usage is also different than models/postprocessing, shader is just activated when required
SetTargetFPS(60);
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
// TODO: Update your variables here
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(RAYWHITE);
// Start drawing with default shader
DrawText("USING DEFAULT SHADER", 20, 40, 10, RED);
DrawCircle(80, 120, 35, DARKBLUE);
DrawCircleGradient(80, 220, 60, GREEN, SKYBLUE);
DrawCircleLines(80, 340, 80, DARKBLUE);
// Activate our custom shader to be applied on next shapes/textures drawings
BeginShaderMode(shader);
DrawText("USING CUSTOM SHADER", 190, 40, 10, RED);
DrawRectangle(250 - 60, 90, 120, 60, RED);
DrawRectangleGradient(250 - 90, 170, 180, 130, MAROON, GOLD);
DrawRectangleLines(250 - 40, 320, 80, 60, ORANGE);
// Activate our default shader for next drawings
EndShaderMode();
DrawText("USING DEFAULT SHADER", 370, 40, 10, RED);
DrawTriangle((Vector2){430, 80},
(Vector2){430 - 60, 150},
(Vector2){430 + 60, 150}, VIOLET);
DrawTriangleLines((Vector2){430, 160},
(Vector2){430 - 20, 230},
(Vector2){430 + 20, 230}, DARKBLUE);
DrawPoly((Vector2){430, 320}, 6, 80, 0, BROWN);
// Activate our custom shader to be applied on next shapes/textures drawings
BeginShaderMode(shader);
DrawTexture(sonic, 380, -10, WHITE); // Using custom shader
// Activate our default shader for next drawings
EndShaderMode();
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
UnloadShader(shader); // Unload shader
UnloadTexture(sonic); // Unload texture
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}

BIN
examples/shaders/shaders_shapes_textures.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 108 KiB

482
examples/shaders/shaders_standard_lighting.c Normal file
View File

@@ -0,0 +1,482 @@
/*******************************************************************************************
*
* raylib [shaders] example - Standard lighting (materials and lights)
*
* NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
* OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
*
* NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
* on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
* raylib comes with shaders ready for both versions, check raylib/shaders install folder
*
* This example has been created using raylib 1.7 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
*
* Copyright (c) 2016-2017 Ramon Santamaria (@raysan5)
*
********************************************************************************************/
#include "raylib.h"
#include <stdlib.h> // Required for: NULL
#include <string.h> // Required for: strcpy()
#include <math.h> // Required for: vector math
//----------------------------------------------------------------------------------
// Defines and Macros
//----------------------------------------------------------------------------------
#define MAX_LIGHTS 8 // Max lights supported by standard shader
//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------
// Light type
typedef struct LightData {
unsigned int id; // Light unique id
bool enabled; // Light enabled
int type; // Light type: LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_SPOT
Vector3 position; // Light position
Vector3 target; // Light direction: LIGHT_DIRECTIONAL and LIGHT_SPOT (cone direction target)
float radius; // Light attenuation radius light intensity reduced with distance (world distance)
Color diffuse; // Light diffuse color
float intensity; // Light intensity level
float coneAngle; // Light cone max angle: LIGHT_SPOT
} LightData, *Light;
// Light types
typedef enum { LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_SPOT } LightType;
//----------------------------------------------------------------------------------
// Global Variables Definition
//----------------------------------------------------------------------------------
static Light lights[MAX_LIGHTS]; // Lights pool
static int lightsCount = 0; // Enabled lights counter
static int lightsLocs[MAX_LIGHTS][8]; // Lights location points in shader: 8 possible points per light:
// enabled, type, position, target, radius, diffuse, intensity, coneAngle
//----------------------------------------------------------------------------------
// Module Functions Declaration
//----------------------------------------------------------------------------------
static Light CreateLight(int type, Vector3 position, Color diffuse); // Create a new light, initialize it and add to pool
static void DestroyLight(Light light); // Destroy a light and take it out of the list
static void DrawLight(Light light); // Draw light in 3D world
static void GetShaderLightsLocations(Shader shader); // Get shader locations for lights (up to MAX_LIGHTS)
static void SetShaderLightsValues(Shader shader); // Set shader uniform values for lights
// Vector3 math functions
static float VectorLength(const Vector3 v); // Calculate vector lenght
static void VectorNormalize(Vector3 *v); // Normalize provided vector
static Vector3 VectorSubtract(Vector3 v1, Vector3 v2); // Substract two vectors
//https://www.gamedev.net/topic/655969-speed-gluniform-vs-uniform-buffer-objects/
//https://www.reddit.com/r/opengl/comments/4ri20g/is_gluniform_more_expensive_than_glprogramuniform/
//http://cg.alexandra.dk/?p=3778 - AZDO
//https://developer.apple.com/library/content/documentation/3DDrawing/Conceptual/OpenGLES_ProgrammingGuide/BestPracticesforShaders/BestPracticesforShaders.html
//------------------------------------------------------------------------------------
// Program main entry point
//------------------------------------------------------------------------------------
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int screenHeight = 450;
SetConfigFlags(FLAG_MSAA_4X_HINT); // Enable Multi Sampling Anti Aliasing 4x (if available)
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader");
// Define the camera to look into our 3d world
Camera camera = {{ 4.0f, 4.0f, 4.0f }, { 0.0f, 1.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
Vector3 position = { 0.0f, 0.0f, 0.0f }; // Set model position
Model dwarf = LoadModel("resources/model/dwarf.obj"); // Load OBJ model
Material material;// = LoadStandardMaterial();
material.shader = LoadShader("resources/shaders/glsl330/standard.vs", "resources/shaders/glsl330/standard.fs");
// Try to get lights location points (if available)
GetShaderLightsLocations(material.shader);
material.texDiffuse = LoadTexture("resources/model/dwarf_diffuse.png"); // Load model diffuse texture
material.texNormal = LoadTexture("resources/model/dwarf_normal.png"); // Load model normal texture
material.texSpecular = LoadTexture("resources/model/dwarf_specular.png"); // Load model specular texture
material.colDiffuse = WHITE;
material.colAmbient = (Color){0, 0, 10, 255};
material.colSpecular = WHITE;
material.glossiness = 50.0f;
dwarf.material = material; // Apply material to model
Light spotLight = CreateLight(LIGHT_SPOT, (Vector3){3.0f, 5.0f, 2.0f}, (Color){255, 255, 255, 255});
spotLight->target = (Vector3){0.0f, 0.0f, 0.0f};
spotLight->intensity = 2.0f;
spotLight->diffuse = (Color){255, 100, 100, 255};
spotLight->coneAngle = 60.0f;
Light dirLight = CreateLight(LIGHT_DIRECTIONAL, (Vector3){0.0f, -3.0f, -3.0f}, (Color){255, 255, 255, 255});
dirLight->target = (Vector3){1.0f, -2.0f, -2.0f};
dirLight->intensity = 2.0f;
dirLight->diffuse = (Color){100, 255, 100, 255};
Light pointLight = CreateLight(LIGHT_POINT, (Vector3){0.0f, 4.0f, 5.0f}, (Color){255, 255, 255, 255});
pointLight->intensity = 2.0f;
pointLight->diffuse = (Color){100, 100, 255, 255};
pointLight->radius = 3.0f;
// Set shader lights values for enabled lights
// NOTE: If values are not changed in real time, they can be set at initialization!!!
SetShaderLightsValues(material.shader);
//SetShaderActive(0);
// Setup orbital camera
SetCameraMode(camera, CAMERA_ORBITAL); // Set an orbital camera mode
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
UpdateCamera(&camera); // Update camera
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(RAYWHITE);
Begin3dMode(camera);
DrawModel(dwarf, position, 2.0f, WHITE); // Draw 3d model with texture
DrawLight(spotLight); // Draw spot light
DrawLight(dirLight); // Draw directional light
DrawLight(pointLight); // Draw point light
DrawGrid(10, 1.0f); // Draw a grid
End3dMode();
DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY);
DrawFPS(10, 10);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
UnloadMaterial(material); // Unload material and assigned textures
UnloadModel(dwarf); // Unload model
// Destroy all created lights
DestroyLight(pointLight);
DestroyLight(dirLight);
DestroyLight(spotLight);
// Unload lights
if (lightsCount > 0)
{
for (int i = 0; i < lightsCount; i++) free(lights[i]);
lightsCount = 0;
}
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}
//--------------------------------------------------------------------------------------------
// Module Functions Definitions
//--------------------------------------------------------------------------------------------
// Create a new light, initialize it and add to pool
Light CreateLight(int type, Vector3 position, Color diffuse)
{
Light light = NULL;
if (lightsCount < MAX_LIGHTS)
{
// Allocate dynamic memory
light = (Light)malloc(sizeof(LightData));
// Initialize light values with generic values
light->id = lightsCount;
light->type = type;
light->enabled = true;
light->position = position;
light->target = (Vector3){ 0.0f, 0.0f, 0.0f };
light->intensity = 1.0f;
light->diffuse = diffuse;
// Add new light to the array
lights[lightsCount] = light;
// Increase enabled lights count
lightsCount++;
}
else
{
// NOTE: Returning latest created light to avoid crashes
light = lights[lightsCount];
}
return light;
}
// Destroy a light and take it out of the list
void DestroyLight(Light light)
{
if (light != NULL)
{
int lightId = light->id;
// Free dynamic memory allocation
free(lights[lightId]);
// Remove *obj from the pointers array
for (int i = lightId; i < lightsCount; i++)
{
// Resort all the following pointers of the array
if ((i + 1) < lightsCount)
{
lights[i] = lights[i + 1];
lights[i]->id = lights[i + 1]->id;
}
}
// Decrease enabled physic objects count
lightsCount--;
}
}
// Draw light in 3D world
void DrawLight(Light light)
{
switch (light->type)
{
case LIGHT_POINT:
{
DrawSphereWires(light->position, 0.3f*light->intensity, 8, 8, (light->enabled ? light->diffuse : GRAY));
DrawCircle3D(light->position, light->radius, (Vector3){ 0, 0, 0 }, 0.0f, (light->enabled ? light->diffuse : GRAY));
DrawCircle3D(light->position, light->radius, (Vector3){ 1, 0, 0 }, 90.0f, (light->enabled ? light->diffuse : GRAY));
DrawCircle3D(light->position, light->radius, (Vector3){ 0, 1, 0 },90.0f, (light->enabled ? light->diffuse : GRAY));
} break;
case LIGHT_DIRECTIONAL:
{
DrawLine3D(light->position, light->target, (light->enabled ? light->diffuse : GRAY));
DrawSphereWires(light->position, 0.3f*light->intensity, 8, 8, (light->enabled ? light->diffuse : GRAY));
DrawCubeWires(light->target, 0.3f, 0.3f, 0.3f, (light->enabled ? light->diffuse : GRAY));
} break;
case LIGHT_SPOT:
{
DrawLine3D(light->position, light->target, (light->enabled ? light->diffuse : GRAY));
Vector3 dir = VectorSubtract(light->target, light->position);
VectorNormalize(&dir);
DrawCircle3D(light->position, 0.5f, dir, 0.0f, (light->enabled ? light->diffuse : GRAY));
//DrawCylinderWires(light->position, 0.0f, 0.3f*light->coneAngle/50, 0.6f, 5, (light->enabled ? light->diffuse : GRAY));
DrawCubeWires(light->target, 0.3f, 0.3f, 0.3f, (light->enabled ? light->diffuse : GRAY));
} break;
default: break;
}
}
// Get shader locations for lights (up to MAX_LIGHTS)
static void GetShaderLightsLocations(Shader shader)
{
char locName[32] = "lights[x].\0";
char locNameUpdated[64];
for (int i = 0; i < MAX_LIGHTS; i++)
{
locName[7] = '0' + i;
strcpy(locNameUpdated, locName);
strcat(locNameUpdated, "enabled\0");
lightsLocs[i][0] = GetShaderLocation(shader, locNameUpdated);
locNameUpdated[0] = '\0';
strcpy(locNameUpdated, locName);
strcat(locNameUpdated, "type\0");
lightsLocs[i][1] = GetShaderLocation(shader, locNameUpdated);
locNameUpdated[0] = '\0';
strcpy(locNameUpdated, locName);
strcat(locNameUpdated, "position\0");
lightsLocs[i][2] = GetShaderLocation(shader, locNameUpdated);
locNameUpdated[0] = '\0';
strcpy(locNameUpdated, locName);
strcat(locNameUpdated, "direction\0");
lightsLocs[i][3] = GetShaderLocation(shader, locNameUpdated);
locNameUpdated[0] = '\0';
strcpy(locNameUpdated, locName);
strcat(locNameUpdated, "radius\0");
lightsLocs[i][4] = GetShaderLocation(shader, locNameUpdated);
locNameUpdated[0] = '\0';
strcpy(locNameUpdated, locName);
strcat(locNameUpdated, "diffuse\0");
lightsLocs[i][5] = GetShaderLocation(shader, locNameUpdated);
locNameUpdated[0] = '\0';
strcpy(locNameUpdated, locName);
strcat(locNameUpdated, "intensity\0");
lightsLocs[i][6] = GetShaderLocation(shader, locNameUpdated);
locNameUpdated[0] = '\0';
strcpy(locNameUpdated, locName);
strcat(locNameUpdated, "coneAngle\0");
lightsLocs[i][7] = GetShaderLocation(shader, locNameUpdated);
}
}
// Set shader uniform values for lights
// NOTE: It would be far easier with shader UBOs but are not supported on OpenGL ES 2.0
// TODO: Replace glUniform1i(), glUniform1f(), glUniform3f(), glUniform4f():
//SetShaderValue(Shader shader, int uniformLoc, float *value, int size)
//SetShaderValuei(Shader shader, int uniformLoc, int *value, int size)
static void SetShaderLightsValues(Shader shader)
{
int tempInt[8] = { 0 };
float tempFloat[8] = { 0.0f };
for (int i = 0; i < MAX_LIGHTS; i++)
{
if (i < lightsCount)
{
tempInt[0] = lights[i]->enabled;
SetShaderValuei(shader, lightsLocs[i][0], tempInt, 1); //glUniform1i(lightsLocs[i][0], lights[i]->enabled);
tempInt[0] = lights[i]->type;
SetShaderValuei(shader, lightsLocs[i][1], tempInt, 1); //glUniform1i(lightsLocs[i][1], lights[i]->type);
tempFloat[0] = (float)lights[i]->diffuse.r/255.0f;
tempFloat[1] = (float)lights[i]->diffuse.g/255.0f;
tempFloat[2] = (float)lights[i]->diffuse.b/255.0f;
tempFloat[3] = (float)lights[i]->diffuse.a/255.0f;
SetShaderValue(shader, lightsLocs[i][5], tempFloat, 4);
//glUniform4f(lightsLocs[i][5], (float)lights[i]->diffuse.r/255, (float)lights[i]->diffuse.g/255, (float)lights[i]->diffuse.b/255, (float)lights[i]->diffuse.a/255);
tempFloat[0] = lights[i]->intensity;
SetShaderValue(shader, lightsLocs[i][6], tempFloat, 1);
switch (lights[i]->type)
{
case LIGHT_POINT:
{
tempFloat[0] = lights[i]->position.x;
tempFloat[1] = lights[i]->position.y;
tempFloat[2] = lights[i]->position.z;
SetShaderValue(shader, lightsLocs[i][2], tempFloat, 3);
tempFloat[0] = lights[i]->radius;
SetShaderValue(shader, lightsLocs[i][4], tempFloat, 1);
//glUniform3f(lightsLocs[i][2], lights[i]->position.x, lights[i]->position.y, lights[i]->position.z);
//glUniform1f(lightsLocs[i][4], lights[i]->radius);
} break;
case LIGHT_DIRECTIONAL:
{
Vector3 direction = VectorSubtract(lights[i]->target, lights[i]->position);
VectorNormalize(&direction);
tempFloat[0] = direction.x;
tempFloat[1] = direction.y;
tempFloat[2] = direction.z;
SetShaderValue(shader, lightsLocs[i][3], tempFloat, 3);
//glUniform3f(lightsLocs[i][3], direction.x, direction.y, direction.z);
} break;
case LIGHT_SPOT:
{
tempFloat[0] = lights[i]->position.x;
tempFloat[1] = lights[i]->position.y;
tempFloat[2] = lights[i]->position.z;
SetShaderValue(shader, lightsLocs[i][2], tempFloat, 3);
//glUniform3f(lightsLocs[i][2], lights[i]->position.x, lights[i]->position.y, lights[i]->position.z);
Vector3 direction = VectorSubtract(lights[i]->target, lights[i]->position);
VectorNormalize(&direction);
tempFloat[0] = direction.x;
tempFloat[1] = direction.y;
tempFloat[2] = direction.z;
SetShaderValue(shader, lightsLocs[i][3], tempFloat, 3);
//glUniform3f(lightsLocs[i][3], direction.x, direction.y, direction.z);
tempFloat[0] = lights[i]->coneAngle;
SetShaderValue(shader, lightsLocs[i][7], tempFloat, 1);
//glUniform1f(lightsLocs[i][7], lights[i]->coneAngle);
} break;
default: break;
}
}
else
{
tempInt[0] = 0;
SetShaderValuei(shader, lightsLocs[i][0], tempInt, 1); //glUniform1i(lightsLocs[i][0], 0); // Light disabled
}
}
}
// Calculate vector lenght
float VectorLength(const Vector3 v)
{
float length;
length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
return length;
}
// Normalize provided vector
void VectorNormalize(Vector3 *v)
{
float length, ilength;
length = VectorLength(*v);
if (length == 0.0f) length = 1.0f;
ilength = 1.0f/length;
v->x *= ilength;
v->y *= ilength;
v->z *= ilength;
}
// Substract two vectors
Vector3 VectorSubtract(Vector3 v1, Vector3 v2)
{
Vector3 result;
result.x = v1.x - v2.x;
result.y = v1.y - v2.y;
result.z = v1.z - v2.z;
return result;
}

BIN
examples/shaders/shaders_standard_lighting.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 246 KiB