Graphics/Material: Inline class

Former-commit-id: 7cd8b7a00c87adf087dae7d0fb8d955747cf82d1
This commit is contained in:
Lynix
2015-06-17 23:36:53 +02:00
parent 35066a3451
commit 763701df7f
3 changed files with 542 additions and 554 deletions

View File

@@ -41,23 +41,6 @@ bool NzMaterialParams::IsValid() const
return true;
}
NzMaterial::NzMaterial()
{
Reset();
}
NzMaterial::NzMaterial(const NzMaterial& material) :
NzRefCounted(),
NzResource(material)
{
Copy(material);
}
NzMaterial::~NzMaterial()
{
OnMaterialRelease(this);
}
const NzShader* NzMaterial::Apply(nzUInt32 shaderFlags, nzUInt8 textureUnit, nzUInt8* lastUsedUnit) const
{
const ShaderInstance& instance = m_shaders[shaderFlags];
@@ -137,242 +120,6 @@ const NzShader* NzMaterial::Apply(nzUInt32 shaderFlags, nzUInt8 textureUnit, nzU
return instance.shader;
}
void NzMaterial::Enable(nzRendererParameter renderParameter, bool enable)
{
#ifdef NAZARA_DEBUG
if (renderParameter > nzRendererParameter_Max)
{
NazaraError("Renderer parameter out of enum");
return;
}
#endif
m_states.parameters[renderParameter] = enable;
}
void NzMaterial::EnableAlphaTest(bool alphaTest)
{
m_alphaTestEnabled = alphaTest;
InvalidateShaders();
}
void NzMaterial::EnableDepthSorting(bool depthSorting)
{
m_depthSortingEnabled = depthSorting;
}
void NzMaterial::EnableLighting(bool lighting)
{
m_lightingEnabled = lighting;
InvalidateShaders();
}
void NzMaterial::EnableTransform(bool transform)
{
m_transformEnabled = transform;
InvalidateShaders();
}
NzTexture* NzMaterial::GetAlphaMap() const
{
return m_alphaMap;
}
float NzMaterial::GetAlphaThreshold() const
{
return m_alphaThreshold;
}
NzColor NzMaterial::GetAmbientColor() const
{
return m_ambientColor;
}
nzRendererComparison NzMaterial::GetDepthFunc() const
{
return m_states.depthFunc;
}
NzColor NzMaterial::GetDiffuseColor() const
{
return m_diffuseColor;
}
NzTextureSampler& NzMaterial::GetDiffuseSampler()
{
return m_diffuseSampler;
}
const NzTextureSampler& NzMaterial::GetDiffuseSampler() const
{
return m_diffuseSampler;
}
NzTexture* NzMaterial::GetDiffuseMap() const
{
return m_diffuseMap;
}
nzBlendFunc NzMaterial::GetDstBlend() const
{
return m_states.dstBlend;
}
NzTexture* NzMaterial::GetEmissiveMap() const
{
return m_emissiveMap;
}
nzFaceSide NzMaterial::GetFaceCulling() const
{
return m_states.faceCulling;
}
nzFaceFilling NzMaterial::GetFaceFilling() const
{
return m_states.faceFilling;
}
NzTexture* NzMaterial::GetHeightMap() const
{
return m_heightMap;
}
NzTexture* NzMaterial::GetNormalMap() const
{
return m_normalMap;
}
const NzRenderStates& NzMaterial::GetRenderStates() const
{
return m_states;
}
const NzUberShader* NzMaterial::GetShader() const
{
return m_uberShader;
}
const NzUberShaderInstance* NzMaterial::GetShaderInstance(nzUInt32 flags) const
{
const ShaderInstance& instance = m_shaders[flags];
if (!instance.uberInstance)
GenerateShader(flags);
return instance.uberInstance;
}
float NzMaterial::GetShininess() const
{
return m_shininess;
}
NzColor NzMaterial::GetSpecularColor() const
{
return m_specularColor;
}
NzTexture* NzMaterial::GetSpecularMap() const
{
return m_specularMap;
}
NzTextureSampler& NzMaterial::GetSpecularSampler()
{
return m_specularSampler;
}
const NzTextureSampler& NzMaterial::GetSpecularSampler() const
{
return m_specularSampler;
}
nzBlendFunc NzMaterial::GetSrcBlend() const
{
return m_states.srcBlend;
}
bool NzMaterial::HasAlphaMap() const
{
return m_alphaMap.IsValid();
}
bool NzMaterial::HasDiffuseMap() const
{
return m_diffuseMap.IsValid();
}
bool NzMaterial::HasEmissiveMap() const
{
return m_emissiveMap.IsValid();
}
bool NzMaterial::HasHeightMap() const
{
return m_heightMap.IsValid();
}
bool NzMaterial::HasNormalMap() const
{
return m_normalMap.IsValid();
}
bool NzMaterial::HasSpecularMap() const
{
return m_specularMap.IsValid();
}
bool NzMaterial::IsAlphaTestEnabled() const
{
return m_alphaTestEnabled;
}
bool NzMaterial::IsDepthSortingEnabled() const
{
return m_depthSortingEnabled;
}
bool NzMaterial::IsEnabled(nzRendererParameter parameter) const
{
#ifdef NAZARA_DEBUG
if (parameter > nzRendererParameter_Max)
{
NazaraError("Renderer parameter out of enum");
return false;
}
#endif
return m_states.parameters[parameter];
}
bool NzMaterial::IsLightingEnabled() const
{
return m_lightingEnabled;
}
bool NzMaterial::IsTransformEnabled() const
{
return m_transformEnabled;
}
bool NzMaterial::LoadFromFile(const NzString& filePath, const NzMaterialParams& params)
{
return NzMaterialLoader::LoadFromFile(this, filePath, params);
}
bool NzMaterial::LoadFromMemory(const void* data, std::size_t size, const NzMaterialParams& params)
{
return NzMaterialLoader::LoadFromMemory(this, data, size, params);
}
bool NzMaterial::LoadFromStream(NzInputStream& stream, const NzMaterialParams& params)
{
return NzMaterialLoader::LoadFromStream(this, stream, params);
}
void NzMaterial::Reset()
{
OnMaterialReset(this);
@@ -406,227 +153,6 @@ void NzMaterial::Reset()
SetShader("Basic");
}
bool NzMaterial::SetAlphaMap(const NzString& textureName)
{
NzTextureRef texture = NzTextureLibrary::Query(textureName);
if (!texture)
{
texture = NzTextureManager::Get(textureName);
if (!texture)
return false;
}
SetAlphaMap(std::move(texture));
return true;
}
void NzMaterial::SetAlphaMap(NzTextureRef alphaMap)
{
m_alphaMap = std::move(alphaMap);
InvalidateShaders();
}
void NzMaterial::SetAlphaThreshold(float alphaThreshold)
{
m_alphaThreshold = alphaThreshold;
}
void NzMaterial::SetAmbientColor(const NzColor& ambient)
{
m_ambientColor = ambient;
}
void NzMaterial::SetDepthFunc(nzRendererComparison depthFunc)
{
m_states.depthFunc = depthFunc;
}
void NzMaterial::SetDiffuseColor(const NzColor& diffuse)
{
m_diffuseColor = diffuse;
}
bool NzMaterial::SetDiffuseMap(const NzString& textureName)
{
NzTextureRef texture = NzTextureLibrary::Query(textureName);
if (!texture)
{
texture = NzTextureManager::Get(textureName);
if (!texture)
return false;
}
SetDiffuseMap(std::move(texture));
return true;
}
void NzMaterial::SetDiffuseMap(NzTextureRef diffuseMap)
{
m_diffuseMap = std::move(diffuseMap);
InvalidateShaders();
}
void NzMaterial::SetDiffuseSampler(const NzTextureSampler& sampler)
{
m_diffuseSampler = sampler;
}
void NzMaterial::SetDstBlend(nzBlendFunc func)
{
m_states.dstBlend = func;
}
bool NzMaterial::SetEmissiveMap(const NzString& textureName)
{
NzTextureRef texture = NzTextureLibrary::Query(textureName);
if (!texture)
{
texture = NzTextureManager::Get(textureName);
if (!texture)
return false;
}
SetEmissiveMap(std::move(texture));
return true;
}
void NzMaterial::SetEmissiveMap(NzTextureRef emissiveMap)
{
m_emissiveMap = std::move(emissiveMap);
InvalidateShaders();
}
void NzMaterial::SetFaceCulling(nzFaceSide faceSide)
{
m_states.faceCulling = faceSide;
}
void NzMaterial::SetFaceFilling(nzFaceFilling filling)
{
m_states.faceFilling = filling;
}
bool NzMaterial::SetHeightMap(const NzString& textureName)
{
NzTextureRef texture = NzTextureLibrary::Query(textureName);
if (!texture)
{
texture = NzTextureManager::Get(textureName);
if (!texture)
return false;
}
SetHeightMap(std::move(texture));
return true;
}
void NzMaterial::SetHeightMap(NzTextureRef heightMap)
{
m_heightMap = std::move(heightMap);
InvalidateShaders();
}
bool NzMaterial::SetNormalMap(const NzString& textureName)
{
NzTextureRef texture = NzTextureLibrary::Query(textureName);
if (!texture)
{
texture = NzTextureManager::Get(textureName);
if (!texture)
return false;
}
SetNormalMap(std::move(texture));
return true;
}
void NzMaterial::SetNormalMap(NzTextureRef normalMap)
{
m_normalMap = std::move(normalMap);
InvalidateShaders();
}
void NzMaterial::SetRenderStates(const NzRenderStates& states)
{
m_states = states;
}
void NzMaterial::SetShader(NzUberShaderConstRef uberShader)
{
m_uberShader = std::move(uberShader);
InvalidateShaders();
}
bool NzMaterial::SetShader(const NzString& uberShaderName)
{
NzUberShaderConstRef uberShader = NzUberShaderLibrary::Get(uberShaderName);
if (!uberShader)
return false;
SetShader(std::move(uberShader));
return true;
}
void NzMaterial::SetShininess(float shininess)
{
m_shininess = shininess;
}
void NzMaterial::SetSpecularColor(const NzColor& specular)
{
m_specularColor = specular;
}
bool NzMaterial::SetSpecularMap(const NzString& textureName)
{
NzTextureRef texture = NzTextureLibrary::Query(textureName);
if (!texture)
{
texture = NzTextureManager::Get(textureName);
if (!texture)
return false;
}
SetSpecularMap(std::move(texture));
return true;
}
void NzMaterial::SetSpecularMap(NzTextureRef specularMap)
{
m_specularMap = std::move(specularMap);
InvalidateShaders();
}
void NzMaterial::SetSpecularSampler(const NzTextureSampler& sampler)
{
m_specularSampler = sampler;
}
void NzMaterial::SetSrcBlend(nzBlendFunc func)
{
m_states.srcBlend = func;
}
NzMaterial& NzMaterial::operator=(const NzMaterial& material)
{
NzResource::operator=(material);
Copy(material);
return *this;
}
NzMaterialRef NzMaterial::GetDefault()
{
return s_defaultMaterial;
}
void NzMaterial::Copy(const NzMaterial& material)
{
// Copie des états de base
@@ -702,12 +228,6 @@ void NzMaterial::GenerateShader(nzUInt32 flags) const
#undef CacheUniform
}
void NzMaterial::InvalidateShaders()
{
for (ShaderInstance& instance : m_shaders)
instance.uberInstance = nullptr;
}
bool NzMaterial::Initialize()
{
if (!NzMaterialLibrary::Initialize())