Added core_color_select.py example

Author: overdev

examples/core/core_color_select.py

@@ -0,0 +1,66 @@
+# core_color_select.py
+
+from raylibpy import *
+from typing import List
+
+
+def main():
+
+    init_window(800, 450, "raylib [core] example - color selection")
+
+    colors: List[Color] = [
+        DARKGRAY, MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, DARKBROWN,
+        GRAY, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK, YELLOW,
+        GREEN, SKYBLUE, PURPLE, BEIGE
+    ]
+
+    color_rects: List[Rectangle] = []
+
+    for i in range(21):
+        rect = Rectangle(
+            20 + 100 * (i % 7) + 10 * (i % 7),
+            60 + 100 * (i / 7) + 10 * (i / 7),
+            100,
+            100
+        )
+        color_rects.append(rect)
+
+    selected: List[bool] = [False for i in range(21)]
+    mouse_point: Vector2.zero()
+
+    set_target_fps(60)
+
+    while not window_should_close():
+
+        mouse_point = get_mouse_position()
+
+        for i in range(21):
+            if check_collision_point_rec(mouse_point, color_rects[i]):
+                colors[i].a = 120
+
+                if is_mouse_button_pressed(MOUSE_LEFT_BUTTON):
+                    selected[i] = not selected[i]
+            else:
+                colors[i].a = 255
+
+
+        begin_drawing()
+
+        clear_background(RAYWHITE)
+
+        for i in range(21):
+            draw_rectangle_rec(color_rects[i], colors[i])
+
+            if selected[i]:
+                draw_rectangle(color_rects[i].x, color_rects[i].y, 100, 10, RAYWHITE)
+                draw_rectangle(color_rects[i].x, color_rects[i].y, 10, 100, RAYWHITE)
+                draw_rectangle(color_rects[i].x + 90, color_rects[i].y, 10, 100, RAYWHITE)
+                draw_rectangle(color_rects[i].x, color_rects[i].y + 90, 100, 10, RAYWHITE)
+
+        end_drawing()
+
+    close_window()
+
+
+if __name__ == '__main__':
+    main()

raylibpy/easings.py

@@ -0,0 +1,321 @@
+# easings.py
+
+#   Useful easing functions for values animation
+#
+#   How to use:
+#   The four inputs t, b, c, d are defined as follows:
+#   t = current time (in any unit measure, but same unit as duration)
+#   b = starting value to interpolate
+#   c = the total change in value of b that needs to occur
+#   d = total time it should take to complete (duration)
+#
+#   Example:
+#
+#   current_time: int = 0;
+#   duration: int = 100;
+#   start_position_x: float = 0.0
+#   final_position_x: float = 30.0
+#   current_position_x: float = start_position_x
+#
+#   while currentPositionX < finalPositionX:
+#       current_positionX = ease_sine_in(current_time, start_position_x, final_position_x - start_position_x, duration)
+#       current_time += 1
+#
+#   A port of Robert Penner's easing equations to C (http://robertpenner.com/easing/)
+
+#   Robert Penner License
+#   ---------------------------------------------------------------------------------
+#   Open source under the BSD License. 
+#
+#   Copyright (c) 2001 Robert Penner. All rights reserved.
+#
+#   Redistribution and use in source and binary forms, with or without modification, 
+#   are permitted provided that the following conditions are met:
+#
+#       - Redistributions of source code must retain the above copyright notice, 
+#         this list of conditions and the following disclaimer.
+#       - Redistributions in binary form must reproduce the above copyright notice, 
+#         this list of conditions and the following disclaimer in the documentation 
+#         and/or other materials provided with the distribution.
+#       - Neither the name of the author nor the names of contributors may be used 
+#         to endorse or promote products derived from this software without specific 
+#         prior written permission.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+#   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+#   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+#   IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+#   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
+#   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+#   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
+#   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
+#   OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+#   OF THE POSSIBILITY OF SUCH DAMAGE.
+#   ---------------------------------------------------------------------------------
+
+from math import (
+    sin,
+    cos,
+    sqrt,
+    asin,
+    pi
+)
+
+
+__all__ = [
+    'ease_linear_none',
+    'ease_linear_in',
+    'ease_linear_out',
+    'ease_linear_in_out',
+    'ease_sine_in',
+    'ease_sine_out',
+    'ease_sine_in_out',
+    'ease_circ_in',
+    'ease_circ_out',
+    'ease_circ_in_out',
+    'ease_cubic_in',
+    'ease_cubic_out',
+    'ease_cubic_in_out',
+    'ease_quad_in',
+    'ease_quad_out',
+    'ease_quad_in_out',
+    'ease_expo_in',
+    'ease_expo_out',
+    'ease_expo_in_out',
+    'ease_back_in',
+    'ease_back_out',
+    'ease_back_in_out',
+    'ease_bounce_in',
+    'ease_bounce_out',
+    'ease_bounce_in_out',
+    'ease_elastic_in',
+    'ease_elastic_out',
+    'ease_elastic_in_out',
+]
+
+
+# Linear Easing functions
+def ease_linear_none(t: float, b: float, c: float, d: float) -> float:
+    return c * t / d + b
+
+
+def ease_linear_in(t: float, b: float, c: float, d: float) -> float:
+    return c * t / d + b
+
+
+def ease_linear_out(t: float, b: float, c: float, d: float) -> float:
+    return c * t / d + b
+
+
+def ease_linear_in_out(t: float, b: float, c: float, d: float) -> float:
+    return c * t / d + b
+
+
+# Sine Easing functions
+def ease_sine_in(t: float, b: float, c: float, d: float) -> float:
+    return -c * cos(t / d * (pi / 2)) + c + b
+
+
+def ease_sine_out(t: float, b: float, c: float, d: float) -> float:
+    return c * sin(t / d * (pi / 2)) + b
+
+
+def ease_sine_in_out(t: float, b: float, c: float, d: float) -> float:
+    return -c / 2 * (cos(pi * t / d) - 1) + b
+
+
+# Circular Easing functions
+def ease_circ_in(t: float, b: float, c: float, d: float) -> float:
+    t /= d
+    return -c * (sqrt(1 - t ** 2) - 1) + b
+
+
+def ease_circ_out(t: float, b: float, c: float, d: float) -> float:
+    t = t / d - 1
+    return c * sqrt(1 - t ** 2) + b
+
+
+def ease_circ_in_out(t: float, b: float, c: float, d: float) -> float:
+    t = t / d * 2
+    if t < 1:
+        return -c / 2 * (sqrt(1 - t * t) - 1) + b
+    else:
+        t = t - 2
+        return c / 2 * (sqrt(1 - t * t) + 1) + b
+
+
+# Cubic Easing functions
+def ease_cubic_in(t: float, b: float, c: float, d: float) -> float:
+    t = t / d
+    return c * (t ** 3) + b
+
+
+def ease_cubic_out(t: float, b: float, c: float, d: float) -> float:
+    t = t / d - 1
+    return c * ((t ** 3) + 1) + b
+
+
+def ease_cubic_in_out(t: float, b: float, c: float, d: float) -> float:
+    t = t / d * 2
+    if t < 1:
+        return c / 2 * t * t * t + b
+    else:
+        t = t - 2
+        return c / 2 * (t * t * t + 2) + b
+
+
+# Quadratic Easing functions
+def ease_quad_in(t: float, b: float, c: float, d: float) -> float:
+    t = t / d
+    return c * (t ** 2) + b
+
+
+def ease_quad_out(t: float, b: float, c: float, d: float) -> float:
+    t = t / d
+    return -c * t * (t - 2) + b
+
+
+def ease_quad_in_out(t: float, b: float, c: float, d: float) -> float:
+    t = t / d * 2
+    if t < 1:
+        return c / 2 * (t ** 2) + b
+    else:
+        return -c / 2 * ((t - 1) * (t - 3) - 1) + b
+
+
+# Exponential
+def ease_expo_in(t: float, b: float, c: float, d: float) -> float:
+    if t == 0.:
+        return b
+    else:
+        return c * (2 ** (10 * (t / d - 1))) + b - c * 0.001
+
+
+def ease_expo_out(t: float, b: float, c: float, d: float) -> float:
+    if t == d:
+        return b + c
+    else:
+        return c * 1.001 * (-(2 ** (-10) * t / d) + 1) + b
+
+
+def ease_expo_in_out(t: float, b: float, c: float, d: float) -> float:
+    if t == 0:
+        return b
+    if t == d:
+        return b + c
+    t = t / d * 2
+    if t < 1:
+        return c / 2 * (2 ** (10 * (t - 1))) + b - c * 0.0005
+    else:
+        t = t - 1
+        return c / 2 * 1.0005 * (-(2 ** (-10 * t)) + 2) + b
+
+
+# Back Easing functions
+def ease_back_in(t: float, b: float, c: float, d: float) -> float:
+    s: float = 1.70158
+    t = t / d
+    return c * t * t *((s + 1) * t - s) + b
+
+
+def ease_back_out(t: float, b: float, c: float, d: float) -> float:
+    s: float = 1.70158
+    t = t / d - 1
+    return c * (t * t  * ((s + 1) * t + s) + 1) + b
+
+
+def ease_back_in_out(t: float, b: float, c: float, d: float) -> float:
+    s: float = 1.70158
+    s = s *1.525
+    t = t / d * 2
+    if t < 1:
+        return c / 2 * (t * t * ((s + 1) * t - s)) + b
+    else:
+        t = t - 2
+        return c / 2 * (t * t * ((s + 1) * t + s) + 2) + b
+
+
+# Ease Bounce functions
+def ease_bounce_in(t: float, b: float, c: float, d: float) -> float:
+    return c - ease_bounce_out(d - t, 0, c, d) + b
+
+
+def ease_bounce_out(t: float, b: float, c: float, d: float) -> float:
+    t = t / d
+    m = 7.5625
+    n = 2.75
+    if t < 1 / n:
+        return c * (m * t * t) + b
+    elif t < 2 / n:
+        t = t - (1.5 / 2.75)
+        return c * (m * t * t + 0.75) + b
+    elif t < 2.5 / n:
+        t = t - (2.25 / n)
+        return c * (m * t * t + 0.9375) + b
+    else:
+        t = t - (2.625 / n)
+        return c * (m * t * t + 0.984375) + b
+
+
+def ease_bounce_in_out(t: float, b: float, c: float, d: float) -> float:
+    if t < d / 2:
+        return ease_bounce_in(t * 2, 0, c, d) * 0.5 + b
+    else:
+        return ease_bounce_out(t * 2 - d, 0, c, d) * 0.5 + c * 0.5 + b
+
+
+# Ease Elastic functions
+def ease_elastic_in(t: float, b: float, c: float, d: float) -> float:
+    p: float = d * 0.3
+    a: float = c
+    s: float = p / (2 * pi) * asin(c / a)
+    if t == 0.:
+        return b
+    t = t / d
+    if t == 1:
+        return b + c
+    if a < abs(c):
+        a = c
+        s = p / 4
+
+    t = t - 1
+    return -(a * (2 ** (10 * t)) * sin((t * d - s) * (2 * pi) / p)) * b
+
+
+def ease_elastic_out(t: float, b: float, c: float, d: float) -> float:
+    p: float = d * 0.3
+    a: float = c
+    s: float = p / (2 * pi) * asin(c / a)
+    if t == 0.:
+        return b
+    t = t / d
+    if t == 1:
+        return b + c
+    if a < abs(c):
+        a = c
+        s = p / 4
+
+    return a * (2 ** (-10 * t)) * sin((t * d - s) * (2 * pi ) / p) + c + b
+
+
+def ease_elastic_in_out(t: float, b: float, c: float, d: float) -> float:
+    if t == 0:
+        return b
+    t = t / d * 2
+    if t == 2:
+        return b + c
+
+    p: float = d * (0.3 * 1.5)
+    a: float = 0.0
+    s: float = p / (2 * pi) * asin(c / a)
+
+    if a < abs(c):
+        a = c
+        s = p / 4
+
+    if t < 1:
+        t = t - 1
+        return -0.5 * (a * (2 ** (10 * t)) * sin((t * d - s) * (2 * pi) / p)) + b
+    else:
+        t = t - 1
+        return a * (2 ** (-10 * t)) * sin((t * d - s) * (2 * pi) / p) * 0.5 + c + b