hdr pass

colorpicker.wren

@@ -14,6 +14,7 @@ class ColorPickerData {
 	outer_ring_size:Num {200}
 	inner_ring_size:Num {140}
 
+	//raw color components in linear space
 	r:Num{_r}
 	g:Num{_g}
 	b:Num{_b}
@@ -24,12 +25,11 @@ class ColorPickerData {
 
 	a:Num{_a}
 
-	rgba:Color{[_hdr_mul * _r, _hdr_mul * _g, _hdr_mul * _b, _a]}
-	rgba_ldr:Color{[_r , _g, _b, _a]}
-	hsva:List{[_h, _s, _v, _a]} //almost a color ^^
+	color_ldr:Color{get_rgba(false, false)}
+	color_hdr:Color{get_rgba(false, true)}
 
-	srgb_hex:Bool{_srgb_hex}
-	srgb_hex=(value:Bool){_srgb_hex = value}
+	srgb:Bool{_srgb_hex}
+	srgb=(value:Bool){_srgb_hex = value}
 
 	hdr_multiplier:Num{_hdr_mul}
 	hdr_multiplier=(value:Num){_hdr_mul = value}
@@ -37,15 +37,65 @@ class ColorPickerData {
 	allow_hdr:Bool{_allow_hdr}
 	allow_hdr=(v:Bool){_allow_hdr = v}
 
-	toString{"Data - HSV:[%(h), %(s), %(v)] - RGB:[%(r), %(g), %(b)] - A:[%(a)]"}
+	show_hdr:Bool{_show_hdr && allow_hdr}
+	show_hdr=(v:Bool){_show_hdr=v}
+
+	show_components:String{_show_components}
+	show_components(v:String){_show_components=v}
+
+	debug=(v){_debug=v}
+
+	toString{"Data - HSV:[%(h), %(s), %(v)] - RGB:[%(r), %(g), %(b)] - A:[%(a)] "+
+			"(srgb:%(srgb), hdr:(intensity:%(hdr_multiplier)%(allow_hdr?", allowed":"")%(show_hdr?", shown":"")), "+
+			"show components:%(show_components))%(_debug?("debug: "+_debug):"")"}
 
 	construct new(){
 		_hdr_mul = 1
+		_show_components = "rgb"
 		set_rgba(Color.hex(0xFFAABB))
 	}
 
-	set_rgba(col){set_rgba(col, true)}
-	set_rgba(col, update_spaces){
+	get_rgba():Color{get_rgba(srgb, allow_hdr)}
+	get_rgba(srgb: Bool, hdr: Bool):Color{
+		var col = [r, g, b, a]
+		if(srgb){
+			CPHelper.apply_srgb(col)
+		}
+		if(hdr){
+			col.r = col.r * hdr_multiplier
+			col.g = col.g * hdr_multiplier
+			col.b = col.b * hdr_multiplier
+		}
+		return col
+	}
+
+	get_hsva_component():Color{get_hsva_component(srgb)}
+	get_hsva(srgb: Bool):Color{
+		var h = _h
+		var s = _s
+		var v = _v
+		var a = _a
+
+		if(srgb){
+			//hsv srgb conversion via rgb is the most easy and solid rn
+			var rgb = [r, g, b, a]
+			CPHelper.apply_srgb(rgb)
+			var hsv_srgb = Color.rgb2hsv(rgb)
+
+			if(!CPHelper.approx(v, 0) && !CPHelper.approx(s, 0)) h = hsv_srgb.x
+			if(!CPHelper.approx(v, 0)) s = hsv_srgb.y
+			v = hsv_srgb.z
+		}
+
+		return [h, s, v, a]
+	}
+
+	set_rgba(col: Color){set_rgba(col, srgb, true)}
+	set_rgba(col: Color, srgb: Bool){set_rgba(col, srgb, true)}
+	set_rgba(col: Color, srgb: Bool, update_spaces: Bool){
+		if(col.r > 1 || col.g > 1 || col.b > 1) Fiber.abort(col)
+		if(srgb) CPHelper.unapply_srgb(col)
+
 		if(!CPHelper.approx(_r, col.r)) _r = col.r
 		if(!CPHelper.approx(_g, col.g)) _g = col.g
 		if(!CPHelper.approx(_b, col.b)) _b = col.b
@@ -55,14 +105,26 @@ class ColorPickerData {
 
 		var hsv = Color.rgb2hsv(col)
 		//be careful not to destroy hue when doing rgb to hsv
-		if(!CPHelper.approx(_h, hsv.x) && !CPHelper.approx(_s, 0) && 
-			!CPHelper.approx(_h, hsv.x-1) && !CPHelper.approx(_h, hsv.x+1)) _h = hsv.x 
+		if(!CPHelper.approx(_h, hsv.x) && !CPHelper.approx(hsv.y, 0) && !CPHelper.approx(hsv.z, 0) &&
+			!CPHelper.approx(_h, hsv.x-1) && !CPHelper.approx(_h, hsv.x+1)) _h = hsv.x
 		if(!CPHelper.approx(_s, hsv.y)) _s = hsv.y
 		if(!CPHelper.approx(_v, hsv.z)) _v = hsv.z
 	}
 
-	set_hsva(col){set_hsva(col, true)}
-	set_hsva(col, update_spaces){
+	set_hsva(col){set_hsva(col, srgb, true)}
+	set_hsva(col: Color, srgb: Bool){set_hsva(col, srgb, true)}
+	set_hsva(col: Color, srgb: Bool, update_spaces: Bool){
+		if(srgb){
+			//hsv srgb conversion via rgb is the most easy and solid rn
+			var rgb = Color.hsv2rgb(col)
+			CPHelper.unapply_srgb(rgb)
+			var hsv_srgb = Color.rgb2hsv(rgb)
+
+			if(!CPHelper.approx(col.z, 0) && !CPHelper.approx(col.y, 0) && !CPHelper.approx(col.x, 1)) col.x = hsv_srgb.x
+			if(!CPHelper.approx(col.z, 0)) col.y = hsv_srgb.y
+			col.z = hsv_srgb.z
+		}
+
 		if(!CPHelper.approx(_h, col.x)) _h = col.x
 		if(!CPHelper.approx(_s, col.y)) _s = col.y
 		if(!CPHelper.approx(_v, col.z)) _v = col.z
@@ -76,52 +138,28 @@ class ColorPickerData {
 		if(!CPHelper.approx(_b, rgb.b)) _b = rgb.b
 	}
 
-	set_rgba_component(index: Num, value: Num){
-		if(index == 0){
-			set_rgba([value, _g, _b, _a])
-		} else if(index == 1){
-			set_rgba([_r, value, _b, _a])
-		} else if(index == 2){
-			set_rgba([_r, _g, value, _a])
-		} else if(index == 3){
-			set_rgba([_r, _g, _b, value])
-		}
+	set_rgba_component(index: Num, value: Num){set_rgba_component(index, value, srgb)}
+	set_rgba_component(index: Num, value: Num, srgb: Bool){
+		var current = get_rgba(srgb, false)
+		current[index] = value
+		set_rgba(current)
+	}
+	get_rgba_component(index: Num){get_rgba_component(index, srgb, false)}
+	get_rgba_component(index: Num, srgb: Bool){get_rgba_component(index, srgb, false)}
+	get_rgba_component(index: Num, srgb: Bool, hdr: Bool){
+		return get_rgba(srgb, hdr)[index]
 	}
 
-	get_rgba_component(index: Num){
-		if(index == 0){
-			return _r
-		} else if(index == 1){
-			return _g
-		} else if(index == 2){
-			return _b
-		} else if(index == 3){
-			return _a
-		}
+	set_hsva_component(index: Num, value: Num){set_hsva_component(index, value, srgb)}
+	set_hsva_component(index: Num, value: Num, srgb: Bool){
+		var current = get_hsva(srgb)
+		current[index] = value
+		set_hsva(current, srgb)
 	}
 
-	set_hsva_component(index: Num, value: Num){
-		if(index == 0){
-			set_hsva([value, _s, _v, _a])
-		} else if(index == 1){
-			set_hsva([_h, value, _v, _a])
-		} else if(index == 2){
-			set_hsva([_h, _s, value, _a])
-		} else if(index == 3){
-			set_hsva([_h, _s, _v, value])
-		}
-	}
-
-	get_hsva_component(index: Num){
-		if(index == 0){
-			return _h
-		} else if(index == 1){
-			return _s
-		} else if(index == 2){
-			return _v
-		} else if(index == 3){
-			return _a
-		}
+	get_hsva_component(index: Num){get_hsva_component(index, srgb)}
+	get_hsva_component(index: Num, srgb: Bool){
+		return get_hsva(srgb)[index]
 	}
 
 }
@@ -160,6 +198,7 @@ class ColorPicker{
 		var color_display = CPHelper.color_display(ui, color_view)
 		Control.child_add(wheel_and_color, color_display)
 
+		//this should be a dropdown
 		var component_choice = Control.create(ui)
 		Control.set_contain(component_choice, UIContain.row | UIContain.start)
 		Control.set_behave(component_choice, UIBehave.hfill | UIBehave.left | UIBehave.top)
@@ -177,6 +216,9 @@ class ColorPicker{
 		UIButton.set_text(hsva_button, "hsv")
 		Control.child_add(component_choice, hsva_button)
 
+		var srgb_switch = CPHelper.colorspace_choice(ui, color_view)
+		Control.child_add(component_choice, srgb_switch)
+
 		var rgba_components = CPHelper.rgba_values(ui, color_view)
 		Control.child_add(color_view, rgba_components)
 		
@@ -201,6 +243,9 @@ class ColorPicker{
 		var hex_field = CPHelper.hex_input(ui, color_view)
 		Control.child_add(color_view, hex_field)
 
+		var hdr_settings = CPHelper.hdr_settings(ui, color_view)
+		Control.child_add(color_view, hdr_settings)
+
 		var bottom_offset = Control.create(ui)
 		Control.set_size(bottom_offset, 0, 8)
 		Control.set_behave(bottom_offset, UIBehave.left)
@@ -212,6 +257,158 @@ class ColorPicker{
 
 #hidden
 class CPHelper{
+	static hdr_settings(ui: UI, data_control: Control){
+		var data: ColorPickerData = Control.get_state_data(data_control)
+		var root = Control.create(ui)
+		Control.set_behave(root, UIBehave.left | UIBehave.hfill)
+		Control.set_contain(root, UIContain.column | UIContain.vfit)
+
+		var hdr_header = Control.create(ui)
+		Control.set_contain(hdr_header, UIContain.start | UIContain.row | UIContain.vfit)
+		Control.set_behave(hdr_header, UIBehave.left | UIBehave.hfill)
+		Control.child_add(root, hdr_header)
+		
+		var hdr_label = UILabel.create(ui)
+		UILabel.set_text(hdr_label, "HDR: ")
+		UILabel.set_text_size(hdr_label, 14)
+		UILabel.set_align_vertical(hdr_label, TextAlign.center)
+		Control.set_margin(hdr_label, 8, 8, 0, 0)
+		Control.set_behave(hdr_label, UIBehave.left | UIBehave.top)
+		Control.set_size(hdr_label, 32, 20)
+		Control.child_add(hdr_header, hdr_label)
+
+		var hdr_toggle = UICheck.create(ui) //this should probably be a proper vertical swoopline
+		Control.set_margin(hdr_toggle, 8, 4, 0, 0)
+		Control.set_size(hdr_toggle, 32, 20)
+		Control.set_behave(hdr_toggle, UIBehave.left)
+		Control.child_add(hdr_header, hdr_toggle)
+		Control.set_events(hdr_toggle){ |event|
+			if(event.type == UIEvent.change){
+				if(data.show_hdr == event.change) return
+				data.show_hdr = event.change
+				data.debug = "hdr toggle"
+				UI.events_emit(data_control, UIEvent.change, data)
+			}
+		}
+
+		var hdr_intensity = Control.create(ui)
+		Control.set_margin(hdr_intensity, 0, 8, 0, 0)
+		Control.set_contain(hdr_intensity, UIContain.start | UIContain.row | UIContain.vfit)
+		Control.set_behave(hdr_intensity, UIBehave.left | UIBehave.hfill)
+		Control.child_add(root, hdr_intensity)
+
+		var hdr_mult_label = UILabel.create(ui)
+		UILabel.set_text(hdr_mult_label, "Intensity:")
+		//UILabel.set_text_size(hdr_mult_label, 12)
+		UILabel.set_color(hdr_mult_label, [0.8, 0.8, 0.8, 1])
+		Control.set_margin(hdr_mult_label, 8, 0, 0, 0)
+		Control.set_size(hdr_mult_label, 64, 32)
+		Control.set_behave(hdr_mult_label, UIBehave.left | UIBehave.top)
+		Control.child_add(hdr_intensity, hdr_mult_label)
+
+		var hdr_intensity_number = UINumber.create(ui)
+		UINumber.set_value(hdr_intensity_number, 1)
+		UINumber.set_validation(hdr_intensity_number) { |input: Num|
+			return input.max(0)
+		}
+		Control.set_size(hdr_intensity_number, 64, 32)
+		Control.set_margin(hdr_intensity_number, 8, 0, 0, 0)
+		Control.set_behave(hdr_intensity_number, UIBehave.left | UIBehave.top)
+		Control.child_add(hdr_intensity, hdr_intensity_number)
+		Control.set_events(hdr_intensity_number){|event|
+			if(event.type == UIEvent.change){
+				if(approx(data.hdr_multiplier, event.change)) return
+				data.hdr_multiplier = event.change
+				data.debug = "hdr intensity input"
+				UI.events_emit(data_control, UIEvent.change, data)
+			}
+		}
+		Control.set_events(data_control){|event|
+			if(event.type == UIEvent.change){
+				System.print(event.change)
+				UINumber.set_value(hdr_intensity_number, data.hdr_multiplier)
+			}
+		}
+
+		var hdr_numbers = Control.create(ui)
+		Control.set_margin(hdr_numbers, 0, 0, 0, 0)
+		Control.set_contain(hdr_numbers, UIContain.start | UIContain.row | UIContain.vfit)
+		Control.set_behave(hdr_numbers, UIBehave.left | UIBehave.hfill)
+		Control.child_add(root, hdr_numbers)
+
+		var hdr_number_display = UILabel.create(ui)
+		UILabel.set_text(hdr_number_display, "[%(Str.fixed(data.r, 3)), %(Str.fixed(data.g, 3)), %(Str.fixed(data.b, 3)), %(Str.fixed(data.a, 3))]")
+		UILabel.set_color(hdr_number_display, Color.hex(0x808080))
+		Control.set_size(hdr_number_display, 180, 32)
+		Control.set_margin(hdr_number_display, 8, 0, 0, 0)
+		Control.set_behave(hdr_number_display, UIBehave.left | UIBehave.hfill)
+		Control.child_add(hdr_numbers, hdr_number_display)
+		Control.set_events(data_control){ |event|
+			if(event.type == UIEvent.change){
+					var hdr = data.color_hdr
+					UILabel.set_text(hdr_number_display, "[%(Str.fixed(hdr.r, 3)), %(Str.fixed(hdr.g, 3)), %(Str.fixed(hdr.b, 3)), %(Str.fixed(hdr.a, 3))]")
+			}
+		}
+
+		var maximize_ldr_button = UIButton.create(ui)
+		UIButton.set_text(maximize_ldr_button, "maximize LDR")
+		UIButton.set_text_size(maximize_ldr_button, 12)
+		Control.set_size(maximize_ldr_button, 80, 24)
+		Control.set_behave(maximize_ldr_button, UIBehave.left | UIBehave.top)
+		Control.set_margin(maximize_ldr_button, 8, 4, 8, 0)
+		Control.child_add(hdr_numbers, maximize_ldr_button)
+		Control.set_events(maximize_ldr_button) {|event|
+			if(event.type == UIEvent.press){
+				if(data.v < 1 && data.v > 0.001){
+					var multiplier = data.hdr_multiplier.min(1/data.v).max(1)
+					data.hdr_multiplier = data.hdr_multiplier / multiplier
+					data.set_hsva_component(2, data.v * multiplier)
+					data.debug = "hdr maximize ldr"
+					UI.events_emit(data_control, UIEvent.change, data)
+				}
+			}
+		}
+
+		var color_hdr = UIPanel.create(ui)
+		UIPanel.set_color(color_hdr, data.color_hdr)
+		UIPanel.set_border(color_hdr, 0, Color.clear)
+		Control.set_size(color_hdr, 64, 32)
+		Control.set_margin(color_hdr, 8, 4, 8, 0)
+		Control.set_behave(color_hdr, UIBehave.left | UIBehave.top)
+		Control.child_add(root, color_hdr)
+		Control.set_events(data_control){|event|
+			if(event.type == UIEvent.change){
+				var color = data.color_hdr
+				color.a = 1
+				UIPanel.set_color(color_hdr, color)
+			}
+		}
+
+		//todo: color steps and more polish
+		
+		if(!data.allow_hdr){
+			Control.set_visible(hdr_header, false)
+		}
+
+		if(!data.show_hdr){
+			Control.set_visible(hdr_intensity, false)
+			Control.set_visible(hdr_numbers, false)
+			Control.set_visible(color_hdr, false)
+		}
+
+		Control.set_events(data_control){ |event|
+			if(event.type == UIEvent.change){
+				Control.set_visible(hdr_intensity, data.show_hdr)
+				Control.set_visible(hdr_numbers, data.show_hdr)
+				Control.set_visible(color_hdr, data.show_hdr)
+
+				Control.set_visible(hdr_header, data.allow_hdr)
+			}
+		}
+
+		return root
+	}
+
 	static color_display(ui: UI, data_control: Control){
 		var data: ColorPickerData = Control.get_state_data(data_control)
 
@@ -221,7 +418,7 @@ class CPHelper{
 		Control.set_margin(root, 16, 0, 0, 0)
 
 		var color_opaque = UIPanel.create(ui)
-		UIPanel.set_color(color_opaque, data.rgba_ldr)
+		UIPanel.set_color(color_opaque, data.color_ldr)
 		UIPanel.set_border(color_opaque, 0, Color.clear)
 		Control.set_size(color_opaque, 64, 32)
 		Control.set_margin(color_opaque, 8, 8, 8, 0)
@@ -235,7 +432,7 @@ class CPHelper{
 		Control.child_add(root, color_w_trans_bg)
 		
 		var color_alpha = UIPanel.create(ui)
-		UIPanel.set_color(color_alpha, data.rgba_ldr)
+		UIPanel.set_color(color_alpha, data.color_ldr)
 		UIPanel.set_border(color_alpha, 0, Color.clear)
 		Control.set_clip(color_alpha, false)
 		Control.set_margin(color_alpha, 0, 0, 0, 0)
@@ -251,7 +448,7 @@ class CPHelper{
 
 		Control.set_events(data_control){|event|
 			if(event.type == UIEvent.change){
-				var color = data.rgba_ldr
+				var color = data.color_ldr
 				UIImage.set_color(alpha_bg, color)
 				color.a = 1
 				UIPanel.set_color(color_alpha, color)
@@ -259,84 +456,43 @@ class CPHelper{
 			}
 		}
 
-		var hdr_header = UILabel.create(ui)
-		UILabel.set_text(hdr_header, "HDR:")
-		UILabel.set_text_size(hdr_header, 14)
-		Control.set_margin(hdr_header, 8, 8, 0, 0)
-		Control.set_behave(hdr_header, UIBehave.left | UIBehave.top)
-		Control.set_size(hdr_header, 64, 32)
-		Control.child_add(root, hdr_header)
+		return root
+	}
 
-		var hdr_mult_label = UILabel.create(ui)
-		UILabel.set_text(hdr_mult_label, "multiplier:")
-		UILabel.set_text_size(hdr_mult_label, 12)
-		UILabel.set_color(hdr_mult_label, [0.8, 0.8, 0.8, 1])
-		Control.set_margin(hdr_mult_label, 8, -10, 0, 0)
-		Control.set_size(hdr_mult_label, 64, 32)
-		Control.set_behave(hdr_mult_label, UIBehave.left | UIBehave.top)
-		Control.child_add(root, hdr_mult_label)
+	static colorspace_choice(ui, data_control){
+		var data: ColorPickerData = Control.get_state_data(data_control)
 
-		var hdr_number = UINumber.create(ui)
-		UINumber.set_value(hdr_number, 1)
-		UINumber.set_validation(hdr_number) { |input: Num|
-			return input.max(0)
-		}
-		Control.set_size(hdr_number, 64, 32)
-		Control.set_margin(hdr_number, 8, -4, 0, 0)
-		Control.set_behave(hdr_number, UIBehave.left | UIBehave.top)
-		Control.child_add(root, hdr_number)
-		Control.set_events(hdr_number){|event|
+		var root = Control.create(ui)
+		Control.set_behave(root, UIBehave.left)
+		Control.set_contain(root, UIContain.row | UIContain.hfit | UIContain.vfit | UIContain.start)
+		Control.set_margin(root, 8, 0, 0, 0)
+
+		var srgb_label = UILabel.create(ui)
+		Control.set_size(srgb_label, 36, 32)
+		UILabel.set_text(srgb_label, "srgb")
+		Control.set_behave(srgb_label, UIBehave.left)
+		Control.child_add(root, srgb_label)
+
+		var srgb_toggle = UICheck.create(ui)
+		Control.set_size(srgb_toggle, 32, 20)
+		Control.set_behave(srgb_toggle, UIBehave.left)
+		Control.child_add(root, srgb_toggle)
+
+		Control.set_events(data_control) {|event|
 			if(event.type == UIEvent.change){
-				data.hdr_multiplier = event.change
+				var data: ColorPickerData = event.change
+				UICheck.set_state(srgb_toggle, data.srgb)
+			}
+		}
+
+		Control.set_events(srgb_toggle){ |event|
+			if(event.type == UIEvent.change){
+				var input = event.change
+				data.srgb = input
+				data.debug = "srgb toggle"
 				UI.events_emit(data_control, UIEvent.change, data)
 			}
 		}
-		Control.set_events(data_control){|event|
-			if(event.type == UIEvent.change){
-				UINumber.set_value(hdr_number, data.hdr_multiplier)
-			}
-		}
-
-		var color_hdr = UIPanel.create(ui)
-		UIPanel.set_color(color_hdr, data.rgba_ldr)
-		UIPanel.set_border(color_hdr, 0, Color.clear)
-		Control.set_size(color_hdr, 64, 32)
-		Control.set_margin(color_hdr, 8, 4, 8, 0)
-		Control.set_behave(color_hdr, UIBehave.left | UIBehave.top)
-		Control.child_add(root, color_hdr)
-		Control.set_events(data_control){|event|
-			if(event.type == UIEvent.change){
-				var color = data.rgba
-				color.a = 1
-				UIPanel.set_color(color_hdr, color)
-			}
-		}
-		
-		var maximize_ldr_button = UIButton.create(ui)
-		UIButton.set_text(maximize_ldr_button, "maximize LDR")
-		UIButton.set_text_size(maximize_ldr_button, 12)
-		Control.set_size(maximize_ldr_button, 80, 24)
-		Control.set_behave(maximize_ldr_button, UIBehave.left | UIBehave.top)
-		Control.set_margin(maximize_ldr_button, 0, 4, 8, 0)
-		Control.child_add(root, maximize_ldr_button)
-		Control.set_events(maximize_ldr_button) {|event|
-			if(event.type == UIEvent.press){
-				if(data.v < 1 && data.v > 0.001){
-					var multiplier = data.hdr_multiplier.min(1/data.v).max(1)
-					data.hdr_multiplier = data.hdr_multiplier / multiplier
-					data.set_hsva_component(2, data.v * multiplier)
-					UI.events_emit(data_control, UIEvent.change, data)
-				}
-			}
-		}
-		
-		if(!data.allow_hdr){
-			Control.set_visible(hdr_header, false)
-			Control.set_visible(hdr_mult_label, false)
-			Control.set_visible(hdr_number, false)
-			Control.set_visible(maximize_ldr_button, false)
-			Control.set_visible(color_hdr, false)
-		}
 
 		return root
 	}
@@ -357,7 +513,7 @@ class CPHelper{
 		Control.child_add(root, label)
 
 		var text = UIText.create(ui)
-		UIText.set_text(text, color_to_hex_string(data.rgba_ldr, true))
+		UIText.set_text(text, color_to_hex_string(data.get_rgba(data.srgb, false), true))
 		Control.set_size(text, 128, 32)
 		Control.set_behave(text, UIBehave.left)
 		Control.child_add(root, text)
@@ -365,12 +521,7 @@ class CPHelper{
 		Control.set_events(data_control) {|event|
 			if(event.type == UIEvent.change){
 				var data: ColorPickerData = event.change
-				var color = data.rgba_ldr
-				if(data.srgb_hex){
-					color.r = color.r.pow(1 / 2.2)
-					color.g = color.g.pow(1 / 2.2)
-					color.b = color.b.pow(1 / 2.2)
-				}
+				var color = data.get_rgba(data.srgb, false)
 				UIText.set_text(text, color_to_hex_string(color, true))
 			}
 		}
@@ -380,44 +531,13 @@ class CPHelper{
 				var input = event.change
 				var color = hex_string_to_color(input)
 				if(color){
-					if(data.srgb_hex){
-						color.r = color.r.pow(2.2)
-						color.g = color.g.pow(2.2)
-						color.b = color.b.pow(2.2)
-					}
 					data.set_rgba(color)
+					data.debug = "hex input"
 					UI.events_emit(data_control, UIEvent.change, data)
 				}
 			}
 		}
 
-		var srgb_label = UILabel.create(ui)
-		Control.set_size(srgb_label, 36, 32)
-		UILabel.set_text(srgb_label, "srgb")
-		Control.set_behave(srgb_label, UIBehave.left)
-		Control.set_margin(srgb_label, 8, 0, 0, 0)
-		Control.child_add(root, srgb_label)
-
-		var srgb_toggle = UICheck.create(ui)
-		Control.set_size(srgb_toggle, 32, 20)
-		Control.set_behave(srgb_toggle, UIBehave.left)
-		Control.child_add(root, srgb_toggle)
-
-		Control.set_events(data_control) {|event|
-			if(event.type == UIEvent.change){
-				var data: ColorPickerData = event.change
-				UICheck.set_state(srgb_toggle, data.srgb_hex)
-			}
-		}
-
-		Control.set_events(srgb_toggle){ |event|
-			if(event.type == UIEvent.change){
-				var input = event.change
-				data.srgb_hex = input
-				UI.events_emit(data_control, UIEvent.change, data)
-			}
-		}
-
 		return root
 	}
 
@@ -504,6 +624,7 @@ class CPHelper{
 		Control.set_events(number) { |event: UIEvent|
 			if(event.type == UIEvent.change){
 				if(approx(UISlider.get_value(slider), event.change, 0.001)) return
+				System.print("number display: %(event.change)")
 				UI.events_emit(base, UIEvent.change, event.change)
 			}
 		}
@@ -511,34 +632,38 @@ class CPHelper{
 		Control.set_events(slider) { |event: UIEvent|
 			if(event.type == UIEvent.change){
 				if(approx(UINumber.get_value(number), event.change, 0.001)) return
+				System.print("slider display: %(event.change)")
 				UI.events_emit(base, UIEvent.change, event.change)
 			}
 		}
 
 		Control.set_events(color_view){|event|
 			if(event.type == UIEvent.change){
+				var data: ColorPickerData = event.change
 				if(space == "rgb"){
-					UISlider.set_value(slider, Math.fixed(event.change.get_rgba_component(index)))
-					UINumber.set_value(number, Math.fixed(event.change.get_rgba_component(index)))
+					UISlider.set_value(slider, Math.fixed(data.get_rgba_component(index)))
+					UINumber.set_value(number, Math.fixed(data.get_rgba_component(index)))
 				} else if(space == "hsv"){
-					UISlider.set_value(slider, Math.fixed(event.change.get_hsva_component(index)))
-					UINumber.set_value(number, Math.fixed(event.change.get_hsva_component(index)))
+					UISlider.set_value(slider, Math.fixed(data.get_hsva_component(index)))
+					UINumber.set_value(number, Math.fixed(data.get_hsva_component(index)))
 				}
 			}
 		}
 
 		Control.set_events(base) {|event|
 			if(event.type == UIEvent.change){
-				var color = Control.get_state_data(color_view)
+				var data: ColorPickerData = Control.get_state_data(color_view)
 				if(space == "rgb"){
-					if(approx(event.change, color.get_rgba_component(index))) return
-					color.set_rgba_component(index, event.change)
+					if(approx(event.change, data.get_rgba_component(index))) return
+					if(event.change > 1) Fiber.abort(event)
+					data.set_rgba_component(index, event.change)
 				} else if(space == "hsv"){
-					if(approx(event.change, color.get_hsva_component(index))) return
-					color.set_hsva_component(index, event.change)
+					if(approx(event.change, data.get_hsva_component(index))) return
+					data.set_hsva_component(index, event.change)
 				}
-				Control.set_state_data(color_view, color)
-				UI.events_emit(color_view, UIEvent.change, color)
+				Control.set_state_data(color_view, data)
+				data.debug = "component display"
+				UI.events_emit(color_view, UIEvent.change, data)
 			}
 		}
 
@@ -571,7 +696,8 @@ class CPHelper{
 					//change relevant values
 					var picker_state: ColorPickerData = Control.get_state_data(data_root)
 					var hsv = [hue, picker_state.s, picker_state.v, picker_state.a]
-					picker_state.set_hsva(hsv)
+					picker_state.set_hsva(hsv, false)
+					data.debug = "ring"
 					UI.events_emit(data_root, UIEvent.change, picker_state)
 				} else if(state["triangle"] == "captured"){ //if we're editing the triangle (saturation & value)
 					var picker_state: ColorPickerData = Control.get_state_data(data_root)
@@ -596,7 +722,8 @@ class CPHelper{
 
 					//calculate and apply relevant values
 					var hsv = [picker_state.h, saturation, value, picker_state.a]
-					picker_state.set_hsva(hsv)
+					picker_state.set_hsva(hsv, false)
+					data.debug = "triangle"
 					UI.events_emit(data_root, UIEvent.change, picker_state)
 				} else { //if we're not editing anything, lets check what we're hovering over!
 					var picker_state: ColorPickerData = Control.get_state_data(data_root)
@@ -681,7 +808,7 @@ class CPHelper{
 			var style: PathStyle = PathStyle.new()
 
 			var picker_state: ColorPickerData = Control.get_state_data(data_root)
-			var color = picker_state.rgba_ldr
+			var color = picker_state.color_ldr
 			color.a = 1
 			var hue = picker_state.h
 			var saturation = picker_state.s.pow(1/base_sat_gamma)
@@ -772,6 +899,20 @@ class CPHelper{
 		return null
 	}
 
+	static apply_srgb(col: Color){
+		col.r = col.r.pow(1 / 2.2)
+		col.g = col.g.pow(1 / 2.2)
+		col.b = col.b.pow(1 / 2.2)
+		//no alpha change
+	}
+
+	static unapply_srgb(col:Color){
+		col.r = col.r.pow(2.2)
+		col.g = col.g.pow(2.2)
+		col.b = col.b.pow(2.2)
+		//no alpha change
+	}
+
 	static approx_rgb(one: Color, other: Color, epsilson: Num) : Bool{
 		return approx(one.x, other.x, epsilson) && approx(one.y, other.y, epsilson) && approx(one.z, other.z, epsilson)
 	}