Work

1 files changed, 206 insertions, 13 deletions

diff --git a/src/tafl.odin b/src/tafl.odin
index 6ffc2e8..a582858 100644
--- a/src/tafl.odin
+++ b/src/tafl.odin
@@ -1,43 +1,197 @@
 package tafl
 
 import "core:fmt"
+//import "core:math"
 import rl "vendor:raylib"
 
-tafl_elements : [1024]Tafl_Element
-tafl_stack    : [1024]int
+tafl_elements : [4096]Tafl
+tafl_elements_count : int
+
+tafl_stack    : [4096]int
 tafl_stack_depth : int
 
+child_buffer : [4096]int
+child_buffer_len : int
+
+temp_child_buffer : [4096]int
+temp_child_buffer_len : int // May be inferred by child count, and not be needed
+
 main :: proc() {
 	
-	tafl()
-	
+	{
+		tafl(color={.1,.1,.1,1})
+		
+		{
+			tafl(color={.1,.1,.1,1})
+			
+			{
+				tafl(color={.1,.1,.1,1})
+				
+				{
+					tafl(color={.1,.1,.1,1})
+				}
+				{
+					tafl(color={.1,.1,.1,1})
+				}
+				{
+					tafl(color={.1,.1,.1,1})
+				}
+			}
+			
+			{
+				tafl(color={.1,.1,.1,1})
+			}
+		}
+		
+		{
+			tafl(color={.1,.1,.1,1})
+		}
+		{
+			tafl(color={.1,.1,.1,1})
+			{
+				tafl(color={.1,.1,.1,1})
+			}
+			{
+				tafl(color={.1,.1,.1,1})
+			}
+		}
+		{
+			tafl(color={.1,.1,.1,1})
+		}
+	}
 }
 
 
-@(deferred_none=__tafl_close)
+
+@(deferred_out=__tafl_close)
 tafl :: proc(
-	width  : int = 0,
+	/*width  : int = 0,
 	height : int = 0,
 	x : int = 0,
-	y : int = 0,
+	y : int = 0,*/
 	sizing_width  : Sizing_Dimension = {.FIT, 0, 0},
 	sizing_height : Sizing_Dimension = {.FIT, 0, 0},
 	layout : Layout = .LEFT_TO_RIGHT,
 	padding : Sides = {0,0,0,0},
 	child_gap : int = 0,
-	) {
+	color : Color =  {1,1,0,1},
+	) -> ^Tafl{
+	
+	parent_ptr : ^Tafl = nil
+	if tafl_stack_depth > 0 {
+		parent_ptr = &tafl_elements[tafl_stack[tafl_stack_depth-1]]
+	}
 	
-	fmt.println("Opened tafl")
+	tafl_elements[tafl_elements_count] = {
+		/*width = width,
+		height = height,
+		x = x,
+		y = y,*/
+		sizing = {sizing_width, sizing_height},
+		layout = layout,
+		padding = padding,
+		child_gap = child_gap,
+		
+		parent = parent_ptr,
+	}
+	this_tafl : ^Tafl = &tafl_elements[tafl_elements_count]
 	
+	tafl_stack[tafl_stack_depth] = tafl_elements_count
+	this_tafl.own_index = tafl_elements_count
+	this_tafl.own_depth = tafl_stack_depth
+	this_tafl.children.index = temp_child_buffer_len
+	
+	indent(this_tafl.own_depth)
+	fmt.printfln("+ Opened tafl {}", this_tafl.own_index)
+
+	tafl_elements_count += 1
+	tafl_stack_depth += 1
+	
+	return this_tafl
 }
 
-__tafl_close :: proc() {
+
+__tafl_close :: proc(tafl : ^Tafl) {
+	
+	parent := tafl.parent
+	if parent != nil {
+		
+		tafl.width  += tafl.padding.left + tafl.padding.right
+		tafl.height += tafl.padding.top  + tafl.padding.bottom
+		
+		// Not entirely sure yet, because Nic's video doesn't say you need this
+		// max(), but I have a feeling that childless tafls will cause negative
+		// total_child_gaps, which would be bad.
+		// 
+		// ALSO: Wtf? Why are we basing this off of the tafls number of siblings?
+		//       I do not understand this.
+		total_child_gap := max(parent.children.len - 1, 0) * parent.child_gap
+		
+		switch parent.layout {
+			case .LEFT_TO_RIGHT:
+				tafl.width += total_child_gap
+				parent.width += tafl.width
+				parent.height = max(tafl.height, parent.height)
+			case .TOP_TO_BOTTOM:
+				tafl.height += total_child_gap
+				parent.height += tafl.height
+				parent.width   = max(tafl.width, parent.width)
+		}
+		
+	}
+	
+	for i in 0..<tafl.children.len {
+		child_buffer[child_buffer_len+i] = temp_child_buffer[tafl.children.index+i]
+		temp_child_buffer_len -= 1
+	}
+	tafl.children.index = child_buffer_len
+	child_buffer_len += tafl.children.len
 	
-	fmt.println("Closed tafl")
+	temp_child_buffer[temp_child_buffer_len] = tafl.own_index
+	temp_child_buffer_len += 1
 	
+	if parent != nil {
+		parent.children.len += 1
+	} else {
+		child_buffer[child_buffer_len] = 0
+		child_buffer_len += 1
+	}
+	
+	tafl_stack_depth -= 1
+	
+	indent(tafl.own_depth)
+	fmt.printfln("+ Closed tafl {}\t\tchild_buffer:{}\t\ttemp_child_buffer:{}\tchild_index:{} {}", tafl.own_index, child_buffer[0:child_buffer_len], temp_child_buffer[0:temp_child_buffer_len], tafl.children.index, tafl.children.len)
 }
 
 
+
+grow_children :: proc(parent : ^Tafl) {
+	remainingWidth := parent.width
+	remainingHeight := parent.height
+	remainingWidth  -= parent.padding.left + parent.padding.right
+	remainingHeight -= parent.padding.top  + parent.padding.bottom
+	
+	for i in 0..<parent.children.len {
+		child : ^Tafl = &tafl_elements[child_buffer[parent.children.index+i]]
+		remainingWidth -= child.width
+	}
+	// Do we need to make sure this isn't negative???
+	remainingWidth -= (parent.children.len - 1) * parent.child_gap
+	
+	for i in 0..<parent.children.len {
+		child : ^Tafl = &tafl_elements[child_buffer[parent.children.index+i]]
+		if child.sizing.width.type == .GROW {
+			child.width += remainingWidth
+		} else if (child.sizing.height.type == .GROW) {
+			child.height += remainingHeight
+		}
+	}
+}
+
+
+
+
+
 Sizing_Dimension :: struct {
 	type : enum{
 		FIT,
@@ -56,9 +210,26 @@ Sides :: struct {
 	top, bottom, left, right : int
 }
 
-Tafl_Element :: struct {
+Color :: struct {
+	r,g,b,a : f32
+}
+
+Tafl :: struct {
 	width, height : int,
 	x, y : int,
+	
+	own_index : int, // Delete me
+	own_depth : int, // Delete me
+	
+	parent : ^Tafl,
+	
+	
+	
+	// style
+	
+	children : struct {
+		index, len : int
+	},
 	sizing : struct {
 		width  : Sizing_Dimension,
 		height : Sizing_Dimension,
@@ -66,4 +237,26 @@ Tafl_Element :: struct {
 	layout : Layout,
 	padding : Sides,
 	child_gap : int,
-}
\ No newline at end of file
+	color : Color,
+}
+
+Tafl_Style :: struct {
+	sizing : struct {
+		width  : Sizing_Dimension,
+		height : Sizing_Dimension,
+	},
+	layout : Layout,
+	padding : Sides,
+	child_gap : int,
+	color : Color,
+}
+
+indent :: proc(x : int) {
+	for _ in 0..<x {
+		fmt.print("|   ")
+	}
+}
+
+GROW : Sizing_Dimension : {.GROW, 0, max(type_of(Sizing_Dimension{}.max))}
+
+FIT : Sizing_Dimension : {.FIT, 0, max(type_of(Sizing_Dimension{}.max))}
\ No newline at end of file