//
// SetFeedbackVaryings
// Called after program linking!
//
void CShadingProgram::SetFeedbackVaryings(
const vector<string>& Varyings,
GLenum Mode
)
{
if (!m_Extensions->NV_transform_feedback)
throw CExtensionException( this, "::SetFeedbackVaryings()", "GL_NV_transform_feedback." );
if (Varyings.empty())
throw Sys::CDeveloperException( this, "::SetFeedbackVaryings() : Invalid <Varyings> parameter." );
if (Mode != GL_INTERLEAVED_ATTRIBS_NV && Mode != GL_SEPARATE_ATTRIBS_NV)
throw Sys::CDeveloperException( this, "::SetFeedbackVaryings() : Invalid <Mode> parameter." );
vector<GLint> Locations;
glClearErrors();
for (int i = 0; i < static_cast<int>( Varyings.size() ); ++i)
{
GLint Location = glGetVaryingLocationNV( m_Program, Varyings[ i ].c_str() );
if (Location == -1)
throw Sys::CException( this, "::SetFeedbackVaryings() : Failed to determine location of varying \"%s\".", Varyings[ i ].c_str() );
Locations.push_back( Location );
}
glTransformFeedbackVaryingsNV( m_Program, static_cast<GLsizei>( Locations.size() ), &Locations[ 0 ], Mode );
GLenum Error = glGetError();
if (Error != GL_NO_ERROR)
throw CException( this, Error, "::SetFeedbackVaryings() : An OpenGL error has occured.." );
}
//-----------------------------------------------------------------------------
void GLRenderToVertexBuffer::bindVerticesOutput(Pass* pass)
{
VertexDeclaration* declaration = mVertexData->vertexDeclaration;
bool useVaryingAttributes = false;
//Check if we are FixedFunc/ASM shaders (Static attributes) or GLSL (Varying attributes)
//We assume that there isn't a mix of GLSL and ASM as this is illegal
GpuProgram* sampleProgram = 0;
if (pass->hasVertexProgram())
{
sampleProgram = pass->getVertexProgram().getPointer();
}
else if (pass->hasGeometryProgram())
{
sampleProgram = pass->getGeometryProgram().getPointer();
}
if ((sampleProgram != 0) && (sampleProgram->getLanguage() == "glsl"))
{
useVaryingAttributes = true;
}
if (useVaryingAttributes)
{
//Have GLSL shaders, using varying attributes
GLSLLinkProgram* linkProgram = GLSLLinkProgramManager::getSingleton().getActiveLinkProgram();
GLhandleARB linkProgramId = linkProgram->getGLHandle();
vector<GLint>::type locations;
for (unsigned short e=0; e < declaration->getElementCount(); e++)
{
const VertexElement* element =declaration->getElement(e);
String varyingName = getSemanticVaryingName(element->getSemantic(), element->getIndex());
GLint location = glGetVaryingLocationNV(linkProgramId, varyingName.c_str());
if (location < 0)
{
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
"GLSL link program does not output " + varyingName +
" so it cannot fill the requested vertex buffer",
"OgreGLRenderToVertexBuffer::bindVerticesOutput");
}
locations.push_back(location);
}
glTransformFeedbackVaryingsNV(
linkProgramId, static_cast<GLsizei>(locations.size()),
&locations[0], GL_INTERLEAVED_ATTRIBS_NV);
}
else
{
//Either fixed function or assembly (CG = assembly) shaders
vector<GLint>::type attribs;
for (unsigned short e=0; e < declaration->getElementCount(); e++)
{
const VertexElement* element = declaration->getElement(e);
//Type
attribs.push_back(getGLSemanticType(element->getSemantic()));
//Number of components
attribs.push_back(VertexElement::getTypeCount(element->getType()));
//Index
attribs.push_back(element->getIndex());
}
glTransformFeedbackAttribsNV(
static_cast<GLuint>(declaration->getElementCount()),
&attribs[0], GL_INTERLEAVED_ATTRIBS_NV);
}
checkGLError(true, true, "GLRenderToVertexBuffer::bindVerticesOutput");
}
&(varyingInfo.size),
&(varyingInfo.type),
(varyingInfo.name));
return varyingInfo;
}
//##ModelId=4C32B4F902FD
void fluid::glExtension::btGLTransformFeedback::bindVarying(btGLShaderModel_4_0 *program, GLint nrVarying, const char** varyingNames, GLenum mode)
{
TEST_ASSERT_MSG(nrVarying <= getMaxBindableAttribs(),"Varying Count Overflow.")
TEST_ASSERT_MSG(mode == GL_SEPARATE_ATTRIBS_NV || mode == GL_INTERLEAVED_ATTRIBS_NV,
"Invalid Transform Feedback Mode.")
for(int i=0;i < nrVarying;i++)
{
varyingLocs[i]=glGetVaryingLocationNV(cgGLGetProgramID(program->vertexShader),varyingNames[i]);
TEST_ASSERT_MSG(varyingLocs[i] >= 0,"Varying Not Detected On Program.")
}
glTransformFeedbackVaryingsNV(cgGLGetProgramID(program->vertexShader),nrVarying,varyingLocs,mode);
this->mode=mode;
}
//##ModelId=4C32B67100BB
void fluid::glExtension::btGLTransformFeedback::bindBuffer(btGLBufferBundle* bundle)
{
char feedbackName[256];
GLint maxLen=getMaxBindableAttribs();
for(int i=0;i < maxLen;i++)
{
sprintf_s(feedbackName,255,"transform_feedback_index_%d",i);
GlobalModel::GlobalModel()
: target(0),
renderSource(1),
bufferSize(MAX_VERTICES * Vertex::SIZE),
count(0),
initProgram(loadProgramFromFile("init_unstable.vert")),
drawProgram(loadProgramFromFile("draw_feedback.vert", "draw_feedback.frag")),
drawSurfelProgram(loadProgramFromFile("draw_global_surface.vert", "draw_global_surface.frag", "draw_global_surface.geom")),
dataProgram(loadProgramFromFile("data.vert", "data.frag", "data.geom")),
updateProgram(loadProgramFromFile("update.vert")),
unstableProgram(loadProgramGeomFromFile("copy_unstable.vert", "copy_unstable.geom")),
renderBuffer(TEXTURE_DIMENSION, TEXTURE_DIMENSION),
updateMapVertsConfs(TEXTURE_DIMENSION, TEXTURE_DIMENSION, GL_RGBA32F, GL_LUMINANCE, GL_FLOAT),
updateMapColorsTime(TEXTURE_DIMENSION, TEXTURE_DIMENSION, GL_RGBA32F, GL_LUMINANCE, GL_FLOAT),
updateMapNormsRadii(TEXTURE_DIMENSION, TEXTURE_DIMENSION, GL_RGBA32F, GL_LUMINANCE, GL_FLOAT),
deformationNodes(NODE_TEXTURE_DIMENSION, 1, GL_LUMINANCE32F_ARB, GL_LUMINANCE, GL_FLOAT)
{
vbos = new std::pair<GLuint, GLuint>[2];
float * vertices = new float[bufferSize];
memset(&vertices[0], 0, bufferSize);
glGenTransformFeedbacks(1, &vbos[0].second);
glGenBuffers(1, &vbos[0].first);
glBindBuffer(GL_ARRAY_BUFFER, vbos[0].first);
glBufferData(GL_ARRAY_BUFFER, bufferSize, &vertices[0], GL_STREAM_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenTransformFeedbacks(1, &vbos[1].second);
glGenBuffers(1, &vbos[1].first);
glBindBuffer(GL_ARRAY_BUFFER, vbos[1].first);
glBufferData(GL_ARRAY_BUFFER, bufferSize, &vertices[0], GL_STREAM_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
delete [] vertices;
vertices = new float[Resolution::getInstance().numPixels() * Vertex::SIZE];
memset(&vertices[0], 0, Resolution::getInstance().numPixels() * Vertex::SIZE);
glGenTransformFeedbacks(1, &newUnstableFid);
glGenBuffers(1, &newUnstableVbo);
glBindBuffer(GL_ARRAY_BUFFER, newUnstableVbo);
glBufferData(GL_ARRAY_BUFFER, Resolution::getInstance().numPixels() * Vertex::SIZE, &vertices[0], GL_STREAM_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
delete [] vertices;
std::vector<Eigen::Vector2f> uv;
for(int i = 0; i < Resolution::getInstance().width(); i++)
{
for(int j = 0; j < Resolution::getInstance().height(); j++)
{
uv.push_back(Eigen::Vector2f(((float)i / (float)Resolution::getInstance().width()) + 1.0 / (2 * (float)Resolution::getInstance().width()),
((float)j / (float)Resolution::getInstance().height()) + 1.0 / (2 * (float)Resolution::getInstance().height())));
}
}
uvSize = uv.size();
glGenBuffers(1, &uvo);
glBindBuffer(GL_ARRAY_BUFFER, uvo);
glBufferData(GL_ARRAY_BUFFER, uvSize * sizeof(Eigen::Vector2f), &uv[0], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
frameBuffer.AttachColour(*updateMapVertsConfs.texture);
frameBuffer.AttachColour(*updateMapColorsTime.texture);
frameBuffer.AttachColour(*updateMapNormsRadii.texture);
frameBuffer.AttachDepth(renderBuffer);
updateProgram->Bind();
int locUpdate[3] =
{
glGetVaryingLocationNV(updateProgram->programId(), "vPosition0"),
glGetVaryingLocationNV(updateProgram->programId(), "vColor0"),
glGetVaryingLocationNV(updateProgram->programId(), "vNormRad0"),
};
glTransformFeedbackVaryingsNV(updateProgram->programId(), 3, locUpdate, GL_INTERLEAVED_ATTRIBS);
updateProgram->Unbind();
dataProgram->Bind();
int dataUpdate[3] =
{
glGetVaryingLocationNV(dataProgram->programId(), "vPosition0"),
glGetVaryingLocationNV(dataProgram->programId(), "vColor0"),
glGetVaryingLocationNV(dataProgram->programId(), "vNormRad0"),
};
glTransformFeedbackVaryingsNV(dataProgram->programId(), 3, dataUpdate, GL_INTERLEAVED_ATTRIBS);
dataProgram->Unbind();
unstableProgram->Bind();
int unstableUpdate[3] =
{
glGetVaryingLocationNV(unstableProgram->programId(), "vPosition0"),
glGetVaryingLocationNV(unstableProgram->programId(), "vColor0"),
glGetVaryingLocationNV(unstableProgram->programId(), "vNormRad0"),
};
glTransformFeedbackVaryingsNV(unstableProgram->programId(), 3, unstableUpdate, GL_INTERLEAVED_ATTRIBS);
unstableProgram->Unbind();
initProgram->Bind();
int locInit[3] =
{
glGetVaryingLocationNV(initProgram->programId(), "vPosition0"),
glGetVaryingLocationNV(initProgram->programId(), "vColor0"),
glGetVaryingLocationNV(initProgram->programId(), "vNormRad0"),
};
glTransformFeedbackVaryingsNV(initProgram->programId(), 3, locInit, GL_INTERLEAVED_ATTRIBS);
glGenQueries(1, &countQuery);
//Empty both transform feedbacks
glEnable(GL_RASTERIZER_DISCARD);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, vbos[0].second);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbos[0].first);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, 0);
glEndTransformFeedback();
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, vbos[1].second);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbos[1].first);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, 0);
glEndTransformFeedback();
glDisable(GL_RASTERIZER_DISCARD);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
initProgram->Unbind();
}
JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_NVTransformFeedback_nglGetVaryingLocationNV(JNIEnv *__env, jclass clazz, jint program, jlong nameAddress) {
glGetVaryingLocationNVPROC glGetVaryingLocationNV = (glGetVaryingLocationNVPROC)tlsGetFunction(2152);
intptr_t name = (intptr_t)nameAddress;
UNUSED_PARAM(clazz)
return (jint)glGetVaryingLocationNV(program, name);
}
