コード例 #1
0
ファイル: main.cpp プロジェクト: Bardo91/GLHL
int main(void){
	WindowGL window("render2texture", 640, 480);
	
	DriverGPU * driver = DriverGPU::get();

	Texture tulipsTex("./Tulips.jpg");

	Shader vShader(eShaderType::eVertexShader, "../../src/shaders/flat.vertex");
	Shader sobelShader(eShaderType::eFragmentShader, "../../src/shaders/sobel.fragment");

	ShaderProgram program;

	program.attachShader(vShader);
	
	program.attachShader(sobelShader);
	program.link();

	#if defined(_WIN32)
	window.peekMessage();
	double t0 = STime::get()->getTime();
	drawImage(tulipsTex, program);
	double t1 = STime::get()->getTime();
	#endif

	std::cout << "Edge detection spent " << t1 - t0 << std::endl;

	window.swapBuffers();

	//	delete window; 	Class has no destructor, undefined behaviour
	delete driver;
	system("PAUSE");
	return 0;
}
コード例 #2
0
ファイル: SceneLoader.cpp プロジェクト: tapio/liblub
void SceneLoader::appendProgram(const QDomElement & programNode) {
    string name, shaderUrl;
    vector<string> flags;
    ShaderProgram * program = new ShaderProgram();

    if (programNode.hasAttribute("name"))
        name = programNode.attribute("name").toStdString();

    QDomElement programInfo = programNode.firstChildElement();
    while (!programInfo.isNull()) {
        if (programInfo.tagName() == "Shader") {
            shaderUrl = programInfo.attribute("url").toStdString();
            if (programInfo.hasAttribute("type")) {
                QString shaderType = programInfo.attribute("type");
                if (shaderType == "VERTEX_SHADER")
                    program->attachShader(shaderUrl, GL_VERTEX_SHADER, false);
                else if (shaderType == "GEOMETRY_SHADER")
                    program->attachShader(shaderUrl, GL_GEOMETRY_SHADER, false);
                else if (shaderType == "FRAGMENT_SHADER")
                    program->attachShader(shaderUrl, GL_FRAGMENT_SHADER, false);
                else if (shaderType == "CONTROL_SHADER")
                    program->attachShader(shaderUrl, GL_TESS_CONTROL_SHADER, false);
                else if (shaderType == "EVALUATION_SHADER")
                    program->attachShader(shaderUrl, GL_TESS_EVALUATION_SHADER, false);
            } else {
                if (programInfo.hasAttribute("flags")) {
                    flags
                            = splitValues<string> (programInfo.attribute(
                                    "flags"));
                    program->attachVertFrag(shaderUrl, flags);
                } else {
                    program->attachVertFrag(shaderUrl, false);
                }
            }
        } else if (programInfo.tagName() == "Template") {
          shaderUrl = programInfo.attribute("url").toStdString();
          program->attachVertFrag(shaderUrl, true);
        } else if (programInfo.tagName() == "Uniform") {
            program->uniforms.push_back(Uniform<float> (programInfo.attribute(
                    "name").toStdString(), splitValues<float> (
                    programInfo.attribute("value"))));
        } else if (programInfo.tagName() == "Uniformi") {
            program->uniformsi.push_back(Uniform<int> (programInfo.attribute(
                    "name").toStdString(), splitValues<int> (
                    programInfo.attribute("value"))));
        }
        programInfo = programInfo.nextSiblingElement();
    }

    QList<string> attributes;
    attributes.push_back("uv");
    attributes.push_back("normal");
    attributes.push_back("tangent");

    program->init(attributes);
    program->name = name;
    SceneData::Instance().shaderPrograms.insert(name, program);
}
コード例 #3
0
ファイル: main.cpp プロジェクト: Bardo91/GLHL
int main(void){
	WindowGL window("Texture loader", 640, 480);
	
	DriverGPU * driver = DriverGPU::get();

	Shader vShader(eShaderType::eVertexShader, "../../src/shaders/flat.vertex");
	Shader fShader(eShaderType::eFragmentShader, "../../src/shaders/flat.fragment");

	ShaderProgram program;

	program.attachShader(vShader);
	program.attachShader(fShader);
	program.link();

	bool condition = true;
	do{	
		#if defined(_WIN32)
		window.peekMessage();
		drawImage(program);
		#endif
		window.swapBuffers();
		
	} while (condition);


	window.hide();

	#ifdef _WIN32
	system("PAUSE");
	#endif
	//	delete window; 	Class has no destructor, undefined behaviour
	delete driver;

	return 0;
}
コード例 #4
0
ファイル: main.cpp プロジェクト: Bardo91/GLHL
void openGLThread(bool _draw, GLfloat _red) {
    //WindowGL * window = WindowGL::createWindow(640, 480);

    Context context;

    DriverGPU *driver = DriverGPU::get();

    Shader vShader(eShaderType::eVertexShader, "../../src/shaders/vTriangleShader.vertex");
    Shader fShader(eShaderType::eFragmentShader, "../../src/shaders/fTriangleShader.fragment");


    ShaderProgram sProgram;
    sProgram.attachShader(vShader);
    sProgram.attachShader(fShader);
    sProgram.bindAttribute(0, "vPosition");

    sProgram.link();

    while(running) {
        //window->peekMessage();
        //window->swapBuffers();
        //if (_draw)
        //	drawOnBuffer(640, 480, sProgram, _red);
    }

    delete driver;
}
コード例 #5
0
	ShaderManager::ShaderProgram* ShaderManager::makeShaderProgram(const char* programName, const char* vertexShaderFile, const char* fragmentShaderFile){
		//Create the shaders with filename as name
		Shader* vsShader = makeShader(vertexShaderFile, Vertex, vertexShaderFile);
		Shader* fsShader = makeShader(fragmentShaderFile, Fragment, fragmentShaderFile);
		
		if( vsShader == 0 || fsShader == 0 ) return 0;
		
		ShaderProgram* newProgram = new ShaderProgram();
		shaderPrograms.insert(ShaderProgramContainer::value_type(programName, newProgram));
		newProgram->attachShader(vsShader);
		newProgram->attachShader(fsShader);
        
        return newProgram;
	}
コード例 #6
0
int main(int argc, char** argv){
    
    int width = 800;
    int height = 600;
    bool fullscreen = false;

    // Device must be the very first thing created!
    Device device(width, height, fullscreen);

    //Default parameters
    
    MeshType meshType = TETRAHEDRON;
    // If meshType is MESH_FILE, load file from mesh stored in meshFile
    char* meshFile = NULL;
    
    // If true, run in visual mode. In this, all calculations are done on the GPU.
    // Otherwise, you get a pretty boring CSV outputted. Activate with -v
    bool visualization = false;
    
    // Number of times the shape is bisected (any number for tetrahedra, preset numbers for
    // icosahedra, and it means nothing for other meshes). Set with -n=##
    int idealTriangleCount = 400;
    
    // Times Update is called if running in non visual mode. Set with -i=##
    int iterations = 10;
    
    // If true, use the GPU for calculations. Else, use the CPU. Set with -cpu
    bool gpu = true;
    
    //Type of stuff to output, set with -o
    OutputType output[8];
    int outputLength = 0;
    
    // scale of the visualization, set with -s=##
    int scale = 5;

    // if timing is true, activate with -t
    bool timing = false;

    // Parse Command Line Arguments:
    for(int i=1;i<argc;i++){
        if(argMatch(argv[i], "-v")){
            visualization = true;
        }else if(argMatch(argv[i], "--help")){
            help();
            return 0;
        }else if(argMatch(argv[i], "-n=")){
            idealTriangleCount = atoi(argv[i]+3);
        }else if(argMatch(argv[i], "-i=")){
            iterations = atoi(argv[i]+3);
        }else if(argMatch(argv[i], "-iterations=")){
            iterations = atoi(argv[i]+12);
        }else if(argMatch(argv[i], "-m")){
            i++;
            if(argMatch(argv[i], "tetra")){
                meshType = TETRAHEDRON;
            }else if(argMatch(argv[i], "icosa")){
                meshType = ICOSAHEDRON;
            }else if(argMatch(argv[i], "jeep")){
                meshType = MESH_FILE;
                meshFile = "models/jeep.mtl";
            }else if(argMatch(argv[i], "dragon")){
                meshType = MESH_FILE;
                meshFile = "models/dragon.ply";
            }else{
                meshType = MESH_FILE;
                meshFile = argv[i];
            }
        }else if(argMatch(argv[i], "-cpu")){
            gpu = false;
		}
		else if (argMatch(argv[i], "-s=")){
			scale = atoi(argv[i] + 3);
		}
		else if (argMatch(argv[i], "-t")){
			timing = true;
		}
		else if (argMatch(argv[i], "-o")){
            do{
                i++;
                if(argMatch(argv[i], "SurfaceArea")){
                    output[outputLength++] = TOTAL_SURFACE_AREA;
                }else if(argMatch(argv[i], "Volume")){
                    output[outputLength++] = TOTAL_VOLUME;
                }else if(argMatch(argv[i], "MeanNetForce")){
                    output[outputLength++] = MEAN_NET_FORCE;
                }else if(argMatch(argv[i], "Curvature")){
                    output[outputLength++] = MEAN_CURVATURE;
                }else if(argMatch(argv[i], "AreaForces")){
                    output[outputLength++] = AREA_FORCES;
                }else if(argMatch(argv[i], "VolumeForces")){
                    output[outputLength++] = VOLUME_FORCES;
                }else if(argMatch(argv[i], "NetForces")){
                    output[outputLength++] = NET_FORCES;
                }else if(argMatch(argv[i], "Points")){
                    output[outputLength++] = POINTS;
                }
            } while(lastChar(argv[i]) == ',');
        }
    }
    
    Mesh* mesh;
    
    switch(meshType){
        case TETRAHEDRON:
            mesh = new TetrahedronMesh(ceil(sqrt(idealTriangleCount/4.0)));
            break;
        case ICOSAHEDRON:
            if(idealTriangleCount <= 100){
                meshFile = "models/icosa1.obj";
            }else if(idealTriangleCount <= 1000){
                meshFile = "models/icosa2.obj";
            }else if(idealTriangleCount <= 10000){
                meshFile = "models/icosa3.obj";
            }else if(idealTriangleCount <= 100000){
                meshFile = "models/icosa4.obj";
            }else{
                meshFile = "models/icosa5.obj";
            }
            mesh = new ExternalMesh(meshFile);
            break;
        default:
            mesh = new ExternalMesh(meshFile);
            break;
    }
    
    // visualization only applies to GPU calculation, so:
    if(visualization){
        
    
        SceneManager manager(&device);
        CameraNode camera(&device, width, height);
        camera.getTransform().setTranslation(20.0f, 20.0f, 20.0f);
        manager.addNode(&camera);

        ModelNode mn;
        //mn.getTransform().setScale(0.025f, 0.025f, 0.025f);
        mn.getTransform().setScale(scale, scale, scale);
        mn.getTransform().setTranslation(0.0f, 0.0f, 0.0f);
        mn.setMesh(mesh);
        manager.addNode(&mn);

        ShaderProgram geometryProgram;
        Shader geometryVertexShader("shaders/geometry_pass.vert", VERTEX);
        Shader geometryFragShader("shaders/geometry_pass.frag", FRAGMENT);
        geometryProgram.attachShader(&geometryVertexShader);
        geometryProgram.attachShader(&geometryFragShader);
        geometryProgram.link();
        manager.setGeometryProgram(&geometryProgram);

        GPUEvolver evolver(mesh, 10);

        while (device.run()) {
            evolver.update();
            evolver.synchronizeToMesh();
            manager.drawAll();
            device.endScene();
        }
    } else {
        if (gpu) {
            GPUEvolver evolver(mesh, 10);
            evolver.setOutputFormat(output, outputLength);
            std::clock_t    start;

            start = std::clock();
                        
            for(int i=0; i < iterations; i++){
                evolver.update();
                evolver.outputData();
            }
            if (timing){
                std::cout << "Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000) << " ms" << std::endl;
            }
        } else {
            CPUEvolver evolver(mesh, 10);
            evolver.setOutputFormat(output, outputLength);
            std::clock_t    start;

            start = std::clock();
            for(int i=0; i < iterations; i++){
                evolver.update();
                evolver.outputData();
            }
            if (timing){
                std::cout << "Time: " << (std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000) << " ms" << std::endl;
            }
        }
    }
    return 0;
}
コード例 #7
0
ファイル: SceneLoader.cpp プロジェクト: lubosz/liblub
void SceneLoader::appendProgram(const QDomElement & programNode) {
    string name, shaderUrl;
    vector<string> flags;
    QList<string> attributes = QList<string>() << "uv" << "normal" << "tangent" << "bitangent";

    if (programNode.hasAttribute("name"))
        name = programNode.attribute("name").toStdString();

    ShaderProgram * program = new ShaderProgram(name);

    QDomElement programInfo = programNode.firstChildElement();
    while (!programInfo.isNull()) {
        if (programInfo.tagName() == "Shader") {
            shaderUrl = programInfo.attribute("url").toStdString();
            if (programInfo.hasAttribute("flags")) {
                flags = splitValues<string> (programInfo.attribute("flags"));
                TemplateEngine::Instance().addFlags(flags);
            }
            if (programInfo.hasAttribute("type")) {
                QString shaderType = programInfo.attribute("type");
                if (shaderType == "VERTEX_SHADER")
                    program->attachShader(shaderUrl, GL_VERTEX_SHADER);
                else if (shaderType == "GEOMETRY_SHADER")
                    program->attachShader(shaderUrl, GL_GEOMETRY_SHADER);
                else if (shaderType == "FRAGMENT_SHADER")
                    program->attachShader(shaderUrl, GL_FRAGMENT_SHADER);
                else if (shaderType == "CONTROL_SHADER")
                    program->attachShader(shaderUrl, GL_TESS_CONTROL_SHADER);
                else if (shaderType == "EVALUATION_SHADER")
                    program->attachShader(shaderUrl, GL_TESS_EVALUATION_SHADER);
            } else {
                program->attachVertFrag(shaderUrl);
            }
        } else if (programInfo.tagName() == "Uniform") {
            program->uniforms.push_back(Uniform<float> (programInfo.attribute(
                    "name").toStdString(), splitValues<float> (
                    programInfo.attribute("value"))));
        } else if (programInfo.tagName() == "Uniformi") {
            program->uniformsi.push_back(Uniform<int> (programInfo.attribute(
                    "name").toStdString(), splitValues<int> (
                    programInfo.attribute("value"))));
        } else if (programInfo.tagName() == "Layer") {
            if (programInfo.hasAttribute("texture")) {
                Texture * texture = Scene::Instance().textures.value(
                        programInfo.attribute("texture").toStdString());
                if (Scene::Instance().textures.count(programInfo.attribute("texture").toStdString()) == 0)
                          LogError << "Texture "
                                    << programInfo.attribute("texture").toStdString()
                                    << " not found.";
                // TODO(bmonkey): uniform name reset
                LogDebug << programInfo.attribute("sampler").toStdString();
                texture->name = programInfo.attribute("sampler").toStdString();
                program->addTexture(texture);
            }
        }
        programInfo = programInfo.nextSiblingElement();
    }

    program->init(attributes);
    program->samplerUniforms();
    Scene::Instance().shaders.insert(name, program);
}
コード例 #8
0
ファイル: main.cpp プロジェクト: WendyHanzer/4s
int main(int argc, char** argv)
{
	--argc;
	++argv;
	
	const int WIDTH = 800;
	const int HEIGHT = 600;

	/*
	*	Create window
	*/
	sf::RenderWindow window(sf::VideoMode(WIDTH, HEIGHT), "Window", sf::Style::Default, sf::ContextSettings(32));
	
	/*
	*	Initialize GLEW
	*/
	GLenum status = glewInit();
	if(status != GLEW_OK)
	{
		std::cerr << "[F] GLEW NOT INITIALIZED: ";
		std::cerr << glewGetErrorString(status) << std::endl;
	
		window.close();
	
		return -1;
	}

	/*
	*	Create GUI
	*/
	tgui::Gui gui(window);
	tgui::Gui gui2(window);
	gui.setGlobalFont("fonts/DejaVuSans.ttf");
	loadWidgets(gui, gui2, window);
	
	char* args[argc + 1];
	
	/*
	*	load geometry
	*/
	Model cube;
	getArgs(argc, argv, ".obj", args);
	
	if (!args[0])
	{
		std::cerr << "[F] MUST SUPPLY 1+ OBJ FILES IN COMMAND LINE ARGS <filename.obj>" << std::endl;
		exit(-1);
	} //if
	
	loadGeometry(cube, args[0]);
	
	getArgs(argc, argv, ".scale", args);
	if (args[0])
	{
		cube.scale = glm::vec3(strtof(args[0], NULL));
	} //if
	else
	{
		cube.scale = glm::vec3(1.0f);
	} //else
	
	/*
	*	load shader
	*/
	Shader vertexShader(GL_VERTEX_SHADER);
	getArgs(argc, argv, ".vs", args);
	vertexShader.loadFromFile(args[0]? args[0] : ".vs");
	vertexShader.compile();
	
	Shader fragmentShader(GL_FRAGMENT_SHADER);
	getArgs(argc, argv, ".fs", args);
	fragmentShader.loadFromFile(args[0]? args[0] : ".fs");
	fragmentShader.compile();
	
	/*
	*	create program
	*/
	ShaderProgram program;
	
	program.attachShader(vertexShader);
	program.attachShader(fragmentShader);
	program.linkProgram();
	
	program.attachShader(vertexShader);
	program.attachShader(fragmentShader);
	program.linkProgram();
	
	glEnable(GL_DEPTH_TEST);
	glDepthMask(GL_TRUE);
	glClearDepth(1.f);

	Camera camera;
	
	sf::Event event;
	tgui::Callback callback;
	
	Planet p(&cube);
	
	/*
	*	main loop
	*/
	while (window.isOpen())
	{
		while (window.pollEvent(event))
		{
			switch (event.type)
			{
				case sf::Event::Closed:
					window.close();
				
					break;
				case sf::Event::Resized:
					glViewport(0, 0, event.size.width, event.size.height);
					camera.projection = glm::perspective(45.0f, float(event.size.width)/float(event.size.height), 0.01f, 100.0f);
					
					break;
				case sf::Event::KeyPressed:
					switch(event.key.code)
					{
						case sf::Keyboard::Escape:
							window.close();
							exit(0);
							
							break;
						default:
							break;
					} //switch
					
					break;
				default:
					break;
			} //switch
			
			gui.handleEvent(event);
		} //if
		
		while (gui.pollCallback(callback))
		{
			gui.handleEvent(event);
		} //if
		
		window.clear();
		guiDraw(window, gui2);
		glClear(GL_DEPTH_BUFFER_BIT); 
		
		/*
		*	render OpenGL here
		*/
		for (Planet* planet : planets)
		{
			render(*planet, camera, program);
		} //for
		
		guiDraw(window, gui);
		
		window.display();
	} //while

	// Clean up after ourselves
	if (window.isOpen())
	{
		window.close();
	} //if
	
	return EXIT_SUCCESS;
} //main
コード例 #9
0
ファイル: Appaction.cpp プロジェクト: wusidn/work
void engine_portal_init(void)
{
	glClearColor(0.1f, 0.2f, 0.3f, 1.0f);

	const GLfloat vertices[6][2] =
	{
		{ -0.50,  -0.50 },
		{ 0.50,   -0.50 },
		{ 0.50,   0.50 },
		{ -0.50,  0.50 }
	};

	const GLfloat colors[] = {
		1.0, 0.0, 0.0, 1.0,
		0.0, 1.0, 0.0, 1.0,
		0.0, 0.0, 1.0, 1.0,
		1.0, 1.0, 0.0, 1.0,
	};



	const GLushort vertex_indies[] = {
		0, 1, 2, 0, 2, 3
	};


	glGenBuffers(1, &indiesBufferObject);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indiesBufferObject);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(vertex_indies), vertex_indies, GL_STATIC_DRAW);

	glGenVertexArrays(1, &vertexArrayObject);
	glBindVertexArray(vertexArrayObject);

	glGenBuffers(1, &vertexBufferObject);
	glBindBuffer(GL_ARRAY_BUFFER, vertexBufferObject);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices) + sizeof(colors), nullptr, GL_STATIC_DRAW);


	glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
	glBufferSubData(GL_ARRAY_BUFFER, sizeof(vertices), sizeof(colors), colors);


	ShaderElement * shaderVert = ShaderElement::createWithShaderCode(GL_VERTEX_SHADER, File::readAllText("../Shader/triangles.vert"));
	if (!shaderVert->compile()) {
		cout << shaderVert->getError() << endl;
		cout << "Vertex Shader Compile Error" << endl;
	}

	ShaderElement * shaderFrag = ShaderElement::createWithShaderCode(GL_FRAGMENT_SHADER, File::readAllText("../Shader/triangles.frag"));
	if (!shaderFrag->compile()) {
		cout << "Fragment Shader Compile Error" << endl;
	}

	ShaderProgram * shaderProgram = ShaderProgram::create();
	shaderProgram->attachShader(*shaderVert);
	shaderProgram->attachShader(*shaderFrag);

	if (!shaderProgram->linkProgram()) {
		cout << "ShaderProgram Linking Error" << endl;
	}

	GLint uboSize;
	GLuint uboIndex = glGetUniformBlockIndex(shaderProgram->programId(), "Uniforms");
	GLvoid * uboData;
	GLuint ubo;
	if (uboIndex == GL_INVALID_INDEX) {
		cout << "Uniforms Is Not Uniform Block Name" << endl;
	}

	glGetActiveUniformBlockiv(shaderProgram->programId(), uboIndex, GL_UNIFORM_BLOCK_DATA_SIZE, &uboSize);
	uboData = (GLvoid *)malloc(uboSize);
	if (uboData == nullptr) {
		cout << "uboData Malloc Error" << endl;
	}

	enum { vTranslation, vRotation, vScale, numUniforms };

	const char* uniformsNames[numUniforms] = {
			"vTranslation",
			"vRotation",
			"vScale"
	};

	GLuint indices[numUniforms];
	GLint sizes[numUniforms];
	GLint offsets[numUniforms];
	GLint types[numUniforms];

	glGetUniformIndices(shaderProgram->programId(), numUniforms, uniformsNames, indices);

	glGetActiveUniformsiv(shaderProgram->programId(), numUniforms, indices, GL_UNIFORM_SIZE, sizes);
	glGetActiveUniformsiv(shaderProgram->programId(), numUniforms, indices, GL_UNIFORM_OFFSET, offsets);
	glGetActiveUniformsiv(shaderProgram->programId(), numUniforms, indices, GL_UNIFORM_TYPE, types);

	//data
	GLfloat translation[3] = { 0.3f, 0.3f, 0.0f};
	GLfloat rotation[3] = { 0.0f, 0.0f, 90.0f};
	GLfloat scale[3] = { 0.5f, 0.8f, 0.0f};

	memcpy((void *)((GLint)uboData + offsets[vTranslation]), translation, sizes[vTranslation] * ShaderProgram::TypeSize(types[vTranslation]));
	memcpy((void *)((GLint)uboData + offsets[vRotation]), rotation, sizes[vRotation] * ShaderProgram::TypeSize(types[vRotation]));
	memcpy((void *)((GLint)uboData + offsets[vScale]), scale, sizes[vScale] * ShaderProgram::TypeSize(types[vScale]));


	glGenBuffers(1, &ubo);
	glBindBuffer(GL_UNIFORM_BUFFER, ubo);
	glBufferData(GL_UNIFORM_BUFFER, uboSize, uboData, GL_STATIC_DRAW);
	glBindBufferBase(GL_UNIFORM_BUFFER, uboIndex, ubo);


	glUseProgram(shaderProgram->programId());

	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
	glEnableVertexAttribArray(0);

	glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, (const void *)sizeof(vertices));
	glEnableVertexAttribArray(1);

}