void partialPatchCreateProgramHelper(const char *prefix,
const char *tcsName, const std::vector<std::string> *tcsMacros,
const char *tesName, const std::vector<std::string> *tesMacros,
GLuint *p_program)
{
std::string vsFileName(SHADER_DIR);
std::string tcsFileName(SHADER_DIR);
std::string tesFileName(SHADER_DIR);
std::string fsFileName(SHADER_DIR);
vsFileName += "/commonpatch_vs.glsl";
tcsFileName += prefix;
tcsFileName += tcsName;
tesFileName += prefix;
tesFileName += tesName;
fsFileName += "/commonpatch_fs.glsl";
std::vector<GLenum> types;
std::vector<const char *> fileNames;
types.push_back(GL_VERTEX_SHADER);
types.push_back(GL_TESS_CONTROL_SHADER);
types.push_back(GL_TESS_EVALUATION_SHADER);
types.push_back(GL_FRAGMENT_SHADER);
fileNames.push_back(vsFileName.c_str());
fileNames.push_back(tcsFileName.c_str());
fileNames.push_back(tesFileName.c_str());
fileNames.push_back(fsFileName.c_str());
std::vector<std::vector<std::string> > shaderMacros;
shaderMacros.resize(4);
shaderMacros[1] = *tcsMacros;
shaderMacros[2] = *tesMacros;
ShaderHelper::createProgramWithShaders(types, fileNames, *p_program, &shaderMacros);
}
void FullPatchNoSharpRenderer::createShaderProgram()
{
if (isGLSetup)
{
return;
}
std::string vsFileName(SHADER_DIR);
std::string tcsFileName(SHADER_DIR);
std::string tesFileName(SHADER_DIR);
std::string fsFileName(SHADER_DIR);
vsFileName += "/commonpatch_vs.glsl";
tcsFileName += "/fullpatch_nosharp_tcs.glsl";
tesFileName += "/fullpatch_nosharp_tes.glsl";
fsFileName += "/commonpatch_fs.glsl";
std::vector<GLenum> types;
std::vector<const char *> fileNames;
types.push_back(GL_VERTEX_SHADER);
types.push_back(GL_TESS_CONTROL_SHADER);
types.push_back(GL_TESS_EVALUATION_SHADER);
types.push_back(GL_FRAGMENT_SHADER);
fileNames.push_back(vsFileName.c_str());
fileNames.push_back(tcsFileName.c_str());
fileNames.push_back(tesFileName.c_str());
fileNames.push_back(fsFileName.c_str());
ShaderHelper::createProgramWithShaders(types, fileNames, program);
isGLSetup = true;
}
void reShader::use()
{
if (!program)
{
program = glCreateProgram();
vs = glCreateShader(GL_VERTEX_SHADER);
fs = glCreateShader(GL_FRAGMENT_SHADER);
std::string vsSrc = preprocess(reRadial::shared()->assetLoader()->loadFile(vsFileName()));
std::string fsSrc = preprocess(reRadial::shared()->assetLoader()->loadFile(fsFileName()));
int vsize = vsSrc.size();
int fsize = fsSrc.size();
const char* vsrc = vsSrc.c_str();
const char* fsrc = fsSrc.c_str();
glShaderSource(vs, 1, &vsrc, NULL);
glShaderSource(fs, 1, &fsrc, NULL);
glCompileShader(vs);
glCompileShader(fs);
glAttachShader(program, vs);
glAttachShader(program, fs);
glLinkProgram(program);
/*
string line;
stringstream ss(fsrc);
int i=0;
while (getline(ss, line))
{
cout << i++ << " " << line << std::endl;
}
*/
printProgramInfoLog(program);
printShaderInfoLog(vs);
printShaderInfoLog(fs);
collectVars();
/*
int sampler = 0;
int total = -1;
glGetProgramiv( program, GL_ACTIVE_UNIFORMS, &total );
for(int i=0; i<total; ++i)
{
int name_len=-1, num=-1;
GLenum type = GL_ZERO;
char name[100];
glGetActiveUniform( program, GLuint(i), sizeof(name)-1,
&name_len, &num, &type, name );
name[name_len] = 0;
assert(name_len < 100);
if (name[name_len-1] == ']') name[name_len-3] = 0;
for (int i=0; i<num; i++)
{
stringstream vname(name);
if (num > 1)
{
vname << string(name) << "[" << i << "]";
}
GLuint location = glGetUniformLocation( program, vname.str().c_str() );
uniforms[vname.str()] = location;
if (type == GL_SAMPLER_2D)
{
textureUnits[vname.str()] = sampler++;
}
printf("%s\n", vname.str().c_str());
}
}
total = -1;
glGetProgramiv( program, GL_ACTIVE_ATTRIBUTES, &total );
for(int i=0; i<total; ++i)
{
int name_len=-1, num=-1;
GLenum type = GL_ZERO;
char name[100];
glGetActiveAttrib( program, GLuint(i), sizeof(name)-1,
&name_len, &num, &type, name );
name[name_len] = 0;
GLuint location = glGetAttribLocation( program, name );
attributes[name] = location;
printf("%s", name);
}
*/
/*
int len;
glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &len);
int formats;
glGetIntegerv(GL_PROGRAM_BINARY_FORMATS, &formats);
char *bin = new char[len];
glProgramBinary(program)
*/
}
glUseProgram(program);
/*
for (reVarMap::iterator it = textureUnits.begin(); it!=textureUnits.end(); it++)
{
for (reVarMap::iterator it2 = textureUnits.begin(); it2!=textureUnits.end(); it2++)
{
if (it->first !=it2->first && it->second == it2->second)
{
__debugbreak();
}
}
}
*/
}
osg::StateSet* createState(osg::ArgumentParser& arguments)
{
// read 4 2d images
osg::ref_ptr<osg::Image> image_0 = osgDB::readImageFile("Images/lz.rgb");
osg::ref_ptr<osg::Image> image_1 = osgDB::readImageFile("Images/reflect.rgb");
osg::ref_ptr<osg::Image> image_2 = osgDB::readImageFile("Images/tank.rgb");
osg::ref_ptr<osg::Image> image_3 = osgDB::readImageFile("Images/skymap.jpg");
if (!image_0 || !image_1 || !image_2 || !image_3)
{
std::cout << "Warning: could not open files."<<std::endl;
return new osg::StateSet;
}
if (image_0->getPixelFormat()!=image_1->getPixelFormat() || image_0->getPixelFormat()!=image_2->getPixelFormat() || image_0->getPixelFormat()!=image_3->getPixelFormat())
{
std::cout << "Warning: image pixel formats not compatible."<<std::endl;
return new osg::StateSet;
}
GLint textureSize = 1024;
// scale them all to the same size.
image_0->scaleImage(textureSize,textureSize,1);
image_1->scaleImage(textureSize,textureSize,1);
image_2->scaleImage(textureSize,textureSize,1);
image_3->scaleImage(textureSize,textureSize,1);
osg::ref_ptr<osg::Texture2DArray> texture = new osg::Texture2DArray;
texture->setFilter(osg::Texture2DArray::MIN_FILTER, osg::Texture2DArray::LINEAR);
texture->setFilter(osg::Texture2DArray::MAG_FILTER, osg::Texture2DArray::LINEAR);
texture->setWrap(osg::Texture2DArray::WRAP_R, osg::Texture2DArray::REPEAT);
if (arguments.read("--mipmap"))
{
OSG_NOTICE<<"Enabling Mipmaping"<<std::endl;
texture->setUseHardwareMipMapGeneration(true);
texture->setFilter(osg::Texture2DArray::MIN_FILTER, osg::Texture2DArray::LINEAR_MIPMAP_LINEAR);
}
if (arguments.read("--subload"))
{
texture->setTextureSize(textureSize, textureSize, 1);
texture->setSubloadCallback(new SubloadCallback());
}
else if (arguments.read("--packed"))
{
OSG_NOTICE<<"Packing all images into a single osg::Image to pass to Texture2DArray."<<std::endl;
osg::ref_ptr<osg::Image> image_3d = new osg::Image;
image_3d->allocateImage(textureSize, textureSize, 4, image_0->getPixelFormat(), image_0->getDataType());
// copy the 2d images into the 3d image.
image_3d->copySubImage(0,0,0,image_0.get());
image_3d->copySubImage(0,0,1,image_1.get());
image_3d->copySubImage(0,0,2,image_2.get());
image_3d->copySubImage(0,0,3,image_3.get());
image_3d->setInternalTextureFormat(image_0->getInternalTextureFormat());
texture->setImage(0, image_3d.get());
}
else
{
OSG_NOTICE<<"Assigned all images to Texture2DArray seperately."<<std::endl;
texture->setImage(0, image_0.get());
texture->setImage(1, image_1.get());
texture->setImage(2, image_2.get());
texture->setImage(3, image_3.get());
}
std::string vsFileName("shaders/osgtexture2DArray.vert");
std::string fsFileName("shaders/osgtexture2DArray.frag");
if (arguments.read("--vs", vsFileName)) {}
if (arguments.read("--fs", vsFileName)) {}
osg::ref_ptr<osg::Program> program = new osg::Program;
osg::ref_ptr<osg::Shader> vertexShader = osgDB::readShaderFile( osg::Shader::VERTEX, vsFileName) ;
if (vertexShader.get()) program->addShader( vertexShader.get() );
osg::ref_ptr<osg::Shader> fragmentShader = osgDB::readShaderFile( osg::Shader::FRAGMENT, fsFileName) ;
if (fragmentShader.get()) program->addShader( fragmentShader.get() );
// create the StateSet to store the texture data
osg::StateSet* stateset = new osg::StateSet;
stateset->setTextureAttributeAndModes(0,texture.get(),osg::StateAttribute::ON);
stateset->addUniform( new osg::Uniform( "texture", 0 ) );
stateset->setAttribute( program.get() );
return stateset;
}
