internal void UpdateMaterial(MaterialState type)
{
if (MeshRender == null)
{
return;
}
Material[] mats = null;
switch (type)
{
case MaterialState.Normal:
{
mats = Materials;
break;
}
case MaterialState.TouMing:
{
mats = TouMingMaterials;
break;
}
}
if (mats != null)
{
MeshRender.materials = mats;
}
}
public MaterialState CreateMaterialState()
{
MaterialState objMaterial = new MaterialState();
objMaterial.FrontMaterial.Ambient = Material.Ambient;
if (Material.AmbientTexture != null)
{
objMaterial.FrontMaterialAmbientTexture = Material.AmbientTexture;
objMaterial.FrontMaterialAmbientTexCoord = 0;
}
objMaterial.FrontMaterial.Diffuse = Material.Diffuse;
if (Material.DiffuseTexture != null)
{
objMaterial.FrontMaterialDiffuseTexture = Material.DiffuseTexture;
objMaterial.FrontMaterialDiffuseTexCoord = 0;
}
objMaterial.FrontMaterial.Specular = Material.Specular;
objMaterial.FrontMaterial.Shininess = Material.SpecularExponent;
if (Material.NormalTexture != null)
{
objMaterial.FrontMaterialNormalTexture = Material.NormalTexture;
objMaterial.FrontMaterialNormalTexCoord = 0;
}
return(objMaterial);
}
/// <summary>
/// 修改材质
/// </summary>
/// <param name="state"></param>
public void ChangeMatTo(MaterialState state)
{
if (state.materials != null)
{
List <string> keywords = new List <string>();
foreach (var clip in state.Clips)
{
if (clip.from.type == PropertyType.keyword)
{
keywords.Add(clip.from.key);
}
}
Material[] mats = new Material[state.materials.Length];
for (int i = 0; i < state.materials.Length; i++)
{
var mat = state.materials[i];
if (mat == null)
{
mats[i] = Renderer.materials[i];
}
else
{
mats[i] = mat;
}
mats[i].shaderKeywords = keywords.ToArray();
}
Renderer.materials = mats;
}
}
private SceneObjectGeometry CreateCubeGeometry()
{
SceneObjectGeometry cubeGeometry = new SceneObjectGeometry("Cube");
#region State
cubeGeometry.ObjectState.DefineState(new CullFaceState(FrontFaceDirection.Ccw, CullFaceMode.Back));
cubeGeometry.ObjectState.DefineState(new TransformState());
MaterialState cubeMaterialState = new MaterialState();
cubeMaterialState.FrontMaterial = new MaterialState.Material(ColorRGBAF.ColorWhite * 0.5f);
cubeMaterialState.FrontMaterial.Ambient = ColorRGBAF.ColorBlack;
cubeMaterialState.FrontMaterial.Diffuse = ColorRGBAF.ColorWhite * 0.5f;
cubeMaterialState.FrontMaterial.Specular = ColorRGBAF.ColorWhite * 0.5f;
cubeMaterialState.FrontMaterial.Shininess = 10.0f;
cubeGeometry.ObjectState.DefineState(cubeMaterialState);
#endregion
#region Vertex Arrays
if (_CubeArrayPosition == null)
{
_CubeArrayPosition = new ArrayBuffer <Vertex3f>();
_CubeArrayPosition.Create(ArrayPosition);
}
if (_CubeArrayColor == null)
{
_CubeArrayColor = new ArrayBuffer <ColorRGBF>();
_CubeArrayColor.Create(ArrayColors);
}
if (_CubeArrayNormal == null)
{
_CubeArrayNormal = new ArrayBuffer <Vertex3f>();
_CubeArrayNormal.Create(ArrayNormals);
}
if (_CubeArrays == null)
{
_CubeArrays = new VertexArrays();
_CubeArrays.SetArray(_CubeArrayPosition, VertexArraySemantic.Position);
_CubeArrays.SetArray(_CubeArrayColor, VertexArraySemantic.Color);
_CubeArrays.SetArray(_CubeArrayNormal, VertexArraySemantic.Normal);
_CubeArrays.SetElementArray(PrimitiveType.Triangles);
}
cubeGeometry.VertexArray = _CubeArrays;
#endregion
#region Program
cubeGeometry.BoundingVolume = new BoundingBox(-Vertex3f.One * _CubeSize, Vertex3f.One * _CubeSize);
#endregion
return(cubeGeometry);
}
public GameObject Pop(MaterialState state)
{
GameObject obj;
switch (state)
{
case MaterialState.WOOD:
obj = woodPool.pop();
break;
case MaterialState.STONE:
obj = stonePool.pop();
break;
case MaterialState.IRON:
obj = ironPool.pop();
break;
case MaterialState.ADAM:
obj = adamPool.pop();
break;
default:
obj = woodPool.pop();
break;
}
activeList.Add(obj);
return(obj);
}
public void Remove(MaterialState state, GameObject obj)
{
if (activeList.Remove(obj))
{
Reset(state, obj);
}
}
/// <summary>
/// Sets the standard material as renderer.
/// </summary>
public void SetStandardMaterial()
{
if (null != standardMaterial)
{
GetComponent <Renderer> ().material = standardMaterial;
materialState = MaterialState.Standard; // refresh the actual state of material
}
}
/// <summary>
/// Sets the playback material.
/// </summary>
public void SetPlaybackMaterial()
{
if (null != playbackMaterial)
{
GetComponent <Renderer> ().material = playbackMaterial;
materialState = MaterialState.Playback;
}
}
/// <summary>
/// Sets the negative material.
/// </summary>
private void SetNegativeMaterial()
{
if (null != negativeMaterial)
{
GetComponent <Renderer> ().material = negativeMaterial;
materialState = MaterialState.Negative;
}
}
IEnumerator DelayChangeMaterialState(MaterialState type)
{
yield return(new WaitForSeconds(0.8f));
if (m_MatChangeState == type)
{
ChangeMaterialState(type);
}
}
void _updateState(MaterialState state, bool value)
{
if (value)
{
_states.Add(state);
}
else
{
_states.Remove(state);
}
}
void ChangeMaterialState(MaterialState type)
{
//SSDebug.Log("ChangeMaterialState -> type ================ " + type);
for (int i = 0; i < m_MaterrialDt.Length; i++)
{
if (m_MaterrialDt[i] != null)
{
m_MaterrialDt[i].UpdateMaterial(type);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Substance"/> class.
/// </summary>
/// <param name="type">The MaterialType of the substance.</param>
/// <param name="mass">The mass of substance to be created.</param>
/// <param name="tempInCelsius">The temperature of the substance in celsius.</param>
/// <param name="state">The material state of the substance.</param>
public Substance(MaterialType type, double mass, double tempInCelsius, MaterialState state = MaterialState.Unknown)
{
if (mass > float.MaxValue)
{
mass = float.MaxValue;
}
m_ssh = new MementoHelper(this, true);
m_type = type;
m_mass = mass;
Temperature = tempInCelsius;
State = state;
}
public TileData(bool isPlayerGround, int index, int hp, TileState tileState, MaterialState materialState)
{
if (tileState != TileState.MATERIAL)
{
return;
}
this.isPlayerGround = isPlayerGround;
this.index = index;
this.hp = hp;
this.tileState = tileState;
this.materialState = materialState;
}
private void Collect(MaterialState materialState, int clickTileIndex)
{ // 플레이어가 자원 타일을 클릭하면 들어오는 함수
if (!isNearTile(clickTileIndex) || onBunker)
{
return;
}
if (!isHasStamina())
{
if (isPlayer)
{
unitUI.ShowMessege("스테미너가 부족합니다.");
}
unitUI.UnitStaminaDiscount(unitData.stamina);
return;
}
if (ground.GetTile(clickTileIndex).TileHurt(unitData.unitDemage) == false)
{
return;
}
switch (materialState)
{
case MaterialState.WOOD:
unitData.unitMaterial.wood += unitData.unitDemage;
unitUI.ShowHeadPopUp("나무 + " + unitData.unitDemage);
break;
case MaterialState.STONE:
unitData.unitMaterial.stone += unitData.unitDemage;
unitUI.ShowHeadPopUp("돌 + " + unitData.unitDemage);
break;
case MaterialState.IRON:
unitData.unitMaterial.iron += unitData.unitDemage;
unitUI.ShowHeadPopUp("철 + " + unitData.unitDemage);
break;
case MaterialState.ADAM:
unitData.unitMaterial.adam += unitData.unitDemage;
unitUI.ShowHeadPopUp("아티움 + " + unitData.unitDemage);
break;
}
if (isPlayer)
{
EventManager.Instance.emit(EVENT_TYPE.MATERIAL_COLLECT, this, unitData.unitMaterial);
}
else
{
EventManager.Instance.emit(EVENT_TYPE.ENEMYMATERAIL_COLLECT, this, unitData.unitMaterial);
}
UnitStaminaCount();
CheckAround();
}
// Use this for initialization
void Start()
{
rb = GetComponent <Rigidbody> ();
rend = GetComponent <Renderer>();
currentMaterial = MaterialState.undefined;
gemCount = 0;
enemyCount = 0;
updateGemText();
updateEnemiesText();
#if UNITY_IOS
Screen.orientation = ScreenOrientation.LandscapeLeft;
#endif
}
/// <summary>
/// 更新材质球.
/// </summary>
void UpdateMaterialState(MaterialState type)
{
if (m_MatChangeState == type)
{
return;
}
m_MatChangeState = type;
if (Time.time - m_TimeLast < 0.8f)
{
StartCoroutine(DelayChangeMaterialState(type));
return;
}
m_TimeLast = Time.time;
ChangeMaterialState(type);
}
public MaterialState GetState(string stateName)
{
if (stateName.IsNullOrEmpty())
{
return(Default);
}
if (dic == null)
{
dic = new Dictionary <string, MaterialState>();
foreach (var state in States)
{
dic[state.StateName] = state;
}
}
MaterialState sta = null;
dic.TryGetValue(stateName, out sta);
return(sta);
}
/// <summary>
/// Constructor for MaterialType. Provides a way for the user to specify all of the detailed
/// characteristics of the material.
/// </summary>
/// <param name="model">The model to which this MaterialType will belong.</param>
/// <param name="name">The name of this MaterialType.</param>
/// <param name="guid">The Guid of this MaterialType.</param>
/// <param name="specificGravity">The specific gravity associated with material of this type.</param>
/// <param name="specificHeat">The specific heat associated with material of this type.</param>
/// <param name="stpState">State of the material at Standard Temperature & Pressure conditions.</param>
/// <param name="molecularWeight">The molecular weight.</param>
/// <param name="latentHeatOfVaporization">The latent heat of vaporization associated with material of this type. J/kg.</param>
public MaterialType(IModel model, string name, Guid guid,
double specificGravity,
double specificHeat,
MaterialState stpState,
double molecularWeight,
double latentHeatOfVaporization
)
{
m_name = name;
m_guid = guid;
m_model = model;
STPState = stpState;
SetSpecificGravity(specificGravity); // kilogram per liter.
SetSpecificHeat(specificHeat); // Joules per Kilogram-degree K.
SetMolecularWeight(molecularWeight);
SetLatentHeatOfVaporization(latentHeatOfVaporization); // Joules per Kilogram.
m_emissionClassifications = null;
IMOHelper.RegisterWithModel(this);
}
public void ChangeMaterial(MaterialState state)
{
if (health.IsDead)
{
return;
}
if (state == MaterialState.NormalMaterial)
{
highlightImage.color = normalColor;
}
else if (state == MaterialState.HighlightMaterial)
{
highlightImage.color = highlightColor;
}
else if (state == MaterialState.SelectedMaterial)
{
highlightImage.color = selectedColor;
}
}
private void Reset(MaterialState state, GameObject obj)
{
switch (state)
{
case MaterialState.WOOD:
woodPool.push(obj);
break;
case MaterialState.STONE:
stonePool.push(obj);
break;
case MaterialState.IRON:
ironPool.push(obj);
break;
case MaterialState.ADAM:
adamPool.push(obj);
break;
}
obj.SetActive(false);
}
private SceneObjectGeometry CreatePlane()
{
SceneObjectGeometry geometry = new SceneObjectGeometry("Plane");
geometry.VertexArray = VertexArrays.CreatePlane(50.0f, 50.0f, 0.0f, 1, 1);
geometry.ObjectState.DefineState(new CullFaceState(FrontFaceDirection.Ccw, CullFaceMode.Back));
geometry.ObjectState.DefineState(new TransformState());
MaterialState cubeMaterialState = new MaterialState();
cubeMaterialState.FrontMaterial = new MaterialState.Material(ColorRGBAF.ColorWhite * 0.5f);
cubeMaterialState.FrontMaterial.Ambient = ColorRGBAF.ColorBlack;
cubeMaterialState.FrontMaterial.Diffuse = ColorRGBAF.ColorWhite * 0.5f;
cubeMaterialState.FrontMaterial.Specular = ColorRGBAF.ColorBlack;
geometry.ObjectState.DefineState(cubeMaterialState);
geometry.LocalModel.RotateX(-90.0);
geometry.ProgramTag = ShadersLibrary.Instance.CreateProgramTag("OpenGL.Standard+PhongFragment");
return(geometry);
}
public GameObject NextState()
{
switch (currentState)
{
case MaterialState.original:
currentState++;
return(refinedMaterial);
case MaterialState.refined:
currentState++;
return(processedMaterial);
case MaterialState.processed:
currentState = MaterialState.damaged;
return(damagedMaterial);
case MaterialState.damaged:
return(damagedMaterial);
default:
return(damagedMaterial);
}
}
void OnTriggerEnter(Collider other)
{
if (other.gameObject.CompareTag("Pick Up"))
{
if (currentMaterial == MaterialState.gem)
{
other.gameObject.SetActive(false);
gemCount++;
updateGemText();
}
}
else if (other.gameObject.CompareTag("Enemy"))
{
enemyCount++;
updateEnemiesText();
other.gameObject.SetActive(false);
gameObject.SetActive(false);
}
else if (other.gameObject.CompareTag("Gem Wall"))
{
Debug.Log("on trigger enter GEM wall");
rend.material = other.GetComponent <Renderer> ().material;
other.isTrigger = false;
currentMaterial = MaterialState.gem;
}
else if (other.gameObject.CompareTag("Enemy Wall"))
{
Debug.Log("on trigger enter ENEMY wall");
rend.material = other.GetComponent <Renderer> ().material;
other.isTrigger = false;
currentMaterial = MaterialState.enemy;
}
// Debug.Log (other.GetComponent<Renderer>().material.name);
// Debug.Log (rend.material.name);
}
/// <summary>
/// Constructor for MaterialType. Uses default values for all unspecified (see larger
/// ctor) properties, marks Molecular Weight as unknown.
/// </summary>
/// <param name="model">The model to which this MaterialType will belong.</param>
/// <param name="name">The name of this MaterialType.</param>
/// <param name="guid">The Guid of this MaterialType.</param>
/// <param name="specificGravity">The specific gravity associated with material of this type.</param>
/// <param name="specificHeat">The specific heat associated with material of this type.</param>
/// <param name="stpState">The state of the material at standard temperature and pressure.</param>
public MaterialType(IModel model, string name, Guid guid, double specificGravity, double specificHeat, MaterialState stpState)
: this(model, name, guid, specificGravity, specificHeat, stpState, UNKNOWN_MOLECULAR_WEIGHT,
s_default_Lhov)
{
}
public MaterialResource(string description, string serialNumber, MaterialState state)
{
_description = description;
_serialNumber = serialNumber;
_state = state;
}
private void RenderMeshes(IEnumerable <Mesh> Meshes)
{
foreach (Mesh Mesh in Meshes)
{
int n = Mesh.BaseMesh.NodeIndex;
if (n < Visibilities.Length && !Visibilities[n])
{
continue;
}
Shader Shader = Shaders[Mesh.BaseMesh.MaterialIndex];
GL.UseProgram(Shader.Handle);
Shader.SetVtx4x4Array(DefaultShaderIds.ProjMtx, Renderer.Camera.ProjectionMatrix);
Shader.SetVtx3x4Array(DefaultShaderIds.ViewMtx, Renderer.Camera.ViewMatrix * Transform);
Shader.SetVtx3x4Array(DefaultShaderIds.NormMtx, Transform.ClearScale());
Shader.SetVtx3x4Array(DefaultShaderIds.WrldMtx, Matrix4.Identity);
int MaterialIndex = Mesh.BaseMesh.MaterialIndex;
H3DMaterialParams MP = BaseModel.Materials[MaterialIndex].MaterialParams;
MaterialState MS = MaterialStates[Mesh.BaseMesh.MaterialIndex];
Vector4 MatAmbient = new Vector4(
MS.Ambient.R,
MS.Ambient.G,
MS.Ambient.B,
MP.ColorScale);
Vector4 MatDiffuse = new Vector4(
MS.Diffuse.R,
MS.Diffuse.G,
MS.Diffuse.B,
MS.Diffuse.A);
Shader.SetVtxVector4(DefaultShaderIds.MatAmbi, MatAmbient);
Shader.SetVtxVector4(DefaultShaderIds.MatDiff, MatDiffuse);
Shader.SetVtx3x4Array(DefaultShaderIds.TexMtx0, MS.Transforms[0]);
Shader.SetVtx3x4Array(DefaultShaderIds.TexMtx1, MS.Transforms[1]);
Shader.SetVtx2x4Array(DefaultShaderIds.TexMtx2, MS.Transforms[2]);
Shader.SetVtxVector4(DefaultShaderIds.TexTran, new Vector4(
MS.Transforms[0].Row3.X,
MS.Transforms[0].Row3.Y,
MS.Transforms[1].Row3.X,
MS.Transforms[1].Row3.Y));
GL.Uniform4(GL.GetUniformLocation(Shader.Handle, FragmentShaderGenerator.EmissionUniform), MS.Emission);
GL.Uniform4(GL.GetUniformLocation(Shader.Handle, FragmentShaderGenerator.AmbientUniform), MS.Ambient);
GL.Uniform4(GL.GetUniformLocation(Shader.Handle, FragmentShaderGenerator.DiffuseUniform), MS.Diffuse);
GL.Uniform4(GL.GetUniformLocation(Shader.Handle, FragmentShaderGenerator.Specular0Uniform), MS.Specular0);
GL.Uniform4(GL.GetUniformLocation(Shader.Handle, FragmentShaderGenerator.Specular1Uniform), MS.Specular1);
GL.Uniform4(GL.GetUniformLocation(Shader.Handle, FragmentShaderGenerator.Constant0Uniform), MS.Constant0);
GL.Uniform4(GL.GetUniformLocation(Shader.Handle, FragmentShaderGenerator.Constant1Uniform), MS.Constant1);
GL.Uniform4(GL.GetUniformLocation(Shader.Handle, FragmentShaderGenerator.Constant2Uniform), MS.Constant2);
GL.Uniform4(GL.GetUniformLocation(Shader.Handle, FragmentShaderGenerator.Constant3Uniform), MS.Constant3);
GL.Uniform4(GL.GetUniformLocation(Shader.Handle, FragmentShaderGenerator.Constant4Uniform), MS.Constant4);
GL.Uniform4(GL.GetUniformLocation(Shader.Handle, FragmentShaderGenerator.Constant5Uniform), MS.Constant5);
Mesh.Texture0Name = MS.Texture0Name;
Mesh.Texture1Name = MS.Texture1Name;
Mesh.Texture2Name = MS.Texture2Name;
Mesh.Render();
}
}
private void SetSphereMaterial(SceneObjectGeometry sphere, string material)
{
MaterialState sphereMaterial = new MaterialState();
sphereMaterial.FrontMaterial = new MaterialState.Material(ColorRGBAF.ColorWhite);
sphereMaterial.FrontMaterial.Ambient = ColorRGBAF.ColorWhite * 0.2f;
sphereMaterial.FrontMaterial.Diffuse = ColorRGBAF.ColorWhite * 0.8f;
sphereMaterial.FrontMaterial.Specular = ColorRGBAF.ColorWhite * 1.0f;
sphereMaterial.FrontMaterial.Shininess = 32.0f;
sphere.ObjectState.DefineState(sphereMaterial);
if (material == null)
{
return;
}
string basePath = Path.Combine("Data", "PhotosculptTextures");
string textureFilename, texturePath;
textureFilename = String.Format("photosculpt-{0}-{1}.jpg", material, "diffuse");
texturePath = Path.Combine(basePath, textureFilename);
if (File.Exists(texturePath))
{
try {
Image textureImage = ImageCodec.Instance.Load(texturePath);
Texture2d texture = new Texture2d();
texture.RequestMipmapsCreation();
texture.WrapCoordR = Texture.Wrap.MirroredRepeat;
texture.WrapCoordS = Texture.Wrap.MirroredRepeat;
texture.Create(textureImage);
sphereMaterial.FrontMaterialDiffuseTexture = texture;
sphereMaterial.FrontMaterialDiffuseTexCoord = 0;
} catch (Exception exception) {
throw new InvalidOperationException(String.Format("unable to load texture {0}", texturePath), exception);
}
}
textureFilename = String.Format("photosculpt-{0}-{1}.jpg", material, "normal");
texturePath = Path.Combine(basePath, textureFilename);
if (File.Exists(texturePath))
{
try {
Image textureImage = ImageCodec.Instance.Load(texturePath);
Texture2d texture = new Texture2d();
texture.RequestMipmapsCreation();
texture.WrapCoordR = Texture.Wrap.MirroredRepeat;
texture.WrapCoordS = Texture.Wrap.MirroredRepeat;
texture.Create(textureImage);
sphereMaterial.FrontMaterialNormalTexture = texture;
sphereMaterial.FrontMaterialNormalTexCoord = 0;
} catch (Exception exception) {
throw new InvalidOperationException(String.Format("unable to load texture {0}", texturePath), exception);
}
}
textureFilename = String.Format("photosculpt-{0}-{1}.jpg", material, "specular");
texturePath = Path.Combine(basePath, textureFilename);
if (File.Exists(texturePath))
{
try {
Image textureImage = ImageCodec.Instance.Load(texturePath);
Texture2d texture = new Texture2d();
texture.RequestMipmapsCreation();
texture.WrapCoordR = Texture.Wrap.MirroredRepeat;
texture.WrapCoordS = Texture.Wrap.MirroredRepeat;
texture.Create(textureImage);
sphereMaterial.FrontMaterialSpecularTexture = texture;
sphereMaterial.FrontMaterialSpecularTexCoord = 0;
} catch (Exception exception) {
throw new InvalidOperationException(String.Format("unable to load texture {0}", texturePath), exception);
}
}
textureFilename = String.Format("photosculpt-{0}-{1}.jpg", material, "ambientocclusion");
texturePath = Path.Combine(basePath, textureFilename);
if (File.Exists(texturePath))
{
try {
Image textureImage = ImageCodec.Instance.Load(texturePath);
Texture2d texture = new Texture2d();
texture.RequestMipmapsCreation();
texture.WrapCoordR = Texture.Wrap.MirroredRepeat;
texture.WrapCoordS = Texture.Wrap.MirroredRepeat;
texture.Create(textureImage);
sphereMaterial.FrontMaterialAmbientTexture = texture;
sphereMaterial.FrontMaterialAmbientTexCoord = 0;
} catch (Exception exception) {
throw new InvalidOperationException(String.Format("unable to load texture {0}", texturePath), exception);
}
}
textureFilename = String.Format("photosculpt-{0}-{1}.jpg", material, "displace");
texturePath = Path.Combine(basePath, textureFilename);
if (File.Exists(texturePath))
{
try {
Image textureImage = ImageCodec.Instance.Load(texturePath);
Texture2d texture = new Texture2d();
// texture.RequestMipmapsCreation();
texture.WrapCoordR = Texture.Wrap.Repeat;
texture.WrapCoordS = Texture.Wrap.Repeat;
texture.MinFilter = Texture.Filter.Nearest;
texture.MagFilter = Texture.Filter.Nearest;
texture.MipmapMaxLevel = 0;
texture.Create(textureImage);
sphereMaterial.FrontMaterialDisplacementTexture = texture;
// sphereMaterial.FrontMaterialDisplacementTexCoord = 0;
sphereMaterial.FrontMaterialDisplacementFactor = 0.2f;
} catch (Exception exception) {
throw new InvalidOperationException(String.Format("unable to load texture {0}", texturePath), exception);
}
}
}
public MaterialResource(string description, string serialNumber, MaterialState state)
{
_description = description;
_serialNumber = serialNumber;
_state = state;
}
public GPUSkinningMaterial GetMaterial(MaterialState state)
{
return(mtrls[(int)state]);
}
/// <summary>
/// Constructor for MaterialType. Uses default values for all unspecified (see larger constructor) properties.
/// </summary>
/// <param name="model">The model to which this MaterialType will belong.</param>
/// <param name="name">The name of this MaterialType.</param>
/// <param name="guid">The Guid of this MaterialType.</param>
/// <param name="specificGravity">The specific gravity associated with material of this type.</param>
/// <param name="specificHeat">The specific heat associated with material of this type.</param>
/// <param name="stpState">The state of the material at standard temperature and pressure.</param>
/// <param name="molecularWeight">The molecular weight of this substance.</param>
public MaterialType(IModel model, string name, Guid guid, double specificGravity, double specificHeat, MaterialState stpState, double molecularWeight)
: this(model, name, guid, specificGravity, specificHeat, stpState, molecularWeight,
s_default_Lhov)
{
}
