added rl5 (binding generator rewrite) working examples (shaders and raymath)

Author: Jorge A. Gomes

examples/core_2d_camera_mouse_zoom.py

@@ -33,8 +33,8 @@ def main():
     while not window_should_close():
         if is_mouse_button_down(MOUSE_BUTTON_RIGHT):
             delta = get_mouse_delta()
-            delta  = vector2scale(delta, -1.0 / camera.zoom)
-            camera.target  = vector2add(camera.target, delta)
+            delta  = delta * (-1.0 / camera.zoom)
+            camera.target += delta
 
         wheel = get_mouse_wheel_move()
 

examples/core_2d_camera_split_screen.py

@@ -31,89 +31,91 @@ def main():
 
     init_window(screenWidth, screenHeight, "raylib [core] example - 2d camera split screen")
 
-    player1 = Rectangle(200, 200, PLAYER_SIZE, PLAYER_SIZE)
-    player2 = Rectangle(250, 200, PLAYER_SIZE, PLAYER_SIZE)
+    red_player = Rectangle(200, 200, PLAYER_SIZE, PLAYER_SIZE)
+    blue_player = Rectangle(250, 200, PLAYER_SIZE, PLAYER_SIZE)
 
-    camera1 = Camera2D(0)
-    camera1.target  = Vector2(player1.x, player1.y)
-    camera1.offset  = Vector2(200.0, 200.0)
-    camera1.rotation  = 0.0
-    camera1.zoom  = 1.0
+    redPlayerCamera = Camera2D()
+    redPlayerCamera.target  = Vector2(red_player.x, red_player.y)
+    redPlayerCamera.offset  = Vector2(200.0, 200.0)
+    redPlayerCamera.rotation  = 0.0
+    redPlayerCamera.zoom  = 1.0
 
-    camera2 = Camera2D(0)
-    camera2.target  = Vector2(player2.x, player2.y)
-    camera2.offset  = Vector2(200.0, 200.0)
-    camera2.rotation  = 0.0
-    camera2.zoom  = 1.0
+    bluePlayerCamera = Camera2D()
+    bluePlayerCamera.target  = Vector2(blue_player.x, blue_player.y)
+    bluePlayerCamera.offset  = Vector2(200.0, 200.0)
+    bluePlayerCamera.rotation  = 0.0
+    bluePlayerCamera.zoom  = 1.0
 
-    screenCamera1 = load_render_texture(screenWidth / 2, screenHeight)
-    screenCamera2 = load_render_texture(screenWidth / 2, screenHeight)
+    redPlayerScreenCamera = load_render_texture(screenWidth / 2, screenHeight)
+    bluePlayerScreenCamera = load_render_texture(screenWidth / 2, screenHeight)
 
-    splitScreenRect = Rectangle(0.0, 0.0, screenCamera1.texture.width, screenCamera1.texture.height)
+    splitScreenRect1 = Rectangle(0.0, 0.0, redPlayerScreenCamera.texture.width, redPlayerScreenCamera.texture.height * -1.0)
+    splitScreenRect2 = Rectangle(0.0, 0.0, redPlayerScreenCamera.texture.width, redPlayerScreenCamera.texture.height * -1.0)
 
     set_target_fps(60)
-    
+
     while not window_should_close():
-        if is_key_down(KEY_S):
-            player1.y  += 3.0
-        elif is_key_down(KEY_W):
-            player1.y  -= 3.0
+        if is_key_down(KEY_KP_8):
+            red_player.y  += 3.0
+        elif is_key_down(KEY_KP_5):
+            red_player.y  -= 3.0
 
-        if is_key_down(KEY_D):
-            player1.x  += 3.0
-        elif is_key_down(KEY_A):
-            player1.x  -= 3.0
+        if is_key_down(KEY_KP_6):
+            red_player.x  += 3.0
+        elif is_key_down(KEY_KP_4):
+            red_player.x  -= 3.0
 
         if is_key_down(KEY_UP):
-            player2.y  -= 3.0
+            blue_player.y  -= 3.0
         elif is_key_down(KEY_DOWN):
-            player2.y  += 3.0
+            blue_player.y  += 3.0
 
         if is_key_down(KEY_RIGHT):
-            player2.x  += 3.0
+            blue_player.x  += 3.0
         elif is_key_down(KEY_LEFT):
-            player2.x  -= 3.0
+            blue_player.x  -= 3.0
 
-        camera1.target  = Vector2(player1.x, player1.y)
-        camera2.target  = Vector2(player2.x, player2.y)
+        redPlayerCamera.target = red_player.xy
+        bluePlayerCamera.target = blue_player.xy
 
-        with texture_mode(screenCamera1):
+        with texture_mode(redPlayerScreenCamera):
             clear_background(RAYWHITE)
 
-            begin_mode2d(camera1)
-            draw_rectangle_rec(player1, RED)
-            draw_rectangle_rec(player2, BLUE)
+            begin_mode2d(redPlayerCamera)
+            draw_rectangle_rec(red_player, RED)
+            draw_rectangle_rec(blue_player, GRAY)
             end_mode2d()
 
             draw_rectangle(0, 0, get_screen_width() / 2, 30, fade(RAYWHITE, 0.6))
-            draw_text("PLAYER1: W/S/A/D to move", 10, 10, 10, MAROON)
+            draw_text("RED PLAYER: W/S/A/D to move", 10, 10, 10, MAROON)
 
         # end_texture_mode()
 
-        with texture_mode(screenCamera2):
+        with texture_mode(bluePlayerScreenCamera):
             clear_background(RAYWHITE)
 
-            begin_mode2d(camera2)
-            draw_rectangle_rec(player1, RED)
-            draw_rectangle_rec(player2, BLUE)
+            begin_mode2d(bluePlayerCamera)
+            draw_rectangle_rec(red_player, GRAY)
+            draw_rectangle_rec(blue_player, BLUE)
             end_mode2d()
 
+            draw_text("BLUE", blue_player.x, blue_player.y, 10, DARKBLUE)
             draw_rectangle(0, 0, get_screen_width() / 2, 30, fade(RAYWHITE, 0.6))
-            draw_text("PLAYER2: UP/DOWN/LEFT/RIGHT to move", 10, 10, 10, DARKBLUE)
+            draw_text("BLUE PLAYER: UP/DOWN/LEFT/RIGHT to move", 10, 10, 10, DARKBLUE)
 
         # end_texture_mode()
 
         with drawing():
 
             clear_background(BLACK)
-            draw_texture_rec(screenCamera1.texture, splitScreenRect, Vector2(0, 0), WHITE)
-            draw_texture_rec(screenCamera2.texture, splitScreenRect, Vector2(screenWidth / 2.0, 0), WHITE)
+            draw_texture_rec(redPlayerScreenCamera.texture, splitScreenRect1, Vector2(0, 0), WHITE)
+            draw_texture_rec(bluePlayerScreenCamera.texture, splitScreenRect2, Vector2(screenWidth / 2.0, 0), WHITE)
             draw_rectangle(get_screen_width() / 2 - 2, 0, 4, get_screen_height(), LIGHTGRAY)
 
         # end_drawing()
 
-    unload_render_texture(screenCamera1)
-    unload_render_texture(screenCamera2)
+    unload_render_texture(redPlayerScreenCamera)
+    unload_render_texture(bluePlayerScreenCamera)
 
     close_window()
 

examples/raymath_vector_angle.py

@@ -0,0 +1,88 @@
+
+import sys
+import os
+from ctypes import byref
+from raylibpy import *
+# import raymath.h
+
+def main():
+
+    screenWidth = 800
+    screenHeight = 450
+
+    init_window(screenWidth, screenHeight, "raylib [math] example - vector angle")
+
+    v0 = Vector2(screenWidth / 2, screenHeight / 2)
+    v1 = v0 + Vector2(100.0, 80.0)
+    v2 = Vector2()
+    angle = 0.0
+    angleMode = 0
+
+    set_target_fps(60)
+    
+    while not window_should_close():
+        startangle = 0.0
+        
+        if angleMode == 0:
+            startangle  = -vector2_line_angle(v0, v1) * RAD2DEG
+        
+        if angleMode == 1:
+            startangle  = 0.0
+        v2  = get_mouse_position()
+        
+        if is_key_pressed(KEY_SPACE):
+            angleMode = not angleMode
+        
+        if angleMode == 0 and is_mouse_button_down(MOUSE_BUTTON_RIGHT):
+            v1  = get_mouse_position()
+        
+        if angleMode == 0:
+            v1Normal = vector2_normalize(vector2_subtract(v1, v0))
+            v2Normal = vector2_normalize(vector2_subtract(v2, v0))
+            angle  = vector2_angle(v1Normal, v2Normal) * RAD2DEG
+        elif angleMode == 1:
+            angle  = vector2_line_angle(v0, v2) * RAD2DEG
+
+        begin_drawing()
+
+        clear_background(RAYWHITE)
+        
+        if angleMode == 0:
+            draw_text("MODE 0: Angle between V1 and V2", 10, 10, 20, BLACK)
+            draw_text("Right Click to Move V2", 10, 30, 20, DARKGRAY)
+            draw_line_ex(v0, v1, 2.0, BLACK)
+            draw_line_ex(v0, v2, 2.0, RED)
+            draw_circle_sector(v0, 40.0, startangle, startangle + angle, 32, fade(GREEN, 0.6))
+
+        elif angleMode == 1:
+            draw_text("MODE 1: Angle formed by line V1 to V2", 10, 10, 20, BLACK)
+            draw_line(0, screenHeight / 2, screenWidth, screenHeight / 2, LIGHTGRAY)
+            draw_line_ex(v0, v2, 2.0, RED)
+            draw_circle_sector(v0, 40.0, startangle, startangle - angle, 32, fade(GREEN, 0.6))
+
+        draw_text("v0", v0.x, v0.y, 10, DARKGRAY)
+        
+        if angleMode == 0 and vector2_subtract(v0, v1).y > 0.0:
+            draw_text("v1", v1.x, v1.y - 10.0, 10, DARKGRAY)
+        
+        if angleMode == 0 and vector2_subtract(v0, v1).y < 0.0:
+            draw_text("v1", v1.x, v1.y, 10, DARKGRAY)
+        
+        if angleMode == 1:
+            draw_text("v1", v0.x + 40.0, v0.y, 10, DARKGRAY)
+
+        draw_text("v2", v2.x - 10.0, v2.y - 10.0, 10, DARKGRAY)
+        draw_text("Press SPACE to change MODE", 460, 10, 20, DARKGRAY)
+        draw_text(text_format("ANGLE: %2.2f", Float(angle)), 10, 70, 20, LIME)
+
+        end_drawing()
+
+    close_window()
+    return 0
+
+
+if __name__ == "__main__":
+    if len(sys.argv) >= 2 and isinstance(sys.argv[1], str):
+        os.chdir(sys.argv[1])
+    print("Working dir:", os.getcwd())
+    sys.exit(main())

examples/shaders_custom_uniform.py

@@ -0,0 +1,86 @@
+
+import sys
+import os
+from ctypes import byref
+from raylibpy import *
+
+GLSL_VERSION = 330
+
+def main():
+
+    screenWidth = 800
+    screenHeight = 450
+
+    set_config_flags(FLAG_MSAA_4X_HINT)
+
+    init_window(screenWidth, screenHeight, "raylib [shaders] example - custom uniform variable")
+
+    camera = Camera(0)
+    camera.position  = Vector3(8.0, 8.0, 8.0)
+    camera.target  = Vector3(0.0, 1.5, 0.0)
+    camera.up  = Vector3(0.0, 1.0, 0.0)
+    camera.fovy  = 45.0
+    camera.projection  = CAMERA_PERSPECTIVE
+
+    model = load_model("resources/models/barracks.obj")
+    texture = load_texture("resources/models/barracks_diffuse.png")
+    model.materials[0].maps[MATERIAL_MAP_ALBEDO].texture  = texture
+
+    position = Vector3(0.0, 0.0, 0.0)
+
+    shader = load_shader(None, f"resources/shaders/glsl{GLSL_VERSION}/swirl.fs")
+    swirlCenterLoc = get_shader_location(shader, "center")
+
+    swirlCenter = (Float * 2)(screenWidth / 2, screenHeight / 2)
+
+    target = load_render_texture(screenWidth, screenHeight)
+
+    set_target_fps(60)
+    
+    while not window_should_close():
+        update_camera(byref(camera), CAMERA_ORBITAL)
+    
+        mousePosition = get_mouse_position()
+        swirlCenter[0]  = mousePosition.x
+        swirlCenter[1]  = screenHeight - mousePosition.y
+
+        set_shader_value(shader, swirlCenterLoc, swirlCenter, SHADER_UNIFORM_VEC2)
+    
+        with texture_mode(target):
+            clear_background(RAYWHITE)
+
+            with mode3d(camera):
+                draw_model(model, position, 0.5, WHITE)
+                draw_grid(10, 1.0)
+            # end_mode3d()
+
+            draw_text("TEXT DRAWN IN RENDER TEXTURE", 200, 10, 30, RED)
+        # end_texture_mode()
+
+        with drawing():
+            clear_background(RAYWHITE)
+
+            with shader_mode(shader):
+                draw_texture_rec(target.texture, Rectangle(0, 0, target.texture.width, target.texture.height), Vector2(0, 0), WHITE)
+            # end_shader_mode()
+
+            draw_text("(c) Barracks 3D model by Alberto Cano", screenWidth - 220, screenHeight - 20, 10, GRAY)
+            draw_fps(10, 10)
+
+        # end_drawing()
+
+    unload_shader(shader)
+    unload_texture(texture)
+    unload_model(model)
+    unload_render_texture(target)
+
+    close_window()
+
+    return 0
+
+
+if __name__ == "__main__":
+    if len(sys.argv) >= 2 and isinstance(sys.argv[1], str):
+        os.chdir(sys.argv[1])
+    print("Working dir:", os.getcwd())
+    sys.exit(main())

examples/shaders_eratosthenes.py

@@ -0,0 +1,48 @@
+
+import sys
+import os
+from ctypes import byref
+from raylibpy import *
+
+GLSL_VERSION = 330
+
+def main():
+
+    screenWidth = 800
+    screenHeight = 450
+
+    init_window(screenWidth, screenHeight, "raylib [shaders] example - Sieve of Eratosthenes")
+
+    target = load_render_texture(screenWidth, screenHeight)
+    shader = load_shader(None, f"resources/shaders/glsl{GLSL_VERSION}/eratosthenes.fs")
+
+    set_target_fps(60)
+    
+    while not window_should_close():
+
+        begin_texture_mode(target)
+        clear_background(BLACK)
+        draw_rectangle(0, 0, get_screen_width(), get_screen_height(), BLACK)
+        end_texture_mode()
+
+        begin_drawing()
+        clear_background(RAYWHITE)
+
+        begin_shader_mode(shader)
+        draw_texture_rec(target.texture, Rectangle(0, 0, target.texture.width, -target.texture.height), Vector2(0.0, 0.0), WHITE)
+        end_shader_mode()
+
+        end_drawing()
+
+    unload_shader(shader)
+    unload_render_texture(target)
+    close_window()
+
+    return 0
+
+
+if __name__ == "__main__":
+    if len(sys.argv) >= 2 and isinstance(sys.argv[1], str):
+        os.chdir(sys.argv[1])
+    print("Working dir:", os.getcwd())
+    sys.exit(main())