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

游戏引擎

开发平台:

C++ Builder

  1. /**
  2.  * @file media_plugin_example.cpp
  3.  * @brief Example plugin for LLMedia API plugin system
  4.  *
  5.  * @cond
  6.  * $LicenseInfo:firstyear=2008&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2008-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  * @endcond
  33.  */
  34. #include "linden_common.h"
  35. #include "llgl.h"
  36. #include "llplugininstance.h"
  37. #include "llpluginmessage.h"
  38. #include "llpluginmessageclasses.h"
  39. #include "media_plugin_base.h"
  40. #include <time.h>
  41. ////////////////////////////////////////////////////////////////////////////////
  42. //
  43. class MediaPluginExample :
  44. public MediaPluginBase
  45. {
  46. public:
  47. MediaPluginExample( LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data );
  48. ~MediaPluginExample();
  49. /*virtual*/ void receiveMessage( const char* message_string );
  50. private:
  51. bool init();
  52. void update( F64 milliseconds );
  53. void write_pixel( int x, int y, unsigned char r, unsigned char g, unsigned char b );
  54. bool mFirstTime;
  55. time_t mLastUpdateTime;
  56. enum Constants { ENumObjects = 10 };
  57. unsigned char* mBackgroundPixels;
  58. int mColorR[ ENumObjects ];
  59. int mColorG[ ENumObjects ];
  60. int mColorB[ ENumObjects ];
  61. int mXpos[ ENumObjects ];
  62. int mYpos[ ENumObjects ];
  63. int mXInc[ ENumObjects ];
  64. int mYInc[ ENumObjects ];
  65. int mBlockSize[ ENumObjects ];
  66. bool mMouseButtonDown;
  67. bool mStopAction;
  68. };
  69. ////////////////////////////////////////////////////////////////////////////////
  70. //
  71. MediaPluginExample::MediaPluginExample( LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data ) :
  72. MediaPluginBase( host_send_func, host_user_data )
  73. {
  74. mFirstTime = true;
  75. mWidth = 0;
  76. mHeight = 0;
  77. mDepth = 4;
  78. mPixels = 0;
  79. mMouseButtonDown = false;
  80. mStopAction = false;
  81. mLastUpdateTime = 0;
  82. }
  83. ////////////////////////////////////////////////////////////////////////////////
  84. //
  85. MediaPluginExample::~MediaPluginExample()
  86. {
  87. }
  88. ////////////////////////////////////////////////////////////////////////////////
  89. //
  90. void MediaPluginExample::receiveMessage( const char* message_string )
  91. {
  92. LLPluginMessage message_in;
  93. if ( message_in.parse( message_string ) >= 0 )
  94. {
  95. std::string message_class = message_in.getClass();
  96. std::string message_name = message_in.getName();
  97. if ( message_class == LLPLUGIN_MESSAGE_CLASS_BASE )
  98. {
  99. if ( message_name == "init" )
  100. {
  101. LLPluginMessage message( "base", "init_response" );
  102. LLSD versions = LLSD::emptyMap();
  103. versions[ LLPLUGIN_MESSAGE_CLASS_BASE ] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION;
  104. versions[ LLPLUGIN_MESSAGE_CLASS_MEDIA ] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION;
  105. versions[ LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER ] = LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER_VERSION;
  106. message.setValueLLSD( "versions", versions );
  107. std::string plugin_version = "Example media plugin, Example Version 1.0.0.0";
  108. message.setValue( "plugin_version", plugin_version );
  109. sendMessage( message );
  110. // Plugin gets to decide the texture parameters to use.
  111. message.setMessage( LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params" );
  112. message.setValueS32( "default_width", mWidth );
  113. message.setValueS32( "default_height", mHeight );
  114. message.setValueS32( "depth", mDepth );
  115. message.setValueU32( "internalformat", GL_RGBA );
  116. message.setValueU32( "format", GL_RGBA );
  117. message.setValueU32( "type", GL_UNSIGNED_BYTE );
  118. message.setValueBoolean( "coords_opengl", false );
  119. sendMessage( message );
  120. }
  121. else
  122. if ( message_name == "idle" )
  123. {
  124. // no response is necessary here.
  125. F64 time = message_in.getValueReal( "time" );
  126. // Convert time to milliseconds for update()
  127. update( time );
  128. }
  129. else
  130. if ( message_name == "cleanup" )
  131. {
  132. // clean up here
  133. }
  134. else
  135. if ( message_name == "shm_added" )
  136. {
  137. SharedSegmentInfo info;
  138. info.mAddress = message_in.getValuePointer( "address" );
  139. info.mSize = ( size_t )message_in.getValueS32( "size" );
  140. std::string name = message_in.getValue( "name" );
  141. mSharedSegments.insert( SharedSegmentMap::value_type( name, info ) );
  142. }
  143. else
  144. if ( message_name == "shm_remove" )
  145. {
  146. std::string name = message_in.getValue( "name" );
  147. SharedSegmentMap::iterator iter = mSharedSegments.find( name );
  148. if( iter != mSharedSegments.end() )
  149. {
  150. if ( mPixels == iter->second.mAddress )
  151. {
  152. // This is the currently active pixel buffer.
  153. // Make sure we stop drawing to it.
  154. mPixels = NULL;
  155. mTextureSegmentName.clear();
  156. };
  157. mSharedSegments.erase( iter );
  158. }
  159. else
  160. {
  161. //std::cerr << "MediaPluginExample::receiveMessage: unknown shared memory region!" << std::endl;
  162. };
  163. // Send the response so it can be cleaned up.
  164. LLPluginMessage message( "base", "shm_remove_response" );
  165. message.setValue( "name", name );
  166. sendMessage( message );
  167. }
  168. else
  169. {
  170. //std::cerr << "MediaPluginExample::receiveMessage: unknown base message: " << message_name << std::endl;
  171. };
  172. }
  173. else
  174. if ( message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA )
  175. {
  176. if ( message_name == "size_change" )
  177. {
  178. std::string name = message_in.getValue( "name" );
  179. S32 width = message_in.getValueS32( "width" );
  180. S32 height = message_in.getValueS32( "height" );
  181. S32 texture_width = message_in.getValueS32( "texture_width" );
  182. S32 texture_height = message_in.getValueS32( "texture_height" );
  183. if ( ! name.empty() )
  184. {
  185. // Find the shared memory region with this name
  186. SharedSegmentMap::iterator iter = mSharedSegments.find( name );
  187. if ( iter != mSharedSegments.end() )
  188. {
  189. mPixels = ( unsigned char* )iter->second.mAddress;
  190. mWidth = width;
  191. mHeight = height;
  192. mTextureWidth = texture_width;
  193. mTextureHeight = texture_height;
  194. init();
  195. };
  196. };
  197. LLPluginMessage message( LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_response" );
  198. message.setValue( "name", name );
  199. message.setValueS32( "width", width );
  200. message.setValueS32( "height", height );
  201. message.setValueS32( "texture_width", texture_width );
  202. message.setValueS32( "texture_height", texture_height );
  203. sendMessage( message );
  204. }
  205. else
  206. if ( message_name == "load_uri" )
  207. {
  208. std::string uri = message_in.getValue( "uri" );
  209. if ( ! uri.empty() )
  210. {
  211. };
  212. }
  213. else
  214. if ( message_name == "mouse_event" )
  215. {
  216. std::string event = message_in.getValue( "event" );
  217. S32 button = message_in.getValueS32( "button" );
  218. // left mouse button
  219. if ( button == 0 )
  220. {
  221. int mouse_x = message_in.getValueS32( "x" );
  222. int mouse_y = message_in.getValueS32( "y" );
  223. std::string modifiers = message_in.getValue( "modifiers" );
  224. if ( event == "move" )
  225. {
  226. if ( mMouseButtonDown )
  227. write_pixel( mouse_x, mouse_y, rand() % 0x80 + 0x80, rand() % 0x80 + 0x80, rand() % 0x80 + 0x80 );
  228. }
  229. else
  230. if ( event == "down" )
  231. {
  232. mMouseButtonDown = true;
  233. }
  234. else
  235. if ( event == "up" )
  236. {
  237. mMouseButtonDown = false;
  238. }
  239. else
  240. if ( event == "double_click" )
  241. {
  242. };
  243. };
  244. }
  245. else
  246. if ( message_name == "key_event" )
  247. {
  248. std::string event = message_in.getValue( "event" );
  249. S32 key = message_in.getValueS32( "key" );
  250. std::string modifiers = message_in.getValue( "modifiers" );
  251. if ( event == "down" )
  252. {
  253. if ( key == ' ')
  254. {
  255. mLastUpdateTime = 0;
  256. update( 0.0f );
  257. };
  258. };
  259. }
  260. else
  261. {
  262. //std::cerr << "MediaPluginExample::receiveMessage: unknown media message: " << message_string << std::endl;
  263. };
  264. }
  265. else
  266. if ( message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER )
  267. {
  268. if ( message_name == "browse_reload" )
  269. {
  270. mLastUpdateTime = 0;
  271. mFirstTime = true;
  272. mStopAction = false;
  273. update( 0.0f );
  274. }
  275. else
  276. if ( message_name == "browse_stop" )
  277. {
  278. for( int n = 0; n < ENumObjects; ++n )
  279. mXInc[ n ] = mYInc[ n ] = 0;
  280. mStopAction = true;
  281. update( 0.0f );
  282. }
  283. else
  284. {
  285. //std::cerr << "MediaPluginExample::receiveMessage: unknown media_browser message: " << message_string << std::endl;
  286. };
  287. }
  288. else
  289. {
  290. //std::cerr << "MediaPluginExample::receiveMessage: unknown message class: " << message_class << std::endl;
  291. };
  292. };
  293. }
  294. ////////////////////////////////////////////////////////////////////////////////
  295. //
  296. void MediaPluginExample::write_pixel( int x, int y, unsigned char r, unsigned char g, unsigned char b )
  297. {
  298. // make sure we don't write outside the buffer
  299. if ( ( x < 0 ) || ( x >= mWidth ) || ( y < 0 ) || ( y >= mHeight ) )
  300. return;
  301. if ( mBackgroundPixels != NULL )
  302. {
  303. unsigned char *pixel = mBackgroundPixels;
  304. pixel += y * mWidth * mDepth;
  305. pixel += ( x * mDepth );
  306. pixel[ 0 ] = b;
  307. pixel[ 1 ] = g;
  308. pixel[ 2 ] = r;
  309. setDirty( x, y, x + 1, y + 1 );
  310. };
  311. }
  312. ////////////////////////////////////////////////////////////////////////////////
  313. //
  314. void MediaPluginExample::update( F64 milliseconds )
  315. {
  316. if ( mWidth < 1 || mWidth > 2048 || mHeight < 1 || mHeight > 2048 )
  317. return;
  318. if ( mPixels == 0 )
  319. return;
  320. if ( mFirstTime )
  321. {
  322. for( int n = 0; n < ENumObjects; ++n )
  323. {
  324. mXpos[ n ] = ( mWidth / 2 ) + rand() % ( mWidth / 16 ) - ( mWidth / 32 );
  325. mYpos[ n ] = ( mHeight / 2 ) + rand() % ( mHeight / 16 ) - ( mHeight / 32 );
  326. mColorR[ n ] = rand() % 0x60 + 0x60;
  327. mColorG[ n ] = rand() % 0x60 + 0x60;
  328. mColorB[ n ] = rand() % 0x60 + 0x60;
  329. mXInc[ n ] = 0;
  330. while ( mXInc[ n ] == 0 )
  331. mXInc[ n ] = rand() % 7 - 3;
  332. mYInc[ n ] = 0;
  333. while ( mYInc[ n ] == 0 )
  334. mYInc[ n ] = rand() % 9 - 4;
  335. mBlockSize[ n ] = rand() % 0x30 + 0x10;
  336. };
  337. delete [] mBackgroundPixels;
  338. mBackgroundPixels = new unsigned char[ mWidth * mHeight * mDepth ];
  339. mFirstTime = false;
  340. };
  341. if ( mStopAction )
  342. return;
  343. if ( time( NULL ) > mLastUpdateTime + 3 )
  344. {
  345. const int num_squares = rand() % 20 + 4;
  346. int sqr1_r = rand() % 0x80 + 0x20;
  347. int sqr1_g = rand() % 0x80 + 0x20;
  348. int sqr1_b = rand() % 0x80 + 0x20;
  349. int sqr2_r = rand() % 0x80 + 0x20;
  350. int sqr2_g = rand() % 0x80 + 0x20;
  351. int sqr2_b = rand() % 0x80 + 0x20;
  352. for ( int y1 = 0; y1 < num_squares; ++y1 )
  353. {
  354. for ( int x1 = 0; x1 < num_squares; ++x1 )
  355. {
  356. int px_start = mWidth * x1 / num_squares;
  357. int px_end = ( mWidth * ( x1 + 1 ) ) / num_squares;
  358. int py_start = mHeight * y1 / num_squares;
  359. int py_end = ( mHeight * ( y1 + 1 ) ) / num_squares;
  360. for( int y2 = py_start; y2 < py_end; ++y2 )
  361. {
  362. for( int x2 = px_start; x2 < px_end; ++x2 )
  363. {
  364. int rowspan = mWidth * mDepth;
  365. if ( ( y1 % 2 ) ^ ( x1 % 2 ) )
  366. {
  367. mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 0 ] = sqr1_r;
  368. mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 1 ] = sqr1_g;
  369. mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 2 ] = sqr1_b;
  370. }
  371. else
  372. {
  373. mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 0 ] = sqr2_r;
  374. mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 1 ] = sqr2_g;
  375. mBackgroundPixels[ y2 * rowspan + x2 * mDepth + 2 ] = sqr2_b;
  376. };
  377. };
  378. };
  379. };
  380. };
  381. time( &mLastUpdateTime );
  382. };
  383. memcpy( mPixels, mBackgroundPixels, mWidth * mHeight * mDepth );
  384. for( int n = 0; n < ENumObjects; ++n )
  385. {
  386. if ( rand() % 50 == 0 )
  387. {
  388. mXInc[ n ] = 0;
  389. while ( mXInc[ n ] == 0 )
  390. mXInc[ n ] = rand() % 7 - 3;
  391. mYInc[ n ] = 0;
  392. while ( mYInc[ n ] == 0 )
  393. mYInc[ n ] = rand() % 9 - 4;
  394. };
  395. if ( mXpos[ n ] + mXInc[ n ] < 0 || mXpos[ n ] + mXInc[ n ] >= mWidth - mBlockSize[ n ] )
  396. mXInc[ n ] =- mXInc[ n ];
  397. if ( mYpos[ n ] + mYInc[ n ] < 0 || mYpos[ n ] + mYInc[ n ] >= mHeight - mBlockSize[ n ] )
  398. mYInc[ n ] =- mYInc[ n ];
  399. mXpos[ n ] += mXInc[ n ];
  400. mYpos[ n ] += mYInc[ n ];
  401. for( int y = 0; y < mBlockSize[ n ]; ++y )
  402. {
  403. for( int x = 0; x < mBlockSize[ n ]; ++x )
  404. {
  405. mPixels[ ( mXpos[ n ] + x ) * mDepth + ( mYpos[ n ] + y ) * mDepth * mWidth + 0 ] = mColorR[ n ];
  406. mPixels[ ( mXpos[ n ] + x ) * mDepth + ( mYpos[ n ] + y ) * mDepth * mWidth + 1 ] = mColorG[ n ];
  407. mPixels[ ( mXpos[ n ] + x ) * mDepth + ( mYpos[ n ] + y ) * mDepth * mWidth + 2 ] = mColorB[ n ];
  408. };
  409. };
  410. };
  411. setDirty( 0, 0, mWidth, mHeight );
  412. };
  413. ////////////////////////////////////////////////////////////////////////////////
  414. //
  415. bool MediaPluginExample::init()
  416. {
  417. LLPluginMessage message( LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text" );
  418. message.setValue( "name", "Example Plugin" );
  419. sendMessage( message );
  420. return true;
  421. };
  422. ////////////////////////////////////////////////////////////////////////////////
  423. //
  424. int init_media_plugin( LLPluginInstance::sendMessageFunction host_send_func,
  425. void* host_user_data,
  426. LLPluginInstance::sendMessageFunction *plugin_send_func,
  427. void **plugin_user_data )
  428. {
  429. MediaPluginExample* self = new MediaPluginExample( host_send_func, host_user_data );
  430. *plugin_send_func = MediaPluginExample::staticReceiveMessage;
  431. *plugin_user_data = ( void* )self;
  432. return 0;
  433. }