private void DrawMeshes(RSkeleton skeleton, Shader currentShader)
{
GroupSubMeshesByPass(out List <RMesh> opaqueMeshes, out List <RMesh> sortMeshes, out List <RMesh> nearMeshes, out List <RMesh> farMeshes);
// Meshes often share a material, so skip redundant and costly state changes.
RMaterial previousMaterial = null;
foreach (RMesh m in opaqueMeshes)
{
DrawMesh(m, skeleton, currentShader, previousMaterial);
previousMaterial = m.Material;
}
// Shader labels with _sort or _far get rendered in a second pass for proper alpha blending.
foreach (RMesh m in farMeshes)
{
DrawMesh(m, skeleton, currentShader, previousMaterial);
previousMaterial = m.Material;
}
foreach (RMesh m in sortMeshes)
{
DrawMesh(m, skeleton, currentShader, previousMaterial);
previousMaterial = m.Material;
}
// Shader labels with _near get rendered last after post processing is done.
foreach (RMesh m in nearMeshes)
{
DrawMesh(m, skeleton, currentShader, previousMaterial);
previousMaterial = m.Material;
}
}
void SetCurrentMaterial(string uidMaterial)
{
if (!_materials.ContainsKey(uidMaterial))
{
RMaterial material = CurrentDocument.GetElement(uidMaterial) as RMaterial;
Color c = material.Color;
MaterialBuilder m;
if (material.Transparency != 0)
{
m = new MaterialBuilder()
.WithAlpha(AlphaMode.BLEND)
.WithDoubleSide(true)
.WithMetallicRoughnessShader()
.WithChannelParam("BaseColor", new Vector4(c.Red / 256f, c.Green / 256f, c.Blue / 256f, 1 - (material.Transparency / 128f)));
}
else
{
m = new MaterialBuilder()
.WithDoubleSide(true)
.WithMetallicRoughnessShader()
.WithChannelParam("BaseColor", new Vector4(c.Red / 256f, c.Green / 256f, c.Blue / 256f, 1));
}
m.UseChannel("MetallicRoughness");
_materials.Add(uidMaterial, m);
}
_material = _materials[uidMaterial];
}
public RMaterial LoadMaterial(string name, MemoryStream stream)
{
RMaterial material = RFileSystem.Instance.Load <RMaterial>(stream);
material.Id = materials.Count + 1;
materials.Add(name, material);
return(material);
}
private void AssignMaterialToMeshes(ModlEntry modlEntry, RMaterial meshMaterial)
{
var meshes = RenderModel.SubMeshes.Where(m => m.Name == modlEntry.MeshName && m.SubIndex == modlEntry.SubIndex);
foreach (var mesh in meshes)
{
mesh.Material = meshMaterial;
}
}
public void Add(string name, object obj, object tag = null)
{
var type = obj.GetType();
if (type == typeof(Shader))
{
var item = new RShader();
item.name = name;
item.value = obj as Shader;
listShader.Add(item);
}
else if (type == typeof(Texture2D))
{
var item = new RTexture();
item.name = name;
item.value = obj as Texture2D;
listTexture.Add(item);
}
else if (type == typeof(Material))
{
var item = new RMaterial();
item.name = name;
item.value = obj as Material;
listMaterial.Add(item);
}
else if (type == typeof(GameObject))
{
var item = new RGameObject();
item.name = name;
item.value = obj as GameObject;
listGameObject.Add(item);
}
else if (type == typeof(GUISkin))
{
var item = new RGUISkin();
item.name = name;
item.value = obj as GUISkin;
listGUISkin.Add(item);
}
else if (type == typeof(Font))
{
var item = new RFont();
item.name = name;
item.value = obj as Font;
listFont.Add(item);
}
else
{
var item = new RUnknown();
item.name = name;
item.type = type.Name;
item.value = obj.ToString();
listUnknown.Add(item);
}
}
public void CreateSkyBox(RShader skyBoxShader)
{
sky = RScene.Instance.CreateMeshBuilder("skybox");
sky.CreateBox(Vector3.Zero, Vector3.One, true);
sky.Matrix = Matrix.Identity;
sky.DepthWrite = false;
RMaterial skyBoxMaterial = new RMaterial("skybox");
skyBoxMaterial.Shader = skyBoxShader;
sky.Material = skyBoxMaterial;
}
private void SyncRasterizerState(RMaterial rMaterial, Material material)
{
if (material.RasterizerState0 != null)
{
material.RasterizerState0.PropertyChanged += (s, e) =>
{
rMaterial.CullMode = material.RasterizerState0.CullMode.ToOpenTk();
rMaterial.FillMode = material.RasterizerState0.FillMode.ToOpenTk();
OnRenderFrameNeeded();
};
}
}
private void SyncBlendState(RMaterial rMaterial, Material material)
{
if (material.BlendState0 != null)
{
material.BlendState0.PropertyChanged += (s, e) =>
{
rMaterial.SourceColor = material.BlendState0.SourceColor.ToOpenTk();
rMaterial.DestinationColor = material.BlendState0.DestinationColor.ToOpenTk();
rMaterial.EnableAlphaSampleCoverage = material.BlendState0.EnableAlphaSampleToCoverage;
OnRenderFrameNeeded();
};
}
}
public RMaterial CreateMaterial(string name)
{
if (!materials.ContainsKey(name))
{
RMaterial material = new RMaterial(name);
material.Id = materials.Count;
materials.Add(name, material);
return(material);
}
else
{
return(materials[name]);
}
}
private void SyncFloats(RMaterial rMaterial, Material material)
{
foreach (var param in material.FloatParams)
{
if (!Enum.TryParse(param.ParamId, out MatlEnums.ParamId paramId))
{
continue;
}
param.PropertyChanged += (s, e) =>
{
rMaterial.UpdateFloat(paramId, param.Value);
OnRenderFrameNeeded();
};
}
}
private void SyncVectors(RMaterial rMaterial, Material material)
{
foreach (var param in material.Vec4Params)
{
if (!Enum.TryParse(param.ParamId, out MatlEnums.ParamId paramId))
{
continue;
}
param.PropertyChanged += (s, e) =>
{
rMaterial.UpdateVec4(paramId, new OpenTK.Vector4(param.Value1, param.Value2, param.Value3, param.Value4));
OnRenderFrameNeeded();
};
}
}
private void SyncViewModelToRMaterial(RMaterial rMaterial, Material material)
{
material.PropertyChanged += (s, e) =>
{
switch (e.PropertyName)
{
case nameof(Material.ShaderLabel):
rMaterial.ShaderLabel = material.ShaderLabel;
OnRenderFrameNeeded();
break;
default:
break;
}
};
SyncBooleans(rMaterial, material);
SyncFloats(rMaterial, material);
SyncTexturesSamplers(rMaterial, material);
SyncVectors(rMaterial, material);
SyncBlendState(rMaterial, material);
SyncRasterizerState(rMaterial, material);
}
public void CreateSkyBox(RTexture3D skyBoxTexture)
{
skybox = new RShader();
skybox.Load(@"
#include ""headers.glsl""
uniform mat4 proj : PROJECTION;
uniform mat4 mv : MODELVIEW;
smooth out vec3 eye;
void main()
{
mat3 imv = mat3(inverse(mv));
mat4 inverseProjection = inverse(proj);
vec3 unprojected = (inverseProjection * vec4(r_Position, 1.0)).xyz;
eye = imv * unprojected;
gl_Position = vec4(r_Position, 1.0);
}
", @"
smooth in vec3 eye;
uniform samplerCube diffuse;
out vec4 fragColor;
void main()
{
fragColor = texture(diffuse, eye);
}
", null);
sky = RScene.Instance.CreateMeshBuilder("skybox");
sky.CreateBox(Vector3.Zero, Vector3.One, true);
sky.Matrix = Matrix.Identity;
sky.DepthWrite = false;
RMaterial skyBoxMaterial = new RMaterial("skybox");
skyBoxMaterial.Shader = skybox;
skyBoxMaterial.SetTexture(RTextureLayer.DIFFUSE, skyBoxTexture);
sky.Material = skyBoxMaterial;
}
private void SyncTexturesSamplers(RMaterial rMaterial, Material material)
{
foreach (var param in material.TextureParams)
{
if (!Enum.TryParse(param.ParamId, out MatlEnums.ParamId paramId))
{
continue;
}
if (!Enum.TryParse(param.SamplerParamId, out MatlEnums.ParamId samplerParamId))
{
continue;
}
param.PropertyChanged += (s, e) =>
{
rMaterial.UpdateTexture(paramId, param.Value);
rMaterial.UpdateSampler(samplerParamId, GetSamplerData(param));
OnRenderFrameNeeded();
};
}
}
public static Texture GetTexture(RMaterial material, MatlEnums.ParamId paramId)
{
// Set a default to avoid unnecessary conditionals in the shader.
if (!material.HasTexture(paramId))
{
return(defaultTextureByParamId[paramId]);
}
var textureName = material.GetTextureName(paramId);
if (material.TextureByName.ContainsKey(textureName))
{
return(material.TextureByName[textureName].Texture);
}
if (defaultTexturesByName.ContainsKey(textureName))
{
return(defaultTexturesByName[textureName]);
}
else
{
return(DefaultTextures.Instance.Value.DefaultWhite);
}
}
/// <summary>
/// 设置当前材质
/// </summary>
/// <param name="uidMaterial"></param>
void SetCurrentMaterial(string uidMaterial)
{
if (!_materials.ContainsKey(uidMaterial))
{
RMaterial material = CurrentDocument.GetElement(uidMaterial) as RMaterial;
Color c = material.Color;
MaterialBuilder m = null;
try
{
if (material.Transparency != 0)
{
m = new MaterialBuilder()
.WithAlpha(SharpGLTF.Materials.AlphaMode.BLEND)
.WithDoubleSide(true)
.WithMetallicRoughnessShader()
.WithChannelParam("BaseColor", new Vector4(c.Red / 256f, c.Green / 256f, c.Blue / 256f, 1 - (material.Transparency / 128f)));
// .WithChannelParam("BaseColor", new Vector4(currentColor.Red / 256f, currentColor.Green / 256f, currentColor.Blue / 256f, (float)currentTransparency));
}
else
{
m = new MaterialBuilder()
.WithDoubleSide(true)
.WithMetallicRoughnessShader()
.WithChannelParam("BaseColor", new Vector4(c.Red / 256f, c.Green / 256f, c.Blue / 256f, 1));
// .WithChannelParam("BaseColor", new Vector4(currentColor.Red / 256f, currentColor.Green / 256f, currentColor.Blue / 256f, (float)currentTransparency));
}
}
catch (Exception e)
{
Debug.Print("{0} Second exception.", e.Message);
}
m.UseChannel("MetallicRoughness");
_materials.Add(uidMaterial, m);
}
_material = _materials[uidMaterial];
}
public static void LoadSource(this RMesh rmesh, string filename)
{
AssimpContext context = new AssimpContext();
context.SetConfig(new Assimp.Configs.FBXImportAllMaterialsConfig(true));
context.SetConfig(new Assimp.Configs.FBXImportAllGeometryLayersConfig(true));
context.SetConfig(new Assimp.Configs.MultithreadingConfig(2));
context.SetConfig(new Assimp.Configs.FBXStrictModeConfig(false));
if (!context.IsImportFormatSupported(Path.GetExtension(filename)))
{
throw new ReactorException("Attempted to load a model that Assimp doesn't know how to load");
}
LogStream log = new LogStream((msg, user) => {
RLog.Info(msg.Remove(msg.Length - 2));
});
log.Attach();
int platform = (int)Environment.OSVersion.Platform;
Scene scene = context.ImportFile(filename,
PostProcessSteps.FindInvalidData |
PostProcessSteps.GenerateSmoothNormals |
PostProcessSteps.Triangulate |
PostProcessSteps.GenerateUVCoords |
PostProcessSteps.CalculateTangentSpace |
PostProcessSteps.PreTransformVertices);
if (scene.HasMeshes)
{
foreach (Mesh mesh in scene.Meshes)
{
if (!mesh.HasVertices)
{
continue;
}
RMeshPart rmeshpart = RMeshPart.Create <RMeshPart> ();
RVertexData [] data = new RVertexData [mesh.VertexCount];
List <int> indicesList = new List <int> ();
if (mesh.HasFaces)
{
foreach (Face face in mesh.Faces)
{
indicesList.AddRange(face.Indices.ToArray());
foreach (int index in face.Indices)
{
Vector3D p = mesh.Vertices [index];
data [index].Position = new Vector3(p.X, p.Y, p.Z);
if (mesh.HasTextureCoords(0))
{
Vector3D t = mesh.TextureCoordinateChannels [0] [index];
data [index].TexCoord = new Vector2(t.X, -t.Y);
}
if (mesh.HasNormals)
{
Vector3D n = mesh.Normals [index];
data [index].Normal = new Vector3(n.X, n.Y, n.Z);
}
if (mesh.HasTangentBasis)
{
Vector3D b = mesh.BiTangents [index];
Vector3D t = mesh.Tangents [index];
data [index].Bitangent = new Vector3(b.X, b.Y, b.Z);
data [index].Tangent = new Vector3(t.X, t.Y, t.Z);
}
}
}
}
RVertexBuffer vbuffer = new RVertexBuffer(typeof(RVertexData), mesh.VertexCount, RBufferUsage.WriteOnly, true);
RIndexBuffer ibuffer = new RIndexBuffer(typeof(int), indicesList.Count, RBufferUsage.WriteOnly);
ibuffer.SetData(indicesList.ToArray());
vbuffer.SetData <RVertexData> (data);
#if WINDOWS
var separator = "\\";
#else
var separator = "/";
#endif
rmeshpart.VertexBuffer = vbuffer;
rmeshpart.IndexBuffer = ibuffer;
RMaterial material = new RMaterial(rmesh.Name + ":Material");
if (scene.HasMaterials)
{
Material mat = scene.Materials[mesh.MaterialIndex];
material.Shininess = mat.Shininess;
material.SetColor(RMaterialColor.DIFFUSE, new RColor(mat.ColorDiffuse.R, mat.ColorDiffuse.G, mat.ColorDiffuse.B, mat.ColorDiffuse.A));
if (mat.HasTextureDiffuse)
{
var texFileName = Path.GetFileName(mat.TextureDiffuse.FilePath.Replace("\\", separator).Replace("/", separator));
RTexture2D tex = (RTexture2D)RTextures.Instance.CreateTexture <RTexture2D>(texFileName, "/textures/" + texFileName.ToLower());
tex.Bind();
tex.GenerateMipmaps();
tex.SetTextureMagFilter(RTextureMagFilter.Linear);
tex.SetTextureMinFilter(RTextureMinFilter.LinearMipmapLinear);
tex.SetTextureWrapMode(RTextureWrapMode.Repeat, RTextureWrapMode.Repeat);
tex.Unbind();
material.SetTexture(RTextureLayer.DIFFUSE, tex);
}
if (mat.HasTextureNormal)
{
var texFileName = Path.GetFileName(mat.TextureNormal.FilePath.Replace("\\", separator).Replace("/", separator));
RTexture2D tex = (RTexture2D)RTextures.Instance.CreateTexture <RTexture2D>(texFileName, "/textures/" + texFileName.ToLower());
tex.Bind();
tex.GenerateMipmaps();
tex.SetTextureMagFilter(RTextureMagFilter.Linear);
tex.SetTextureMinFilter(RTextureMinFilter.LinearMipmapLinear);
tex.SetTextureWrapMode(RTextureWrapMode.Repeat, RTextureWrapMode.Repeat);
tex.Unbind();
material.SetTexture(RTextureLayer.NORMAL, tex);
}
if (mat.HasTextureAmbient)
{
var texFileName = Path.GetFileName(mat.TextureAmbient.FilePath.Replace("\\", separator).Replace("/", separator));
RTexture2D tex = (RTexture2D)RTextures.Instance.CreateTexture <RTexture2D>(texFileName, "/textures/" + texFileName.ToLower());
tex.SetTextureMagFilter(RTextureMagFilter.Linear);
tex.SetTextureMinFilter(RTextureMinFilter.LinearMipmapLinear);
tex.SetTextureWrapMode(RTextureWrapMode.Repeat, RTextureWrapMode.Repeat);
material.SetTexture(RTextureLayer.AMBIENT, tex);
}
if (mat.HasTextureHeight)
{
var texFileName = Path.GetFileName(mat.TextureHeight.FilePath.Replace("\\", separator).Replace("/", separator));
RTexture2D tex = (RTexture2D)RTextures.Instance.CreateTexture <RTexture2D>(texFileName, "/textures/" + texFileName.ToLower());
tex.SetTextureMagFilter(RTextureMagFilter.Linear);
tex.SetTextureMinFilter(RTextureMinFilter.LinearMipmapLinear);
tex.SetTextureWrapMode(RTextureWrapMode.Repeat, RTextureWrapMode.Repeat);
material.SetTexture(RTextureLayer.HEIGHT, tex);
}
if (mat.HasTextureEmissive)
{
var texFileName = Path.GetFileName(mat.TextureEmissive.FilePath.Replace("\\", separator).Replace("/", separator));
RTexture2D tex = (RTexture2D)RTextures.Instance.CreateTexture <RTexture2D>(texFileName, "/textures/" + texFileName.ToLower());
tex.SetTextureMagFilter(RTextureMagFilter.Linear);
tex.SetTextureMinFilter(RTextureMinFilter.LinearMipmapLinear);
tex.SetTextureWrapMode(RTextureWrapMode.Repeat, RTextureWrapMode.Repeat);
material.SetTexture(RTextureLayer.GLOW, tex);
}
if (mat.HasTextureSpecular)
{
var texFileName = Path.GetFileName(mat.TextureSpecular.FilePath.Replace("\\", separator).Replace("/", separator));
RTexture2D tex = (RTexture2D)RTextures.Instance.CreateTexture <RTexture2D>(texFileName, "/textures/" + texFileName.ToLower());
tex.SetTextureMagFilter(RTextureMagFilter.Linear);
tex.SetTextureMinFilter(RTextureMinFilter.LinearMipmapLinear);
tex.SetTextureWrapMode(RTextureWrapMode.Repeat, RTextureWrapMode.Repeat);
material.SetTexture(RTextureLayer.SPECULAR, tex);
}
}
rmeshpart.Material = material;
rmesh.Parts.Add(rmeshpart);
}
//return rmesh;
}
//return null;
if (rmesh.Parts.Count == 0)
{
throw new ReactorException("Attempted to load a model when Assimp couldn't find any verticies!");
}
context.Dispose();
}
private static void DrawMesh(RMesh m, RSkeleton skeleton, Shader currentShader, RMaterial previousMaterial)
{
// Check if the uniform values have already been set for this shader.
if (previousMaterial == null || (m.Material != null && m.Material.MaterialLabel != previousMaterial.MaterialLabel))
{
m.Material.SetMaterialUniforms(currentShader, previousMaterial);
m.Material.SetRenderState();
}
m.Draw(currentShader, skeleton);
}
public MemoryStream SaveMaterial(RMaterial material)
{
return(RFileSystem.Instance.Save <RMaterial>(material));
}
public static RMaterialManager CanonizeMaterial(RMaterialManager mm, string s, RMaterial m)
{
mm.templates.Add(new CanonicalRMaterial(s, m.properties));
return mm;
}
/// <summary>
/// 设置当前材质
/// </summary>
/// <param name="uidMaterial"></param>
void SetCurrentMaterial(string uidMaterial, MaterialNode node)
{
if (!_materials.ContainsKey(uidMaterial))
{
RMaterial material = CurrentDocument.GetElement(uidMaterial) as RMaterial;
Color c = material.Color;
MaterialBuilder m = null;
try
{
if (material.Transparency != 0)
{
m = new MaterialBuilder()
.WithAlpha(SharpGLTF.Materials.AlphaMode.BLEND)
.WithDoubleSide(true)
.WithMetallicRoughnessShader()
.WithChannelParam(KnownChannel.BaseColor, new Vector4(c.Red / 256f, c.Green / 256f, c.Blue / 256f, 1 - (material.Transparency / 128f)));
}
else
{
m = new MaterialBuilder()
.WithDoubleSide(true)
.WithMetallicRoughnessShader()
.WithChannelParam(KnownChannel.BaseColor, new Vector4(c.Red / 256f, c.Green / 256f, c.Blue / 256f, 1));
}
Autodesk.Revit.DB.Visual.Asset currentAsset;
if (node.HasOverriddenAppearance)
{
currentAsset = node.GetAppearanceOverride();
}
else
{
currentAsset = node.GetAppearance();
}
try
{
//取得Asset中贴图信息
Autodesk.Revit.DB.Visual.Asset findAssert = FindTextureAsset(currentAsset as AssetProperty);
if (findAssert != null)
{
string textureFile = (findAssert["unifiedbitmap_Bitmap"] as AssetPropertyString).Value.Split('|')[0];
//用Asset中贴图信息和注册表里的材质库地址得到贴图文件所在位置
string textureName = textureFile.Replace("/", "\\");
string texturePath = Path.Combine(_textureFolder, textureName);
m.WithChannelImage(KnownChannel.BaseColor, texturePath);
}
}
catch (Exception e)
{
}
}
catch (Exception e)
{
}
_materials.Add(uidMaterial, m);
}
_currentMaterial = _materials[uidMaterial];
}
