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

Merged in SL-18485 (pull request #1183) 

SL-18485: Render GLTF materials with extension KHR_texture_transform with approprate texture transforms
master
Sabrina Shanman 2022-11-02 20:10:04 +00:00
parent 106b1a6e6a 9e7b725c15
commit 81011a318e
12 changed files with 241 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
indra/llprimitive/llgltfmaterial.cpp
View File

@ -39,6 +39,28 @@ const char* GLTF_FILE_EXTENSION_TRANSFORM_ROTATION = "rotation";
// special UUID that indicates a null UUID in override data
static const LLUUID GLTF_OVERRIDE_NULL_UUID = LLUUID("ffffffff-ffff-ffff-ffff-ffffffffffff");
// https://github.com/KhronosGroup/glTF/tree/main/extensions/3.0/Khronos/KHR_texture_transform
LLMatrix3 LLGLTFMaterial::TextureTransform::asMatrix()
{
LLMatrix3 scale;
scale.mMatrix[0][0] = mScale[0];
scale.mMatrix[1][1] = mScale[1];
LLMatrix3 rotation;
const F32 cos_r = cos(mRotation);
const F32 sin_r = sin(mRotation);
rotation.mMatrix[0][0] = cos_r;
rotation.mMatrix[0][1] = sin_r;
rotation.mMatrix[1][0] = -sin_r;
rotation.mMatrix[1][1] = cos_r;
LLMatrix3 offset;
offset.mMatrix[2][0] = mOffset[0];
offset.mMatrix[2][1] = mOffset[1];
return offset * rotation * scale;
}
LLGLTFMaterial::LLGLTFMaterial(const LLGLTFMaterial& rhs)
{
*this = rhs;

3
indra/llprimitive/llgltfmaterial.h
View File

@ -28,6 +28,7 @@
#include "llrefcount.h"
#include "llmemory.h"
#include "m3math.h"
#include "v4color.h"
#include "v3color.h"
#include "v2math.h"
@ -53,6 +54,8 @@ public:
LLVector2 mOffset = { 0.f, 0.f };
LLVector2 mScale = { 1.f, 1.f };
F32 mRotation = 0.f;
LLMatrix3 asMatrix();
};
enum AlphaMode

10
indra/llrender/llshadermgr.cpp
View File

@ -1163,6 +1163,10 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedAttribs.push_back("weight4");
mReservedAttribs.push_back("clothing");
mReservedAttribs.push_back("texture_index");
mReservedAttribs.push_back("basecolor_texcoord"); // GLTF
mReservedAttribs.push_back("normal_texcoord"); // GLTF
mReservedAttribs.push_back("metallic_roughness_texcoord"); // GLTF
mReservedAttribs.push_back("emissive_texcoord"); // GLTF
//matrix state
mReservedUniforms.push_back("modelview_matrix");
@ -1177,7 +1181,11 @@ void LLShaderMgr::initAttribsAndUniforms()
mReservedUniforms.push_back("texture_matrix3");
mReservedUniforms.push_back("object_plane_s");
mReservedUniforms.push_back("object_plane_t");
llassert(mReservedUniforms.size() == LLShaderMgr::OBJECT_PLANE_T+1);
mReservedUniforms.push_back("texture_basecolor_matrix"); // GLTF
mReservedUniforms.push_back("texture_normal_matrix"); // GLTF
mReservedUniforms.push_back("texture_metallic_roughness_matrix"); // GLTF
mReservedUniforms.push_back("texture_emissive_matrix"); // GLTF
llassert(mReservedUniforms.size() == LLShaderMgr::TEXTURE_EMISSIVE_MATRIX+1);
mReservedUniforms.push_back("viewport");

4
indra/llrender/llshadermgr.h
View File

@ -51,6 +51,10 @@ public:
TEXTURE_MATRIX3, // "texture_matrix3"
OBJECT_PLANE_S, // "object_plane_s"
OBJECT_PLANE_T, // "object_plane_t"
TEXTURE_BASECOLOR_MATRIX, // "texture_basecolor_matrix" (GLTF)
TEXTURE_NORMAL_MATRIX, // "texture_normal_matrix" (GLTF)
TEXTURE_METALLIC_ROUGHNESS_MATRIX, // "texture_metallic_roughness_matrix" (GLTF)
TEXTURE_EMISSIVE_MATRIX, // "texture_emissive_matrix" (GLTF)
VIEWPORT, // "viewport"
LIGHT_POSITION, // "light_position"
LIGHT_DIRECTION, // "light_direction"

92
indra/llrender/llvertexbuffer.cpp
View File

@ -358,6 +358,10 @@ const S32 LLVertexBuffer::sTypeSize[LLVertexBuffer::TYPE_MAX] =
sizeof(LLVector4), // TYPE_WEIGHT4,
sizeof(LLVector4), // TYPE_CLOTHWEIGHT,
sizeof(LLVector4), // TYPE_TEXTURE_INDEX (actually exists as position.w), no extra data, but stride is 16 bytes
sizeof(LLVector2), // TYPE_BASECOLOR_TEXCOORD,
sizeof(LLVector2), // TYPE_NORMAL_TEXCOORD,
sizeof(LLVector2), // TYPE_METALLIC_ROUGHNESS_TEXCOORD,
sizeof(LLVector2), // TYPE_EMISSIVE_TEXCOORD,
};
static const std::string vb_type_name[] =
@ -375,6 +379,10 @@ static const std::string vb_type_name[] =
"TYPE_WEIGHT4",
"TYPE_CLOTHWEIGHT",
"TYPE_TEXTURE_INDEX",
"TYPE_BASECOLOR_TEXCOORD",
"TYPE_NORMAL_TEXCOORD",
"TYPE_METALLIC_ROUGHNESS_TEXCOORD",
"TYPE_EMISSIVE_TEXCOORD",
"TYPE_MAX",
"TYPE_INDEX",
};
@ -1270,6 +1278,10 @@ void LLVertexBuffer::setupVertexArray()
4, //TYPE_WEIGHT4,
4, //TYPE_CLOTHWEIGHT,
1, //TYPE_TEXTURE_INDEX
2, // TYPE_BASECOLOR_TEXCOORD,
2, // TYPE_NORMAL_TEXCOORD,
2, // TYPE_METALLIC_ROUGHNESS_TEXCOORD,
2, // TYPE_EMISSIVE_TEXCOORD,
};
static const U32 attrib_type[] =
@ -1287,6 +1299,10 @@ void LLVertexBuffer::setupVertexArray()
GL_FLOAT, //TYPE_WEIGHT4,
GL_FLOAT, //TYPE_CLOTHWEIGHT,
GL_UNSIGNED_INT, //TYPE_TEXTURE_INDEX
GL_FLOAT, // TYPE_BASECOLOR_TEXCOORD,
GL_FLOAT, // TYPE_NORMAL_TEXCOORD,
GL_FLOAT, // TYPE_METALLIC_ROUGHNESS_TEXCOORD,
GL_FLOAT, // TYPE_EMISSIVE_TEXCOORD,
};
static const bool attrib_integer[] =
@ -1304,6 +1320,10 @@ void LLVertexBuffer::setupVertexArray()
false, //TYPE_WEIGHT4,
false, //TYPE_CLOTHWEIGHT,
true, //TYPE_TEXTURE_INDEX
false, // TYPE_BASECOLOR_TEXCOORD,
false, // TYPE_NORMAL_TEXCOORD,
false, // TYPE_METALLIC_ROUGHNESS_TEXCOORD,
false, // TYPE_EMISSIVE_TEXCOORD,
};
static const U32 attrib_normalized[] =
@ -1321,6 +1341,10 @@ void LLVertexBuffer::setupVertexArray()
GL_FALSE, //TYPE_WEIGHT4,
GL_FALSE, //TYPE_CLOTHWEIGHT,
GL_FALSE, //TYPE_TEXTURE_INDEX
GL_FALSE, // TYPE_BASECOLOR_TEXCOORD,
GL_FALSE, // TYPE_NORMAL_TEXCOORD,
GL_FALSE, // TYPE_METALLIC_ROUGHNESS_TEXCOORD,
GL_FALSE, // TYPE_EMISSIVE_TEXCOORD,
};
bindGLBuffer(true);
@ -1961,6 +1985,26 @@ bool LLVertexBuffer::getClothWeightStrider(LLStrider<LLVector4>& strider, S32 in
return VertexBufferStrider<LLVector4,TYPE_CLOTHWEIGHT>::get(*this, strider, index, count, map_range);
}
bool LLVertexBuffer::getBasecolorTexcoordStrider(LLStrider<LLVector2>& strider, S32 index, S32 count, bool map_range)
{
return VertexBufferStrider<LLVector2,TYPE_BASECOLOR_TEXCOORD>::get(*this, strider, index, count, map_range);
}
bool LLVertexBuffer::getNormalTexcoordStrider(LLStrider<LLVector2>& strider, S32 index, S32 count, bool map_range)
{
return VertexBufferStrider<LLVector2,TYPE_NORMAL_TEXCOORD>::get(*this, strider, index, count, map_range);
}
bool LLVertexBuffer::getMetallicRoughnessTexcoordStrider(LLStrider<LLVector2>& strider, S32 index, S32 count, bool map_range)
{
return VertexBufferStrider<LLVector2,TYPE_METALLIC_ROUGHNESS_TEXCOORD>::get(*this, strider, index, count, map_range);
}
bool LLVertexBuffer::getEmissiveTexcoordStrider(LLStrider<LLVector2>& strider, S32 index, S32 count, bool map_range)
{
return VertexBufferStrider<LLVector2,TYPE_EMISSIVE_TEXCOORD>::get(*this, strider, index, count, map_range);
}
//----------------------------------------------------------------------------
bool LLVertexBuffer::bindGLArray()
@ -2379,6 +2423,30 @@ void LLVertexBuffer::setupVertexBuffer(U32 data_mask)
void* ptr = (void*)(base + mOffsets[TYPE_VERTEX]);
glVertexAttribPointer(loc, 3,GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_VERTEX], ptr);
}
if (data_mask & MAP_BASECOLOR_TEXCOORD)
{
S32 loc = TYPE_BASECOLOR_TEXCOORD;
void* ptr = (void*)(base + mOffsets[TYPE_BASECOLOR_TEXCOORD]);
glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_BASECOLOR_TEXCOORD], ptr);
}
if (data_mask & MAP_NORMAL_TEXCOORD)
{
S32 loc = TYPE_NORMAL_TEXCOORD;
void* ptr = (void*)(base + mOffsets[TYPE_NORMAL_TEXCOORD]);
glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_NORMAL_TEXCOORD], ptr);
}
if (data_mask & MAP_METALLIC_ROUGHNESS_TEXCOORD)
{
S32 loc = TYPE_METALLIC_ROUGHNESS_TEXCOORD;
void* ptr = (void*)(base + mOffsets[TYPE_METALLIC_ROUGHNESS_TEXCOORD]);
glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_METALLIC_ROUGHNESS_TEXCOORD], ptr);
}
if (data_mask & MAP_EMISSIVE_TEXCOORD)
{
S32 loc = TYPE_EMISSIVE_TEXCOORD;
void* ptr = (void*)(base + mOffsets[TYPE_EMISSIVE_TEXCOORD]);
glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_EMISSIVE_TEXCOORD], ptr);
}
llglassertok();
}
@ -2472,6 +2540,30 @@ void LLVertexBuffer::setupVertexBufferFast(U32 data_mask)
void* ptr = (void*)(base + mOffsets[TYPE_VERTEX]);
glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_VERTEX], ptr);
}
if (data_mask & MAP_BASECOLOR_TEXCOORD)
{
S32 loc = TYPE_BASECOLOR_TEXCOORD;
void* ptr = (void*)(base + mOffsets[TYPE_BASECOLOR_TEXCOORD]);
glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_BASECOLOR_TEXCOORD], ptr);
}
if (data_mask & MAP_NORMAL_TEXCOORD)
{
S32 loc = TYPE_NORMAL_TEXCOORD;
void* ptr = (void*)(base + mOffsets[TYPE_NORMAL_TEXCOORD]);
glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_NORMAL_TEXCOORD], ptr);
}
if (data_mask & MAP_METALLIC_ROUGHNESS_TEXCOORD)
{
S32 loc = TYPE_METALLIC_ROUGHNESS_TEXCOORD;
void* ptr = (void*)(base + mOffsets[TYPE_METALLIC_ROUGHNESS_TEXCOORD]);
glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_METALLIC_ROUGHNESS_TEXCOORD], ptr);
}
if (data_mask & MAP_EMISSIVE_TEXCOORD)
{
S32 loc = TYPE_EMISSIVE_TEXCOORD;
void* ptr = (void*)(base + mOffsets[TYPE_EMISSIVE_TEXCOORD]);
glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_EMISSIVE_TEXCOORD], ptr);
}
}
LLVertexBuffer::MappedRegion::MappedRegion(S32 type, S32 index, S32 count)

24
indra/llrender/llvertexbuffer.h
View File

@ -160,11 +160,12 @@ public:
//WARNING -- when updating these enums you MUST
// 1 - update LLVertexBuffer::sTypeSize
// 2 - add a strider accessor
// 3 - modify LLVertexBuffer::setupVertexBuffer
// 4 - modify LLVertexBuffer::setupClientArray
// 5 - modify LLViewerShaderMgr::mReservedAttribs
// 6 - update LLVertexBuffer::setupVertexArray
// 2 - update LLVertexBuffer::vb_type_name
// 3 - add a strider accessor
// 4 - modify LLVertexBuffer::setupVertexBuffer
// 5 - modify LLVertexBuffer::setupVertexBufferFast
// 6 - modify LLViewerShaderMgr::mReservedAttribs
// 7 - update LLVertexBuffer::setupVertexArray
// clang-format off
enum { // Shader attribute name, set in LLShaderMgr::initAttribsAndUniforms()
@ -181,6 +182,10 @@ public:
TYPE_WEIGHT4, // "weight4"
TYPE_CLOTHWEIGHT, // "clothing"
TYPE_TEXTURE_INDEX, // "texture_index"
TYPE_BASECOLOR_TEXCOORD, // "basecolor_texcoord" (GLTF)
TYPE_NORMAL_TEXCOORD, // "normal_texcoord" (GLTF)
TYPE_METALLIC_ROUGHNESS_TEXCOORD, // "metallic_roughness_texcoord" (GLTF)
TYPE_EMISSIVE_TEXCOORD, // "emissive_texcoord" (GLTF)
TYPE_MAX, // TYPE_MAX is the size/boundary marker for attributes that go in the vertex buffer
TYPE_INDEX, // TYPE_INDEX is beyond _MAX because it lives in a separate (index) buffer
};
@ -195,12 +200,15 @@ public:
MAP_TEXCOORD3 = (1<<TYPE_TEXCOORD3),
MAP_COLOR = (1<<TYPE_COLOR),
MAP_EMISSIVE = (1<<TYPE_EMISSIVE),
// These use VertexAttribPointer and should possibly be made generic
MAP_TANGENT = (1<<TYPE_TANGENT),
MAP_WEIGHT = (1<<TYPE_WEIGHT),
MAP_WEIGHT4 = (1<<TYPE_WEIGHT4),
MAP_CLOTHWEIGHT = (1<<TYPE_CLOTHWEIGHT),
MAP_TEXTURE_INDEX = (1<<TYPE_TEXTURE_INDEX),
MAP_BASECOLOR_TEXCOORD = (1<<TYPE_BASECOLOR_TEXCOORD),
MAP_NORMAL_TEXCOORD = (1<<TYPE_NORMAL_TEXCOORD),
MAP_METALLIC_ROUGHNESS_TEXCOORD = (1<<TYPE_METALLIC_ROUGHNESS_TEXCOORD),
MAP_EMISSIVE_TEXCOORD = (1<<TYPE_EMISSIVE_TEXCOORD),
};
protected:
@ -269,6 +277,10 @@ public:
bool getWeightStrider(LLStrider<F32>& strider, S32 index=0, S32 count = -1, bool map_range = false);
bool getWeight4Strider(LLStrider<LLVector4>& strider, S32 index=0, S32 count = -1, bool map_range = false);
bool getClothWeightStrider(LLStrider<LLVector4>& strider, S32 index=0, S32 count = -1, bool map_range = false);
bool getBasecolorTexcoordStrider(LLStrider<LLVector2>& strider, S32 index=0, S32 count = -1, bool map_range = false);
bool getNormalTexcoordStrider(LLStrider<LLVector2>& strider, S32 index=0, S32 count = -1, bool map_range = false);
bool getMetallicRoughnessTexcoordStrider(LLStrider<LLVector2>& strider, S32 index=0, S32 count = -1, bool map_range = false);
bool getEmissiveTexcoordStrider(LLStrider<LLVector2>& strider, S32 index=0, S32 count = -1, bool map_range = false);
bool useVBOs() const;

40
indra/newview/app_settings/shaders/class1/deferred/pbralphaV.glsl
View File

@ -44,29 +44,32 @@ uniform mat4 modelview_projection_matrix;
VARYING vec3 vary_position;
#endif
uniform mat4 texture_matrix0;
uniform mat3 texture_basecolor_matrix;
uniform mat3 texture_normal_matrix;
uniform mat3 texture_metallic_roughness_matrix;
uniform mat3 texture_emissive_matrix;
#ifdef HAS_SUN_SHADOW
VARYING vec3 vary_fragcoord;
out vec3 vary_fragcoord;
uniform float near_clip;
#endif
ATTRIBUTE vec3 position;
ATTRIBUTE vec4 diffuse_color;
ATTRIBUTE vec3 normal;
ATTRIBUTE vec4 tangent;
ATTRIBUTE vec2 texcoord0;
ATTRIBUTE vec2 texcoord1;
ATTRIBUTE vec2 texcoord2;
in vec3 position;
in vec4 diffuse_color;
in vec3 normal;
in vec4 tangent;
in vec2 texcoord0;
out vec2 basecolor_texcoord;
out vec2 normal_texcoord;
out vec2 metallic_roughness_texcoord;
out vec2 emissive_texcoord;
VARYING vec4 vertex_color;
VARYING vec2 vary_texcoord0;
VARYING vec2 vary_texcoord1;
VARYING vec2 vary_texcoord2;
VARYING vec3 vary_normal;
VARYING vec3 vary_tangent;
out vec4 vertex_color;
out vec3 vary_tangent;
flat out float vary_sign;
out vec3 vary_normal;
void main()
@ -89,9 +92,10 @@ void main()
vary_fragcoord.xyz = vert.xyz + vec3(0,0,near_clip);
#endif
vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
vary_texcoord1 = (texture_matrix0 * vec4(texcoord1,0,1)).xy;
vary_texcoord2 = (texture_matrix0 * vec4(texcoord2,0,1)).xy;
basecolor_texcoord = (texture_basecolor_matrix * vec3(texcoord0,1)).xy;
normal_texcoord = (texture_normal_matrix * vec3(texcoord0,1)).xy;
metallic_roughness_texcoord = (texture_metallic_roughness_matrix * vec3(texcoord0,1)).xy;
emissive_texcoord = (texture_emissive_matrix * vec3(texcoord0,1)).xy;
#ifdef HAS_SKIN
vec3 n = (mat*vec4(normal.xyz+position.xyz,1.0)).xyz-pos.xyz;

30
indra/newview/app_settings/shaders/class1/deferred/pbropaqueF.glsl
View File

@ -36,15 +36,16 @@ uniform sampler2D specularMap; // Packed: Occlusion, Metal, Roughness
out vec4 frag_data[4];
VARYING vec3 vary_position;
VARYING vec4 vertex_color;
VARYING vec3 vary_normal;
VARYING vec3 vary_tangent;
in vec3 vary_position;
in vec4 vertex_color;
in vec3 vary_normal;
in vec3 vary_tangent;
flat in float vary_sign;
VARYING vec2 vary_texcoord0;
VARYING vec2 vary_texcoord1;
VARYING vec2 vary_texcoord2;
in vec2 basecolor_texcoord;
in vec2 normal_texcoord;
in vec2 metallic_roughness_texcoord;
in vec2 emissive_texcoord;
uniform float minimum_alpha; // PBR alphaMode: MASK, See: mAlphaCutoff, setAlphaCutoff()
@ -56,19 +57,16 @@ uniform mat3 normal_matrix;
void main()
{
// IF .mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
// vec3 col = vertex_color.rgb * diffuseLookup(vary_texcoord0.xy).rgb;
// else
vec4 albedo = texture2D(diffuseMap, vary_texcoord0.xy).rgba;
if (albedo.a < minimum_alpha)
vec4 basecolor = texture2D(diffuseMap, basecolor_texcoord.xy).rgba;
if (basecolor.a < minimum_alpha)
{
discard;
}
vec3 col = vertex_color.rgb * srgb_to_linear(albedo.rgb);
vec3 col = vertex_color.rgb * srgb_to_linear(basecolor.rgb);
// from mikktspace.com
vec3 vNt = texture2D(bumpMap, vary_texcoord1.xy).xyz*2.0-1.0;
vec3 vNt = texture2D(bumpMap, normal_texcoord.xy).xyz*2.0-1.0;
float sign = vary_sign;
vec3 vN = vary_normal;
vec3 vT = vary_tangent.xyz;
@ -81,13 +79,13 @@ void main()
// occlusion 1.0
// roughness 0.0
// metal 0.0
vec3 spec = texture2D(specularMap, vary_texcoord2.xy).rgb;
vec3 spec = texture2D(specularMap, metallic_roughness_texcoord.xy).rgb;
spec.g *= roughnessFactor;
spec.b *= metallicFactor;
vec3 emissive = emissiveColor;
emissive *= srgb_to_linear(texture2D(emissiveMap, vary_texcoord0.xy).rgb);
emissive *= srgb_to_linear(texture2D(emissiveMap, emissive_texcoord.xy).rgb);
tnorm *= gl_FrontFacing ? 1.0 : -1.0;

38
indra/newview/app_settings/shaders/class1/deferred/pbropaqueV.glsl
View File

@ -37,25 +37,27 @@ uniform mat3 normal_matrix;
uniform mat4 modelview_projection_matrix;
#endif
uniform mat4 texture_matrix0;
uniform mat3 texture_basecolor_matrix;
uniform mat3 texture_normal_matrix;
uniform mat3 texture_metallic_roughness_matrix;
uniform mat3 texture_emissive_matrix;
ATTRIBUTE vec3 position;
ATTRIBUTE vec4 diffuse_color;
ATTRIBUTE vec3 normal;
ATTRIBUTE vec4 tangent;
ATTRIBUTE vec2 texcoord0;
ATTRIBUTE vec2 texcoord1;
ATTRIBUTE vec2 texcoord2;
in vec3 position;
in vec4 diffuse_color;
in vec3 normal;
in vec4 tangent;
in vec2 texcoord0;
VARYING vec2 vary_texcoord0;
VARYING vec2 vary_texcoord1;
VARYING vec2 vary_texcoord2;
out vec2 basecolor_texcoord;
out vec2 normal_texcoord;
out vec2 metallic_roughness_texcoord;
out vec2 emissive_texcoord;
VARYING vec4 vertex_color;
out vec4 vertex_color;
VARYING vec3 vary_tangent;
out vec3 vary_tangent;
flat out float vary_sign;
VARYING vec3 vary_normal;
out vec3 vary_normal;
void main()
{
@ -73,9 +75,11 @@ void main()
gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0);
#endif
vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
vary_texcoord1 = (texture_matrix0 * vec4(texcoord1,0,1)).xy;
vary_texcoord2 = (texture_matrix0 * vec4(texcoord2,0,1)).xy;
basecolor_texcoord = (texture_basecolor_matrix * vec3(texcoord0,1)).xy;
normal_texcoord = (texture_normal_matrix * vec3(texcoord0,1)).xy;
metallic_roughness_texcoord = (texture_metallic_roughness_matrix * vec3(texcoord0,1)).xy;
emissive_texcoord = (texture_emissive_matrix * vec3(texcoord0,1)).xy;
#ifdef HAS_SKIN
vec3 n = (mat*vec4(normal.xyz+position.xyz,1.0)).xyz-pos.xyz;
vec3 t = (mat*vec4(tangent.xyz+position.xyz,1.0)).xyz-pos.xyz;

41
indra/newview/app_settings/shaders/class2/deferred/pbralphaF.glsl
View File

@ -45,17 +45,21 @@ uniform vec3 moon_dir;
out vec4 frag_color;
#ifdef HAS_SUN_SHADOW
VARYING vec3 vary_fragcoord;
in vec3 vary_fragcoord;
uniform vec2 screen_res;
#endif
VARYING vec3 vary_position;
VARYING vec4 vertex_color;
VARYING vec2 vary_texcoord0;
VARYING vec2 vary_texcoord1;
VARYING vec2 vary_texcoord2;
VARYING vec3 vary_normal;
VARYING vec3 vary_tangent;
in vec3 vary_position;
in vec2 basecolor_texcoord;
in vec2 normal_texcoord;
in vec2 metallic_roughness_texcoord;
in vec2 emissive_texcoord;
in vec4 vertex_color;
in vec3 vary_normal;
in vec3 vary_tangent;
flat in float vary_sign;
@ -155,21 +159,18 @@ void main()
waterClip(pos);
// IF .mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
// vec3 col = vertex_color.rgb * diffuseLookup(vary_texcoord0.xy).rgb;
// else
vec4 albedo = texture(diffuseMap, vary_texcoord0.xy).rgba;
albedo.rgb = srgb_to_linear(albedo.rgb);
vec4 basecolor = texture(diffuseMap, basecolor_texcoord.xy).rgba;
basecolor.rgb = srgb_to_linear(basecolor.rgb);
#ifdef HAS_ALPHA_MASK
if (albedo.a < minimum_alpha)
if (basecolor.a < minimum_alpha)
{
discard;
}
#endif
vec3 baseColor = vertex_color.rgb * albedo.rgb;
vec3 col = vertex_color.rgb * basecolor.rgb;
vec3 vNt = texture(bumpMap, vary_texcoord1.xy).xyz*2.0-1.0;
vec3 vNt = texture(bumpMap, normal_texcoord.xy).xyz*2.0-1.0;
float sign = vary_sign;
vec3 vN = vary_normal;
vec3 vT = vary_tangent.xyz;
@ -192,7 +193,7 @@ void main()
scol = sampleDirectionalShadow(pos.xyz, norm.xyz, frag);
#endif
vec3 orm = texture(specularMap, vary_texcoord2.xy).rgb; //orm is packed into "emissiveRect" to keep the data in linear color space
vec3 orm = texture(specularMap, metallic_roughness_texcoord.xy).rgb; //orm is packed into "emissiveRect" to keep the data in linear color space
float perceptualRoughness = orm.g * roughnessFactor;
float metallic = orm.b * metallicFactor;
@ -201,7 +202,7 @@ void main()
// emissiveColor is the emissive color factor from GLTF and is already in linear space
vec3 colorEmissive = emissiveColor;
// emissiveMap here is a vanilla RGB texture encoded as sRGB, manually convert to linear
colorEmissive *= srgb_to_linear(texture2D(emissiveMap, vary_texcoord0.xy).rgb);
colorEmissive *= srgb_to_linear(texture2D(emissiveMap, emissive_texcoord.xy).rgb);
// PBR IBL
float gloss = 1.0 - perceptualRoughness;
@ -214,7 +215,7 @@ void main()
vec3 diffuseColor;
vec3 specularColor;
calcDiffuseSpecular(baseColor.rgb, metallic, diffuseColor, specularColor);
calcDiffuseSpecular(col.rgb, metallic, diffuseColor, specularColor);
vec3 v = -normalize(pos.xyz);
color = pbrBaseLight(diffuseColor, specularColor, metallic, v, norm.xyz, perceptualRoughness, light_dir, sunlit, scol, radiance, irradiance, colorEmissive, ao, additive, atten);
@ -235,5 +236,5 @@ void main()
color.rgb += light.rgb;
frag_color = vec4(color.rgb,albedo.a * vertex_color.a);
frag_color = vec4(color.rgb,basecolor.a * vertex_color.a);
}

6
indra/newview/llface.cpp
View File

@ -1601,6 +1601,12 @@ BOOL LLFace::getGeometryVolume(const LLVolume& volume,
LLMaterial* mat = tep->getMaterialParams().get();
LLGLTFMaterial* gltf_mat = tep->getGLTFRenderMaterial();
if (gltf_mat)
{
// Transforms will be applied later
do_xform = false;
}
bool do_bump = bump_code && mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_TEXCOORD1);
if ((mat || gltf_mat) && !do_bump)

9
indra/newview/llfetchedgltfmaterial.cpp
View File

@ -101,6 +101,15 @@ void LLFetchedGLTFMaterial::bind(LLGLSLShader* shader)
shader->uniform1f(LLShaderMgr::ROUGHNESS_FACTOR, mRoughnessFactor);
shader->uniform1f(LLShaderMgr::METALLIC_FACTOR, mMetallicFactor);
shader->uniform3fv(LLShaderMgr::EMISSIVE_COLOR, 1, mEmissiveColor.mV);
const LLMatrix3 base_color_matrix = mTextureTransform[GLTF_TEXTURE_INFO_BASE_COLOR].asMatrix();
shader->uniformMatrix3fv(LLShaderMgr::TEXTURE_BASECOLOR_MATRIX, 1, false, (F32*)base_color_matrix.mMatrix);
const LLMatrix3 normal_matrix = mTextureTransform[GLTF_TEXTURE_INFO_NORMAL].asMatrix();
shader->uniformMatrix3fv(LLShaderMgr::TEXTURE_NORMAL_MATRIX, 1, false, (F32*)normal_matrix.mMatrix);
const LLMatrix3 metallic_roughness_matrix = mTextureTransform[GLTF_TEXTURE_INFO_METALLIC_ROUGHNESS].asMatrix();
shader->uniformMatrix3fv(LLShaderMgr::TEXTURE_METALLIC_ROUGHNESS_MATRIX, 1, false, (F32*)metallic_roughness_matrix.mMatrix);
const LLMatrix3 emissive_matrix = mTextureTransform[GLTF_TEXTURE_INFO_EMISSIVE].asMatrix();
shader->uniformMatrix3fv(LLShaderMgr::TEXTURE_EMISSIVE_MATRIX, 1, false, (F32*)emissive_matrix.mMatrix);
}
}