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

Merge branch 'DRTVWR-559' of ssh://bitbucket.org/lindenlab/viewer into DRTVWR-559

meow-7.2.2
Dave Parks 2022-11-16 16:07:58 -06:00
parent bc4694e82a 6387fbb378
commit d539550252
6 changed files with 304 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
indra/newview/llmaterialeditor.cpp
View File

@ -378,6 +378,20 @@ BOOL LLMaterialEditor::postBuild()
mBaseColorCtrl = getChild<LLColorSwatchCtrl>("base color");
mEmissiveColorCtrl = getChild<LLColorSwatchCtrl>("emissive color");
if (!gAgent.isGodlike())
{
// Only allow fully permissive textures
mBaseColorTextureCtrl->setImmediateFilterPermMask(PERM_ITEM_UNRESTRICTED);
mBaseColorTextureCtrl->setNonImmediateFilterPermMask(PERM_ITEM_UNRESTRICTED);
mMetallicTextureCtrl->setImmediateFilterPermMask(PERM_ITEM_UNRESTRICTED);
mMetallicTextureCtrl->setNonImmediateFilterPermMask(PERM_ITEM_UNRESTRICTED);
mEmissiveTextureCtrl->setImmediateFilterPermMask(PERM_ITEM_UNRESTRICTED);
mEmissiveTextureCtrl->setNonImmediateFilterPermMask(PERM_ITEM_UNRESTRICTED);
mNormalTextureCtrl->setImmediateFilterPermMask(PERM_ITEM_UNRESTRICTED);
mNormalTextureCtrl->setNonImmediateFilterPermMask(PERM_ITEM_UNRESTRICTED);
}
// Texture callback
mBaseColorTextureCtrl->setCommitCallback(boost::bind(&LLMaterialEditor::onCommitTexture, this, _1, _2, MATERIAL_BASE_COLOR_TEX_DIRTY));
mMetallicTextureCtrl->setCommitCallback(boost::bind(&LLMaterialEditor::onCommitTexture, this, _1, _2, MATERIAL_METALLIC_ROUGHTNESS_TEX_DIRTY));
mEmissiveTextureCtrl->setCommitCallback(boost::bind(&LLMaterialEditor::onCommitTexture, this, _1, _2, MATERIAL_EMISIVE_TEX_DIRTY));

255
indra/newview/llpanelface.cpp
View File

@ -114,6 +114,73 @@ const S32 PBRTYPE_NORMAL = 2; // PBR Normal
const S32 PBRTYPE_METALLIC_ROUGHNESS = 3; // PBR Metallic
const S32 PBRTYPE_EMISSIVE = 4; // PBR Emissive
LLGLTFMaterial::TextureInfo texture_info_from_pbrtype(S32 pbr_type)
{
switch (pbr_type)
{
case PBRTYPE_BASE_COLOR:
return LLGLTFMaterial::GLTF_TEXTURE_INFO_BASE_COLOR;
break;
case PBRTYPE_NORMAL:
return LLGLTFMaterial::GLTF_TEXTURE_INFO_NORMAL;
break;
case PBRTYPE_METALLIC_ROUGHNESS:
return LLGLTFMaterial::GLTF_TEXTURE_INFO_METALLIC_ROUGHNESS;
break;
case PBRTYPE_EMISSIVE:
return LLGLTFMaterial::GLTF_TEXTURE_INFO_EMISSIVE;
break;
default:
return LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT;
break;
}
}
void updateSelectedGLTFMaterials(std::function<void(LLGLTFMaterial*)> func)
{
struct LLSelectedTEGLTFMaterialFunctor : public LLSelectedTEFunctor
{
LLSelectedTEGLTFMaterialFunctor(std::function<void(LLGLTFMaterial*)> func) : mFunc(func) {}
virtual ~LLSelectedTEGLTFMaterialFunctor() {};
bool apply(LLViewerObject* object, S32 face) override
{
LLGLTFMaterial new_override;
const LLTextureEntry* tep = object->getTE(face);
if (tep->getGLTFMaterialOverride())
{
new_override = *tep->getGLTFMaterialOverride();
}
mFunc(&new_override);
LLGLTFMaterialList::queueModify(object->getID(), face, &new_override);
return true;
}
std::function<void(LLGLTFMaterial*)> mFunc;
} select_func(func);
LLSelectMgr::getInstance()->getSelection()->applyToTEs(&select_func);
}
template<typename T>
void readSelectedGLTFMaterial(std::function<T(const LLGLTFMaterial*)> func, T& value, bool& identical, bool has_tolerance, T tolerance)
{
struct LLSelectedTEGetGLTFMaterialFunctor : public LLSelectedTEGetFunctor<T>
{
LLSelectedTEGetGLTFMaterialFunctor(std::function<T(const LLGLTFMaterial*)> func) : mFunc(func) {}
virtual ~LLSelectedTEGetGLTFMaterialFunctor() {};
T get(LLViewerObject* object, S32 face) override
{
const LLTextureEntry* tep = object->getTE(face);
const LLGLTFMaterial* render_material = tep->getGLTFRenderMaterial();
return mFunc(render_material);
}
std::function<T(const LLGLTFMaterial*)> mFunc;
} select_func(func);
identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue(&select_func, value, has_tolerance, tolerance);
}
BOOST_STATIC_ASSERT(MATTYPE_DIFFUSE == LLRender::DIFFUSE_MAP && MATTYPE_NORMAL == LLRender::NORMAL_MAP && MATTYPE_SPECULAR == LLRender::SPECULAR_MAP);
//
@ -201,11 +268,11 @@ BOOL LLPanelFace::postBuild()
childSetCommitCallback("add_media", &LLPanelFace::onClickBtnAddMedia, this);
childSetCommitCallback("delete_media", &LLPanelFace::onClickBtnDeleteMedia, this);
childSetCommitCallback("gltfTextureScaleU", &LLPanelFace::onCommitGLTFTextureScaleU, this);
childSetCommitCallback("gltfTextureScaleV", &LLPanelFace::onCommitGLTFTextureScaleV, this);
childSetCommitCallback("gltfRotation", &LLPanelFace::onCommitGLTFRotation, this);
childSetCommitCallback("gltfTextureTranslationU", &LLPanelFace::onCommitGLTFTextureTranslationU, this);
childSetCommitCallback("gltfTextureTranslationV", &LLPanelFace::onCommitGLTFTextureTranslationV, this);
childSetCommitCallback("gltfTextureScaleU", boost::bind(&LLPanelFace::onCommitGLTFTextureScaleU, this, _1), nullptr);
childSetCommitCallback("gltfTextureScaleV", boost::bind(&LLPanelFace::onCommitGLTFTextureScaleV, this, _1), nullptr);
childSetCommitCallback("gltfTextureRotation", boost::bind(&LLPanelFace::onCommitGLTFRotation, this, _1), nullptr);
childSetCommitCallback("gltfTextureOffsetU", boost::bind(&LLPanelFace::onCommitGLTFTextureOffsetU, this, _1), nullptr);
childSetCommitCallback("gltfTextureOffsetV", boost::bind(&LLPanelFace::onCommitGLTFTextureOffsetV, this, _1), nullptr);
childSetAction("button align",&LLPanelFace::onClickAutoFix,this);
childSetAction("button align textures", &LLPanelFace::onAlignTexture, this);
@ -936,6 +1003,8 @@ void LLPanelFace::updateUI(bool force_set_values /*false*/)
radio_pbr_type->selectNthItem(PBRTYPE_RENDER_MATERIAL_ID);
}
radio_pbr_type->setEnabled(editable);
const bool pbr_selected = mComboMatMedia->getCurrentIndex() == MATMEDIA_PBR;
const bool texture_info_selected = pbr_selected && radio_pbr_type->getSelectedIndex() != PBRTYPE_RENDER_MATERIAL_ID;
getChildView("checkbox_sync_settings")->setEnabled(editable);
childSetValue("checkbox_sync_settings", gSavedSettings.getBOOL("SyncMaterialSettings"));
@ -1184,9 +1253,9 @@ void LLPanelFace::updateUI(bool force_set_values /*false*/)
LLCheckBoxCtrl* cb_planar_align = getChild<LLCheckBoxCtrl>("checkbox planar align");
align_planar = (cb_planar_align && cb_planar_align->get());
bool enabled = (editable && isIdenticalPlanarTexgen());
bool enabled = (editable && isIdenticalPlanarTexgen() && (!pbr_selected || texture_info_selected));
childSetValue("checkbox planar align", align_planar && enabled);
childSetVisible("checkbox planar align", enabled);
childSetVisible("checkbox planar align", enabled);
childSetEnabled("checkbox planar align", enabled);
childSetEnabled("button align textures", enabled && LLSelectMgr::getInstance()->getSelection()->getObjectCount() > 1);
@ -1722,6 +1791,70 @@ void LLPanelFace::updateUIGLTF(LLViewerObject* objectp, bool& has_pbr_material,
getChildView("pbr_from_inventory")->setEnabled(editable);
getChildView("edit_selected_pbr")->setEnabled(editable && has_pbr_material);
getChildView("save_selected_pbr")->setEnabled(objectp->permCopy() && has_pbr_material);
const bool show_pbr = mComboMatMedia->getCurrentIndex() == MATMEDIA_PBR && mComboMatMedia->getEnabled();
if (show_pbr)
{
const U32 pbr_type = findChild<LLRadioGroup>("radio_pbr_type")->getSelectedIndex();
const LLGLTFMaterial::TextureInfo texture_info = texture_info_from_pbrtype(pbr_type);
const bool show_texture_info = texture_info != LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT;
LLUICtrl* gltfCtrlTextureScaleU = getChild<LLUICtrl>("gltfTextureScaleU");
LLUICtrl* gltfCtrlTextureScaleV = getChild<LLUICtrl>("gltfTextureScaleV");
LLUICtrl* gltfCtrlTextureRotation = getChild<LLUICtrl>("gltfTextureRotation");
LLUICtrl* gltfCtrlTextureOffsetU = getChild<LLUICtrl>("gltfTextureOffsetU");
LLUICtrl* gltfCtrlTextureOffsetV = getChild<LLUICtrl>("gltfTextureOffsetV");
gltfCtrlTextureScaleU->setEnabled(show_texture_info);
gltfCtrlTextureScaleV->setEnabled(show_texture_info);
gltfCtrlTextureRotation->setEnabled(show_texture_info);
gltfCtrlTextureOffsetU->setEnabled(show_texture_info);
gltfCtrlTextureOffsetV->setEnabled(show_texture_info);
if (show_texture_info)
{
LLGLTFMaterial::TextureTransform transform;
bool scale_u_same = true;
bool scale_v_same = true;
bool rotation_same = true;
bool offset_u_same = true;
bool offset_v_same = true;
readSelectedGLTFMaterial<float>([&](const LLGLTFMaterial* mat)
{
return mat->mTextureTransform[texture_info].mScale[VX];
}, transform.mScale[VX], scale_u_same, true, 1e-3f);
readSelectedGLTFMaterial<float>([&](const LLGLTFMaterial* mat)
{
return mat->mTextureTransform[texture_info].mScale[VY];
}, transform.mScale[VY], scale_v_same, true, 1e-3f);
readSelectedGLTFMaterial<float>([&](const LLGLTFMaterial* mat)
{
return mat->mTextureTransform[texture_info].mRotation;
}, transform.mRotation, rotation_same, true, 1e-3f);
readSelectedGLTFMaterial<float>([&](const LLGLTFMaterial* mat)
{
return mat->mTextureTransform[texture_info].mOffset[VX];
}, transform.mOffset[VX], offset_u_same, true, 1e-3f);
readSelectedGLTFMaterial<float>([&](const LLGLTFMaterial* mat)
{
return mat->mTextureTransform[texture_info].mOffset[VY];
}, transform.mOffset[VY], offset_v_same, true, 1e-3f);
gltfCtrlTextureScaleU->setValue(transform.mScale[VX]);
gltfCtrlTextureScaleV->setValue(transform.mScale[VY]);
gltfCtrlTextureRotation->setValue(transform.mRotation * RAD_TO_DEG);
gltfCtrlTextureOffsetU->setValue(transform.mOffset[VX]);
gltfCtrlTextureOffsetV->setValue(transform.mOffset[VY]);
gltfCtrlTextureScaleU->setTentative(!scale_u_same);
gltfCtrlTextureScaleV->setTentative(!scale_v_same);
gltfCtrlTextureRotation->setTentative(!rotation_same);
gltfCtrlTextureOffsetU->setTentative(!offset_u_same);
gltfCtrlTextureOffsetV->setTentative(!offset_v_same);
}
}
}
void LLPanelFace::updateVisibilityGLTF()
@ -1748,8 +1881,8 @@ void LLPanelFace::updateVisibilityGLTF()
getChildView("gltfTextureScaleU")->setVisible(show_pbr_transform);
getChildView("gltfTextureScaleV")->setVisible(show_pbr_transform);
getChildView("gltfTextureRotation")->setVisible(show_pbr_transform);
getChildView("gltfTextureTranslationU")->setVisible(show_pbr_transform);
getChildView("gltfTextureTranslationV")->setVisible(show_pbr_transform);
getChildView("gltfTextureOffsetU")->setVisible(show_pbr_transform);
getChildView("gltfTextureOffsetV")->setVisible(show_pbr_transform);
}
void LLPanelFace::updateCopyTexButton()
@ -2597,13 +2730,17 @@ void LLPanelFace::updateVisibility()
bool show_texture = (show_media || (show_material && (material_type == MATTYPE_DIFFUSE) && mComboMatMedia->getEnabled()));
bool show_bumpiness = show_material && (material_type == MATTYPE_NORMAL) && mComboMatMedia->getEnabled();
bool show_shininess = show_material && (material_type == MATTYPE_SPECULAR) && mComboMatMedia->getEnabled();
const bool show_pbr = mComboMatMedia->getCurrentIndex() == MATMEDIA_PBR && mComboMatMedia->getEnabled();
const U32 pbr_type = findChild<LLRadioGroup>("radio_pbr_type")->getSelectedIndex();
const LLGLTFMaterial::TextureInfo texture_info = texture_info_from_pbrtype(pbr_type);
const bool show_texture_info = show_pbr && texture_info != LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT;
radio_mat_type->setVisible(show_material);
// Shared material controls
getChildView("checkbox_sync_settings")->setVisible(show_material || show_media);
getChildView("tex gen")->setVisible(show_material || show_media);
getChildView("combobox texgen")->setVisible(show_material || show_media);
getChildView("checkbox_sync_settings")->setVisible(show_material || show_media || show_texture_info);
getChildView("tex gen")->setVisible(show_material || show_media || show_texture_info);
getChildView("combobox texgen")->setVisible(show_material || show_media || show_texture_info);
getChildView("button align textures")->setVisible(show_material || show_media);
// Media controls
@ -4538,54 +4675,78 @@ void LLPanelFace::onCommitPlanarAlign(LLUICtrl* ctrl, void* userdata)
self->sendTextureInfo();
}
// static
void LLPanelFace::onCommitGLTFTextureScaleU(LLUICtrl* ctrl, void* userdata)
void updateGLTFTextureTransform(float value, U32 pbr_type, std::function<void(LLGLTFMaterial::TextureTransform*)> edit)
{
#if 0
LLPanelFace* self = (LLPanelFace*)userdata;
LL_WARNS() << ctrl->getValue().asReal() << LL_ENDL; // TODO: Remove
// TODO
#endif
U32 texture_info_start;
U32 texture_info_end;
if (gSavedSettings.getBOOL("SyncMaterialSettings"))
{
texture_info_start = 0;
texture_info_end = LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT;
}
else
{
texture_info_start = texture_info_from_pbrtype(pbr_type);
texture_info_end = texture_info_start + 1;
}
updateSelectedGLTFMaterials([&](LLGLTFMaterial* new_override)
{
for (U32 ti = texture_info_start; ti < texture_info_end; ++ti)
{
LLGLTFMaterial::TextureTransform& new_transform = new_override->mTextureTransform[(LLGLTFMaterial::TextureInfo)ti];
edit(&new_transform);
}
});
}
// static
void LLPanelFace::onCommitGLTFTextureScaleV(LLUICtrl* ctrl, void* userdata)
void LLPanelFace::onCommitGLTFTextureScaleU(LLUICtrl* ctrl)
{
#if 0
LLPanelFace* self = (LLPanelFace*)userdata;
LL_WARNS() << ctrl->getValue().asReal() << LL_ENDL; // TODO: Remove
// TODO
#endif
const float value = ctrl->getValue().asReal();
const U32 pbr_type = findChild<LLRadioGroup>("radio_pbr_type")->getSelectedIndex();
updateGLTFTextureTransform(value, pbr_type, [&](LLGLTFMaterial::TextureTransform* new_transform)
{
new_transform->mScale.mV[VX] = value;
});
}
// static
void LLPanelFace::onCommitGLTFRotation(LLUICtrl* ctrl, void* userdata)
void LLPanelFace::onCommitGLTFTextureScaleV(LLUICtrl* ctrl)
{
#if 0
LLPanelFace* self = (LLPanelFace*)userdata;
LL_WARNS() << ctrl->getValue().asReal() << LL_ENDL; // TODO: Remove
// TODO
#endif
const float value = ctrl->getValue().asReal();
const U32 pbr_type = findChild<LLRadioGroup>("radio_pbr_type")->getSelectedIndex();
updateGLTFTextureTransform(value, pbr_type, [&](LLGLTFMaterial::TextureTransform* new_transform)
{
new_transform->mScale.mV[VY] = value;
});
}
// static
void LLPanelFace::onCommitGLTFTextureTranslationU(LLUICtrl* ctrl, void* userdata)
void LLPanelFace::onCommitGLTFRotation(LLUICtrl* ctrl)
{
#if 0
LLPanelFace* self = (LLPanelFace*)userdata;
LL_WARNS() << ctrl->getValue().asReal() << LL_ENDL; // TODO: Remove
// TODO
#endif
const float value = ctrl->getValue().asReal() * DEG_TO_RAD;
const U32 pbr_type = findChild<LLRadioGroup>("radio_pbr_type")->getSelectedIndex();
updateGLTFTextureTransform(value, pbr_type, [&](LLGLTFMaterial::TextureTransform* new_transform)
{
new_transform->mRotation = value;
});
}
// static
void LLPanelFace::onCommitGLTFTextureTranslationV(LLUICtrl* ctrl, void* userdata)
void LLPanelFace::onCommitGLTFTextureOffsetU(LLUICtrl* ctrl)
{
#if 0
LLPanelFace* self = (LLPanelFace*)userdata;
LL_WARNS() << ctrl->getValue().asReal() << LL_ENDL; // TODO: Remove
// TODO
#endif
const float value = ctrl->getValue().asReal();
const U32 pbr_type = findChild<LLRadioGroup>("radio_pbr_type")->getSelectedIndex();
updateGLTFTextureTransform(value, pbr_type, [&](LLGLTFMaterial::TextureTransform* new_transform)
{
new_transform->mOffset.mV[VX] = value;
});
}
void LLPanelFace::onCommitGLTFTextureOffsetV(LLUICtrl* ctrl)
{
const float value = ctrl->getValue().asReal();
const U32 pbr_type = findChild<LLRadioGroup>("radio_pbr_type")->getSelectedIndex();
updateGLTFTextureTransform(value, pbr_type, [&](LLGLTFMaterial::TextureTransform* new_transform)
{
new_transform->mOffset.mV[VY] = value;
});
}
void LLPanelFace::onTextureSelectionChanged(LLInventoryItem* itemp)

10
indra/newview/llpanelface.h
View File

@ -229,11 +229,11 @@ protected:
static void onCommitGlow( LLUICtrl* ctrl, void *userdata);
static void onCommitPlanarAlign( LLUICtrl* ctrl, void* userdata);
static void onCommitRepeatsPerMeter( LLUICtrl* ctrl, void* userinfo);
static void onCommitGLTFTextureScaleU(LLUICtrl* ctrl, void* userinfo);
static void onCommitGLTFTextureScaleV(LLUICtrl* ctrl, void* userinfo);
static void onCommitGLTFRotation(LLUICtrl* ctrl, void* userinfo);
static void onCommitGLTFTextureTranslationU(LLUICtrl* ctrl, void* userinfo);
static void onCommitGLTFTextureTranslationV(LLUICtrl* ctrl, void* userinfo);
void onCommitGLTFTextureScaleU(LLUICtrl* ctrl);
void onCommitGLTFTextureScaleV(LLUICtrl* ctrl);
void onCommitGLTFRotation(LLUICtrl* ctrl);
void onCommitGLTFTextureOffsetU(LLUICtrl* ctrl);
void onCommitGLTFTextureOffsetV(LLUICtrl* ctrl);
static void onClickAutoFix(void*);
static void onAlignTexture(void*);
static void onClickBtnLoadInvPBR(void* userdata);

56
indra/newview/lltexturectrl.cpp
View File

@ -301,8 +301,24 @@ BOOL LLFloaterTexturePicker::handleDragAndDrop(
BOOL handled = FALSE;
bool is_mesh = cargo_type == DAD_MESH;
bool is_texture = cargo_type == DAD_TEXTURE;
bool is_material = cargo_type == DAD_MATERIAL;
if ((cargo_type == DAD_TEXTURE) || is_mesh)
bool allow_dnd = false;
if (mInventoryPickType == LLTextureCtrl::PICK_MATERIAL)
{
allow_dnd = is_material;
}
else if (mInventoryPickType == LLTextureCtrl::PICK_TEXTURE)
{
allow_dnd = is_texture || is_mesh;
}
else
{
allow_dnd = is_texture || is_mesh || is_material;
}
if (allow_dnd)
{
LLInventoryItem *item = (LLInventoryItem *)cargo_data;
@ -1246,6 +1262,21 @@ void LLFloaterTexturePicker::setInventoryPickType(LLTextureCtrl::EPickInventoryT
S32 index = mModeSelector->getValue().asInteger();
getChild<LLButton>("Pipette")->setVisible(index == 0);
}
if (!mLabel.empty())
{
std::string pick = getString("pick title");
setTitle(pick + mLabel);
}
else if(mInventoryPickType == LLTextureCtrl::PICK_MATERIAL)
{
setTitle(getString("pick_material"));
}
else
{
setTitle(getString("pick_texture"));
}
}
void LLFloaterTexturePicker::onPickerCallback(const std::vector<std::string>& filenames, LLHandle<LLFloater> handle)
@ -1770,11 +1801,26 @@ BOOL LLTextureCtrl::handleDragAndDrop(S32 x, S32 y, MASK mask,
// returns true, then the cast was valid, and we can perform
// the third test without problems.
LLInventoryItem* item = (LLInventoryItem*)cargo_data;
bool is_mesh = cargo_type == DAD_MESH;
if (getEnabled() &&
((cargo_type == DAD_TEXTURE) || is_mesh) &&
allowDrop(item))
bool is_mesh = cargo_type == DAD_MESH;
bool is_texture = cargo_type == DAD_TEXTURE;
bool is_material = cargo_type == DAD_MATERIAL;
bool allow_dnd = false;
if (mInventoryPickType == LLTextureCtrl::PICK_MATERIAL)
{
allow_dnd = is_material;
}
else if (mInventoryPickType == LLTextureCtrl::PICK_TEXTURE)
{
allow_dnd = is_texture || is_mesh;
}
else
{
allow_dnd = is_texture || is_mesh || is_material;
}
if (getEnabled() && allow_dnd && allowDrop(item))
{
if (drop)
{

10
indra/newview/skins/default/xui/en/floater_texture_ctrl.xml
View File

@ -19,7 +19,15 @@
</floater.string>
<floater.string
name="pick title">
Pick:
Pick:
</floater.string>
<floater.string
name="pick_material">
PICK: MATERIAL
</floater.string>
<floater.string
name="pick_texture">
PICK: TEXTURE
</floater.string>
<view

24
indra/newview/skins/default/xui/en/panel_tools_texture.xml
View File

@ -896,10 +896,12 @@
follows="left|top"
height="19"
initial_value="1"
label="ScaleU"
label="Scale u"
label_width="205"
layout="topleft"
left="10"
min_val="-100"
max_val="100"
name="gltfTextureScaleU"
top_delta="-115"
width="265" />
@ -907,10 +909,12 @@
follows="left|top"
height="19"
initial_value="1"
label="ScaleV"
label="Scale v"
label_width="205"
layout="topleft"
left="10"
min_val="-100"
max_val="100"
name="gltfTextureScaleV"
width="265" />
<spinner
@ -921,27 +925,33 @@
label_width="205"
layout="topleft"
left="10"
min_val="-360"
max_val="360"
name="gltfTextureRotation"
width="265" />
<spinner
follows="left|top"
height="19"
initial_value="0"
label="TranslationU"
label="Offset u"
label_width="205"
layout="topleft"
left="10"
name="gltfTextureTranslationU"
min_val="-999"
max_val="999"
name="gltfTextureOffsetU"
width="265" />
<spinner
follows="left|top"
height="19"
initial_value="0"
label="TranslationV"
label="Offset v"
label_width="205"
layout="topleft"
left="10"
name="gltfTextureTranslationV"
min_val="-999"
max_val="999"
name="gltfTextureOffsetV"
width="265" />
<!-- END PBR Material texture transform parameters -->
<check_box
@ -953,7 +963,7 @@
left="7"
name="checkbox planar align"
tool_tip="Align textures on all selected faces with the last selected face. Requires Planar texture mapping."
top_delta="16"
top_delta="43"
width="260" />
<button
follows="left|top"