/indra/newview/llfloatermodelpreview.h

https://bitbucket.org/lindenlab/viewer-beta/ · C Header · 475 lines · 322 code · 106 blank · 47 comment · 0 complexity · ea868eec476ed36b9627a80a0bfeaefe MD5 · raw file

  1. /**
  2. * @file llfloatermodelpreview.h
  3. * @brief LLFloaterModelPreview class definition
  4. *
  5. * $LicenseInfo:firstyear=2004&license=viewerlgpl$
  6. * Second Life Viewer Source Code
  7. * Copyright (C) 2010, Linden Research, Inc.
  8. *
  9. * This library is free software; you can redistribute it and/or
  10. * modify it under the terms of the GNU Lesser General Public
  11. * License as published by the Free Software Foundation;
  12. * version 2.1 of the License only.
  13. *
  14. * This library is distributed in the hope that it will be useful,
  15. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17. * Lesser General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU Lesser General Public
  20. * License along with this library; if not, write to the Free Software
  21. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22. *
  23. * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
  24. * $/LicenseInfo$
  25. */
  26. #ifndef LL_LLFLOATERMODELPREVIEW_H
  27. #define LL_LLFLOATERMODELPREVIEW_H
  28. #include "llfloaternamedesc.h"
  29. #include "lldynamictexture.h"
  30. #include "llfloatermodelwizard.h"
  31. #include "llquaternion.h"
  32. #include "llmeshrepository.h"
  33. #include "llmodel.h"
  34. #include "llthread.h"
  35. #include "llviewermenufile.h"
  36. class LLComboBox;
  37. class LLJoint;
  38. class LLViewerJointMesh;
  39. class LLVOAvatar;
  40. class LLTextBox;
  41. class LLVertexBuffer;
  42. class LLModelPreview;
  43. class LLFloaterModelPreview;
  44. class daeElement;
  45. class domProfile_COMMON;
  46. class domInstance_geometry;
  47. class domNode;
  48. class domTranslate;
  49. class domController;
  50. class LLMenuButton;
  51. class LLToggleableMenu;
  52. typedef std::map<std::string, LLMatrix4> JointTransformMap;
  53. typedef std::map<std::string, LLMatrix4>:: iterator JointTransformMapIt;
  54. const S32 NUM_LOD = 4;
  55. class LLModelLoader : public LLThread
  56. {
  57. public:
  58. typedef enum
  59. {
  60. STARTING = 0,
  61. READING_FILE,
  62. CREATING_FACES,
  63. GENERATING_VERTEX_BUFFERS,
  64. GENERATING_LOD,
  65. DONE,
  66. ERROR_PARSING, //basically loading failed
  67. ERROR_MATERIALS,
  68. } eLoadState;
  69. U32 mState;
  70. std::string mFilename;
  71. S32 mLod;
  72. LLModelPreview* mPreview;
  73. LLMatrix4 mTransform;
  74. BOOL mFirstTransform;
  75. LLVector3 mExtents[2];
  76. bool mTrySLM;
  77. std::map<daeElement*, LLPointer<LLModel> > mModel;
  78. typedef std::vector<LLPointer<LLModel> > model_list;
  79. model_list mModelList;
  80. typedef std::vector<LLModelInstance> model_instance_list;
  81. typedef std::map<LLMatrix4, model_instance_list > scene;
  82. scene mScene;
  83. typedef std::queue<LLPointer<LLModel> > model_queue;
  84. //queue of models that need a physics rep
  85. model_queue mPhysicsQ;
  86. LLModelLoader( std::string filename, S32 lod, LLModelPreview* preview, JointTransformMap& jointMap,
  87. std::deque<std::string>& jointsFromNodes );
  88. ~LLModelLoader() ;
  89. virtual void run();
  90. bool doLoadModel();
  91. bool loadFromSLM(const std::string& filename);
  92. void loadModelCallback();
  93. void loadTextures() ; //called in the main thread.
  94. void processElement(daeElement* element, bool& badElement);
  95. std::map<std::string, LLImportMaterial> getMaterials(LLModel* model, domInstance_geometry* instance_geo);
  96. LLImportMaterial profileToMaterial(domProfile_COMMON* material);
  97. std::string getElementLabel(daeElement *element);
  98. LLColor4 getDaeColor(daeElement* element);
  99. daeElement* getChildFromElement( daeElement* pElement, std::string const & name );
  100. bool isNodeAJoint( domNode* pNode );
  101. void processJointNode( domNode* pNode, std::map<std::string,LLMatrix4>& jointTransforms );
  102. void extractTranslation( domTranslate* pTranslate, LLMatrix4& transform );
  103. void extractTranslationViaElement( daeElement* pTranslateElement, LLMatrix4& transform );
  104. void extractTranslationViaSID( daeElement* pElement, LLMatrix4& transform );
  105. void setLoadState(U32 state);
  106. void buildJointToNodeMappingFromScene( daeElement* pRoot );
  107. void processJointToNodeMapping( domNode* pNode );
  108. void processChildJoints( domNode* pParentNode );
  109. //map of avatar joints as named in COLLADA assets to internal joint names
  110. std::map<std::string, std::string> mJointMap;
  111. JointTransformMap& mJointList;
  112. std::deque<std::string>& mJointsFromNode;
  113. S32 mNumOfFetchingTextures ; //updated in the main thread
  114. bool areTexturesReady() { return !mNumOfFetchingTextures; } //called in the main thread.
  115. private:
  116. static std::list<LLModelLoader*> sActiveLoaderList;
  117. static bool isAlive(LLModelLoader* loader) ;
  118. };
  119. class LLFloaterModelPreview : public LLFloaterModelUploadBase
  120. {
  121. public:
  122. class DecompRequest : public LLPhysicsDecomp::Request
  123. {
  124. public:
  125. S32 mContinue;
  126. LLPointer<LLModel> mModel;
  127. DecompRequest(const std::string& stage, LLModel* mdl);
  128. virtual S32 statusCallback(const char* status, S32 p1, S32 p2);
  129. virtual void completed();
  130. };
  131. static LLFloaterModelPreview* sInstance;
  132. LLFloaterModelPreview(const LLSD& key);
  133. virtual ~LLFloaterModelPreview();
  134. virtual BOOL postBuild();
  135. void initModelPreview();
  136. BOOL handleMouseDown(S32 x, S32 y, MASK mask);
  137. BOOL handleMouseUp(S32 x, S32 y, MASK mask);
  138. BOOL handleHover(S32 x, S32 y, MASK mask);
  139. BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
  140. /*virtual*/ void onOpen(const LLSD& key);
  141. static void onMouseCaptureLostModelPreview(LLMouseHandler*);
  142. static void setUploadAmount(S32 amount) { sUploadAmount = amount; }
  143. void setDetails(F32 x, F32 y, F32 z, F32 streaming_cost, F32 physics_cost);
  144. void onBrowseLOD(S32 lod);
  145. static void onReset(void* data);
  146. static void onUpload(void* data);
  147. void refresh();
  148. void loadModel(S32 lod);
  149. void loadModel(S32 lod, const std::string& file_name, bool force_disable_slm = false);
  150. void onViewOptionChecked(LLUICtrl* ctrl);
  151. bool isViewOptionChecked(const LLSD& userdata);
  152. bool isViewOptionEnabled(const LLSD& userdata);
  153. void setViewOptionEnabled(const std::string& option, bool enabled);
  154. void enableViewOption(const std::string& option);
  155. void disableViewOption(const std::string& option);
  156. // shows warning message if agent has no permissions to upload model
  157. /*virtual*/ void onPermissionsReceived(const LLSD& result);
  158. // called when error occurs during permissions request
  159. /*virtual*/ void setPermissonsErrorStatus(U32 status, const std::string& reason);
  160. /*virtual*/ void onModelPhysicsFeeReceived(const LLSD& result, std::string upload_url);
  161. void handleModelPhysicsFeeReceived();
  162. /*virtual*/ void setModelPhysicsFeeErrorStatus(U32 status, const std::string& reason);
  163. /*virtual*/ void onModelUploadSuccess();
  164. /*virtual*/ void onModelUploadFailure();
  165. protected:
  166. friend class LLModelPreview;
  167. friend class LLMeshFilePicker;
  168. friend class LLPhysicsDecomp;
  169. static void onImportScaleCommit(LLUICtrl*, void*);
  170. static void onPelvisOffsetCommit(LLUICtrl*, void*);
  171. static void onUploadJointsCommit(LLUICtrl*,void*);
  172. static void onUploadSkinCommit(LLUICtrl*,void*);
  173. static void onPreviewLODCommit(LLUICtrl*,void*);
  174. static void onGenerateNormalsCommit(LLUICtrl*,void*);
  175. void toggleGenarateNormals();
  176. static void onAutoFillCommit(LLUICtrl*,void*);
  177. void onLODParamCommit(S32 lod, bool enforce_tri_limit);
  178. static void onExplodeCommit(LLUICtrl*, void*);
  179. static void onPhysicsParamCommit(LLUICtrl* ctrl, void* userdata);
  180. static void onPhysicsStageExecute(LLUICtrl* ctrl, void* userdata);
  181. static void onCancel(LLUICtrl* ctrl, void* userdata);
  182. static void onPhysicsStageCancel(LLUICtrl* ctrl, void* userdata);
  183. static void onPhysicsBrowse(LLUICtrl* ctrl, void* userdata);
  184. static void onPhysicsUseLOD(LLUICtrl* ctrl, void* userdata);
  185. static void onPhysicsOptimize(LLUICtrl* ctrl, void* userdata);
  186. static void onPhysicsDecomposeBack(LLUICtrl* ctrl, void* userdata);
  187. static void onPhysicsSimplifyBack(LLUICtrl* ctrl, void* userdata);
  188. void draw();
  189. void initDecompControls();
  190. void setStatusMessage(const std::string& msg);
  191. LLModelPreview* mModelPreview;
  192. LLPhysicsDecomp::decomp_params mDecompParams;
  193. S32 mLastMouseX;
  194. S32 mLastMouseY;
  195. LLRect mPreviewRect;
  196. U32 mGLName;
  197. static S32 sUploadAmount;
  198. std::set<LLPointer<DecompRequest> > mCurRequest;
  199. std::string mStatusMessage;
  200. //use "disabled" as false by default
  201. std::map<std::string, bool> mViewOptionDisabled;
  202. //store which lod mode each LOD is using
  203. // 0 - load from file
  204. // 1 - auto generate
  205. // 2 - use LoD above
  206. S32 mLODMode[4];
  207. LLMutex* mStatusLock;
  208. LLSD mModelPhysicsFee;
  209. private:
  210. void onClickCalculateBtn();
  211. void toggleCalculateButton();
  212. void onLoDSourceCommit(S32 lod);
  213. // Toggles between "Calculate weights & fee" and "Upload" buttons.
  214. void toggleCalculateButton(bool visible);
  215. // resets display options of model preview to their defaults.
  216. void resetDisplayOptions();
  217. void createSmoothComboBox(LLComboBox* combo_box, float min, float max);
  218. LLButton* mUploadBtn;
  219. LLButton* mCalculateBtn;
  220. };
  221. class LLMeshFilePicker : public LLFilePickerThread
  222. {
  223. public:
  224. LLMeshFilePicker(LLModelPreview* mp, S32 lod);
  225. virtual void notify(const std::string& filename);
  226. private:
  227. LLModelPreview* mMP;
  228. S32 mLOD;
  229. };
  230. class LLModelPreview : public LLViewerDynamicTexture, public LLMutex
  231. {
  232. typedef boost::signals2::signal<void (F32 x, F32 y, F32 z, F32 streaming_cost, F32 physics_cost)> details_signal_t;
  233. typedef boost::signals2::signal<void (void)> model_loaded_signal_t;
  234. typedef boost::signals2::signal<void (bool)> model_updated_signal_t;
  235. public:
  236. LLModelPreview(S32 width, S32 height, LLFloater* fmp);
  237. virtual ~LLModelPreview();
  238. void resetPreviewTarget();
  239. void setPreviewTarget(F32 distance);
  240. void setTexture(U32 name) { mTextureName = name; }
  241. void setPhysicsFromLOD(S32 lod);
  242. BOOL render();
  243. void update();
  244. void genBuffers(S32 lod, bool skinned);
  245. void clearBuffers();
  246. void refresh();
  247. void rotate(F32 yaw_radians, F32 pitch_radians);
  248. void zoom(F32 zoom_amt);
  249. void pan(F32 right, F32 up);
  250. virtual BOOL needsRender() { return mNeedsUpdate; }
  251. void setPreviewLOD(S32 lod);
  252. void clearModel(S32 lod);
  253. void loadModel(std::string filename, S32 lod, bool force_disable_slm = false);
  254. void loadModelCallback(S32 lod);
  255. void genLODs(S32 which_lod = -1, U32 decimation = 3, bool enforce_tri_limit = false);
  256. void generateNormals();
  257. U32 calcResourceCost();
  258. void rebuildUploadData();
  259. void saveUploadData(bool save_skinweights, bool save_joint_poisitions);
  260. void saveUploadData(const std::string& filename, bool save_skinweights, bool save_joint_poisitions);
  261. void clearIncompatible(S32 lod);
  262. void updateStatusMessages();
  263. void updateLodControls(S32 lod);
  264. void clearGLODGroup();
  265. void onLODParamCommit(S32 lod, bool enforce_tri_limit);
  266. void addEmptyFace( LLModel* pTarget );
  267. const bool getModelPivot( void ) const { return mHasPivot; }
  268. void setHasPivot( bool val ) { mHasPivot = val; }
  269. void setModelPivot( const LLVector3& pivot ) { mModelPivot = pivot; }
  270. //Determines the viability of an asset to be used as an avatar rig (w or w/o joint upload caps)
  271. void critiqueRigForUploadApplicability( const std::vector<std::string> &jointListFromAsset );
  272. void critiqueJointToNodeMappingFromScene( void );
  273. //Is a rig valid so that it can be used as a criteria for allowing for uploading of joint positions
  274. //Accessors for joint position upload friendly rigs
  275. const bool isRigValidForJointPositionUpload( void ) const { return mRigValidJointUpload; }
  276. void setRigValidForJointPositionUpload( bool rigValid ) { mRigValidJointUpload = rigValid; }
  277. bool isRigSuitableForJointPositionUpload( const std::vector<std::string> &jointListFromAsset );
  278. //Determines if a rig is a legacy from the joint list
  279. bool isRigLegacy( const std::vector<std::string> &jointListFromAsset );
  280. //Accessors for the legacy rigs
  281. const bool isLegacyRigValid( void ) const { return mLegacyRigValid; }
  282. void setLegacyRigValid( bool rigValid ) { mLegacyRigValid = rigValid; }
  283. //Verify that a controller matches vertex counts
  284. bool verifyController( domController* pController );
  285. static void textureLoadedCallback( BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* src_aux, S32 discard_level, BOOL final, void* userdata );
  286. boost::signals2::connection setDetailsCallback( const details_signal_t::slot_type& cb ){ return mDetailsSignal.connect(cb); }
  287. boost::signals2::connection setModelLoadedCallback( const model_loaded_signal_t::slot_type& cb ){ return mModelLoadedSignal.connect(cb); }
  288. boost::signals2::connection setModelUpdatedCallback( const model_updated_signal_t::slot_type& cb ){ return mModelUpdatedSignal.connect(cb); }
  289. void setLoadState( U32 state ) { mLoadState = state; }
  290. U32 getLoadState() { return mLoadState; }
  291. void setRigWithSceneParity( bool state ) { mRigParityWithScene = state; }
  292. const bool getRigWithSceneParity( void ) const { return mRigParityWithScene; }
  293. LLVector3 getTranslationForJointOffset( std::string joint );
  294. private:
  295. //Utility function for controller vertex compare
  296. bool verifyCount( int expected, int result );
  297. //Creates the dummy avatar for the preview window
  298. void createPreviewAvatar( void );
  299. //Accessor for the dummy avatar
  300. LLVOAvatar* getPreviewAvatar( void ) { return mPreviewAvatar; }
  301. protected:
  302. friend class LLModelLoader;
  303. friend class LLFloaterModelPreview;
  304. friend class LLFloaterModelWizard;
  305. friend class LLFloaterModelPreview::DecompRequest;
  306. friend class LLFloaterModelWizard::DecompRequest;
  307. friend class LLPhysicsDecomp;
  308. LLFloater* mFMP;
  309. BOOL mNeedsUpdate;
  310. bool mDirty;
  311. bool mGenLOD;
  312. U32 mTextureName;
  313. F32 mCameraDistance;
  314. F32 mCameraYaw;
  315. F32 mCameraPitch;
  316. F32 mCameraZoom;
  317. LLVector3 mCameraOffset;
  318. LLVector3 mPreviewTarget;
  319. LLVector3 mPreviewScale;
  320. S32 mPreviewLOD;
  321. U32 mResourceCost;
  322. std::string mLODFile[LLModel::NUM_LODS];
  323. bool mLoading;
  324. U32 mLoadState;
  325. bool mResetJoints;
  326. bool mRigParityWithScene;
  327. std::map<std::string, bool> mViewOption;
  328. //GLOD object parameters (must rebuild object if these change)
  329. bool mLODFrozen;
  330. F32 mBuildShareTolerance;
  331. U32 mBuildQueueMode;
  332. U32 mBuildOperator;
  333. U32 mBuildBorderMode;
  334. U32 mRequestedLoDMode[LLModel::NUM_LODS];
  335. S32 mRequestedTriangleCount[LLModel::NUM_LODS];
  336. F32 mRequestedErrorThreshold[LLModel::NUM_LODS];
  337. U32 mRequestedBuildOperator[LLModel::NUM_LODS];
  338. U32 mRequestedQueueMode[LLModel::NUM_LODS];
  339. U32 mRequestedBorderMode[LLModel::NUM_LODS];
  340. F32 mRequestedShareTolerance[LLModel::NUM_LODS];
  341. F32 mRequestedCreaseAngle[LLModel::NUM_LODS];
  342. LLModelLoader* mModelLoader;
  343. LLModelLoader::scene mScene[LLModel::NUM_LODS];
  344. LLModelLoader::scene mBaseScene;
  345. LLModelLoader::model_list mModel[LLModel::NUM_LODS];
  346. LLModelLoader::model_list mBaseModel;
  347. U32 mGroup;
  348. std::map<LLPointer<LLModel>, U32> mObject;
  349. U32 mMaxTriangleLimit;
  350. LLMeshUploadThread::instance_list mUploadData;
  351. std::set<LLViewerFetchedTexture* > mTextureSet;
  352. //map of vertex buffers to models (one vertex buffer in vector per face in model
  353. std::map<LLModel*, std::vector<LLPointer<LLVertexBuffer> > > mVertexBuffer[LLModel::NUM_LODS+1];
  354. details_signal_t mDetailsSignal;
  355. model_loaded_signal_t mModelLoadedSignal;
  356. model_updated_signal_t mModelUpdatedSignal;
  357. LLVector3 mModelPivot;
  358. bool mHasPivot;
  359. float mPelvisZOffset;
  360. bool mRigValidJointUpload;
  361. bool mLegacyRigValid;
  362. bool mLastJointUpdate;
  363. std::deque<std::string> mMasterJointList;
  364. std::deque<std::string> mMasterLegacyJointList;
  365. std::deque<std::string> mJointsFromNode;
  366. JointTransformMap mJointTransformMap;
  367. LLPointer<LLVOAvatar> mPreviewAvatar;
  368. };
  369. #endif // LL_LLFLOATERMODELPREVIEW_H