static bool AddTechnique(JSON &json, CGtechnique technique, UniformsMap &uniformRemapping)
{
bool success = true;
const char * const techniqueName = cgGetTechniqueName(technique);
if (sVerbose)
{
puts(techniqueName);
}
json.AddArray(techniqueName);
CGpass pass = cgGetFirstPass(technique);
if (NULL == pass)
{
success = false;
}
while (NULL != pass)
{
success &= AddPass(technique, json, pass, uniformRemapping);
pass = cgGetNextPass(pass);
}
json.CloseArray(); // techniqueName
return success;
}
void DoF::Setup() {
// calc gaussian values (with variance=1) in the interval [-4;4];
calcBlurWeightArray();
vector<vector<float> > weights;
for (int i=0; i<NUM_SAMPLES; i++) {
vector<float> weight;
weight.push_back(blurweights[i]);
weights.push_back(weight);
}
// blur
pass1 = AddPass("Effects/GaussianBlur_Pass1.frag");
pass1->BindColorBuffer("colorbuf");
pass1->BindFloat("weights", weights);
pass1->AttachUserBuffer(0);
pass2 = AddPass("Effects/GaussianBlur_Pass2.frag");
pass2->BindUserBuffer("colorbuf", pass1, 0);
pass2->BindFloat("weights", weights);
pass2->AttachUserBuffer(0);
/*
pass1 = AddPass("TwoPassBlur_Pass1.frag");
pass1->BindColorBuffer("colorbuf");
pass1->AttachUserBuffer(0);
pass2 = AddPass("TwoPassBlur_Pass2.frag");
pass2->BindUserBuffer("colorbuf", pass1, 0);
pass2->AttachUserBuffer(0);
*/
// dof
IPostProcessingPass* pass3 = AddPass("Effects/DoF.frag");
pass3->BindFloat("znear", znear);
pass3->BindFloat("zfar", zfar);
pass3->BindFloat("zsharp", zsharp);
pass3->BindUserBuffer ("blurred", pass2, 0);
pass3->BindColorBuffer("unblurred");
pass3->BindDepthBuffer("depthbuf");
pass3->EnableColorBufferOutput();
}
void CBspMapResourceProvider::LoadTextures(const CBspFile& bspFile, CPakFile& pakFile)
{
const Bsp::TextureArray& textures(bspFile.GetTextures());
m_materials.resize(textures.size());
for(uint32 i = 0; i < textures.size(); i++)
{
const Bsp::TEXTURE& texture(textures[i]);
auto resultMaterial = BspMapMaterialPtr(new CBspMapMaterial());
m_materials[i] = resultMaterial;
ShaderMap::const_iterator shaderIterator = m_shaders.find(texture.name);
if(shaderIterator == m_shaders.end())
{
//Create a basic material with this texture
std::string fullName;
if(!pakFile.TryCompleteFileName(texture.name, fullName))
{
continue;
}
LoadTexture(fullName.c_str(), pakFile);
{
auto pass = BspMapPassPtr(new CBspMapPass());
pass->SetTexture(GetTexture(fullName.c_str()));
pass->SetTextureSource(CBspMapPass::TEXTURE_SOURCE_DIFFUSE);
pass->SetBlendingFunction(Palleon::TEXTURE_COMBINE_MODULATE);
resultMaterial->AddPass(pass);
}
{
auto pass = BspMapPassPtr(new CBspMapPass());
pass->SetTextureSource(CBspMapPass::TEXTURE_SOURCE_LIGHTMAP);
pass->SetBlendingFunction(Palleon::TEXTURE_COMBINE_MODULATE);
resultMaterial->AddPass(pass);
}
}
else
{
const QUAKE_SHADER& shader = shaderIterator->second;
resultMaterial->SetIsSky(shader.isSky);
for(QuakeShaderPassArray::const_iterator passIterator(shader.passes.begin());
passIterator != shader.passes.end(); passIterator++)
{
const QUAKE_SHADER_PASS& passData(*passIterator);
if(passData.mapName.length() < 4) continue;
auto pass = BspMapPassPtr(new CBspMapPass());
{
Palleon::TEXTURE_COMBINE_MODE blendingFunction = Palleon::TEXTURE_COMBINE_MODULATE;
switch(passData.blendFunc)
{
case QUAKE_SHADER_BLEND_BLEND:
blendingFunction = Palleon::TEXTURE_COMBINE_LERP;
break;
case QUAKE_SHADER_BLEND_ADD:
blendingFunction = Palleon::TEXTURE_COMBINE_ADD;
break;
case QUAKE_SHADER_BLEND_FILTER:
blendingFunction = Palleon::TEXTURE_COMBINE_MODULATE;
break;
}
pass->SetBlendingFunction(blendingFunction);
}
if(passData.mapName == "$lightmap")
{
pass->SetTextureSource(CBspMapPass::TEXTURE_SOURCE_LIGHTMAP);
}
else
{
std::string fileName(passData.mapName.begin(), passData.mapName.begin() + passData.mapName.length() - 4);
std::string fullName;
if(!pakFile.TryCompleteFileName(fileName.c_str(), fullName))
{
continue;
}
LoadTexture(fullName.c_str(), pakFile);
pass->SetTexture(GetTexture(fullName.c_str()));
pass->SetTextureSource(CBspMapPass::TEXTURE_SOURCE_DIFFUSE);
}
for(unsigned int i = 0; i < passData.tcMods.size(); i++)
{
const QUAKE_SHADER_TCMOD& tcMod(passData.tcMods[i]);
BspMapTcModPtr result;
switch(tcMod.type)
{
case QUAKE_SHADER_TCMOD_SCROLL:
result = BspMapTcModPtr(new CBspMapTcMod_Scroll(
tcMod.params[0],
tcMod.params[1]));
break;
case QUAKE_SHADER_TCMOD_SCALE:
result = BspMapTcModPtr(new CBspMapTcMod_Scale(
tcMod.params[0],
tcMod.params[1]));
break;
case QUAKE_SHADER_TCMOD_ROTATE:
result = BspMapTcModPtr(new CBspMapTcMod_Rotate(
tcMod.params[0]));
break;
case QUAKE_SHADER_TCMOD_TURB:
result = BspMapTcModPtr(new CBspMapTcMod_Turb(
tcMod.params[1],
tcMod.params[3]));
break;
case QUAKE_SHADER_TCMOD_STRETCH:
{
BSPMAPWAVEPARAMS wave;
wave.type = BSPMAPWAVEPARAMS::WAVE_SIN;
wave.base = tcMod.params[0];
wave.amplitude = tcMod.params[1];
wave.phase = tcMod.params[2];
wave.freq = tcMod.params[3];
result = BspMapTcModPtr(new CBspMapTcMod_Stretch(wave));
}
break;
default:
continue;
break;
}
pass->AddTcMod(result);
}
resultMaterial->AddPass(pass);
if(resultMaterial->GetPassCount() == CBspMapMaterial::MAX_PASS)
{
break;
}
}
}
}
}
void PassDriver::PopulatePasses() {
UnreachablePass* unreachable = new UnreachablePass();
AddPass(unreachable);
}
void SimpleBlur::Setup() {
pass1 = AddPass("Effects/SimpleBlur.frag");
pass1->BindFloat("offset", offset);
pass1->BindColorBuffer("colorbuf");
pass1->EnableColorBufferOutput();
}
