bool RenderEngine::init()
{
if ( !mEffect.loadFromSingleFile( "Shader/MVPiece") )
return false;
locDirX = mEffect.getParamLoc( "dirX" );
locDirZ = mEffect.getParamLoc( "dirZ" );
locLocalScale = mEffect.getParamLoc( "localScale" );
{
MeshLoader loader;
if ( !MeshUtility::createCube( mMesh[ MESH_BOX ] , 0.5f ) ||
!MeshUtility::createUVSphere( mMesh[ MESH_SPHERE ] , 0.3 , 10 , 10 ) ||
!MeshUtility::createPlane( mMesh[ MESH_PLANE ] , Vector3(0.5,0,0) ,Vector3(1,0,0) , Vector3(0,1,0) , 0.5 , 1 ) )
return false;
for( int i = 0 ; i < ARRAY_SIZE( gMeshInfo ) ; ++i )
{
MeshInfo const& info = gMeshInfo[i];
FixString< 256 > path = "Mesh/";
path += info.name; path += ".obj";
if ( !loader.load( mMesh[ info.id ] , path ) )
return false;
}
}
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable( GL_CULL_FACE );
glEnable( GL_DEPTH_TEST );
return true;
}
CComplexModelSceneNode::CComplexModelSceneNode(CSceneManager *sceneManager, string filename, string texture)
{
//mesh = new CMesh(filename);
MeshLoader *msl = new MeshLoader;
mesh = msl->loadMesh(ASSETS::MODEL(filename));
this->sceneManager = sceneManager;
this->texture = texture;
reset();
}
int main(void)
{
if(!glfwInit())
return -1;
window = glfwCreateWindow(windowWidth, windowHeight, "Simple Render", NULL, NULL);
glfwMakeContextCurrent(window);
if( window == NULL )
{
fprintf( stderr, "Failed to open GLFW window.\n" );
glfwTerminate();
return -1;
}
//glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK) {
fprintf(stderr, "Failed to initialize GLEW\n");
return -1;
}
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glClearColor(0.4f,0.5f,1.0f,1.0f);
MeshLoader* meshLoader = new MeshLoader();
Camera camera(window, (float)windowWidth/windowHeight, vec2(windowWidth/2, windowHeight/2));
DirectionLight dirLight;
Scene* scene = new Scene(windowWidth, windowHeight, "Scene.json", meshLoader);
ColorFrameBufferObj defaultFBO(windowWidth, windowHeight);
map<string, GLuint> textures;
textures["colorTex"] = defaultFBO.getTextureID();
Mesh* quad = meshLoader->loadMesh("Quad.obj");
Bloom bloom(windowWidth, windowHeight, quad);
ImageEffect tiltShift(windowWidth, windowHeight, quad, (new ImageMaterial("TiltShift.glsl"))->getID());
bloom.setImageEffect(&tiltShift);
while (glfwWindowShouldClose(window) == 0 && glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS)
{
scene->render(camera, dirLight, defaultFBO);
bloom.process(textures);
camera.update();
dirLight.updatePosition();
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwTerminate();
return 0;
}
/**
Loads data from mesh files located in the folder specified in the
geometry parameters (command line parameter --mesh-folder)
*/
void _loadMeshFolder()
{
#ifdef BRAYNS_USE_ASSIMP
GeometryParameters& geometryParameters =
_parametersManager->getGeometryParameters();
const boost::filesystem::path& folder =
geometryParameters.getMeshFolder( );
BRAYNS_INFO << "Loading meshes from " << folder << std::endl;
MeshLoader meshLoader;
size_t meshIndex = 0;
boost::filesystem::directory_iterator endIter;
if( boost::filesystem::exists(folder) &&
boost::filesystem::is_directory(folder))
{
for( boost::filesystem::directory_iterator dirIter( folder );
dirIter != endIter; ++dirIter )
{
if( boost::filesystem::is_regular_file(dirIter->status( )))
{
const std::string& filename = dirIter->path( ).string( );
BRAYNS_INFO << "- " << filename << std::endl;
ScenePtr scene = _engine->getScene();
MeshContainer MeshContainer =
{
scene->getTriangleMeshes(), scene->getMaterials(),
scene->getWorldBounds()
};
if(!meshLoader.importMeshFromFile(
filename, MeshContainer, MQ_FAST, NO_MATERIAL ))
{
BRAYNS_ERROR << "Failed to import " <<
filename << std::endl;
}
++meshIndex;
}
}
}
#endif
}
int main(int argc, char* argv[])
{
int ret = ERROR_FAILURE;
if (argc < 2)
{
printf("please input as this format: <mesh type> <meshfile> [meshfiledump] \n");
return ERROR_FAILURE;
}
char *mtype = argv[1];
char *file_name = argv[2];
char *file_name_dump = NULL;
if (argc > 2)
file_name_dump = argv[3];
// load the mesh file
Mesh mesh;
MeshLoader *mloader = NULL;
if (strcmp(mtype, "exII") == 0) mloader = new ExodusIIReader();
else if (strcmp(mtype, "h2d") == 0) mloader = new H2DReader();
else if (strcmp(mtype, "h2d-str") == 0) {
// load the file into a string
FILE *file = fopen(file_name , "rb");
error_if(file == NULL, "unable to open file '%s'", file_name);
// obtain file size:
fseek(file, 0, SEEK_END);
long size = ftell(file);
rewind(file);
// allocate memory to contain the whole file:
char *buffer = (char *) malloc (sizeof(char) * size);
error_if(buffer == NULL, "memory error");
// copy the file into the buffer:
size_t result = fread(buffer, 1, size, file);
error_if(result != size, "reading error");
fclose(file);
//
H2DReader *hloader = new H2DReader();
hloader->load_str(buffer, &mesh);
ret = dump_compare(mesh, file_name_dump);
delete hloader;
free(buffer);
return ret;
}
else if (strcmp(mtype, "h2d-old") == 0) {
H2DReader *hloader = new H2DReader();
hloader->load_old(file_name, &mesh);
ret = dump_compare(mesh, file_name_dump);
delete hloader;
return ret;
}
else {
error("unknown mesh loader type");
}
if (mloader->load(file_name, &mesh))
{
ret = dump_compare(mesh, file_name_dump);
}
else
{
error("failed");
ret = ERROR_FAILURE;
}
delete mloader;
return ret;
}
//---------------------------------------------------------------------------
void Init()
{
backbuffer = new Buffer(windowSize.x, windowSize.y);
float lumScale = 1.f;
Color ballDiffuse(0.1f, 0.4f, 0.4f);
Color ballSpec(0.2f, 0.2f, 0.2f);
Color ballEmit(0.75f, 0.75f, 0.75f);
Color planeDiffuse(0.5, 0, 0);
Color planeSpec(0.1f, 0.1f, 0.1f);
ballEmit = lumScale * ballEmit;
Color zero(0, 0, 0);
#define LOAD_MESH 0
#if LOAD_MESH
MeshLoader loader;
loader.Load("gfx/crystals_flat.boba");
for (const protocol::MeshBlob* meshBlob : loader.meshes)
{
for (u32 i = 0; i < meshBlob->numIndices; i += 3)
{
u32 idx0 = meshBlob->indices[i + 0];
u32 idx1 = meshBlob->indices[i + 1];
u32 idx2 = meshBlob->indices[i + 2];
Vector3 p0 = { meshBlob->verts[idx0 * 3 + 0], meshBlob->verts[idx0 * 3 + 1], meshBlob->verts[idx0 * 3 + 2] };
Vector3 p1 = { meshBlob->verts[idx1 * 3 + 0], meshBlob->verts[idx1 * 3 + 1], meshBlob->verts[idx1 * 3 + 2] };
Vector3 p2 = { meshBlob->verts[idx2 * 3 + 0], meshBlob->verts[idx2 * 3 + 1], meshBlob->verts[idx2 * 3 + 2] };
tris.push_back({ p0, p1, p2 });
}
}
#else
#if 1
int numBalls = 10;
for (u32 i = 0; i < numBalls; ++i)
{
float angle = i * 2 * Pi / numBalls;
Geo* g = new Sphere(Vector3(10 * cosf(angle), 0, 30 + 10 * sinf(angle)), 2);
if (i & 1)
g->material = new Material(ballDiffuse, ballSpec, zero);
else
g->material = new Material(ballDiffuse, ballSpec, ballEmit);
objects.push_back(g);
}
Geo* center = new Sphere(Vector3(0, 50, 30), 15);
center->material = new Material(ballDiffuse, zero, ballEmit);
objects.push_back(center);
#else
{
Geo* g = new Sphere(Vector3(-10, 10, 30), 7);
g->material = new Material(ballDiffuse, ballSpec, ballEmit);
objects.push_back(g);
}
{
Geo* g = new Sphere(Vector3(0, 0, 30), 5);
g->material = new Material(ballDiffuse, ballSpec, zero);
objects.push_back(g);
}
{
Geo* g = new Sphere(Vector3(10, 0, 30), 2);
g->material = new Material(ballDiffuse, ballSpec, zero);
objects.push_back(g);
}
#endif
Geo* plane = new Plane(Vector3(0, 1, 0), 0);
plane->material = new Material(planeDiffuse, planeSpec, zero);
objects.push_back(plane);
for (Geo* g : objects)
{
if (g->material->emissive.Max3() > 0)
emitters.push_back(g);
}
#endif
}
