improved testing functions. imrpoved gradient calculation. added .value to GradientEditor, to get the resulting list of colors.

Author: pokepetter

ursina/prefabs/color_picker.py

@@ -1,9 +1,11 @@
-from ursina import Entity, Slider, color, Button, camera, Quad, copy
+from ursina import Entity, Slider, color, Button, camera, Quad, copy, Color
 
 
 class ColorPicker(Entity):
+    default_values = dict(parent=camera.ui)
+
     def __init__(self, dynamic=True, **kwargs):
-        super().__init__(parent=camera.ui, **kwargs)
+        super().__init__(**(__class__.default_values | kwargs))
 
         self.bg = Entity(parent=self, z=.01, model=Quad(aspect=.5/.2), scale=[.5,.225], origin=[0,.5], color=color.black66)
         self.h_slider = Slider(parent=self, max=360, step=1, dynamic=dynamic, on_value_changed=self._calculate_color)
@@ -36,6 +38,18 @@ def __init__(self, dynamic=True, **kwargs):
         for key, value in kwargs.items():
             setattr(self, key, value)
 
+    @property
+    def value(self):
+        return color.hsv(self.h_slider.value, self.s_slider.value/100, self.v_slider.value/100, self.a_slider.value/100)
+
+    @value.setter
+    def value(self, value:Color):
+        value = value.hsv
+        self.h_slider.value = value[0]
+        self.s_slider.value = value[1]*100
+        self.v_slider.value = value[2]*100
+        self.a_slider.value = value[3]*100
+
 
     def _calculate_color(self):
         self.color = color.hsv(self.h_slider.value, self.s_slider.value/100, self.v_slider.value/100, self.a_slider.value/100)

ursina/ursinamath.py

@@ -154,8 +154,11 @@ def make_gradient(index_value_dict):
     given a dict of positions and values (usually colors), interpolates the values into a list of with the interpolated values.
     example input: {'0':color.hex('#9d9867'), '38':color.hex('#828131'), '54':color.hex('#5d5b2a'), '255':color.hex('#000000')}
     '''
+    min_index = min(int(e) for e in index_value_dict.keys())
     max_index = max(int(e) for e in index_value_dict.keys())
-    gradient = [None for _ in range(max_index+1)]
+    # default_value = index_value_dict.values()[0]
+    # print('-------------', tuple(index_value_dict.values())[0])
+    gradient = [None for _ in range(max_index+1-min_index)]
 
     sorted_dict = [(idx, index_value_dict[str(idx)]) for idx in sorted([int(key) for key in index_value_dict.keys()])]
     # print(sorted_dict)
@@ -166,7 +169,7 @@ def make_gradient(index_value_dict):
         # print(start_index, '-->', next_index, ':', start_value, '-->', next_value)
         dist = next_index - start_index
         for j in range(dist+1):
-            gradient[start_index+j] = lerp(start_value, next_value, j/dist)
+            gradient[start_index+j-min_index] = lerp(start_value, next_value, j/dist)
 
     return gradient
 
@@ -185,6 +188,8 @@ def make_gradient(index_value_dict):
         ])
     _test(make_gradient, ({'0':16, '2':0}, ), expected_result=[16, 8, 0])
 
+    _test(make_gradient, ({'6':0, '8':8}, ), expected_result=[0, 4, 8])
+
 
 def sample_gradient(list_of_values, t):     # distribute list_of_values equally on a line and get the interpolated value at t (0-1).
     l = len(list_of_values)

ursina/ursinastuff.py

@@ -221,6 +221,25 @@ def _test(function, test_input, expected_result):
         print('\33[41mFAILED\033[0m', function.__name__)
         print('result:', result)
         print('expected result:', expected_result)
+        if type(result) != type(expected_result):
+            print(f'result should be: {type(expected_result)}, not: {type(result)}')
+        
+        if isinstance(expected_result, (tuple, list)):
+            if len(result) != len(expected_result):
+                print(f'resulting tuple/list should be {len(expected_result)} long, not {len(result)}')
+
+            if type(result[0]) != type(expected_result[0]):
+                print(f'resulting list/tuple should contain: {type(expected_result[0])}, not: {type(result[0])}')
+    return result
+
+def _assert(passed:bool, name=''):
+    if passed:
+        print('\33[42mPASSED\033[0m', name)
+    else:
+        print('\33[41mFAILED\033[0m', name)
+    return passed
+
+
 
 
 # define a new metaclass which overrides the "__call__" function