clogre.clj

(ns clogre
  (:import [org.eclipse.swt SWT]
	   [org.eclipse.swt.events KeyEvent KeyListener MouseEvent MouseListener]
	   [org.eclipse.swt.events MouseMoveListener PaintEvent PaintListener]
	   [org.eclipse.swt.layout FillLayout]
	   [org.eclipse.swt.opengl GLCanvas GLData]
	   [org.eclipse.swt.widgets Canvas Display Shell]
	   [org.ogre4j ColourValue HardwareBuffer ICamera IColourValue IEntity]
	   [org.ogre4j ILight IMeshManager IMeshPtr INameValuePairList IRadian]
	   [org.ogre4j IRay IRaySceneQuery IRaySceneQueryResult IRaySceneQueryResultEntry]
	   [org.ogre4j IRenderSystemList IRenderWindow IRoot ISceneManager ISceneNode]
	   [org.ogre4j IVector3 IViewport MeshManager MeshPtr NameValuePairList]
	   [org.ogre4j Plane Quaternion Radian Ray ResourceGroupManager Root StringUtil]
	   [org.ogre4j Vector3]
	   [org.ogre4j Light]
	   [org.xbig.base StringPointer]
	   [org.xbig.base WithoutNativeObject]))

(def default-window-size {:w 640, :h 480})

;;
(defn setup-canvas [os shell]
  (let [data (new GLData)]
   (if (. os equals "linux")
     (let [canvas (new GLCanvas shell SWT/NONE data)]
       (. canvas setCurrent)
       canvas)
     (let [canvas (new GLCanvas shell SWT/EMBEDDED data)]
       canvas))))

(defn setup-shell [os text size]
  (let [shell (new Shell)]
    (doto shell
      (.setText text)
      (.setLayout (new FillLayout))
      (.setSize (:w size) (:h size)))
    (let [canvas (setup-canvas os shell)]
      (. shell open)
      {:shell shell, :canvas canvas})))

;;
(defn setup-params [os params canvas]
  (if (. os equals "linux")
    (let [window-handle-pointer (new StringPointer "true")]
      (. params insert "currentGLContext" window-handle-pointer)
      {:params params, :window-handle-pointer window-handle-pointer})
    (let [window-handle-pointer (new StringPointer (. Integer toString (. canvas handle)))]
      (. params insert "externalWindowHandle" window-handle-pointer)
      {:params params, :window-handle-pointer window-handle-pointer})))

(defn setup-render-window [os root canvas]
  (let [params (setup-params os (new NameValuePairList) canvas)]
    (let [render-window (. root createRenderWindow ""
			   (.. canvas getBounds width)
			   (.. canvas getBounds height)
			   false params)]
      (. (:params params) delete)
      (. (:window-handle-pointer params) delete)
      render-window)))

;; initialize root
(defn setup-root [os render-system canvas root]
  ;; load render system 
  (if (. "Direct3D9" equals render-system)
    (. root loadPlugin "RenderSystem_Direct3D9")
    (. root loadPlugin "RenderSystem_GL"))

  (println "--- loaded render system ---")
  
  ;; set render system
  (let [lst (. root getAvailableRenderers)]
    (when (not lst)
      (throw (new Exception "No RenderSystem loaded!")))
    (. root setRenderSystem (. lst at 0)))

  (println "--- set render system ---")
  
  ;; initialize ogre root
  (try (. root initialise false "" (. StringUtil getBLANK))
       (catch NullPointerException e))

  (println "--- initialized ogre root ---")

  (setup-render-window os root canvas))

;; 
(defn create-scene-manager [root]
  (let [scene-manager (. root createSceneManager 0 "Default"),
	ambient-colour (new ColourValue 0.1 0.1 0.1 0)]
    (. scene-manager setAmbientLight ambient-colour)
    (. ambient-colour delete)
    scene-manager))

;;
(defn create-light [scene-manager]
  (let [light-colour (new ColourValue 0.7 0.7 0.7 0),
	light (. scene-manager createLight "lightName")]
    (doto light
      (.setDiffuseColour light-colour)
      (.setSpecularColour light-colour)
      (.setDirection 0 -0.5 -1)
      (.setPosition 0 50 100)
      (.setVisible true))
    (. light-colour delete)
    light))

;;
(defn create-camera [scene-manager]
  (let [root-scene-node (. scene-manager getRootSceneNode),
	camera (. scene-manager createCamera "Main Camera")]
    (doto camera
      (.setPosition 0 10 20)
      (.lookAt 0 0 0)
      (.setNearClipDistance 0.1))))

;;
(defn setup [media loc-type render-system]
  (let [os (. (System/getProperty "os.name") toLowerCase)]
    (let [root (new Root "" "" "aName.log"),
	  display (new Display),
	  shell (setup-shell os "" default-window-size)]
      (let [render-window (setup-root os render-system (:canvas shell) root)]
	render-window))))

;;
(defn start [media loc-type render-system]
  (try
   (setup media loc-type render-system)

   (loop []
     (if (not (. shell isDisposed))))))

(def os (. (System/getProperty "os.name") toLowerCase))
(def root (new Root "" "" "aName.log"))
(def shell (setup-shell os "" default-window-size))

shell
=> {:shell #<Shell Shell {*Wrong Thread*}>, :canvas #<GLCanvas GLCanvas {*Wrong Thread*}>}