bool GLSL::initialize(const std::string& vertName, const std::string& fragName)
{
std::ifstream fileVert(vertName.c_str());
std::ifstream fileFrag(fragName.c_str());
std::string sline;
std::string sVertSource;
std::string sFragSource;
while(getline(fileVert, sline))
{
sVertSource += sline+"\n";
}
while(getline(fileFrag, sline))
{
sFragSource += sline+"\n";
}
mProgram = createProgram(sVertSource.c_str(), sFragSource.c_str());
if (!mProgram)
{
Tools::getLogStream()<<"Could not create shader program."<<std::endl;
mIsInit = false;
}
else
{
initUniforms();
mIsInit = true;
}
return mIsInit;
}
bool App::OnInit() {
_frame = new GLFrame( "Hello World", wxPoint(50, 50), wxSize(1024, 768) );
_frame->Show( true );
initShader("E:/Vault/glmanv2/vir.json");
initUniforms();
initModels();
initTextures();
ControlFrame* controlFrame = new ControlFrame();
controlFrame->Show( true );
_eventTimer = new wxTimer(this, kEventTimerId);
_eventTimer->Start(1, wxTIMER_CONTINUOUS);
return true;
}
RendererDR::RendererDR(Engine* engine, ProgramLoader& loader)
:
mScreenSize(engine->getScreenSize()),
mLights(engine->getLightSystem()),
mTextures(engine->getTextureSystem()),
mProgramMain(loader.getDefaultDR()),
mProgramMainAnimated(loader.getDefaultBonesDR()),
mProgramDirecionalLight(loader.getDRDirectionalLights()),
mProgramSpotLight(loader.getDRSpotLights()),
mProgramPointLight(loader.getDRPointLights()),
mProgramDepthless(loader.getDRDepthless()),
mProgramAmbient(loader.getDRAmbient()),
mProgramAOGeometry(loader.getAmbientOcclusionGeometry()),
mProgramAOColor(loader.getAmbientOcclusionColor()),
mAOGeometryBuffer(engine->storeTextureRenderable()),
mAOColorBuffer(engine->storeTextureRenderable()),
mIsAO(GL_FALSE),
mDeferredColorAttachments(5),
mDeferredDepthAttachments(1),
mGBuffer(
std::make_unique<core::FramebufferGeometry>(mTextures, mScreenSize[0],
mScreenSize[1], mDeferredColorAttachments,
mDeferredDepthAttachments)) {
framework::Sphere sphere(3.0f, 10.0f,
10.0f); // xxx hardcoded values fix ! todo !
std::vector<core::VertexBasic> vertices = sphere.getVertices();
std::vector<GLuint> indices = sphere.getIndices();
core::VertexArray* vao = new core::VertexArray();
mDeferredPointLight = std::make_unique<Mesh>(engine, Material(),
nullptr,
nullptr, nullptr,
mProgramPointLight, nullptr, nullptr, loader.getOcclusionQuery(),
nullptr, nullptr, mLights,
engine->storeBuffer<core::VertexBufferBasic>(vao, vertices),
engine->storeBuffer<core::IndexBuffer>(vao, indices),
#ifdef FILLWAVE_MODEL_LOADER_ASSIMP
nullptr,
#endif /* FILLWAVE_MODEL_LOADER_ASSIMP */
GL_TRIANGLES, vao);
initUniforms();
initGeometryBuffer();
initGeometryShading();
initUniformsCache();
reset(mScreenSize[0], mScreenSize[1]);
}
void Material::enable() {
if (mShaderProgram != NULL && mShaderProgram->ready()) {
mShaderProgram->enable();
if (!mUniformsInitialized) {
initUniforms();
}
} else {
return;
}
for (unsigned int comp = 0; comp < MATERIAL_COMPONENT_COUNT; ++comp) {
MaterialComponent &mat = mMaterialComponent[comp];
if (mMaterialComponentEnabled[comp]) {
// enable material component, if trigger uniform is defined //
if (mat.uniformIsEnabled >= 0) {
glUniform1i(mat.uniformIsEnabled, 1);
}
// link material value //
glUniform4f(mat.uniformLocation, mat.value[0], mat.value[1], mat.value[2], mat.value[3]);
} else {
// disable material component, if trigger uniform is defined //
if (mat.uniformIsEnabled >= 0) {
glUniform1i(mat.uniformIsEnabled, 0);
}
}
}
for (unsigned int layer = 0; layer < TEX_LAYER_COUNT; ++layer) {
if (mTexture[layer].isEnabled) {
// enable texture, if trigger uniform defined //
if (mTexture[layer].uniformIsEnabled >= 0) {
glUniform1i(mTexture[layer].uniformIsEnabled, 1);
}
// link texture //
glActiveTexture(GL_TEXTURE0 + layer);
glBindTexture(GL_TEXTURE_2D, mTexture[layer].glTextureLocation);
glUniform1i(mTexture[layer].uniformLocation, layer);
} else {
// disable texture, if trigger uniform defined //
if (mTexture[layer].uniformIsEnabled >= 0) {
glUniform1i(mTexture[layer].uniformIsEnabled, 0);
}
}
}
}
ParticleBasicMaterial::ParticleBasicMaterial() : Material(kParticleBasicMaterial)
{
// equivalent to three.js setMaterialShaders
initUniforms(uniforms);
vertexShader(ParticleBasicMaterial::kVertexShader);
fragmentShader(ParticleBasicMaterial::kFragmentShader);
color() = Color( 0xffffff );
// map = null;
size() = 1.0f;
sizeAttenuation() = true;
vertexColors() = false;
fog() = true;
}
void TextureShader::programInit(RenderState* rstate, RenderData* render_data, Material* material,
const std::vector<glm::mat4>& model_matrix,int drawcount, bool batching){
if(!material->isMainTextureReady())
return;
Texture* texture = material->getTexture("main_texture");
glm::vec3 color = material->getVec3("color");
float opacity = material->getFloat("opacity");
glm::vec4 material_ambient_color = material->getVec4("ambient_color");
glm::vec4 material_diffuse_color = material->getVec4("diffuse_color");
glm::vec4 material_specular_color = material->getVec4("specular_color");
float material_specular_exponent = material->getFloat("specular_exponent");
if (texture->getTarget() != GL_TEXTURE_2D) {
std::string error = "TextureShader::render : texture with wrong target.";
throw error;
}
bool use_light = false;
Light* light;
if (render_data->light_enabled()) {
light = render_data->light();
if (light->enabled()) {
use_light = true;
}
}
bool batching_enabled = batching;
int feature_set =0;
feature_set |= (use_light) ? LIGHT : NO_LIGHT;
feature_set |= (use_multiview) ? MULTIVIEW : NO_MULTIVIEW;
feature_set |= (batching_enabled) ? BATCHING : NO_BATCHING;
bool properties [] = {use_light, use_multiview, batching_enabled};
const char* feature_strings[2][3]={{NOT_USE_LIGHT, NOT_USE_MULTIVIEW, NOT_USE_BATCHING},
{USE_LIGHT, USE_MULTIVIEW, USE_BATCHING}};
int feature_string_lengths[2][3]={{strlen(NOT_USE_LIGHT), strlen(NOT_USE_MULTIVIEW), strlen(NOT_USE_BATCHING)},
{strlen(USE_LIGHT),strlen(USE_MULTIVIEW), strlen(USE_BATCHING)}};
uniforms uniform_locations;
GLProgram* prgram = nullptr;
if(program_object_map_.find(feature_set)==program_object_map_.end()){
const char* vertex_shader_strings[5];
GLint vertex_shader_string_lengths[5];
vertex_shader_strings[0]=version;
vertex_shader_strings[4]=VERTEX_SHADER;
vertex_shader_string_lengths[0]= (GLint) strlen(version);
vertex_shader_string_lengths[4]= (GLint) strlen(VERTEX_SHADER);
const char* frag_shader_strings[5];
GLint frag_shader_string_lengths[5];
frag_shader_strings[0]=version;
frag_shader_strings[4]=FRAGMENT_SHADER;
frag_shader_string_lengths [0] = vertex_shader_string_lengths[0];
frag_shader_string_lengths [4] = (GLint) strlen(FRAGMENT_SHADER);
int index = 1;
for(int i=0;i<3; i++){
vertex_shader_strings[index]= feature_strings[properties[i]][i];
vertex_shader_string_lengths [index]= feature_string_lengths[properties[i]][i];
frag_shader_strings[index]=vertex_shader_strings[index];
frag_shader_string_lengths[index] = vertex_shader_string_lengths [index];
index++;
}
prgram = new GLProgram(vertex_shader_strings,
vertex_shader_string_lengths, frag_shader_strings,
frag_shader_string_lengths, 5);
program_object_map_[feature_set] = prgram;
if(use_multiview)
LOGE("Rendering with multiview");
initUniforms(feature_set, prgram->id(), uniform_locations);
uniform_loc[feature_set] = uniform_locations;
}
else {
prgram = program_object_map_[feature_set];
uniform_locations = uniform_loc[feature_set];
}
program_ = prgram;
GLuint programId = prgram->id();
//render_data->mesh()->generateVAO(programId);
GL(glUseProgram(programId));
GL(glActiveTexture (GL_TEXTURE0));
GL(glBindTexture(texture->getTarget(), texture->getId()));
glUniform1i(uniform_locations.u_texture, 0);
glUniform3f(uniform_locations.u_color, color.r, color.g, color.b);
glUniform1f(uniform_locations.u_opacity, opacity);
if(!batching_enabled)
glUniformMatrix4fv(uniform_locations.u_model, 1, GL_FALSE, glm::value_ptr(rstate->uniforms.u_model));
glUniformMatrix4fv(uniform_locations.u_proj, 1, GL_FALSE, glm::value_ptr(rstate->uniforms.u_proj));
if (use_light) {
glm::vec3 light_position = light->getVec3("world_position");
glm::vec4 light_ambient_intensity = light->getVec4("ambient_intensity");
glm::vec4 light_diffuse_intensity = light->getVec4("diffuse_intensity");
glm::vec4 light_specular_intensity = light->getVec4(
"specular_intensity");
glUniform3f(uniform_locations.u_light_pos, light_position.x, light_position.y,
light_position.z);
glUniform4f(uniform_locations.u_material_ambient_color_, material_ambient_color.r,
material_ambient_color.g, material_ambient_color.b,
material_ambient_color.a);
glUniform4f(uniform_locations.u_material_diffuse_color_, material_diffuse_color.r,
material_diffuse_color.g, material_diffuse_color.b,
material_diffuse_color.a);
glUniform4f(uniform_locations.u_material_specular_color_, material_specular_color.r,
material_specular_color.g, material_specular_color.b,
material_specular_color.a);
glUniform1f(uniform_locations.u_material_specular_exponent_, material_specular_exponent);
glUniform4f(uniform_locations.u_light_ambient_intensity_, light_ambient_intensity.r,
light_ambient_intensity.g, light_ambient_intensity.b,
light_ambient_intensity.a);
glUniform4f(uniform_locations.u_light_diffuse_intensity_, light_diffuse_intensity.r,
light_diffuse_intensity.g, light_diffuse_intensity.b,
light_diffuse_intensity.a);
glUniform4f(uniform_locations.u_light_specular_intensity_, light_specular_intensity.r,
light_specular_intensity.g, light_specular_intensity.b,
light_specular_intensity.a);
}
if(use_multiview)
glUniformMatrix4fv(uniform_locations.u_view, 2, GL_FALSE, glm::value_ptr(rstate->uniforms.u_view_[0]));
else
glUniformMatrix4fv(uniform_locations.u_view, 1, GL_FALSE, glm::value_ptr(rstate->uniforms.u_view));
if(batching){
glUniform4fv(uniform_locations.u_model, drawcount*4, &model_matrix[0][0][0]);
glBindVertexArray(render_data->mesh()->getVAOId(programId));
}
}
Splatterer::Splatterer( const Logger* logger,
const Context* context,
GLfloat viewportSize,
QString textureFilename,
BufferTexture* baseDiscomfort)
: pointBuffer(0),
screenSizedQuadBuffer(0),
framebufferObject(0),
densityDiscomfortVelocity(NULL),
splatAreas(NULL),
agent(NULL),
splatAttribVertex(-1),
splatProgram(NULL),
splatVertexShader(NULL),
splatGeometryShader(NULL),
splatFragmentShader(NULL),
camera(NULL),
bufferSideLength(viewportSize),
totalBufferSize(0),
densityDiscomfortVelocityTripple(NULL),
logger(logger),
context(context),
prepareFramebufferRenderer(NULL),
discomfortProgram(NULL),
discomfortVertexShader(NULL),
discomfortGeometryShader(NULL),
discomfortFragmentShader(NULL),
discomfortFactor(NULL),
discomfortRadius(NULL),
discomfortPosition(NULL)
{
attachments[0] = GL_COLOR_ATTACHMENT0;
attachments[1] = GL_COLOR_ATTACHMENT1;
initCamera();
initSplatShaderProgram();
initAttribs();
initVBO();
initUniforms();
initFramebufferObject();
try
{
//
// Create splatted texture
//
QImage image = Texture::loadTexture(textureFilename, false, true);
uint pixelCount = image.width() * image.height();
std::vector<float> data(pixelCount * 4);
Texture::convertToFloats(image, data, pixelCount);
glActiveTexture(GL_TEXTURE0);
agent = new Texture2D(image.width(), image.height(), GL_CLAMP_TO_EDGE, GL_LINEAR, GL_LINEAR, GL_RGBA32F, GL_RGBA, GL_FLOAT, &data[0]);
totalBufferSize += image.width() * image.height() * 4 * 4;
}
catch (Exception& e)
{
throw Exception("Could not load splatting texture: " + e.message);
}
//
// Create buffer object for density, discomfort and velocity
//
size_t bufferByteSize = bufferSideLength * bufferSideLength * sizeof(GLfloat) * 4;
densityDiscomfortVelocityTripple = new TextureBufferTripple(bufferByteSize, NULL, GL_DYNAMIC_COPY, GL_RGBA32F, CL_MEM_READ_WRITE, context);
totalBufferSize += bufferByteSize;
//
// Create renderer to render base discomfort map to framebuffer
//
std::vector<QString> filenamesVert;
std::vector<QString> filenamesFrag;
filenamesVert.push_back("src/shaders/shared.vert");
filenamesFrag.push_back("src/shaders/shared.frag");
filenamesFrag.push_back("src/shaders/prepareFramebuffer.frag");
prepareFramebufferRenderer = new TextureRenderer(bufferSideLength, baseDiscomfort, filenamesVert, filenamesFrag, "Framebuffer Preparation Shader", false);
//
// Create shader to render discomfort at pointer to framebuffer
//
initDiscomfortShaderProgram();
}
