/indra/llmath/llvolume.h
C Header | 1111 lines | 843 code | 187 blank | 81 comment | 66 complexity | 7662167199e69f00a002207ee3ce4bcf MD5 | raw file
Possible License(s): LGPL-2.1
- /**
- * @file llvolume.h
- * @brief LLVolume base class.
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
- * $/LicenseInfo$
- */
- #ifndef LL_LLVOLUME_H
- #define LL_LLVOLUME_H
- #include <iostream>
- class LLProfileParams;
- class LLPathParams;
- class LLVolumeParams;
- class LLProfile;
- class LLPath;
- template <class T> class LLOctreeNode;
- class LLVector4a;
- class LLVolumeFace;
- class LLVolume;
- class LLVolumeTriangle;
- #include "lldarray.h"
- #include "lluuid.h"
- #include "v4color.h"
- //#include "vmath.h"
- #include "v2math.h"
- #include "v3math.h"
- #include "v3dmath.h"
- #include "v4math.h"
- #include "llquaternion.h"
- #include "llstrider.h"
- #include "v4coloru.h"
- #include "llrefcount.h"
- #include "llfile.h"
- //============================================================================
- const S32 MIN_DETAIL_FACES = 6;
- const S32 MIN_LOD = 0;
- const S32 MAX_LOD = 3;
- // These are defined here but are not enforced at this level,
- // rather they are here for the convenience of code that uses
- // the LLVolume class.
- const F32 MIN_VOLUME_PROFILE_WIDTH = 0.05f;
- const F32 MIN_VOLUME_PATH_WIDTH = 0.05f;
- const F32 CUT_QUANTA = 0.00002f;
- const F32 SCALE_QUANTA = 0.01f;
- const F32 SHEAR_QUANTA = 0.01f;
- const F32 TAPER_QUANTA = 0.01f;
- const F32 REV_QUANTA = 0.015f;
- const F32 HOLLOW_QUANTA = 0.00002f;
- const S32 MAX_VOLUME_TRIANGLE_INDICES = 10000;
- //============================================================================
- // useful masks
- const LLPCode LL_PCODE_HOLLOW_MASK = 0x80; // has a thickness
- const LLPCode LL_PCODE_SEGMENT_MASK = 0x40; // segments (1 angle)
- const LLPCode LL_PCODE_PATCH_MASK = 0x20; // segmented segments (2 angles)
- const LLPCode LL_PCODE_HEMI_MASK = 0x10; // half-primitives get their own type per PR's dictum
- const LLPCode LL_PCODE_BASE_MASK = 0x0F;
- // primitive shapes
- const LLPCode LL_PCODE_CUBE = 1;
- const LLPCode LL_PCODE_PRISM = 2;
- const LLPCode LL_PCODE_TETRAHEDRON = 3;
- const LLPCode LL_PCODE_PYRAMID = 4;
- const LLPCode LL_PCODE_CYLINDER = 5;
- const LLPCode LL_PCODE_CONE = 6;
- const LLPCode LL_PCODE_SPHERE = 7;
- const LLPCode LL_PCODE_TORUS = 8;
- const LLPCode LL_PCODE_VOLUME = 9;
- // surfaces
- //const LLPCode LL_PCODE_SURFACE_TRIANGLE = 10;
- //const LLPCode LL_PCODE_SURFACE_SQUARE = 11;
- //const LLPCode LL_PCODE_SURFACE_DISC = 12;
- const LLPCode LL_PCODE_APP = 14; // App specific pcode (for viewer/sim side only objects)
- const LLPCode LL_PCODE_LEGACY = 15;
- // Pcodes for legacy objects
- //const LLPCode LL_PCODE_LEGACY_ATOR = 0x10 | LL_PCODE_LEGACY; // ATOR
- const LLPCode LL_PCODE_LEGACY_AVATAR = 0x20 | LL_PCODE_LEGACY; // PLAYER
- //const LLPCode LL_PCODE_LEGACY_BIRD = 0x30 | LL_PCODE_LEGACY; // BIRD
- //const LLPCode LL_PCODE_LEGACY_DEMON = 0x40 | LL_PCODE_LEGACY; // DEMON
- const LLPCode LL_PCODE_LEGACY_GRASS = 0x50 | LL_PCODE_LEGACY; // GRASS
- const LLPCode LL_PCODE_TREE_NEW = 0x60 | LL_PCODE_LEGACY; // new trees
- //const LLPCode LL_PCODE_LEGACY_ORACLE = 0x70 | LL_PCODE_LEGACY; // ORACLE
- const LLPCode LL_PCODE_LEGACY_PART_SYS = 0x80 | LL_PCODE_LEGACY; // PART_SYS
- const LLPCode LL_PCODE_LEGACY_ROCK = 0x90 | LL_PCODE_LEGACY; // ROCK
- //const LLPCode LL_PCODE_LEGACY_SHOT = 0xA0 | LL_PCODE_LEGACY; // BASIC_SHOT
- //const LLPCode LL_PCODE_LEGACY_SHOT_BIG = 0xB0 | LL_PCODE_LEGACY;
- //const LLPCode LL_PCODE_LEGACY_SMOKE = 0xC0 | LL_PCODE_LEGACY; // SMOKE
- //const LLPCode LL_PCODE_LEGACY_SPARK = 0xD0 | LL_PCODE_LEGACY;// SPARK
- const LLPCode LL_PCODE_LEGACY_TEXT_BUBBLE = 0xE0 | LL_PCODE_LEGACY; // TEXTBUBBLE
- const LLPCode LL_PCODE_LEGACY_TREE = 0xF0 | LL_PCODE_LEGACY; // TREE
- // hemis
- const LLPCode LL_PCODE_CYLINDER_HEMI = LL_PCODE_CYLINDER | LL_PCODE_HEMI_MASK;
- const LLPCode LL_PCODE_CONE_HEMI = LL_PCODE_CONE | LL_PCODE_HEMI_MASK;
- const LLPCode LL_PCODE_SPHERE_HEMI = LL_PCODE_SPHERE | LL_PCODE_HEMI_MASK;
- const LLPCode LL_PCODE_TORUS_HEMI = LL_PCODE_TORUS | LL_PCODE_HEMI_MASK;
- // Volumes consist of a profile at the base that is swept around
- // a path to make a volume.
- // The profile code
- const U8 LL_PCODE_PROFILE_MASK = 0x0f;
- const U8 LL_PCODE_PROFILE_MIN = 0x00;
- const U8 LL_PCODE_PROFILE_CIRCLE = 0x00;
- const U8 LL_PCODE_PROFILE_SQUARE = 0x01;
- const U8 LL_PCODE_PROFILE_ISOTRI = 0x02;
- const U8 LL_PCODE_PROFILE_EQUALTRI = 0x03;
- const U8 LL_PCODE_PROFILE_RIGHTTRI = 0x04;
- const U8 LL_PCODE_PROFILE_CIRCLE_HALF = 0x05;
- const U8 LL_PCODE_PROFILE_MAX = 0x05;
- // Stored in the profile byte
- const U8 LL_PCODE_HOLE_MASK = 0xf0;
- const U8 LL_PCODE_HOLE_MIN = 0x00;
- const U8 LL_PCODE_HOLE_SAME = 0x00; // same as outside profile
- const U8 LL_PCODE_HOLE_CIRCLE = 0x10;
- const U8 LL_PCODE_HOLE_SQUARE = 0x20;
- const U8 LL_PCODE_HOLE_TRIANGLE = 0x30;
- const U8 LL_PCODE_HOLE_MAX = 0x03; // min/max needs to be >> 4 of real min/max
- const U8 LL_PCODE_PATH_IGNORE = 0x00;
- const U8 LL_PCODE_PATH_MIN = 0x01; // min/max needs to be >> 4 of real min/max
- const U8 LL_PCODE_PATH_LINE = 0x10;
- const U8 LL_PCODE_PATH_CIRCLE = 0x20;
- const U8 LL_PCODE_PATH_CIRCLE2 = 0x30;
- const U8 LL_PCODE_PATH_TEST = 0x40;
- const U8 LL_PCODE_PATH_FLEXIBLE = 0x80;
- const U8 LL_PCODE_PATH_MAX = 0x08;
- //============================================================================
- // face identifiers
- typedef U16 LLFaceID;
- const LLFaceID LL_FACE_PATH_BEGIN = 0x1 << 0;
- const LLFaceID LL_FACE_PATH_END = 0x1 << 1;
- const LLFaceID LL_FACE_INNER_SIDE = 0x1 << 2;
- const LLFaceID LL_FACE_PROFILE_BEGIN = 0x1 << 3;
- const LLFaceID LL_FACE_PROFILE_END = 0x1 << 4;
- const LLFaceID LL_FACE_OUTER_SIDE_0 = 0x1 << 5;
- const LLFaceID LL_FACE_OUTER_SIDE_1 = 0x1 << 6;
- const LLFaceID LL_FACE_OUTER_SIDE_2 = 0x1 << 7;
- const LLFaceID LL_FACE_OUTER_SIDE_3 = 0x1 << 8;
- //============================================================================
- // sculpt types + flags
- const U8 LL_SCULPT_TYPE_NONE = 0;
- const U8 LL_SCULPT_TYPE_SPHERE = 1;
- const U8 LL_SCULPT_TYPE_TORUS = 2;
- const U8 LL_SCULPT_TYPE_PLANE = 3;
- const U8 LL_SCULPT_TYPE_CYLINDER = 4;
- const U8 LL_SCULPT_TYPE_MESH = 5;
- const U8 LL_SCULPT_TYPE_MASK = LL_SCULPT_TYPE_SPHERE | LL_SCULPT_TYPE_TORUS | LL_SCULPT_TYPE_PLANE |
- LL_SCULPT_TYPE_CYLINDER | LL_SCULPT_TYPE_MESH;
- const U8 LL_SCULPT_FLAG_INVERT = 64;
- const U8 LL_SCULPT_FLAG_MIRROR = 128;
- const S32 LL_SCULPT_MESH_MAX_FACES = 8;
- class LLProfileParams
- {
- public:
- LLProfileParams()
- : mCurveType(LL_PCODE_PROFILE_SQUARE),
- mBegin(0.f),
- mEnd(1.f),
- mHollow(0.f),
- mCRC(0)
- {
- }
- LLProfileParams(U8 curve, F32 begin, F32 end, F32 hollow)
- : mCurveType(curve),
- mBegin(begin),
- mEnd(end),
- mHollow(hollow),
- mCRC(0)
- {
- }
- LLProfileParams(U8 curve, U16 begin, U16 end, U16 hollow)
- {
- mCurveType = curve;
- F32 temp_f32 = begin * CUT_QUANTA;
- if (temp_f32 > 1.f)
- {
- temp_f32 = 1.f;
- }
- mBegin = temp_f32;
- temp_f32 = end * CUT_QUANTA;
- if (temp_f32 > 1.f)
- {
- temp_f32 = 1.f;
- }
- mEnd = 1.f - temp_f32;
- temp_f32 = hollow * HOLLOW_QUANTA;
- if (temp_f32 > 1.f)
- {
- temp_f32 = 1.f;
- }
- mHollow = temp_f32;
- mCRC = 0;
- }
- bool operator==(const LLProfileParams ¶ms) const;
- bool operator!=(const LLProfileParams ¶ms) const;
- bool operator<(const LLProfileParams ¶ms) const;
-
- void copyParams(const LLProfileParams ¶ms);
- BOOL importFile(LLFILE *fp);
- BOOL exportFile(LLFILE *fp) const;
- BOOL importLegacyStream(std::istream& input_stream);
- BOOL exportLegacyStream(std::ostream& output_stream) const;
- LLSD asLLSD() const;
- operator LLSD() const { return asLLSD(); }
- bool fromLLSD(LLSD& sd);
- const F32& getBegin () const { return mBegin; }
- const F32& getEnd () const { return mEnd; }
- const F32& getHollow() const { return mHollow; }
- const U8& getCurveType () const { return mCurveType; }
- void setCurveType(const U32 type) { mCurveType = type;}
- void setBegin(const F32 begin) { mBegin = (begin >= 1.0f) ? 0.0f : ((int) (begin * 100000))/100000.0f;}
- void setEnd(const F32 end) { mEnd = (end <= 0.0f) ? 1.0f : ((int) (end * 100000))/100000.0f;}
- void setHollow(const F32 hollow) { mHollow = ((int) (hollow * 100000))/100000.0f;}
- friend std::ostream& operator<<(std::ostream &s, const LLProfileParams &profile_params);
- protected:
- // Profile params
- U8 mCurveType;
- F32 mBegin;
- F32 mEnd;
- F32 mHollow;
- U32 mCRC;
- };
- inline bool LLProfileParams::operator==(const LLProfileParams ¶ms) const
- {
- return
- (getCurveType() == params.getCurveType()) &&
- (getBegin() == params.getBegin()) &&
- (getEnd() == params.getEnd()) &&
- (getHollow() == params.getHollow());
- }
- inline bool LLProfileParams::operator!=(const LLProfileParams ¶ms) const
- {
- return
- (getCurveType() != params.getCurveType()) ||
- (getBegin() != params.getBegin()) ||
- (getEnd() != params.getEnd()) ||
- (getHollow() != params.getHollow());
- }
- inline bool LLProfileParams::operator<(const LLProfileParams ¶ms) const
- {
- if (getCurveType() != params.getCurveType())
- {
- return getCurveType() < params.getCurveType();
- }
- else
- if (getBegin() != params.getBegin())
- {
- return getBegin() < params.getBegin();
- }
- else
- if (getEnd() != params.getEnd())
- {
- return getEnd() < params.getEnd();
- }
- else
- {
- return getHollow() < params.getHollow();
- }
- }
- #define U8_TO_F32(x) (F32)(*((S8 *)&x))
- class LLPathParams
- {
- public:
- LLPathParams()
- :
- mCurveType(LL_PCODE_PATH_LINE),
- mBegin(0.f),
- mEnd(1.f),
- mScale(1.f,1.f),
- mShear(0.f,0.f),
- mTwistBegin(0.f),
- mTwistEnd(0.f),
- mRadiusOffset(0.f),
- mTaper(0.f,0.f),
- mRevolutions(1.f),
- mSkew(0.f),
- mCRC(0)
- {
- }
- LLPathParams(U8 curve, F32 begin, F32 end, F32 scx, F32 scy, F32 shx, F32 shy, F32 twistend, F32 twistbegin, F32 radiusoffset, F32 tx, F32 ty, F32 revolutions, F32 skew)
- : mCurveType(curve),
- mBegin(begin),
- mEnd(end),
- mScale(scx,scy),
- mShear(shx,shy),
- mTwistBegin(twistbegin),
- mTwistEnd(twistend),
- mRadiusOffset(radiusoffset),
- mTaper(tx,ty),
- mRevolutions(revolutions),
- mSkew(skew),
- mCRC(0)
- {
- }
- LLPathParams(U8 curve, U16 begin, U16 end, U8 scx, U8 scy, U8 shx, U8 shy, U8 twistend, U8 twistbegin, U8 radiusoffset, U8 tx, U8 ty, U8 revolutions, U8 skew)
- {
- mCurveType = curve;
- mBegin = (F32)(begin * CUT_QUANTA);
- mEnd = (F32)(100.f - end) * CUT_QUANTA;
- if (mEnd > 1.f)
- mEnd = 1.f;
- mScale.setVec((F32) (200 - scx) * SCALE_QUANTA,(F32) (200 - scy) * SCALE_QUANTA);
- mShear.setVec(U8_TO_F32(shx) * SHEAR_QUANTA,U8_TO_F32(shy) * SHEAR_QUANTA);
- mTwistBegin = U8_TO_F32(twistbegin) * SCALE_QUANTA;
- mTwistEnd = U8_TO_F32(twistend) * SCALE_QUANTA;
- mRadiusOffset = U8_TO_F32(radiusoffset) * SCALE_QUANTA;
- mTaper.setVec(U8_TO_F32(tx) * TAPER_QUANTA,U8_TO_F32(ty) * TAPER_QUANTA);
- mRevolutions = ((F32)revolutions) * REV_QUANTA + 1.0f;
- mSkew = U8_TO_F32(skew) * SCALE_QUANTA;
- mCRC = 0;
- }
- bool operator==(const LLPathParams ¶ms) const;
- bool operator!=(const LLPathParams ¶ms) const;
- bool operator<(const LLPathParams ¶ms) const;
- void copyParams(const LLPathParams ¶ms);
- BOOL importFile(LLFILE *fp);
- BOOL exportFile(LLFILE *fp) const;
- BOOL importLegacyStream(std::istream& input_stream);
- BOOL exportLegacyStream(std::ostream& output_stream) const;
- LLSD asLLSD() const;
- operator LLSD() const { return asLLSD(); }
- bool fromLLSD(LLSD& sd);
- const F32& getBegin() const { return mBegin; }
- const F32& getEnd() const { return mEnd; }
- const LLVector2 &getScale() const { return mScale; }
- const F32& getScaleX() const { return mScale.mV[0]; }
- const F32& getScaleY() const { return mScale.mV[1]; }
- const LLVector2 getBeginScale() const;
- const LLVector2 getEndScale() const;
- const LLVector2 &getShear() const { return mShear; }
- const F32& getShearX() const { return mShear.mV[0]; }
- const F32& getShearY() const { return mShear.mV[1]; }
- const U8& getCurveType () const { return mCurveType; }
- const F32& getTwistBegin() const { return mTwistBegin; }
- const F32& getTwistEnd() const { return mTwistEnd; }
- const F32& getTwist() const { return mTwistEnd; } // deprecated
- const F32& getRadiusOffset() const { return mRadiusOffset; }
- const LLVector2 &getTaper() const { return mTaper; }
- const F32& getTaperX() const { return mTaper.mV[0]; }
- const F32& getTaperY() const { return mTaper.mV[1]; }
- const F32& getRevolutions() const { return mRevolutions; }
- const F32& getSkew() const { return mSkew; }
- void setCurveType(const U8 type) { mCurveType = type; }
- void setBegin(const F32 begin) { mBegin = begin; }
- void setEnd(const F32 end) { mEnd = end; }
- void setScale(const F32 x, const F32 y) { mScale.setVec(x,y); }
- void setScaleX(const F32 v) { mScale.mV[VX] = v; }
- void setScaleY(const F32 v) { mScale.mV[VY] = v; }
- void setShear(const F32 x, const F32 y) { mShear.setVec(x,y); }
- void setShearX(const F32 v) { mShear.mV[VX] = v; }
- void setShearY(const F32 v) { mShear.mV[VY] = v; }
- void setTwistBegin(const F32 twist_begin) { mTwistBegin = twist_begin; }
- void setTwistEnd(const F32 twist_end) { mTwistEnd = twist_end; }
- void setTwist(const F32 twist) { setTwistEnd(twist); } // deprecated
- void setRadiusOffset(const F32 radius_offset){ mRadiusOffset = radius_offset; }
- void setTaper(const F32 x, const F32 y) { mTaper.setVec(x,y); }
- void setTaperX(const F32 v) { mTaper.mV[VX] = v; }
- void setTaperY(const F32 v) { mTaper.mV[VY] = v; }
- void setRevolutions(const F32 revolutions) { mRevolutions = revolutions; }
- void setSkew(const F32 skew) { mSkew = skew; }
- friend std::ostream& operator<<(std::ostream &s, const LLPathParams &path_params);
- protected:
- // Path params
- U8 mCurveType;
- F32 mBegin;
- F32 mEnd;
- LLVector2 mScale;
- LLVector2 mShear;
- F32 mTwistBegin;
- F32 mTwistEnd;
- F32 mRadiusOffset;
- LLVector2 mTaper;
- F32 mRevolutions;
- F32 mSkew;
- U32 mCRC;
- };
- inline bool LLPathParams::operator==(const LLPathParams ¶ms) const
- {
- return
- (getCurveType() == params.getCurveType()) &&
- (getScale() == params.getScale()) &&
- (getBegin() == params.getBegin()) &&
- (getEnd() == params.getEnd()) &&
- (getShear() == params.getShear()) &&
- (getTwist() == params.getTwist()) &&
- (getTwistBegin() == params.getTwistBegin()) &&
- (getRadiusOffset() == params.getRadiusOffset()) &&
- (getTaper() == params.getTaper()) &&
- (getRevolutions() == params.getRevolutions()) &&
- (getSkew() == params.getSkew());
- }
- inline bool LLPathParams::operator!=(const LLPathParams ¶ms) const
- {
- return
- (getCurveType() != params.getCurveType()) ||
- (getScale() != params.getScale()) ||
- (getBegin() != params.getBegin()) ||
- (getEnd() != params.getEnd()) ||
- (getShear() != params.getShear()) ||
- (getTwist() != params.getTwist()) ||
- (getTwistBegin() !=params.getTwistBegin()) ||
- (getRadiusOffset() != params.getRadiusOffset()) ||
- (getTaper() != params.getTaper()) ||
- (getRevolutions() != params.getRevolutions()) ||
- (getSkew() != params.getSkew());
- }
- inline bool LLPathParams::operator<(const LLPathParams ¶ms) const
- {
- if( getCurveType() != params.getCurveType())
- {
- return getCurveType() < params.getCurveType();
- }
- else
- if( getScale() != params.getScale())
- {
- return getScale() < params.getScale();
- }
- else
- if( getBegin() != params.getBegin())
- {
- return getBegin() < params.getBegin();
- }
- else
- if( getEnd() != params.getEnd())
- {
- return getEnd() < params.getEnd();
- }
- else
- if( getShear() != params.getShear())
- {
- return getShear() < params.getShear();
- }
- else
- if( getTwist() != params.getTwist())
- {
- return getTwist() < params.getTwist();
- }
- else
- if( getTwistBegin() != params.getTwistBegin())
- {
- return getTwistBegin() < params.getTwistBegin();
- }
- else
- if( getRadiusOffset() != params.getRadiusOffset())
- {
- return getRadiusOffset() < params.getRadiusOffset();
- }
- else
- if( getTaper() != params.getTaper())
- {
- return getTaper() < params.getTaper();
- }
- else
- if( getRevolutions() != params.getRevolutions())
- {
- return getRevolutions() < params.getRevolutions();
- }
- else
- {
- return getSkew() < params.getSkew();
- }
- }
- typedef LLVolumeParams* LLVolumeParamsPtr;
- typedef const LLVolumeParams* const_LLVolumeParamsPtr;
- class LLVolumeParams
- {
- public:
- LLVolumeParams()
- : mSculptType(LL_SCULPT_TYPE_NONE)
- {
- }
- LLVolumeParams(LLProfileParams &profile, LLPathParams &path,
- LLUUID sculpt_id = LLUUID::null, U8 sculpt_type = LL_SCULPT_TYPE_NONE)
- : mProfileParams(profile), mPathParams(path), mSculptID(sculpt_id), mSculptType(sculpt_type)
- {
- }
- bool operator==(const LLVolumeParams ¶ms) const;
- bool operator!=(const LLVolumeParams ¶ms) const;
- bool operator<(const LLVolumeParams ¶ms) const;
- void copyParams(const LLVolumeParams ¶ms);
-
- const LLProfileParams &getProfileParams() const {return mProfileParams;}
- LLProfileParams &getProfileParams() {return mProfileParams;}
- const LLPathParams &getPathParams() const {return mPathParams;}
- LLPathParams &getPathParams() {return mPathParams;}
- BOOL importFile(LLFILE *fp);
- BOOL exportFile(LLFILE *fp) const;
- BOOL importLegacyStream(std::istream& input_stream);
- BOOL exportLegacyStream(std::ostream& output_stream) const;
- LLSD sculptAsLLSD() const;
- bool sculptFromLLSD(LLSD& sd);
-
- LLSD asLLSD() const;
- operator LLSD() const { return asLLSD(); }
- bool fromLLSD(LLSD& sd);
- bool setType(U8 profile, U8 path);
- //void setBeginS(const F32 beginS) { mProfileParams.setBegin(beginS); } // range 0 to 1
- //void setBeginT(const F32 beginT) { mPathParams.setBegin(beginT); } // range 0 to 1
- //void setEndS(const F32 endS) { mProfileParams.setEnd(endS); } // range 0 to 1, must be greater than begin
- //void setEndT(const F32 endT) { mPathParams.setEnd(endT); } // range 0 to 1, must be greater than begin
- bool setBeginAndEndS(const F32 begin, const F32 end); // both range from 0 to 1, begin must be less than end
- bool setBeginAndEndT(const F32 begin, const F32 end); // both range from 0 to 1, begin must be less than end
- bool setHollow(const F32 hollow); // range 0 to 1
- bool setRatio(const F32 x) { return setRatio(x,x); } // 0 = point, 1 = same as base
- bool setShear(const F32 x) { return setShear(x,x); } // 0 = no movement,
- bool setRatio(const F32 x, const F32 y); // 0 = point, 1 = same as base
- bool setShear(const F32 x, const F32 y); // 0 = no movement
- bool setTwistBegin(const F32 twist_begin); // range -1 to 1
- bool setTwistEnd(const F32 twist_end); // range -1 to 1
- bool setTwist(const F32 twist) { return setTwistEnd(twist); } // deprecated
- bool setTaper(const F32 x, const F32 y) { bool pass_x = setTaperX(x); bool pass_y = setTaperY(y); return pass_x && pass_y; }
- bool setTaperX(const F32 v); // -1 to 1
- bool setTaperY(const F32 v); // -1 to 1
- bool setRevolutions(const F32 revolutions); // 1 to 4
- bool setRadiusOffset(const F32 radius_offset);
- bool setSkew(const F32 skew);
- bool setSculptID(const LLUUID sculpt_id, U8 sculpt_type);
- static bool validate(U8 prof_curve, F32 prof_begin, F32 prof_end, F32 hollow,
- U8 path_curve, F32 path_begin, F32 path_end,
- F32 scx, F32 scy, F32 shx, F32 shy,
- F32 twistend, F32 twistbegin, F32 radiusoffset,
- F32 tx, F32 ty, F32 revolutions, F32 skew);
-
- const F32& getBeginS() const { return mProfileParams.getBegin(); }
- const F32& getBeginT() const { return mPathParams.getBegin(); }
- const F32& getEndS() const { return mProfileParams.getEnd(); }
- const F32& getEndT() const { return mPathParams.getEnd(); }
-
- const F32& getHollow() const { return mProfileParams.getHollow(); }
- const F32& getTwist() const { return mPathParams.getTwist(); }
- const F32& getRatio() const { return mPathParams.getScaleX(); }
- const F32& getRatioX() const { return mPathParams.getScaleX(); }
- const F32& getRatioY() const { return mPathParams.getScaleY(); }
- const F32& getShearX() const { return mPathParams.getShearX(); }
- const F32& getShearY() const { return mPathParams.getShearY(); }
- const F32& getTwistBegin()const { return mPathParams.getTwistBegin(); }
- const F32& getRadiusOffset() const { return mPathParams.getRadiusOffset(); }
- const F32& getTaper() const { return mPathParams.getTaperX(); }
- const F32& getTaperX() const { return mPathParams.getTaperX(); }
- const F32& getTaperY() const { return mPathParams.getTaperY(); }
- const F32& getRevolutions() const { return mPathParams.getRevolutions(); }
- const F32& getSkew() const { return mPathParams.getSkew(); }
- const LLUUID& getSculptID() const { return mSculptID; }
- const U8& getSculptType() const { return mSculptType; }
- bool isSculpt() const;
- bool isMeshSculpt() const;
- BOOL isConvex() const;
- // 'begin' and 'end' should be in range [0, 1] (they will be clamped)
- // (begin, end) = (0, 1) will not change the volume
- // (begin, end) = (0, 0.5) will reduce the volume to the first half of its profile/path (S/T)
- void reduceS(F32 begin, F32 end);
- void reduceT(F32 begin, F32 end);
- struct compare
- {
- bool operator()( const const_LLVolumeParamsPtr& first, const const_LLVolumeParamsPtr& second) const
- {
- return (*first < *second);
- }
- };
-
- friend std::ostream& operator<<(std::ostream &s, const LLVolumeParams &volume_params);
- // debug helper functions
- void setCube();
- protected:
- LLProfileParams mProfileParams;
- LLPathParams mPathParams;
- LLUUID mSculptID;
- U8 mSculptType;
- };
- class LLProfile
- {
- public:
- LLProfile()
- : mOpen(FALSE),
- mConcave(FALSE),
- mDirty(TRUE),
- mTotalOut(0),
- mTotal(2)
- {
- }
- ~LLProfile();
- S32 getTotal() const { return mTotal; }
- S32 getTotalOut() const { return mTotalOut; } // Total number of outside points
- BOOL isFlat(S32 face) const { return (mFaces[face].mCount == 2); }
- BOOL isOpen() const { return mOpen; }
- void setDirty() { mDirty = TRUE; }
- static S32 getNumPoints(const LLProfileParams& params, BOOL path_open, F32 detail = 1.0f, S32 split = 0,
- BOOL is_sculpted = FALSE, S32 sculpt_size = 0);
- BOOL generate(const LLProfileParams& params, BOOL path_open, F32 detail = 1.0f, S32 split = 0,
- BOOL is_sculpted = FALSE, S32 sculpt_size = 0);
- BOOL isConcave() const { return mConcave; }
- public:
- struct Face
- {
- S32 mIndex;
- S32 mCount;
- F32 mScaleU;
- BOOL mCap;
- BOOL mFlat;
- LLFaceID mFaceID;
- };
-
- std::vector<LLVector3> mProfile;
- std::vector<LLVector2> mNormals;
- std::vector<Face> mFaces;
- std::vector<LLVector3> mEdgeNormals;
- std::vector<LLVector3> mEdgeCenters;
- friend std::ostream& operator<<(std::ostream &s, const LLProfile &profile);
- protected:
- void genNormals(const LLProfileParams& params);
- static S32 getNumNGonPoints(const LLProfileParams& params, S32 sides, F32 offset=0.0f, F32 bevel = 0.0f, F32 ang_scale = 1.f, S32 split = 0);
- void genNGon(const LLProfileParams& params, S32 sides, F32 offset=0.0f, F32 bevel = 0.0f, F32 ang_scale = 1.f, S32 split = 0);
- Face* addHole(const LLProfileParams& params, BOOL flat, F32 sides, F32 offset, F32 box_hollow, F32 ang_scale, S32 split = 0);
- Face* addCap (S16 faceID);
- Face* addFace(S32 index, S32 count, F32 scaleU, S16 faceID, BOOL flat);
- protected:
- BOOL mOpen;
- BOOL mConcave;
- BOOL mDirty;
- S32 mTotalOut;
- S32 mTotal;
- };
- //-------------------------------------------------------------------
- // SWEEP/EXTRUDE PATHS
- //-------------------------------------------------------------------
- class LLPath
- {
- public:
- struct PathPt
- {
- LLVector3 mPos;
- LLVector2 mScale;
- LLQuaternion mRot;
- F32 mTexT;
- PathPt() { mPos.setVec(0,0,0); mTexT = 0; mScale.setVec(0,0); mRot.loadIdentity(); }
- };
- public:
- LLPath()
- : mOpen(FALSE),
- mTotal(0),
- mDirty(TRUE),
- mStep(1)
- {
- }
- virtual ~LLPath();
- static S32 getNumPoints(const LLPathParams& params, F32 detail);
- static S32 getNumNGonPoints(const LLPathParams& params, S32 sides, F32 offset=0.0f, F32 end_scale = 1.f, F32 twist_scale = 1.f);
- void genNGon(const LLPathParams& params, S32 sides, F32 offset=0.0f, F32 end_scale = 1.f, F32 twist_scale = 1.f);
- virtual BOOL generate(const LLPathParams& params, F32 detail=1.0f, S32 split = 0,
- BOOL is_sculpted = FALSE, S32 sculpt_size = 0);
- BOOL isOpen() const { return mOpen; }
- F32 getStep() const { return mStep; }
- void setDirty() { mDirty = TRUE; }
- S32 getPathLength() const { return (S32)mPath.size(); }
- void resizePath(S32 length) { mPath.resize(length); }
- friend std::ostream& operator<<(std::ostream &s, const LLPath &path);
- public:
- std::vector<PathPt> mPath;
- protected:
- BOOL mOpen;
- S32 mTotal;
- BOOL mDirty;
- F32 mStep;
- };
- class LLDynamicPath : public LLPath
- {
- public:
- LLDynamicPath() : LLPath() { }
- /*virtual*/ BOOL generate(const LLPathParams& params, F32 detail=1.0f, S32 split = 0,
- BOOL is_sculpted = FALSE, S32 sculpt_size = 0);
- };
- // Yet another "face" class - caches volume-specific, but not instance-specific data for faces)
- class LLVolumeFace
- {
- public:
- class VertexData
- {
- enum
- {
- POSITION = 0,
- NORMAL = 1
- };
- private:
- void init();
- public:
- VertexData();
- VertexData(const VertexData& rhs);
- const VertexData& operator=(const VertexData& rhs);
- ~VertexData();
- LLVector4a& getPosition();
- LLVector4a& getNormal();
- const LLVector4a& getPosition() const;
- const LLVector4a& getNormal() const;
- void setPosition(const LLVector4a& pos);
- void setNormal(const LLVector4a& norm);
-
- LLVector2 mTexCoord;
- bool operator<(const VertexData& rhs) const;
- bool operator==(const VertexData& rhs) const;
- bool compareNormal(const VertexData& rhs, F32 angle_cutoff) const;
- private:
- LLVector4a* mData;
- };
- LLVolumeFace();
- LLVolumeFace(const LLVolumeFace& src);
- LLVolumeFace& operator=(const LLVolumeFace& rhs);
- ~LLVolumeFace();
- private:
- void freeData();
- public:
- BOOL create(LLVolume* volume, BOOL partial_build = FALSE);
- void createBinormals();
-
- void appendFace(const LLVolumeFace& face, LLMatrix4& transform, LLMatrix4& normal_tranform);
- void resizeVertices(S32 num_verts);
- void allocateBinormals(S32 num_verts);
- void allocateWeights(S32 num_verts);
- void resizeIndices(S32 num_indices);
- void fillFromLegacyData(std::vector<LLVolumeFace::VertexData>& v, std::vector<U16>& idx);
- void pushVertex(const VertexData& cv);
- void pushVertex(const LLVector4a& pos, const LLVector4a& norm, const LLVector2& tc);
- void pushIndex(const U16& idx);
- void swapData(LLVolumeFace& rhs);
- void getVertexData(U16 indx, LLVolumeFace::VertexData& cv);
- class VertexMapData : public LLVolumeFace::VertexData
- {
- public:
- U16 mIndex;
- bool operator==(const LLVolumeFace::VertexData& rhs) const;
- struct ComparePosition
- {
- bool operator()(const LLVector3& a, const LLVector3& b) const;
- };
- typedef std::map<LLVector3, std::vector<VertexMapData>, VertexMapData::ComparePosition > PointMap;
- };
- void optimize(F32 angle_cutoff = 2.f);
- void cacheOptimize();
- void createOctree(F32 scaler = 0.25f, const LLVector4a& center = LLVector4a(0,0,0), const LLVector4a& size = LLVector4a(0.5f,0.5f,0.5f));
- enum
- {
- SINGLE_MASK = 0x0001,
- CAP_MASK = 0x0002,
- END_MASK = 0x0004,
- SIDE_MASK = 0x0008,
- INNER_MASK = 0x0010,
- OUTER_MASK = 0x0020,
- HOLLOW_MASK = 0x0040,
- OPEN_MASK = 0x0080,
- FLAT_MASK = 0x0100,
- TOP_MASK = 0x0200,
- BOTTOM_MASK = 0x0400
- };
-
- public:
- S32 mID;
- U32 mTypeMask;
-
- // Only used for INNER/OUTER faces
- S32 mBeginS;
- S32 mBeginT;
- S32 mNumS;
- S32 mNumT;
- LLVector4a* mExtents; //minimum and maximum point of face
- LLVector4a* mCenter;
- LLVector2 mTexCoordExtents[2]; //minimum and maximum of texture coordinates of the face.
- S32 mNumVertices;
- S32 mNumIndices;
- LLVector4a* mPositions;
- LLVector4a* mNormals;
- LLVector4a* mBinormals;
- LLVector2* mTexCoords;
- U16* mIndices;
- std::vector<S32> mEdge;
- //list of skin weights for rigged volumes
- // format is mWeights[vertex_index].mV[influence] = <joint_index>.<weight>
- // mWeights.size() should be empty or match mVertices.size()
- LLVector4a* mWeights;
- LLOctreeNode<LLVolumeTriangle>* mOctree;
- private:
- BOOL createUnCutCubeCap(LLVolume* volume, BOOL partial_build = FALSE);
- BOOL createCap(LLVolume* volume, BOOL partial_build = FALSE);
- BOOL createSide(LLVolume* volume, BOOL partial_build = FALSE);
- };
- class LLVolume : public LLRefCount
- {
- friend class LLVolumeLODGroup;
- protected:
- ~LLVolume(); // use unref
- public:
- struct Point
- {
- LLVector3 mPos;
- };
- struct FaceParams
- {
- LLFaceID mFaceID;
- S32 mBeginS;
- S32 mCountS;
- S32 mBeginT;
- S32 mCountT;
- };
- LLVolume(const LLVolumeParams ¶ms, const F32 detail, const BOOL generate_single_face = FALSE, const BOOL is_unique = FALSE);
-
- U8 getProfileType() const { return mParams.getProfileParams().getCurveType(); }
- U8 getPathType() const { return mParams.getPathParams().getCurveType(); }
- S32 getNumFaces() const;
- S32 getNumVolumeFaces() const { return mVolumeFaces.size(); }
- F32 getDetail() const { return mDetail; }
- const LLVolumeParams& getParams() const { return mParams; }
- LLVolumeParams getCopyOfParams() const { return mParams; }
- const LLProfile& getProfile() const { return *mProfilep; }
- LLPath& getPath() const { return *mPathp; }
- void resizePath(S32 length);
- const std::vector<Point>& getMesh() const { return mMesh; }
- const LLVector3& getMeshPt(const U32 i) const { return mMesh[i].mPos; }
- void setDirty() { mPathp->setDirty(); mProfilep->setDirty(); }
- void regen();
- void genBinormals(S32 face);
- BOOL isConvex() const;
- BOOL isCap(S32 face);
- BOOL isFlat(S32 face);
- BOOL isUnique() const { return mUnique; }
- S32 getSculptLevel() const { return mSculptLevel; }
- void setSculptLevel(S32 level) { mSculptLevel = level; }
- S32 *getTriangleIndices(U32 &num_indices) const;
- // returns number of triangle indeces required for path/profile mesh
- S32 getNumTriangleIndices() const;
- static void getLoDTriangleCounts(const LLVolumeParams& params, S32* counts);
- S32 getNumTriangles(S32* vcount = NULL) const;
- void generateSilhouetteVertices(std::vector<LLVector3> &vertices,
- std::vector<LLVector3> &normals,
- const LLVector3& view_vec,
- const LLMatrix4& mat,
- const LLMatrix3& norm_mat,
- S32 face_index);
- //get the face index of the face that intersects with the given line segment at the point
- //closest to start. Moves end to the point of intersection. Returns -1 if no intersection.
- //Line segment must be in volume space.
- S32 lineSegmentIntersect(const LLVector3& start, const LLVector3& end,
- S32 face = -1, // which face to check, -1 = ALL_SIDES
- LLVector3* intersection = NULL, // return the intersection point
- LLVector2* tex_coord = NULL, // return the texture coordinates of the intersection point
- LLVector3* normal = NULL, // return the surface normal at the intersection point
- LLVector3* bi_normal = NULL // return the surface bi-normal at the intersection point
- );
- S32 lineSegmentIntersect(const LLVector4a& start, const LLVector4a& end,
- S32 face = 1,
- LLVector3* intersection = NULL,
- LLVector2* tex_coord = NULL,
- LLVector3* normal = NULL,
- LLVector3* bi_normal = NULL);
-
- // The following cleans up vertices and triangles,
- // getting rid of degenerate triangles and duplicate vertices,
- // and allocates new arrays with the clean data.
- static BOOL cleanupTriangleData( const S32 num_input_vertices,
- const std::vector<Point> &input_vertices,
- const S32 num_input_triangles,
- S32 *input_triangles,
- S32 &num_output_vertices,
- LLVector3 **output_vertices,
- S32 &num_output_triangles,
- S32 **output_triangles);
- LLFaceID generateFaceMask();
- BOOL isFaceMaskValid(LLFaceID face_mask);
- static S32 sNumMeshPoints;
- friend std::ostream& operator<<(std::ostream &s, const LLVolume &volume);
- friend std::ostream& operator<<(std::ostream &s, const LLVolume *volumep); // HACK to bypass Windoze confusion over
- // conversion if *(LLVolume*) to LLVolume&
- const LLVolumeFace &getVolumeFace(const S32 f) const {return mVolumeFaces[f];} // DO NOT DELETE VOLUME WHILE USING THIS REFERENCE, OR HOLD A POINTER TO THIS VOLUMEFACE
-
- U32 mFaceMask; // bit array of which faces exist in this volume
- LLVector3 mLODScaleBias; // vector for biasing LOD based on scale
-
- void sculpt(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data, S32 sculpt_level);
- void copyVolumeFaces(const LLVolume* volume);
- void cacheOptimize();
- private:
- void sculptGenerateMapVertices(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data, U8 sculpt_type);
- F32 sculptGetSurfaceArea();
- void sculptGeneratePlaceholder();
- void sculptCalcMeshResolution(U16 width, U16 height, U8 type, S32& s, S32& t);
-
- protected:
- BOOL generate();
- void createVolumeFaces();
- public:
- virtual bool unpackVolumeFaces(std::istream& is, S32 size);
- virtual void setMeshAssetLoaded(BOOL loaded);
- virtual BOOL isMeshAssetLoaded();
- protected:
- BOOL mUnique;
- F32 mDetail;
- S32 mSculptLevel;
- BOOL mIsMeshAssetLoaded;
-
- LLVolumeParams mParams;
- LLPath *mPathp;
- LLProfile *mProfilep;
- std::vector<Point> mMesh;
-
- BOOL mGenerateSingleFace;
- typedef std::vector<LLVolumeFace> face_list_t;
- face_list_t mVolumeFaces;
- public:
- LLVector4a* mHullPoints;
- U16* mHullIndices;
- S32 mNumHullPoints;
- S32 mNumHullIndices;
- };
- std::ostream& operator<<(std::ostream &s, const LLVolumeParams &volume_params);
- void calc_binormal_from_triangle(
- LLVector4a& binormal,
- const LLVector4a& pos0,
- const LLVector2& tex0,
- const LLVector4a& pos1,
- const LLVector2& tex1,
- const LLVector4a& pos2,
- const LLVector2& tex2);
- BOOL LLLineSegmentBoxIntersect(const F32* start, const F32* end, const F32* center, const F32* size);
- BOOL LLLineSegmentBoxIntersect(const LLVector3& start, const LLVector3& end, const LLVector3& center, const LLVector3& size);
- BOOL LLLineSegmentBoxIntersect(const LLVector4a& start, const LLVector4a& end, const LLVector4a& center, const LLVector4a& size);
- BOOL LLTriangleRayIntersect(const LLVector3& vert0, const LLVector3& vert1, const LLVector3& vert2, const LLVector3& orig, const LLVector3& dir,
- F32& intersection_a, F32& intersection_b, F32& intersection_t, BOOL two_sided);
- BOOL LLTriangleRayIntersect(const LLVector4a& vert0, const LLVector4a& vert1, const LLVector4a& vert2, const LLVector4a& orig, const LLVector4a& dir,
- F32& intersection_a, F32& intersection_b, F32& intersection_t);
- BOOL LLTriangleRayIntersectTwoSided(const LLVector4a& vert0, const LLVector4a& vert1, const LLVector4a& vert2, const LLVector4a& orig, const LLVector4a& dir,
- F32& intersection_a, F32& intersection_b, F32& intersection_t);
-
-
- #endif