livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge

meow-7.2.2
Richard Linden 2014-09-23 19:13:35 -07:00
parent f0fa1961a8 e298325bed
commit 4fc71be01a
3 changed files with 13 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
indra/llprimitive/llmodel.cpp
View File

@ -172,7 +172,7 @@ LLModel::EModelStatus load_face_from_dom_triangles(std::vector<LLVolumeFace>& fa
if (!pos_source)
{
llwarns << "Unable to process mesh without position data; invalid model; invalid model." << llendl;
LL_WARNS() << "Unable to process mesh without position data; invalid model; invalid model." << LL_ENDL;
return LLModel::BAD_ELEMENT;
}
@ -193,7 +193,7 @@ LLModel::EModelStatus load_face_from_dom_triangles(std::vector<LLVolumeFace>& fa
if ((vertex_count == 0) || (tc_count == 0))
{
llwarns << "Unable to process mesh with empty position array; invalid model." << llendl;
LL_WARNS() << "Unable to process mesh with empty position array; invalid model." << LL_ENDL;
return LLModel::BAD_ELEMENT;
}

52
indra/newview/llmanipscale.cpp
View File

@ -85,7 +85,6 @@ const LLManip::EManipPart MANIPULATOR_IDS[LLManipScale::NUM_MANIPULATORS] =
LLManip::LL_FACE_NEGZ
};
F32 get_default_max_prim_scale(bool is_flora)
{
// a bit of a hack, but if it's foilage, we don't want to use the
@ -292,10 +291,6 @@ void LLManipScale::render()
LLGLEnable poly_offset(GL_POLYGON_OFFSET_FILL);
glPolygonOffset( -2.f, -2.f);
// JC - Band-aid until edge stretch working similar to side stretch
// in non-uniform.
// renderEdges( bbox );
renderCorners( bbox );
renderFaces( bbox );
@ -693,63 +688,38 @@ void LLManipScale::renderFaces( const LLBBox& bbox )
{
case 0:
conditionalHighlight( LL_FACE_POSZ, &z_highlight_color, &z_normal_color );
renderAxisHandle( LL_FACE_POSZ, ctr, LLVector3( ctr.mV[VX], ctr.mV[VY], max.mV[VZ] ) );
renderAxisHandle( 8, ctr, LLVector3( ctr.mV[VX], ctr.mV[VY], max.mV[VZ] ) );
break;
case 1:
conditionalHighlight( LL_FACE_POSX, &x_highlight_color, &x_normal_color );
renderAxisHandle( LL_FACE_POSX, ctr, LLVector3( max.mV[VX], ctr.mV[VY], ctr.mV[VZ] ) );
renderAxisHandle( 9, ctr, LLVector3( max.mV[VX], ctr.mV[VY], ctr.mV[VZ] ) );
break;
case 2:
conditionalHighlight( LL_FACE_POSY, &y_highlight_color, &y_normal_color );
renderAxisHandle( LL_FACE_POSY, ctr, LLVector3( ctr.mV[VX], max.mV[VY], ctr.mV[VZ] ) );
renderAxisHandle( 10, ctr, LLVector3( ctr.mV[VX], max.mV[VY], ctr.mV[VZ] ) );
break;
case 3:
conditionalHighlight( LL_FACE_NEGX, &x_highlight_color, &x_normal_color );
renderAxisHandle( LL_FACE_NEGX, ctr, LLVector3( min.mV[VX], ctr.mV[VY], ctr.mV[VZ] ) );
renderAxisHandle( 11, ctr, LLVector3( min.mV[VX], ctr.mV[VY], ctr.mV[VZ] ) );
break;
case 4:
conditionalHighlight( LL_FACE_NEGY, &y_highlight_color, &y_normal_color );
renderAxisHandle( LL_FACE_NEGY, ctr, LLVector3( ctr.mV[VX], min.mV[VY], ctr.mV[VZ] ) );
renderAxisHandle( 12, ctr, LLVector3( ctr.mV[VX], min.mV[VY], ctr.mV[VZ] ) );
break;
case 5:
conditionalHighlight( LL_FACE_NEGZ, &z_highlight_color, &z_normal_color );
renderAxisHandle( LL_FACE_NEGZ, ctr, LLVector3( ctr.mV[VX], ctr.mV[VY], min.mV[VZ] ) );
renderAxisHandle( 13, ctr, LLVector3( ctr.mV[VX], ctr.mV[VY], min.mV[VZ] ) );
break;
}
}
}
}
void LLManipScale::renderEdges( const LLBBox& bbox )
{
LLVector3 extent = bbox.getExtentLocal();
for( U32 part = LL_EDGE_MIN; part <= LL_EDGE_MAX; part++ )
{
F32 edge_width = mBoxHandleSize[part] * .6f;
LLVector3 direction = edgeToUnitVector( part );
LLVector3 center_to_edge = unitVectorToLocalBBoxExtent( direction, bbox );
gGL.pushMatrix();
{
gGL.translatef( center_to_edge.mV[0], center_to_edge.mV[1], center_to_edge.mV[2] );
conditionalHighlight( part );
gGL.scalef(
direction.mV[0] ? edge_width : extent.mV[VX],
direction.mV[1] ? edge_width : extent.mV[VY],
direction.mV[2] ? edge_width : extent.mV[VZ] );
gBox.render();
}
gGL.popMatrix();
}
}
void LLManipScale::renderCorners( const LLBBox& bbox )
{
U32 part = LL_CORNER_NNN;
@ -792,14 +762,14 @@ void LLManipScale::renderBoxHandle( F32 x, F32 y, F32 z )
}
void LLManipScale::renderAxisHandle( U32 part, const LLVector3& start, const LLVector3& end )
void LLManipScale::renderAxisHandle( U32 handle_index, const LLVector3& start, const LLVector3& end )
{
if( getShowAxes() )
{
// Draws a single "jacks" style handle: a long, retangular box from start to end.
LLVector3 offset_start = end - start;
offset_start.normalize();
offset_start = start + mBoxHandleSize[part] * offset_start;
offset_start = start + mBoxHandleSize[handle_index] * offset_start;
LLVector3 delta = end - offset_start;
LLVector3 pos = offset_start + 0.5f * delta;
@ -808,9 +778,9 @@ void LLManipScale::renderAxisHandle( U32 part, const LLVector3& start, const LLV
{
gGL.translatef( pos.mV[VX], pos.mV[VY], pos.mV[VZ] );
gGL.scalef(
mBoxHandleSize[part] + llabs(delta.mV[VX]),
mBoxHandleSize[part] + llabs(delta.mV[VY]),
mBoxHandleSize[part] + llabs(delta.mV[VZ]));
mBoxHandleSize[handle_index] + llabs(delta.mV[VX]),
mBoxHandleSize[handle_index] + llabs(delta.mV[VY]),
mBoxHandleSize[handle_index] + llabs(delta.mV[VZ]));
gBox.render();
}
gGL.popMatrix();

1
indra/newview/llmanipscale.h
View File

@ -96,7 +96,6 @@ public:
private:
void renderCorners( const LLBBox& local_bbox );
void renderFaces( const LLBBox& local_bbox );
void renderEdges( const LLBBox& local_bbox );
void renderBoxHandle( F32 x, F32 y, F32 z );
void renderAxisHandle( U32 part, const LLVector3& start, const LLVector3& end );
void renderGuidelinesPart( const LLBBox& local_bbox );