(ns com.aurellem.run.image

   (:use (com.aurellem.gb saves gb-driver util constants

                          items vbm characters money

                          rlm-assembly))

   (:use (com.aurellem.run util music title save-corruption

                           bootstrap-0 bootstrap-1))

   (:require clojure.string)

   (:import [com.aurellem.gb.gb_driver SaveState])

   (:import java.io.File))

 

 ;; want to display an image onto the screen.

 ;; probably will be the six ponies, possibly with scrolling. 

 

 ;; probably don't need hi-color mode since the images shuld be

 ;; simple. 

 

 ;; use background tiles?  they provide greater color depth than

 ;; sprites, and can still be scrolled, so why not? 

 

 ;; could also use sprites to get 3 more colors per tile for a total of

 ;; 7 colors per tile, although not for all tiles...

 

 

 

 ;; want a function to

 

 ;; 1. read an image

 ;; 2. split into a grid of 8x8 pixels

 ;; 3. convert all RGB colors to gb-RGB colors

 ;; 4. determine efficient color palletes for the image

 ;; 5. output efficient assembly code to draw the image to the gb

 ;; screen.

 

 

 

 

 

 

 

 

 

 

 

 

 

 (def image-program-target 0xB000)

 

 (def display-width 160)

 (def display-height 144)

 

 

 

 ;{:r :g :b }

 

 (def character-data     0x8000)

 (def character-data-end 0x97FF)

 

 

 

 

 (def BG-data-1 0x9800)

 

 (def BG-data-2 0x9C00)

 

 (def OAM 0xFE00)

 

 

 

 (def video-bank-select-register 0xFF4F)

 

 (defn gb-rgb->bits [[r g b]]

   (assert (<= 0 r 31))

   (assert (<= 0 g 31))

   (assert (<= 0 b 31))

   [(bit-and

     0xFF

     (+

      r

      (bit-shift-left g 5)))

    (+

     (bit-shift-right g 3)

     (bit-shift-left  b 2))])

 

 

 (def bg-palette-select 0xFF68)

 (def bg-palette-data   0xFF69)

 

 (def obj-palette-select 0xFF6A)

 (def obj-palette-data   0xFF6B)

 

 (def max-palettes 8)

 

 (defn write-data [target data]

     (flatten

      [0x3E ;; load literal to A

       data

       0xEA ;; load A into target

       (reverse (disect-bytes-2 target))]))

 

 (defn begin-sequential-palette-write

   [palette-num palette-select-address]

   (assert (<= 0 palette-num max-palettes))

   (assert

    (or (= palette-select-address bg-palette-select)

        (= palette-select-address obj-palette-select)))

   (let [palette-write-data

         (Integer/parseInt

          (str "1" ;; auto increment

               "0" ;; not used

               (format

                "%03d"

                (Integer/parseInt

                 (Integer/toBinaryString palette-num) 10))

               "00" ;; color num

               "0"  ;; H/L

               ) 2)]

     (write-data palette-select-address palette-write-data)))

         

 (defn set-palettes [palette-select palette-data palettes]

   (assert (<= (count palettes)) max-palettes)

   (flatten 

    [(begin-sequential-palette-write 0 palette-select)

     (map (partial write-data palette-data)

          (flatten (map gb-rgb->bits palettes)))]))

 

 (defn display-one-color

   "Displayes a single color onto the gameboy screen. input rgb in

    gameboy rgb."

   [[r g b]]

   ;; construct a kernel that displays a single color

   (let

       [palettes (repeat 8 [r g b])

        kernel-address 0xC000

        kernel

        [0xF3 ;; disable interrupts

         (clear-music-registers)

         (frame-metronome)

         (set-palettes obj-palette-select obj-palette-data palettes)

         (set-palettes bg-palette-select bg-palette-data palettes)

         (infinite-loop)]]

     (-> (set-memory-range (second (music-base))

                           kernel-address (flatten kernel))

         (PC! kernel-address))))

 

 

 (require 'cortex.sense)

 (import java.awt.image.BufferedImage)

 

 (defn show-screenshot []

   (let [im (BufferedImage. 160 144 BufferedImage/TYPE_INT_RGB)

         pix (vec (pixels))

         view (cortex.sense/view-image)]

     (dorun (for [x (range 160) y (range 144)]

              (.setRGB im x y

                       ;0

                       (pix (+ x (* 160 y)))

                       )))

     (view im)))

 

      

   

 (defn write-palette-color [palette-num r g b]

   (let [[byte-1 byte-2] (gb-rgb->bits r g b)]

 

 

     ))