1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
/**
* @file llflexibleobject.h
* @author JJ Ventrella, Andrew Meadows, Tom Yedwab
* @brief Flexible object definition
*
* $LicenseInfo:firstyear=2006&license=viewergpl$
*
* Copyright (c) 2006-2007, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlife.com/developers/opensource/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at http://secondlife.com/developers/opensource/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
/**
* This is for specifying objects in the world that are animated and
* rendered locally - on the viewer. Flexible Objects are linear arrays
* of positions, which stay at a fixed distance from each other. One
* position is fixed as an "anchor" and is attached to some other object
* in the world, determined by the server. All the other positions are
* updated according to local physics.
*/
#ifndef LL_LLFLEXIBLEOBJECT_H
#define LL_LLFLEXIBLEOBJECT_H
#include "llmemory.h"
#include "llprimitive.h"
#include "llvovolume.h"
#include "llwind.h"
// 10 ms for the whole thing!
const F32 FLEXIBLE_OBJECT_TIMESLICE = 0.003f;
const U32 FLEXIBLE_OBJECT_MAX_LOD = 10;
// See llprimitive.h for LLFlexibleObjectData and DEFAULT/MIN/MAX values
//-------------------------------------------------------------------
struct LLFlexibleObjectSection
{
// Input parameters
LLVector2 mScale;
LLQuaternion mAxisRotation;
// Simulated state
LLVector3 mPosition;
LLVector3 mVelocity;
LLVector3 mDirection;
LLQuaternion mRotation;
// Derivatives (Not all currently used, will come back with LLVolume changes to automagically generate normals)
LLVector3 mdPosition;
//LLMatrix4 mRotScale;
//LLMatrix4 mdRotScale;
};
//---------------------------------------------------------
// The LLVolumeImplFlexible class
//---------------------------------------------------------
class LLVolumeImplFlexible : public LLVolumeInterface
{
public:
LLVolumeImplFlexible(LLViewerObject* volume, LLFlexibleObjectData* attributes);
// Implements LLVolumeInterface
U32 getID() const { return mID; }
LLVector3 getFramePosition() const;
LLQuaternion getFrameRotation() const;
LLVolumeInterfaceType getInterfaceType() const { return INTERFACE_FLEXIBLE; }
BOOL doIdleUpdate(LLAgent &agent, LLWorld &world, const F64 &time);
BOOL doUpdateGeometry(LLDrawable *drawable);
LLVector3 getPivotPosition() const;
void onSetVolume(const LLVolumeParams &volume_params, const S32 detail);
void onSetScale(const LLVector3 &scale, BOOL damped);
void onParameterChanged(U16 param_type, LLNetworkData *data, BOOL in_use, bool local_origin);
void onShift(const LLVector3 &shift_vector);
bool isVolumeUnique() const { return true; }
bool isVolumeGlobal() const { return true; }
bool isActive() const { return true; }
const LLMatrix4& getWorldMatrix(LLXformMatrix* xform) const;
void updateRelativeXform();
void doFlexibleUpdate(); // Called to update the simulation
void doFlexibleRebuild(); // Called to rebuild the geometry
void preRebuild();
//void setAttributes( LLFlexibleObjectData );
void setParentPositionAndRotationDirectly( LLVector3 p, LLQuaternion r );
void setUsingCollisionSphere( bool u );
void setCollisionSphere( LLVector3 position, F32 radius );
void setRenderingCollisionSphere( bool r);
LLVector3 getEndPosition();
LLQuaternion getEndRotation();
LLVector3 getNodePosition( int nodeIndex );
LLVector3 getAnchorPosition() const;
private:
//--------------------------------------
// private members
//--------------------------------------
// Backlink only; don't make this an LLPointer.
LLViewerObject* mVO;
LLTimer mTimer;
LLVector3 mAnchorPosition;
LLVector3 mParentPosition;
LLQuaternion mParentRotation;
LLQuaternion mLastFrameRotation;
LLQuaternion mLastSegmentRotation;
BOOL mInitialized;
BOOL mUpdated;
LLFlexibleObjectData* mAttributes;
LLFlexibleObjectSection mSection [ (1<<FLEXIBLE_OBJECT_MAX_SECTIONS)+1 ];
S32 mInitializedRes;
S32 mSimulateRes;
S32 mRenderRes;
U32 mFrameNum;
LLVector3 mCollisionSpherePosition;
F32 mCollisionSphereRadius;
U32 mID;
//--------------------------------------
// private methods
//--------------------------------------
void setAttributesOfAllSections ();
void remapSections(LLFlexibleObjectSection *source, S32 source_sections,
LLFlexibleObjectSection *dest, S32 dest_sections);
public:
// Global setting for update rate
static F32 sUpdateFactor;
};// end of class definition
#endif // LL_LLFLEXIBLEOBJECT_H
|
