llui.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:16k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llui.h
  3.  * @brief GL function declarations and other general static UI services.
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. // All immediate-mode gl drawing should happen here.
  33. #ifndef LL_LLUI_H
  34. #define LL_LLUI_H
  35. #include "llpointer.h" // LLPointer<>
  36. #include "llrect.h"
  37. #include "llcontrol.h"
  38. #include "llcoord.h"
  39. #include "lluiimage.h" // *TODO: break this dependency, need to add #include "lluiimage.h" to all widgets that hold an Optional<LLUIImage*> in their paramblocks
  40. #include "llinitparam.h"
  41. #include "llregistry.h"
  42. #include "lluicolor.h"
  43. #include "lluicolortable.h"
  44. #include <boost/signals2.hpp>
  45. #include "lllazyvalue.h"
  46. #include "llhandle.h" // *TODO: remove this dependency, added as a 
  47. // convenience when LLHandle moved to llhandle.h
  48. #include "llframetimer.h"
  49. // LLUIFactory
  50. #include "llsd.h"
  51. // for initparam specialization
  52. #include "llfontgl.h"
  53. class LLColor4; 
  54. class LLVector3;
  55. class LLVector2;
  56. class LLUIImage;
  57. class LLUUID;
  58. class LLWindow;
  59. class LLView;
  60. class LLHelp;
  61. // UI colors
  62. extern const LLColor4 UI_VERTEX_COLOR;
  63. void make_ui_sound(const char* name);
  64. BOOL ui_point_in_rect(S32 x, S32 y, S32 left, S32 top, S32 right, S32 bottom);
  65. void gl_state_for_2d(S32 width, S32 height);
  66. void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2);
  67. void gl_line_2d(S32 x1, S32 y1, S32 x2, S32 y2, const LLColor4 &color );
  68. void gl_triangle_2d(S32 x1, S32 y1, S32 x2, S32 y2, S32 x3, S32 y3, const LLColor4& color, BOOL filled);
  69. void gl_rect_2d_simple( S32 width, S32 height );
  70. void gl_draw_x(const LLRect& rect, const LLColor4& color);
  71. void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, BOOL filled = TRUE );
  72. void gl_rect_2d(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, BOOL filled = TRUE );
  73. void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &color, S32 pixel_offset = 0, BOOL filled = TRUE );
  74. void gl_rect_2d_offset_local( S32 left, S32 top, S32 right, S32 bottom, S32 pixel_offset = 0, BOOL filled = TRUE );
  75. void gl_rect_2d(const LLRect& rect, BOOL filled = TRUE );
  76. void gl_rect_2d(const LLRect& rect, const LLColor4& color, BOOL filled = TRUE );
  77. void gl_rect_2d_checkerboard(const LLRect& rect);
  78. void gl_drop_shadow(S32 left, S32 top, S32 right, S32 bottom, const LLColor4 &start_color, S32 lines);
  79. void gl_circle_2d(F32 x, F32 y, F32 radius, S32 steps, BOOL filled);
  80. void gl_arc_2d(F32 center_x, F32 center_y, F32 radius, S32 steps, BOOL filled, F32 start_angle, F32 end_angle);
  81. void gl_deep_circle( F32 radius, F32 depth );
  82. void gl_ring( F32 radius, F32 width, const LLColor4& center_color, const LLColor4& side_color, S32 steps, BOOL render_center );
  83. void gl_corners_2d(S32 left, S32 top, S32 right, S32 bottom, S32 length, F32 max_frac);
  84. void gl_washer_2d(F32 outer_radius, F32 inner_radius, S32 steps, const LLColor4& inner_color, const LLColor4& outer_color);
  85. void gl_washer_segment_2d(F32 outer_radius, F32 inner_radius, F32 start_radians, F32 end_radians, S32 steps, const LLColor4& inner_color, const LLColor4& outer_color);
  86. void gl_washer_spokes_2d(F32 outer_radius, F32 inner_radius, S32 count, const LLColor4& inner_color, const LLColor4& outer_color);
  87. void gl_draw_image(S32 x, S32 y, LLTexture* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
  88. void gl_draw_scaled_image(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
  89. void gl_draw_rotated_image(S32 x, S32 y, F32 degrees, LLTexture* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
  90. void gl_draw_scaled_rotated_image(S32 x, S32 y, S32 width, S32 height, F32 degrees,LLTexture* image, const LLColor4& color = UI_VERTEX_COLOR, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
  91. void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 border_width, S32 border_height, S32 width, S32 height, LLTexture* image, const LLColor4 &color, BOOL solid_color = FALSE, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
  92. void gl_draw_scaled_image_with_border(S32 x, S32 y, S32 width, S32 height, LLTexture* image, const LLColor4 &color, BOOL solid_color = FALSE, const LLRectf& uv_rect = LLRectf(0.f, 1.f, 1.f, 0.f), const LLRectf& scale_rect = LLRectf(0.f, 1.f, 1.f, 0.f));
  93. void gl_rect_2d_xor(S32 left, S32 top, S32 right, S32 bottom);
  94. void gl_stippled_line_3d( const LLVector3& start, const LLVector3& end, const LLColor4& color, F32 phase = 0.f ); 
  95. void gl_rect_2d_simple_tex( S32 width, S32 height );
  96. // segmented rectangles
  97. /*
  98.    TL |______TOP_________| TR 
  99.      /|                  |  
  100.    _/_|__________________|__
  101.    L| |    MIDDLE        | |R
  102.    _|_|__________________|_|_
  103.      |    BOTTOM        | /  
  104.    BL|__________________|/ BR
  105.       |                  |    
  106. */
  107. typedef enum e_rounded_edge
  108. {
  109. ROUNDED_RECT_LEFT = 0x1, 
  110. ROUNDED_RECT_TOP = 0x2, 
  111. ROUNDED_RECT_RIGHT = 0x4, 
  112. ROUNDED_RECT_BOTTOM = 0x8,
  113. ROUNDED_RECT_ALL = 0xf
  114. }ERoundedEdge;
  115. void gl_segmented_rect_2d_tex(const S32 left, const S32 top, const S32 right, const S32 bottom, const S32 texture_width, const S32 texture_height, const S32 border_size, const U32 edges = ROUNDED_RECT_ALL);
  116. void gl_segmented_rect_2d_fragment_tex(const S32 left, const S32 top, const S32 right, const S32 bottom, const S32 texture_width, const S32 texture_height, const S32 border_size, const F32 start_fragment, const F32 end_fragment, const U32 edges = ROUNDED_RECT_ALL);
  117. void gl_segmented_rect_3d_tex(const LLVector2& border_scale, const LLVector3& border_width, const LLVector3& border_height, const LLVector3& width_vec, const LLVector3& height_vec, U32 edges = ROUNDED_RECT_ALL);
  118. void gl_segmented_rect_3d_tex_top(const LLVector2& border_scale, const LLVector3& border_width, const LLVector3& border_height, const LLVector3& width_vec, const LLVector3& height_vec);
  119. inline void gl_rect_2d( const LLRect& rect, BOOL filled )
  120. {
  121. gl_rect_2d( rect.mLeft, rect.mTop, rect.mRight, rect.mBottom, filled );
  122. }
  123. inline void gl_rect_2d_offset_local( const LLRect& rect, S32 pixel_offset, BOOL filled)
  124. {
  125. gl_rect_2d_offset_local( rect.mLeft, rect.mTop, rect.mRight, rect.mBottom, pixel_offset, filled );
  126. }
  127. class LLImageProviderInterface;
  128. typedef void (*LLUIAudioCallback)(const LLUUID& uuid);
  129. class LLUI
  130. {
  131. LOG_CLASS(LLUI);
  132. public:
  133. //
  134. // Methods
  135. //
  136. typedef std::map<std::string, LLControlGroup*> settings_map_t;
  137. static void initClass(const settings_map_t& settings,
  138.   LLImageProviderInterface* image_provider,
  139.   LLUIAudioCallback audio_callback = NULL,
  140.   const LLVector2 *scale_factor = NULL,
  141.   const std::string& language = LLStringUtil::null);
  142. static void cleanupClass();
  143. static void pushMatrix();
  144. static void popMatrix();
  145. static void loadIdentity();
  146. static void translate(F32 x, F32 y, F32 z = 0.0f);
  147. static LLRect sDirtyRect;
  148. static BOOL sDirty;
  149. static void dirtyRect(LLRect rect);
  150. // Return the ISO639 language name ("en", "ko", etc.) for the viewer UI.
  151. // http://www.loc.gov/standards/iso639-2/php/code_list.php
  152. static std::string getLanguage();
  153. static void setupPaths();
  154. static const std::vector<std::string>& getXUIPaths() { return sXUIPaths; }
  155. static std::string getSkinPath() { return sXUIPaths.front(); }
  156. static std::string getLocalizedSkinPath() { return sXUIPaths.back(); }  //all files may not exist at the localized path
  157. //helper functions (should probably move free standing rendering helper functions here)
  158. static LLView* getRootView() { return sRootView; }
  159. static void setRootView(LLView* view) { sRootView = view; }
  160. static std::string locateSkin(const std::string& filename);
  161. static void setMousePositionScreen(S32 x, S32 y);
  162. static void getMousePositionScreen(S32 *x, S32 *y);
  163. static void setMousePositionLocal(const LLView* viewp, S32 x, S32 y);
  164. static void getMousePositionLocal(const LLView* viewp, S32 *x, S32 *y);
  165. static void setScaleFactor(const LLVector2& scale_factor);
  166. static void setLineWidth(F32 width);
  167. static LLPointer<LLUIImage> getUIImageByID(const LLUUID& image_id, S32 priority = 0);
  168. static LLPointer<LLUIImage> getUIImage(const std::string& name, S32 priority = 0);
  169. static LLVector2 getWindowSize();
  170. static void screenPointToGL(S32 screen_x, S32 screen_y, S32 *gl_x, S32 *gl_y);
  171. static void glPointToScreen(S32 gl_x, S32 gl_y, S32 *screen_x, S32 *screen_y);
  172. static void screenRectToGL(const LLRect& screen, LLRect *gl);
  173. static void glRectToScreen(const LLRect& gl, LLRect *screen);
  174. // Returns the control group containing the control name, or the default group
  175. static LLControlGroup& getControlControlGroup (const std::string& controlname);
  176. static F32 getMouseIdleTime() { return sMouseIdleTimer.getElapsedTimeF32(); }
  177. static void resetMouseIdleTimer() { sMouseIdleTimer.reset(); }
  178. static LLWindow* getWindow() { return sWindow; }
  179. // Ensures view does not overlap mouse cursor, but is inside
  180. // the view's parent rectangle.  Used for tooltips, inspectors.
  181. // Optionally override the view's default X/Y, which are relative to the
  182. // view's parent.
  183. static void positionViewNearMouse(LLView* view, S32 spawn_x = S32_MAX, S32 spawn_y = S32_MAX);
  184. //
  185. // Data
  186. //
  187. static settings_map_t sSettingGroups;
  188. static LLUIAudioCallback sAudioCallback;
  189. static LLVector2 sGLScaleFactor;
  190. static LLWindow* sWindow;
  191. static LLView* sRootView;
  192. static LLHelp* sHelpImpl;
  193. private:
  194. static LLImageProviderInterface* sImageProvider;
  195. static std::vector<std::string> sXUIPaths;
  196. static LLFrameTimer sMouseIdleTimer;
  197. };
  198. // Moved LLLocalClipRect to lllocalcliprect.h
  199. // Moved all LLHandle-related code to llhandle.h
  200. //RN: maybe this needs to moved elsewhere?
  201. class LLImageProviderInterface
  202. {
  203. protected:
  204. LLImageProviderInterface() {};
  205. virtual ~LLImageProviderInterface() {};
  206. public:
  207. virtual LLPointer<LLUIImage> getUIImage(const std::string& name, S32 priority) = 0;
  208. virtual LLPointer<LLUIImage> getUIImageByID(const LLUUID& id, S32 priority) = 0;
  209. virtual void cleanUp() = 0;
  210. };
  211. class LLCallbackRegistry
  212. {
  213. public:
  214. typedef boost::signals2::signal<void()> callback_signal_t;
  215. void registerCallback(const callback_signal_t::slot_type& slot)
  216. {
  217. mCallbacks.connect(slot);
  218. }
  219. void fireCallbacks()
  220. {
  221. mCallbacks();
  222. }
  223. private:
  224. callback_signal_t mCallbacks;
  225. };
  226. class LLInitClassList : 
  227. public LLCallbackRegistry, 
  228. public LLSingleton<LLInitClassList>
  229. {
  230. friend class LLSingleton<LLInitClassList>;
  231. private:
  232. LLInitClassList() {}
  233. };
  234. class LLDestroyClassList : 
  235. public LLCallbackRegistry, 
  236. public LLSingleton<LLDestroyClassList>
  237. {
  238. friend class LLSingleton<LLDestroyClassList>;
  239. private:
  240. LLDestroyClassList() {}
  241. };
  242. template<typename T>
  243. class LLRegisterWith
  244. {
  245. public:
  246. LLRegisterWith(boost::function<void ()> func)
  247. {
  248. T::instance().registerCallback(func);
  249. }
  250. // this avoids a MSVC bug where non-referenced static members are "optimized" away
  251. // even if their constructors have side effects
  252. void reference()
  253. {
  254. S32 dummy;
  255. dummy = 0;
  256. }
  257. };
  258. template<typename T>
  259. class LLInitClass
  260. {
  261. public:
  262. LLInitClass() { sRegister.reference(); }
  263. static LLRegisterWith<LLInitClassList> sRegister;
  264. private:
  265. static void initClass()
  266. {
  267. llerrs << "No static initClass() method defined for " << typeid(T).name() << llendl;
  268. }
  269. };
  270. template<typename T>
  271. class LLDestroyClass
  272. {
  273. public:
  274. LLDestroyClass() { sRegister.reference(); }
  275. static LLRegisterWith<LLDestroyClassList> sRegister;
  276. private:
  277. static void destroyClass()
  278. {
  279. llerrs << "No static destroyClass() method defined for " << typeid(T).name() << llendl;
  280. }
  281. };
  282. template <typename T> LLRegisterWith<LLInitClassList> LLInitClass<T>::sRegister(&T::initClass);
  283. template <typename T> LLRegisterWith<LLDestroyClassList> LLDestroyClass<T>::sRegister(&T::destroyClass);
  284. // useful parameter blocks
  285. struct TimeIntervalParam : public LLInitParam::Choice<TimeIntervalParam>
  286. {
  287. Alternative<F32> seconds;
  288. Alternative<S32> frames;
  289. TimeIntervalParam()
  290. : seconds("seconds"),
  291. frames("frames")
  292. {}
  293. };
  294. template <class T>
  295. class LLUICachedControl : public LLCachedControl<T>
  296. {
  297. public:
  298. // This constructor will declare a control if it doesn't exist in the contol group
  299. LLUICachedControl(const std::string& name,
  300.   const T& default_value,
  301.   const std::string& comment = "Declared In Code")
  302. : LLCachedControl<T>(LLUI::getControlControlGroup(name), name, default_value, comment)
  303. {}
  304. // This constructor will signal an error if the control doesn't exist in the control group
  305. LLUICachedControl(const std::string& name)
  306. : LLCachedControl<T>(LLUI::getControlControlGroup(name), name)
  307. {}
  308. };
  309. namespace LLInitParam
  310. {
  311. template<>
  312. class TypedParam<LLRect> 
  313. : public BlockValue<LLRect>
  314. {
  315.         typedef BlockValue<LLRect> super_t;
  316. public:
  317. Optional<S32> left,
  318. top,
  319. right,
  320. bottom,
  321. width,
  322. height;
  323. TypedParam(BlockDescriptor& descriptor, const char* name, const LLRect& value, ParamDescriptor::validation_func_t func, S32 min_count, S32 max_count);
  324. void setValueFromBlock() const;
  325. void setBlockFromValue();
  326. };
  327. template<>
  328. struct TypeValues<LLUIColor> : public TypeValuesHelper<LLUIColor>
  329. {
  330. static void declareValues();
  331. };
  332. template<>
  333. class TypedParam<LLUIColor> 
  334. : public BlockValue<LLUIColor>
  335. {
  336.         typedef BlockValue<LLUIColor> super_t;
  337. public:
  338. Optional<F32> red,
  339. green,
  340. blue,
  341. alpha;
  342. Optional<std::string> control;
  343. TypedParam(BlockDescriptor& descriptor, const char* name, const LLUIColor& value, ParamDescriptor::validation_func_t func, S32 min_count, S32 max_count);
  344. void setValueFromBlock() const;
  345. void setBlockFromValue();
  346. };
  347. // provide a better default for Optional<const LLFontGL*> than NULL
  348. template <>
  349. struct DefaultInitializer<const LLFontGL*>
  350. {
  351. // return reference to a single default instance of T
  352. // built-in types will be initialized to zero, default constructor otherwise
  353. static const LLFontGL* get() 
  354. static const LLFontGL* sDefaultFont = LLFontGL::getFontDefault();  
  355. return sDefaultFont;
  356. };
  357. template<>
  358. class TypedParam<const LLFontGL*> 
  359. : public BlockValue<const LLFontGL*>
  360. {
  361.         typedef BlockValue<const LLFontGL*> super_t;
  362. public:
  363. Optional<std::string> name,
  364. size,
  365. style;
  366. TypedParam(BlockDescriptor& descriptor, const char* name, const LLFontGL* const value, ParamDescriptor::validation_func_t func, S32 min_count, S32 max_count);
  367. void setValueFromBlock() const;
  368. void setBlockFromValue();
  369. };
  370. template<>
  371. struct TypeValues<LLFontGL::HAlign> : public TypeValuesHelper<LLFontGL::HAlign>
  372. {
  373. static void declareValues();
  374. };
  375. template<>
  376. struct TypeValues<LLFontGL::VAlign> : public TypeValuesHelper<LLFontGL::VAlign>
  377. {
  378. static void declareValues();
  379. };
  380. template<>
  381. struct TypeValues<LLFontGL::ShadowType> : public TypeValuesHelper<LLFontGL::ShadowType>
  382. {
  383. static void declareValues();
  384. };
  385. template<>
  386. struct ParamCompare<const LLFontGL*, false>
  387. {
  388. static bool equals(const LLFontGL* a, const LLFontGL* b);
  389. };
  390. template<>
  391. class TypedParam<LLCoordGL>
  392. : public BlockValue<LLCoordGL>
  393. {
  394. typedef BlockValue<LLCoordGL> super_t;
  395. public:
  396. Optional<S32> x,
  397. y;
  398. TypedParam(BlockDescriptor& descriptor, const char* name, LLCoordGL value, ParamDescriptor::validation_func_t func, S32 min_count, S32 max_count);
  399. void setValueFromBlock() const;
  400. void setBlockFromValue();
  401. };
  402. }
  403. #endif