sketch_apr-28-2021_22-45-51.glisp

;; Example: Primitive Definition
;; Defining new type of primitives
;;(defn vec2/- [a b] (vec2/+ (vec2/scale b -1) a)) 
(defn scale_ [a] ( scale [a a]))

; (defn rot_onto [q w] 
; (
; 	let [a (vec2/normalize q)
; 			 b (vec2/normalize w)]
; 	(mat2d/* (mat2d [(.x b) (- (.y b))
; 	          			 (.y b) (.x b)
; 	          			 0 0])
; 	         (mat2d [   (.x a)  (.y a)
; 	          		   (- (.y a)) (.x a) 
; 	          		   0 0]) 
; )))

(defn rot_onto [q w] (
 mat2d/* 
 (mat2d/rotate (- (vec2/angle q)))
 (mat2d/rotate (vec2/angle w))
))

(defn transform_op [start end bend translate ] 
(
	mat2d/* 
	(pivot translate ( 
	 mat2d/* 
		(rot_onto (vec2/- end start  ) bend )
		(scale_ (/  (vec2/len bend)
	         (vec2/len (vec2/- end start)) ))
	)
	(mat2d/translate (vec2/- translate start ) )
	
	
)))

(defn transform_iter 
	[[ i j k l ]] 
 (
	let [ bend (vec2/- j i)]
	(concat
   (path/transform 
  	( transform_op i l bend i  ) [ i j k l ])
   (path/transform 
		( transform_op i l (vec2/- k j) j  ) [ i j k l ])
   (path/transform 
		( transform_op i l bend k  ) [ i j k l ])
 )
))

(defn test2 [a b] 
(
	let [a (vec2/normalize a)
			 b (vec2/normalize b)]
			[(.x b) (- (.y b))
	          (- (.y b)) (.x b)]
))
( defn iter
   [n P]
    (if (zero? n)
      P  ; we're done
      (iter (dec n) 
                 ( mapcat (fn[x] (transform_iter (slice P x)))     
                   (range 0 (count P) 4 ) )     
            )))
     
; (def iter
;   (fn [n S]
;     (loop [cnt n
;           acc S]
;       (if (zero? cnt)
;             acc
;           (recur (dec cnt) 
;                 ( mapcat (fn[x] (transform_iter (slice S x)))
;     		(range 0 (count S) 4 ) )
;                 )
; ))))

(defn test
	{
		:params [{:label "Start" :type "vec2"}
		         {:label "End" :type "vec2"}
		         {:label "Bend" :type "vec2"}
		         ]
    :handles
    {:draw
     (fn {:params [s e b]}
       [{:id :start :type "point" :pos s}
         {:id :end :type "point" :pos e}
         {:id :bend :type "point" :pos (vec2/+ s b)}
       ]
      )
    :drag
    ;; In turn, returns new parameters
    ;; from the handle's ID and position
    (fn {:id id :pos pos
         :params [s e b]}
      (case id
        :start [pos e b]
        :end [s pos b]
        :bend [s e (vec2/- pos s ) ]
        ))
    }
	}

[s e b] (apply polyline 
	(let [S 
	     
    	[s (vec2/+ s b) 
      	(vec2/- e b)
      e]] 
		(iter 4 S)
    ; (let [P
	   ; ]
    ; ( mapcat (fn[x] (transform_iter (slice P x)))
    ; 		(range 0 (count P) 4 ) )
    ; )
    )

     ;(concat (transform_iter (slice S 0 ) )
     ;        (transform_iter (slice S 4 ) )
     ;        (transform_iter (slice S 8 ) ))
            
))

:start-sketch

(background "#B1A0A0")

(style (stroke "#FFC679" 1)
  
  (test [-119.5 -1.6] [-47.8508 -48.0407] [31.087 -1.7395] )
  

;(path/merge A B)
;(path/unite A B)
;(path/subtract A B)
;(path/intersect A B)
  )