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

Merge viewer-cougar

master
Ansariel 2019-02-07 23:45:34 +01:00
parent 0984f0c299 986567a654
commit 445b66a93e
12 changed files with 287 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
indra/llrender/llgl.cpp
View File

@ -1901,7 +1901,7 @@ void LLGLState::checkClientArrays(const std::string& msg, U32 data_mask)
GL_TEXTURE_COORD_ARRAY
};
U32 mask[] =
static const U32 mask[] =
{ //copied from llvertexbuffer.h
0x0001, //MAP_VERTEX,
0x0002, //MAP_NORMAL,

3
indra/llwindow/llwindow.h
View File

@ -167,9 +167,6 @@ public:
// Provide native key event data
virtual LLSD getNativeKeyData() { return LLSD::emptyMap(); }
// Default scale
virtual float getDeviceScaleFactor() { return 1.0f; }
// Get system UI size based on DPI (for 96 DPI UI size should be 1.0)
virtual F32 getSystemUISize() { return 1.0f; }

2
indra/llwindow/llwindowmacosx-objc.mm
View File

@ -386,8 +386,8 @@ void closeWindow(NSWindowRef window)
void removeGLView(GLViewRef view)
{
[(LLOpenGLView*)view clearGLContext];
[(LLOpenGLView*)view removeFromSuperview];
[(LLOpenGLView*)view release];
}
void setupInputWindow(NSWindowRef window, GLViewRef glview)

8
indra/llwindow/llwindowmacosx.cpp
View File

@ -1112,7 +1112,7 @@ BOOL LLWindowMacOSX::setCursorPosition(const LLCoordWindow position)
// trigger mouse move callback
LLCoordGL gl_pos;
convertCoords(position, &gl_pos);
float scale = getDeviceScaleFactor();
float scale = getSystemUISize();
gl_pos.mX *= scale;
gl_pos.mY *= scale;
mCallbacks->handleMouseMove(this, gl_pos, (MASK)0);
@ -1145,7 +1145,7 @@ BOOL LLWindowMacOSX::getCursorPosition(LLCoordWindow *position)
cursor_point[1] += mCursorLastEventDeltaY;
}
float scale = getDeviceScaleFactor();
float scale = getSystemUISize();
position->mX = cursor_point[0] * scale;
position->mY = cursor_point[1] * scale;
@ -1957,9 +1957,9 @@ MASK LLWindowMacOSX::modifiersToMask(S16 modifiers)
return mask;
}
F32 LLWindowMacOSX::getDeviceScaleFactor()
F32 LLWindowMacOSX::getSystemUISize()
{
return gHiDPISupport ? ::getDeviceUnitSize(mGLView) : LLWindow::getDeviceScaleFactor();
return gHiDPISupport ? ::getDeviceUnitSize(mGLView) : LLWindow::getSystemUISize();
}
#if LL_OS_DRAGDROP_ENABLED

2
indra/llwindow/llwindowmacosx.h
View File

@ -112,7 +112,7 @@ public:
/*virtual*/ void allowLanguageTextInput(LLPreeditor *preeditor, BOOL b);
/*virtual*/ void interruptLanguageTextInput();
/*virtual*/ void spawnWebBrowser(const std::string& escaped_url, bool async);
/*virtual*/ F32 getDeviceScaleFactor();
/*virtual*/ F32 getSystemUISize();
/*virtual*/ void openFile(const std::string& file_name);
/*virtual*/ void setTitle(const std::string& title);

134
indra/newview/llface.cpp
View File

@ -36,6 +36,8 @@
#include "llmatrix4a.h"
#include "v3color.h"
#include "lldefs.h"
#include "lldrawpoolavatar.h"
#include "lldrawpoolbump.h"
#include "llgl.h"
@ -631,6 +633,138 @@ void LLFace::renderSelected(LLViewerTexture *imagep, const LLColor4& color)
}
void renderFace(LLDrawable* drawable, LLFace *face)
{
LLVOVolume* vobj = drawable->getVOVolume();
if (vobj)
{
LLVertexBuffer::unbind();
gGL.pushMatrix();
gGL.multMatrix((F32*)vobj->getRelativeXform().mMatrix);
LLVolume* volume = NULL;
if (drawable->isState(LLDrawable::RIGGED))
{
vobj->updateRiggedVolume();
volume = vobj->getRiggedVolume();
}
else
{
volume = vobj->getVolume();
}
if (volume)
{
const LLVolumeFace& vol_face = volume->getVolumeFace(face->getTEOffset());
// <FS:Ansariel> Use a vbo for the static LLVertexBuffer::drawArray/Element functions; by Drake Arconis/Shyotl Kuhr
//LLVertexBuffer::drawElements(LLRender::TRIANGLES, vol_face.mPositions, NULL, vol_face.mNumIndices, vol_face.mIndices);
LLVertexBuffer::drawElements(LLRender::TRIANGLES, vol_face.mNumVertices, vol_face.mPositions, NULL, vol_face.mNumIndices, vol_face.mIndices);
}
gGL.popMatrix();
}
}
void LLFace::renderOneWireframe(const LLColor4 &color, F32 fogCfx, bool wireframe_selection, bool bRenderHiddenSelections)
{
//Need to because crash on ATI 3800 (and similar cards) MAINT-5018
LLGLDisable multisample(LLPipeline::RenderFSAASamples > 0 ? GL_MULTISAMPLE_ARB : 0);
LLGLSLShader* shader = LLGLSLShader::sCurBoundShaderPtr;
if (shader)
{
gDebugProgram.bind();
}
gGL.matrixMode(LLRender::MM_MODELVIEW);
gGL.pushMatrix();
BOOL is_hud_object = mVObjp->isHUDAttachment();
if (mDrawablep->isActive())
{
gGL.loadMatrix(gGLModelView);
gGL.multMatrix((F32*)mVObjp->getRenderMatrix().mMatrix);
}
else if (!is_hud_object)
{
gGL.loadIdentity();
gGL.multMatrix(gGLModelView);
LLVector3 trans = mVObjp->getRegion()->getOriginAgent();
gGL.translatef(trans.mV[0], trans.mV[1], trans.mV[2]);
}
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
if (bRenderHiddenSelections)
{
gGL.blendFunc(LLRender::BF_SOURCE_COLOR, LLRender::BF_ONE);
LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE, GL_GEQUAL);
if (shader)
{
gGL.diffuseColor4f(color.mV[VRED], color.mV[VGREEN], color.mV[VBLUE], 0.4f);
renderFace(mDrawablep, this);
}
else
{
// <FS:Ansariel> Don't use fixed functions when using shader renderer; found by Drake Arconis
if (!LLGLSLShader::sNoFixedFunction)
{
// </FS:Ansariel>
LLGLEnable fog(GL_FOG);
glFogi(GL_FOG_MODE, GL_LINEAR);
float d = (LLViewerCamera::getInstance()->getPointOfInterest() - LLViewerCamera::getInstance()->getOrigin()).magVec();
LLColor4 fogCol = color * fogCfx;
glFogf(GL_FOG_START, d);
glFogf(GL_FOG_END, d*(1 + (LLViewerCamera::getInstance()->getView() / LLViewerCamera::getInstance()->getDefaultFOV())));
glFogfv(GL_FOG_COLOR, fogCol.mV);
// <FS:Ansariel> Don't use fixed functions when using shader renderer; found by Drake Arconis
}
// </FS:Ansariel>
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
{
gGL.diffuseColor4f(color.mV[VRED], color.mV[VGREEN], color.mV[VBLUE], 0.4f);
renderFace(mDrawablep, this);
}
}
}
gGL.flush();
gGL.setSceneBlendType(LLRender::BT_ALPHA);
gGL.diffuseColor4f(color.mV[VRED] * 2, color.mV[VGREEN] * 2, color.mV[VBLUE] * 2, color.mV[VALPHA]);
{
LLGLDisable depth(wireframe_selection ? 0 : GL_BLEND);
LLGLEnable stencil(wireframe_selection ? 0 : GL_STENCIL_TEST);
if (!wireframe_selection)
{ //modify wireframe into outline selection mode
glStencilFunc(GL_NOTEQUAL, 2, 0xffff);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
}
LLGLEnable offset(GL_POLYGON_OFFSET_LINE);
glPolygonOffset(3.f, 3.f);
glLineWidth(5.f);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
renderFace(mDrawablep, this);
}
glLineWidth(1.f);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
gGL.popMatrix();
if (shader)
{
shader->bind();
}
}
/* removed in lieu of raycast uv detection
void LLFace::renderSelectedUV()
{

1
indra/newview/llface.h
View File

@ -201,6 +201,7 @@ public:
void renderSelectedUV();
void renderSelected(LLViewerTexture *image, const LLColor4 &color);
void renderOneWireframe(const LLColor4 &color, F32 fogCfx, bool wireframe_selection, bool bRenderHiddenSelections);
F32 getKey() const { return mDistance; }

66
indra/newview/llpanelface.cpp
View File

@ -549,14 +549,17 @@ struct LLPanelFaceSetTEFunctor : public LLSelectedTEFunctor
//LLSpinCtrl* ctrlTexOffsetS = mPanel->getChild<LLSpinCtrl>("TexOffsetU");
//LLSpinCtrl* ctrlTexOffsetT = mPanel->getChild<LLSpinCtrl>("TexOffsetV");
//LLSpinCtrl* ctrlTexRotation = mPanel->getChild<LLSpinCtrl>("TexRot");
LLComboBox* comboTexGen = mPanel->getChild<LLComboBox>("combobox texgen");
LLComboBox* comboTexGen = mPanel->getChild<LLComboBox>("combobox texgen");
LLCheckBoxCtrl* cb_planar_align = mPanel->getChild<LLCheckBoxCtrl>("checkbox planar align");
bool align_planar = (cb_planar_align && cb_planar_align->get());
llassert(comboTexGen);
llassert(object);
if (mPanel->mCtrlTexScaleU)
{
valid = !mPanel->mCtrlTexScaleU->getTentative();
if (valid)
if (valid || align_planar)
{
value = mPanel->mCtrlTexScaleU->get();
if (comboTexGen &&
@ -565,13 +568,19 @@ struct LLPanelFaceSetTEFunctor : public LLSelectedTEFunctor
value *= 0.5f;
}
object->setTEScaleS( te, value );
if (align_planar)
{
LLPanelFace::LLSelectedTEMaterial::setNormalRepeatX(mPanel, value, te);
LLPanelFace::LLSelectedTEMaterial::setSpecularRepeatX(mPanel, value, te);
}
}
}
if (mPanel->mCtrlTexScaleV)
{
valid = !mPanel->mCtrlTexScaleV->getTentative();
if (valid)
if (valid || align_planar)
{
value = mPanel->mCtrlTexScaleV->get();
if (comboTexGen &&
@ -580,36 +589,60 @@ struct LLPanelFaceSetTEFunctor : public LLSelectedTEFunctor
value *= 0.5f;
}
object->setTEScaleT( te, value );
if (align_planar)
{
LLPanelFace::LLSelectedTEMaterial::setNormalRepeatY(mPanel, value, te);
LLPanelFace::LLSelectedTEMaterial::setSpecularRepeatY(mPanel, value, te);
}
}
}
if (mPanel->mCtrlTexOffsetU)
{
valid = !mPanel->mCtrlTexOffsetU->getTentative();
if (valid)
if (valid || align_planar)
{
value = mPanel->mCtrlTexOffsetU->get();
object->setTEOffsetS( te, value );
if (align_planar)
{
LLPanelFace::LLSelectedTEMaterial::setNormalOffsetX(mPanel, value, te);
LLPanelFace::LLSelectedTEMaterial::setSpecularOffsetX(mPanel, value, te);
}
}
}
if (mPanel->mCtrlTexOffsetV)
{
valid = !mPanel->mCtrlTexOffsetV->getTentative();
if (valid)
if (valid || align_planar)
{
value = mPanel->mCtrlTexOffsetV->get();
object->setTEOffsetT( te, value );
if (align_planar)
{
LLPanelFace::LLSelectedTEMaterial::setNormalOffsetY(mPanel, value, te);
LLPanelFace::LLSelectedTEMaterial::setSpecularOffsetY(mPanel, value, te);
}
}
}
if (mPanel->mCtrlTexRot)
{
valid = !mPanel->mCtrlTexRot->getTentative();
if (valid)
if (valid || align_planar)
{
value = mPanel->mCtrlTexRot->get() * DEG_TO_RAD;
object->setTERotation( te, value );
if (align_planar)
{
LLPanelFace::LLSelectedTEMaterial::setNormalRotation(mPanel, value, te);
LLPanelFace::LLSelectedTEMaterial::setSpecularRotation(mPanel, value, te);
}
}
}
return true;
@ -651,14 +684,21 @@ struct LLPanelFaceSetAlignedTEFunctor : public LLSelectedTEFunctor
if (set_aligned)
{
object->setTEOffset(te, uv_offset.mV[VX], uv_offset.mV[VY]);
object->setTEScale(te, uv_scale.mV[VX], uv_scale.mV[VY]);
object->setTEScale(te, uv_scale.mV[VX], uv_scale.mV[VY]);
object->setTERotation(te, uv_rot);
LLPanelFace::LLSelectedTEMaterial::setNormalOffsetX(mPanel, uv_offset.mV[VX], te);
LLPanelFace::LLSelectedTEMaterial::setNormalOffsetY(mPanel, uv_offset.mV[VY], te);
LLPanelFace::LLSelectedTEMaterial::setSpecularOffsetX(mPanel, uv_offset.mV[VX], te);
LLPanelFace::LLSelectedTEMaterial::setSpecularOffsetY(mPanel, uv_offset.mV[VY], te);
LLPanelFace::LLSelectedTEMaterial::setNormalRotation(mPanel, uv_rot, te);
LLPanelFace::LLSelectedTEMaterial::setSpecularRotation(mPanel, uv_rot, te);
LLPanelFace::LLSelectedTEMaterial::setNormalRotation(mPanel, uv_rot, te, object->getID());
LLPanelFace::LLSelectedTEMaterial::setSpecularRotation(mPanel, uv_rot, te, object->getID());
LLPanelFace::LLSelectedTEMaterial::setNormalOffsetX(mPanel, uv_offset.mV[VX], te, object->getID());
LLPanelFace::LLSelectedTEMaterial::setNormalOffsetY(mPanel, uv_offset.mV[VY], te, object->getID());
LLPanelFace::LLSelectedTEMaterial::setNormalRepeatX(mPanel, uv_scale.mV[VX], te, object->getID());
LLPanelFace::LLSelectedTEMaterial::setNormalRepeatY(mPanel, uv_scale.mV[VY], te, object->getID());
LLPanelFace::LLSelectedTEMaterial::setSpecularOffsetX(mPanel, uv_offset.mV[VX], te, object->getID());
LLPanelFace::LLSelectedTEMaterial::setSpecularOffsetY(mPanel, uv_offset.mV[VY], te, object->getID());
LLPanelFace::LLSelectedTEMaterial::setSpecularRepeatX(mPanel, uv_scale.mV[VX], te, object->getID());
LLPanelFace::LLSelectedTEMaterial::setSpecularRepeatY(mPanel, uv_scale.mV[VY], te, object->getID());
}
}
if (!set_aligned)

23
indra/newview/llpanelface.h
View File

@ -307,16 +307,16 @@ private:
typename DataType,
typename SetValueType,
void (LLMaterial::*MaterialEditFunc)(SetValueType data) >
static void edit(LLPanelFace* p, DataType data, int te = -1)
static void edit(LLPanelFace* p, DataType data, int te = -1, const LLUUID &only_for_object_id = LLUUID())
{
LLMaterialEditFunctor< DataType, SetValueType, MaterialEditFunc > edit(data);
struct LLSelectedTEEditMaterial : public LLSelectedTEMaterialFunctor
{
LLSelectedTEEditMaterial(LLPanelFace* panel, LLMaterialEditFunctor< DataType, SetValueType, MaterialEditFunc >* editp) : _panel(panel), _edit(editp) {}
LLSelectedTEEditMaterial(LLPanelFace* panel, LLMaterialEditFunctor< DataType, SetValueType, MaterialEditFunc >* editp, const LLUUID &only_for_object_id) : _panel(panel), _edit(editp), _only_for_object_id(only_for_object_id) {}
virtual ~LLSelectedTEEditMaterial() {};
virtual LLMaterialPtr apply(LLViewerObject* object, S32 face, LLTextureEntry* tep, LLMaterialPtr& current_material)
{
if (_edit)
if (_edit && (_only_for_object_id.isNull() || _only_for_object_id == object->getID()))
{
LLMaterialPtr new_material = _panel->createDefaultMaterial(current_material);
llassert_always(new_material);
@ -380,14 +380,15 @@ private:
return NULL;
}
LLMaterialEditFunctor< DataType, SetValueType, MaterialEditFunc >* _edit;
LLPanelFace* _panel;
} editor(p, &edit);
LLSelectMgr::getInstance()->selectionSetMaterialParams(&editor, te);
LLPanelFace *_panel;
const LLUUID & _only_for_object_id;
} editor(p, &edit, only_for_object_id);
LLSelectMgr::getInstance()->selectionSetMaterialParams(&editor, te);
}
template<
typename DataType,
typename ReturnType,
typename ReturnType,
ReturnType (LLMaterial::* const MaterialGetFunc)() const >
static void getTEMaterialValue(DataType& data_to_return, bool& identical,DataType default_value, bool has_tolerance = false, DataType tolerance = DataType())
{
@ -492,10 +493,10 @@ public:
// Mutators for selected TE material
//
#define DEF_EDIT_MAT_STATE(DataType,ReturnType,MaterialMemberFunc) \
static void MaterialMemberFunc(LLPanelFace* p, DataType data, int te = -1) \
{ \
edit< DataType, ReturnType, &LLMaterial::MaterialMemberFunc >(p, data, te); \
#define DEF_EDIT_MAT_STATE(DataType,ReturnType,MaterialMemberFunc) \
static void MaterialMemberFunc(LLPanelFace* p, DataType data, int te = -1, const LLUUID &only_for_object_id = LLUUID()) \
{ \
edit< DataType, ReturnType, &LLMaterial::MaterialMemberFunc >(p, data, te, only_for_object_id); \
}
// Accessors for selected TE state proper (legacy settings etc)

253
indra/newview/llselectmgr.cpp
View File

@ -6041,6 +6041,7 @@ void LLSelectMgr::renderSilhouettes(BOOL for_hud)
gGL.translatef(-hud_bbox.getCenterLocal().mV[VX] + (depth *0.5f), 0.f, 0.f);
gGL.scalef(cur_zoom, cur_zoom, cur_zoom);
}
if (mSelectedObjects->getNumNodes())
{
LLUUID inspect_item_id= LLUUID::null;
@ -6058,6 +6059,9 @@ void LLSelectMgr::renderSilhouettes(BOOL for_hud)
}
}
bool wireframe_selection = (gFloaterTools && gFloaterTools->getVisible()) || LLSelectMgr::sRenderHiddenSelections;
F32 fogCfx = (F32)llclamp((LLSelectMgr::getInstance()->getSelectionCenterGlobal() - gAgentCamera.getCameraPositionGlobal()).magVec() / (LLSelectMgr::getInstance()->getBBoxOfSelection().getExtentLocal().magVec() * 4), 0.0, 1.0);
LLUUID focus_item_id = LLViewerMediaFocus::getInstance()->getFocusedObjectID();
// <FS:Ansariel> Improve selection silhouette rendering speed by Drake Arconis
//for (S32 pass = 0; pass < 2; pass++)
@ -6069,35 +6073,63 @@ void LLSelectMgr::renderSilhouettes(BOOL for_hud)
LLViewerObject* objectp = node->getObject();
if (!objectp)
continue;
if (objectp->isHUDAttachment() != for_hud)
{
continue;
}
if (objectp->getID() == focus_item_id)
{
node->renderOneSilhouette(gFocusMgr.getFocusColor());
}
else if(objectp->getID() == inspect_item_id)
{
node->renderOneSilhouette(sHighlightInspectColor);
}
else if (node->isTransient())
{
BOOL oldHidden = LLSelectMgr::sRenderHiddenSelections;
LLSelectMgr::sRenderHiddenSelections = FALSE;
node->renderOneSilhouette(sContextSilhouetteColor);
LLSelectMgr::sRenderHiddenSelections = oldHidden;
}
else if (objectp->isRootEdit())
{
node->renderOneSilhouette(sSilhouetteParentColor);
}
else
{
node->renderOneSilhouette(sSilhouetteChildColor);
}
}
}
if(getTEMode() && !node->hasSelectedTE())
continue;
if (objectp->mDrawable
&& objectp->mDrawable->getVOVolume()
&& objectp->mDrawable->getVOVolume()->isMesh())
{
S32 num_tes = llmin((S32)objectp->getNumTEs(), (S32)objectp->getNumFaces()); // avatars have TEs but no faces
for (S32 te = 0; te < num_tes; ++te)
{
if (!getTEMode())
{
objectp->mDrawable->getFace(te)->renderOneWireframe(
LLColor4(sSilhouetteParentColor[VRED], sSilhouetteParentColor[VGREEN], sSilhouetteParentColor[VBLUE], LLSelectMgr::sHighlightAlpha * 2)
, fogCfx, wireframe_selection, node->isTransient() ? FALSE : LLSelectMgr::sRenderHiddenSelections);
}
else if(node->isTESelected(te))
{
objectp->mDrawable->getFace(te)->renderOneWireframe(
LLColor4(sSilhouetteParentColor[VRED], sSilhouetteParentColor[VGREEN], sSilhouetteParentColor[VBLUE], LLSelectMgr::sHighlightAlpha * 2)
, fogCfx, wireframe_selection, node->isTransient() ? FALSE : LLSelectMgr::sRenderHiddenSelections);
}
}
}
else
{
if (objectp->isHUDAttachment() != for_hud)
{
continue;
}
if (objectp->getID() == focus_item_id)
{
node->renderOneSilhouette(gFocusMgr.getFocusColor());
}
else if (objectp->getID() == inspect_item_id)
{
node->renderOneSilhouette(sHighlightInspectColor);
}
else if (node->isTransient())
{
BOOL oldHidden = LLSelectMgr::sRenderHiddenSelections;
LLSelectMgr::sRenderHiddenSelections = FALSE;
node->renderOneSilhouette(sContextSilhouetteColor);
LLSelectMgr::sRenderHiddenSelections = oldHidden;
}
else if (objectp->isRootEdit())
{
node->renderOneSilhouette(sSilhouetteParentColor);
}
else
{
node->renderOneSilhouette(sSilhouetteChildColor);
}
}
} //for all selected node's
} //for pass
}
if (mHighlightedObjects->getNumNodes())
@ -6261,7 +6293,7 @@ void LLSelectNode::selectTE(S32 te_index, BOOL selected)
mLastTESelected = te_index;
}
BOOL LLSelectNode::isTESelected(S32 te_index)
BOOL LLSelectNode::isTESelected(S32 te_index) const
{
if (te_index < 0 || te_index >= mObject->getNumTEs())
{
@ -6270,7 +6302,7 @@ BOOL LLSelectNode::isTESelected(S32 te_index)
return (mTESelectMask & (0x1 << te_index)) != 0;
}
S32 LLSelectNode::getLastSelectedTE()
S32 LLSelectNode::getLastSelectedTE() const
{
if (!isTESelected(mLastTESelected))
{
@ -6279,11 +6311,6 @@ S32 LLSelectNode::getLastSelectedTE()
return mLastTESelected;
}
S32 LLSelectNode::getLastOperatedTE()
{
return mLastTESelected;
}
LLViewerObject* LLSelectNode::getObject()
{
if (!mObject)
@ -6483,157 +6510,6 @@ BOOL LLSelectNode::allowOperationOnNode(PermissionBit op, U64 group_proxy_power)
return (mPermissions->allowOperationBy(op, proxy_agent_id, group_id));
}
//helper function for pushing relevant vertices from drawable to GL
void pushWireframe(LLDrawable* drawable)
{
LLVOVolume* vobj = drawable->getVOVolume();
if (vobj)
{
LLVertexBuffer::unbind();
gGL.pushMatrix();
gGL.multMatrix((F32*) vobj->getRelativeXform().mMatrix);
LLVolume* volume = NULL;
if (drawable->isState(LLDrawable::RIGGED))
{
vobj->updateRiggedVolume();
volume = vobj->getRiggedVolume();
}
else
{
volume = vobj->getVolume();
}
if (volume)
{
for (S32 i = 0; i < volume->getNumVolumeFaces(); ++i)
{
const LLVolumeFace& face = volume->getVolumeFace(i);
// <FS:Ansariel> Use a vbo for the static LLVertexBuffer::drawArray/Element functions; by Drake Arconis/Shyotl Kuhr
//LLVertexBuffer::drawElements(LLRender::TRIANGLES, face.mPositions, NULL, face.mNumIndices, face.mIndices);
LLVertexBuffer::drawElements(LLRender::TRIANGLES, face.mNumVertices, face.mPositions, NULL, face.mNumIndices, face.mIndices);
}
}
gGL.popMatrix();
}
}
void LLSelectNode::renderOneWireframe(const LLColor4& color)
{
//Need to because crash on ATI 3800 (and similar cards) MAINT-5018
LLGLDisable multisample(LLPipeline::RenderFSAASamples > 0 ? GL_MULTISAMPLE_ARB : 0);
LLViewerObject* objectp = getObject();
if (!objectp)
{
return;
}
LLDrawable* drawable = objectp->mDrawable;
if (!drawable)
{
return;
}
LLGLSLShader* shader = LLGLSLShader::sCurBoundShaderPtr;
if (shader)
{
gDebugProgram.bind();
}
gGL.matrixMode(LLRender::MM_MODELVIEW);
gGL.pushMatrix();
BOOL is_hud_object = objectp->isHUDAttachment();
if (drawable->isActive())
{
gGL.loadMatrix(gGLModelView);
gGL.multMatrix((F32*)objectp->getRenderMatrix().mMatrix);
}
else if (!is_hud_object)
{
gGL.loadIdentity();
gGL.multMatrix(gGLModelView);
LLVector3 trans = objectp->getRegion()->getOriginAgent();
gGL.translatef(trans.mV[0], trans.mV[1], trans.mV[2]);
}
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
bool wireframe_selection = (gFloaterTools && gFloaterTools->getVisible()) || LLSelectMgr::sRenderHiddenSelections;
if (LLSelectMgr::sRenderHiddenSelections)
{
gGL.blendFunc(LLRender::BF_SOURCE_COLOR, LLRender::BF_ONE);
LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE, GL_GEQUAL);
if (shader)
{
gGL.diffuseColor4f(color.mV[VRED], color.mV[VGREEN], color.mV[VBLUE], 0.4f);
pushWireframe(drawable);
}
else
{
// <FS:Ansariel> Don't use fixed functions when using shader renderer; found by Drake Arconis
if (!LLGLSLShader::sNoFixedFunction)
{
// </FS:Ansariel>
LLGLEnable fog(GL_FOG);
glFogi(GL_FOG_MODE, GL_LINEAR);
float d = (LLViewerCamera::getInstance()->getPointOfInterest() - LLViewerCamera::getInstance()->getOrigin()).magVec();
LLColor4 fogCol = color * (F32)llclamp((LLSelectMgr::getInstance()->getSelectionCenterGlobal() - gAgentCamera.getCameraPositionGlobal()).magVec() / (LLSelectMgr::getInstance()->getBBoxOfSelection().getExtentLocal().magVec() * 4), 0.0, 1.0);
glFogf(GL_FOG_START, d);
glFogf(GL_FOG_END, d*(1 + (LLViewerCamera::getInstance()->getView() / LLViewerCamera::getInstance()->getDefaultFOV())));
glFogfv(GL_FOG_COLOR, fogCol.mV);
// <FS:Ansariel> Don't use fixed functions when using shader renderer; found by Drake Arconis
}
// </FS:Ansariel>
gGL.setAlphaRejectSettings(LLRender::CF_DEFAULT);
{
gGL.diffuseColor4f(color.mV[VRED], color.mV[VGREEN], color.mV[VBLUE], 0.4f);
pushWireframe(drawable);
}
}
}
gGL.flush();
gGL.setSceneBlendType(LLRender::BT_ALPHA);
gGL.diffuseColor4f(color.mV[VRED] * 2, color.mV[VGREEN] * 2, color.mV[VBLUE] * 2, LLSelectMgr::sHighlightAlpha * 2);
{
LLGLDisable depth(wireframe_selection ? 0 : GL_BLEND);
LLGLEnable stencil(wireframe_selection ? 0 : GL_STENCIL_TEST);
if (!wireframe_selection)
{ //modify wireframe into outline selection mode
glStencilFunc(GL_NOTEQUAL, 2, 0xffff);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
}
LLGLEnable offset(GL_POLYGON_OFFSET_LINE);
glPolygonOffset(3.f, 3.f);
glLineWidth(5.f);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
pushWireframe(drawable);
}
glLineWidth(1.f);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
gGL.popMatrix();
if (shader)
{
shader->bind();
}
}
//-----------------------------------------------------------------------------
// renderOneSilhouette()
//-----------------------------------------------------------------------------
@ -6663,7 +6539,8 @@ void LLSelectNode::renderOneSilhouette(const LLColor4 &aColor)
LLVOVolume* vobj = drawable->getVOVolume();
if (vobj && vobj->isMesh())
{
renderOneWireframe(color);
//This check (if(...)) with assert here just for ensure that this situation will not happens, and can be removed later. For example on the next release.
llassert(!"renderOneWireframe() was removed SL-10194");
return;
}

16
indra/newview/llselectmgr.h
View File

@ -191,14 +191,14 @@ public:
void selectAllTEs(BOOL b);
void selectTE(S32 te_index, BOOL selected);
BOOL isTESelected(S32 te_index);
S32 getLastSelectedTE();
S32 getLastOperatedTE();
BOOL isTESelected(S32 te_index) const;
bool hasSelectedTE() const { return TE_SELECT_MASK_ALL & mTESelectMask; }
S32 getLastSelectedTE() const;
S32 getLastOperatedTE() const { return mLastTESelected; }
S32 getTESelectMask() { return mTESelectMask; }
void renderOneWireframe(const LLColor4& color);
void renderOneSilhouette(const LLColor4 &color);
void setTransient(BOOL transient) { mTransient = transient; }
BOOL isTransient() { return mTransient; }
BOOL isTransient() const { return mTransient; }
LLViewerObject* getObject();
void setObject(LLViewerObject* object);
// *NOTE: invalidate stored textures and colors when # faces change
@ -615,10 +615,10 @@ public:
EGridMode getGridMode() { return mGridMode; }
void getGrid(LLVector3& origin, LLQuaternion& rotation, LLVector3 &scale, bool for_snap_guides = false);
BOOL getTEMode() { return mTEMode; }
void setTEMode(BOOL b) { mTEMode = b; }
BOOL getTEMode() const { return mTEMode; }
void setTEMode(BOOL b) { mTEMode = b; }
BOOL shouldShowSelection() { return mShowSelection; }
BOOL shouldShowSelection() const { return mShowSelection; }
LLBBox getBBoxOfSelection() const;
LLBBox getSavedBBoxOfSelection() const { return mSavedSelectionBBox; }

11
indra/newview/llviewerwindow.cpp
View File

@ -1684,7 +1684,6 @@ BOOL LLViewerWindow::handleDPIChanged(LLWindow *window, F32 ui_scale_factor, S32
if (ui_scale_factor >= MIN_UI_SCALE && ui_scale_factor <= MAX_UI_SCALE)
{
gSavedSettings.setF32("LastSystemUIScaleFactor", ui_scale_factor);
gSavedSettings.setF32("UIScaleFactor", ui_scale_factor);
LLViewerWindow::reshape(window_width, window_height);
mResDirty = true;
return TRUE;
@ -1856,13 +1855,17 @@ LLViewerWindow::LLViewerWindow(const Params& p)
//gSavedSettings.setS32("FullScreenHeight",scr.mY);
// }
// </FS:Ansariel>
#if LL_DARWIN
F32 system_scale_factor = 1.f;
#else
F32 system_scale_factor = mWindow->getSystemUISize();
if (system_scale_factor < MIN_UI_SCALE || system_scale_factor > MAX_UI_SCALE)
{
// reset to default;
system_scale_factor = 1.f;
}
#endif
// <FS:Ansariel> FIRE-20416: Option for automatic UI scaling
//if (p.first_run || gSavedSettings.getF32("LastSystemUIScaleFactor") != system_scale_factor)
#if !LL_WINDOWS
@ -1879,7 +1882,7 @@ LLViewerWindow::LLViewerWindow(const Params& p)
// Get the real window rect the window was created with (since there are various OS-dependent reasons why
// the size of a window or fullscreen context may have been adjusted slightly...)
F32 ui_scale_factor = llclamp(gSavedSettings.getF32("UIScaleFactor"), MIN_UI_SCALE, MAX_UI_SCALE) * mWindow->getDeviceScaleFactor();
F32 ui_scale_factor = llclamp(gSavedSettings.getF32("UIScaleFactor"), MIN_UI_SCALE, MAX_UI_SCALE) * mWindow->getSystemUISize();
mDisplayScale.setVec(llmax(1.f / mWindow->getPixelAspectRatio(), 1.f), llmax(mWindow->getPixelAspectRatio(), 1.f));
mDisplayScale *= ui_scale_factor;
@ -6641,7 +6644,7 @@ F32 LLViewerWindow::getWorldViewAspectRatio() const
void LLViewerWindow::calcDisplayScale()
{
F32 ui_scale_factor = llclamp(gSavedSettings.getF32("UIScaleFactor"), MIN_UI_SCALE, MAX_UI_SCALE) * mWindow->getDeviceScaleFactor();
F32 ui_scale_factor = llclamp(gSavedSettings.getF32("UIScaleFactor"), MIN_UI_SCALE, MAX_UI_SCALE) * mWindow->getSystemUISize();
LLVector2 display_scale;
display_scale.setVec(llmax(1.f / mWindow->getPixelAspectRatio(), 1.f), llmax(mWindow->getPixelAspectRatio(), 1.f));
display_scale *= ui_scale_factor;