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);
}
