Texture* GraphicsEngine::GaussianBlur(Texture* input, float radius, bool halfRes)
{
FBO* blurFBO = GetFBO(BLUR);
if (halfRes)
blurFBO = GetFBO(HALF);
blurFBO->BindForWriting();
blurFBO->SetDrawBuffer(0);
GetShader("Gaussian")->Use();
GetShader("Gaussian")->SetUniform2f("blurSize", 1.0f / Screen.width * (1 + halfRes), 1.0f / Screen.height * (1 + halfRes));
GetShader("Gaussian")->SetUniform1f("radius", radius);
//Horizontal Blur
GetShader("Gaussian")->SetUniform1i("verticalBlur", false);
input->Bind();
FBO::Render();
blurFBO->SetDrawBuffer(1);
//Vertical Blur
GetShader("Gaussian")->SetUniform1i("verticalBlur", true);
blurFBO->GetTexture()->Bind();
FBO::Render();
return blurFBO->GetActiveTexture();
}
void LindenmayerTreeNode::Render(OGLRenderer& r, bool render_children) {
if (r.GetCurrentShader() != shader) r.SetCurrentShader(shader);
r.UpdateShaderMatrices();
Matrix4 transform = GetWorldTransform() * Matrix4::Scale(GetModelScale());
glUniformMatrix4fv(glGetUniformLocation(GetShader()->GetProgram(), "modelMatrix"), 1, false, (float*)&transform);
glUniformMatrix4fv(glGetUniformLocation(GetShader()->GetProgram(), "textureMatrix"), 1, false, (float*)&GetTextureMatrix());
glUniform4fv(glGetUniformLocation(GetShader()->GetProgram(), "nodeColour"), 1, (float*)&GetColour());
/*Draw the branches first to reduce expensive BindTexture calls*/
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0].id);
for (auto it = children.begin(); it != children.end(); ++it) {
mem_usage += sizeof(LBranchNode);
(*it)->Render(r, false);
}
/*Then draw the "leaves", turning off alpha blending to do so*/
glBindTexture(GL_TEXTURE_2D, textures[1].id);
glDisable(GL_BLEND);
for (auto it = children.begin(); it != children.end(); ++it) {
for (auto it2 = (*it)->GetChildIteratorStart(); it2 != (*it)->GetChildIteratorEnd(); ++it2) {
mem_usage += sizeof(LLeafNode) + sizeof(ParticleEmitter);
(*it2)->Render(r, false);
}
}
glEnable(GL_BLEND);
}
void IRenderSystem::Draw()
{
// Set clear color
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
// Calculate matrices
m_ProjectionMatrix = glm::perspective(m_Camera->GetFOV(), float(GetGame()->GetWindowWidth()) / float(GetGame()->GetWindowHeight()), GetCamera()->GetNearZ(), GetCamera()->GetFarZ());
m_ViewMatrix = glm::lookAt(m_Camera->GetPos(), m_Camera->GetPos() + m_Camera->GetDirection(), m_Camera->GetUp());
m_ViewRotMatrix = glm::mat3(m_ViewMatrix);
if (GetShader("gbuffer") != 0)
{
// Geometry Pass
SetShader(GetShader("gbuffer"));
m_GBuffer.BindForWriting();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GetGame()->GetSceneManager()->Draw(false);
m_GBuffer.Unbind();
// Light Pass
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
RenderPostEffects();
}
// Skybox
//RenderSkybox();
// Present the frame
glfwSwapBuffers();
}
Shader* ShaderManager::GetShader(const string& aVertexShader, const string& aFragmentShader)
{
if(aVertexShader == aFragmentShader)
{
GetShader(aVertexShader);
}
return GetShader(string(aVertexShader + aFragmentShader));
}
void GraphicsEngine::FinalPass(Texture * texture)
{
FBO::Unbind();
GetShader("FBO")->Use();
GetShader("FBO")->SetUniform1f("overlay", Engine.GetTransition());
texture->Bind();
FBO::Render();
GetShader("FBO")->SetUniform1f("overlay", 1);
}
GLSLProgram* ShaderManager::UseShader(const char* vertName, const char* fragName)
{
GLSLProgram* prog = GetShader(vertName, fragName);
assert(prog != NULL);
prog->use();
return prog;
}
void CShaderManager::Render( )
{
if( m_pD3DDevice == NULL || m_pObject == NULL )
return;
LPD3DXEFFECT fxShader = GetShader( m_pObject->m_hShader );
if( fxShader == NULL )
{
m_pObject->Render();
return;
}
UINT uiNumPasses = 0;
fxShader->Begin( &uiNumPasses, 0 );
for( UINT iPass = 0; iPass < uiNumPasses; ++iPass )
{
fxShader->BeginPass( iPass );
m_pObject->Render();
fxShader->EndPass();
}
fxShader->End();
}
GLSLProgram* ShaderManager::UseShader(const char* vertName, const char* fragName, std::string vertString, std::string fragString)
{
GLSLProgram* prog = GetShader(vertName, fragName,vertString, fragString);
assert(prog != NULL);
prog->use();
return prog;
}
CUIDragItem* CUICellItem::CreateDragItem()
{
CUIDragItem* tmp;
tmp = xr_new<CUIDragItem>(this);
Frect r;
GetAbsoluteRect(r);
if( m_UIStaticItem.GetFixedLTWhileHeading() )
{
float w, h;
w = r.width();
h = r.height();
if (Heading())
{ // исправление пропорций
w = w / m_cell_size.x * m_cell_size.y;
h = h / m_cell_size.y * m_cell_size.x;
}
Fvector2 cp = GetUICursor()->GetCursorPosition();
// поворот на 90 градусов, и центрирование по курсору мыша
r.x1 = (cp.x - h / 2.0f);
r.y1 = (cp.y - w / 2.0f);
r.x2 = r.x1 + h;
r.y2 = r.y1 + w;
}
tmp->Init(GetShader(),r,GetUIStaticItem().GetOriginalRect());
return tmp;
}
void CShaderManager::UnloadShader( HSHADER hShader )
{
LPD3DXEFFECT fxShader = GetShader( hShader );
if( fxShader == NULL ) return;
fxShader->Release();
m_vEffects[ hShader ] = NULL;
}
/// Populates this collection of assets with more specific types
/// of data as specified in the generic collection of assets.
/// @param[in] assets - The generic asset data to populate from.
/// @return True if all assets are successfully populated; false otherwise.
bool Assets::Populate(const std::vector<Asset>& assets)
{
for (const auto& asset : assets)
{
switch (asset.Type)
{
case RESOURCES::AssetType::FONT:
{
std::shared_ptr<GRAPHICS::GUI::Font> font = GetFont(asset.Id, asset.BinaryData);
if (!font)
{
return false;
}
break;
}
case RESOURCES::AssetType::MUSIC:
{
std::shared_ptr<sf::Music> music = GetMusic(asset.Id, asset.BinaryData);
if (!music)
{
return false;
}
break;
}
case RESOURCES::AssetType::SHADER:
{
std::shared_ptr<sf::Shader> shader = GetShader(asset.Id, asset.BinaryData);
if (!shader)
{
return false;
}
break;
}
case RESOURCES::AssetType::SOUND_EFFECT:
{
std::shared_ptr<sf::SoundBuffer> sound = GetSound(asset.Id, asset.BinaryData);
if (!sound)
{
return false;
}
break;
}
case RESOURCES::AssetType::TEXTURE:
{
std::shared_ptr<GRAPHICS::Texture> texture = GetTexture(asset.Id, asset.BinaryData);
if (!texture)
{
return false;
}
break;
}
}
}
return true;
}
void VisualRaymarchComponent::DrawWithShadows(D3D& d3d)
{
SetShader(G_ShaderManager().GetShader("Raymarch"));
// CAMERA BUFFER
ConstantBuffers::RayMarchCameraBuffer cameraBuffer;
cameraBuffer.eyePos = GetParent().GetParent().GetActiveCamera()->GetParent().GetPos();
cameraBuffer.nearPlane = 1.0f;
cameraBuffer.farPlane = 1000.0f;
glm::mat4 inverse = GetParent().GetParent().GetActiveCamera()->GetViewMatrix();
cameraBuffer.viewInverse =/* glm::transpose( */
inverse ;
cameraBuffer.viewportH = d3d.GetScreenHeight();
cameraBuffer.viewportW = d3d.GetScreenWidth();
cameraBuffer.raymarchId = m_raymarchId;
GetShader().PSSetConstBufferData(d3d, std::string("RaymarchCameraBuffer"), (void*)&cameraBuffer,
sizeof(cameraBuffer), 0);
// LIGHT BUFFER
const std::vector<Component*>& lights = GetParent().GetParent().GetLights();
LightComponent* light = static_cast<LightComponent*>(lights[0]);
ConstantBuffers::RayMarchLightBuffer lightBuffer;
lightBuffer.lightColor = light->GetDiffuse();
lightBuffer.lightPosition = light->GetParent().GetPos();
GetShader().PSSetConstBufferData(d3d, std::string("RaymarchLightBuffer"), (void*)&lightBuffer,
sizeof(lightBuffer), 1);
// BACKGROUND BUFFER
ConstantBuffers::RayMarchBackgroundColorBuffer backgroundBuffer;
backgroundBuffer.backgroundColor = glm::vec4(0.1f, 0.1f, 0.1f, 1.0f);
GetShader().PSSetConstBufferData(d3d, std::string("RaymarchBackgroundColorBuffer"),
(void*)&backgroundBuffer, sizeof(backgroundBuffer), 2);
// Render with shader.
GetShader().RenderShader(d3d, m_mesh.GetIndexCount());
}
ReferenceTarget* mrShaderButtonHandler::GetInstance(HWND hwnd, POINT p, SClass_ID type) {
if(type == TEXMAP_CLASS_ID) {
Texmap* shader = GetShader();
return shader;
}
else {
return NULL;
}
}
//! ѕерезагружает все шейдеры
//!
bool CRendererD3D::ReloadShaders()
{
g_pResManager->RegCreator( NEW CShaderCreator );
TResource * pShaderConfig = NULL;
g_pResManager->Request( "Shaders.xml", &pShaderConfig );
m_ppShaders[ UI_SHADER ] = GetShader( "UI" );
return true;
}
Texture * GraphicsEngine::Combine(Texture * input1, Texture * input2)
{
GetFBO(BLUR)->BindForWriting();
GetFBO(BLUR)->SetDrawBuffer(2);
GetShader("Combine")->Use();
input1->Bind();
input2->Bind(1);
FBO::Render();
return GetFBO(BLUR)->GetActiveTexture();
}
static osg::Shader* AddShader( const shaders::shader_t& t, std::string mat_name, const uint16_t version, const std::string comp_str, const std::string& preprocessorDefinitions )
{
auto shader_text = GetShader(t,mat_name);
if(shader_text)
{
std::string prog = "#version " + boost::lexical_cast<string>(version) + comp_str + "\n "
+ preprocessorDefinitions + "\n "
+ osg_modification(version,Utils::format(*shader_text));
return new osg::Shader( static_cast<osg::Shader::Type>(t), prog );
}
return new osg::Shader();
}
bool
CSphere::Intersect(const CRay& clRay, RealType t0, RealType t1, TTracingContext& tContext ) const
{
/*
Implement ray-sphere intersection.
You must set the following member of the TTracingContext struct:
t - ray parameter of intersection point
v3Normal - Normal of surface at intersection point
v3HitPoint - Coordinate of intersection point
v2TexCoord - 2D-Texture coordinate of intersection point (use polar coordinates (method Cartesian2Polar), not needed currently)
pclShader - Material of sphere
*/
VectorType3 vecDiff(m_v3Center - clRay.GetOrigin());
RealType t_ca = vecDiff | clRay.GetDir();
if (t_ca < 0)
return false;
RealType d2 = (vecDiff | vecDiff) - t_ca * t_ca;
RealType r2 = m_rRadius * m_rRadius ;
if (d2 > r2) {
return false;
}
RealType desc = sqrt(r2 - d2);
RealType t = (t_ca - desc) ;
if (t < 0.0) {
t = (t_ca + desc);
}
if (t > tContext.t) {
return false;
}
tContext.t = t;
tContext.v3HitPoint = clRay.Evaluate(tContext.t);
tContext.v3Normal = (tContext.v3HitPoint - m_v3Center).normalize();
tContext.pclShader = GetShader();
return true;
}
HRESULT GLSkyNode::VPreRender(Scene* pScene)
{
//the position should always be 0, so offset by the opposit of the camera position
//doing this in the prerender stage make sure the position is correct BEFORE applying the transforms
this->SetPosition(pScene->GetCamera()->GetPosition());
pScene->PushAndSetMatrix(this->GetToWorld());
GLUFProgramPtr prog = static_pointer_cast<GLProgramResourceExtraData>(GetShader()->GetExtra())->GetProgram();
//if (m_pShader)
//{
//this is always safe to do
GLUFSHADERMANAGER.UseProgram(prog);
//}
//apply the uniforms
glm::mat4 model = pScene->GetTopMatrix() * glm::scale(glm::mat4(), glm::vec3(40, 40, 40));
glm::mat4 view = pScene->GetCamera()->GetView();
glm::mat4 proj = pScene->GetCamera()->GetProjection();
glm::mat4 model_view_proj = proj * view * model;
GLUFVariableLocMap uniformLocations = GLUFSHADERMANAGER.GetShaderUniformLocations(prog);
GLUFVariableLocMap::iterator it = uniformLocations.find("_mvp");
if (it != uniformLocations.end())
glUniformMatrix4fv(it->second, 1, GL_FALSE, &model_view_proj[0][0]);
shared_ptr<GLTextureResourceExtraData> cubMap = static_pointer_cast<GLTextureResourceExtraData>(m_Cubemap->GetExtra());
it = uniformLocations.find("m_tex0");
if (it != uniformLocations.end())//make sure the there is a sampler, and we have a texture
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, cubMap->GetTexture());
glUniform1i(it->second, 0);
}
// disable depth test
//glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_CULL_FACE);
return S_OK;
}
void GradientParticleEmitter::UpdateShader(const GameTime &gameTime)
{
glEnable(GL_TEXTURE_2D);
Shader *shader = (Shader*)GetShader();
Texture &shaderAlphaMap = (Texture&)GetAlphaMap();
glActiveTexture(shaderAlphaMap.GetTextureSlot());
shaderAlphaMap.Activate();
glActiveTexture(gradientMap.GetTextureSlot());
gradientMap.Activate();
shader->SetUniform("AlphaMap", 0);
shader->SetUniform("GradientMap", 1);
shader->SetUniform("Time", gameTime.GetRunningTime());
};
void cShaderManager::CreateProgramWithFile( const std::string ShaderName )
{
std::fstream File;
File.open( ShaderName, std::ios::in );
if( !File.is_open() )
{
std::cerr << "ERROR: Blad wczytywania shaderow z pliku: " << ShaderName << std::endl;
return;
}
std::string buffor;
std::string name;
std::vector< std::string > Shaders;
//std::vector< std::string > Fragment;
while( !File.eof() )
{
File >> buffor;
switch (buffor[0])
{
case 'v':
File >> buffor;
name = GetName( buffor );
Shaders.push_back( name );
CreateShader( name, SHADERTYPE::VertexShader, buffor );
break;
case 'f':
File >> buffor;
name = GetName( buffor );
Shaders.push_back( name );
CreateShader( name, SHADERTYPE::FragmentShader, buffor );
break;
default:
break;
}
}
File.close();
std::string ProgramName = GetName( ShaderName );
CreateProgram( ProgramName );
cProgramShader* Program = GetProgram( ProgramName );
for( unsigned i = 0; i < Shaders.size(); i++ )
{
Program->AttachShader( GetShader( Shaders[i] ) );
}
Program->Link();
}
void GraphicsEngine::ForwardPass(bool pass)
{
switch (pass)
{
case 0:
{
gBuffer->StartForwardPass();
GetShader("Forward")->Use();
break;
}
case 1:
{
glDisable(GL_DEPTH_TEST);
break;
}
}
}
/// Loads assets in the specified asset package into this collection.
/// @param[in] asset_package - The package of assets to load.
/// @return True if all assets in the package are loaded successfully; false otherwise.
bool Assets::Load(const AssetPackageDefinition& asset_package)
{
// PROTECT AGAINST THIS CLASS BEING USED BY MULTIPLE THREADS.
std::lock_guard<std::recursive_mutex> lock(AssetMutex);
// LOAD EACH ASSET IN THE PACKAGE.
for (const AssetDefinition& asset_definition : asset_package.Assets)
{
// LOAD THE ASSET BASED ON IT'S TYPE.
bool asset_loaded = false;
switch (asset_definition.Type)
{
case AssetType::FONT:
// LOAD THE FONT.
asset_loaded = static_cast<bool>(GetFont(asset_definition.Id));
break;
case AssetType::MUSIC:
// LOAD THE MUSIC.
asset_loaded = static_cast<bool>(GetMusic(asset_definition.Id));
break;
case AssetType::SHADER:
// LOAD THE SHADER.
asset_loaded = static_cast<bool>(GetShader(asset_definition.Id));
break;
default:
// The asset can be loaded if it's type isn't known.
asset_loaded = false;
}
// ABORT IF THE ASSET FAILED TO BE LOADED.
if (!asset_loaded)
{
return false;
}
}
// INDICATE THAT ALL ASSETS WERE LOADED SUCCESSFULLY.
return true;
}
void mrShaderButtonHandler::Update() {
DbgAssert(m_dialogHWnd != NULL);
HWND ctrlHWnd = GetDlgItem(m_dialogHWnd, m_ctrlID);
ICustButton* custButton = GetICustButton(ctrlHWnd);
if(custButton != NULL) {
MSTR text;
Texmap* shader = GetShader();
if(shader != NULL)
text = shader->GetFullName();
else
text = GetNoneString();
custButton->SetText(text.data());
ReleaseICustButton(custButton);
}
else {
DbgAssert(false);
}
}
CUIDragItem* CUICellItem::CreateDragItem()
{
CUIDragItem* tmp;
tmp = xr_new<CUIDragItem>(this);
Frect r;
GetAbsoluteRect(r);
if( m_UIStaticItem.GetFixedLTWhileHeading() )
{
float t1,t2;
t1 = r.width();
t2 = r.height()*UI().get_current_kx();
Fvector2 cp = GetUICursor().GetCursorPosition();
r.x1 = (cp.x-t2/2.0f);
r.y1 = (cp.y-t1/2.0f);
r.x2 = r.x1 + t2;
r.y2 = r.y1 + t1;
}
tmp->Init(GetShader(), r, GetUIStaticItem().GetTextureRect());
return tmp;
}
void plParticleMtl::ShadeWithBackground(ShadeContext &sc, Color background)
{
#if 1
TimeValue t = sc.CurTime();
Color color(0, 0, 0);
float alpha = 0.0;
// Evaluate Base layer
Texmap *map = fBasicPB->GetTexmap(kTexmap);
if (map && map->ClassID() == LAYER_TEX_CLASS_ID)
{
plLayerTex *layer = (plLayerTex*)map;
AColor evalColor = layer->EvalColor(sc);
color = evalColor;
alpha = evalColor.a;
}
#if 1
AColor black;
black.Black();
AColor white;
white.White();
SIllumParams ip;
if( fBasicPB->GetInt( kNormal ) == kEmissive )
{
// Emissive objects don't get shaded
ip.diffIllum = fBasicPB->GetColor(kColorAmb, t) * color;
ip.diffIllum.ClampMinMax();
ip.specIllum = black;
}
else
{
//
// Shading setup
//
// Setup the parameters for the shader
ip.amb = black;
ip.diff = fBasicPB->GetColor(kColor, t) * color;
ip.spec = white;
ip.diffIllum = black;
ip.specIllum = black;
ip.N = sc.Normal();
ip.V = sc.V();
//
// Specularity
//
ip.sh_str = 0;
ip.ph_exp = 0;
ip.shine = 0;
ip.softThresh = 0;
// Do the shading
Shader *myShader = GetShader(SHADER_BLINN);
myShader->Illum(sc, ip);
ip.diffIllum.ClampMinMax();
ip.specIllum.ClampMinMax();
ip.diffIllum = ip.amb * sc.ambientLight + ip.diff * ip.diffIllum;
}
// AColor returnColor = AColor(opac * ip.diffIllum + ip.specIllum, opac)
#endif
// Get opacity and combine with alpha
float opac = float(fBasicPB->GetInt(kOpacity, t)) / 100.0f;
//float opac = 1.0f;
alpha *= opac;
// MAX will do the additive/alpha/no blending for us based on what Requirements()
// we tell it. However, since MAX's formula is bgnd*sc.out.t + sc.out.c,
// we have to multiply our output color by the alpha.
// If we ever need a more complicated blending function, you can request the
// background color via Requirements() (otherwise it's just black) and then do
// the blending yourself; however, if the transparency isn't set, the shadows
// will be opaque, so be careful.
Color outC = ip.diffIllum + ip.specIllum;
sc.out.c = ( outC * alpha );
sc.out.t = Color( 1.f - alpha, 1.f - alpha, 1.f - alpha );
#endif
}
void plPassMtl::ShadeWithBackground(ShadeContext &sc, Color background, bool useVtxAlpha /* = true */)
{
#if 1
// old
#if 0
Color lightCol,rescol, diffIllum0;
RGBA mval;
Point3 N0,P;
BOOL bumped = FALSE;
int i;
if (gbufID)
sc.SetGBufferID(gbufID);
if (sc.mode == SCMODE_SHADOW) {
float opac = 0.0;
for (i=0; i < NumSubTexmaps(); i++) {
if (SubTexmapOn(i)) {
hsMaxLayerBase *hsmLay = (hsMaxLayerBase *)GetSubTexmap(i);
opac += hsmLay->GetOpacity(t);
}
}
float f = 1.0f - opac;
sc.out.t = Color(f,f,f);
return;
}
N0 = sc.Normal();
P = sc.P();
#endif
TimeValue t = sc.CurTime();
Color color(0, 0, 0);
float alpha = 0.0;
// Evaluate Base layer
Texmap *map = fLayersPB->GetTexmap(kPassLayBase);
if (map && ( map->ClassID() == LAYER_TEX_CLASS_ID
|| map->ClassID() == STATIC_ENV_LAYER_CLASS_ID ) )
{
plLayerTex *layer = (plLayerTex*)map;
AColor evalColor = layer->EvalColor(sc);
color = evalColor;
alpha = evalColor.a;
}
// Evaluate Top layer, if it's on
if (fLayersPB->GetInt(kPassLayTopOn))
{
Texmap *map = fLayersPB->GetTexmap(kPassLayTop);
if (map && ( map->ClassID() == LAYER_TEX_CLASS_ID
|| map->ClassID() == STATIC_ENV_LAYER_CLASS_ID
|| map->ClassID() == ANGLE_ATTEN_LAYER_CLASS_ID) )
{
plPlasmaMAXLayer *layer = (plPlasmaMAXLayer*)map;
AColor evalColor = layer->EvalColor(sc);
// Blend layers
if( !layer->DiscardColor() )
{
int blendType = fLayersPB->GetInt(kPassLayBlend);
switch (blendType)
{
case kBlendAdd:
color += evalColor * evalColor.a;
break;
case kBlendAlpha:
color = (1.0f - evalColor.a) * color + evalColor.a * evalColor;
break;
case kBlendMult:
color *= evalColor;
break;
default: // No blend...
color = evalColor;
break;
}
}
if( !layer->DiscardAlpha() )
{
int alphaType = fLayersPB->GetInt(kPassLayOutputBlend);
switch( alphaType )
{
case kAlphaMultiply:
alpha *= evalColor.a;
break;
case kAlphaAdd:
alpha += evalColor.a;
break;
case kAlphaDiscard:
default:
break;
}
}
}
}
#if 1
AColor black;
black.Black();
AColor white;
white.White();
SIllumParams ip;
if (fBasicPB->GetInt(kPassBasEmissive))
{
// Emissive objects don't get shaded
ip.diffIllum = fBasicPB->GetColor(kPassBasColorAmb, t) * color;
ip.diffIllum.ClampMinMax();
ip.specIllum = black;
}
else
{
//
// Shading setup
//
// Setup the parameters for the shader
ip.amb = fBasicPB->GetColor(kPassBasColorAmb, t);
ip.diff = fBasicPB->GetColor(kPassBasColor, t) * color;
ip.diffIllum = black;
ip.specIllum = black;
ip.N = sc.Normal();
ip.V = sc.V();
//
// Specularity
//
if (fBasicPB->GetInt(kPassBasUseSpec, t))
{
ip.sh_str = 1.f;
ip.spec = fBasicPB->GetColor( kPassBasSpecColor, t );
ip.ph_exp = (float)pow(2.0f,float(fBasicPB->GetInt(kPassBasShine, t)) / 10.0f);
ip.shine = float(fBasicPB->GetInt(kPassBasShine, t)) / 100.0f;
}
else
{
ip.spec = black;
ip.sh_str = 0;
ip.ph_exp = 0;
ip.shine = 0;
}
ip.softThresh = 0;
//
// Do the shading
Shader *myShader = GetShader(SHADER_BLINN);
myShader->Illum(sc, ip);
// Override shader parameters
if (fAdvPB->GetInt(kPBAdvNoShade))
{
ip.diffIllum = black;
ip.specIllum = black;
}
if (fAdvPB->GetInt(kPBAdvWhite))
{
ip.diffIllum = white;
ip.specIllum = black;
}
ip.specIllum.ClampMinMax();
ip.diffIllum = ip.amb * sc.ambientLight + ip.diff * ip.diffIllum;
ip.diffIllum.ClampMinMax();
}
// AColor returnColor = AColor(opac * ip.diffIllum + ip.specIllum, opac)
#endif
// Get opacity and combine with alpha
float opac = float(fBasicPB->GetInt(kPassBasOpacity, t)) / 100.0f;
alpha *= opac;
float vtxAlpha = 1.0f;
if (useVtxAlpha && GetOutputBlend() == plPassMtlBase::kBlendAlpha)
{
Point3 p;
GetInterpVtxValue(MAP_ALPHA, sc, p);
vtxAlpha = p.x;
}
alpha *= vtxAlpha;
// MAX will do the additive/alpha/no blending for us based on what Requirements()
// we tell it. However, since MAX's formula is bgnd*sc.out.t + sc.out.c,
// we have to multiply our output color by the alpha.
// If we ever need a more complicated blending function, you can request the
// background color via Requirements() (otherwise it's just black) and then do
// the blending yourself; however, if the transparency isn't set, the shadows
// will be opaque, so be careful.
Color outC = ip.diffIllum + ip.specIllum;
sc.out.c = ( outC * alpha );
sc.out.t = Color( 1.f - alpha, 1.f - alpha, 1.f - alpha );
#endif
}
MaterialID TitleScreen::GetMaterial()
{
TextureParameter textureParameter(GetTexture());
MaterialParameters materialParameters;
materialParameters.diffuseMapParam = textureParameter;
static MaterialID titleScreenMaterialID = SceneManager::GetInstance().GetMaterialManager()->CreateMaterial(materialParameters,GetShader());
return titleScreenMaterialID;
}
void mitk::ShaderRepository::ApplyProperties(mitk::DataNode* node, vtkActor *actor, mitk::BaseRenderer* renderer,itk::TimeStamp &MTime)
{
bool setMTime = false;
vtkProperty* property = actor->GetProperty();
unsigned long ts = MTime.GetMTime();
mitk::ShaderProperty *sep=(mitk::ShaderProperty *)node->GetProperty("shader",renderer);
if(!sep)
{
property->ShadingOff();
return;
}
std::string shader=sep->GetValueAsString();
// Need update pipeline mode
if(sep->GetMTime() > ts)
{
if(shader.compare("fixed")==0)
{
//MITK_INFO << "disabling shader";
property->ShadingOff();
}
else
{
Shader *s=GetShader(shader.c_str());
if(s)
{
//MITK_INFO << "enabling shader";
property->ShadingOn();
property->LoadMaterial(s->path.c_str());
}
}
setMTime = true;
}
if(shader.compare("fixed")!=0)
{
Shader *s=GetShader(shader.c_str());
if(!s)
return;
std::list<Shader::Uniform::Pointer>::const_iterator j = s->uniforms.begin();
while( j != s->uniforms.end() )
{
std::string propertyName = "shader." + s->name + "." + (*j)->name;
// MITK_INFO << "querying property: " << propertyName;
// mitk::BaseProperty *p = node->GetProperty( propertyName.c_str(), renderer );
// if( p && p->GetMTime() > MTime.GetMTime() )
{
float fval[4];
// MITK_INFO << "copying property " << propertyName << " ->->- " << (*j)->name << " type=" << (*j)->type ;
switch( (*j)->type )
{
case Shader::Uniform::glsl_float:
node->GetFloatProperty( propertyName.c_str(), fval[0], renderer );
property->AddShaderVariable( (*j)->name.c_str(), 1 , fval );
break;
case Shader::Uniform::glsl_vec2:
node->GetFloatProperty( (propertyName+".x").c_str(), fval[0], renderer );
node->GetFloatProperty( (propertyName+".y").c_str(), fval[1], renderer );
property->AddShaderVariable( (*j)->name.c_str(), 2 , fval );
break;
case Shader::Uniform::glsl_vec3:
node->GetFloatProperty( (propertyName+".x").c_str(), fval[0], renderer );
node->GetFloatProperty( (propertyName+".y").c_str(), fval[1], renderer );
node->GetFloatProperty( (propertyName+".z").c_str(), fval[2], renderer );
property->AddShaderVariable( (*j)->name.c_str(), 3 , fval );
break;
case Shader::Uniform::glsl_vec4:
node->GetFloatProperty( (propertyName+".x").c_str(), fval[0], renderer );
node->GetFloatProperty( (propertyName+".y").c_str(), fval[1], renderer );
node->GetFloatProperty( (propertyName+".z").c_str(), fval[2], renderer );
node->GetFloatProperty( (propertyName+".w").c_str(), fval[3], renderer );
property->AddShaderVariable( (*j)->name.c_str(), 4 , fval );
break;
default:
break;
}
//setMTime=true;
}
j++;
}
}
if(setMTime)
MTime.Modified();
}
bool c_shader_instance::UsesGBuffer()
{
if(!GetShader() || !GetShader()->GetShaderDefinition<TagGroups::s_shader_postprocess_definition>())
return false;
return GetShader()->GetShaderDefinition<TagGroups::s_shader_postprocess_definition>()->runtime.flags.uses_gbuffer_bit;
}
void Material::ActivateForDraw()
{
GetShader()->Activate();
ActivateTextures();
}
