Esempio n. 1
0
void EdvsRiftApp::drawSphereBackground(int camera_id)
{
    static ProgramPtr program = oria::loadProgram("./resources/sphere_background.vs", "./resources/sphere_background.fs");
    static ShapeWrapperPtr geometry = ShapeWrapperPtr(new shapes::ShapeWrapper({ "Position" }, shapes::ObjMesh(mesh_input.stream), *program));

    // Reset before application exit
    Platform::addShutdownHook([]
    {
        program.reset();
        geometry.reset();
    });


    MatrixStack & mv = Stacks::modelview();

    mv.withPush([&]
    {
        // Binds the program
        program->Use();

        // Matrices as uniforms
        Mat4Uniform(*program, "ModelView").Set(Stacks::modelview().top());
        Mat4Uniform(*program, "Projection").Set(Stacks::projection().top());

        // Draw this
        geometry->Use();
        geometry->Draw();
    });

    // Unbind
    oglplus::NoProgram().Bind();
    oglplus::NoVertexArray().Bind();
}
Esempio n. 2
0
void GlUtils::draw3dGrid() {
  using namespace gl;

  GL_CHECK_ERROR;
  static GeometryPtr g;
  if (!g) {
    Mesh m;
    for (int i = 0; i < 5; ++i) {
      float offset = ((float) i * 0.2f) + 0.2f;
      glm::vec3 zOffset(0, 0, offset);
      glm::vec3 xOffset(offset, 0, 0);
      m.addVertex(-X_AXIS + zOffset);
      m.addVertex(X_AXIS + zOffset);
      m.addVertex(-X_AXIS - zOffset);
      m.addVertex(X_AXIS - zOffset);
      m.addVertex(-Z_AXIS + xOffset);
      m.addVertex(Z_AXIS + xOffset);
      m.addVertex(-Z_AXIS - xOffset);
      m.addVertex(Z_AXIS - xOffset);
    }
    m.addVertex(X_AXIS);
    m.addVertex(-X_AXIS);
    m.addVertex(Z_AXIS);
    m.addVertex(-Z_AXIS);
    g = m.getGeometry(GL_LINES);
  }
  ProgramPtr program = getProgram(Resource::SHADERS_SIMPLE_VS, Resource::SHADERS_COLORED_FS);
  GL_CHECK_ERROR;
  program->use();
  GL_CHECK_ERROR;
  program->setUniform("Color", glm::vec4(Colors::gray,1));
  GL_CHECK_ERROR;
  renderGeometry(g, program);
  GL_CHECK_ERROR;
}
Esempio n. 3
0
 Shader::~Shader()
 {
   if (m_shader) {
     ProgramPtr prog = program();
     if (prog) prog->removeShader(shared_from_this());
     glDeleteShader(m_shader);
   }
 }
Esempio n. 4
0
int main(int argc, char **argv)
{
    if (argc == 1)
    {
        curr_filename = "<stdin>";
        yyin = stdin;
        yyparse();
    }
    else
    {
        for (int i = 1; i < argc; ++i)
        {
            curr_filename = argv[i];
            yyin = std::fopen(argv[i], "r");

            if (yyin)
            {
                yyparse();
                std::fclose(yyin);
            }
            else
            {
                utility::print_error(argv[i], "cannot be opened");
            }
        }
    }

    if (yynerrs > 0)
    {
        std::cerr << "Compilation halted due to lexical or syntax errors.\n";
        exit(1);
    }
    
    SemanticAnalyzer semant;
    semant.install_basic(ast_root);
    if (!semant.validate_inheritance(ast_root->classes))
    {
        std::cerr << "Compilation halted due to inheritance errors.\n";
        exit(1);
    }

    if (!semant.type_check(ast_root))
    {
        std::cerr << "Compilation halted due to type errors.\n";
        exit(1);
    }

    AstNodeDisplayer print(std::cout, AstNodeDisplayer::DISPLAYNONBASIC);
    ast_root->accept(print);

    std::ofstream out("output.s");
    AstNodeCodeGenerator codegen(semant.get_inherit_graph(), out);
    ast_root->accept(codegen);

    return 0;
}
Esempio n. 5
0
void GlUtils::renderBunny() {
  static GeometryPtr bunnyGeometry =
      getMesh(Resource::MESHES_BUNNY2_CTM).getGeometry();
  ProgramPtr program = GlUtils::getProgram(
      Resource::SHADERS_LITCOLORED_VS,
      Resource::SHADERS_LITCOLORED_FS);
  program->use();
  program->setUniform("Color", glm::vec4(1));
  renderGeometry(bunnyGeometry, program);
}
Esempio n. 6
0
 bool Shader::loadSrc(const QString& data)
 {
   if (m_src != data) {
     m_src = data;
     m_needCompile = true;
     // Tell the program object, that it needs to recompile stuff
     ProgramPtr p = m_prog.lock();
     if (p) p->setIsCompiled(false);
     return true;
   }
   return false;
 }
Esempio n. 7
0
void GlUtils::draw3dVector(glm::vec3 vec, const glm::vec3 & col) {
  Mesh m;
  m.color = Colors::gray;

  m.addVertex(glm::vec3());
  m.addVertex(glm::vec3(vec.x, 0, vec.z));

  m.addVertex(glm::vec3(vec.x, 0, vec.z));
  m.addVertex(vec);

  m.fillColors(true);
  m.color = col;
  m.addVertex(vec);
  m.addVertex(glm::vec3());

  m.fillColors();
  static GeometryPtr g = m.getGeometry(GL_LINES);
  g->updateVertices(m.buildVertices());

  ProgramPtr program = getProgram(
      Resource::SHADERS_COLORED_VS,
      Resource::SHADERS_COLORED_FS);
  program->use();
  renderGeometry(g, program);
  gl::Program::clear();


//  lineWidth(1.0f);
//  float len = glm::length(vec);
//  if (len > 1.0f) {
//    vec /= len;
//  }
//  gl::Program::clear();
//
//  glLineWidth(2.0f + len);
//  glBegin(GL_LINES);
//  gl::color(col);
//  gl::vertex();
//  gl::vertex();
//  glEnd();
//
//  glLineWidth(1.0f);
//  glBegin(GL_LINE_STRIP);
//  gl::color(Colors::gray);
//  gl::vertex(glm::vec3());
//  gl::vertex(glm::vec3(vec.x, 0, vec.z));
//  gl::vertex(vec);
//  glEnd();
}
Esempio n. 8
0
	ProgramPtr Program::remEntryPoints(NodeManager& manager, const ProgramPtr& program, const ExpressionList& entryPoints) {
		ExpressionList list;
		for_each(program->getEntryPoints(), [&list, &entryPoints](const ExpressionPtr& cur) {
			if(!contains(entryPoints, cur, equal_target<ExpressionPtr>())) { list.push_back(cur); }
		});
		return manager.get(Program(list));
	}
Esempio n. 9
0
 void State::useProgram(ProgramPtr prog)
 {
   if (prog)
     glRun(glUseProgram(prog->id()));
   else
     glRun(glUseProgram(0));
   m_data.back().m_prog = prog;
 }
Esempio n. 10
0
 ShaderPtr Shader::clone(ProgramPtr prog) const
 {
   ShaderPtr s(new Shader(prog, m_type));
   s->setFilename(rawFilename());
   s->m_src = m_src;
   s->m_needCompile = true;
   if (prog) prog->setIsCompiled(false);
   return s;
 }
Esempio n. 11
0
	bool dumpTo(const ProgramPtr& program, const std::string& dir) {
		// first of all, we want to dump the callgraph
		auto callgraph = analysis::callgraph::getCallGraph(program);
		if (!dumpTo(dir + "/callgraph.dot", toString(callgraph))) return false;
		// finally, generate a file for each function
		for (const auto& fun : program->getFunctions()) {
			if (!dumpTo(dir + "/" + analysis::callgraph::getFunctionName(fun) + ".dot", toString(*fun))) return false;
		}
		return true;
	}
Esempio n. 12
0
void GlUtils::drawAngleTicks() {
  using namespace gl;
  static GeometryPtr g;
  if (!g) {
    float offsets[] = { //
      (float) tan( PI / 6.0f), // 30 degrees
      (float) tan( PI / 4.0f), // 45 degrees
      (float) tan( PI / 3.0f) // 60 degrees
    };
    Mesh m;
    // 43.9 degrees puts tick on the inner edge of the screen
    // 42.6 degrees is the effective fov for wide screen
    // 43.9 degrees puts tick on the inner edge of the screen
    m.addVertex(glm::vec3(-2, 0, 0));
    m.addVertex(glm::vec3(2, 0, 0));
    m.addVertex(glm::vec3(0, -2, 0));
    m.addVertex(glm::vec3(0, 2, 0));
    // By keeping the camera locked at 1 unit away from the origin, all our
    // distances can be computed as tan(angle)
    for (float offset : offsets) {
      m.addVertex(glm::vec3(offset, -0.05, 0));
      m.addVertex(glm::vec3(offset, 0.05, 0));
      m.addVertex(glm::vec3(-offset, -0.05, 0));
      m.addVertex(glm::vec3(-offset, 0.05, 0));
    }
    for (float offset : offsets) {
      m.addVertex(glm::vec3(-0.05, offset, 0));
      m.addVertex(glm::vec3(0.05, offset, 0));
      m.addVertex(glm::vec3(-0.05, -offset, 0));
      m.addVertex(glm::vec3(0.05, -offset, 0));
    }
    g = m.getGeometry(GL_LINES);
  }

  // Fix the modelview at exactly 1 unit away from the origin, no rotation
  gl::Stacks::modelview().push(glm::mat4(1)).translate(glm::vec3(0, 0, -1));
  ProgramPtr program = getProgram(Resource::SHADERS_SIMPLE_VS, Resource::SHADERS_COLORED_FS);
  program->use();
  renderGeometry(g, program);
  gl::Stacks::modelview().pop();
}
Esempio n. 13
0
void
UniformGroup::apply_subroutines(ProgramPtr prog, GLenum shadertype,
                                const std::unordered_map<std::string, std::string>& subroutines)
{
  assert_gl("apply_subroutines:enter");
  GLint num_uniform_locations;
  glGetProgramStageiv(prog->get_id(), shadertype, GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS, &num_uniform_locations);

  std::vector<GLuint> subroutine_mappings;
  for(int i = 0; i < num_uniform_locations; ++i)
  {
    char name[256];
    GLsizei length;
    glGetActiveSubroutineUniformName(prog->get_id(), shadertype, i, sizeof(name), &length, name);

    const auto& it = subroutines.find(name);
    if (it == subroutines.end())
    {
      log_error("unmapped subroutine: %s", name);
    }
    else
    {
      GLuint loc = glGetSubroutineIndex(prog->get_id(), shadertype, it->second.c_str());
      if (loc == GL_INVALID_INDEX)
      {
        log_error("unknown subroutine: %s", it->second);
      }
      else
      {
        subroutine_mappings.emplace_back(loc);
      }
    }
  }

  glUniformSubroutinesuiv(shadertype, subroutine_mappings.size(), subroutine_mappings.data());

  assert_gl("apply_subroutines:exit");
}
Esempio n. 14
0
bool Parser::parse(const wchar_t* code, const ProgramPtr& program)
{
    tokenizer->set(code);
    try
    {
        Token token;
        while(peek(token))
        {
            StatementPtr statement = parseStatement();
            if(!statement)
                break;
            program->addStatement(statement);
            match(L";");
        }
    }
    catch(...)
    {
        return false;
    }
    return true;
}
Esempio n. 15
0
void
Uniform<UniformSymbol>::apply(ProgramPtr prog, const RenderContext& ctx)
{
  assert_gl("Uniform<UniformSymbol>::apply:enter");
  switch(m_value)
  {
    case UniformSymbol::NormalMatrix:
      prog->set_uniform(m_name, glm::mat3(ctx.get_view_matrix() * ctx.get_model_matrix()));
      break;

    case UniformSymbol::ViewMatrix:
      prog->set_uniform(m_name, ctx.get_view_matrix());
      break;

    case UniformSymbol::ModelMatrix:
      prog->set_uniform(m_name, ctx.get_model_matrix());
      break;

    case UniformSymbol::ModelViewMatrix:
      prog->set_uniform(m_name, ctx.get_view_matrix() * ctx.get_model_matrix());
      break;

    case UniformSymbol::ProjectionMatrix:
      prog->set_uniform(m_name, ctx.get_projection_matrix());
      break;

    case UniformSymbol::ModelViewProjectionMatrix:
      prog->set_uniform(m_name, ctx.get_projection_matrix() * ctx.get_view_matrix() * ctx.get_model_matrix());
      break;

    default:
      log_error("unknown UniformSymbol %d", static_cast<int>(m_value));
      break;
  }
  assert_gl("Uniform<UniformSymbol>::apply:exit");
}
Esempio n. 16
0
 /** Bind a program
     Program have bindings globalVar->parameter
 */
 void GLEngine::setProgram(ProgramPtr program)
 {
     if(mCurrentProgram.get() == program.get())
         return;
     mCurrentProgram = program;
 }
Esempio n. 17
0
 void apply(ProgramPtr prog, const RenderContext& ctx)
 {
     prog->set_uniform(m_name, m_value);
 }
Esempio n. 18
0
void GlUtils::renderArtificialHorizon(float alpha) {
  static GeometryPtr geometry;
  if (!geometry) {
    Mesh mesh;
    MatrixStack & m = mesh.getModel();

    m.push();
    {
      m.top() = glm::translate(glm::mat4(), glm::vec3(0, 0, 1.01));
      mesh.getColor() = Colors::yellow;
      mesh.addQuad(0.5, 0.05f);
      mesh.fillColors(true);
      mesh.getColor() = Colors::lightGray;
      glm::vec2 bar(0.5, 0.025);
      glm::vec2 smallBar(0.3, 0.015);
      for (int i = 1; i <= 4; ++i) {
        float angle = i * (TAU / 18.0f);
        m.identity().rotate(angle, GlUtils::X_AXIS).translate(
            GlUtils::Z_AXIS);
        mesh.addQuad(bar);
        m.identity().rotate(HALF_TAU, GlUtils::Y_AXIS).rotate(angle,
            GlUtils::X_AXIS).translate(GlUtils::Z_AXIS);
        mesh.addQuad(bar);
        m.identity().rotate(HALF_TAU, GlUtils::Z_AXIS).rotate(angle,
            GlUtils::X_AXIS).translate(GlUtils::Z_AXIS);
        mesh.addQuad(bar);
        m.identity().rotate(HALF_TAU, GlUtils::Z_AXIS).rotate(HALF_TAU,
            GlUtils::Y_AXIS).rotate(angle, GlUtils::X_AXIS).translate(
            GlUtils::Z_AXIS);
        mesh.addQuad(bar);

        angle -= (TAU / 36.0f);
        m.identity().rotate(angle, GlUtils::X_AXIS).translate(
            GlUtils::Z_AXIS);
        mesh.addQuad(smallBar);
        m.identity().rotate(HALF_TAU, GlUtils::Y_AXIS).rotate(angle,
            GlUtils::X_AXIS).translate(GlUtils::Z_AXIS);
        mesh.addQuad(smallBar);
        m.identity().rotate(HALF_TAU, GlUtils::Z_AXIS).rotate(angle,
            GlUtils::X_AXIS).translate(GlUtils::Z_AXIS);
        mesh.addQuad(smallBar);
        m.identity().rotate(HALF_TAU, GlUtils::Z_AXIS).rotate(HALF_TAU,
            GlUtils::Y_AXIS).rotate(angle, GlUtils::X_AXIS).translate(
            GlUtils::Z_AXIS);
        mesh.addQuad(smallBar);
      }
    }
    m.pop();
    mesh.fillNormals(true);

    const Mesh & hemi = getMesh(Resource::MESHES_HEMI_CTM);
    m.top() = glm::rotate(glm::mat4(), -QUARTER_TAU, GlUtils::X_AXIS);
    mesh.getColor() = Colors::cyan;
    mesh.addMesh(hemi, true);

    m.top() = glm::rotate(glm::mat4(), QUARTER_TAU, GlUtils::X_AXIS);
    mesh.getColor() = Colors::orange;
    mesh.addMesh(hemi);
    {
      set<int> poleIndices;
      for (size_t i = 0; i < mesh.positions.size(); ++i) {
        const glm::vec4 & v = mesh.positions[i];
        if (abs(v.x) < EPSILON && abs(v.z) < EPSILON) {
          poleIndices.insert(i);
        }
      }
      for (size_t i = 0; i < mesh.indices.size(); i += 3) {
        bool black = false;
        for (size_t j = i; j < i + 3; ++j) {
          if (poleIndices.count(mesh.indices[j])) {
            black = true;
            break;
          }
        }
        if (black) {
          for (size_t j = i; j < i + 3; ++j) {
            mesh.colors[mesh.indices[j]] = Colors::grey;
          }
        }
      }
    }
    geometry = mesh.getGeometry();
  }
  ProgramPtr program = getProgram(
      Resource::SHADERS_LITCOLORED_VS,
      Resource::SHADERS_LITCOLORED_FS);
  program->use();
  program->setUniform("ForceAlpha", alpha);
  renderGeometry(geometry, program);
}
Esempio n. 19
0
bool Compiler::CompileShaderPrimary(
    const ShaderInput&          inputDesc,
    const ShaderOutput&         outputDesc,
    Reflection::ReflectionData* reflectionData)
{
    /* Validate arguments */
    ValidateArguments(inputDesc, outputDesc);

    /* ----- Pre-processing ----- */

    timePoints_.preprocessor = Time::now();

    std::unique_ptr<IncludeHandler> stdIncludeHandler;
    if (!inputDesc.includeHandler)
        stdIncludeHandler = std::unique_ptr<IncludeHandler>(new IncludeHandler());

    auto includeHandler = (inputDesc.includeHandler != nullptr ? inputDesc.includeHandler : stdIncludeHandler.get());

    std::unique_ptr<PreProcessor> preProcessor;

    if (IsLanguageHLSL(inputDesc.shaderVersion))
        preProcessor = MakeUnique<PreProcessor>(*includeHandler, log_);
    else if (IsLanguageGLSL(inputDesc.shaderVersion))
        preProcessor = MakeUnique<GLSLPreProcessor>(*includeHandler, log_);

    const bool writeLineMarksInPP = (!outputDesc.options.preprocessOnly || outputDesc.formatting.lineMarks);
    const bool writeLineMarkFilenamesInPP = (!outputDesc.options.preprocessOnly || IsLanguageHLSL(inputDesc.shaderVersion));

    auto processedInput = preProcessor->Process(
        std::make_shared<SourceCode>(inputDesc.sourceCode),
        inputDesc.filename,
        writeLineMarksInPP,
        writeLineMarkFilenamesInPP,
        ((inputDesc.warnings & Warnings::PreProcessor) != 0)
    );

    if (reflectionData)
        reflectionData->macros = preProcessor->ListDefinedMacroIdents();

    if (!processedInput)
        return ReturnWithError(R_PreProcessingSourceFailed);

    if (outputDesc.options.preprocessOnly)
    {
        (*outputDesc.sourceCode) << processedInput->rdbuf();
        return true;
    }

    /* ----- Parsing ----- */

    timePoints_.parser = Time::now();

    std::unique_ptr<IntrinsicAdept> intrinsicAdpet;
    ProgramPtr program;

    if (IsLanguageHLSL(inputDesc.shaderVersion))
    {
        /* Establish intrinsic adept */
        intrinsicAdpet = MakeUnique<HLSLIntrinsicAdept>();

        /* Parse HLSL input code */
        HLSLParser parser(log_);
        program = parser.ParseSource(
            std::make_shared<SourceCode>(std::move(processedInput)),
            outputDesc.nameMangling,
            inputDesc.shaderVersion,
            outputDesc.options.rowMajorAlignment,
            ((inputDesc.warnings & Warnings::Syntax) != 0)
        );
    }
    else if (IsLanguageGLSL(inputDesc.shaderVersion))
    {
        /* Establish intrinsic adept */
        #if 0
        intrinsicAdpet = MakeUnique<GLSLIntrinsicAdept>();
        #else //!!!
        intrinsicAdpet = MakeUnique<HLSLIntrinsicAdept>();
        #endif

        /* Parse GLSL input code */
        GLSLParser parser(log_);
        program = parser.ParseSource(
            std::make_shared<SourceCode>(std::move(processedInput)),
            outputDesc.nameMangling,
            inputDesc.shaderVersion,
            ((inputDesc.warnings & Warnings::Syntax) != 0)
        );
    }

    if (!program)
        return ReturnWithError(R_ParsingSourceFailed);

    /* ----- Context analysis ----- */

    timePoints_.analyzer = Time::now();

    bool analyzerResult = false;

    if (IsLanguageHLSL(inputDesc.shaderVersion))
    {
        /* Analyse HLSL program */
        HLSLAnalyzer analyzer(log_);
        analyzerResult = analyzer.DecorateAST(*program, inputDesc, outputDesc);
    }

    /* Print AST */
    if (outputDesc.options.showAST)
    {
        ASTPrinter printer;
        printer.PrintAST(program.get());
    }

    if (!analyzerResult)
        return ReturnWithError(R_AnalyzingSourceFailed);

    /* Optimize AST */
    timePoints_.optimizer = Time::now();

    if (outputDesc.options.optimize)
    {
        Optimizer optimizer;
        optimizer.Optimize(*program);
    }

    /* ----- Code generation ----- */

    timePoints_.generation = Time::now();

    bool generatorResult = false;

    if (IsLanguageGLSL(outputDesc.shaderVersion) || IsLanguageESSL(outputDesc.shaderVersion) || IsLanguageVKSL(outputDesc.shaderVersion))
    {
        /* Generate GLSL output code */
        GLSLGenerator generator(log_);
        generatorResult = generator.GenerateCode(*program, inputDesc, outputDesc, log_);
    }

    if (!generatorResult)
        return ReturnWithError(R_GeneratingOutputCodeFailed);

    /* ----- Code reflection ----- */

    timePoints_.reflection = Time::now();

    if (reflectionData)
    {
        ReflectionAnalyzer reflectAnalyzer(log_);
        reflectAnalyzer.Reflect(
            *program, inputDesc.shaderTarget, *reflectionData,
            ((inputDesc.warnings & Warnings::CodeReflection) != 0)
        );
    }

    return true;
}
Esempio n. 20
0
void EdvsRiftApp::drawEvents()
{
    static ProgramPtr program = oria::loadProgram("./resources/event_pixel.vs", "./resources/event_pixel.fs");

    // Reset before application exit
    Platform::addShutdownHook([]
    {
        program.reset();
    });


    MatrixStack & mv = Stacks::modelview();

    mv.withPush([&]
    {
        // Binds the program
        program->Use();

        // Matrices as uniforms
        Mat4Uniform(*program, "ModelView").Set(Stacks::modelview().top());
        Mat4Uniform(*program, "Projection").Set(Stacks::projection().top());

        // Manual set for azimuth and elevation
        oglplus::Uniform<float>(*program, "ManAzimuth").Set(azimuth);
        oglplus::Uniform<float>(*program, "ManElevation").Set(elevation);

        // Manual set for field of view
        oglplus::Uniform<float>(*program, "FovX").Set(60.0 * DEGREES_TO_RADIANS);
        oglplus::Uniform<float>(*program, "FovY").Set(60.0 * DEGREES_TO_RADIANS);


        // Bind VAO
        vao->Bind();

        // Bind VBO "Positions"
        vbo_position->Bind(Buffer::Target::Array);
        {
            Buffer::Data(Buffer::Target::Array, position_);

            VertexArrayAttrib vao_attr(*program, "Position");
            vao_attr.Setup<Vec2f>();
            vao_attr.Enable();
        }

        // Bind VBO "CameraId"
        vbo_camera_id->Bind(Buffer::Target::Array);
        {
            Buffer::Data(Buffer::Target::Array, camera_id_);

            VertexArrayAttrib vao_attr(*program, "CameraId");
            vao_attr.Setup<Vec1f>();
            vao_attr.Enable();
        }

        // Bind VBO "Color"
        vbo_color->Bind(Buffer::Target::Array);
        {
            Buffer::Data(Buffer::Target::Array, parity_); //, BufferUsage::StreamDraw);

            VertexArrayAttrib vao_attr(*program, "Color");
            vao_attr.Setup<Vec1f>();
            vao_attr.Enable();
        }

        // Draw all elements
        Context::DrawArrays(PrimitiveType::Points, 0, camera_id_.size());
    });

    // Unbind
    oglplus::NoProgram().Bind();
    oglplus::NoVertexArray().Bind();
}
Esempio n. 21
0
 inline GLhandleARB handleOf(const ProgramPtr& p) {
     return (p ? p->getHandle() : 0);
 }