mettli / glfx Goto Github PK

When trying to compile the test shaders with the given test code in glfxc.cpp i 
always get errors while compiling.

For example the "simple_technique.glsl" shader throws the error 

"Status: VSmain shader compiled with errors
Compilation details for VSmain shader:
Vertex shader failed to compile with the following errors:
ERROR: 0:11: error(#181) Cannot be used with a structure: in
ERROR: error(#273) 1 compilation errors.  No code generated


Status: FSmain shader compiled without errors
Compilation details for FSmain shader:

Status: Link failed
Linkage details:
Vertex shader(s) were not successfully compiled before glLinkProgram() was 
called.  Link failed. 

Errors in shader compilation"

I tried all test shaders and only the null_technique.glsl compiled correctly. 
Might this be a problem with drivers?

I'm running on a Radeon HD 6950 with 13.4 drivers.

I just looked at the build system on Linux, and oh well, what can I say... I 
was practically horrified.
We need to switch from automake asap. CMake and SCons sound like good 
alternatives. Lets decide which way to go and stick with it.
The only exception for now, is that I don't want to give up on MSVC files.

Requirements:
1. Build scripts should be easy and intuitive to modify
2. Should support less common configurations (like MiniGW)
3. Should be clear about what is the selected build (64/32 bit, shared/static 
lib)
4. All build scripts should be confined to one directory (to reduce pollution)
5. Intermediate files created by the build system and the compiler should be 
cleanable without using source control
6. Should produce simple output during compilation. Seeing long lines of "gcc 
......." doesn't help anyone. More verbose output should be achievable with 
parameters.
7. In case of installation, should tell where it's going to put the files

Would it be possible to also parse included files? Currently included files 
(#include "external.glsl") can only contain pure opengl, since its content will 
just be pasted into the final content. Wouldn't it be possible to first paste 
its content into a string and then parse it? That should also work recursively, 
right?

I did:
svn checkout http://glfx.googlecode.com/svn/trunk/ libglfx #On 01 June 2013
cd libglfx
./configure
make

As advised per : http://ogldev.atspace.co.uk/www/tutorial34/tutorial34.html

Make exited with error 2. It failed to find "include/glfx.h".

The file "glfx.h" is actually located in "include/gl/" and not in "include/". 
Simply changing "libglfx/Makefile" and "libglfx/src/Makefile" to look for it in 
"include/gl/glfx.h" fixed the problem.

I am using Ubuntu 12.10 with up to date make and GCC.

This is a very critical function for if I am to use glfx. Please add this 
functionality as soon as possible!

I like the looks of this library, and it nicely solves some of the problems 
inherent in using GL's shader API.  Unfortunately, it can't solve some of the 
problems we have in our current project, which requires support for older 
versions of GL (and GL ES) that glfx cannot easily support.

This requires parsing a higher level shading language and generating metadata 
from it in order to create some data structures and other API calls.  For 
instance, instead of using layout location for attributes, it would require 
generating a list of attribute names and their desired positions and then 
calling glBindAttribLocation just before linking the program.  Uniform blocks 
are even trickier to work around (e.g. on GLES) but it's doable (requires 
abstractions in other parts of the graphics stack, but any decent application 
graphics architecture will have those anyway).

These kinds of features can be most easily supported by updating the glfx 
parser to build an AST instead of directly generating source strings, using 
that to build a list of declarations and properties (list of attributes, list 
of uniform blocks, list of entry points, etc.), and then writing multiple "code 
generators" for different target platforms.  This is essentially what Cg does, 
for instance, albeit in a non-Open way (and still without GL ES support, 
unfortunately).

What I'd like to see from glfx in future versions is a means of getting that 
metadata and then passing in a code generator (with at least the current 
4.20-based one being provided with the library, of course).  The higher level 
abstractions aren't necessary, but at least being able to get the metadata is 
essentially mandatory for supporting other GLSL versions.

It might also make it possible to compile the glfx shaders into HLSL, should 
someone find themselves needing to quickly port to a Direct3D-only platform 
like the Xbox.  (Or just to support Intel better, since their drivers happily 
support D3D10 even though they refuse to update the GL support to anything 
relatively recent.)

error C2039: 'at' : is not a member of 'std::map<_Kty,_Ty>'

What steps will reproduce the problem?
1. Create a new directory glfx-build/
2. cd to glfx-build/
3. Run cmake -G Unix\ Makefiles glfx-read-only/
4. Run sudo make install

What is the expected output? What do you see instead?
The project is build and installed, but instead it fails because it produces 
"file INSTALL cannot find
  "glfx-read-only/src/libglfx_static.a"

What version of the product are you using? On what operating system?
The latest svn repository version, on arch linux.

Please provide any additional information below.
It seems to be the case that the install points to the source directory instead 
of the build directory.

What steps will reproduce the problem?
1.I am compiling under ati 7970 and none of the shaders are working
2.
3.

What is the expected output? What do you see instead?
The error i am getting is that you are using the in keyword along with a 
structure when you call the Vertex Shader which is illegal. It might work on 
NVidia but it is not part of the specs.

What version of the product are you using? On what operating system?


Please provide any additional information below.

I desperately need to be able to retrieve a list of all programs within an 
effect. I would really love to join your development team to help implement 
these features.

#What steps will reproduce the problem?

See code in  'code_snippet.cpp'. I execute this code after my GL context has 
been created and initialized. It references an effect file 'null.glsl' also in 
the attached folder. The program crashes immediately at glfxCompileProgram()

#What is the expected output? What do you see instead?

Expect to see either 'successfully compiled program!" or "failed to compile 
program!" written to my debug output. Instead, the program crashes, and Visual 
Studio's debugger opens up a file called 'sstream' and highlights a function 
definition as the source of the error. This function is given in 'error.txt'


#What version of the product are you using? On what operating system?

I have the problem on both glfx0.6 and 0.7. I am using Windows 7 Home Premium, 
64 bit.


#Please provide any additional information below.

Graphics card: GeForce GT 525M. 
Development Environment: Microsoft Visual Studio 2010.

Hi, i`ll be really thankful if you help me to solve this problem.
I have a Visual Studio 2012 and Windows 8,also ATI HD4850. I try to run an 
OGLDEV tutorial 39, the source is builded ok, but when i run the programm the 
compiling of shaders is start and i have an error states that "Undeclared 
identefier gl_in, Undeclared identefier gl_position, and No matching overloaded 
function found EmitVertex and No matching overloaded function found 
EndPrimitive". I attached a screenshot of errors and the shader file. Please 
help, i can provide any information if neccesary.


Thanks, Timur. 

CG and HLSL are able to define multiple passes. I don't know enough about GLSL 
as I normally use CG but I believe you may intend users to use GLSL subroutines 
to accomplish this functionality. At least that is what I think subroutines are 
used for. Does this need to be implemented or am I right about the subroutines?

I`m using Visual Studio 2012 and Windows 8 64 bit, the issue is simple

here is shader code:

struct VSInput1
{
    vec3 Position;
    vec2 TexCoord;
};

shader VSmain(in VSInput1 Vsin:0)                                               

{                                                                               

}
When compiling i have an error "Cannot be used with a structure in", how to 
solve this?
If i use an interface declaration instead of struct it says that interface 
cannot be used with vertex shader.

Please help.

Thanks Timur. 

Good implementation can be found here:
http://www.codeproject.com/Articles/3853/Wave-a-Standard-conformant-C-preprocess
or-library

Or in boost::wave library.

This should be quite beneficial when working in the D3D model.

Open questions:
1. How to specify GLSL version (should this be like in D3D)?

Need templates for performance.

1. What is the desired interface?
2. Should glfx manage generated instantiations?
3. What is the scope of the templates? This will probably be in program/stages 
scope.

Anything else?