void Model::render(const RenderConf & _conf) const
{
if (!getShader())
return;
if (!Configurator::isDepthTestEnabled())
glEnable(GL_DEPTH_TEST);
Shader & shader = *getShader();
shader.use();
bool useCustomConf = _conf != RenderConf::Default;
const auto & lights = useCustomConf ? _conf.lights : getLights();
const auto & matrices = useCustomConf ? _conf.matrices : getMatrices();
shader.setMat4f("mvp", matrices.mvp)
.setMat4f("model", matrices.transform)
.setMat4f("inverseModel", matrices.inverseTransform)
.setVec3("cameraPos", matrices.cameraPosition)
.setFloat("material.shininess", 5.f)
.setLights("light", lights.cbegin(), lights.cend())
.setBoolean("useColorOnly", m_useColorOnly)
.setColor("singleColor", m_color);
renderMeshes();
Shader::unuse();
if (!Configurator::isDepthTestEnabled())
glDisable(GL_DEPTH_TEST);
}
void SSAOPass::configBlurQuadStateSet(osg::Group *g, char dir, osg::TextureRectangle *outSSAOTex)
{
osg::ref_ptr<osg::StateSet> ss = g->getOrCreateStateSet();
if(dir == 'y')
{
ss->setAttributeAndModes(getShader(_blurY_shader), osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE);
}
else if(dir == 'x')
{
ss->setAttributeAndModes(getShader(_blurX_shader), osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE);
}
else
{
fprintf(stderr, "Shadow Group, blur dir err\n");
exit(0);
}
ss->addUniform(new osg::Uniform("u_ssaoTex", 0));
ss->setTextureAttribute(0, outSSAOTex);
ss->addUniform(new osg::Uniform("u_depthTex", 1));
ss->setTextureAttribute(1, _sharedDepthTex);
ss->addUniform(new osg::Uniform("u_inv_screenSize", osg::Vec2(1.0 / _screenWidth, 1.0 / _screenHeight)));
float s = 128.0f, e = 131070.0f, fs = 1.0f / s, fe = 1.0f / e, fd = fs - fe;
ss->addUniform(new osg::Uniform("fs", fs));
ss->addUniform(new osg::Uniform("fd", fd));
}
void DCTextBox::e_draw()
{
::X39::Singletons::MATERIAL* mat = ::X39::Singletons::MaterialManager::getInstance().getMaterialByIndex(1);
int textureIndex = 1;
getShader().use();
if(width < 16 || height < 16)
{
drawTexture2D(mat, textureIndex, 0, 0, mat->textures[0]->width, mat->textures[0]->height, posX, posY, width, height, getShader());
}
else
{
//TopLeft corner
drawTexture2D(mat, textureIndex, 0, 0, 16, 16, posX, posY, 16, 16, getShader());
if(height > 32)
{
//Left Side
drawTexture2D(mat, textureIndex, 0, 16, 16, 16, posX, posY + 16, 16, height - 32, getShader());
}
//BottomLeft corner
drawTexture2D(mat, textureIndex, 0, 64 - 16, 16, 16, posX, posY + height - 16, 16, 16, getShader());
//TopRight corner
drawTexture2D(mat, textureIndex, 64 - 16, 0, 16, 16, posX + width - 16, posY, 16, 16, getShader());
if(height > 32)
{
//Right Side
drawTexture2D(mat, textureIndex, 64 - 16, 16, 16, 16, posX + width - 16, posY + 16, 16, height - 32, getShader());
}
//BottomRight corner
drawTexture2D(mat, textureIndex, 64 - 16, 64 - 16, 16, 16, posX + width - 16, posY + height - 16, 16, 16, getShader());
if(width > 32)
{
//Top side
drawTexture2D(mat, textureIndex, 16, 0, 16, 16, posX + 16, posY, width - 32, 16, getShader());
if(height > 32)
{
//Middle side
drawTexture2D(mat, textureIndex, 16, 16, 16, 16, posX + 16, posY + 16, width - 32, height - 32, getShader());
}
//Bottom side
drawTexture2D(mat, textureIndex, 16, 64 - 16, 16, 16, posX + 16, posY + height - 16, width - 32, 16, getShader());
}
}
getShader().unuse();
if(!innerText.empty())
drawTextLine2D(::X39::Singletons::FontManager::getInstance().getFont(0), innerText.c_str(), height / FONTSIZEBASE, posX, posY, width);
if(deleteButtonPressed)
{
deleteButtonPressedTimeout++;
if(deleteButtonPressedTimeout > 22)
{
deleteButtonPressedTimeout = 20;
if(innerText.size() > 0)
innerText.pop_back();
}
}
}
void Shader::reload() {
this->m_shader.setupShaderFromSource(GL_VERTEX_SHADER, getShader(GL_VERTEX_SHADER));
this->m_shader.setupShaderFromSource(GL_FRAGMENT_SHADER, getShader(GL_FRAGMENT_SHADER));
if(ofIsGLProgrammableRenderer()) {
this->m_shader.bindDefaults();
}
this->m_shader.linkProgram();
}
void Material::update()
{
getShader()->use();
getShader()->setUniform("color", diffuseColor);
// ToDo: set specularColor
// ToDo: set shininess
}
osg::ref_ptr<osg::Program> OSGShaderFactory::createShaderProgram( const std::string& vertexProgram, const std::string& fragmentProgram )
{
osg::ref_ptr<osg::Program> program = new osg::Program;
osg::ref_ptr<osg::Shader> vertexShader = getShader( vertexProgram, osg::Shader::VERTEX );
osg::ref_ptr<osg::Shader> fragmentShader = getShader( fragmentProgram, osg::Shader::FRAGMENT );
program->addShader( vertexShader );
program->addShader( fragmentShader );
return program;
}
void Rectangle::draw()
{
getShader()->beginShader();
if (getShader()->drawShaded()) {
getShader()->beginShading();
beginList();
if(!isCached())
{
glRectf(x, y, width, height);
}
endList();
getShader()->endShading();
}
if (getShader()->drawOutline()) {
getShader()->beginOutline();
beginList();
if(!isCached())
{
glRectf(x, y, width, height);
}
endList();
getShader()->endOutline();
}
getShader()->endShader();
}
/*
* Shall return a shader where offsets of members in
* lightsource uniform buffer and shadowmap matrix uniform buffer can be queried,
* if the global shader features indicate their possible usage;
*
* note: an instance transform uniform block is not necessary, as every instance manager
* has its "own" shader to query from; only the other two uniform blocks have a "global" character
*/
Shader* ShaderManager::getUniformBufferOffsetQueryShader(bool forShadowMapGeneration)
{
//shaderfeatures to request from the shadermanager a minimalistic shader containing the
//uniform buffer declaration, so that offsets can be queried
// static ShaderFeaturesLocal sfl =
// ShaderFeaturesLocal(
// RENDERING_TECHNIQUE_DEFAULT_LIGHTING, //lighting, for the creation of the lightsource uniform block
// TEXTURE_TYPE_2D_RECT, //play no role, dummy..
// VISUAL_MATERIAL_TYPE_DEFAULT_LIGHTING, //lighting, for the creation of the lightsource uniform block
// ShadingFeatures(
// SHADING_FEATURE_DIRECT_LIGHTING //lighting, for the creation of the lightsource uniform block
// //TODO add shadowing when the rest is stable
// ),
// false //no global instance buffer query needed
// );
if(forShadowMapGeneration)
{
//shadow map generation,layout(shared) uniform ShadowCameraTransformBuffer block
//note the ShadowCameraTransformBuffer is used twice:
// - for generation of shadowmaps in a geometry shader
// - for shadowmap lookup in a fragment shader
//though the same buffer object is used, the logical uniform block in the shaders is different;
//to omit bugs as far as possible, two meta infos for the same buffer will be maintained
//queried;
return getShader(
ShaderFeaturesLocal(
RENDERING_TECHNIQUE_SHADOWMAP_GENERATION,
TEXTURE_TYPE_2D_RECT, //play no role, dummy..
VISUAL_MATERIAL_TYPE_NONE,
ShadingFeatures(SHADING_FEATURE_NONE),
false //no global instance buffer query needed
)
);
}
else
{
//lighting, for the creation of the "layout(shared) uniform LightSourceBuffer" block
return getShader(
ShaderFeaturesLocal(
RENDERING_TECHNIQUE_DEFAULT_LIGHTING,
TEXTURE_TYPE_2D_RECT, //play no role, dummy..
VISUAL_MATERIAL_TYPE_DEFAULT_LIGHTING,
ShadingFeatures(SHADING_FEATURE_DIRECT_LIGHTING),
false //no global instance buffer query needed
)
);
}
}
void GPUNullFilter::applyOnGPU(GLTexturePtr pSrcTex)
{
getShader()->activate();
m_pTextureParam->set(0);
draw(pSrcTex);
}
bool Render::rawFrame(CZScene &scene,CZNode *pRootNode, CZMat4 &projMat)
{
curShader = getShader(kDirectionalLightShading);
if (curShader == NULL)
{
LOG_ERROR("there's no shader designated\n");
return false;
}
curShader->begin();
// common uniforms
glUniform3f(curShader->getUniformLocation("ambientLight.intensities"),
scene.ambientLight.intensity.x,
scene.ambientLight.intensity.y,
scene.ambientLight.intensity.z);
glUniform3f(curShader->getUniformLocation("directionalLight.direction"),
scene.directionalLight.direction.x,scene.directionalLight.direction.y,scene.directionalLight.direction.z);
glUniform3f(curShader->getUniformLocation("eyePosition"),scene.eyePosition.x,scene.eyePosition.y,scene.eyePosition.z);
glUniform3f(curShader->getUniformLocation("directionalLight.intensities"),
scene.directionalLight.intensity.x,
scene.directionalLight.intensity.y,
scene.directionalLight.intensity.z);
CZCheckGLError();
draw(pRootNode, projMat);
CZCheckGLError();
curShader->end();
return true;
}
int ShaderManager::saveProgress(const char *shaderName, char *errorText, Editor *editor)
{
Shader *shader;
int retVal = getShader(shaderName, &shader, errorText);
if (retVal) return retVal;
SYSTEMTIME sysTime;
GetSystemTime(&sysTime);
char filename[SM_MAX_FILENAME_LENGTH+1];
sprintf_s(filename, SM_MAX_FILENAME_LENGTH, "%s%s.%d_%d_%d_%d_%d_%d",
SM_PROGRESS_DIRECTORY, shaderName, sysTime.wYear, sysTime.wMonth,
sysTime.wDay, sysTime.wHour, sysTime.wMinute, sysTime.wSecond);
FILE *fid;
if (fopen_s(&fid, filename, "wb"))
{
sprintf_s(errorText, MAX_ERROR_LENGTH,
"Could not write to '%s'", filename);
return -1;
}
fwrite(shader->getShaderText(), sizeof(char), strlen(shader->getShaderText()), fid);
fclose(fid);
// If there is an editor attached, set a snapshot
if (editor)
{
editor->setSnapshot(filename);
}
return 0;
}
void SSAOPass::configureStateSet()
{
osg::Matrix projMatrix = _mainCamera->getProjectionMatrix();
osg::Matrix inverseProjMat = osg::Matrix::inverse(projMatrix);
_stateSet->setAttributeAndModes(getShader(_ssao_shader_id), osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE);
_stateSet->addUniform(new osg::Uniform("u_occluderBias", _occulderBias));
_stateSet->addUniform(new osg::Uniform("u_samplingRadius", _samplingRadius));
_stateSet->addUniform(new osg::Uniform("u_attenuation", osg::Vec2(_constantAttenuation, _linearAttenuation)));
_stateSet->addUniform(new osg::Uniform("u_farDistance", _farPlaneDist));
_stateSet->addUniform(new osg::Uniform("u_inverseProjMatrix", inverseProjMat));
_stateSet->addUniform(new osg::Uniform("u_randomJitterTex", 0));
_stateSet->addUniform(new osg::Uniform("u_normalAndDepthTex", 1));
_stateSet->addUniform(new osg::Uniform("u_positionTex", 2));
_stateSet->addUniform(new osg::Uniform("u_screen_wh", osg::Vec2(_screenWidth, _screenHeight)));
// _stateSet->addUniform(new osg::Uniform("u_debug", 3));
// _stateSet->setTextureAttributeAndModes(3, _debug);
//
_stateSet->setTextureAttribute(0, _randomTexture2D);
_stateSet->setTextureAttribute(1, getInTexture(_in_normal_tex));
_stateSet->setTextureAttribute(2, getInTexture(_in_position_tex));
//
// float w = _mainCamera->getViewport()->width();
// float h = _mainCamera->getViewport()->height();
// osg::Vec2 texelSize = osg::Vec2(1.0f/w, 1.0f/h);
// _stateSet->addUniform(new osg::Uniform("u_texelSize", texelSize));
//_screenQuad->getOrCreateStateSet()->setUpdateCallback(new SSAOStateCallback(_mainCamera, this));
_stateSet->setUpdateCallback(new SSAOStateCallback(_mainCamera, this));
}
void GPUChromaKeyFilter::applyOnGPU(GLTexturePtr pSrcTex)
{
// Set up double-buffering
int curBufferIndex = m_Erosion%2;
getFBO(curBufferIndex)->activate();
getShader()->activate();
m_pTextureParam->set(0);
float h, s, l;
m_Color.toHSL(h, s, l);
m_pHKeyParam->set(h);
m_pHToleranceParam->set(m_HTolerance*360);
m_pHSoftToleranceParam->set((m_HTolerance+m_Softness)*360.0f);
m_pSKeyParam->set(s);
m_pSToleranceParam->set(m_STolerance);
m_pSSoftToleranceParam->set(m_STolerance+m_Softness);
m_pLKeyParam->set(l);
m_pLToleranceParam->set(m_LTolerance);
m_pLSoftToleranceParam->set(m_LTolerance+m_Softness);
m_pSpillThresholdParam->set(m_SpillThreshold*360);
m_pIsLastParam->set(int(m_Erosion==0));
draw(pSrcTex);
for (int i = 0; i < m_Erosion; ++i) {
curBufferIndex = (curBufferIndex+1)%2;
getFBO(curBufferIndex)->activate();
OGLShaderPtr pShader = avg::getShader(SHADERID_EROSION);
pShader->activate();
m_pErosionTextureParam->set(0);
m_pErosionIsLastParam->set(int(i==m_Erosion-1));
getDestTex((curBufferIndex+1)%2)->activate(GL_TEXTURE0);
m_pProjection2->draw(avg::getShader(SHADERID_EROSION));
}
}
GLuint ObjectManager::obtainShader( const void* key, const GLenum type )
{
const GLuint id = getShader( key );
if( id != INVALID )
return id;
return newShader( key, type );
}
void Margin::draw()
{
Vector3D * scale = getScale();
getVSML()->loadIdentity(VSMathLib::MODEL);
// Margin
getVSML()->pushMatrix(VSMathLib::MODEL);
getVSML()->translate(getPosition()->getX(), getPosition()->getY(), getPosition()->getZ());
getVSML()->scale(scale->getX(), scale->getY(), scale->getZ());
// cube
getVSML()->pushMatrix(VSMathLib::MODEL);
getVSML()->translate(-0.5f, -0.5f, -0.5f);
glUseProgram((*getShader()).getProgramIndex());
getVSML()->matricesToGL();
glBindVertexArray(vaoMargin);
glDrawElements(GL_TRIANGLES, faceCountMargin * 3, GL_UNSIGNED_INT, 0);
getVSML()->popMatrix(VSMathLib::MODEL);
// cube
getVSML()->popMatrix(VSMathLib::MODEL);
// Margin
}
void fsDrawMgr::deleteAllVramObjForEngine()
{
fsDrawMgr* ins = instance();
for (const fsID* tex_id = ins->m_tex_map.getFirstKeyN(); tex_id; tex_id = ins->m_tex_map.getNextKeyN(*tex_id))
{
fsTex* tex = getTexture(*tex_id);
if (tex->m_tex_obj != 0)
{
fsLowLevelAPI::unregisterTexture(tex->m_tex_obj);
tex->m_tex_obj = 0;
}
tex->m_flag.setOn(fsTex::FLAG_UPLOAD);
}
for (const fsID* shd_id = ins->m_shd_map.getFirstKeyN(); shd_id; shd_id = ins->m_shd_map.getNextKeyN(*shd_id))
{
fsShd* shd = getShader(*shd_id);
if (shd->m_shd_obj != 0)
{
fsLowLevelAPI::unregisterShader(shd->m_shd_obj);
shd->m_shd_obj = 0;
}
shd->m_flag.setOn(fsShd::FLAG_UPLOAD);
}
}
template <typename T> Ptr<T> Panel::createWidget()
{
Ptr<T> widget = widgets.appendNew<T>(getScene(), getShader());
widget->setDepth(depth + 1);
widgetInfos.insert({widget, WidgetInfo()});
updateWidgetBounds(widget);
return widget;
}
void init()
{
int argc = 0;
char** argv = NULL;
glutInit(&argc, argv); /* NOTE: this hack will not work on windows */
glewInit();
/* Load the shader */
shader = getShader("mesh-generation.vert", "shader.frag");
uniform.object = glGetUniformLocation(shader, "object");
uniform.lightingModel = glGetUniformLocation(shader, "lightingModel");
uniform.isLocalViewer = glGetUniformLocation(shader, "isLocalViewer");
uniform.isPerPixelLighting = glGetUniformLocation(shader, "isPerPixelLighting");
uniform.time = glGetUniformLocation(shader, "time");
/* Lighting and colours */
glClearColor(0, 0, 0, 0);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHT0);
//glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
//glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
//glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular);
glMaterialfv(GL_FRONT, GL_AMBIENT, material_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, material_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, material_specular);
glMaterialf(GL_FRONT, GL_SHININESS, material_shininess);
/* Camera */
camera_zoom = 5.0;
camera_heading = 0.0;
camera_pitch = 0.0;
mouse1_down = 0;
mouse2_down = 0;
/* Turn off all keystate flags */
memset(key_state, 0, 1024);
/* Default render modes */
renderstate.wireframe = 0;
renderstate.lighting = 1;
renderstate.shaders = 0;
renderstate.osd = 1;
renderstate.lightType = 1;
renderstate.lightModel = 1;
renderstate.shading = 1;
renderstate.animate = 0;
update_renderstate();
regenerate_geometry();
}
void RenderingSystemOgl::resetShader( Shader::Type shaderType ) {
if( getShader(shaderType) == nullptr )
return;
::glUseProgramStages( *_programPipeline, selectShaderStage(shaderType), 0 );
checkResult( "::glUseProgramStages" );
RenderingSystemCommon::resetShader( shaderType );
}
//! reinitialize inventor volume
void DVRVolume::reload(void)
{
if(getShader() != NullFC)
{
textureManager.clearTextures(getTextureStorage());
shadingInitialized = false;
}
}
void DVRVolume::initializeClipObjects( DrawActionBase *action,
const Matrix &volumeToWorld)
{
DVRClipObjectsPtr clipObjects = DVRVOLUME_PARAMETER(this, DVRClipObjects);
if(clipObjects != NullFC &&
clipObjects->getClipMode() != DVRClipObjects::Off)
{
DVRVolumeTexturePtr tex = DVRVOLUME_PARAMETER(this, DVRVolumeTexture);
if(tex != NullFC)
{
const Vec3f &res = tex->getResolution();
const Vec3f &slice = tex->getSliceThickness();
Vec3f diag(res[0] * slice[0],
res[1] * slice[1],
res[2] * slice[2]);
Vec3f sliceDir;
if(getShader()->useMTSlabs())
{
Slicer::getAASlicingDirection(action,&sliceDir);
}
else
{
switch (getTextures2D())
{
case 0: // 3D textures
Slicer::getSlicingDirection(action, &sliceDir);
break;
case 1: // 2D textures
Slicer::getAASlicingDirection(action, &sliceDir);
break;
default: // auto
Window *window = action->getWindow();
if(window->hasExtension(_extTex3D))
Slicer::getSlicingDirection(action, &sliceDir);
else
Slicer::getAASlicingDirection(action, &sliceDir);
}
}
Plane clipReferencePlane(sliceDir, -0.5f * diag.length());
clipObjects->initialize(volumeToWorld, clipReferencePlane);
clipper.setReferencePlane(clipReferencePlane);
}
}
}
static void texture_define(lua_State* L, const char* define)
{
auto* shader = getShader(L);
if (!shader) return;
Renderer* renderer = getRendererGlobal(L);
if (!renderer) return;
auto& slot = shader->m_texture_slots[shader->m_texture_slot_count - 1];
slot.define_idx = renderer->getShaderDefineIdx(lua_tostring(L, -1));
}
void SuperShader::createShaders(
const Material& material,
ShaderRef& nonShadowedShader,
ShaderRef& shadowMappedShader) {
Cache::Pair p = getShader(material);
nonShadowedShader = p.nonShadowedShader;
shadowMappedShader = p.shadowMappedShader;
}
//string mPath, string tPath, string sPath, glm::vec3 position, glm::vec3 direction, glm::vec3 up
Ocean::Ocean() : GameObject("Models\\ocean.obj", "Textures\\error.tga", "Shaders\\Ocean Shaders\\ocean.glsl", glm::vec3(0,0,0), glm::vec3(0,0,-1), glm::vec3(0,1,0))
{
windDirection = glm::normalize(glm::vec2(1,1));
amplitude = 5.0f; // 2.0f;
windSpeed = 600.0f;
lambda = 1000.0f;
gridSize = 512.0f;//2000.0f;
oceanTime = 0;
FFTbool = true;
quad = getModel("Models\\quad.obj");
//save seed
oceanSeed = rand();
grandSeed(oceanSeed);
gaussianNumbersTexture = Texture::loadComplexGaussianNumbersTexture(textureSize, textureSize);
butterflyLookupTexture = Texture::loadButterflyLookupTexture(textureSize, numPasses);
FFTTestTexture = Texture::loadFFTTest(textureSize, textureSize);
iFFTTestTexture = Texture::loadiFFTTest(textureSize, textureSize);
h0Buffer = new FrameBuffer(textureSize, textureSize);
h0Buffer->addDepthBuffer();
h0Buffer->addColorFloatTexture();
htBuffer = new FrameBuffer(textureSize, textureSize);
htBuffer->addDepthBuffer();
htBuffer->addColorFloatTexture();
FFTPingPongBuffer = new FrameBuffer(textureSize, textureSize);
FFTPingPongBuffer->addDepthBuffer();
FFTPingPongBuffer->addColorFloatTexture();
FFTPingPongBuffer->addColorFloatTexture();
dataBuffer = new FrameBuffer(textureSize, textureSize);
dataBuffer->addDepthBuffer();
dataBuffer->addColorFloatTexture(); //heigth(2)
dataBuffer->addColorFloatTexture(); //choppy vectors
dataBuffer->addColorFloatTexture(); //heights - boat depths(r)
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
h0Shader = getShader("Shaders\\Ocean Shaders\\h0.glsl");
htShader = getShader("Shaders\\Ocean Shaders\\ht.glsl");
choppyShader = getShader("Shaders\\Ocean Shaders\\choppy.glsl");
FFTxShader = getShader("Shaders\\Ocean Shaders\\FFTx.glsl");
FFTyShader = getShader("Shaders\\Ocean Shaders\\FFTy.glsl");
scaleShader = getShader("Shaders\\Ocean Shaders\\scale.glsl");
finalHeightShader = getShader("Shaders\\Ocean Shaders\\finalOceanHeight.glsl");
quadShader = getShader("Shaders\\quad.glsl");
updateH0Texture();
}
static void texture_slot(lua_State* state, const char* name, const char* uniform)
{
auto* shader = getShader(state);
if (!shader) return;
auto& slot = shader->m_texture_slots[shader->m_texture_slot_count];
copyString(slot.name, name);
slot.uniform_handle = bgfx::createUniform(uniform, bgfx::UniformType::Int1);
copyString(slot.uniform, uniform);
++shader->m_texture_slot_count;
}
void fsDrawMgr::deleteShader(fsID shd_id)
{
instance();
if (shd_id == fsID::ZERO)
{
fsThrow(ExceptionInvalidArgument);
}
fsDelete(getShader(shd_id), fsShd);
}
void CharacterModel::deactivateShader(void)
{
for(UInt32 i = 0; i < getMaterials().size(); ++i)
{
ChunkMaterialPtr m = getMaterials(i);
beginEditCP(m);
m->subChunk(getShader());
endEditCP(m);
}
}
void GPUHueSatFilter::applyOnGPU(GLTexturePtr pSrcTex)
{
OGLShaderPtr pShader = getShader(SHADERID_HSL_COLOR);
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
pShader->activate();
m_pHueParam->set(m_Hue);
m_pSatParam->set(m_Saturation);
m_pLightnessParam->set(m_LightnessOffset);
m_pColorizeParam->set((int)(m_bColorize));
m_pTextureParam->set(0);
draw(pSrcTex);
}
MaterialData CompiledMaterial::getMaterial() const {
MaterialData data;
String frag = core::String(getShader().toStdString());
data.prog = ShaderProgram(new Shader<FragmentShader>(frag));
for(int i = 0; i != samplers.size(); i++) {
data.surface.textures[i] = samplers[i].texture;
}
return data;
}
bool Render::blitBackground(CZImage *bgImg, bool clearColor /* = true */)
{
if(bgImg == nullptr)
{
LOG_ERROR("bgImg is nullptr!\n");
return false;
}
CZShader *pShader = getShader(kBlitImage);
if (pShader == NULL)
{
LOG_ERROR("there's no shader for blitting background image\n");
return false;
}
if(prepareBgImage(bgImg) == false) return false;
if(prepareBgVAO() == false) return false;
// draw Rect
glClear(GL_DEPTH_BUFFER_BIT);
if(clearColor)
glClear(GL_COLOR_BUFFER_BIT);
CZMat4 mvpMat;
mvpMat.SetOrtho(0,width,0,height,-1.0f,1.0f);
pShader->begin();
glUniformMatrix4fv(pShader->getUniformLocation("mvpMat"),1,GL_FALSE,mvpMat);
glUniform1i(pShader->getUniformLocation("texture"), (GLuint) 0);
glUniform1f(pShader->getUniformLocation("opacity"), 1.0f); // fully opaque
enableTexture(bgImg);
// clear the buffer to get a transparent background
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT );
// set up premultiplied normal blend
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
GL_BIND_VERTEXARRAY(pBgImageRes->vao);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
GL_BIND_VERTEXARRAY(0);
pShader->end();
CZCheckGLError();
return true;
}
