示例#1
0
void
initShader(void)
{
  int maxImageUnits;
  loadETC1FragProg();
  const GLsizei vertexShaderLines = sizeof(vertexShaderSource) / sizeof(char*);
  GLuint vertexShader = compileShaderSource(GL_VERTEX_SHADER, vertexShaderLines,
                                            vertexShaderSource);

  const GLsizei fragmentShaderLines =
    sizeof(fragmentShaderSource) / sizeof(char*);
  GLuint fragmentShader = compileShaderSource(
    GL_FRAGMENT_SHADER, fragmentShaderLines, fragmentShaderSource);

  GLuint program = createProgram(vertexShader, fragmentShader);

  checkError("createProgram");

  u_TextureRender = glGetUniformLocation(program, "myt");
  checkError("GetRenderUniform");

  a_Position = glGetAttribLocation(program, "a_Position");
  glEnableVertexAttribArray(a_Position);
  checkError("initRender");

  computeProgramETC1 =
    glCreateShaderProgramv(GL_COMPUTE_SHADER, computeShaderSourceETC1LineCount,
                           (const char**)computeShaderSourceETC1);
  if (!checkProgram(computeProgramETC1, "computeProgramETC1")) {
    exit(1);
  }
  renderProgram = program;
  u_TextureComputeETC1 = glGetUniformLocation(computeProgramETC1, "u_Texture");
  u_OutComputeETC1 = glGetUniformLocation(computeProgramETC1, "u_Output");
  printf(
    "u_TextureRender: %u, u_TextureComputeETC1: %u, u_OutComputeETC1: %u.\n",
    u_TextureRender, u_TextureComputeETC1, u_OutComputeETC1);

  computeProgramS3TC =
    glCreateShaderProgramv(GL_COMPUTE_SHADER, computeShaderSourceS3TCLineCount,
                           (const char**)computeShaderSourceS3TC);
  if (!checkProgram(computeProgramS3TC, "computeProgramS3TC")) {
    exit(1);
  }
  u_TextureComputeS3TC = glGetUniformLocation(computeProgramS3TC, "u_Texture");
  printf("u_TextureComputeS3TC: %u.\n", u_TextureComputeS3TC);

  glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImageUnits);
  printf("maxImageUnits: %d.\n", maxImageUnits);
  checkError("initCompute");
}
示例#2
0
bool createProgram(GLuint & program, GLuint vertexShader, GLuint fragShader, GLuint geometryShader, GLenum inputType, GLenum outputType, int vertOut)
{
    program = glCreateProgram();
    if(vertexShader)
    {
	glAttachShader(program,vertexShader);
    }

    if(fragShader)
    {
	glAttachShader(program,fragShader);
    }

    if(geometryShader)
    {
	glAttachShader(program,geometryShader);
	glProgramParameteriEXT(program, GL_GEOMETRY_INPUT_TYPE_EXT, inputType);
	glProgramParameteriEXT(program, GL_GEOMETRY_OUTPUT_TYPE_EXT, outputType);
	glProgramParameteriEXT(program,GL_GEOMETRY_VERTICES_OUT_EXT,vertOut);
    }

    glLinkProgram(program);

    return checkProgram(program);
}
示例#3
0
static void
linkAndCheck(GLuint program)
{
  GLint programBinaryLength;

  glLinkProgram(program);
  if (!checkProgram(program, "render")) {
    exit(1);
  }
  programBinaryLength = 0;
  glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &programBinaryLength);
  if (programBinaryLength > 0) {
    void* buf;
    GLenum format;
    GLsizei length;
    FILE* file;

    printf("programBinaryLength: %d.\n", programBinaryLength);
    buf = malloc(programBinaryLength);
    glGetProgramBinary(program, programBinaryLength, &length, &format, buf);
    printf("programBinaryFormat: %x.\n", format);
    file = fopen("p_binary.dat", "wb");
    if (file) {
      printf("write binary to p_binary.dat, length: %d.\n", length);
      fwrite(buf, 1, length, file);
      fclose(file);
    }
  }
}
示例#4
0
bool initShaders(const char* vertShaderPath, const char* fragShaderPath)
{
	// create a program before linking shaders
	program = glCreateProgram();
	glUseProgram(program);

	// compile shader sources
	GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
	const char* vertexShaderSource = readShader(vertShaderPath); if (vertexShaderSource == NULL) return false;
	GLint vertexShaderLength = strlen(vertexShaderSource);
	glShaderSource(vertexShader, 1, &vertexShaderSource, &vertexShaderLength);
	glCompileShader(vertexShader);
	if (!checkShader(vertexShader, "vertexShader")){ printf("Unable to compile vertex shader\n"); return false; }
	GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	const char* fragmentShaderSource = readShader(fragShaderPath); if (fragmentShaderSource == NULL) return false;
	GLint fragmentShaderLength = strlen(fragmentShaderSource);
	glShaderSource(fragmentShader, 1, &fragmentShaderSource, &fragmentShaderLength);
	glCompileShader(fragmentShader);
	if (!checkShader(fragmentShader, "fragmentShader")){ printf("Unable to compile fragment shader\n"); return false; }
	// attach vertex/fragments shaders and link program
	glAttachShader(program, vertexShader);
	glAttachShader(program, fragmentShader);
	glLinkProgram(program);
	if (!checkProgram(program, "program")){ printf("Unable to link program\n"); return false; }

	// deallocate string
	free((void*)vertexShaderSource);
	free((void*)fragmentShaderSource);

	return true;
}
示例#5
0
Program::Program(int files, char** fileNames, char *options) {
    program = -1;
    vertexShader = -1;
    fragmentShader = -1;

    const char **contents = (const char**) malloc((files + 2) * sizeof(char*));

    int i;
    for (i = 0; i < files; ++i) {
        contents[i + 2] = readFile(fileNames[i]);
    }

    

    if (program == -1) {
        program = glCreateProgram();
        vertexShader = glCreateShader(GL_VERTEX_SHADER);
        fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
        glAttachShader(program, vertexShader);
        glAttachShader(program, fragmentShader);
        assert(glGetError() == 0);
    }

    contents[0] = "#define _VERTEXSHADER_\n";
    contents[1] = options == NULL ? "" : options;
    glShaderSource(vertexShader, files + 2, contents, NULL);
    glCompileShader(vertexShader);
    checkShader(vertexShader);
    assert(glGetError() == 0);

    contents[0] = "#define _FRAGMENTSHADER_\n";
    glShaderSource(fragmentShader, files + 2, contents, NULL);
    glCompileShader(fragmentShader);
    checkShader(fragmentShader);
    assert(glGetError() == 0);

    for (i = 0; i < files; ++i) {
        free((void*) contents[i + 2]);
    }

    glBindAttribLocation(program, 1, "normal");
    glBindAttribLocation(program, 2, "color");

    glLinkProgram(program);
    GLint logLength;
    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
    if (logLength > 0) {
        char *log = new char[logLength];
        glGetProgramInfoLog(program, logLength, &logLength, log);
        printf("%s", log);
    }

    if (checkProgram(program)) {
        assert(glGetError() == 0);
    } else {
        printShaderLog(vertexShader);
        printShaderLog(fragmentShader);
     //   exit(-1);
    }
}
示例#6
0
struct node *parse(char *program)
{
	struct node *head = NULL;

	checkProgram(program);	// checking syntax of the program
	head = tokenize(program);

	return read_from_list(&head);
}
示例#7
0
void Shader::bind()
{
	string err = checkProgram();

	if (err == "")
	{
		glUseProgram(*program);
		setUniforms();
	}
	else
		LOG << "OpenGL Shader " << err << "\n";
}
示例#8
0
void checkAll()
{
	map<string,vector<ParticipantTask> >::iterator i;
	for (i=participants.begin(); i!=participants.end(); i++)
	{
		addLog("Name "+i->first+" path "+i->second[0].path);
		//int t=i->second[0].taskNumber;
		for (unsigned int j=0; j<i->second.size(); j++)
			checkProgram(i->second[j], i->first);
	};

}
示例#9
0
	unsigned int ShaderManager::createProgram(const std::string &vertexShaderFilename, const std::string &geometryShaderFilename,
			const std::string &fragmentShaderFilename, const std::map<std::string, std::string> &tokens)
	{
		unsigned int programID = glCreateProgram();
		programs.push_back(programID);

		//vertex shader
		const std::string &vertexShaderFileSource = readEntireFile(shadersParentDirectory + shadersDirectoryName + vertexShaderFilename);
		const std::string &vertexShaderSourceStep1 = tokenReplacerShader.replaceTokens(vertexShaderFileSource, tokens);
		const std::string &vertexShaderSource = loopUnrollerShader.unrollLoops(vertexShaderSourceStep1);
		const char *vertexShaderSourceChar = vertexShaderSource.c_str();
		unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
		glShaderSource(vertexShader, 1, &vertexShaderSourceChar, nullptr);
		glCompileShader(vertexShader);
		checkShader(vertexShader, vertexShaderFilename);
		glAttachShader(programID, vertexShader);

		//geometry shader
		if(!geometryShaderFilename.empty())
		{
			const std::string &geometryShaderFileSource = readEntireFile(shadersParentDirectory + shadersDirectoryName + geometryShaderFilename);
			const std::string &geometryShaderSourceStep1 = tokenReplacerShader.replaceTokens(geometryShaderFileSource, tokens);
			const std::string &geometryShaderSource = loopUnrollerShader.unrollLoops(geometryShaderSourceStep1);
			const char *geometryShaderSourceChar = geometryShaderSource.c_str();
			unsigned int geometryShader = glCreateShader(GL_GEOMETRY_SHADER);

			glShaderSource(geometryShader, 1, &geometryShaderSourceChar, nullptr);
			glCompileShader(geometryShader);
			checkShader(geometryShader, geometryShaderFilename);
			glAttachShader(programID, geometryShader);
		}

		//fragment shader
		const std::string &fragmentShaderFileSource = readEntireFile(shadersParentDirectory + shadersDirectoryName + fragmentShaderFilename);
		const std::string &fragmentShaderSourceStep1 = tokenReplacerShader.replaceTokens(fragmentShaderFileSource, tokens);
		const std::string &fragmentShaderSource = loopUnrollerShader.unrollLoops(fragmentShaderSourceStep1);
		const char *fragmentShaderSourceChar = fragmentShaderSource.c_str();
		unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(fragmentShader, 1, &fragmentShaderSourceChar, nullptr);
		glCompileShader(fragmentShader);
		checkShader(fragmentShader, fragmentShaderFilename);
		glAttachShader(programID, fragmentShader);

		//link
		glLinkProgram(programID);
		checkProgram(programID, vertexShaderFilename + ", " + geometryShaderFilename + ", " + fragmentShaderFilename);

		return programID;
	}
示例#10
0
void Shader::loadShaders(std::string s)
{

    GLuint vs = 0, fs = 0, gs = 0, tes = 0, tcs = 0;

    try
    {

        vs = loadShader(GL_VERTEX_SHADER, s);

    } catch_err(Error::ShaderNoFile, Error::ShaderNoVertex)
    try
    {

        fs = loadShader(GL_FRAGMENT_SHADER, s);

    } catch_err(Error::ShaderNoFile, Error::ShaderNoFragment)
    try
    {

        gs = loadShader(GL_GEOMETRY_SHADER, s);

    } catch_ignore(Error::ShaderNoFile)
    try
    {

        tes = loadShader(GL_TESS_EVALUATION_SHADER, s);

    } catch_ignore(Error::ShaderNoFile)
    try
    {

        tcs = loadShader(GL_TESS_CONTROL_SHADER, s);

    } catch_ignore(Error::ShaderNoFile)


    glLinkProgram(program);


    if(vs != 0)
        glDeleteShader(vs);


    if(fs != 0)
        glDeleteShader(fs);


    if(gs != 0)
        glDeleteShader(gs);


    if(tes != 0)
        glDeleteShader(tes);


    if(tcs != 0)
        glDeleteShader(tcs);


    if(!checkProgram(program, GL_LINK_STATUS))
        throw Error::ShaderLinkerError;


    GLuint transBlockIndex = glGetUniformBlockIndex(program, TRANSFORMATION_BLOCK_NAME.c_str());

    if(transBlockIndex != GL_INVALID_INDEX)
        glUniformBlockBinding(program, transBlockIndex, TRANSFORMATION_BLOCK_BINDING_POINT);


    GLuint matBlockIndex = glGetUniformBlockIndex(program, MATERIAL_BLOCK_NAME.c_str());

    if(matBlockIndex != GL_INVALID_INDEX)
        glUniformBlockBinding(program, matBlockIndex, MATERIAL_BLOCK_BINDING_POINT);


    GLint texUnitLoc = glGetUniformLocation(program, "diffuseTex");
    if(texUnitLoc != -1)
        glProgramUniform1i(program, texUnitLoc , 0);


    texUnitLoc = glGetUniformLocation(program, "normalTex");

    if(texUnitLoc != -1)
        glProgramUniform1i(program, texUnitLoc , 1);


    texUnitLoc = glGetUniformLocation(program, "specularTex");

    if(texUnitLoc != -1)
        glProgramUniform1i(program, texUnitLoc , 2);


    texUnitLoc = glGetUniformLocation(program, "environmentTex");

    if(texUnitLoc != -1)
        glProgramUniform1i(program, texUnitLoc , 3);


    texUnitLoc = glGetUniformLocation(program, "shadowTex");

    if(texUnitLoc != -1)
        glProgramUniform1i(program, texUnitLoc , 4);

}
示例#11
0
/**
 * @brief ParticleSystem activate method
 */
bool ParticleSystem::Activate(void) {
  // --------------------------------------------------
  //  Get the path name of the plugin folder, e.g.
  //  "/path/to/oglcore/Plugins/PCVC/ParticleSystem"
  // --------------------------------------------------
  std::string pathName = this->GetCurrentPluginPath();

  // --------------------------------------------------
  //  Initialize manipulator for camera view
  // --------------------------------------------------
  int camHandle = this->AddManipulator("View", &this->viewMX,
                                       Manipulator::MANIPULATOR_ORBIT_VIEW_3D);
  this->SelectCurrentManipulator(camHandle);
  this->SetManipulatorRotation(camHandle, glm::vec3(0, 1, 0), 180.0f);
  this->SetManipulatorRotation(camHandle, glm::vec3(1, 0, 0), 180.0f);
  this->SetManipulatorDolly(camHandle, -1.5f);
  modelMX = glm::scale(glm::translate(glm::mat4(), glm::vec3(0.0f, -0.25f, 0.0f)), glm::vec3(0.5f, 0.5f, 0.5f));

  // --------------------------------------------------
  //  Initialize API variables here
  // --------------------------------------------------
  fovY.Set(this, "FoVy");
  fovY.Register();
  fovY.SetMinMax(5.0f, 90.0f);
  fovY = 45.0f;

  simulationSpeed.Set(this, "simulationSpeed");
  simulationSpeed.Register("step=0.01 min=0.01 max=1.0");
  simulationSpeed = 0.2f;

  num_points.Set(this, "numOfPoints", &OnnumPointsChanged);
  num_points.Register("step=1000 min=1 max=500000");
  num_points = 100000;

  num_instances.Set(this, "num_instances");
  num_instances.Register("step=1 min=1 max=3");
  num_instances = 1;

  pointSize.Set(this, "pointSize");
  pointSize.Register("step=0.1 min=0.1 max=10.0");
  pointSize = 0.1f;

  scale.Set(this, "scale");
  scale.Register("step=0.01 min=0.0 max=2.0");
  scale = 0.5f;

  velocity.Set(this, "velocity", &OnColorChanged);
  velocity.Register();
  velocity = glm::vec3(0.01f, 0.01f, 0.01f);
  targetSpeed = velocity;

  showBox.Set(this, "showBox");
  showBox.Register();
  showBox = true;

  stopMotion.Set(this, "stopMotion");
  stopMotion.Register();
  stopMotion = false;

  EnumPair ep[] = {{0, "None"},{1, "cube"}, {2, "sphere"}, {3, "torus"}, {4, "ef"}, {5, "ef5"}};
  importObject.Set(this, "importObject", ep, 6, &onObjectChanged);
  importObject.Register();

  // --------------------------------------------------
  //  Initialize shaders and VAs
  // --------------------------------------------------
  vsQuad = pathName + std::string("/resources/quad.vert");
  fsQuad = pathName + std::string("/resources/quad.frag");
  shaderQuad.CreateProgramFromFile(vsQuad.c_str(),
                                   fsQuad.c_str());
  vaQuad.Create(4);
  vaQuad.SetArrayBuffer(0, GL_FLOAT, 2, ogl4_2dQuadVerts);

  vsBox = pathName + std::string("/resources/box.vert");
  fsBox = pathName + std::string("/resources/box.frag");
  shaderBox.CreateProgramFromFile(vsBox.c_str(),
                                  fsBox.c_str());

  vsCube = pathName + std::string("/resources/cube.vert");
  gsCube = pathName + std::string("/resources/cube.geom");
  fsCube = pathName + std::string("/resources/cube.frag");
  shaderCube.CreateProgramFromFile( vsCube.c_str(), gsCube.c_str(), fsCube.c_str() );
  createCube();

  vsObject = pathName + std::string("/resources/object.vert");
  gsObject = pathName + std::string("/resources/object.geom");
  fsObject = pathName + std::string("/resources/object.frag");
  shaderObject.CreateProgramFromFile( vsObject.c_str(), fsObject.c_str() );//gsObject.c_str(),

  createTransformProgram(pathName);
  createBox();
  createSphere();
  createTorus();
  createCube();
  createEF(pathName, true);
  createEF(pathName, false);


  if(!checkProgram(pathName, "/resources/ctrlPoints.vert",
                   "/resources/ctrlPoints.frag")){//, "/resources/ctrlPoints.geom"
      std::cout.flush();
      std::cout << "******** shader error ********" <<std::endl;
      exit(0);
  }
  createCtrlPoints();
  vsCtrlPoints = pathName + std::string("/resources/ctrlPoints.vert");
  fsCtrlPoints = pathName + std::string("/resources/ctrlPoints.frag");
  shaderCtrlPoints.CreateProgramFromFile(vsCtrlPoints.c_str(),//gsCtrlPoints.c_str(),
                                         fsCtrlPoints.c_str());


  // --------------------------------------------------
  //  fbo and textures
  // --------------------------------------------------
  initFBO();

  // --------------------------------------------------
  //  random textures
  // --------------------------------------------------
  srand (time(NULL));
  for(int i = 0; i < random_tex_size; i++) {
      for(int j = 0; j < random_tex_size; j++) {
          texdata[4 * (i * random_tex_size + j) + 0] = (static_cast <float> (rand()) / static_cast <float> (RAND_MAX));// - 0.5f;
          texdata[4 * (i * random_tex_size + j) + 1] = (static_cast <float> (rand()) / static_cast <float> (RAND_MAX));// - 0.5f;
          texdata[4 * (i * random_tex_size + j) + 2] = (static_cast <float> (rand()) / static_cast <float> (RAND_MAX));// - 0.5f;
          texdata[4 * (i * random_tex_size + j) + 3] = 1.0f;
      }
  }

  glGenTextures(1, &randomTex);
  glBindTexture(GL_TEXTURE_2D, randomTex);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, random_tex_size, random_tex_size, 0, GL_RGBA, GL_FLOAT, texdata);

  int tex_cube_width = 800;
  int tex_cube_height = 400;
  char *texpathBoard = (pathName + std::string("/resources/textures/board.ppm")).c_str();
  texBoard = LoadPPMTexture(texpathBoard, tex_cube_width, tex_cube_height);

  //target point
  targetPoint= glm::vec3(static_cast <float> (rand()) / static_cast <float> (RAND_MAX),
                         static_cast <float> (rand()) / static_cast <float> (RAND_MAX),
                         static_cast <float> (rand()) / static_cast <float> (RAND_MAX));
  direction = glm::vec3(1.0f,1.0f,1.0f);

  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  glClearDepth(1.0f);
  glEnable(GL_DEPTH_TEST);

  return true;
}