void PerVertexColorShader::construct()
{
QOpenGLFunctions_4_1_Core* f = resourceManager()->functions();
bool success = create();
Q_ASSERT(success);
success = compileFile(ShaderProgram::VertexShader, ":/shaders/pervertexcolor.vert");
Q_ASSERT(success);
success = compileFile(ShaderProgram::FragmentShader, ":/shaders/pervertexcolor.frag");
Q_ASSERT(success);
link();
m_iAttributeLocations[Position] = f->glGetAttribLocation(handle(), "vPositionModelSpace");
m_iAttributeLocations[Normal] = f->glGetAttribLocation(handle(), "vNormal");
m_iAttributeLocations[Color] = f->glGetAttribLocation(handle(), "vColor");
m_iAttributeLocations[ColorUniform] = f->glGetUniformLocation(handle(), "fColor");
m_iAttributeLocations[FogColorUniform] = f->glGetUniformLocation(handle(), "fFogColor");
m_iAttributeLocations[FogBeginUniform] = f->glGetUniformLocation(handle(), "fFogBegin");
m_iAttributeLocations[FogEndUniform] = f->glGetUniformLocation(handle(), "fFogEnd");
m_iAttributeLocations[ModelToWorldMatrix] = f->glGetUniformLocation(handle(), "modelToWorld");
m_iAttributeLocations[WorldToCameraMatrix] = f->glGetUniformLocation(handle(), "worldToCamera");
m_iAttributeLocations[CoordinateTransformMatrix] = f->glGetUniformLocation(handle(), "hammerToOpenGL");
m_iAttributeLocations[CameraProjectionMatrix] = f->glGetUniformLocation(handle(), "projection");
m_iAttributeLocations[CounterScaleUniform] = f->glGetUniformLocation(handle(), "counterScale");
m_iAttributeLocations[DirectionalLightUniform] = f->glGetUniformLocation(handle(), "directionalLight");
}
void
compileObjectFiles()
{ int n;
for(n=0; n<cfiles.size; n++)
compileFile(cc, &coptions, cfiles.list[n]);
for(n=0; n<cppfiles.size; n++)
compileFile(cxx, &cppoptions, cppfiles.list[n]);
}
int main(int argc, char **argv)
{
struct ByteStream *data;
FILE *output;
--argc;
if (argc < 1) {
fprintf(stderr, "\t\x1b[1m\x1b[91mSyntax: %s <path to test file> [<path to executable>]\x1b[0m\n",
*argv);
exit(-1);
}
++argv;
data = compileFile(*argv);
printf("\n");
--argc;
if (argc) {
++argv;
output = fopen(*argv, "w");
} else {
output = fopen("b.out", "w");
}
writeStreamToFile(output, data);
fclose(output);
fprintf(stdout, "\x1b[1m\x1b[92mExiting...\x1b[0m\n");
return 0;
}
void z::Compiler::compile() {
for(z::Ast::Config::PathList::const_iterator it = _config.sourceFileList().begin(); it != _config.sourceFileList().end(); ++it) {
const z::string& filename = *it;
z::string ext = z::dir::getExtention(filename);
if(_project.zppExt().find(ext) == z::string::npos) {
continue;
}
std::cout << "Compiling " << filename << std::endl;
z::Ast::Unit unit;
initContext(unit, false);
z::Ast::Module module(unit, filename, 0);
if(!compileFile(module, filename, "Compiling"))
throw z::Exception("Compiler", zfmt(Ast::Token(filename, 0, 0, ""), z::string("Cannot open source file: %{s}").arg("s", filename)));
ZenlangGenerator zgenerator(_project, _config, module);
zgenerator.run();
if(_config.olanguage() == "stlcpp") {
StlcppGenerator generator(_project, _config, module);
generator.run();
} else {
throw z::Exception("Compiler", zfmt(Ast::Token(filename, 0, 0, ""), "Unknown code generator %{s}").arg("s", _config.olanguage()));
}
}
}
std::pair<PExprNode, FilePath> FileCompiler::loadCode(ExprLocation loc, ConstStrA name)
{
FilePath p = loc.getFileName();
if (p.getPath().empty()) p = FilePath(ConstStrW(L"."), true);
for (ConstStrA::SplitIterator iter = name.split('/'); iter.hasItems();) {
ConstStrA part = iter.getNext();
if (part.empty()) {
continue;
}
else if (part == "..") {
p = p / parent;
}
else {
p = p / part;
}
}
const PExprNode *code = codeCache.find(p);
PExprNode out;
if (code) out = *code;
else {
out = compileFile(p);
codeCache(p, out);
}
return std::make_pair(out, p);
}
void IF_LoadCS(void)
{
char * f;
f = getString();
if (f != NULL) {
compileFile(f);
free((void*)f);
}
}
Compiler::Compiler(QWidget *parent) : Page(parent), m_serial(this)
{
setupUi(this);
QObject::connect(&m_compiler, SIGNAL(readyReadStandardError()), this, SLOT(readStandardError()));
QObject::connect(&m_compiler, SIGNAL(readyReadStandardOutput()), this, SLOT(readStandardOutput()));
QObject::connect(&m_compiler, SIGNAL(finished(int, QProcess::ExitStatus)), UserProgram::instance(), SLOT(compileFinished(int, QProcess::ExitStatus)));
QObject::connect(&m_serial, SIGNAL(downloadFinished(QString)), this, SLOT(compileFile(QString)));
m_serial.start();
}
void z::Compiler::import(z::Ast::Module& module) {
z::string ifilename = findImport(module.filename());
ifilename = z::dir::cleanPath(ifilename);
// check if file is already imported
if(module.unit().headerFileList().find(ifilename) != module.unit().headerFileList().end()) {
return;
}
// if not, add it to list of files imported into this unit
module.unit().addheaderFile(ifilename);
compileFile(module, ifilename, "Importing");
}
bool ofxShader::loadShader(char const *vertexFileName, char const *fragmentFileName) {
loaded = false;
if (!GLEE_ARB_shader_objects) {
printf("Extension \"ARB_shader_objects\" not supported.\n");
return false;
}
vertexShader = (GLhandleARB)glCreateShader(GL_VERTEX_SHADER);
fragmentShader = (GLhandleARB)glCreateShader(GL_FRAGMENT_SHADER);
shader = glCreateProgramObjectARB();
if (
compileFile(vertexFileName, vertexShader, vertexFileName) &&
compileFile(fragmentFileName, fragmentShader, fragmentFileName) &&
link(fragmentFileName)
) {
return loaded = true;
} else {
unload();
return false;
}
}
static inline void compileFolder(const Config *config)
{
assert(config->handler_dir!=NULL);
DIR *rep=opendir(config->handler_dir);
if(rep == NULL)
die("This is not a folder : %s\n", config->handler_dir);
Dirent *current=NULL;
char *ext=NULL;
while ((current=readdir(rep)) != NULL)
{
ext=rindex(current->d_name, '.');
if (strcmp(current->d_name, ".")!=0 && strcmp(current->d_name, "..")!=0 && ext!=NULL)
if(strcmp(ext, ".c") == 0)
{
size_t size=sizeof(char)*(strlen(config->handler_dir)+strlen(current->d_name)+strlen("/"))+1;
PRINT("Size1 %d", (int)size);
char *filename=malloc(size);
strcpy(filename, config->handler_dir);
strcat(filename, "/");
strcat(filename, current->d_name);
*ext='\0';
size=sizeof(char)*(strlen(config->tmp_dir)+strlen(current->d_name)+strlen("/"))+1;
PRINT("Size2 %d", (int)size);
char *tmp=malloc(size);
strcpy(tmp, config->tmp_dir);
strcat(tmp, "/");
strcat(tmp, current->d_name);
/*strcpy(tmp, config->tmp_dir);
strcat(tmp, "/");
strcat(tmp, current->d_name);*/
compileFile(config, filename, tmp);
free(tmp);
free(filename);
}
}
closedir(rep);
}
bool CppCompiler::compile()
{
if (abortChecker && abortChecker->abortRequested())
return false;
TIME_SECTION(!verbose ? NULL : onlyCompile ? "compile" : "compile/link");
Owned<IThreadPool> pool = createThreadPool("CCompilerWorker", this, NULL, maxCompileThreads?maxCompileThreads:1, INFINITE);
addCompileOption(COMPILE_ONLY[targetCompiler]);
bool ret = false;
Semaphore finishedCompiling;
int numSubmitted = 0;
numFailed.store(0);
ForEachItemIn(i0, allSources)
{
ret = compileFile(pool, allSources.item(i0), finishedCompiling);
if (!ret)
break;
++numSubmitted;
}
int main(int argc, char **argv)
{
excmd::parser parser;
excmd::option_state options;
// Setup command line options
parser.global_options()
.add_option("h,help", excmd::description { "Show the help." })
.add_option("vsh",
excmd::description { "Vertex shader to compile to gsh." },
excmd::value<std::string> {})
.add_option("psh",
excmd::description { "Pixel shader to compile to gsh." },
excmd::value<std::string> {});
parser.add_command("help")
.add_argument("command", excmd::value<std::string> { });
parser.add_command("compile")
.add_argument("gsh", excmd::value<std::string> { });
// Parse command line
try {
options = parser.parse(argc, argv);
} catch (excmd::exception ex) {
std::cout << "Error parsing command line: " << ex.what() << std::endl;
return -1;
}
// Print help
if (argc == 1 || options.has("help")) {
if (options.has("command")) {
std::cout << parser.format_help("gfdtool", options.get<std::string>("command")) << std::endl;
} else {
std::cout << parser.format_help("gfdtool") << std::endl;
}
return 0;
}
Shader shader;
try {
if (options.has("compile")) {
auto dst = options.get<std::string>("gsh");
gfd::GFDFile gfd;
if (options.has("vsh")) {
auto src = options.get<std::string>("vsh");
Shader shader;
shader.path = src;
shader.type = ShaderType::VertexShader;
if (!compileFile(shader, src)) {
return -1;
}
if (!gfdAddVertexShader(gfd, shader)) {
return -1;
}
}
if (options.has("psh")) {
auto src = options.get<std::string>("psh");
Shader shader;
shader.path = src;
shader.type = ShaderType::PixelShader;
if (!compileFile(shader, src)) {
return -1;
}
if (!gfdAddPixelShader(gfd, shader)) {
return -1;
}
}
if (!gfd::writeFile(gfd, dst)) {
return -1;
}
} else {
return -1;
}
} catch (parse_exception e) {
std::cout << "Parse exception: " << e.what() << std::endl;
return -1;
} catch (gfd_header_parse_exception e) {
std::cout << "GFD header parse exception: " << e.what() << std::endl;
return -1;
}
return 0;
}
void FSM::VM<X>::init(const std::string &conf, const std::string &luaFile)
{
readConfFile(conf, luaFile);
compileFile(luaFile);
}
inline bool z::Compiler::parseFile(z::Ast::Module& module, const z::string& msg) {
return compileFile(module, module.filename(), msg);
}
