开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llvowlsky.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：20k
源码类别：

游戏引擎

开发平台：

C++ Builder

llvowlsky.cpp：源码内容
  1. /** 
  2.  * @file llvowlsky.cpp
  3.  * @brief LLVOWLSky class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2007-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.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "pipeline.h"
  37. #include "llvowlsky.h"
  38. #include "llsky.h"
  39. #include "lldrawpoolwlsky.h"
  40. #include "llface.h"
  41. #include "llwlparammanager.h"
  42. #include "llviewercontrol.h"
  44. #define DOME_SLICES 1
  45. const F32 LLVOWLSky::DISTANCE_TO_STARS = (HORIZON_DIST - 10.f)*0.25f;
  47. const U32 LLVOWLSky::MIN_SKY_DETAIL = 3;
  48. const U32 LLVOWLSky::MAX_SKY_DETAIL = 180;
  50. inline U32 LLVOWLSky::getNumStacks(void)
  51. {
  52. return llmin(MAX_SKY_DETAIL, llmax(MIN_SKY_DETAIL, gSavedSettings.getU32("WLSkyDetail")));
  53. }
  55. inline U32 LLVOWLSky::getNumSlices(void)
  56. {
  57. return 2 * llmin(MAX_SKY_DETAIL, llmax(MIN_SKY_DETAIL, gSavedSettings.getU32("WLSkyDetail")));
  58. }
  60. inline U32 LLVOWLSky::getFanNumVerts(void)
  61. {
  62. return getNumSlices() + 1;
  63. }
  65. inline U32 LLVOWLSky::getFanNumIndices(void)
  66. {
  67. return getNumSlices() * 3;
  68. }
  70. inline U32 LLVOWLSky::getStripsNumVerts(void)
  71. {
  72. return (getNumStacks() - 1) * getNumSlices();
  73. }
  75. inline U32 LLVOWLSky::getStripsNumIndices(void)
  76. {
  77. return 2 * ((getNumStacks() - 2) * (getNumSlices() + 1)) + 1 ; 
  78. }
  80. inline U32 LLVOWLSky::getStarsNumVerts(void)
  81. {
  82. return 1000;
  83. }
  85. inline U32 LLVOWLSky::getStarsNumIndices(void)
  86. {
  87. return 1000;
  88. }
  90. LLVOWLSky::LLVOWLSky(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
  91. : LLStaticViewerObject(id, pcode, regionp, TRUE)
  92. {
  93. initStars();
  94. }
  96. void LLVOWLSky::initSunDirection(LLVector3 const & sun_direction,
  97. LLVector3 const & sun_angular_velocity)
  98. {
  99. }
  101. BOOL LLVOWLSky::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
  102. {
  103. return TRUE;
  104. }
  106. BOOL LLVOWLSky::isActive(void) const
  107. {
  108. return FALSE;
  109. }
  111. LLDrawable * LLVOWLSky::createDrawable(LLPipeline * pipeline)
  112. {
  113. pipeline->allocDrawable(this);
  115. //LLDrawPoolWLSky *poolp = static_cast<LLDrawPoolWLSky *>(
  116. gPipeline.getPool(LLDrawPool::POOL_WL_SKY);
  118. mDrawable->setRenderType(LLPipeline::RENDER_TYPE_WL_SKY);
  120. return mDrawable;
  121. }
  123. inline F32 LLVOWLSky::calcPhi(U32 i)
  124. {
  125. // i should range from [0..SKY_STACKS] so t will range from [0.f .. 1.f]
  126. F32 t = float(i) / float(getNumStacks());
  128. // ^4 the parameter of the tesselation to bias things toward 0 (the dome's apex)
  129. t = t*t*t*t;
  131. // invert and square the parameter of the tesselation to bias things toward 1 (the horizon)
  132. t = 1.f - t;
  133. t = t*t;
  134. t = 1.f - t;
  136. return (F_PI / 8.f) * t;
  137. }
  139. #if !DOME_SLICES
  140. static const F32 Q = (1.f + sqrtf(5.f))/2.f; //golden ratio
  142. //icosahedron verts (based on asset b0c7b76e-28c6-1f87-a1de-752d5e3cd264, contact Runitai Linden for a copy)
  143. static const LLVector3 icosahedron_vert[] =
  144. {
  145. LLVector3(0,1.f,Q),
  146. LLVector3(0,-1.f,Q),
  147. LLVector3(0,-1.f,-Q),
  148. LLVector3(0,1.f,-Q),
  150. LLVector3(Q,0,1.f),
  151. LLVector3(-Q,0,1.f),
  152. LLVector3(-Q,0,-1.f),
  153. LLVector3(Q,0,-1.f),
  155. LLVector3(1,-Q,0.f),
  156. LLVector3(-1,-Q,0.f),
  157. LLVector3(-1,Q,0.f),
  158. LLVector3(1,Q,0.f),
  159. };
  161. //indices
  162. static const U32 icosahedron_ind[] = 
  163. {
  164. 5,0,1,
  165. 10,0,5,
  166. 5,1,9,
  167. 10,5,6,
  168. 6,5,9,
  169. 11,0,10,
  170. 3,11,10,
  171. 3,10,6,
  172. 3,6,2,
  173. 7,3,2,
  174. 8,7,2,
  175. 4,7,8,
  176. 1,4,8,
  177. 9,8,2,
  178. 9,2,6,
  179. 11,3,7,
  180. 4,0,11,
  181. 4,11,7,
  182. 1,0,4,
  183. 1,8,9,
  184. };
  187. //split every triangle in LLVertexBuffer into even fourths (assumes index triangle lists)
  188. void subdivide(LLVertexBuffer& in, LLVertexBuffer* ret)
  189. {
  190. S32 tri_in = in.getNumIndices()/3;
  192. ret->allocateBuffer(tri_in*4*3, tri_in*4*3, TRUE);
  194. LLStrider<LLVector3> vin, vout;
  195. LLStrider<U16> indin, indout;
  197. ret->getVertexStrider(vout);
  198. in.getVertexStrider(vin);
  200. ret->getIndexStrider(indout);
  201. in.getIndexStrider(indin);
  204. for (S32 i = 0; i < tri_in; i++)
  205. {
  206. LLVector3 v0 = vin[*indin++];
  207. LLVector3 v1 = vin[*indin++];
  208. LLVector3 v2 = vin[*indin++];
  210. LLVector3 v3 = (v0 + v1) * 0.5f;
  211. LLVector3 v4 = (v1 + v2) * 0.5f;
  212. LLVector3 v5 = (v2 + v0) * 0.5f;
  214. *vout++ = v0;
  215. *vout++ = v3;
  216. *vout++ = v5;
  218. *vout++ = v3;
  219. *vout++ = v4;
  220. *vout++ = v5;
  222. *vout++ = v3;
  223. *vout++ = v1;
  224. *vout++ = v4;
  226. *vout++ = v5;
  227. *vout++ = v4;
  228. *vout++ = v2;
  229. }
  231. for (S32 i = 0; i < ret->getNumIndices(); i++)
  232. {
  233. *indout++ = i;
  234. }
  236. }
  238. void chop(LLVertexBuffer& in, LLVertexBuffer* out)
  239. {
  240. //chop off all triangles below horizon 
  241. F32 d = LLWLParamManager::sParamMgr->getDomeOffset() * LLWLParamManager::sParamMgr->getDomeRadius();
  243. std::vector<LLVector3> vert;
  245. LLStrider<LLVector3> vin;
  246. LLStrider<U16> index;
  248. in.getVertexStrider(vin);
  249. in.getIndexStrider(index);
  251. U32 tri_count = in.getNumIndices()/3;
  252. for (U32 i = 0; i < tri_count; i++)
  253. {
  254. LLVector3 &v1 = vin[index[i*3+0]];
  255. LLVector3 &v2 = vin[index[i*3+1]];
  256. LLVector3 &v3 = vin[index[i*3+2]];
  258. if (v1.mV[1] > d ||
  259. v2.mV[1] > d ||
  260. v3.mV[1] > d)
  261. {
  262. v1.mV[1] = llmax(v1.mV[1], d);
  263. v2.mV[1] = llmax(v1.mV[1], d);
  264. v3.mV[1] = llmax(v1.mV[1], d);
  266. vert.push_back(v1);
  267. vert.push_back(v2);
  268. vert.push_back(v3);
  269. }
  270. }
  272. out->allocateBuffer(vert.size(), vert.size(), TRUE);
  274. LLStrider<LLVector3> vout;
  275. out->getVertexStrider(vout);
  276. out->getIndexStrider(index);
  278. for (U32 i = 0; i < vert.size(); i++)
  279. {
  280. *vout++ = vert[i];
  281. *index++ = i;
  282. }
  283. }
  284. #endif // !DOME_SLICES
  286. void LLVOWLSky::resetVertexBuffers()
  287. {
  288. mFanVerts = NULL;
  289. mStripsVerts.clear();
  290. mStarsVerts = NULL;
  292. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  293. }
  295. void LLVOWLSky::cleanupGL()
  296. {
  297. mFanVerts = NULL;
  298. mStripsVerts.clear();
  299. mStarsVerts = NULL;
  301. LLDrawPoolWLSky::cleanupGL();
  302. }
  304. void LLVOWLSky::restoreGL()
  305. {
  306. LLDrawPoolWLSky::restoreGL();
  307. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  308. }
  310. static LLFastTimer::DeclareTimer FTM_GEO_SKY("Sky Geometry");
  312. BOOL LLVOWLSky::updateGeometry(LLDrawable * drawable)
  313. {
  314. LLFastTimer ftm(FTM_GEO_SKY);
  315. LLStrider<LLVector3> vertices;
  316. LLStrider<LLVector2> texCoords;
  317. LLStrider<U16> indices;
  319. #if DOME_SLICES
  320. {
  321. mFanVerts = new LLVertexBuffer(LLDrawPoolWLSky::SKY_VERTEX_DATA_MASK, GL_STATIC_DRAW_ARB);
  322. mFanVerts->allocateBuffer(getFanNumVerts(), getFanNumIndices(), TRUE);
  324. BOOL success = mFanVerts->getVertexStrider(vertices)
  325. && mFanVerts->getTexCoord0Strider(texCoords)
  326. && mFanVerts->getIndexStrider(indices);
  328. if(!success) 
  329. {
  330. llerrs << "Failed updating WindLight sky geometry." << llendl;
  331. }
  333. buildFanBuffer(vertices, texCoords, indices);
  335. mFanVerts->setBuffer(0);
  336. }
  338. {
  339. const U32 max_buffer_bytes = gSavedSettings.getS32("RenderMaxVBOSize")*1024;
  340. const U32 data_mask = LLDrawPoolWLSky::SKY_VERTEX_DATA_MASK;
  341. const U32 max_verts = max_buffer_bytes / LLVertexBuffer::calcStride(data_mask);
  343. const U32 total_stacks = getNumStacks();
  345. const U32 verts_per_stack = getNumSlices();
  347. // each seg has to have one more row of verts than it has stacks
  348. // then round down
  349. const U32 stacks_per_seg = (max_verts - verts_per_stack) / verts_per_stack;
  351. // round up to a whole number of segments
  352. const U32 strips_segments = (total_stacks+stacks_per_seg-1) / stacks_per_seg;
  354. llinfos << "WL Skydome strips in " << strips_segments << " batches." << llendl;
  356. mStripsVerts.resize(strips_segments, NULL);
  358. for (U32 i = 0; i < strips_segments ;++i)
  359. {
  360. LLVertexBuffer * segment = new LLVertexBuffer(LLDrawPoolWLSky::SKY_VERTEX_DATA_MASK, GL_STATIC_DRAW_ARB);
  361. mStripsVerts[i] = segment;
  363. U32 num_stacks_this_seg = stacks_per_seg;
  364. if ((i == strips_segments - 1) && (total_stacks % stacks_per_seg) != 0)
  365. {
  366. // for the last buffer only allocate what we'll use
  367. num_stacks_this_seg = total_stacks % stacks_per_seg;
  368. }
  370. // figure out what range of the sky we're filling
  371. const U32 begin_stack = i * stacks_per_seg;
  372. const U32 end_stack = begin_stack + num_stacks_this_seg;
  373. llassert(end_stack <= total_stacks);
  375. const U32 num_verts_this_seg = verts_per_stack * (num_stacks_this_seg+1);
  376. llassert(num_verts_this_seg <= max_verts);
  378. const U32 num_indices_this_seg = 1+num_stacks_this_seg*(2+2*verts_per_stack);
  379. llassert(num_indices_this_seg * sizeof(U16) <= max_buffer_bytes);
  381. segment->allocateBuffer(num_verts_this_seg, num_indices_this_seg, TRUE);
  383. // lock the buffer
  384. BOOL success = segment->getVertexStrider(vertices)
  385. && segment->getTexCoord0Strider(texCoords)
  386. && segment->getIndexStrider(indices);
  388. if(!success) 
  389. {
  390. llerrs << "Failed updating WindLight sky geometry." << llendl;
  391. }
  393. // fill it
  394. buildStripsBuffer(begin_stack, end_stack,  vertices, texCoords, indices);
  396. // and unlock the buffer
  397. segment->setBuffer(0);
  398. }
  399. }
  400. #else
  401. mStripsVerts = new LLVertexBuffer(LLDrawPoolWLSky::SKY_VERTEX_DATA_MASK, GL_STATIC_DRAW_ARB);
  403. const F32 RADIUS = LLWLParamManager::sParamMgr->getDomeRadius();
  405. LLPointer<LLVertexBuffer> temp = new LLVertexBuffer(LLVertexBuffer::MAP_VERTEX, 0);
  406. temp->allocateBuffer(12, 60, TRUE);
  408. BOOL success = temp->getVertexStrider(vertices)
  409. && temp->getIndexStrider(indices);
  411. if (success)
  412. {
  413. for (U32 i = 0; i < 12; i++)
  414. {
  415. *vertices++ = icosahedron_vert[i];
  416. }
  418. for (U32 i = 0; i < 60; i++)
  419. {
  420. *indices++ = icosahedron_ind[i];
  421. }
  422. }
  425. LLPointer<LLVertexBuffer> temp2;
  427. for (U32 i = 0; i < 8; i++)
  428. {
  429. temp2 = new LLVertexBuffer(LLVertexBuffer::MAP_VERTEX, 0);
  430. subdivide(*temp, temp2);
  431. temp = temp2;
  432. }
  434. temp->getVertexStrider(vertices);
  435. for (S32 i = 0; i < temp->getNumVerts(); i++)
  436. {
  437. LLVector3 v = vertices[i];
  438. v.normVec();
  439. vertices[i] = v*RADIUS;
  440. }
  442. temp2 = new LLVertexBuffer(LLVertexBuffer::MAP_VERTEX, 0);
  443. chop(*temp, temp2);
  445. mStripsVerts->allocateBuffer(temp2->getNumVerts(), temp2->getNumIndices(), TRUE);
  447. success = mStripsVerts->getVertexStrider(vertices)
  448. && mStripsVerts->getTexCoordStrider(texCoords)
  449. && mStripsVerts->getIndexStrider(indices);
  451. LLStrider<LLVector3> v;
  452. temp2->getVertexStrider(v);
  453. LLStrider<U16> ind;
  454. temp2->getIndexStrider(ind);
  456. if (success)
  457. {
  458. for (S32 i = 0; i < temp2->getNumVerts(); ++i)
  459. {
  460. LLVector3 vert = *v++;
  461. vert.normVec();
  462. F32 z0 = vert.mV[2];
  463. F32 x0 = vert.mV[0];
  465. vert *= RADIUS;
  467. *vertices++ = vert;
  468. *texCoords++ = LLVector2((-z0 + 1.f) / 2.f, (-x0 + 1.f) / 2.f);
  469. }
  471. for (S32 i = 0; i < temp2->getNumIndices(); ++i)
  472. {
  473. *indices++ = *ind++;
  474. }
  475. }
  477. mStripsVerts->setBuffer(0);
  478. #endif
  480. updateStarColors();
  481. updateStarGeometry(drawable);
  483. LLPipeline::sCompiles++;
  485. return TRUE;
  486. }
  488. void LLVOWLSky::drawStars(void)
  489. {
  490. //  render the stars as a sphere centered at viewer camera 
  491. if (mStarsVerts.notNull())
  492. {
  493. mStarsVerts->setBuffer(LLDrawPoolWLSky::STAR_VERTEX_DATA_MASK);
  494. mStarsVerts->drawArrays(LLRender::QUADS, 0, getStarsNumVerts()*4);
  495. }
  496. }
  498. void LLVOWLSky::drawDome(void)
  499. {
  500. if (mStripsVerts.empty())
  501. {
  502. updateGeometry(mDrawable);
  503. }
  505. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  507. const U32 data_mask = LLDrawPoolWLSky::SKY_VERTEX_DATA_MASK;
  509. #if DOME_SLICES
  510. std::vector< LLPointer<LLVertexBuffer> >::const_iterator strips_vbo_iter, end_strips;
  511. end_strips = mStripsVerts.end();
  512. for(strips_vbo_iter = mStripsVerts.begin(); strips_vbo_iter != end_strips; ++strips_vbo_iter)
  513. {
  514. LLVertexBuffer * strips_segment = strips_vbo_iter->get();
  516. strips_segment->setBuffer(data_mask);
  518. strips_segment->drawRange(
  519. LLRender::TRIANGLE_STRIP, 
  520. 0, strips_segment->getRequestedVerts()-1, strips_segment->getRequestedIndices(), 
  521. 0);
  522. gPipeline.addTrianglesDrawn(strips_segment->getRequestedIndices() - 2);
  523. }
  525. #else
  526. mStripsVerts->setBuffer(data_mask);
  527. glDrawRangeElements(
  528. GL_TRIANGLES,
  529. 0, mStripsVerts->getNumVerts()-1, mStripsVerts->getNumIndices(),
  530. GL_UNSIGNED_SHORT,
  531. mStripsVerts->getIndicesPointer());
  532. #endif
  534. LLVertexBuffer::unbind();
  535. }
  537. void LLVOWLSky::initStars()
  538. {
  539. // Initialize star map
  540. mStarVertices.resize(getStarsNumVerts());
  541. mStarColors.resize(getStarsNumVerts());
  542. mStarIntensities.resize(getStarsNumVerts());
  544. std::vector<LLVector3>::iterator v_p = mStarVertices.begin();
  545. std::vector<LLColor4>::iterator v_c = mStarColors.begin();
  546. std::vector<F32>::iterator v_i = mStarIntensities.begin();
  548. U32 i;
  550. for (i = 0; i < getStarsNumVerts(); ++i)
  551. {
  552. v_p->mV[VX] = ll_frand() - 0.5f;
  553. v_p->mV[VY] = ll_frand() - 0.5f;
  555. // we only want stars on the top half of the dome!
  557. v_p->mV[VZ] = ll_frand()/2.f;
  559. v_p->normVec();
  560. *v_p *= DISTANCE_TO_STARS;
  561. *v_i = llmin((F32)pow(ll_frand(),2.f) + 0.1f, 1.f);
  562. v_c->mV[VRED]   = 0.75f + ll_frand() * 0.25f ;
  563. v_c->mV[VGREEN] = 1.f ;
  564. v_c->mV[VBLUE]  = 0.75f + ll_frand() * 0.25f ;
  565. v_c->mV[VALPHA] = 1.f;
  566. v_c->clamp();
  567. v_p++;
  568. v_c++;
  569. v_i++;
  570. }
  571. }
  573. void LLVOWLSky::buildFanBuffer(LLStrider<LLVector3> & vertices,
  574.    LLStrider<LLVector2> & texCoords,
  575.    LLStrider<U16> & indices)
  576. {
  577. const F32 RADIUS = LLWLParamManager::instance()->getDomeRadius();
  579. U32 i, num_slices;
  580. F32 phi0, theta, x0, y0, z0;
  582. // paranoia checking for SL-55986/SL-55833
  583. U32 count_verts = 0;
  584. U32 count_indices = 0;
  586. // apex
  587. *vertices++ = LLVector3(0.f, RADIUS, 0.f);
  588. *texCoords++ = LLVector2(0.5f, 0.5f);
  589. ++count_verts;
  591. num_slices = getNumSlices();
  593. // and fan in a circle around the apex
  594. phi0 = calcPhi(1);
  595. for(i = 0; i < num_slices; ++i) {
  596. theta = 2.f * F_PI * float(i) / float(num_slices);
  598. // standard transformation from  spherical to
  599. // rectangular coordinates
  600. x0 = sin(phi0) * cos(theta);
  601. y0 = cos(phi0);
  602. z0 = sin(phi0) * sin(theta);
  604. *vertices++ = LLVector3(x0 * RADIUS, y0 * RADIUS, z0 * RADIUS);
  605. // generate planar uv coordinates
  606. // note: x and z are transposed in order for things to animate
  607. // correctly in the global coordinate system where +x is east and
  608. // +y is north
  609. *texCoords++ = LLVector2((-z0 + 1.f) / 2.f, (-x0 + 1.f) / 2.f);
  610. ++count_verts;
  612. if (i > 0)
  613. {
  614. *indices++ = 0;
  615. *indices++ = i;
  616. *indices++ = i+1;
  617. count_indices += 3;
  618. }
  619. }
  621. // the last vertex of the last triangle should wrap around to 
  622. // the beginning
  623. *indices++ = 0;
  624. *indices++ = num_slices;
  625. *indices++ = 1;
  626. count_indices += 3;
  628. // paranoia checking for SL-55986/SL-55833
  629. llassert(getFanNumVerts() == count_verts);
  630. llassert(getFanNumIndices() == count_indices);
  631. }
  633. void LLVOWLSky::buildStripsBuffer(U32 begin_stack, U32 end_stack,
  634.   LLStrider<LLVector3> & vertices,
  635.   LLStrider<LLVector2> & texCoords,
  636.   LLStrider<U16> & indices)
  637. {
  638. const F32 RADIUS = LLWLParamManager::instance()->getDomeRadius();
  640. U32 i, j, num_slices, num_stacks;
  641. F32 phi0, theta, x0, y0, z0;
  643. // paranoia checking for SL-55986/SL-55833
  644. U32 count_verts = 0;
  645. U32 count_indices = 0;
  647. num_slices = getNumSlices();
  648. num_stacks = getNumStacks();
  650. llassert(end_stack <= num_stacks);
  652. // stacks are iterated one-indexed since phi(0) was handled by the fan above
  653. for(i = begin_stack + 1; i <= end_stack+1; ++i) 
  654. {
  655. phi0 = calcPhi(i);
  657. for(j = 0; j < num_slices; ++j)
  658. {
  659. theta = F_TWO_PI * (float(j) / float(num_slices));
  661. // standard transformation from  spherical to
  662. // rectangular coordinates
  663. x0 = sin(phi0) * cos(theta);
  664. y0 = cos(phi0);
  665. z0 = sin(phi0) * sin(theta);
  667. if (i == num_stacks-2)
  668. {
  669. *vertices++ = LLVector3(x0*RADIUS, y0*RADIUS-1024.f*2.f, z0*RADIUS);
  670. }
  671. else if (i == num_stacks-1)
  672. {
  673. *vertices++ = LLVector3(0, y0*RADIUS-1024.f*2.f, 0);
  674. }
  675. else
  676. {
  677. *vertices++ = LLVector3(x0 * RADIUS, y0 * RADIUS, z0 * RADIUS);
  678. }
  679. ++count_verts;
  681. // generate planar uv coordinates
  682. // note: x and z are transposed in order for things to animate
  683. // correctly in the global coordinate system where +x is east and
  684. // +y is north
  685. *texCoords++ = LLVector2((-z0 + 1.f) / 2.f, (-x0 + 1.f) / 2.f);
  686. }
  687. }
  689. //build triangle strip...
  690. *indices++ = 0 ;
  691. count_indices++ ;
  692. S32 k = 0 ;
  693. for(i = 1; i <= end_stack - begin_stack; ++i) 
  694. {
  695. *indices++ = i * num_slices + k ;
  696. count_indices++ ;
  698. k = (k+1) % num_slices ;
  699. for(j = 0; j < num_slices ; ++j) 
  700. {
  701. *indices++ = (i-1) * num_slices + k ;
  702. *indices++ = i * num_slices + k ;
  704. count_indices += 2 ;
  706. k = (k+1) % num_slices ;
  707. }
  709. if((--k) < 0)
  710. {
  711. k = num_slices - 1 ;
  712. }
  714. *indices++ = i * num_slices + k ;
  715. count_indices++ ;
  716. }
  717. }
  719. void LLVOWLSky::updateStarColors()
  720. {
  721. std::vector<LLColor4>::iterator v_c = mStarColors.begin();
  722. std::vector<F32>::iterator v_i = mStarIntensities.begin();
  723. std::vector<LLVector3>::iterator v_p = mStarVertices.begin();
  725. const F32 var = 0.15f;
  726. const F32 min = 0.5f; //0.75f;
  727. const F32 sunclose_max = 0.6f;
  728. const F32 sunclose_range = 1 - sunclose_max;
  730. //F32 below_horizon = - llmin(0.0f, gSky.mVOSkyp->getToSunLast().mV[2]);
  731. //F32 brightness_factor = llmin(1.0f, below_horizon * 20);
  733. static S32 swap = 0;
  734. swap++;
  736. if ((swap % 2) == 1)
  737. {
  738. F32 intensity; //  max intensity of each star
  739. U32 x;
  740. for (x = 0; x < getStarsNumVerts(); ++x)
  741. {
  742. F32 sundir_factor = 1;
  743. LLVector3 tostar = *v_p;
  744. tostar.normVec();
  745. const F32 how_close_to_sun = tostar * gSky.mVOSkyp->getToSunLast();
  746. if (how_close_to_sun > sunclose_max)
  747. {
  748. sundir_factor = (1 - how_close_to_sun) / sunclose_range;
  749. }
  750. intensity = *(v_i);
  751. F32 alpha = v_c->mV[VALPHA] + (ll_frand() - 0.5f) * var * intensity;
  752. if (alpha < min * intensity)
  753. {
  754. alpha = min * intensity;
  755. }
  756. if (alpha > intensity)
  757. {
  758. alpha = intensity;
  759. }
  760. //alpha *= brightness_factor * sundir_factor;
  762. alpha = llclamp(alpha, 0.f, 1.f);
  763. v_c->mV[VALPHA] = alpha;
  764. v_c++;
  765. v_i++;
  766. v_p++;
  767. }
  768. }
  769. }
  771. BOOL LLVOWLSky::updateStarGeometry(LLDrawable *drawable)
  772. {
  773. LLStrider<LLVector3> verticesp;
  774. LLStrider<LLColor4U> colorsp;
  775. LLStrider<LLVector2> texcoordsp;
  777. if (mStarsVerts.isNull())
  778. {
  779. mStarsVerts = new LLVertexBuffer(LLDrawPoolWLSky::STAR_VERTEX_DATA_MASK, GL_DYNAMIC_DRAW);
  780. mStarsVerts->allocateBuffer(getStarsNumVerts()*4, 0, TRUE);
  781. }
  782.  
  783. BOOL success = mStarsVerts->getVertexStrider(verticesp)
  784. && mStarsVerts->getColorStrider(colorsp)
  785. && mStarsVerts->getTexCoord0Strider(texcoordsp);
  787. if(!success)
  788. {
  789. llerrs << "Failed updating star geometry." << llendl;
  790. }
  792. // *TODO: fix LLStrider with a real prefix increment operator so it can be
  793. // used as a model of OutputIterator. -Brad
  794. // std::copy(mStarVertices.begin(), mStarVertices.end(), verticesp);
  796. if (mStarVertices.size() < getStarsNumVerts())
  797. {
  798. llerrs << "Star reference geometry insufficient." << llendl;
  799. }
  801. for (U32 vtx = 0; vtx < getStarsNumVerts(); ++vtx)
  802. {
  803. LLVector3 at = mStarVertices[vtx];
  804. at.normVec();
  805. LLVector3 left = at%LLVector3(0,0,1);
  806. LLVector3 up = at%left;
  808. F32 sc = 0.5f+ll_frand()*1.25f;
  809. left *= sc;
  810. up *= sc;
  812. *(verticesp++)  = mStarVertices[vtx];
  813. *(verticesp++) = mStarVertices[vtx]+left;
  814. *(verticesp++) = mStarVertices[vtx]+left+up;
  815. *(verticesp++) = mStarVertices[vtx]+up;
  817. *(texcoordsp++) = LLVector2(0,0);
  818. *(texcoordsp++) = LLVector2(0,1);
  819. *(texcoordsp++) = LLVector2(1,1);
  820. *(texcoordsp++) = LLVector2(1,0);
  822. *(colorsp++)    = LLColor4U(mStarColors[vtx]);
  823. *(colorsp++)    = LLColor4U(mStarColors[vtx]);
  824. *(colorsp++)    = LLColor4U(mStarColors[vtx]);
  825. *(colorsp++)    = LLColor4U(mStarColors[vtx]);
  826. }
  828. mStarsVerts->setBuffer(0);
  829. return TRUE;
  830. }