static void run(tool_options_t &opts) { netlist_tool_t nt; osd_ticks_t t = osd_ticks(); nt.m_opts = &opts; nt.init(); nt.read_netlist(filetobuf(opts.opt_file()), opts.opt_name()); plist_t<input_t> *inps = read_input(&nt, opts.opt_inp()); double ttr = opts.opt_ttr(); printf("startup time ==> %5.3f\n", (double) (osd_ticks() - t) / (double) osd_ticks_per_second() ); printf("runnning ...\n"); t = osd_ticks(); unsigned pos = 0; netlist::netlist_time nlt = netlist::netlist_time::zero; while (pos < inps->size() && (*inps)[pos].m_time < netlist::netlist_time::from_double(ttr)) { nt.process_queue((*inps)[pos].m_time - nlt); (*inps)[pos].setparam(); nlt = (*inps)[pos].m_time; pos++; } nt.process_queue(netlist::netlist_time::from_double(ttr) - nlt); nt.stop(); pfree(inps); double emutime = (double) (osd_ticks() - t) / (double) osd_ticks_per_second(); printf("%f seconds emulation took %f real time ==> %5.2f%%\n", ttr, emutime, ttr/emutime*100.0); }
int main(int argc, char *argv[]) { #if (!PSTANDALONE) track_memory(true); { #endif tool_options_t opts; int ret; fprintf(stderr, "%s", "WARNING: This is Work In Progress! - It may fail anytime\n"); fprintf(stderr, "Update dispatching using method %s\n", pmf_verbose[NL_PMF_TYPE]); if ((ret = opts.parse(argc, argv)) != argc) { fprintf(stderr, "Error parsing %s\n", argv[ret]); usage(opts); return 1; } if (opts.opt_help()) { usage(opts); return 1; } pstring cmd = opts.opt_cmd(); if (cmd == "listdevices") listdevices(); else if (cmd == "run") run(opts); else if (cmd == "convert") { pstring contents = filetobuf(opts.opt_file()); nl_convert_base_t *converter = NULL; if (opts.opt_type().equals("spice")) converter = palloc(nl_convert_spice_t); else converter = palloc(nl_convert_eagle_t); converter->convert(contents); /* present result */ printf("%s\n", converter->result().cstr()); pfree(converter); } else { fprintf(stderr, "Unknown command %s\n", cmd.cstr()); usage(opts); return 1; } #if (!PSTANDALONE) } dump_unfreed_mem(); #endif return 0; }
plist_t<input_t> *read_input(netlist::netlist_t *netlist, pstring fname) { plist_t<input_t> *ret = palloc(plist_t<input_t>()); if (fname != "") { pstring_list_t lines(filetobuf(fname) , "\n"); for (unsigned i=0; i<lines.size(); i++) { pstring l = lines[i].trim(); if (l != "") { input_t inp(netlist, l); ret->add(inp); } } } return ret; }
static void run(core_options &opts) { netlist_tool_t nt; osd_ticks_t t = osd_ticks(); nt.init(); nt.m_logs = opts.value("l"); nt.read_netlist(filetobuf(opts.value("f"))); double ttr = opts.float_value("t"); printf("startup time ==> %5.3f\n", (double) (osd_ticks() - t) / (double) osd_ticks_per_second() ); printf("runnning ...\n"); t = osd_ticks(); nt.process_queue(netlist_time::from_double(ttr)); double emutime = (double) (osd_ticks() - t) / (double) osd_ticks_per_second(); printf("%f seconds emulation took %f real time ==> %5.2f%%\n", ttr, emutime, ttr/emutime*100.0); }
int compileShader(GLuint shaderID, char* shaderPath){ int isCompiled; char *shaderSource = filetobuf(shaderPath); glShaderSource(shaderID, 1, (const char**)&shaderSource, 0); glCompileShader(shaderID); glGetShaderiv(shaderID,GL_COMPILE_STATUS,&isCompiled); if(isCompiled == GL_FALSE){ int maxLength; glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &maxLength); char *infolog = (char*) malloc(maxLength); glGetShaderInfoLog(shaderID, maxLength, &maxLength, infolog); printf("Error compiling shader: %s\n Error log:\n%s", shaderPath, infolog); free(infolog); return 0; }else{ printf("%s was succesfully compiled to run on the hardware\n", shaderPath); fflush(stdout); } return 1; }
static void run(tool_options_t &opts) { netlist_tool_t nt; osd_ticks_t t = osd_ticks(); nt.init(); nt.m_logs = opts.opt_logs(); nt.m_verbose = opts.opt_verb(); nt.read_netlist(filetobuf(opts.opt_file()), opts.opt_name()); double ttr = opts.opt_ttr(); printf("startup time ==> %5.3f\n", (double) (osd_ticks() - t) / (double) osd_ticks_per_second() ); printf("runnning ...\n"); t = osd_ticks(); nt.process_queue(netlist::netlist_time::from_double(ttr)); nt.stop(); double emutime = (double) (osd_ticks() - t) / (double) osd_ticks_per_second(); printf("%f seconds emulation took %f real time ==> %5.2f%%\n", ttr, emutime, ttr/emutime*100.0); }
void MtlLoader::load_materials(char* file_name){ char* mtl_file = filetobuf(file_name); int i = 0; int n = 0; int line_length = 0; char* line_start = mtl_file; while (mtl_file[i] != 0){ line_length++; if (mtl_file[i] == '\n'){ process_line(line_start, line_length); line_start = line_start + line_length; line_length = 0; n++; } i++; } if (NOISEY) { } }
GLuint LoadShaders(char * vertex_file_path, char * fragment_file_path) { GLint Result = GL_FALSE; int InfoLogLength; // Create the shaders GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER); GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER); // Compile vertex shader printf("Compiling Vertex Shader\n"); char* VertexSource = filetobuf(vertex_file_path); glShaderSource(VertexShaderID, 1, (const GLchar**)&VertexSource , NULL); glCompileShader(VertexShaderID); // Check Vertex Shader glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result); if(Result == GL_FALSE) { glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength); char* VertexShaderErrorMessage = (char *)malloc(InfoLogLength); glGetShaderInfoLog(VertexShaderID, InfoLogLength, &InfoLogLength, VertexShaderErrorMessage); printf("Vertex Shader complilation error\n"); printf(VertexShaderErrorMessage); free(VertexShaderErrorMessage); } // Compile fragment shader printf("Compiling Fragment Shader\n"); char* FragmentSource = filetobuf(fragment_file_path); glShaderSource(FragmentShaderID, 1, (const GLchar**)&FragmentSource , NULL); glCompileShader(FragmentShaderID); // Check fragment Shader glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result); if(Result == GL_FALSE) { glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength); char* FragmentShaderErrorMessage = (char *)malloc(InfoLogLength); glGetShaderInfoLog(FragmentShaderID, InfoLogLength, &InfoLogLength, FragmentShaderErrorMessage); printf("Fragment shader compilation error\n"); printf(FragmentShaderErrorMessage); free(FragmentShaderErrorMessage); } // Link the program fprintf(stdout, "Linking program\n"); GLuint ProgramID = glCreateProgram(); glAttachShader(ProgramID, VertexShaderID); glAttachShader(ProgramID, FragmentShaderID); glLinkProgram(ProgramID); // Check the program glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result); if(Result == GL_FALSE) { glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength); char *ProgramErrorMessage = (char *)malloc(InfoLogLength); glGetProgramInfoLog(ProgramID, InfoLogLength, &InfoLogLength, ProgramErrorMessage); printf("Shader Linking error\n"); printf(ProgramErrorMessage); free(ProgramErrorMessage); } glDeleteShader(VertexShaderID); glDeleteShader(FragmentShaderID); return ProgramID; }
GLfloat Theta[3] = {0.0,0.0,0.0}; GLuint mvpMatrix, mvMatrix, normalMatrix, diffuseColor, vLightPosition, ambientColor, specularColor; GLfloat FOV = 45.0f; bool WKeyDown = false; bool XKeyDown = false; GLuint VertexShaderId, FragmentShaderId, ProgramId, VaoId, VboId, NormalBufferId; const GLchar* VertexShader = filetobuf("shader.vert"); const GLchar* FragmentShader = filetobuf("shader.frag"); void Initialize(int, char*[]); void InitWindow(int, char*[]); void ResizeFunction(int, int); void RenderFunction(void); void IdleFunction(void); void Cleanup(void); void CreateVBO(void); void DestroyVBO(void); void CreateShaders(void); void DestroyShaders(void); void SpecialKeys(int,int,int); void Keyboard(unsigned char, int, int); void AverageNormals(void);
Shader::Shader(const std::string &filepath, glm::vec2 viewport, GLenum culling, GLboolean colormask0, GLboolean colormask1, GLboolean colormask2, GLboolean colormask3, GLboolean depthmask, GLbitfield clear) { registred.push_back(this); this->culling = culling; this->colormask[0] = colormask0; this->colormask[1] = colormask1; this->colormask[2] = colormask2; this->colormask[3] = colormask3; this->depthmask = depthmask; this->clear = clear; this->viewport = viewport; std::string firstpath = g_System()->GetDataFile(filepath); std::string vertexsource, fragmentsource, geometrysource, libraries = "\n"; GLuint vertexshader, fragmentshader, geometryshader; int IsCompiled_VS, IsCompiled_FS, IsCompiled_GS; int IsLinked; vertexsource = filetobuf(firstpath + ".vert"); fragmentsource = filetobuf(firstpath + ".frag"); geometrysource = filetobuf(firstpath + ".geom"); std::vector<std::string> libs; g_System()->GetFilesInDirectory(libs, g_System()->GetDataFile("shaders")); for (auto &s : libs) { s = "shaders/" + s; if (endsWith(s, ".slib")) { std::string libsource = filetobuf(g_System()->GetDataFile(s)); if (libsource.length() == 0) continue; g_Console()->Info("Shader library loaded " + s); libraries += libsource + "\n"; } } vertexsource = libraries + vertexsource; fragmentsource = libraries + fragmentsource; if (geometrysource.length() > 0) geometrysource = libraries + geometrysource; vertexshader = glCreateShader(GL_VERTEX_SHADER); const GLchar* ptr = vertexsource.c_str(); glShaderSource(vertexshader, 1, (const GLchar **)&ptr, 0); glCompileShader(vertexshader); glGetShaderiv(vertexshader, GL_COMPILE_STATUS, &IsCompiled_VS); if (IsCompiled_VS == GL_FALSE) { logShader(vertexshader); return; } fragmentshader = glCreateShader(GL_FRAGMENT_SHADER); ptr = fragmentsource.c_str(); glShaderSource(fragmentshader, 1, (const GLchar **)&ptr, 0); glCompileShader(fragmentshader); glGetShaderiv(fragmentshader, GL_COMPILE_STATUS, &IsCompiled_FS); if (IsCompiled_FS == GL_FALSE) { logShader(fragmentshader); return; } if (geometrysource.length() > 0) { geometryshader = glCreateShader(GL_GEOMETRY_SHADER); ptr = geometrysource.c_str(); glShaderSource(geometryshader, 1, (const GLchar **)&ptr, 0); glCompileShader(geometryshader); glGetShaderiv(geometryshader, GL_COMPILE_STATUS, &IsCompiled_GS); if (IsCompiled_GS == GL_FALSE) { logShader(geometryshader); return; } } id = glCreateProgram(); glAttachShader(id, vertexshader); glAttachShader(id, fragmentshader); if (geometrysource.length() > 0) glAttachShader(id, geometryshader); glLinkProgram(id); glGetProgramiv(id, GL_LINK_STATUS, (int *)&IsLinked); if (IsLinked == GL_FALSE) { logProgram(id); id = 0; return; } g_Console()->Info("Shader loaded " + filepath); }
Obj::Obj(Vertex* vertices, int numverts, GLuint* elements, int numelements, char* vertex_shader_file, char* tessc_shader_file, char* tesse_shader_file, char* geom_shader_file, char* frag_shader_file) { this->numelements = numelements; use_tess = !(tesse_shader_file == NULL || tessc_shader_file == NULL); GLuint vertexshader, tessellationcontrolshader, tessellationevaluationshader, geometryshader, fragmentshader; shader_program = glCreateProgram(); char* vertex_source = filetobuf(vertex_shader_file); vertexshader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertexshader, 1, (const GLchar **) &vertex_source, 0); glCompileShader(vertexshader); glAttachShader(shader_program, vertexshader); if(use_tess) { char* tessc_source = filetobuf(tessc_shader_file); tessellationcontrolshader = glCreateShader(GL_TESS_CONTROL_SHADER); glShaderSource(tessellationcontrolshader, 1, (const GLchar **) &tessc_source, 0); glCompileShader(tessellationcontrolshader); glAttachShader(shader_program, tessellationcontrolshader); char* tesse_source = filetobuf(tesse_shader_file); tessellationevaluationshader = glCreateShader(GL_TESS_EVALUATION_SHADER); glShaderSource(tessellationevaluationshader, 1, (const GLchar **) &tesse_source, 0); glCompileShader(tessellationevaluationshader); glAttachShader(shader_program, tessellationevaluationshader); } char* geom_source = filetobuf(geom_shader_file); geometryshader = glCreateShader(GL_GEOMETRY_SHADER); glShaderSource(geometryshader, 1, (const GLchar **) &geom_source, 0); glCompileShader(geometryshader); glAttachShader(shader_program, geometryshader); char* frag_source = filetobuf(frag_shader_file); fragmentshader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragmentshader, 1, (const GLchar **) &frag_source, 0); glCompileShader(fragmentshader); glAttachShader(shader_program, fragmentshader); glLinkProgram(shader_program); char text[1000]; int length; glGetProgramInfoLog(shader_program, 1000, &length, text); if(length > 0) { fprintf(stderr,"Validate Shader program\n%s\n", text); } //Now for geometry. glGenVertexArrays(1, &vao); glBindVertexArray(vao); glGenBuffers(2, vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo[0]); glBufferData(GL_ARRAY_BUFFER, numverts*sizeof(Vertex), vertices, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[1]); glBufferData(GL_ELEMENT_ARRAY_BUFFER, numelements*sizeof(GLuint), elements, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_DOUBLE, GL_FALSE, sizeof(struct Vertex), (GLvoid*)offsetof(struct Vertex, pos)); glVertexAttribPointer(1, 3, GL_DOUBLE, GL_FALSE, sizeof(struct Vertex), (GLvoid*)offsetof(struct Vertex, norm)); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); }