/dgud-wings-9a2473e/src/wings_camera.erl

# · Erlang · 956 lines · 812 code · 92 blank · 52 comment · 2 complexity · 0c7f879bc7d2705e1db44fdafd212fff MD5 · raw file 

    

  1. %%
    2. 

  2. %%  wings_camera.erl --
    3. 

  3. %%
    4. 

  4. %%     This module handles camera moves (rotation, zooming, and panning).
    5. 

  5. %%
    6. 

  6. %%  Copyright (c) 2001-2011 Bjorn Gustavsson
    7. 

  7. %%
    8. 

  8. %%  See the file "license.terms" for information on usage and redistribution
    9. 

  9. %%  of this file, and for a DISCLAIMER OF ALL WARRANTIES.
    10. 

  10. %%
    11. 

  11. %%     $Id$
    12. 

  12. %%
    13. 

  13. 

  14. -module(wings_camera).
    15. 

  15. -export([init/0,prefs/0,help/0,event/2,event/3]).
    16. 

  16. 

  17. -export([tweak_camera_event/4]).
    18. 

  18. 

  19. -define(NEED_ESDL, 1).
    20. 

  20. -include("wings.hrl").
    21. 

  21. 

  22. -define(ZOOM_FACTOR, 20).
    23. 

  23. -define(ZOOM_FACTOR_ALT, 1).
    24. 

  24. 

  25. -define(CAMDIV, 4).
    26. 

  26. 

  27. -define(CSEP, 160).				%Short space.
    28. 

  28. -define(NEARZERO, 1.0e-6).
    29. 

  29. -record(camera,
    30. 

  30. 	{x,y,					%Current mouse position.
    31. 

  31. 	 ox,oy,					%Original mouse position.
    32. 

  32. 	 xt=0,yt=0				%Last warp length.
    33. 

  33. 	}).
    34. 

  34. 

  35. -record(state, {st, func}).
    36. 

  36. 

  37. init() ->
    38. 

  38.     wings_pref:set_default(camera_mode, wings_cam),
    39. 

  39.     wings_pref:set_default(num_buttons, 3),
    40. 

  40.     wings_pref:set_default(cam_rotation_speed, 25),
    41. 

  41.     wings_pref:set_default(pan_speed, 25),
    42. 

  42.     wings_pref:set_default(pan_speed_arrow_keys, 50),
    43. 

  43.     wings_pref:set_default(wheel_adds, false),
    44. 

  44.     wings_pref:set_default(wh_scroll_info,true),
    45. 

  45.     wings_pref:set_default(wh_pan_spd, 50),
    46. 

  46.     wings_pref:set_default(wh_rot_spd, 7.50),
    47. 

  47.     wings_pref:set_default(highlight_zoom_aim, false),
    48. 

  48.     case {wings_pref:get_value(num_buttons),wings_pref:get_value(camera_mode)} of
    49. 

  49. 	{3,_} -> ok;
    50. 

  50. 	{_,nendo} -> ok;
    51. 

  51. 	{_,blender} -> ok;
    52. 

  52. 	{_,_} -> wings_pref:set_value(camera_mode, nendo)
    53. 

  53.     end.
    54. 

  54.     
    55. 

  55. prefs() ->
    56. 

  56.     ZoomFlag0 = wings_pref:get_value(wheel_zooms, true),
    57. 

  57.     ZoomFactor0 = wings_pref:get_value(wheel_zoom_factor, ?ZOOM_FACTOR),
    58. 

  58.     ZoomFactorAlt = wings_pref:get_value(wheel_zoom_factor_alt, ?ZOOM_FACTOR_ALT),
    59. 

  59.     CamRotSpeed = wings_pref:get_value(cam_rotation_speed, 25),
    60. 

  60.     PanSpeed0 = wings_pref:get_value(pan_speed, 25),
    61. 

  61.     ArrowPanSpeed = wings_pref:get_value(pan_speed_arrow_keys, 50),
    62. 

  62.     WheelAdds = wings_pref:get_value(wheel_adds,false),
    63. 

  63.     WhScrollInfo = wings_pref:get_value(wh_scroll_info,true),
    64. 

  64.     WhPanSpd = wings_pref:get_value(wh_pan_spd, 50),
    65. 

  65.     WhRotate = wings_pref:get_value(wh_rot_spd, 7.5),
    66. 

  66.     ZoomAim = wings_pref:get_value(highlight_zoom_aim),
    67. 

  67. 

  68.     Hook = fun (is_disabled, {_Var,_I,Sto}) ->
    69. 

  69.             not gb_trees:get(wheel_zooms, Sto);
    70. 

  70.              (_, _) -> void
    71. 

  71.            end,
    72. 

  72.     WHook = fun (is_disabled, {_Var,_I,Sto}) ->
    73. 

  73.              not ((gb_trees:get(wheel_adds, Sto)) andalso (gb_trees:get(wheel_zooms, Sto)));
    74. 

  74.              (_, _) -> void
    75. 

  75.             end,
    76. 

  76.     {hframe,
    77. 

  77.     [{vframe,
    78. 

  78.      [{vframe,[mouse_buttons()],[{title,?__(1,"Mouse Buttons")}]},
    79. 

  79.       {vframe,[camera_modes()],[{title,?__(2,"Camera Mode")}]},
    80. 

  80.       {vframe,
    81. 

  81.        [{hframe,[{slider,{text,CamRotSpeed,[{key,cam_rotation_speed},{range,{1,100}}]}}]}],
    82. 

  82.        [{title,?__(19,"Rotation Speed")}]},
    83. 

  83.       {vframe,
    84. 

  84.        [{hframe,[{slider,{text,PanSpeed0,[{key,pan_speed},{range,{1,100}}]}}]}],
    85. 

  85.        [{title,?__(3,"Pan Speed")}]},
    86. 

  86.       {vframe,
    87. 

  87.        [{hframe,[{slider,{text,ArrowPanSpeed,[{key,pan_speed_arrow_keys},{range,{1,100}}]}}]}],
    88. 

  88.        [{title,?__(16,"Arrow Key Pan Speed")}]}]},
    89. 

  89.     {vframe,
    90. 

  90.       [{vframe,
    91. 

  91.        [{hframe,[{?__(4,"Wheel Zooms"),ZoomFlag0,[{key,wheel_zooms}]},
    92. 

  92.                  {?__(20,"Zooming in aims Camera"),ZoomAim,[{key,highlight_zoom_aim}]}]},
    93. 

  93.     {hframe,
    94. 

  94.      [{label,?__(7,"Zoom Factor"),[{hook,Hook}]},
    95. 

  95.       {text,ZoomFactor0,
    96. 

  96.        [{key,wheel_zoom_factor},
    97. 

  97.      {range,{1,50}},{hook,Hook}]},
    98. 

  98.       {label,"%",[{hook,Hook}]}]},
    99. 

  99.      {hframe,
    100. 

  100.       [{label,?__(10,"Alternate Zoom Factor(Alt+Scroll)"),[{hook,Hook}]},
    101. 

  101.        {text,ZoomFactorAlt,
    102. 

  102.         [{key,wheel_zoom_factor_alt},
    103. 

  103.       {range,{1,50}},{hook,Hook}]},
    104. 

  104.      {label,"%",[{hook,Hook}]}]} ],[{title,?__(9,"Scroll Wheel")}]},
    105. 

  105.     {vframe,
    106. 

  106.       [{?__(11,"Wheel Pans & Rotates"),WheelAdds,[{key,wheel_adds},{hook,Hook}]},
    107. 

  107.        {?__(17,"Show Info Line Help String"),WhScrollInfo,[{key,wh_scroll_info},{hook,WHook}]}, 
    108. 

  108.       {vframe,
    109. 

  109.        [{hframe,
    110. 

  110.         [{slider,{text,WhPanSpd,[{key, wh_pan_spd},{range,{1,100}}]}}],
    111. 

  111.       [{title,?__(12,"Pan Speed")},{hook,WHook}]},
    112. 

  112.       {hframe,
    113. 

  113.        [{slider,{text,WhRotate,[{key, wh_rot_spd},{range,{?NEARZERO,180.0}}]}}],
    114. 

  114.        [{title,?__(13,"Rotation Step in Degrees")},{hook,WHook}]}]}],
    115. 

  115.     [{title,?__(15,"Unidirectional Camera")}]}]}]}.
    116. 

  116. 

  117. mouse_buttons() ->
    118. 

  118.     {menu,[{desc(1),1,[{info,info(1)}]},
    119. 

  119.            {desc(2),2,[{info,info(2)}]},
    120. 

  120.            {desc(3),3,[{info,info(3)}]}],
    121. 

  121.      wings_pref:get_value(num_buttons),
    122. 

  122.      [{key,num_buttons},
    123. 

  123.       {hook,fun (update, {Var,_I,Val,Sto0}) ->
    124. 

  124. 		    Sto = gb_trees:update(Var, Val, Sto0),
    125. 

  125. 		    Mode0 = gb_trees:get(camera_mode, Sto),
    126. 

  126. 		    Mode = case {Val,Mode0} of
    127. 

  127. 			       {1,_} -> nendo;
    128. 

  128. 			       {2,blender} -> blender;
    129. 

  129. 			       {2,_} -> nendo;
    130. 

  130. 			       {3,_} -> Mode0
    131. 

  131. 			   end,
    132. 

  132. 		    {store,gb_trees:update(camera_mode, Mode, Sto)};
    133. 

  133. 		(_, _) -> void
    134. 

  134. 	    end}]}.
    135. 

  135. 

  136. camera_modes() ->
    137. 

  137.     Modes = [wings_cam,mirai,nendo,maya,tds,blender,mb,sketchup],
    138. 

  138.     {menu,[{desc(Mode),Mode,[{info,info(Mode)}]} || Mode <- Modes],
    139. 

  139.      wings_pref:get_value(camera_mode),
    140. 

  140.      [{key,camera_mode},
    141. 

  141.       {hook,fun (menu_disabled, {_Var,_I,Sto}) ->
    142. 

  142. 		    case gb_trees:get(num_buttons, Sto) of
    143. 

  143. 			1 -> [mirai,maya,tds,blender,mb,sketchup,wings_cam];
    144. 

  144. 			2 -> [mirai,maya,tds,mb,sketchup,wings_cam];
    145. 

  145. 			3 -> []
    146. 

  146. 		    end;
    147. 

  147. 		(_, _) -> void
    148. 

  148. 	    end}]}.
    149. 

  149. 

  150. desc(1) -> ?__(1,"One");
    151. 

  151. desc(2) -> ?__(2,"Two");
    152. 

  152. desc(3) -> ?__(3,"Three");
    153. 

  153. desc(Other) -> wings_s:camera_mode(Other).
    154. 

  154. 

  155. info(1) ->
    156. 

  156.     ?__(1,"Note: Only the Nendo camera mode can be used with a one-button mouse");
    157. 

  157. info(2) ->
    158. 

  158.     ?__(2,"Note: Only the Nendo and Blender camera modes can be used with a two-button mouse");
    159. 

  159. info(3) -> "";
    160. 

  160. info(nendo) -> "";
    161. 

  161. info(blender) ->
    162. 

  162.     [?__(3,"Note: The "),desc(blender),
    163. 

  163.      ?__(4," camera mode requires at least 2 mouse buttons")];
    164. 

  164. info(Mode) ->
    165. 

  165.     [?__(5,"Note: The "),desc(Mode),
    166. 

  166.      ?__(6," camera mode requires 3 mouse buttons")].
    167. 

  167. 

  168. help() ->
    169. 

  169. 	Help = case wings_pref:get_value(camera_mode) of
    170. 

  170. 	  blender -> blender_help();
    171. 

  171. 	  nendo -> wings_msg:button_format([], ?__(1,"Start camera"));
    172. 

  172. 	  mirai -> wings_msg:button_format([], ?__(1,"Start camera"));
    173. 

  173. 	  wings_cam -> wings_msg:button_format([], ?__(1,"Start camera"));
    174. 

  174. 	  tds -> tds_help();
    175. 

  175. 	  maya -> maya_help();
    176. 

  176. 	  mb -> mb_help();
    177. 

  177. 	  sketchup -> sketchup_help()
    178. 

  178. 	end,
    179. 

  179. 	WheelAdds = wings_pref:get_value(wheel_adds),
    180. 

  180. 	WhScrollHelp = wings_pref:get_value(wh_scroll_info),
    181. 

  181. 	case {WheelAdds,WhScrollHelp} of
    182. 

  182. 	  {true,true} -> [Help|scroll_help()];
    183. 

  183. 	  {_,_} -> Help
    184. 

  184. 	end.
    185. 

  185. scroll_help() ->
    186. 

  186.     ?__(1,"  [Ctrl](+[Alt])+Scroll: Pan  [Shift](+[Alt])+Scroll: Rotate").
    187. 

  187. 

  188. %% Event handler.
    189. 

  189. event(Ev, St=#st{}) -> 
    190. 

  190.     event(Ev,St,none).
    191. 

  191. %% Scroll wheel camera events
    192. 

  192. event(#mousebutton{button=B}=Ev, _St, _Redraw) when B=:=4; B=:=5 ->
    193. 

  193.     generic_event(Ev,_St,_Redraw);
    194. 

  194. % Camera mode specific events
    195. 

  195. event(Ev, St, Redraw) ->
    196. 

  196.     case wings_pref:get_value(camera_mode) of
    197. 

  197. 	wings_cam -> wings_cam(Ev, #state{st=St, func=Redraw});
    198. 

  198. 	blender -> blender(Ev, #state{st=St, func=Redraw});
    199. 

  199. 	nendo -> nendo(Ev, #state{st=St, func=Redraw});
    200. 

  200. 	mirai -> mirai(Ev, #state{st=St, func=Redraw});
    201. 

  201. 	tds -> tds(Ev, #state{st=St, func=Redraw});
    202. 

  202. 	maya -> maya(Ev, #state{st=St, func=Redraw});
    203. 

  203. 	mb -> mb(Ev, #state{st=St, func=Redraw});
    204. 

  204. 	sketchup -> sketchup(Ev, #state{st=St, func=Redraw})
    205. 

  205.     end.
    206. 

  206. 

  207. %%%
    208. 

  208. %%% Tweak Camera
    209. 

  209. %%%
    210. 

  210. 

  211. tweak_camera_event(Sym, X, Y, St) when Sym =:= $c; Sym =:= $s; Sym =:= $d ->
    212. 

  212.     Camera = #camera{x=X,y=Y,ox=X,oy=Y},
    213. 

  213.     {seq,push,get_tweak_cam_event(Sym, Camera, St)};
    214. 

  214. tweak_camera_event(Sym, _, _, _) ->
    215. 

  215.     arrow_key_pan(Sym).
    216. 

  216. 

  217. get_tweak_cam_event(Sym, Camera, St) ->
    218. 

  218.     {replace,fun(Ev) -> tweak_cam_event(Ev, Sym, Camera, St) end}.
    219. 

  219. 

  220. tweak_cam_event(#mousemotion{x=X0,y=Y0}, Sym, Camera0, St) ->
    221. 

  221.     case wings_io:is_key_pressed(Sym) of
    222. 

  222.       true  ->
    223. 

  223.           {Dx,Dy,Camera} = camera_mouse_range(X0, Y0, Camera0),
    224. 

  224.           case Sym of
    225. 

  225.               $c -> rotate(Dx,Dy);
    226. 

  226.               $s -> pan(Dx,Dy);
    227. 

  227.               $d -> zoom(Dy)
    228. 

  228.           end,
    229. 

  229.           wings_wm:dirty(),
    230. 

  230.           get_tweak_cam_event(Sym, Camera, St);
    231. 

  231.       false ->
    232. 

  232.         quit_tweak_cam()
    233. 

  233.      end;
    234. 

  234. tweak_cam_event(#mousebutton{button=B,state=?SDL_RELEASED}=Ev, Sym, Camera, St)
    235. 

  235.   when B =< 3->
    236. 

  236.     case wings_io:is_key_pressed(Sym) of
    237. 

  237.       true ->
    238. 

  238.         generic_event(Ev, Camera, #state{st=St, func=none});
    239. 

  239.       false ->
    240. 

  240.         quit_tweak_cam()
    241. 

  241.      end;
    242. 

  242. tweak_cam_event(Ev, Sym, Camera, St) ->
    243. 

  243.     case wings_io:is_key_pressed(Sym) of
    244. 

  244.       true ->
    245. 

  245.         generic_event(Ev, Camera, #state{st=St, func=none});
    246. 

  246.       false ->
    247. 

  247.         quit_tweak_cam()
    248. 

  248.      end.
    249. 

  249. 

  250. quit_tweak_cam() ->
    251. 

  251.     case wings_io:get_mouse_state() of
    252. 

  252.       {0,X,Y} ->
    253. 

  253.         wings_wm:later(#mousebutton{button=1,x=X,y=Y,mod=0,state=?SDL_RELEASED}),
    254. 

  254.         pop;
    255. 

  255.       _ ->
    256. 

  256.         pop
    257. 

  257.     end.
    258. 

  258. 

  259. %%%
    260. 

  260. %%% Blender style camera.
    261. 

  261. %%%
    262. 

  262. 

  263. blender(#mousebutton{button=2,state=?SDL_PRESSED,x=X0,y=Y0,mod=Mod}, Redraw)
    264. 

  264.   when Mod band ?ALT_BITS =:= 0 ->
    265. 

  265.     {X,Y} = wings_wm:local2global(X0, Y0),
    266. 

  266.     Camera = #camera{x=X,y=Y,ox=X,oy=Y},
    267. 

  267.     grab(),
    268. 

  268.     message(blender_help()),
    269. 

  269.     {seq,push,get_blender_event(Camera, Redraw)};
    270. 

  270. blender(#keyboard{sym=Sym}, _Redraw) ->
    271. 

  271.     arrow_key_pan(Sym);
    272. 

  272. blender(_, _) -> next.
    273. 

  273. 

  274. blender_event(#mousebutton{button=2,state=?SDL_RELEASED}, Camera, _Redraw) ->
    275. 

  275.     stop_camera(Camera);
    276. 

  276. blender_event(#mousemotion{x=X,y=Y,mod=Mod}, Camera0, Redraw) ->
    277. 

  277.     {Dx,Dy,Camera} = camera_mouse_range(X, Y, Camera0),
    278. 

  278.     case Mod of
    279. 

  279.       Mod when Mod band ?SHIFT_BITS =/= 0 ->
    280. 

  280.           pan(Dx, Dy);
    281. 

  281.       Mod when Mod band ?CTRL_BITS =/= 0 ->
    282. 

  282.           zoom(Dy);
    283. 

  283.       _Other ->
    284. 

  284.           rotate(Dx, Dy)
    285. 

  285.     end,
    286. 

  286.     wings_wm:dirty(),
    287. 

  287.     get_blender_event(Camera, Redraw);
    288. 

  288. blender_event(Other, Camera, Redraw) ->
    289. 

  289.     generic_event(Other, Camera, Redraw).
    290. 

  290. 

  291. get_blender_event(Camera, Redraw) ->
    292. 

  292.     {replace,fun(Ev) -> blender_event(Ev, Camera, Redraw) end}.
    293. 

  293. 

  294. blender_help() ->
    295. 

  295.     TrackDolly = [{?SHIFT_BITS,2,?STR(mode_help,1,"Track")},
    296. 

  296. 		  {?CTRL_BITS,2,?STR(mode_help,2,"Dolly")}],
    297. 

  297.     case allow_rotation() of
    298. 

  298.       false -> format(TrackDolly);
    299. 

  299.       true -> format([{0,2,?STR(mode_help,3,"Tumble")}|TrackDolly])
    300. 

  300.     end.
    301. 

  301. 

  302. %%%
    303. 

  303. %%% Nendo style camera.
    304. 

  304. %%%
    305. 

  305. 

  306. nendo(#mousebutton{button=2,x=X0,y=Y0,mod=Mod,state=?SDL_RELEASED}, Redraw)
    307. 

  307.   when Mod band ?CTRL_BITS =:= 0 ->
    308. 

  308.     {X,Y} = wings_wm:local2global(X0, Y0),
    309. 

  309.     Camera = #camera{x=X,y=Y,ox=X,oy=Y},
    310. 

  310.     grab(),
    311. 

  311.     MoveTumbles = allow_rotation(),
    312. 

  312.     nendo_message(MoveTumbles),
    313. 

  313.     {seq,push,get_nendo_event(Camera, Redraw, MoveTumbles)};
    314. 

  314. nendo(#keyboard{sym=Sym}, _Redraw) ->
    315. 

  315.     arrow_key_pan(Sym);
    316. 

  316. nendo(_, _) -> next.
    317. 

  317. 

  318. nendo_event(#mousebutton{button=1,state=?SDL_RELEASED}, Camera, _, _) ->
    319. 

  319.     stop_camera(Camera);
    320. 

  320. nendo_event(#mousemotion{x=X,y=Y,state=Buttons}, Camera0, Redraw, true) ->
    321. 

  321.     {Dx,Dy,Camera} = camera_mouse_range(X, Y, Camera0),
    322. 

  322.     case Buttons band 6 of
    323. 

  323. 	0 ->
    324. 

  324. 	    rotate(-Dx, -Dy);
    325. 

  325. 	_Other ->
    326. 

  326. 	    zoom(Dy)
    327. 

  327.     end,
    328. 

  328.     get_nendo_event(Camera, Redraw, true);
    329. 

  329. nendo_event(#mousemotion{x=X,y=Y,state=Buttons}, Camera0, Redraw, false) ->
    330. 

  330.     {Dx,Dy,Camera} = camera_mouse_range(X, Y, Camera0),
    331. 

  331.     case Buttons band 6 of
    332. 

  332. 	0 ->
    333. 

  333. 	    pan(-Dx, -Dy);
    334. 

  334. 	_Other ->
    335. 

  335. 	    zoom(Dy)
    336. 

  336.     end,
    337. 

  337.     get_nendo_event(Camera, Redraw, false);
    338. 

  338. nendo_event(#keyboard{unicode=$q}, Camera, Redraw, MR0) ->
    339. 

  339.     MR = MR0 xor allow_rotation(),
    340. 

  340.     nendo_message(MR),
    341. 

  341.     get_nendo_event(Camera, Redraw, MR);
    342. 

  342. nendo_event(#keyboard{sym=Sym}=Event, Camera, Redraw, _) ->
    343. 

  343.     case arrow_key_pan(Sym) of
    344. 

  344. 	keep -> keep;
    345. 

  345. 	next -> view_hotkey(Event, Camera, Redraw)
    346. 

  346.     end;
    347. 

  347. nendo_event(Event, Camera, Redraw, _) ->
    348. 

  348.     generic_event(Event, Camera, Redraw).
    349. 

  349.     
    350. 

  350. get_nendo_event(Camera, Redraw, MouseRotates) ->
    351. 

  351.     wings_wm:dirty(),
    352. 

  352.     {replace,fun(Ev) -> nendo_event(Ev, Camera, Redraw, MouseRotates) end}.
    353. 

  353. 

  354. nendo_message(true) ->
    355. 

  355.     Help = wings_msg:join([wings_msg:button_format(wings_s:accept(),[],
    356. 

  356.            ?STR(message,2,"Drag to Dolly")),
    357. 

  357.            ?STR(message,3,"Move mouse to tumble"),
    358. 

  358.           [?STR(message,4,"[Q]"),?CSEP,
    359. 

  359.            ?STR(message,5,"Move mouse to track")]]),
    360. 

  360.     message(Help);
    361. 

  361. nendo_message(false) ->
    362. 

  362.     QText = case allow_rotation() of
    363. 

  363. 		false -> [];
    364. 

  364. 		true -> [?STR(message,4,"[Q]"),?CSEP,
    365. 

  365. 			 ?STR(message,3,"Move mouse to tumble")]
    366. 

  366. 	    end,
    367. 

  367.     Help = wings_msg:join([wings_msg:button_format(wings_s:accept(),[],
    368. 

  368. 						   ?STR(message,2,"Drag to Dolly")),
    369. 

  369. 			         QText]),
    370. 

  370.     message(Help).
    371. 

  371. 

  372. %%%
    373. 

  373. %%% Mirai style camera.
    374. 

  374. %%%
    375. 

  375. 

  376. mirai(#mousebutton{button=2,x=X0,y=Y0,mod=Mod,state=?SDL_RELEASED}, Redraw)
    377. 

  377.   when Mod band ?CTRL_BITS =:= 0 ->
    378. 

  378.     {X,Y} = wings_wm:local2global(X0, Y0),
    379. 

  379.     Camera = #camera{x=X,y=Y,ox=X,oy=Y},
    380. 

  380.     grab(),
    381. 

  381.     MoveTumbles = allow_rotation(),
    382. 

  382.     mirai_message(MoveTumbles),
    383. 

  383.     View = wings_view:current(),
    384. 

  384.     {seq,push,get_mirai_event(Camera, Redraw, MoveTumbles, View)};
    385. 

  385. mirai(#keyboard{sym=Sym}, _Redraw) ->
    386. 

  386.     arrow_key_pan(Sym);
    387. 

  387. mirai(_, _) -> next.
    388. 

  388. 

  389. mirai_event(#mousebutton{button=1,state=?SDL_RELEASED}, Camera, _, _, _) ->
    390. 

  390.     stop_camera(Camera);
    391. 

  391. mirai_event(#mousebutton{button=3,state=?SDL_RELEASED}, Camera, _, _, View) ->
    392. 

  392.     wings_view:set_current(View),
    393. 

  393.     stop_camera(Camera);
    394. 

  394. mirai_event(#mousemotion{x=X,y=Y,state=Buttons}, Camera0, Redraw, true, View) ->
    395. 

  395.     {Dx,Dy,Camera} = camera_mouse_range(X, Y, Camera0),
    396. 

  396.     case Buttons band 2 of
    397. 

  397. 	0 ->					%MMB not pressed.
    398. 

  398. 	    rotate(-Dx, -Dy);
    399. 

  399. 	_Other ->				%MMB pressed.
    400. 

  400. 	    zoom(Dy)
    401. 

  401.     end,
    402. 

  402.     get_mirai_event(Camera, Redraw, true, View);
    403. 

  403. mirai_event(#mousemotion{x=X,y=Y,state=Buttons}, Camera0, Redraw, false, View) ->
    404. 

  404.     {Dx,Dy,Camera} = camera_mouse_range(X, Y, Camera0),
    405. 

  405.     case Buttons band 2 of
    406. 

  406. 	0 ->					%MMB pressed.
    407. 

  407. 	    pan(-Dx, -Dy);
    408. 

  408. 	_Other ->				%MMB pressed.
    409. 

  409. 	    zoom(Dy)
    410. 

  410.     end,
    411. 

  411.     get_mirai_event(Camera, Redraw, false, View);
    412. 

  412. mirai_event(#keyboard{unicode=$q}, Camera, Redraw, MR0, View) ->
    413. 

  413.     MR = MR0 xor allow_rotation(),
    414. 

  414.     mirai_message(MR),
    415. 

  415.     get_mirai_event(Camera, Redraw, MR, View);
    416. 

  416. mirai_event(#keyboard{sym=Sym}=Event, Camera, Redraw, _, _) ->
    417. 

  417.     case arrow_key_pan(Sym) of
    418. 

  418. 	keep -> keep;
    419. 

  419. 	next -> view_hotkey(Event, Camera, Redraw)
    420. 

  420.     end;
    421. 

  421. mirai_event(Event, Camera, Redraw, _, _) ->
    422. 

  422.     generic_event(Event, Camera, Redraw).
    423. 

  423. 

  424. get_mirai_event(Camera, Redraw, MouseRotates, View) ->
    425. 

  425.     wings_wm:dirty(),
    426. 

  426.     {replace,fun(Ev) -> mirai_event(Ev, Camera, Redraw, MouseRotates, View) end}.
    427. 

  427. 

  428. mirai_message(true) ->
    429. 

  429.     Help = wings_msg:join([wings_msg:button_format(wings_s:accept(),
    430. 

  430. 				   ?STR(message,2,"Drag to Dolly"),
    431. 

  431. 				   ?STR(message,6,"Cancel/restore view")),
    432. 

  432. 				   ?STR(message,3,"Move mouse to tumble"),
    433. 

  433. 				  [?STR(message,4,"[Q]"),?CSEP,
    434. 

  434. 				   ?STR(message,5,"Move mouse to track")]]),
    435. 

  435.     message(Help);
    436. 

  436. mirai_message(false) ->
    437. 

  437.     QText = case allow_rotation() of
    438. 

  438. 		false -> [];
    439. 

  439. 		true -> [?STR(message,4,"[Q]"),?CSEP,?STR(message,3,"Move mouse to tumble")]
    440. 

  440. 	    end,
    441. 

  441.     Help = wings_msg:join([wings_msg:button_format(wings_s:accept(),
    442. 

  442. 				   ?STR(message,2,"Drag to Dolly"),
    443. 

  443. 				   ?STR(message,6,"Cancel/restore view")),
    444. 

  444. 				   ?STR(message,5,"Move mouse to track"),QText]),
    445. 

  445.     message(Help).
    446. 

  446. 

  447. %%%
    448. 

  448. %%% 3ds max style camera.
    449. 

  449. %%%
    450. 

  450. 

  451. tds(#mousebutton{button=2,x=X0,y=Y0,state=?SDL_PRESSED}, Redraw) ->
    452. 

  452.     {X,Y} = wings_wm:local2global(X0, Y0),
    453. 

  453.     Camera = #camera{x=X,y=Y,ox=X,oy=Y},
    454. 

  454.     grab(),
    455. 

  455.     message(wings_msg:join(tds_help(), 
    456. 

  456. 			   wings_msg:button_format([], [],
    457. 

  457. 			   ?STR(message,7,"Restore view")))),
    458. 

  458.     View = wings_view:current(),
    459. 

  459.     {seq,push,get_tds_event(Camera, Redraw, View)};
    460. 

  460. tds(#keyboard{sym=Sym}, _Redraw) ->
    461. 

  461.     arrow_key_pan(Sym);
    462. 

  462. tds(_, _) -> next.
    463. 

  463. 

  464. tds_event(#mousebutton{button=1,state=?SDL_RELEASED}=Mb, Camera, Redraw, View) ->
    465. 

  465.     tds_event(Mb#mousebutton{button=2}, Camera, Redraw, View);
    466. 

  466. tds_event(#mousebutton{button=2,state=?SDL_RELEASED}, Camera, _, _) ->
    467. 

  467.     stop_camera(Camera);
    468. 

  468. tds_event(#mousebutton{button=3,state=?SDL_RELEASED}, Camera, _, View) ->
    469. 

  469.     wings_view:set_current(View),
    470. 

  470.     stop_camera(Camera);
    471. 

  471. tds_event(#mousemotion{x=X,y=Y,mod=Mod}, Camera0, Redraw, View) ->
    472. 

  472.     {Dx,Dy,Camera} = camera_mouse_range(X, Y, Camera0),
    473. 

  473.     if
    474. 

  474. 	Mod band ?CTRL_BITS =/= 0, Mod band ?ALT_BITS =/= 0 ->
    475. 

  475. 	    zoom(Dy);
    476. 

  476. 	Mod band ?ALT_BITS =/= 0 ->
    477. 

  477. 	    rotate(Dx, Dy);
    478. 

  478. 	true ->
    479. 

  479. 	    pan(Dx, Dy)
    480. 

  480.     end,
    481. 

  481.     get_tds_event(Camera, Redraw, View);
    482. 

  482. tds_event(Event, Camera, Redraw, _) ->
    483. 

  483.     generic_event(Event, Camera, Redraw).
    484. 

  484. 

  485. get_tds_event(Camera, Redraw, View) ->
    486. 

  486.     wings_wm:dirty(),
    487. 

  487.     {replace,fun(Ev) -> tds_event(Ev, Camera, Redraw, View) end}.
    488. 

  488. 

  489. tds_help() ->
    490. 

  490.     TrackDolly = [{0,2,?STR(mode_help,1,"Track")},
    491. 

  491. 		  {?CTRL_BITS bor ?ALT_BITS,2,?STR(mode_help,2,"Dolly")}],
    492. 

  492.     case allow_rotation() of
    493. 

  493. 	false -> format(TrackDolly);
    494. 

  494. 	true -> format([{?ALT_BITS,2,?STR(mode_help,3,"Tumble")}|TrackDolly])
    495. 

  495.     end.
    496. 

  496. 

  497. %%%
    498. 

  498. %%% Maya style camera.
    499. 

  499. %%%
    500. 

  500. 

  501. maya(#mousebutton{x=X0,y=Y0,mod=Mod,state=?SDL_PRESSED}, Redraw)
    502. 

  502.   when Mod band ?ALT_BITS =/= 0, Mod band ?CTRL_BITS =:= 0, Mod band ?SHIFT_BITS =:= 0 ->
    503. 

  503.     {X,Y} = wings_wm:local2global(X0, Y0),
    504. 

  504.     wings_io:change_event_handler(?SDL_KEYUP, ?SDL_ENABLE),
    505. 

  505.     Camera = #camera{x=X,y=Y,ox=X,oy=Y},
    506. 

  506.     grab(),
    507. 

  507.     message(maya_help()),
    508. 

  508.     {seq,push,get_maya_event(Camera, Redraw)};
    509. 

  509. maya(#keyboard{sym=Sym}, _Redraw) ->
    510. 

  510.     arrow_key_pan(Sym);
    511. 

  511. maya(_, _) -> next.
    512. 

  512. 

  513. maya_event(#keyboard{sym=Alt,state=?SDL_RELEASED},
    514. 

  514. 	   Camera, _Redraw) when Alt =:= ?SDLK_LALT; Alt =:= ?SDLK_RALT ->
    515. 

  515.     maya_stop_camera(Camera);
    516. 

  516. maya_event(#mousebutton{button=B,state=?SDL_RELEASED}, Camera, _)
    517. 

  517.   when B < 4 ->
    518. 

  518.     case wings_io:get_mouse_state() of
    519. 

  519. 	{0,_,_} ->
    520. 

  520. 	    %% Exit camera mode if all mouse buttons released.
    521. 

  521. 	    maya_stop_camera(Camera);
    522. 

  522. 	_ ->
    523. 

  523. 	    %% Some mouse button still pressed.
    524. 

  524. 	    keep
    525. 

  525.     end;
    526. 

  526. maya_event(#mousemotion{x=X,y=Y,state=Buttons}, Camera0, Redraw) ->
    527. 

  527.     {Dx,Dy,Camera} = camera_mouse_range(X, Y, Camera0),
    528. 

  528.     if
    529. 

  529. 	Buttons band 4 =:= 4 ->			%RMB
    530. 

  530. 	    zoom(-Dx);
    531. 

  531. 	Buttons band 3 =:= 3 ->			%LMB+MMB
    532. 

  532. 	    zoom(-Dx);
    533. 

  533. 	Buttons band 1 =:= 1 ->			%LMB
    534. 

  534. 	    rotate(Dx, Dy);
    535. 

  535. 	Buttons band 2 =:= 2 ->			%MMB
    536. 

  536. 	    pan(Dx, Dy);
    537. 

  537. 	true -> ok
    538. 

  538.     end,
    539. 

  539.     get_maya_event(Camera, Redraw);
    540. 

  540. maya_event(Event, Camera, Redraw) ->
    541. 

  541.     generic_event(Event, Camera, Redraw).
    542. 

  542. 

  543. get_maya_event(Camera, Redraw) ->
    544. 

  544.     wings_wm:dirty(),
    545. 

  545.     {replace,fun(Ev) -> maya_event(Ev, Camera, Redraw) end}.
    546. 

  546. 

  547. maya_stop_camera(Camera) ->
    548. 

  548.     wings_io:change_event_handler(?SDL_KEYUP, ?SDL_IGNORE),
    549. 

  549.     stop_camera(Camera).
    550. 

  550. 

  551. maya_help() ->
    552. 

  552.     TrackDolly = [{?ALT_BITS,2,?STR(mode_help,1,"Track")},
    553. 

  553. 		  {?ALT_BITS,3,?STR(mode_help,2,"Dolly")}],
    554. 

  554.     case allow_rotation() of
    555. 

  555. 	false -> format(TrackDolly);
    556. 

  556. 	true -> format([{?ALT_BITS,1,?STR(mode_help,3,"Tumble")}|TrackDolly])
    557. 

  557.     end.
    558. 

  558. 

  559. %%%
    560. 

  560. %%% Motionbuilder style camera.
    561. 

  561. %%%
    562. 

  562. 

  563. mb(#mousebutton{button=1,mod=Mod,x=X0,y=Y0,state=?SDL_PRESSED}, Redraw)
    564. 

  564.   when Mod band (?SHIFT_BITS bor ?CTRL_BITS) =/= 0 ->
    565. 

  565.     {X,Y} = wings_wm:local2global(X0, Y0),
    566. 

  566.     Camera = #camera{x=X,y=Y,ox=X,oy=Y},
    567. 

  567.     grab(),
    568. 

  568.     message(mb_help()),
    569. 

  569.     {seq,push,get_mb_event(Camera, Redraw)};
    570. 

  570. mb(#keyboard{sym=Sym}, _Redraw) ->
    571. 

  571.     arrow_key_pan(Sym);
    572. 

  572. mb(_, _) -> next.
    573. 

  573. 

  574. mb_event(#mousebutton{button=1,state=?SDL_RELEASED}, Camera, _) ->
    575. 

  575.     stop_camera(Camera);
    576. 

  576. mb_event(#mousemotion{x=X,y=Y,mod=Mod}, Camera0, Redraw) ->
    577. 

  577.     {Dx,Dy,Camera} = camera_mouse_range(X, Y, Camera0),
    578. 

  578.     if
    579. 

  579. 	Mod band ?CTRL_BITS =/= 0, Mod band ?SHIFT_BITS =/= 0 ->
    580. 

  580. 	    rotate(Dx, Dy),
    581. 

  581. 	    get_mb_event(Camera, Redraw);
    582. 

  582. 	Mod band ?CTRL_BITS =/= 0 ->
    583. 

  583. 	    zoom(Dy),
    584. 

  584. 	    get_mb_event(Camera, Redraw);
    585. 

  585. 	Mod band ?SHIFT_BITS =/= 0 ->
    586. 

  586. 	    pan(Dx, Dy),
    587. 

  587. 	    get_mb_event(Camera, Redraw);
    588. 

  588. 	true ->
    589. 

  589. 	    stop_camera(Camera)
    590. 

  590.     end;
    591. 

  591. mb_event(Event, Camera, Redraw) ->
    592. 

  592.     generic_event(Event, Camera, Redraw).
    593. 

  593. 

  594. get_mb_event(Camera, Redraw) ->
    595. 

  595.     wings_wm:dirty(),
    596. 

  596.     {replace,fun(Ev) -> mb_event(Ev, Camera, Redraw) end}.
    597. 

  597. 

  598. mb_help() ->
    599. 

  599.     TrackDolly = [{?SHIFT_BITS,1,?STR(mode_help,1,"Track")},
    600. 

  600. 		  {?CTRL_BITS,1,?STR(mode_help,2,"Dolly")}],
    601. 

  601.     case allow_rotation() of
    602. 

  602. 	false -> format(TrackDolly);
    603. 

  603. 	true -> format([{?SHIFT_BITS bor ?CTRL_BITS,1,?STR(mode_help,3,"Tumble")}|TrackDolly])
    604. 

  604.     end.
    605. 

  605.     
    606. 

  606. %%%
    607. 

  607. %%% Sketchup style camera.
    608. 

  608. %%%
    609. 

  609. 

  610. sketchup(#mousebutton{button=2,state=?SDL_PRESSED,x=X0,y=Y0,mod=Mod}, Redraw)
    611. 

  611.   when (Mod band (?ALT_BITS  bor ?CTRL_BITS)) =:= 0  ->
    612. 

  612.     {X,Y} = wings_wm:local2global(X0, Y0),
    613. 

  613.     Camera = #camera{x=X,y=Y,ox=X,oy=Y},
    614. 

  614.     grab(),
    615. 

  615.     message(sketchup_help()),
    616. 

  616.     {seq,push,get_sketchup_event(Camera, Redraw)};
    617. 

  617. sketchup(#keyboard{sym=Sym}, _Redraw) ->
    618. 

  618.     arrow_key_pan(Sym);
    619. 

  619. sketchup(_, _) -> next.
    620. 

  620. 

  621. sketchup_event(#mousebutton{button=2,state=?SDL_RELEASED}, Camera, _Redraw) ->
    622. 

  622.     stop_camera(Camera);
    623. 

  623. sketchup_event(#mousemotion{x=X,y=Y,mod=Mod}, Camera0, Redraw) ->
    624. 

  624.     {Dx,Dy,Camera} = camera_mouse_range(X, Y, Camera0),
    625. 

  625.     case Mod of
    626. 

  626.       Mod when Mod band ?SHIFT_BITS =/= 0 ->
    627. 

  627.           pan(Dx, Dy);
    628. 

  628.       _Other ->
    629. 

  629.           rotate(Dx, Dy)
    630. 

  630.     end,
    631. 

  631.     wings_wm:dirty(),
    632. 

  632.     get_sketchup_event(Camera, Redraw);
    633. 

  633. sketchup_event(Other, Camera, Redraw) ->
    634. 

  634.     generic_event(Other, Camera, Redraw).
    635. 

  635. 

  636. get_sketchup_event(Camera, Redraw) ->
    637. 

  637.     {replace,fun(Ev) -> sketchup_event(Ev, Camera, Redraw) end}.
    638. 

  638. 

  639. sketchup_help() ->
    640. 

  640.     TrackDolly = [{?SHIFT_BITS,2,?STR(mode_help,1,"Track")},
    641. 

  641.         {0,?CSEP,?STR(mode_help,4,"Scroll: Dolly")}],
    642. 

  642.     case allow_rotation() of
    643. 

  643.       false -> format(TrackDolly);
    644. 

  644.       true -> format([{0,2,?STR(mode_help,3,"Tumble")}|TrackDolly])
    645. 

  645.     end.
    646. 

  646. 

  647. %%%
    648. 

  648. %%% Wings 3D camera suggested by oort
    649. 

  649. %%%
    650. 

  650. 

  651. wings_cam(#mousebutton{button=2,x=X0,y=Y0,mod=Mod,state=?SDL_RELEASED}, Redraw)
    652. 

  652.   when Mod band (?CTRL_BITS bor ?SHIFT_BITS bor ?ALT_BITS) =:= 0 ->
    653. 

  653.     {X,Y} = wings_wm:local2global(X0, Y0),
    654. 

  654.     Camera = #camera{x=X,y=Y,ox=X,oy=Y},
    655. 

  655.     grab(),
    656. 

  656.     wings_cam_message(),
    657. 

  657.     View = wings_view:current(),
    658. 

  658.     {seq,push,get_wings_cam_event(Camera, Redraw, View)};
    659. 

  659. wings_cam(#keyboard{sym=Sym}, _Redraw) ->
    660. 

  660.     arrow_key_pan(Sym);
    661. 

  661. wings_cam(_, _) -> next.
    662. 

  662. 

  663. wings_cam_event(#mousebutton{button=1,state=?SDL_RELEASED}, Camera, _, _) ->
    664. 

  664.     stop_camera(Camera);
    665. 

  665. wings_cam_event(#mousebutton{button=3,state=?SDL_RELEASED}, Camera, _, View) ->
    666. 

  666.     wings_view:set_current(View),
    667. 

  667.     stop_camera(Camera);
    668. 

  668. wings_cam_event(#mousemotion{x=X,y=Y,state=Buttons}, Camera0, Redraw, View) ->
    669. 

  669.     {Dx,Dy,Camera} = camera_mouse_range(X, Y, Camera0),
    670. 

  670.     case Buttons band 2 of
    671. 

  671.       0 ->					%MMB not pressed.
    672. 

  672.           rotate(-Dx, -Dy);
    673. 

  673.       _Other ->				%MMB pressed.
    674. 

  674.           pan(-Dx, -Dy)
    675. 

  675.     end,
    676. 

  676.     get_wings_cam_event(Camera, Redraw, View);
    677. 

  677. wings_cam_event(#keyboard{sym=Sym}=Event, Camera, Redraw, _) ->
    678. 

  678.     case arrow_key_pan(Sym) of
    679. 

  679.       keep -> keep;
    680. 

  680.       next -> view_hotkey(Event, Camera, Redraw)
    681. 

  681.     end;
    682. 

  682. wings_cam_event(Event, Camera, Redraw, _) ->
    683. 

  683.     generic_event(Event, Camera, Redraw).
    684. 

  684. 

  685. get_wings_cam_event(Camera, Redraw, View) ->
    686. 

  686.     wings_wm:dirty(),
    687. 

  687.     {replace,fun(Ev) -> wings_cam_event(Ev, Camera, Redraw, View) end}.
    688. 

  688. 

  689. wings_cam_message() ->
    690. 

  690.     Help = wings_msg:join([wings_msg:button_format(wings_s:accept(),
    691. 

  691.                 ?STR(message,8,"Drag to Pan"),
    692. 

  692.                 ?STR(message,6,"Cancel/restore view")),
    693. 

  693.                 ?STR(message,3,"Move mouse to tumble")]),
    694. 

  694.     message(Help).
    695. 

  695. 

  696. %%%
    697. 

  697. %%% Common utilities.
    698. 

  698. %%%
    699. 

  699. 

  700. generic_event(redraw, _Camera, #state{st=St, func=none}) ->
    701. 

  701.     wings:redraw(St),
    702. 

  702.     keep;
    703. 

  703. generic_event(redraw, _Camera, #state{func=Redraw}) when is_function(Redraw) ->
    704. 

  704.     Redraw(),
    705. 

  705.     keep;
    706. 

  706. 

  707. generic_event(#mousebutton{button=4,mod=Mod,state=?SDL_RELEASED}, _Camera, _Redraw)
    708. 

  708.   when Mod band ?SHIFT_BITS =/= 0 andalso Mod band ?ALT_BITS =/= 0 ->
    709. 

  709.     whrotate(0.5,0.0);
    710. 

  710. generic_event(#mousebutton{button=5,mod=Mod,state=?SDL_RELEASED}, _Camera, _Redraw)
    711. 

  711.   when Mod band ?SHIFT_BITS =/= 0 andalso Mod band ?ALT_BITS =/= 0 ->
    712. 

  712.     whrotate(-0.5,0.0);
    713. 

  713. generic_event(#mousebutton{button=4,mod=Mod,state=?SDL_RELEASED}, _Camera, _Redraw)
    714. 

  714.   when Mod band ?SHIFT_BITS =/= 0 ->
    715. 

  715.     whrotate(0.0,0.5);
    716. 

  716. generic_event(#mousebutton{button=5,mod=Mod,state=?SDL_RELEASED}, _Camera, _Redraw)
    717. 

  717.   when Mod band ?SHIFT_BITS =/= 0 ->
    718. 

  718.     whrotate(0.0,-0.5);
    719. 

  719. 

  720. generic_event(#mousebutton{button=4,mod=Mod,state=?SDL_RELEASED}, _Camera, _Redraw)
    721. 

  721.   when Mod band ?CTRL_BITS =/= 0 andalso Mod band ?ALT_BITS =/= 0 ->
    722. 

  722.     whpan(0.05,0.0);
    723. 

  723. generic_event(#mousebutton{button=5,mod=Mod,state=?SDL_RELEASED}, _Camera, _Redraw)
    724. 

  724.   when Mod band ?CTRL_BITS =/= 0 andalso Mod band ?ALT_BITS =/= 0 ->
    725. 

  725.     whpan(-0.05,0.0);
    726. 

  726. generic_event(#mousebutton{button=4,mod=Mod,state=?SDL_RELEASED}, _Camera, _Redraw)
    727. 

  727.   when Mod band ?CTRL_BITS =/= 0 ->
    728. 

  728.     whpan(0.0,0.05);
    729. 

  729. generic_event(#mousebutton{button=5,mod=Mod,state=?SDL_RELEASED}, _Camera, _Redraw)
    730. 

  730.   when Mod band ?CTRL_BITS =/= 0 ->
    731. 

  731.     whpan(0.0,-0.05);
    732. 

  732. 

  733. generic_event(#mousebutton{button=4,mod=Mod,state=?SDL_RELEASED}, _Camera, _Redraw)
    734. 

  734.   when Mod band ?ALT_BITS =/= 0 ->
    735. 

  735.     zoom_step_alt(-1);
    736. 

  736. generic_event(#mousebutton{button=4,state=?SDL_RELEASED}, #st{}=St, none) ->
    737. 

  737. %% Matching 'none' stops zoom aim from being activated during a drag sequence.
    738. 

  738. %% Zoom aim warps the mouse to the screen's centre, and this can cause a crash
    739. 

  739. %% in since drag events also depend on cursor position.
    740. 

  740.     aim_zoom(-1, St);
    741. 

  741. generic_event(#mousebutton{button=4,state=?SDL_RELEASED}, _Camera, _Redraw) ->
    742. 

  742.     zoom_step(-1);
    743. 

  743. generic_event(#mousebutton{button=5,mod=Mod,state=?SDL_RELEASED}, _Camera, _Redraw)
    744. 

  744.   when Mod band ?ALT_BITS =/= 0 ->
    745. 

  745.     zoom_step_alt(1);
    746. 

  746. generic_event(#mousebutton{button=5,state=?SDL_RELEASED}, _, none) ->
    747. 

  747. %% Matching 'none' stops zoom aim from being activated during a drag sequence
    748. 

  748.     zoom_step(1);
    749. 

  749. generic_event(#mousebutton{button=5,state=?SDL_RELEASED}, _Camera, _Redraw) ->
    750. 

  750.     zoom_step(1);
    751. 

  751. 

  752. generic_event(_, _, _) -> keep.
    753. 

  753. 

  754. aim_zoom(Dir, St0) ->
    755. 

  755.     case wings_pref:get_value(highlight_zoom_aim) of
    756. 

  756.       true ->
    757. 

  757.         #view{origin=OriginB}=Before = wings_view:current(),
    758. 

  758.         {{_,Cmd},_} = wings:highlight_aim_setup(St0),
    759. 

  759.         wings_view:command(Cmd,St0),
    760. 

  760.         #view{origin=OriginA} = wings_view:current(),
    761. 

  761.         O = e3d_vec:zero(),
    762. 

  762.         if OriginA =:= O, Cmd =:= aim ->
    763. 

  763.               wings_view:set_current(Before),
    764. 

  764.               zoom_step(Dir);
    765. 

  765.             OriginA =:= OriginB ->
    766. 

  766.               zoom_step(Dir);
    767. 

  767.             true ->
    768. 

  768.               Client = wings_wm:this(),
    769. 

  769.               {X0,Y0} = wings_wm:win_size(Client),
    770. 

  770.               {X,Y} = wings_wm:local2global(X0 div 2, Y0 div 2),
    771. 

  771.               wings_io:warp(X,Y),
    772. 

  772.               zoom_step(Dir)
    773. 

  773.         end;
    774. 

  774.       false ->
    775. 

  775.         zoom_step(Dir)
    776. 

  776.     end.
    777. 

  777. 

  778. 

  779. rotate(Dx, Dy) ->
    780. 

  780.     Speed = wings_pref:get_value(cam_rotation_speed,25)/25,
    781. 

  781.     case allow_rotation() of
    782. 

  782. 	false -> ok;
    783. 

  783. 	true ->
    784. 

  784. 	    View0= wings_view:current(),
    785. 

  785. 	    #view{azimuth=Az0,elevation=El0} = View0,
    786. 

  786. 	    Az = Az0 + Dx * Speed,
    787. 

  787. 	    El = El0 + Dy * Speed,
    788. 

  788. 	    View = View0#view{azimuth=Az,elevation=El,along_axis=none},
    789. 

  789. 	    wings_view:set_current(View)
    790. 

  790.     end.
    791. 

  791. 

  792. whrotate(Dx, Dy) ->
    793. 

  793.     case wings_pref:get_value(wheel_zooms, true) of
    794. 

  794.       false -> keep;
    795. 

  795.       true ->
    796. 

  796.         case wings_pref:get_value(wheel_adds, true) of
    797. 

  797.           false -> keep;
    798. 

  798.           true ->
    799. 

  799.              wings_wm:dirty(),
    800. 

  800.              View0= wings_view:current(),
    801. 

  801.              #view{azimuth=Az0,elevation=El0} = View0,
    802. 

  802.              S = 2 * wings_pref:get_value(wh_rot_spd),
    803. 

  803.              Az = Az0 + Dx*S,
    804. 

  804.              El = El0 + Dy*S,
    805. 

  805.              View = View0#view{azimuth=Az,elevation=El,along_axis=none},
    806. 

  806.              wings_view:set_current(View),
    807. 

  807.              keep
    808. 

  808.         end
    809. 

  809.     end.
    810. 

  810. 

  811. zoom_step_alt(Dir) ->
    812. 

  812.     case wings_pref:get_value(wheel_zooms, true) of
    813. 

  813. 	false -> keep;
    814. 

  814. 	true ->
    815. 

  815. 	    ZoomFactor = wings_pref:get_value(wheel_zoom_factor_alt, ?ZOOM_FACTOR_ALT),
    816. 

  816. 		wheel_zoom(ZoomFactor,Dir)
    817. 

  817.     end.
    818. 

  818. 

  819. zoom_step(Dir) ->
    820. 

  820.     case wings_pref:get_value(wheel_zooms, true) of
    821. 

  821. 	false -> keep;
    822. 

  822. 	true ->
    823. 

  823. 	    ZoomFactor = wings_pref:get_value(wheel_zoom_factor, ?ZOOM_FACTOR),
    824. 

  824. 		wheel_zoom(ZoomFactor,Dir)
    825. 

  825.     end.
    826. 

  826. 

  827. wheel_zoom(Factor, Dir) ->
    828. 

  828.     wings_wm:dirty(),
    829. 

  829.     #view{distance=Dist} = View = wings_view:current(),
    830. 

  830.     ZoomPercent = Factor/100,
    831. 

  831.     Delta = dist_factor(Dist)*Dir*ZoomPercent,
    832. 

  832.     wings_view:set_current(View#view{distance=Dist+Delta}),
    833. 

  833.     keep.
    834. 

  834. 

  835. zoom(Delta0) ->
    836. 

  836.     #view{distance=Dist} = View = wings_view:current(),
    837. 

  837.     Delta = dist_factor(Dist)*Delta0/80,
    838. 

  838.     wings_view:set_current(View#view{distance=Dist+Delta}).
    839. 

  839. 

  840. pan(Dx0, Dy0) ->
    841. 

  841.     #view{pan_x=PanX0,pan_y=PanY0,distance=D} = View = wings_view:current(),
    842. 

  842.     S = D*(1/20)/(101-wings_pref:get_value(pan_speed)),
    843. 

  843.     Dx = Dx0*S,
    844. 

  844.     Dy = Dy0*S,
    845. 

  845.     PanX = PanX0 + Dx,
    846. 

  846.     PanY = PanY0 - Dy,
    847. 

  847.     wings_view:set_current(View#view{pan_x=PanX,pan_y=PanY}).
    848. 

  848. 

  849. arrow_key_pan(?SDLK_LEFT) -> arrow_key_pan(0.05, 0.0);
    850. 

  850. arrow_key_pan(?SDLK_RIGHT) -> arrow_key_pan(-0.05, 0.0);
    851. 

  851. arrow_key_pan(?SDLK_UP) -> arrow_key_pan(0.0, 0.05);
    852. 

  852. arrow_key_pan(?SDLK_DOWN) -> arrow_key_pan(0.0, -0.05);
    853. 

  853. arrow_key_pan(_) -> next.
    854. 

  854. 

  855. arrow_key_pan(Dx, Dy) ->
    856. 

  856.     key_pan(Dx, Dy),
    857. 

  857.     wings_wm:dirty(),
    858. 

  858.     keep.
    859. 

  859. 

  860. key_pan(Dx0, Dy0) ->
    861. 

  861.     #view{pan_x=PanX0,pan_y=PanY0,distance=D} = View = wings_view:current(),
    862. 

  862.     S = D * (wings_pref:get_value(pan_speed_arrow_keys)/100),
    863. 

  863.     Dx = Dx0*S,
    864. 

  864.     Dy = Dy0*S,
    865. 

  865.     PanX = PanX0 + Dx,
    866. 

  866.     PanY = PanY0 - Dy,
    867. 

  867.     wings_view:set_current(View#view{pan_x=PanX,pan_y=PanY}).
    868. 

  868. 

  869. whpan(Dx0, Dy0) ->
    870. 

  870.     case wings_pref:get_value(wheel_zooms, true) of
    871. 

  871.   false -> keep;
    872. 

  872.   true ->
    873. 

  873.       case wings_pref:get_value(wheel_adds, true) of
    874. 

  874.     false -> keep;
    875. 

  875.     true ->
    876. 

  876.         wings_wm:dirty(),
    877. 

  877.         #view{pan_x=PanX0,pan_y=PanY0,distance=D} = View = wings_view:current(),
    878. 

  878.         S = D * (wings_pref:get_value(wh_pan_spd)/100),
    879. 

  879.         Dx = Dx0*S,
    880. 

  880.         Dy = Dy0*S,
    881. 

  881.         PanX = PanX0 + Dx,
    882. 

  882.         PanY = PanY0 - Dy,
    883. 

  883.         wings_view:set_current(View#view{pan_x=PanX,pan_y=PanY}),
    884. 

  884.         keep
    885. 

  885.        end
    886. 

  886.     end.
    887. 

  887. dist_factor(Dist) ->
    888. 

  888.     max(abs(Dist), 0.2).
    889. 

  889. 

  890. stop_camera(#camera{ox=Ox,oy=Oy}) ->
    891. 

  891.     case wings_io:ungrab(Ox, Oy) of
    892. 

  892. 	still_grabbed ->
    893. 

  893. 	    wings_wm:later(view_changed);
    894. 

  894. 	no_grab ->
    895. 

  895. 	    wings_wm:release_focus(),
    896. 

  896. 	    wings_wm:dirty()
    897. 

  897.     end,
    898. 

  898.     update_sel(fun show_sel_fun/2),
    899. 

  899.     pop.
    900. 

  900. 

  901. camera_mouse_range(X0, Y0, #camera{x=OX,y=OY, xt=Xt0, yt=Yt0}=Camera) ->
    902. 

  902. %%    io:format("Camera Mouse Range ~p ~p~n", [{X0,Y0}, {OX,OY,Xt0,Yt0}]),
    903. 

  903.     {X1,Y1} = wings_wm:local2global(X0, Y0),
    904. 

  904.     XD0 = (X1 - OX),
    905. 

  905.     YD0 = (Y1 - OY),
    906. 

  906.     {XD,YD} = wings_pref:lowpass(XD0 + Xt0, YD0 + Yt0),
    907. 

  907. 

  908.     if
    909. 

  909. 	XD0 =:= 0, YD0 =:= 0 ->
    910. 

  910. 	    {0.0,0.0,Camera#camera{xt=0,yt=0}};
    911. 

  911. 	true ->
    912. 

  912. 	    wings_io:warp(OX, OY),
    913. 

  913. 	    {XD/?CAMDIV, YD/?CAMDIV, Camera#camera{xt=XD0, yt=YD0}}
    914. 

  914.     end.
    915. 

  915. 

  916. view_hotkey(Ev, Camera, #state{st=St}) ->
    917. 

  917.     case wings_hotkey:event(Ev,St) of
    918. 

  918. 	next -> keep;
    919. 

  919. 	{view,smooth_proxy} -> keep;
    920. 

  920. 	{view,quick_preview} -> keep;
    921. 

  921. 	{view,Cmd} -> 
    922. 

  922. 	    wings_view:command(Cmd, St),
    923. 

  923. 	    keep;	
    924. 

  924. 	_Other -> %% Hotkey pressed, Quit camera mode
    925. 

  925. 	    wings_wm:later(Ev),
    926. 

  926. 	    stop_camera(Camera)
    927. 

  927.     end.
    928. 

  928. 

  929. message(Message) ->
    930. 

  930.     wings_wm:message(Message),
    931. 

  931.     wings_wm:message_right([]).
    932. 

  932.     
    933. 

  933. grab() ->
    934. 

  934.     wings_io:grab(),
    935. 

  935.     wings_wm:grab_focus(),
    936. 

  936.     update_sel(fun hide_sel_fun/2).
    937. 

  937. 

  938. hide_sel_fun(#dlo{sel=Sel}=D, _) ->
    939. 

  939.     D#dlo{sel={call,none,Sel}}.
    940. 

  940. 

  941. show_sel_fun(#dlo{sel={call,none,Sel}}=D, _) ->
    942. 

  942.     D#dlo{sel=Sel};
    943. 

  943. show_sel_fun(D, _) -> D.
    944. 

  944. 

  945. allow_rotation() ->
    946. 

  946.     wings_wm:get_prop(allow_rotation).
    947. 

  947. 

  948. update_sel(Fun) ->
    949. 

  949.     case wings_pref:get_value(hide_sel_in_camera_moves) of
    950. 

  950. 	false -> ok;
    951. 

  951. 	true -> wings_dl:map(Fun, [])
    952. 

  952.     end.
    953. 

  953. 

  954. format([{Mod,But,Msg}|T]) ->
    955. 

  955.     wings_msg:join(wings_msg:mod_format(Mod, But, Msg), format(T));
    956. 

  956. format([]) -> [].
    957.