void ofxPBR::drawEnvironment(){
glm::mat4 projectionMatrix = ofGetCurrentMatrix(OF_MATRIX_PROJECTION);
float m22 = projectionMatrix[2][2];
float m32 = projectionMatrix[3][2];
\
float nearClip = (2.0f*m32) / (2.0f*m22 - 2.0f);
float farClip = ((m22 - 1.0f) * nearClip) / (m22 + 1.0);
if (enableCubemap && cubeMap != nullptr && cubeMap->isAllocated()) {
float scale = (farClip - nearClip) / 2;
glm::mat4 invCurrentViewMatrix = glm::inverse(ofGetCurrentViewMatrix());
glm::vec3 translate = glm::vec3(invCurrentViewMatrix[3][0], invCurrentViewMatrix[3][1], invCurrentViewMatrix[3][2]);
ofDisableDepthTest();
ofPushMatrix();
ofTranslate(translate);
cubeMap->bind(1);
envShader->begin();
envShader->setUniform1f("envLevel", cubeMap->getEnvLevel());
envShader->setUniform1i("envMap", 1);
envShader->setUniform1i("numMips", cubeMap->getNumMips());
envShader->setUniform1f("cubeMapExposure", cubeMap->getExposure());
envShader->setUniform1f("cubeMapRotation", cubeMap->getRotation());
ofPushMatrix();
ofScale(scale, scale, scale);
sphereMesh.draw();
ofPopMatrix();
envShader->end();
cubeMap->unbind();
ofPopMatrix();
ofEnableDepthTest();
}
}
ofVec3f ofxMapamok::worldToScreen(ofVec3f WorldXYZ, ofRectangle viewport) {
if (!calibrationReady) {
return WorldXYZ;
}
if (viewport.isZero()) {
viewport = ofGetCurrentViewport();
}
begin();
ofMatrix4x4 modelViewMatrix = ofGetCurrentMatrix(OF_MATRIX_MODELVIEW);
ofMatrix4x4 projectionMatrix = ofGetCurrentMatrix(OF_MATRIX_PROJECTION);
end();
ofVec3f CameraXYZ = WorldXYZ * modelViewMatrix * projectionMatrix;
ofVec3f ScreenXYZ;
ScreenXYZ.x = (CameraXYZ.x + 1.0f) / 2.0f * viewport.width + viewport.x;
ScreenXYZ.y = (1.0f - CameraXYZ.y) / 2.0f * viewport.height + viewport.y;
ScreenXYZ.z = CameraXYZ.z;
return ScreenXYZ;
}
//--------------------------------------------------------------
void ofApp::draw(){
cam.begin();
shader.begin();
shader.setUniform1f("fraction", 1.0);
ofMatrix4x4 mv = ofGetCurrentMatrix(OF_MATRIX_MODELVIEW);
ofMatrix4x4 normMat = ofMatrix4x4::getTransposedOf(mv.getInverse());
shader.setUniformMatrix4f("normalMatrix", normMat);
float dirY = (mouseY / float(ofGetHeight()) - 0.5) * 2;
float dirX = (mouseX / float(ofGetWidth()) - 0.5) * 2;
lightDir.set(-dirX, -dirY, -1);
ofVec3f lightNorm = ofMatrix4x4::transform3x3(normMat, lightDir);
lightNorm.normalize();
shader.setUniform3f("lightNormal", lightNorm.x, lightNorm.y, lightNorm.z);
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
ofDrawSphere(0, 0, 120);
shader.end();
cam.end();
}
// pbr
void ofxPBR::beginPBR(){
glm::mat4 modelViewMatrix = ofGetCurrentMatrix(ofMatrixMode::OF_MATRIX_MODELVIEW);
// pbr
PBRShader->begin();
// common uniforms
PBRShader->setUniform1i("renderMode", renderMode);
PBRShader->setUniformMatrix4f("viewTranspose", glm::transpose(modelViewMatrix));
PBRShader->setUniformMatrix4f("viewMatrix", modelViewMatrix);
// cubemap uniforms
if (enableCubemap && cubeMap != nullptr && cubeMap->isAllocated()) {
// enable cubemap
cubeMap->bind(1);
PBRShader->setUniform1i("enableEnv", true);
PBRShader->setUniform1i("numMips", cubeMap->getNumMips());
PBRShader->setUniform1f("cubeMapExposure", cubeMap->getExposure());
PBRShader->setUniform1f("cubeMapRotation", cubeMap->getRotation());
PBRShader->setUniform1i("isHDR", cubeMap->isHDR());
PBRShader->setUniform1i("envMap", 1);
}else{
// disable cubemap
PBRShader->setUniform1i("enableEnv", false);
PBRShader->setUniform1i("isHDR", false);
}
// light uniforms
PBRShader->setUniform1i("numLights", lights.size());
for (int i = 0; i < lights.size(); i++) {
string lightIndex = ofToString(i);
// common
PBRShader->setUniform1i("lights[" + lightIndex + "].isEnabled", lights[i]->getIsEnabled());
PBRShader->setUniform1i("lights[" + lightIndex + "].type", lights[i]->getLightType());
// color
PBRShader->setUniform4f("lights[" + lightIndex + "].color", lights[i]->getColor());
PBRShader->setUniform1f("lights[" + lightIndex + "].intensity", lights[i]->getIntensity());
// transform
PBRShader->setUniform3f("lights[" + lightIndex + "].position", lights[i]->getGlobalPosition());
PBRShader->setUniform3f("lights[" + lightIndex + "].vPosition", lights[i]->getViewSpacePosition(modelViewMatrix));
PBRShader->setUniform3f("lights[" + lightIndex + "].direction", lights[i]->getViewSpaceDirection(modelViewMatrix));
// shadow
PBRShader->setUniform1i("lights[" + lightIndex + "].shadowType", lights[i]->getShadowType());
PBRShader->setUniform1i("lights[" + lightIndex + "].spotShadowIndex", lights[i]->getSpotShadowIndex());
PBRShader->setUniform1i("lights[" + lightIndex + "].omniShadowIndex", lights[i]->getOmniShadowIndex());
PBRShader->setUniform1i("lights[" + lightIndex + "].directionalShadowIndex", lights[i]->getDirectionalShadowIndex());
PBRShader->setUniform1f("lights[" + lightIndex + "].shadowStrength", lights[i]->getShadowStrength());
PBRShader->setUniform1f("lights[" + lightIndex + "].bias", lights[i]->getShadowBias());
PBRShader->setUniform1f("lights[" + lightIndex + "].farClip", lights[i]->getFarClip());
// point light
PBRShader->setUniform1f("lights[" + lightIndex + "].pointLightRadius", lights[i]->getPointLightRadius());
// spot light
PBRShader->setUniform1f("lights[" + lightIndex + "].spotLightFactor", lights[i]->getSpotLightGradient());
PBRShader->setUniform1f("lights[" + lightIndex + "].spotLightCutoff", lights[i]->getSpotLightCutoff());
PBRShader->setUniform1f("lights[" + lightIndex + "].spotLightDistance", lights[i]->getSpotLightDistance());
}
// depth map uniforms
directionalShadow.bind(10);
PBRShader->setUniform1i("directionalShadowMap", 10);
glUniformMatrix4fv(PBRShader->getUniformLocation("directionalShadowMatrix"), directionalShadow.getShadowMatrix().size(), false, &directionalShadow.getShadowMatrix()[0][0][0]);
spotShadow.bind(11);
PBRShader->setUniform1i("spotShadowMap", 11);
glUniformMatrix4fv(PBRShader->getUniformLocation("spotShadowMatrix"), spotShadow.getShadowMatrix().size(), false, &spotShadow.getShadowMatrix()[0][0][0]);
omniShadow.bind(12);
PBRShader->setUniform1i("omniShadowMap", 12);
}
void ofApp::updateNormalMatrix()
{
normalMatrix = mat4ToMat3(ofGetCurrentMatrix(OF_MATRIX_MODELVIEW));
normalMatrix.invert();
normalMatrix.transpose();
}
void ofxSpriteRenderer::Render()
{
//printf("--------------RENDER--------------\n");
for(ofxBaseCommands::iterator it = m_Commands.begin();it != m_Commands.end();it++)
{
ofxBaseCommand* item = *it;
delete item;
}
m_Commands.clear();
//unsigned long long time_start_build = ofGetSystemTime();
sort(m_Sprites.begin(), m_Sprites.end(), QuadCompare);
for(int i=0;i<m_Sprites.size();i++)
{
m_Sprites[i]->SetID(i);
}
//unsigned long long time_finish_sort = ofGetSystemTime();
//printf("sort time = %llu\n", time_finish_sort - time_start_build);
bool is_custom_command = false;
for(ofxBaseSprites::iterator it = m_Sprites.begin();it != m_Sprites.end();it++)
{
ofxBaseSprite* sprite = *it;
if(!(sprite->GetOcclusion() == SPRITE_OCCLUSION_IN_SCREEN || sprite->GetOcclusion() == SPRITE_OCCLUSION_UNKNOWN) ||
!sprite->IsVisible())
{
continue;
}
if(sprite->IsCustomRendered())
{
ofxBaseCommand* command = (ofxBaseCommand*)sprite;
m_Commands.push_back(command);
is_custom_command = true;
continue;
}
ofxSpriteCommand* command;
if(m_Commands.size() == 0 || is_custom_command)
{
command = new ofxSpriteCommand();
command->SetShader(sprite->GetShader());
command->SetTexture(sprite->GetTexture());
bool push_success = command->PushSprite(sprite);
assert(push_success);
m_Commands.push_back(command);
is_custom_command = false;
}
else
{
command = (ofxSpriteCommand*)m_Commands.back();
bool push_success = command->PushSprite(sprite);
if(command->GetShader() != sprite->GetShader()
|| command->GetTexture() != sprite->GetTexture()
|| !push_success)
{
command = new ofxSpriteCommand();
command->SetShader(sprite->GetShader());
command->SetTexture(sprite->GetTexture());
push_success = command->PushSprite(sprite);
m_Commands.push_back(command);
assert(push_success);
}
}
}
//unsigned long long time_finish_build = ofGetSystemTime();
//printf("build time = %llu\n", time_finish_build - time_start_build);
#ifdef _DEBUG
m_DrawnBatches = 0;
m_DrawnVertices = 0;
unsigned long long time_start_render = ofGetSystemTime();
#endif
m_TransformMatrix = ofGetCurrentMatrix(OF_MATRIX_MODELVIEW)*ofGetCurrentMatrix(OF_MATRIX_PROJECTION);
//m_Camera->begin();
{
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
//glDisable(GL_DEPTH_TEST);// transparent isn't work well with depth test
glDepthMask(GL_FALSE);
for(ofxBaseCommands::iterator it = m_Commands.begin();it != m_Commands.end();it++)
{
ofxBaseCommand* cmd = *it;
cmd->Render();
#ifdef _DEBUG
m_DrawnBatches++;
m_DrawnVertices += cmd->GetRenderedVertices();
#endif
}
//glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
}
//m_Camera->end();
#ifdef _DEBUG
unsigned long long time_finish_render = ofGetSystemTime();
m_RenderTimeMilisecond = time_finish_render - time_start_render;
#endif
}
