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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llsprite.cpp
  3.  * @brief LLSprite class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2000&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2000-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. /* -*- c++ -*-
  33.  * Notes:
  34.  * PR - Should add a creator that can take a pointer rather than handle for streaming 
  35.  * object textures.
  36.  * PR - Need to add support for lit/non-lit conditions, set normals?
  37.  */
  38. #include "llviewerprecompiledheaders.h"
  39. #include <llglheaders.h>
  40. #include "llsprite.h"
  41. #include "math.h"
  42. #include "lldrawable.h"
  43. #include "llface.h"
  44. #include "llviewercamera.h"
  45. #include "llviewertexturelist.h"
  46. LLVector3 LLSprite::sCameraUp(0.0f,0.0f,1.0f);
  47. LLVector3 LLSprite::sCameraRight(1.0f,0.0f,0.0f);
  48. LLVector3 LLSprite::sCameraPosition(0.f, 0.f, 0.f);
  49. LLVector3 LLSprite::sNormal(0.0f,0.0f,0.0f);
  50. //////////////////////////////////////////////////////////////////////
  51. // Construction/Destruction
  52. //////////////////////////////////////////////////////////////////////
  53. // A simple initialization
  54. LLSprite::LLSprite(const LLUUID &image_uuid) :
  55. mImageID(image_uuid),
  56. mImagep(NULL),
  57. mPitch(0.f),
  58. mYaw(0.f),
  59. mPosition(0.0f, 0.0f, 0.0f),
  60. mFollow(TRUE),
  61. mUseCameraUp(TRUE),
  62. mColor(0.5f, 0.5f, 0.5f, 1.0f),
  63. mTexMode(GL_REPLACE)
  64. {
  65. setSize(1.0f, 1.0f);
  66. }
  67. //////////////////////////////////////////////////////////////////////
  68. LLSprite::~LLSprite()
  69. {
  70. }
  71. void LLSprite::updateFace(LLFace &face)
  72. {
  73. LLViewerCamera &camera = *LLViewerCamera::getInstance();
  74. // First, figure out how many vertices/indices we need.
  75. U32 num_vertices, num_indices;
  76. U32 vertex_count = 0;
  77. // Get the total number of vertices and indices
  78. if (mFollow)
  79. {
  80. num_vertices = 4;
  81. num_indices = 6;
  82. }
  83. else
  84. {
  85. num_vertices = 4;
  86. num_indices = 12;
  87. }
  88. face.setSize(num_vertices, num_indices);
  89. if (mFollow) 
  90. {
  91. sCameraUp = camera.getUpAxis();
  92. sCameraRight = -camera.getLeftAxis();
  93. sCameraPosition = camera.getOrigin();
  94. sNormal = -camera.getAtAxis();
  95. if (mUseCameraUp)
  96. {
  97. // these need to live here because the height/width may change between render calls
  98. mScaledUp = sCameraUp;
  99. mScaledRight = sCameraRight;
  100. mScaledUp *= mHeightDiv2;
  101. mScaledRight *= mWidthDiv2;
  102. mA = mPosition + mScaledRight + mScaledUp;
  103. mB = mPosition - mScaledRight + mScaledUp;
  104. mC = mPosition - mScaledRight - mScaledUp;
  105. mD = mPosition + mScaledRight - mScaledUp;
  106. }
  107. else
  108. {
  109. // The up vector is perpendicular to the camera vector...
  110. LLVector3 camera_vec = mPosition - sCameraPosition;
  111. mScaledRight = camera_vec % LLVector3(0.f, 0.f, 1.f);
  112. mScaledUp = -(camera_vec % mScaledRight);
  113. mScaledUp.normalize();
  114. mScaledRight.normalize();
  115. mScaledUp *= mHeightDiv2;
  116. mScaledRight *= mWidthDiv2;
  117. mA = mPosition + mScaledRight + mScaledUp;
  118. mB = mPosition - mScaledRight + mScaledUp;
  119. mC = mPosition - mScaledRight - mScaledUp;
  120. mD = mPosition + mScaledRight - mScaledUp;
  121. }
  122. }
  123. else
  124. {
  125. // this is equivalent to how it was done before. . . 
  126. // we need to establish a way to 
  127. // identify the orientation of a particular sprite rather than
  128. // just banging it in on the x,z plane if it's not following the camera.
  129. LLVector3 x_axis;
  130. LLVector3 y_axis;
  131. F32 dot = sNormal * LLVector3(0.f, 1.f, 0.f);
  132. if (dot == 1.f || dot == -1.f)
  133. {
  134. x_axis.setVec(1.f, 0.f, 0.f);
  135. y_axis.setVec(0.f, 1.f, 0.f);
  136. }
  137. else
  138. {
  139. x_axis = sNormal % LLVector3(0.f, -1.f, 0.f);
  140. x_axis.normalize();
  141. y_axis = sNormal % x_axis;
  142. }
  143. LLQuaternion yaw_rot(mYaw, sNormal);
  144. // rotate axes by specified yaw
  145. x_axis = x_axis * yaw_rot;
  146. y_axis = y_axis * yaw_rot;
  147. // rescale axes by width and height of sprite
  148. x_axis = x_axis * mWidthDiv2;
  149. y_axis = y_axis *  mHeightDiv2;
  150. mA = -x_axis + y_axis;
  151. mB = x_axis + y_axis;
  152. mC = x_axis - y_axis;
  153. mD = -x_axis - y_axis;
  154. mA += mPosition;
  155. mB += mPosition;
  156. mC += mPosition;
  157. mD += mPosition;
  158. }
  159. face.setFaceColor(mColor);
  160. LLStrider<LLVector3> verticesp;
  161. LLStrider<LLVector3> normalsp;
  162. LLStrider<LLVector2> tex_coordsp;
  163. LLStrider<U16> indicesp;
  164. U16 index_offset;
  165. // Setup face
  166. if (face.mVertexBuffer.isNull())
  167. {
  168. face.mVertexBuffer = new LLVertexBuffer(LLVertexBuffer::MAP_VERTEX | 
  169. LLVertexBuffer::MAP_TEXCOORD0,
  170. GL_STREAM_DRAW_ARB);
  171. face.mVertexBuffer->allocateBuffer(4, 12, TRUE);
  172. face.setGeomIndex(0);
  173. face.setIndicesIndex(0);
  174. }
  175. index_offset = face.getGeometry(verticesp,normalsp,tex_coordsp, indicesp);
  176. *tex_coordsp = LLVector2(0.f, 0.f);
  177. *verticesp = mC;
  178. tex_coordsp++;
  179. verticesp++;
  180. vertex_count++;
  181. *tex_coordsp = LLVector2(0.f, 1.f);
  182. *verticesp = mB;
  183. tex_coordsp++;
  184. verticesp++;
  185. vertex_count++;
  186. *tex_coordsp = LLVector2(1.f, 1.f);
  187. *verticesp = mA;
  188. tex_coordsp++;
  189. verticesp++;
  190. vertex_count++;
  191. *tex_coordsp = LLVector2(1.f, 0.0f);
  192. *verticesp = mD;
  193. tex_coordsp++;
  194. verticesp++;
  195. vertex_count++;
  196. // Generate indices, since they're easy.
  197. // Just a series of quads.
  198. *indicesp++ = index_offset;
  199. *indicesp++ = 2 + index_offset;
  200. *indicesp++ = 1 + index_offset;
  201. *indicesp++ = index_offset;
  202. *indicesp++ = 3 + index_offset;
  203. *indicesp++ = 2 + index_offset;
  204. if (!mFollow)
  205. {
  206. *indicesp++ = 0 + index_offset;
  207. *indicesp++ = 1 + index_offset;
  208. *indicesp++ = 2 + index_offset;
  209. *indicesp++ = 0 + index_offset;
  210. *indicesp++ = 2 + index_offset;
  211. *indicesp++ = 3 + index_offset;
  212. }
  213. face.mVertexBuffer->setBuffer(0);
  214. face.mCenterAgent = mPosition;
  215. }
  216. void LLSprite::setPosition(const LLVector3 &position) 
  217. {
  218. mPosition = position; 
  219. }
  220. void LLSprite::setPitch(const F32 pitch) 
  221. {
  222. mPitch = pitch; 
  223. }
  224. void LLSprite::setSize(const F32 width, const F32 height) 
  225. {
  226. mWidth = width; 
  227. mHeight = height;
  228. mWidthDiv2 = width/2.0f;
  229. mHeightDiv2 = height/2.0f;
  230. }
  231. void LLSprite::setYaw(F32 yaw) 
  232. {
  233. mYaw = yaw; 
  234. }
  235. void LLSprite::setFollow(const BOOL follow)
  236. {
  237. mFollow = follow; 
  238. }
  239. void LLSprite::setUseCameraUp(const BOOL use_up)
  240. {
  241. mUseCameraUp = use_up; 
  242. }
  243. void LLSprite::setTexMode(const LLGLenum mode) 
  244. {
  245. mTexMode = mode; 
  246. }
  247. void LLSprite::setColor(const LLColor4 &color)
  248. {
  249. mColor = color; 
  250. }
  251. void LLSprite::setColor(const F32 r, const F32 g, const F32 b, const F32 a)
  252. {
  253. mColor.setVec(r, g, b, a);
  254. }