Added many other
This commit is contained in:
@@ -0,0 +1,845 @@
|
||||
#if UNITY_EDITOR
|
||||
|
||||
//#define SUPPORT_MBLOCKS
|
||||
|
||||
using UnityEngine;
|
||||
using UnityEditor;
|
||||
using System.IO;
|
||||
using System.Reflection;
|
||||
|
||||
public class ftUVGBufferGen
|
||||
{
|
||||
static RenderTexture rtAlbedo, rtEmissive, rtNormal, rtAlpha;
|
||||
public static Texture2D texAlbedo, texEmissive, texNormal, texBestFit, texAlpha;
|
||||
//static GameObject dummyCamGO;
|
||||
//static Camera dummyCam;
|
||||
static float texelSize;
|
||||
//static Vector4 shaBlack, shaWhite;
|
||||
static Material matFromRGBM;
|
||||
static Material matDilate, matMultiply;
|
||||
static bool emissiveEnabled = false;
|
||||
static bool normalEnabled = false;
|
||||
static bool alphaEnabled = false;
|
||||
static Vector4 metaControl, metaControlAlbedo, metaControlEmission, metaControlNormal, metaControlAlpha;
|
||||
static Material fallbackMat, normalMat, blackMat;
|
||||
static int fallbackMatMetaPass;
|
||||
static BakeryProjectSettings pstorage;
|
||||
|
||||
public static float[] vertexBakeSamples;
|
||||
static int vertexBakeSampleCounter;
|
||||
|
||||
const int PASS_ALBEDO = 0;
|
||||
const int PASS_EMISSIVE = 1;
|
||||
const int PASS_NORMAL = 2;
|
||||
const int PASS_ALPHA = 3;
|
||||
const int PASS_COUNT = 4; // just a marker
|
||||
|
||||
#if SUPPORT_MBLOCKS
|
||||
static Material activeMaterial;
|
||||
static int activeMaterialPass;
|
||||
static MaterialPropertyBlock mb = new MaterialPropertyBlock();
|
||||
#endif
|
||||
static Material tmpMaterial;
|
||||
|
||||
public static float[] uvOffset =
|
||||
{
|
||||
-2, -2,
|
||||
2, -2,
|
||||
-2, 2,
|
||||
2, 2,
|
||||
|
||||
-1, -2,
|
||||
1, -2,
|
||||
-2, -1,
|
||||
2, -1,
|
||||
-2, 1,
|
||||
2, 1,
|
||||
-1, 2,
|
||||
1, 2,
|
||||
|
||||
-2, 0,
|
||||
2, 0,
|
||||
0, -2,
|
||||
0, 2,
|
||||
|
||||
-1, -1,
|
||||
1, -1,
|
||||
-1, 0,
|
||||
1, 0,
|
||||
-1, 1,
|
||||
1, 1,
|
||||
0, -1,
|
||||
0, 1,
|
||||
|
||||
0, 0
|
||||
};
|
||||
|
||||
static public void UpdateMatrix(Matrix4x4 worldMatrix, float offsetX, float offsetY)//Matrix4x4 worldMatrix)
|
||||
{
|
||||
// Generate a projection matrix similar to LoadOrtho
|
||||
/*var dummyCamGO = new GameObject();
|
||||
dummyCamGO.name = "dummyCam";
|
||||
var dummyCam = dummyCamGO.AddComponent<Camera>();
|
||||
dummyCam.cullingMask = 0;
|
||||
dummyCam.orthographic = true;
|
||||
dummyCam.orthographicSize = 0.5f;
|
||||
dummyCam.nearClipPlane = -10;
|
||||
dummyCam.aspect = 1;
|
||||
var proj = dummyCam.projectionMatrix;
|
||||
var c3 = proj.GetColumn(3);
|
||||
proj.SetColumn(3, new Vector4(-1, -1, c3.z, c3.w));
|
||||
Debug.Log(proj);*/
|
||||
|
||||
var proj = new Matrix4x4();
|
||||
proj.SetRow(0, new Vector4(2.00000f, 0.00000f, 0.00000f, -1.00000f + offsetX));
|
||||
proj.SetRow(1, new Vector4(0.00000f, 2.00000f, 0.00000f, -1.00000f + offsetY));
|
||||
proj.SetRow(2, new Vector4(0.00000f, 0.00000f, -0.00198f, -0.98f));
|
||||
proj.SetRow(3, new Vector4(0.00000f, 0.00000f, 0.00000f, 1.00000f));
|
||||
|
||||
//if (ftBuildGraphics.unityVersionMajor < 2018) // Unity 2018 stopped multiplying vertices by world matrix in meta pass
|
||||
//{
|
||||
#if UNITY_2018_1_OR_NEWER
|
||||
#else
|
||||
proj = proj * worldMatrix.inverse;
|
||||
#endif
|
||||
//}
|
||||
|
||||
// If Camera.current is set, multiply our matrix by the inverse of its view matrix
|
||||
if (Camera.current != null)
|
||||
{
|
||||
proj = proj * Camera.current.worldToCameraMatrix.inverse;
|
||||
}
|
||||
|
||||
GL.LoadProjectionMatrix(proj);
|
||||
}
|
||||
|
||||
static Mesh GenerateVertexBakeSamples(Mesh mesh, int vertexSamplingDensity, Vector3[] wpos)
|
||||
{
|
||||
int vertexCount = mesh.vertexCount;
|
||||
var verts = wpos;//mesh.vertices;
|
||||
var normals = mesh.normals;
|
||||
var uv = mesh.uv;
|
||||
bool hasUV = uv != null && uv.Length > 0;
|
||||
Vector2 tA = Vector2.zero;
|
||||
Vector2 tB = Vector2.zero;
|
||||
Vector2 tC = Vector2.zero;
|
||||
int newVertexCount = ftBuildGraphics.GetNumVertexSamples(mesh, vertexSamplingDensity);
|
||||
var newMesh = new Mesh();
|
||||
if (newVertexCount > 65000)
|
||||
{
|
||||
#if UNITY_2017_3_OR_NEWER
|
||||
newMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
|
||||
#else
|
||||
ftBuildGraphics.DebugLogError("Using this vertexSamplingDensity value (" + vertexSamplingDensity + ") on this mesh (" + mesh.name + ") results in more than 65000 new vertices. Please lower the value, split the mesh, or use Unity >= 2017.3. Alternatively, annoy me via email, so I fix it.");
|
||||
return null;
|
||||
#endif
|
||||
}
|
||||
var newVerts = new Vector3[newVertexCount];
|
||||
var newNormals = new Vector3[newVertexCount];
|
||||
var newUV = new Vector2[newVertexCount];
|
||||
int subMeshCount = mesh.subMeshCount;
|
||||
int sampleCount = 0;
|
||||
UnityEngine.Random.InitState(vertexCount); // instead of storing barycentrics we will regenerate them
|
||||
for(int subMesh=0; subMesh<subMeshCount; subMesh++)
|
||||
{
|
||||
var inds = mesh.GetIndices(subMesh);
|
||||
int tris = inds.Length / 3;
|
||||
for(int tri=0; tri<tris; tri++)
|
||||
{
|
||||
var A = verts[inds[tri*3]];
|
||||
var B = verts[inds[tri*3+1]];
|
||||
var C = verts[inds[tri*3+2]];
|
||||
|
||||
var nA = normals[inds[tri*3]];
|
||||
var nB = normals[inds[tri*3+1]];
|
||||
var nC = normals[inds[tri*3+2]];
|
||||
|
||||
if (hasUV)
|
||||
{
|
||||
tA = uv[inds[tri*3]];
|
||||
tB = uv[inds[tri*3+1]];
|
||||
tC = uv[inds[tri*3+2]];
|
||||
}
|
||||
|
||||
for(int i=0; i<vertexSamplingDensity; i++)
|
||||
{
|
||||
float rndA = UnityEngine.Random.value;
|
||||
float rndB = UnityEngine.Random.value;
|
||||
float rndC = UnityEngine.Random.value;
|
||||
|
||||
float baryA = 1.0f - Mathf.Sqrt(rndA);
|
||||
float baryB = Mathf.Sqrt(rndA) * (1.0f - rndB);
|
||||
float baryC = Mathf.Sqrt(rndA) * rndB;
|
||||
|
||||
//var testPos = new Vector3[3];
|
||||
//testPos[0] = A;
|
||||
//testPos[1] = B;
|
||||
//testPos[2] = C;
|
||||
//var testNormal = new Vector3[3];
|
||||
//testNormal[0] = nA;
|
||||
//testNormal[1] = nB;
|
||||
//testNormal[2] = nC;
|
||||
|
||||
newVerts[sampleCount] = baryA * A + baryB * B + baryC * C;
|
||||
newNormals[sampleCount] = baryA * nA + baryB * nB + baryC * nC;
|
||||
newUV[sampleCount] = baryA * tA + baryB * tB + baryC * tC;
|
||||
|
||||
vertexBakeSamples[vertexBakeSampleCounter*4] = newVerts[sampleCount].x;
|
||||
vertexBakeSamples[vertexBakeSampleCounter*4+1] = newVerts[sampleCount].y;
|
||||
vertexBakeSamples[vertexBakeSampleCounter*4+2] = newVerts[sampleCount].z;
|
||||
|
||||
sampleCount++;
|
||||
vertexBakeSampleCounter++;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
newMesh.vertices = newVerts;
|
||||
newMesh.normals = newNormals;
|
||||
newMesh.uv = newUV;
|
||||
newMesh.subMeshCount = subMeshCount;
|
||||
int offset = 0;
|
||||
for(int subMesh=0; subMesh<subMeshCount; subMesh++)
|
||||
{
|
||||
int tris = (int)mesh.GetIndexCount(subMesh)/3;
|
||||
int samples = tris * vertexSamplingDensity;
|
||||
var newIndices = new int[samples];
|
||||
for(int i=0; i<samples; i++)
|
||||
{
|
||||
newIndices[i] = offset + i;
|
||||
}
|
||||
offset += samples;
|
||||
newMesh.SetIndices(newIndices, MeshTopology.Points, subMesh, false);
|
||||
}
|
||||
|
||||
return newMesh;
|
||||
}
|
||||
|
||||
static public void StartUVGBuffer(int size, bool hasEmissive, bool hasNormal, int vertexBakeSampleBufferSize = 0)
|
||||
{
|
||||
emissiveEnabled = hasEmissive;
|
||||
normalEnabled = hasNormal;
|
||||
alphaEnabled = false;
|
||||
|
||||
vertexBakeSampleCounter = 0;
|
||||
if (vertexBakeSampleBufferSize > 0)
|
||||
{
|
||||
vertexBakeSamples = new float[vertexBakeSampleBufferSize * 4];
|
||||
}
|
||||
|
||||
rtAlbedo = new RenderTexture(size, size, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
|
||||
texAlbedo = new Texture2D(size, size, TextureFormat.RGBA32, false, false);
|
||||
|
||||
Graphics.SetRenderTarget(rtAlbedo);
|
||||
GL.Clear(true, true, new Color(0,0,0,0));
|
||||
|
||||
if (hasEmissive)
|
||||
{
|
||||
rtEmissive = new RenderTexture(size, size, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
|
||||
texEmissive = new Texture2D(size, size, TextureFormat.RGBAHalf, false, true);
|
||||
Graphics.SetRenderTarget(rtEmissive);
|
||||
GL.Clear(true, true, new Color(0,0,0,0));
|
||||
}
|
||||
|
||||
if (hasNormal)
|
||||
{
|
||||
rtNormal = new RenderTexture(size, size, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
|
||||
texNormal = new Texture2D(size, size, TextureFormat.RGBA32, false, false);
|
||||
Graphics.SetRenderTarget(rtNormal);
|
||||
GL.Clear(true, true, new Color(0,0,0,0));
|
||||
}
|
||||
|
||||
//GL.sRGBWrite = true;//!hasEmissive;
|
||||
GL.invertCulling = false;
|
||||
GL.PushMatrix();
|
||||
//GL.LoadOrtho();
|
||||
//UpdateMatrix();
|
||||
/*float ambR, ambG, ambB;
|
||||
//ambR = ambG = ambB = emissiveOnly ? 0 : 1;
|
||||
Shader.SetGlobalVector("unity_SHBr", Vector4.zero);
|
||||
Shader.SetGlobalVector("unity_SHBg", Vector4.zero);
|
||||
Shader.SetGlobalVector("unity_SHBb", Vector4.zero);
|
||||
Shader.SetGlobalVector("unity_SHC", Vector4.zero);*/
|
||||
texelSize = (1.0f / size) / 5;
|
||||
//shaBlack = new Vector4(0,0,0,0);
|
||||
//shaWhite = new Vector4(0,0,0,1);
|
||||
metaControl = new Vector4(1,0,0,0);
|
||||
metaControlAlbedo = new Vector4(1,0,0,0);
|
||||
metaControlEmission = new Vector4(0,1,0,0);
|
||||
metaControlNormal = new Vector4(0,0,1,0);
|
||||
metaControlAlpha = new Vector4(0,0,0,1);
|
||||
Shader.SetGlobalVector("unity_MetaVertexControl", metaControl);
|
||||
Shader.SetGlobalFloat("unity_OneOverOutputBoost", 1.0f);
|
||||
Shader.SetGlobalFloat("unity_MaxOutputValue", 10000000.0f);
|
||||
Shader.SetGlobalFloat("unity_UseLinearSpace", PlayerSettings.colorSpace == ColorSpace.Linear ? 1.0f : 0.0f);
|
||||
}
|
||||
|
||||
static public void InitAlphaBuffer(int size)
|
||||
{
|
||||
alphaEnabled = true;
|
||||
rtAlpha = new RenderTexture(size, size, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
|
||||
rtAlpha.name = "BakeryRTAlpha";
|
||||
texAlpha = new Texture2D(size, size, TextureFormat.RGBA32, false, true);
|
||||
texAlpha.name = "BakeryTexAlpha";
|
||||
Graphics.SetRenderTarget(rtAlpha);
|
||||
GL.Clear(true, true, new Color(0,0,0,0));
|
||||
}
|
||||
|
||||
#if SUPPORT_MBLOCKS
|
||||
static void OverrideColor(MaterialPropertyBlock mb, string pname)
|
||||
{
|
||||
#if UNITY_2021_1_OR_NEWER
|
||||
if (!mb.HasColor(pname)) return;
|
||||
tmpMaterial.SetColor(pname, mb.GetColor(pname));
|
||||
#else
|
||||
|
||||
#if UNITY_2017_3_OR_NEWER
|
||||
var v = mb.GetColor(pname);
|
||||
if (v.r == 0 && v.g == 0 && v.b == 0 && v.a == 0) return; // not the best workaround - can't override with 0 on < 2021.1
|
||||
tmpMaterial.SetColor(pname, v);
|
||||
#else
|
||||
var v = mb.GetVector(pname);
|
||||
if (v.x == 0 && v.y == 0 && v.z == 0 && v.w == 0) return; // not the best workaround - can't override with 0 on < 2021.1
|
||||
tmpMaterial.SetVector(pname, v);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
static void OverrideVector(MaterialPropertyBlock mb, string pname)
|
||||
{
|
||||
#if UNITY_2021_1_OR_NEWER
|
||||
if (!mb.HasVector(pname)) return;
|
||||
tmpMaterial.SetVector(pname, mb.GetVector(pname));
|
||||
#else
|
||||
var v = mb.GetVector(pname);
|
||||
if (v.x == 0 && v.y == 0 && v.z == 0 && v.w == 0) return; // not the best workaround - can't override with 0 on < 2021.1
|
||||
tmpMaterial.SetVector(pname, v);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void OverrideFloat(MaterialPropertyBlock mb, string pname)
|
||||
{
|
||||
#if UNITY_2021_1_OR_NEWER
|
||||
if (!mb.HasFloat(pname)) return;
|
||||
tmpMaterial.SetFloat(pname, mb.GetFloat(pname));
|
||||
#else
|
||||
var v = mb.GetFloat(pname);
|
||||
if (v == 0) return; // not the best workaround - can't override with 0 on < 2021.1
|
||||
tmpMaterial.SetFloat(pname, v);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void OverrideTexture(MaterialPropertyBlock mb, string pname)
|
||||
{
|
||||
#if UNITY_2021_1_OR_NEWER
|
||||
if (!mb.HasTexture(pname)) return;
|
||||
tmpMaterial.SetTexture(pname, mb.GetTexture(pname));
|
||||
#else
|
||||
var v = mb.GetTexture(pname);
|
||||
if (v == null) return;
|
||||
tmpMaterial.SetTexture(pname, v);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
static void DrawWithOverrides(Renderer renderer, Mesh m, ref Matrix4x4 worldMatrix, int i)
|
||||
{
|
||||
#if SUPPORT_MBLOCKS
|
||||
|
||||
#if UNITY_2018_1_OR_NEWER
|
||||
if (renderer.HasPropertyBlock())
|
||||
#endif
|
||||
{
|
||||
|
||||
//#if UNITY_2018_1_OR_NEWER
|
||||
// renderer.GetPropertyBlock(mb, i);
|
||||
//#else
|
||||
renderer.GetPropertyBlock(mb);
|
||||
//#endif
|
||||
|
||||
var shader = activeMaterial.shader;
|
||||
if ((!mb.isEmpty) && activeMaterial != null && shader != null)
|
||||
{
|
||||
tmpMaterial = new Material(activeMaterial);
|
||||
|
||||
int numPropsInShader = ShaderUtil.GetPropertyCount(shader);
|
||||
for(int j=0; j<numPropsInShader; j++)
|
||||
{
|
||||
var pname = ShaderUtil.GetPropertyName(shader, j);
|
||||
int ptype = (int)ShaderUtil.GetPropertyType(shader, j);
|
||||
if (ptype == 0) // color
|
||||
{
|
||||
OverrideColor(mb, pname);
|
||||
}
|
||||
else if (ptype == 1) // vector
|
||||
{
|
||||
OverrideVector(mb, pname);
|
||||
}
|
||||
else if (ptype == 2) // float
|
||||
{
|
||||
OverrideFloat(mb, pname);
|
||||
}
|
||||
else if (ptype == 4) // TexEnv
|
||||
{
|
||||
OverrideTexture(mb, pname);
|
||||
}
|
||||
}
|
||||
|
||||
tmpMaterial.SetPass(activeMaterialPass);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
Graphics.DrawMeshNow(m, worldMatrix, i);
|
||||
}
|
||||
|
||||
static public void RenderUVGBuffer(Mesh mesh, Renderer renderer, Vector4 scaleOffset, Transform worldTransform, bool vertexBake, int vertexSamplingDensity, Vector3[] tformedPos,
|
||||
Vector2[] uvOverride, bool terrainNormals = false, bool metaAlpha = false)
|
||||
{
|
||||
var worldMatrix = worldTransform.localToWorldMatrix;
|
||||
|
||||
if (pstorage == null) pstorage = ftLightmaps.GetProjectSettings();
|
||||
|
||||
if (metaAlpha && !alphaEnabled)
|
||||
{
|
||||
int res = rtAlbedo.width * pstorage.alphaMetaPassResolutionMultiplier;
|
||||
if (res > 8192) res = 8192;
|
||||
InitAlphaBuffer(res);
|
||||
}
|
||||
|
||||
Material[] materials = renderer.sharedMaterials;
|
||||
|
||||
var m = mesh;
|
||||
if (uvOverride != null)
|
||||
{
|
||||
if (vertexBake && vertexSamplingDensity > 1)
|
||||
{
|
||||
m = GenerateVertexBakeSamples(mesh, vertexSamplingDensity, tformedPos);
|
||||
}
|
||||
else
|
||||
{
|
||||
m = Mesh.Instantiate(mesh);
|
||||
if (vertexBake)
|
||||
{
|
||||
for(int i=0; i<mesh.subMeshCount; i++)
|
||||
{
|
||||
var indices = m.GetIndices(i);
|
||||
m.SetIndices(indices, MeshTopology.Points, i, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
m.uv2 = uvOverride;
|
||||
}
|
||||
|
||||
//var scaleOffsetFlipped = new Vector4(scaleOffset.x, -scaleOffset.y, scaleOffset.z, 1.0f - scaleOffset.w);
|
||||
|
||||
//UpdateMatrix(worldMatrix);
|
||||
|
||||
for(int pass=0; pass<PASS_COUNT; pass++)
|
||||
{
|
||||
if (pass == PASS_EMISSIVE && !emissiveEnabled) continue;
|
||||
if (pass == PASS_NORMAL && !normalEnabled) continue;
|
||||
if (pass == PASS_ALPHA && !alphaEnabled) continue; // per Start-End
|
||||
if (pass == PASS_ALPHA && !metaAlpha) continue; // per this object
|
||||
|
||||
if (pass == PASS_ALBEDO)
|
||||
{
|
||||
Graphics.SetRenderTarget(rtAlbedo);
|
||||
}
|
||||
else if (pass == PASS_EMISSIVE)
|
||||
{
|
||||
Graphics.SetRenderTarget(rtEmissive);
|
||||
}
|
||||
else if (pass == PASS_NORMAL)
|
||||
{
|
||||
Graphics.SetRenderTarget(rtNormal);
|
||||
}
|
||||
else if (pass == PASS_ALPHA)
|
||||
{
|
||||
Graphics.SetRenderTarget(rtAlpha);
|
||||
}
|
||||
|
||||
for(int i=0; i<mesh.subMeshCount; i++)
|
||||
{
|
||||
if (materials.Length <= i) break;
|
||||
if (materials[i] == null) continue;
|
||||
if (materials[i].shader == null) continue;
|
||||
|
||||
// Optionally skip emission
|
||||
bool passAsBlack = (pass == PASS_EMISSIVE && materials[i].globalIlluminationFlags != MaterialGlobalIlluminationFlags.BakedEmissive);
|
||||
|
||||
var rpTag = materials[i].GetTag("RenderPipeline", true, "");
|
||||
bool isHDRP = rpTag == "HDRenderPipeline";
|
||||
if (pass >= PASS_NORMAL) isHDRP = false; // custom meta shaders are not affected
|
||||
int bakeryPass = -1;
|
||||
|
||||
if (pass < PASS_NORMAL)
|
||||
{
|
||||
int metaPass = -1;
|
||||
if (!materials[i].HasProperty("BAKERY_FORCE_NO_META"))
|
||||
{
|
||||
if (!passAsBlack)
|
||||
{
|
||||
metaPass = materials[i].FindPass("META");
|
||||
if (metaPass < 0)
|
||||
{
|
||||
// Try finding another pass pass with "META" in it
|
||||
for(int mpass=0; mpass<materials[i].passCount; mpass++)
|
||||
{
|
||||
if (materials[i].GetPassName(mpass).IndexOf("META") >= 0)
|
||||
{
|
||||
metaPass = mpass;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Shader.SetGlobalVector("unity_LightmapST", scaleOffset);//(isHDRP) ? scaleOffsetFlipped : scaleOffset);
|
||||
Shader.SetGlobalVector("unity_MetaFragmentControl", pass == PASS_ALBEDO ? metaControlAlbedo : metaControlEmission);
|
||||
|
||||
if (metaPass >= 0)
|
||||
{
|
||||
materials[i].SetPass(metaPass);
|
||||
#if SUPPORT_MBLOCKS
|
||||
activeMaterial = materials[i];
|
||||
activeMaterialPass = metaPass;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
if (passAsBlack)
|
||||
{
|
||||
if (blackMat == null)
|
||||
{
|
||||
blackMat = new Material(Shader.Find("Hidden/ftBlack"));
|
||||
}
|
||||
Shader.SetGlobalVector("unity_LightmapST", scaleOffset);
|
||||
blackMat.SetPass(0);
|
||||
#if SUPPORT_MBLOCKS
|
||||
activeMaterial = blackMat;
|
||||
activeMaterialPass = 0;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
if (fallbackMat == null)
|
||||
{
|
||||
fallbackMat = new Material(Shader.Find("Standard"));
|
||||
fallbackMat.EnableKeyword("_EMISSION");
|
||||
fallbackMatMetaPass = fallbackMat.FindPass("META");
|
||||
}
|
||||
if ((pstorage.logLevel & (int)BakeryProjectSettings.LogLevel.Warning) != 0)
|
||||
{
|
||||
if (materials[i].name != "Hidden/ftFarSphere")
|
||||
{
|
||||
Debug.LogWarning("Material " + materials[i].name + " doesn't have meta pass - maps are taken by name");
|
||||
}
|
||||
}
|
||||
if (materials[i].HasProperty("_MainTex"))
|
||||
{
|
||||
fallbackMat.mainTexture = materials[i].GetTexture("_MainTex");
|
||||
}
|
||||
else if (materials[i].HasProperty("_BaseColorMap"))
|
||||
{
|
||||
// HDRP
|
||||
fallbackMat.mainTexture = materials[i].GetTexture("_BaseColorMap");
|
||||
}
|
||||
else if (materials[i].HasProperty("_BaseMap"))
|
||||
{
|
||||
// URP
|
||||
fallbackMat.mainTexture = materials[i].GetTexture("_BaseMap");
|
||||
}
|
||||
if (materials[i].HasProperty("_Color"))
|
||||
{
|
||||
fallbackMat.SetVector("_Color", materials[i].GetVector("_Color"));
|
||||
}
|
||||
else
|
||||
{
|
||||
fallbackMat.SetVector("_Color", Color.white);
|
||||
}
|
||||
if (materials[i].HasProperty("_EmissionMap"))
|
||||
{
|
||||
fallbackMat.SetTexture("_EmissionMap", materials[i].GetTexture("_EmissionMap"));
|
||||
}
|
||||
else
|
||||
{
|
||||
fallbackMat.SetTexture("_EmissionMap", null);
|
||||
}
|
||||
if (materials[i].HasProperty("_EmissionColor"))
|
||||
{
|
||||
fallbackMat.SetVector("_EmissionColor", materials[i].GetVector("_EmissionColor"));
|
||||
}
|
||||
else
|
||||
{
|
||||
fallbackMat.SetVector("_EmissionColor", Color.black);
|
||||
}
|
||||
fallbackMat.SetPass(fallbackMatMetaPass);
|
||||
#if SUPPORT_MBLOCKS
|
||||
activeMaterial = fallbackMat;
|
||||
activeMaterialPass = fallbackMatMetaPass;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (pass == PASS_NORMAL)
|
||||
{
|
||||
bool isURP = rpTag == "UniversalPipeline";
|
||||
|
||||
var metaPass = materials[i].FindPass("META_BAKERY");
|
||||
bakeryPass = metaPass;
|
||||
|
||||
if (normalMat == null && metaPass < 0)
|
||||
{
|
||||
normalMat = new Material(Shader.Find("Hidden/ftUVNormalMap"));
|
||||
}
|
||||
if (texBestFit == null)
|
||||
{
|
||||
texBestFit = new Texture2D(1024, 1024, TextureFormat.RGBA32, false, true);
|
||||
var edPath = ftLightmaps.GetEditorPath();
|
||||
var fbestfit = new BinaryReader(File.Open(edPath + "NormalsFittingTexture_dds", FileMode.Open, FileAccess.Read));
|
||||
fbestfit.BaseStream.Seek(128, SeekOrigin.Begin);
|
||||
var bytes = fbestfit.ReadBytes(1024 * 1024 * 4);
|
||||
fbestfit.Close();
|
||||
texBestFit.LoadRawTextureData(bytes);
|
||||
texBestFit.Apply();
|
||||
}
|
||||
|
||||
if (metaPass < 0)
|
||||
{
|
||||
if (materials[i].HasProperty("_BumpMap"))
|
||||
{
|
||||
normalMat.SetTexture("_BumpMap", materials[i].GetTexture("_BumpMap"));
|
||||
if (materials[i].HasProperty("_MainTex_ST"))
|
||||
{
|
||||
normalMat.SetVector("_BumpMap_scaleOffset", materials[i].GetVector("_MainTex_ST"));
|
||||
//Debug.LogError(materials[i].GetVector("_MainTex_ST"));
|
||||
}
|
||||
else
|
||||
{
|
||||
normalMat.SetVector("_BumpMap_scaleOffset", new Vector4(1,1,0,0));
|
||||
}
|
||||
}
|
||||
else if (materials[i].HasProperty("_NormalMap"))
|
||||
{
|
||||
normalMat.SetTexture("_BumpMap", materials[i].GetTexture("_NormalMap"));
|
||||
normalMat.SetVector("_BumpMap_scaleOffset", new Vector4(1,1,0,0));
|
||||
}
|
||||
else
|
||||
{
|
||||
normalMat.SetTexture("_BumpMap", null);
|
||||
}
|
||||
normalMat.SetFloat("_IsTerrain", terrainNormals ? 1.0f : 0.0f);
|
||||
normalMat.SetTexture("bestFitNormalMap", texBestFit);
|
||||
normalMat.SetFloat("_IsPerPixel", (isURP||isHDRP) ? 1.0f : 0.0f);
|
||||
normalMat.SetPass(0);
|
||||
#if SUPPORT_MBLOCKS
|
||||
activeMaterial = normalMat;
|
||||
activeMaterialPass = 0;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
materials[i].SetTexture("bestFitNormalMap", texBestFit);
|
||||
materials[i].SetFloat("_IsPerPixel", (isURP||isHDRP) ? 1.0f : 0.0f);
|
||||
materials[i].SetPass(metaPass);
|
||||
#if SUPPORT_MBLOCKS
|
||||
activeMaterial = materials[i];
|
||||
activeMaterialPass = metaPass;
|
||||
#endif
|
||||
}
|
||||
Shader.SetGlobalVector("unity_MetaFragmentControl", metaControlNormal);
|
||||
}
|
||||
else if (pass == PASS_ALPHA)
|
||||
{
|
||||
// Unity does not output alpha in its meta pass, so only custom shaders are supported
|
||||
var metaPass = materials[i].FindPass("META_BAKERY");
|
||||
if (metaPass < 0)
|
||||
{
|
||||
Debug.LogError("BAKERY_META_ALPHA_ENABLE is set, but there is no META_BAKERY pass in " + materials[i].name);
|
||||
continue;
|
||||
}
|
||||
bakeryPass = metaPass;
|
||||
materials[i].SetPass(metaPass);
|
||||
#if SUPPORT_MBLOCKS
|
||||
activeMaterial = materials[i];
|
||||
activeMaterialPass = metaPass;
|
||||
#endif
|
||||
Shader.SetGlobalVector("unity_MetaFragmentControl", metaControlAlpha);
|
||||
}
|
||||
|
||||
GL.sRGBWrite = pass == PASS_ALBEDO;
|
||||
|
||||
if (!vertexBake)
|
||||
{
|
||||
for(int j=0; j<uvOffset.Length/2; j++)
|
||||
{
|
||||
if (pass < PASS_NORMAL)
|
||||
{
|
||||
UpdateMatrix(worldMatrix, uvOffset[j*2] * texelSize, uvOffset[j*2+1] * texelSize);
|
||||
}
|
||||
else
|
||||
{
|
||||
// TODO: use in HDRP as well
|
||||
var srcVec = scaleOffset;//(isHDRP) ? scaleOffsetFlipped : scaleOffset;
|
||||
var vec = new Vector4(srcVec.x, srcVec.y, srcVec.z + uvOffset[j*2] * texelSize, srcVec.w + uvOffset[j*2+1] * texelSize);
|
||||
Shader.SetGlobalVector("unity_LightmapST", vec);
|
||||
if (bakeryPass >= 0)
|
||||
{
|
||||
materials[i].SetPass(bakeryPass);
|
||||
#if SUPPORT_MBLOCKS
|
||||
activeMaterial = materials[i];
|
||||
activeMaterialPass = bakeryPass;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
var s = worldTransform.lossyScale;
|
||||
bool isFlipped = Mathf.Sign(s.x*s.y*s.z) < 0;
|
||||
normalMat.SetFloat("_IsFlipped", isFlipped ? -1.0f : 1.0f);
|
||||
normalMat.SetPass(0);
|
||||
#if SUPPORT_MBLOCKS
|
||||
activeMaterial = normalMat;
|
||||
activeMaterialPass = 0;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
DrawWithOverrides(renderer, m, ref worldMatrix, i);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
UpdateMatrix(worldMatrix, 0, 0);
|
||||
|
||||
DrawWithOverrides(renderer, m, ref worldMatrix, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static public void EndUVGBuffer()
|
||||
{
|
||||
GL.PopMatrix();
|
||||
|
||||
Graphics.SetRenderTarget(rtAlbedo);
|
||||
texAlbedo.ReadPixels(new Rect(0,0,rtAlbedo.width,rtAlbedo.height), 0, 0, false);
|
||||
texAlbedo.Apply();
|
||||
Graphics.SetRenderTarget(null);
|
||||
rtAlbedo.Release();
|
||||
|
||||
if (emissiveEnabled)
|
||||
{
|
||||
Graphics.SetRenderTarget(rtEmissive);
|
||||
texEmissive.ReadPixels(new Rect(0,0,rtEmissive.width,rtEmissive.height), 0, 0, false);
|
||||
texEmissive.Apply();
|
||||
Graphics.SetRenderTarget(null);
|
||||
rtEmissive.Release();
|
||||
}
|
||||
|
||||
if (normalEnabled)
|
||||
{
|
||||
Graphics.SetRenderTarget(rtNormal);
|
||||
texNormal.ReadPixels(new Rect(0,0,rtNormal.width,rtNormal.height), 0, 0, false);
|
||||
texNormal.Apply();
|
||||
Graphics.SetRenderTarget(null);
|
||||
rtNormal.Release();
|
||||
}
|
||||
|
||||
if (alphaEnabled)
|
||||
{
|
||||
Graphics.SetRenderTarget(rtAlpha);
|
||||
texAlpha.ReadPixels(new Rect(0,0,rtAlpha.width,rtAlpha.height), 0, 0, false);
|
||||
texAlpha.Apply();
|
||||
Graphics.SetRenderTarget(null);
|
||||
rtAlpha.Release();
|
||||
rtAlpha = null;
|
||||
}
|
||||
}
|
||||
|
||||
static public Texture2D DecodeFromRGBM(Texture2D emissive)
|
||||
{
|
||||
var rt = new RenderTexture(emissive.width, emissive.height, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
|
||||
var tex = new Texture2D(emissive.width, emissive.height, TextureFormat.RGBAHalf, false, true);
|
||||
|
||||
if (matFromRGBM == null) matFromRGBM = new Material(Shader.Find("Hidden/ftRGBM2Half"));
|
||||
|
||||
Graphics.SetRenderTarget(rt);
|
||||
GL.sRGBWrite = false;
|
||||
|
||||
matFromRGBM.SetTexture("_MainTex", emissive);
|
||||
|
||||
Graphics.Blit(emissive, rt, matFromRGBM);
|
||||
|
||||
tex.ReadPixels(new Rect(0,0,rt.width,rt.height), 0, 0, false);
|
||||
tex.Apply();
|
||||
|
||||
Graphics.SetRenderTarget(null);
|
||||
rt.Release();
|
||||
Object.DestroyImmediate(emissive);
|
||||
|
||||
return tex;
|
||||
}
|
||||
|
||||
static public void Dilate(Texture2D albedo, int pass = 0)
|
||||
{
|
||||
if (matDilate == null) matDilate = new Material(Shader.Find("Hidden/ftDilate"));
|
||||
|
||||
RenderTexture rt, rt2;
|
||||
if (albedo.format == TextureFormat.RGBA32)
|
||||
{
|
||||
rt = new RenderTexture(albedo.width, albedo.height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
|
||||
rt2 = new RenderTexture(albedo.width, albedo.height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
|
||||
}
|
||||
else
|
||||
{
|
||||
rt = new RenderTexture(albedo.width, albedo.height, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
|
||||
rt2 = new RenderTexture(albedo.width, albedo.height, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
|
||||
}
|
||||
|
||||
GL.sRGBWrite = albedo.format == TextureFormat.RGBA32;
|
||||
Graphics.Blit(albedo, rt, matDilate, pass);
|
||||
|
||||
for(int i=0; i<8; i++)
|
||||
{
|
||||
Graphics.Blit(rt, rt2, matDilate, pass);
|
||||
Graphics.Blit(rt2, rt, matDilate, pass);
|
||||
}
|
||||
|
||||
Graphics.SetRenderTarget(rt);
|
||||
albedo.ReadPixels(new Rect(0,0,rt.width,rt.height), 0, 0, false);
|
||||
albedo.Apply();
|
||||
|
||||
Graphics.SetRenderTarget(null);
|
||||
rt.Release();
|
||||
rt2.Release();
|
||||
}
|
||||
|
||||
static public void Multiply(Texture2D albedo, float val)
|
||||
{
|
||||
if (matMultiply == null) matMultiply = new Material(Shader.Find("Hidden/ftMultiply"));
|
||||
|
||||
RenderTexture rt;
|
||||
if (albedo.format == TextureFormat.RGBA32)
|
||||
{
|
||||
rt = new RenderTexture(albedo.width, albedo.height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
|
||||
}
|
||||
else
|
||||
{
|
||||
rt = new RenderTexture(albedo.width, albedo.height, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
|
||||
}
|
||||
|
||||
GL.sRGBWrite = albedo.format == TextureFormat.RGBA32;
|
||||
matMultiply.SetFloat("multiplier", val);
|
||||
Graphics.Blit(albedo, rt, matMultiply);
|
||||
|
||||
Graphics.SetRenderTarget(rt);
|
||||
albedo.ReadPixels(new Rect(0,0,rt.width,rt.height), 0, 0, false);
|
||||
albedo.Apply();
|
||||
|
||||
Graphics.SetRenderTarget(null);
|
||||
rt.Release();
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user