[5] | 1 | /* |
---|
| 2 | ----------------------------------------------------------------------------- |
---|
| 3 | This source file is part of OGRE |
---|
| 4 | (Object-oriented Graphics Rendering Engine) |
---|
| 5 | For the latest info, see http://www.ogre3d.org/ |
---|
| 6 | |
---|
| 7 | Copyright (c) 2000-2006 Torus Knot Software Ltd |
---|
| 8 | Also see acknowledgements in Readme.html |
---|
| 9 | |
---|
| 10 | This program is free software; you can redistribute it and/or modify it under |
---|
| 11 | the terms of the GNU Lesser General Public License as published by the Free Software |
---|
| 12 | Foundation; either version 2 of the License, or (at your option) any later |
---|
| 13 | version. |
---|
| 14 | |
---|
| 15 | This program is distributed in the hope that it will be useful, but WITHOUT |
---|
| 16 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
---|
| 17 | FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. |
---|
| 18 | |
---|
| 19 | You should have received a copy of the GNU Lesser General Public License along with |
---|
| 20 | this program; if not, write to the Free Software Foundation, Inc., 59 Temple |
---|
| 21 | Place - Suite 330, Boston, MA 02111-1307, USA, or go to |
---|
| 22 | http://www.gnu.org/copyleft/lesser.txt. |
---|
| 23 | |
---|
| 24 | You may alternatively use this source under the terms of a specific version of |
---|
| 25 | the OGRE Unrestricted License provided you have obtained such a license from |
---|
| 26 | Torus Knot Software Ltd. |
---|
| 27 | ----------------------------------------------------------------------------- |
---|
| 28 | */ |
---|
| 29 | #include "OgreStableHeaders.h" |
---|
| 30 | |
---|
| 31 | #include "OgreBillboardParticleRenderer.h" |
---|
| 32 | #include "OgreParticle.h" |
---|
| 33 | #include "OgreStringConverter.h" |
---|
| 34 | |
---|
| 35 | namespace Ogre { |
---|
| 36 | String rendererTypeName = "billboard"; |
---|
| 37 | |
---|
| 38 | //----------------------------------------------------------------------- |
---|
| 39 | BillboardParticleRenderer::CmdBillboardType BillboardParticleRenderer::msBillboardTypeCmd; |
---|
| 40 | BillboardParticleRenderer::CmdBillboardOrigin BillboardParticleRenderer::msBillboardOriginCmd; |
---|
| 41 | BillboardParticleRenderer::CmdBillboardRotationType BillboardParticleRenderer::msBillboardRotationTypeCmd; |
---|
| 42 | BillboardParticleRenderer::CmdCommonDirection BillboardParticleRenderer::msCommonDirectionCmd; |
---|
| 43 | BillboardParticleRenderer::CmdCommonUpVector BillboardParticleRenderer::msCommonUpVectorCmd; |
---|
| 44 | BillboardParticleRenderer::CmdPointRendering BillboardParticleRenderer::msPointRenderingCmd; |
---|
| 45 | BillboardParticleRenderer::CmdAccurateFacing BillboardParticleRenderer::msAccurateFacingCmd; |
---|
| 46 | //----------------------------------------------------------------------- |
---|
| 47 | BillboardParticleRenderer::BillboardParticleRenderer() |
---|
| 48 | { |
---|
| 49 | if (createParamDictionary("BillboardParticleRenderer")) |
---|
| 50 | { |
---|
| 51 | ParamDictionary* dict = getParamDictionary(); |
---|
| 52 | dict->addParameter(ParameterDef("billboard_type", |
---|
| 53 | "The type of billboard to use. 'point' means a simulated spherical particle, " |
---|
| 54 | "'oriented_common' means all particles in the set are oriented around common_direction, " |
---|
| 55 | "'oriented_self' means particles are oriented around their own direction, " |
---|
| 56 | "'perpendicular_common' means all particles are perpendicular to common_direction, " |
---|
| 57 | "and 'perpendicular_self' means particles are perpendicular to their own direction.", |
---|
| 58 | PT_STRING), |
---|
| 59 | &msBillboardTypeCmd); |
---|
| 60 | |
---|
| 61 | dict->addParameter(ParameterDef("billboard_origin", |
---|
| 62 | "This setting controls the fine tuning of where a billboard appears in relation to it's position. " |
---|
| 63 | "Possible value are: 'top_left', 'top_center', 'top_right', 'center_left', 'center', 'center_right', " |
---|
| 64 | "'bottom_left', 'bottom_center' and 'bottom_right'. Default value is 'center'.", |
---|
| 65 | PT_STRING), |
---|
| 66 | &msBillboardOriginCmd); |
---|
| 67 | |
---|
| 68 | dict->addParameter(ParameterDef("billboard_rotation_type", |
---|
| 69 | "This setting controls the billboard rotation type. " |
---|
| 70 | "'vertex' means rotate the billboard's vertices around their facing direction." |
---|
| 71 | "'texcoord' means rotate the billboard's texture coordinates. Default value is 'texcoord'.", |
---|
| 72 | PT_STRING), |
---|
| 73 | &msBillboardRotationTypeCmd); |
---|
| 74 | |
---|
| 75 | dict->addParameter(ParameterDef("common_direction", |
---|
| 76 | "Only useful when billboard_type is oriented_common or perpendicular_common. " |
---|
| 77 | "When billboard_type is oriented_common, this parameter sets the common orientation for " |
---|
| 78 | "all particles in the set (e.g. raindrops may all be oriented downwards). " |
---|
| 79 | "When billboard_type is perpendicular_common, this parameter sets the perpendicular vector for " |
---|
| 80 | "all particles in the set (e.g. an aureola around the player and parallel to the ground).", |
---|
| 81 | PT_VECTOR3), |
---|
| 82 | &msCommonDirectionCmd); |
---|
| 83 | |
---|
| 84 | dict->addParameter(ParameterDef("common_up_vector", |
---|
| 85 | "Only useful when billboard_type is perpendicular_self or perpendicular_common. This " |
---|
| 86 | "parameter sets the common up-vector for all particles in the set (e.g. an aureola around " |
---|
| 87 | "the player and parallel to the ground).", |
---|
| 88 | PT_VECTOR3), |
---|
| 89 | &msCommonUpVectorCmd); |
---|
| 90 | dict->addParameter(ParameterDef("point_rendering", |
---|
| 91 | "Set whether or not particles will use point rendering " |
---|
| 92 | "rather than manually generated quads. This allows for faster " |
---|
| 93 | "rendering of point-oriented particles although introduces some " |
---|
| 94 | "limitations too such as requiring a common particle size." |
---|
| 95 | "Possible values are 'true' or 'false'.", |
---|
| 96 | PT_BOOL), |
---|
| 97 | &msPointRenderingCmd); |
---|
| 98 | dict->addParameter(ParameterDef("accurate_facing", |
---|
| 99 | "Set whether or not particles will be oriented to the camera " |
---|
| 100 | "based on the relative position to the camera rather than just " |
---|
| 101 | "the camera direction. This is more accurate but less optimal. " |
---|
| 102 | "Cannot be combined with point rendering.", |
---|
| 103 | PT_BOOL), |
---|
| 104 | &msAccurateFacingCmd); |
---|
| 105 | } |
---|
| 106 | |
---|
| 107 | // Create billboard set |
---|
| 108 | mBillboardSet = new BillboardSet("", 0, true); |
---|
| 109 | // World-relative axes |
---|
| 110 | mBillboardSet->setBillboardsInWorldSpace(true); |
---|
| 111 | } |
---|
| 112 | //----------------------------------------------------------------------- |
---|
| 113 | BillboardParticleRenderer::~BillboardParticleRenderer() |
---|
| 114 | { |
---|
| 115 | delete mBillboardSet; |
---|
| 116 | } |
---|
| 117 | //----------------------------------------------------------------------- |
---|
| 118 | const String& BillboardParticleRenderer::getType(void) const |
---|
| 119 | { |
---|
| 120 | return rendererTypeName; |
---|
| 121 | } |
---|
| 122 | //----------------------------------------------------------------------- |
---|
| 123 | void BillboardParticleRenderer::_updateRenderQueue(RenderQueue* queue, |
---|
| 124 | std::list<Particle*>& currentParticles, bool cullIndividually) |
---|
| 125 | { |
---|
| 126 | mBillboardSet->setCullIndividually(cullIndividually); |
---|
| 127 | |
---|
| 128 | // Update billboard set geometry |
---|
| 129 | mBillboardSet->beginBillboards(currentParticles.size()); |
---|
| 130 | Billboard bb; |
---|
| 131 | for (std::list<Particle*>::iterator i = currentParticles.begin(); |
---|
| 132 | i != currentParticles.end(); ++i) |
---|
| 133 | { |
---|
| 134 | Particle* p = *i; |
---|
| 135 | bb.mPosition = p->position; |
---|
| 136 | if (mBillboardSet->getBillboardType() == BBT_ORIENTED_SELF || |
---|
| 137 | mBillboardSet->getBillboardType() == BBT_PERPENDICULAR_SELF) |
---|
| 138 | { |
---|
| 139 | // Normalise direction vector |
---|
| 140 | bb.mDirection = p->direction; |
---|
| 141 | bb.mDirection.normalise(); |
---|
| 142 | } |
---|
| 143 | bb.mColour = p->colour; |
---|
| 144 | bb.mRotation = p->rotation; |
---|
| 145 | // Assign and compare at the same time |
---|
| 146 | if (bb.mOwnDimensions = p->mOwnDimensions) |
---|
| 147 | { |
---|
| 148 | bb.mWidth = p->mWidth; |
---|
| 149 | bb.mHeight = p->mHeight; |
---|
| 150 | } |
---|
| 151 | mBillboardSet->injectBillboard(bb); |
---|
| 152 | |
---|
| 153 | } |
---|
| 154 | |
---|
| 155 | mBillboardSet->endBillboards(); |
---|
| 156 | |
---|
| 157 | // Update the queue |
---|
| 158 | mBillboardSet->_updateRenderQueue(queue); |
---|
| 159 | } |
---|
| 160 | //----------------------------------------------------------------------- |
---|
| 161 | void BillboardParticleRenderer::_setMaterial(MaterialPtr& mat) |
---|
| 162 | { |
---|
| 163 | mBillboardSet->setMaterialName(mat->getName()); |
---|
| 164 | } |
---|
| 165 | //----------------------------------------------------------------------- |
---|
| 166 | void BillboardParticleRenderer::setBillboardType(BillboardType bbt) |
---|
| 167 | { |
---|
| 168 | mBillboardSet->setBillboardType(bbt); |
---|
| 169 | } |
---|
| 170 | //----------------------------------------------------------------------- |
---|
| 171 | void BillboardParticleRenderer::setUseAccurateFacing(bool acc) |
---|
| 172 | { |
---|
| 173 | mBillboardSet->setUseAccurateFacing(acc); |
---|
| 174 | } |
---|
| 175 | //----------------------------------------------------------------------- |
---|
| 176 | bool BillboardParticleRenderer::getUseAccurateFacing(void) const |
---|
| 177 | { |
---|
| 178 | return mBillboardSet->getUseAccurateFacing(); |
---|
| 179 | } |
---|
| 180 | //----------------------------------------------------------------------- |
---|
| 181 | BillboardType BillboardParticleRenderer::getBillboardType(void) const |
---|
| 182 | { |
---|
| 183 | return mBillboardSet->getBillboardType(); |
---|
| 184 | } |
---|
| 185 | //----------------------------------------------------------------------- |
---|
| 186 | void BillboardParticleRenderer::setBillboardRotationType(BillboardRotationType rotationType) |
---|
| 187 | { |
---|
| 188 | mBillboardSet->setBillboardRotationType(rotationType); |
---|
| 189 | } |
---|
| 190 | //----------------------------------------------------------------------- |
---|
| 191 | BillboardRotationType BillboardParticleRenderer::getBillboardRotationType(void) const |
---|
| 192 | { |
---|
| 193 | return mBillboardSet->getBillboardRotationType(); |
---|
| 194 | } |
---|
| 195 | //----------------------------------------------------------------------- |
---|
| 196 | void BillboardParticleRenderer::setCommonDirection(const Vector3& vec) |
---|
| 197 | { |
---|
| 198 | mBillboardSet->setCommonDirection(vec); |
---|
| 199 | } |
---|
| 200 | //----------------------------------------------------------------------- |
---|
| 201 | const Vector3& BillboardParticleRenderer::getCommonDirection(void) const |
---|
| 202 | { |
---|
| 203 | return mBillboardSet->getCommonDirection(); |
---|
| 204 | } |
---|
| 205 | //----------------------------------------------------------------------- |
---|
| 206 | void BillboardParticleRenderer::setCommonUpVector(const Vector3& vec) |
---|
| 207 | { |
---|
| 208 | mBillboardSet->setCommonUpVector(vec); |
---|
| 209 | } |
---|
| 210 | //----------------------------------------------------------------------- |
---|
| 211 | const Vector3& BillboardParticleRenderer::getCommonUpVector(void) const |
---|
| 212 | { |
---|
| 213 | return mBillboardSet->getCommonUpVector(); |
---|
| 214 | } |
---|
| 215 | //----------------------------------------------------------------------- |
---|
| 216 | void BillboardParticleRenderer::_notifyCurrentCamera(Camera* cam) |
---|
| 217 | { |
---|
| 218 | mBillboardSet->_notifyCurrentCamera(cam); |
---|
| 219 | } |
---|
| 220 | //----------------------------------------------------------------------- |
---|
| 221 | void BillboardParticleRenderer::_notifyParticleRotated(void) |
---|
| 222 | { |
---|
| 223 | mBillboardSet->_notifyBillboardRotated(); |
---|
| 224 | } |
---|
| 225 | //----------------------------------------------------------------------- |
---|
| 226 | void BillboardParticleRenderer::_notifyDefaultDimensions(Real width, Real height) |
---|
| 227 | { |
---|
| 228 | mBillboardSet->setDefaultDimensions(width, height); |
---|
| 229 | } |
---|
| 230 | //----------------------------------------------------------------------- |
---|
| 231 | void BillboardParticleRenderer::_notifyParticleResized(void) |
---|
| 232 | { |
---|
| 233 | mBillboardSet->_notifyBillboardResized(); |
---|
| 234 | } |
---|
| 235 | //----------------------------------------------------------------------- |
---|
| 236 | void BillboardParticleRenderer::_notifyParticleQuota(size_t quota) |
---|
| 237 | { |
---|
| 238 | mBillboardSet->setPoolSize(quota); |
---|
| 239 | } |
---|
| 240 | //----------------------------------------------------------------------- |
---|
| 241 | void BillboardParticleRenderer::_notifyAttached(Node* parent, bool isTagPoint) |
---|
| 242 | { |
---|
| 243 | mBillboardSet->_notifyAttached(parent, isTagPoint); |
---|
| 244 | } |
---|
| 245 | //----------------------------------------------------------------------- |
---|
| 246 | void BillboardParticleRenderer::setRenderQueueGroup(uint8 queueID) |
---|
| 247 | { |
---|
| 248 | assert(queueID <= RENDER_QUEUE_MAX && "Render queue out of range!"); |
---|
| 249 | mBillboardSet->setRenderQueueGroup(queueID); |
---|
| 250 | } |
---|
| 251 | //----------------------------------------------------------------------- |
---|
| 252 | void BillboardParticleRenderer::setKeepParticlesInLocalSpace(bool keepLocal) |
---|
| 253 | { |
---|
| 254 | mBillboardSet->setBillboardsInWorldSpace(!keepLocal); |
---|
| 255 | } |
---|
| 256 | //----------------------------------------------------------------------- |
---|
| 257 | SortMode BillboardParticleRenderer::_getSortMode(void) const |
---|
| 258 | { |
---|
| 259 | return mBillboardSet->_getSortMode(); |
---|
| 260 | } |
---|
| 261 | //----------------------------------------------------------------------- |
---|
| 262 | void BillboardParticleRenderer::setPointRenderingEnabled(bool enabled) |
---|
| 263 | { |
---|
| 264 | mBillboardSet->setPointRenderingEnabled(enabled); |
---|
| 265 | } |
---|
| 266 | //----------------------------------------------------------------------- |
---|
| 267 | bool BillboardParticleRenderer::isPointRenderingEnabled(void) const |
---|
| 268 | { |
---|
| 269 | return mBillboardSet->isPointRenderingEnabled(); |
---|
| 270 | } |
---|
| 271 | //----------------------------------------------------------------------- |
---|
| 272 | //----------------------------------------------------------------------- |
---|
| 273 | //----------------------------------------------------------------------- |
---|
| 274 | const String& BillboardParticleRendererFactory::getType() const |
---|
| 275 | { |
---|
| 276 | return rendererTypeName; |
---|
| 277 | } |
---|
| 278 | //----------------------------------------------------------------------- |
---|
| 279 | ParticleSystemRenderer* BillboardParticleRendererFactory::createInstance( |
---|
| 280 | const String& name ) |
---|
| 281 | { |
---|
| 282 | return new BillboardParticleRenderer(); |
---|
| 283 | } |
---|
| 284 | //----------------------------------------------------------------------- |
---|
| 285 | void BillboardParticleRendererFactory::destroyInstance( |
---|
| 286 | ParticleSystemRenderer* inst) |
---|
| 287 | { |
---|
| 288 | delete inst; |
---|
| 289 | } |
---|
| 290 | //----------------------------------------------------------------------- |
---|
| 291 | //----------------------------------------------------------------------- |
---|
| 292 | String BillboardParticleRenderer::CmdBillboardType::doGet(const void* target) const |
---|
| 293 | { |
---|
| 294 | BillboardType t = static_cast<const BillboardParticleRenderer*>(target)->getBillboardType(); |
---|
| 295 | switch(t) |
---|
| 296 | { |
---|
| 297 | case BBT_POINT: |
---|
| 298 | return "point"; |
---|
| 299 | break; |
---|
| 300 | case BBT_ORIENTED_COMMON: |
---|
| 301 | return "oriented_common"; |
---|
| 302 | break; |
---|
| 303 | case BBT_ORIENTED_SELF: |
---|
| 304 | return "oriented_self"; |
---|
| 305 | break; |
---|
| 306 | case BBT_PERPENDICULAR_COMMON: |
---|
| 307 | return "perpendicular_common"; |
---|
| 308 | case BBT_PERPENDICULAR_SELF: |
---|
| 309 | return "perpendicular_self"; |
---|
| 310 | } |
---|
| 311 | // Compiler nicety |
---|
| 312 | return ""; |
---|
| 313 | } |
---|
| 314 | void BillboardParticleRenderer::CmdBillboardType::doSet(void* target, const String& val) |
---|
| 315 | { |
---|
| 316 | BillboardType t; |
---|
| 317 | if (val == "point") |
---|
| 318 | { |
---|
| 319 | t = BBT_POINT; |
---|
| 320 | } |
---|
| 321 | else if (val == "oriented_common") |
---|
| 322 | { |
---|
| 323 | t = BBT_ORIENTED_COMMON; |
---|
| 324 | } |
---|
| 325 | else if (val == "oriented_self") |
---|
| 326 | { |
---|
| 327 | t = BBT_ORIENTED_SELF; |
---|
| 328 | } |
---|
| 329 | else if (val == "perpendicular_common") |
---|
| 330 | { |
---|
| 331 | t = BBT_PERPENDICULAR_COMMON; |
---|
| 332 | } |
---|
| 333 | else if (val == "perpendicular_self") |
---|
| 334 | { |
---|
| 335 | t = BBT_PERPENDICULAR_SELF; |
---|
| 336 | } |
---|
| 337 | else |
---|
| 338 | { |
---|
| 339 | OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, |
---|
| 340 | "Invalid billboard_type '" + val + "'", |
---|
| 341 | "ParticleSystem::CmdBillboardType::doSet"); |
---|
| 342 | } |
---|
| 343 | |
---|
| 344 | static_cast<BillboardParticleRenderer*>(target)->setBillboardType(t); |
---|
| 345 | } |
---|
| 346 | //----------------------------------------------------------------------- |
---|
| 347 | String BillboardParticleRenderer::CmdBillboardOrigin::doGet(const void* target) const |
---|
| 348 | { |
---|
| 349 | BillboardOrigin o = static_cast<const BillboardParticleRenderer*>(target)->getBillboardOrigin(); |
---|
| 350 | switch (o) |
---|
| 351 | { |
---|
| 352 | case BBO_TOP_LEFT: |
---|
| 353 | return "top_left"; |
---|
| 354 | case BBO_TOP_CENTER: |
---|
| 355 | return "top_center"; |
---|
| 356 | case BBO_TOP_RIGHT: |
---|
| 357 | return "top_right"; |
---|
| 358 | case BBO_CENTER_LEFT: |
---|
| 359 | return "center_left"; |
---|
| 360 | case BBO_CENTER: |
---|
| 361 | return "center"; |
---|
| 362 | case BBO_CENTER_RIGHT: |
---|
| 363 | return "center_right"; |
---|
| 364 | case BBO_BOTTOM_LEFT: |
---|
| 365 | return "bottom_left"; |
---|
| 366 | case BBO_BOTTOM_CENTER: |
---|
| 367 | return "bottom_center"; |
---|
| 368 | case BBO_BOTTOM_RIGHT: |
---|
| 369 | return "bottom_right"; |
---|
| 370 | } |
---|
| 371 | // Compiler nicety |
---|
| 372 | return StringUtil::BLANK; |
---|
| 373 | } |
---|
| 374 | void BillboardParticleRenderer::CmdBillboardOrigin::doSet(void* target, const String& val) |
---|
| 375 | { |
---|
| 376 | BillboardOrigin o; |
---|
| 377 | if (val == "top_left") |
---|
| 378 | o = BBO_TOP_LEFT; |
---|
| 379 | else if (val =="top_center") |
---|
| 380 | o = BBO_TOP_CENTER; |
---|
| 381 | else if (val =="top_right") |
---|
| 382 | o = BBO_TOP_RIGHT; |
---|
| 383 | else if (val =="center_left") |
---|
| 384 | o = BBO_CENTER_LEFT; |
---|
| 385 | else if (val =="center") |
---|
| 386 | o = BBO_CENTER; |
---|
| 387 | else if (val =="center_right") |
---|
| 388 | o = BBO_CENTER_RIGHT; |
---|
| 389 | else if (val =="bottom_left") |
---|
| 390 | o = BBO_BOTTOM_LEFT; |
---|
| 391 | else if (val =="bottom_center") |
---|
| 392 | o = BBO_BOTTOM_CENTER; |
---|
| 393 | else if (val =="bottom_right") |
---|
| 394 | o = BBO_BOTTOM_RIGHT; |
---|
| 395 | else |
---|
| 396 | { |
---|
| 397 | OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, |
---|
| 398 | "Invalid billboard_origin '" + val + "'", |
---|
| 399 | "ParticleSystem::CmdBillboardOrigin::doSet"); |
---|
| 400 | } |
---|
| 401 | |
---|
| 402 | static_cast<BillboardParticleRenderer*>(target)->setBillboardOrigin(o); |
---|
| 403 | } |
---|
| 404 | //----------------------------------------------------------------------- |
---|
| 405 | String BillboardParticleRenderer::CmdBillboardRotationType::doGet(const void* target) const |
---|
| 406 | { |
---|
| 407 | BillboardRotationType r = static_cast<const BillboardParticleRenderer*>(target)->getBillboardRotationType(); |
---|
| 408 | switch(r) |
---|
| 409 | { |
---|
| 410 | case BBR_VERTEX: |
---|
| 411 | return "vertex"; |
---|
| 412 | case BBR_TEXCOORD: |
---|
| 413 | return "texcoord"; |
---|
| 414 | } |
---|
| 415 | // Compiler nicety |
---|
| 416 | return StringUtil::BLANK; |
---|
| 417 | } |
---|
| 418 | void BillboardParticleRenderer::CmdBillboardRotationType::doSet(void* target, const String& val) |
---|
| 419 | { |
---|
| 420 | BillboardRotationType r; |
---|
| 421 | if (val == "vertex") |
---|
| 422 | r = BBR_VERTEX; |
---|
| 423 | else if (val == "texcoord") |
---|
| 424 | r = BBR_TEXCOORD; |
---|
| 425 | else |
---|
| 426 | { |
---|
| 427 | OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, |
---|
| 428 | "Invalid billboard_rotation_type '" + val + "'", |
---|
| 429 | "ParticleSystem::CmdBillboardRotationType::doSet"); |
---|
| 430 | } |
---|
| 431 | |
---|
| 432 | static_cast<BillboardParticleRenderer*>(target)->setBillboardRotationType(r); |
---|
| 433 | } |
---|
| 434 | //----------------------------------------------------------------------- |
---|
| 435 | String BillboardParticleRenderer::CmdCommonDirection::doGet(const void* target) const |
---|
| 436 | { |
---|
| 437 | return StringConverter::toString( |
---|
| 438 | static_cast<const BillboardParticleRenderer*>(target)->getCommonDirection() ); |
---|
| 439 | } |
---|
| 440 | void BillboardParticleRenderer::CmdCommonDirection::doSet(void* target, const String& val) |
---|
| 441 | { |
---|
| 442 | static_cast<BillboardParticleRenderer*>(target)->setCommonDirection( |
---|
| 443 | StringConverter::parseVector3(val)); |
---|
| 444 | } |
---|
| 445 | //----------------------------------------------------------------------- |
---|
| 446 | String BillboardParticleRenderer::CmdCommonUpVector::doGet(const void* target) const |
---|
| 447 | { |
---|
| 448 | return StringConverter::toString( |
---|
| 449 | static_cast<const BillboardParticleRenderer*>(target)->getCommonUpVector() ); |
---|
| 450 | } |
---|
| 451 | void BillboardParticleRenderer::CmdCommonUpVector::doSet(void* target, const String& val) |
---|
| 452 | { |
---|
| 453 | static_cast<BillboardParticleRenderer*>(target)->setCommonUpVector( |
---|
| 454 | StringConverter::parseVector3(val)); |
---|
| 455 | } |
---|
| 456 | //----------------------------------------------------------------------- |
---|
| 457 | String BillboardParticleRenderer::CmdPointRendering::doGet(const void* target) const |
---|
| 458 | { |
---|
| 459 | return StringConverter::toString( |
---|
| 460 | static_cast<const BillboardParticleRenderer*>(target)->isPointRenderingEnabled() ); |
---|
| 461 | } |
---|
| 462 | void BillboardParticleRenderer::CmdPointRendering::doSet(void* target, const String& val) |
---|
| 463 | { |
---|
| 464 | static_cast<BillboardParticleRenderer*>(target)->setPointRenderingEnabled( |
---|
| 465 | StringConverter::parseBool(val)); |
---|
| 466 | } |
---|
| 467 | //----------------------------------------------------------------------- |
---|
| 468 | String BillboardParticleRenderer::CmdAccurateFacing::doGet(const void* target) const |
---|
| 469 | { |
---|
| 470 | return StringConverter::toString( |
---|
| 471 | static_cast<const BillboardParticleRenderer*>(target)->getUseAccurateFacing() ); |
---|
| 472 | } |
---|
| 473 | void BillboardParticleRenderer::CmdAccurateFacing::doSet(void* target, const String& val) |
---|
| 474 | { |
---|
| 475 | static_cast<BillboardParticleRenderer*>(target)->setUseAccurateFacing( |
---|
| 476 | StringConverter::parseBool(val)); |
---|
| 477 | } |
---|
| 478 | |
---|
| 479 | } |
---|
| 480 | |
---|