anchor.diff:                              ]
                           )
                       Sg.ofIndexedGeometry geom
  +                | Render (_, Cone(center,dir,height,radius)) -> 
  +                    let ig = IndexedGeometryPrimitives.solidCone center dir height radius 10 s.color
  +                    ig
  +                     |> Sg.ofIndexedGeometry
  +                     |> Sg.transform s.trafo
  +                | Render (_, Cylinder(center,dir,height,radius)) -> 
  +                    let ig = IndexedGeometryPrimitives.solidCylinder center dir height radius radius 10 s.color
  +                    ig
  +                     |> Sg.ofIndexedGeometry
  +                     |> Sg.transform s.trafo
                   | Render (_, Sphere g) -> 
                       let ig = IndexedGeometryPrimitives.solidSubdivisionSphere g 5 s.color
                       //ig.IndexedAttributes.[DefaultSemantic.Colors] <- (Array.replicate 4 s.color :> System.Array)
  
positive.code: open Aardvark.SceneGraph
  open Aardvark.Application
  
  module Controllers = 
  
      FsiSetup.initFsi (Path.combine [__SOURCE_DIRECTORY__; ".."; ".."; ".."; ".."; "bin";"Debug";"Examples.exe"])
  
      let win = Interactive.Window
  
      type Kind = Move | Down
  
      type PickOperation<'msg> = Kind -> Option<'msg>
      
      module Pick =
          let ignore = []
  
      type Primitive = 
          | Quad        of Quad3d
          | Sphere      of Sphere3d
  
      type Axis = X | Y | Z
      type Msg = Hover of Axis | Cleared | Translate of Axis
  
      type Scene<'msg> = 
          | Transform of Trafo3d * seq<Scene<'msg>>
          | Colored   of C4b     * seq<Scene<'msg>>
          | Render    of list<PickOperation<'msg>> * Primitive 
          | Group     of seq<Scene<'msg>>
  
      let colored     = curry Colored 
      let transformed = curry Transform 
      let translate x y z  = transformed ( Trafo3d.Translation(x,y,z) )
      let render      = curry Render
  
      type Model = {
          hovered   : Option<Axis>
          lastClick : Option<PixelPosition>
          trafo     : Trafo3d
      }
  
      let on (ref : Kind) (action : Msg) (k : Kind) =
          if ref = k then Some action else None
  
      let dir (a : Axis) =
          match a with 
              | X -> V3d.XAxis | Y -> V3d.YAxis | Z -> V3d.ZAxis
  
      let update (m : Model) (a : Msg) =
          match a with
              | Cleared ->  { m with hovered = None }
              | Hover v ->  { m with hovered = Some v}
              | Translate d -> { m with trafo = m.trafo * Trafo3d.Translation(dir d * 0.1) }
  
  
      let view (m : Model) =
          let sphereHandle = Sphere3d(V3d.Zero, 0.1)
  
          let ifHit (a : Axis) (selection : C4b) (defaultColor : C4b) =
              match m.hovered with
                  | Some v when v = a -> selection
                  | _ -> defaultColor
  
          transformed m.trafo [
                  translate 1.0 0.0 0.0 [
                      [sphereHandle |> Sphere |> render [on Move (Hover X); on Down (Translate X)]] 
                          |> colored (ifHit X C4b.White C4b.DarkRed)
                  ]
                  translate 0.0 1.0 0.0 [
                      [sphereHandle |> Sphere |> render [on Move (Hover Y); on Down (Translate Y)]] 
                          |> colored (ifHit Y C4b.White C4b.DarkBlue)
                  ]
                  translate 0.0 0.0 1.0 [
                      [sphereHandle |> Sphere |> render [on Move (Hover Z); on Down (Translate Z)]] 
                          |> colored (ifHit Z C4b.White C4b.DarkGreen)
                  ]
                  translate 0.0 0.0 0.0 [
                      [sphereHandle |> Sphere |> render Pick.ignore] |> colored C4b.Gray
                  ]
          ]
  
  
      type State = { trafo : Trafo3d; color : C4b }
  
negative.code:                      |> Sg.transform (Trafo3d.Translation(g.Center)) 
                       |> Sg.transform s.trafo
                  | Group xs -> xs |> Seq.map ( toSg s) |> Sg.group'
  
          toSg { trafo = Trafo3d.Identity; color = C4b.White } scene
  
      let pick (r : Ray3d) (s : Scene<'msg>)  =
  