void ParticleRenderer::_initGL()
{
m_program = _compileProgram(vertexShader, spherePixelShader);
#if !defined(__APPLE__) && !defined(MACOSX)
glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, GL_FALSE);
glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, GL_FALSE);
#endif
}
void glut_viewer_hdr_init() {
glut_viewer_get_screen_size(&WINDOW_WIDTH, &WINDOW_HEIGHT) ;
if(!InitShaders()) {
std::cerr << "could not init shaders" << std::endl ;
exit(-1) ;
}
if(!InitFBO()) {
std::cerr << "could not init FBO" << std::endl ;
exit(-1) ;
}
glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, GL_FALSE) ;
glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, GL_FALSE) ;
InitBlur() ;
}
EXTERN_C_ENTER
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBColorBufferFloat_glClampColorARB(JNIEnv *__env, jclass clazz, jint target, jint clamp) {
glClampColorARBPROC glClampColorARB = (glClampColorARBPROC)tlsGetFunction(1097);
UNUSED_PARAM(clazz)
glClampColorARB(target, clamp);
}
void ParticleRenderer::_initGL()
{
m_program_sphere = _compileProgram(vertexShader_sphere, pixelShader_sphere);
m_program_cosmos = _compileProgram(vertexShader_cosmos, pixelShader_cosmos); _createTexture(32);
#if !defined(__APPLE__) && !defined(MACOSX)
glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, GL_FALSE);
glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, GL_FALSE);
#endif
// load floor texture
char imagePath[] = "../src/data/floortile.ppm";
if (imagePath == 0) {
fprintf(stderr, "Error finding floor image file\n");
fprintf(stderr, " FAILED\n");
exit(EXIT_FAILURE);
}
floorTex = loadTexture(imagePath);
// load sky texture
char imagePath2[] = "../src/data/pansky2.ppm";
if (imagePath2 == 0) {
fprintf(stderr, "Error finding floor image file\n");
fprintf(stderr, " FAILED\n");
exit(EXIT_FAILURE);
}
skyboxTex[0] = loadTexture("../src/data/faesky02back.ppm");
skyboxTex[1] = loadTexture("../src/data/faesky02down.ppm");
skyboxTex[2] = loadTexture("../src/data/faesky02front.ppm");
skyboxTex[3] = loadTexture("../src/data/faesky02left.ppm");
skyboxTex[4] = loadTexture("../src/data/faesky02right.ppm");
skyboxTex[5] = loadTexture("../src/data/faesky02up.ppm");
for (int i=0; i<6; i++){
glBindTexture(GL_TEXTURE_2D, skyboxTex[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 16.0f);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glBindTexture(GL_TEXTURE_2D, 0);
}
//floorProg = new GLSLProgram(floorVS, floorPS);
}
GLboolean test()
{
GLboolean pass = GL_TRUE;
unsigned read_clamp;
for(read_clamp = 0; read_clamp < 3; ++read_clamp)
{
unsigned clamped = clamp_enums[read_clamp] == GL_TRUE || (clamp_enums[read_clamp] == GL_FIXED_ONLY_ARB && fixed);
unsigned x, y;
float* expected;
printf("probe_pixel of fbo with read clamp %s (expecting %sclamping)\n", clamp_strings[read_clamp], clamped ? "" : "no ");
if (!sanity)
glClampColorARB(GL_CLAMP_READ_COLOR_ARB, clamp_enums[read_clamp]);
expected = clamped ? clamped_pixels :
fixed_snorm ? signed_clamped_pixels :
fixed ? clamped_pixels :
pixels;
for(y = 0; y < 2; ++y)
for(x = 0; x < 2; ++x)
{
GLboolean cpass = piglit_probe_pixel_rgba(x, y, expected + 8 * y + 4 * x);
GLboolean opass = cpass;
if(!cpass && clamped && ati_driver)
{
printf("ATI driver known bug: 1x1 glReadPixels ignores the read clamp!\n");
opass = GL_TRUE;
}
if(!cpass && nvidia_driver && clamped)
{
printf("nVidia driver known *** MAJOR BUG ***: they ignore the read clamp!\n");
opass = GL_TRUE;
}
pass = opass && pass;
}
}
if (!sanity)
glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);
return pass;
}
void CoreInit(void (GLUTCALLBACK *drawFunc)(void),int argc,char **argv)
{
glutInit(&argc, (char**)argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH);
glutInitWindowSize(SCREEN_SIZE_X, SCREEN_SIZE_Y);
glutInitWindowPosition(0, 0);
glutCreateWindow("Title");
glutDisplayFunc(drawFunc);
glutIdleFunc(drawFunc);
glutReshapeFunc(&CoreReshape);
glutSpecialFunc(&CorekeyDown1Static);
glutSpecialUpFunc(&CorekeyUp1Static);
glutKeyboardFunc(&CorekeyDown2Static);
glutKeyboardUpFunc(&CorekeyUp2Static);
glutMotionFunc(&CoreMouseMotionStatic);
glutPassiveMotionFunc(&CoreMouseMotionStatic);
glutMouseFunc (&CoreMouseButtonStatic);
glewInit();
std::cout << "GL_VERSION: " << glGetString(GL_VERSION) << std::endl; //std::cout << "GL_EXTENSIONS: " << glGetString(GL_EXTENSIONS) << std::endl;
std::cout << "GL_RENDERER: " << glGetString(GL_RENDERER) << std::endl;
std::cout << "GL_VENDOR: " << glGetString(GL_VENDOR) << std::endl;
std::cout << "GLU_VERSION: " << gluGetString(GLU_VERSION) << std::endl; //std::cout << "GLU_EXTENSIONS: " << gluGetString(GLU_EXTENSIONS) << std::endl;
std::cout << "GLUT_API_VERSION: " << GLUT_API_VERSION << std::endl;
int res[16];
#ifndef MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS
#define MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS 0x8E81
#endif
#ifndef MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS
#define MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS 0x8E82
#endif
glGetIntegerv(MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS,res);
printf("MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS %d\n",res[0]);
glGetIntegerv(MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS,res);
printf("MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS %d\n",res[0]);
wglSwapIntervalEXT(0);
//glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, GL_FALSE);CHECK_GL_ERROR();
//glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, GL_FALSE);CHECK_GL_ERROR();
glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);CHECK_GL_ERROR();
glClearDepth(1.0); // Enables Clearing Of The Depth Buffer
glDepthFunc(GL_LESS); // The Type Of Depth Test To Do
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glShadeModel(GL_SMOOTH); // Enables Smooth Color Shading
glEnable(GL_CULL_FACE);
glCullFace (GL_FRONT);
}
GLboolean test()
{
GLboolean pass = GL_TRUE;
unsigned vert_clamp, frag_clamp;
for (vert_clamp = 0; vert_clamp < (sanity ? 1 : 3); ++vert_clamp)
{
for (frag_clamp = sanity ? 1 : 0; frag_clamp < (sanity ? 2 : 3); ++frag_clamp)
{
GLboolean cpass;
GLboolean opass;
float* expected;
printf("glClear of fbo with vertex clamp %s and fragment clamp %s (expecting no clamping)\n", clamp_strings[vert_clamp], clamp_strings[frag_clamp]);
if (!sanity) {
glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, clamp_enums[vert_clamp]);
glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, clamp_enums[frag_clamp]);
}
glClearColor(pixels[0], pixels[1], pixels[2], pixels[3]);
glClear(GL_COLOR_BUFFER_BIT);
expected = fixed ? (fixed_snorm ? signed_clamped_pixels : clamped_pixels) : pixels;
cpass = piglit_probe_pixel_rgba(0, 0, expected);
opass = cpass;
if(!cpass && ati_driver && format == GL_RGBA16F_ARB)
{
printf("ATI driver known *** MAJOR BUG ***: they always clamp clears for fp16 targets!\n");
opass = GL_TRUE;
}
pass = opass && pass;
}
}
return pass;
}
void GLRenderer::init(Device *device, Renderer *other) {
Renderer::init(device, other);
m_driverRenderer = (char *) glGetString(GL_RENDERER);
m_driverVendor = (char *) glGetString(GL_VENDOR);
m_driverVersion = (char *) glGetString(GL_VERSION);
Log(m_logLevel, "OpenGL renderer : %s", m_driverRenderer.c_str());
Log(m_logLevel, "OpenGL vendor : %s", m_driverVendor.c_str());
Log(m_logLevel, "OpenGL version : %s", m_driverVersion.c_str());
/* OpenGL extensions */
GLenum err = glewInit();
if (err != GLEW_OK)
Log(EError, "GLEW Error: %s\n", glewGetErrorString(err));
if (glewIsSupported("GL_EXT_framebuffer_object")) {
m_capabilities->setSupported(
RendererCapabilities::ERenderToTexture, true);
Log(m_logLevel, "Capabilities: Framebuffers objects are supported.");
} else {
Log(m_warnLogLevel, "Capabilities: Framebuffers objects are NOT supported!");
}
if (glewIsSupported("GL_ARB_shading_language_100")) {
m_capabilities->setSupported(
RendererCapabilities::EShadingLanguage, true);
Log(m_logLevel, "Capabilities: GLSL is supported.");
} else {
Log(m_warnLogLevel, "Capabilities: GLSL is NOT supported!");
}
if (glewIsSupported("GL_ARB_texture_float")) {
m_capabilities->setSupported(
RendererCapabilities::EFloatingPointTextures, true);
Log(m_logLevel, "Capabilities: Floating point textures are supported.");
} else {
Log(m_warnLogLevel, "Capabilities: Floating point textures are NOT supported!");
}
if (glewIsSupported("GL_ARB_color_buffer_float")) {
m_capabilities->setSupported(
RendererCapabilities::EFloatingPointBuffer, true);
Log(m_logLevel, "Capabilities: Floating point color buffers are supported.");
} else {
Log(m_warnLogLevel, "Capabilities: Floating point color buffers are NOT supported!");
}
if (glewIsSupported("GL_EXT_framebuffer_blit")) {
m_capabilities->setSupported(
RendererCapabilities::EBufferBlit, true);
Log(m_logLevel, "Capabilities: Fast buffer blitting is supported.");
} else {
Log(m_warnLogLevel, "Capabilities: Fast buffer blitting is NOT supported!");
}
if (glewIsSupported("GL_EXT_framebuffer_multisample") &&
glewIsSupported("GL_EXT_framebuffer_blit") &&
glewIsSupported("GL_ARB_texture_multisample")) {
m_capabilities->setSupported(
RendererCapabilities::EMultisampleRenderToTexture, true);
Log(m_logLevel, "Capabilities: Multisample framebuffer objects are supported.");
} else {
Log((m_warnLogLevel == EWarn) ? EInfo : m_warnLogLevel,
"Capabilities: Multisample framebuffer objects are NOT supported!");
}
if (glewIsSupported("GL_ARB_vertex_buffer_object")) {
m_capabilities->setSupported(
RendererCapabilities::EVertexBufferObjects, true);
Log(m_logLevel, "Capabilities: Vertex buffer objects are supported.");
} else {
Log(m_warnLogLevel, "Capabilities: Vertex buffer objects are NOT supported!");
}
if (glewIsSupported("GL_EXT_geometry_shader4") && glewIsSupported("GL_EXT_gpu_shader4")) {
m_capabilities->setSupported(
RendererCapabilities::EGeometryShaders, true);
Log(m_logLevel, "Capabilities: Geometry shaders are supported.");
} else {
Log(m_warnLogLevel, "Capabilities: Geometry shaders are NOT supported!");
}
if (glewIsSupported("GL_ARB_shader_texture_lod") || glewIsSupported("GL_EXT_gpu_shader4")) {
m_capabilities->setSupported(
RendererCapabilities::ECustomTextureFiltering, true);
Log(m_logLevel, "Capabilities: Custom texture filtering is supported.");
} else {
Log(m_warnLogLevel, "Capabilities: Custom texture filtering is NOT supported.");
}
bool radeonOnOSX = false;
#if defined(__OSX__)
/* Synchronization objects cause problem with ATI cards on OSX -- ignore
them even if the driver claims to support it */
radeonOnOSX = boost::to_lower_copy(m_driverRenderer).find("radeon") != std::string::npos;
#endif
if (glewIsSupported("GL_ARB_sync") && !radeonOnOSX) {
m_capabilities->setSupported(
RendererCapabilities::ESyncObjects, true);
Log(m_logLevel, "Capabilities: Synchronization objects are supported.");
} else {
Log(m_warnLogLevel, "Capabilities: Synchronization objects are NOT supported!");
}
if (glewIsSupported("GL_NV_vertex_buffer_unified_memory")) {
m_capabilities->setSupported(
RendererCapabilities::EBindless, true);
Log(m_logLevel, "Capabilities: Bindless rendering is supported.");
} else {
Log((m_warnLogLevel == EWarn) ? EInfo : m_warnLogLevel,
"Capabilities: Bindless rendering is NOT supported!");
}
/* Hinting */
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
/* Disable color value clamping */
if (m_capabilities->isSupported(
RendererCapabilities::EFloatingPointBuffer)) {
glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, GL_FALSE);
glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);
glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, GL_FALSE);
}
/* Clip to viewport */
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
setBlendMode(EBlendNone);
glEnable(GL_POINT_SMOOTH);
m_normalsEnabled = false;
m_texcoordsEnabled = false;
m_tangentsEnabled = false;
m_colorsEnabled = false;
m_stride = -1;
m_queuedTriangles = 0;
m_transmitOnlyPositions = false;
checkError();
}
void generateFBO()
{
//GLfloat borderColor[4] = {0,0,0,0};
GLenum FBOstatus;
glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, GL_FALSE);
glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FALSE);
glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, GL_FALSE);
int i;
for (i=0; i<2; i++)
{
GLuint *id = &fieldTexIds[i];
glGenTextures(1, id);
glBindTexture(GL_TEXTURE_2D, *id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
// Remove artefact on the edges
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
//glTexParameterfv( GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor );
// No need to force GL_DEPTH_COMPONENT24, drivers usually give you the max precision if available
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA32F_ARB,
field_width, field_height, 0, GL_RGBA,
GL_FLOAT, 0);
}
glBindTexture(GL_TEXTURE_2D, 0);
// create a framebuffer object
glGenFramebuffersEXT(1, &fboId);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboId);
// attach the texture to FBO color attachment point
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, fieldTexIds[0], 0);
// attach the texture to FBO color attachment point
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT,
GL_TEXTURE_2D, fieldTexIds[1], 0);
// check FBO status
FBOstatus = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if(FBOstatus != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf("GL_FRAMEBUFFER_COMPLETE_EXT failed, CANNOT use FBO\n");
exit(1);
}
glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
glClear( GL_COLOR_BUFFER_BIT);
glDrawBuffer(GL_COLOR_ATTACHMENT1_EXT);
glClear( GL_COLOR_BUFFER_BIT);
// switch back to window-system-provided framebuffer
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}
GLboolean test_one(unsigned vert_clamp, unsigned frag_clamp, unsigned semantic,
unsigned blend, unsigned logicop, unsigned vpmode, unsigned fpmode)
{
GLfloat probe[4];
char test_name[4096];
unsigned clamped = (semantic == 0 && (clamp_enums[vert_clamp] == GL_TRUE || (clamp_enums[vert_clamp] == GL_FIXED_ONLY_ARB && fixed))) || clamp_enums[frag_clamp] == GL_TRUE || (clamp_enums[frag_clamp] == GL_FIXED_ONLY_ARB && fixed);
float *expected;
GLboolean cpass;
GLboolean opass;
glFogi(GL_FOG_MODE, GL_LINEAR);
sprintf(test_name, "%s: Attrib %s VertClamp %s FragClamp %s Blending %s LogicOp %s %s %s Fog %s (expecting %sclamping)",
format_name,
semantic ? "TEXCOORD0" : "COLOR ",
clamp_strings[vert_clamp],
clamp_strings[frag_clamp],
blend_strings[blend],
logicop ? "Yes" : "No ",
vpmode ? "ARB_vp" : "ffvp ",
fpmode ? "ARB_fp" : "fffp ",
test_fog ? "Yes" : "No ",
clamped ? "" : "no ");
if (!sanity) {
glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, clamp_enums[vert_clamp]);
glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, clamp_enums[frag_clamp]);
}
glColor4f(0.1f, 0.2f, 0.3f, 0.4f);
glTexCoord4f(0.5f, 0.6f, 0.7f, 0.8f);
if (vpmode) {
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vps[semantic]);
glEnable(GL_VERTEX_PROGRAM_ARB);
}
else {
if (semantic == 0)
glColor4f(pixels[0], pixels[1], pixels[2], pixels[3]);
else
glTexCoord4f(pixels[0], pixels[1], pixels[2], pixels[3]);
}
if (fpmode) {
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fps[semantic + (test_fog ? 2 : 0)]);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
}
else {
if (test_fog)
glEnable(GL_FOG);
}
glClearColor(0.5, 0.5, 0.5, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
if (blend) {
glEnable(GL_BLEND);
glBlendFunc(blend_src[blend], blend_dst[blend]);
glBlendColor(2.0f, 2.0f, 2.0f, 2.0f);
}
if (logicop)
glEnable(GL_COLOR_LOGIC_OP);
piglit_draw_rect(-1, -1, 1, 1);
if (logicop)
glDisable(GL_COLOR_LOGIC_OP);
if (blend)
glDisable(GL_BLEND);
if (vpmode)
glDisable(GL_VERTEX_PROGRAM_ARB);
if (fpmode)
glDisable(GL_FRAGMENT_PROGRAM_ARB);
else if (test_fog)
glDisable(GL_FOG);
if (blend == 2 && !logicop) {
if (fixed_snorm)
expected = clamped ? clamped_pixels : signed_clamped_pixels;
else if (fixed)
expected = clamped_pixels;
else
expected = clamped ? clamped_pixels_mul_2 : pixels_mul_2;
}
else if (blend == 3 && !logicop) {
if (fixed_snorm)
expected = clamped ? clamped_pixels_plus_half_signed_clamped : signed_clamped_pixels_plus_half_signed_clamped;
else if (fixed)
expected = clamped_pixels_plus_half_clamped;
else
expected = clamped ? clamped_pixels_plus_half : pixels_plus_half;
}
else {
expected = clamped ? clamped_pixels :
fixed_snorm ? signed_clamped_pixels :
fixed ? clamped_pixels :
pixels;
}
opass = cpass = piglit_probe_pixel_rgba_silent(0, 0, expected, probe);
if (nvidia_driver && clamped && !(semantic == 0 && clamp_enums[vert_clamp] == GL_TRUE) && clamp_enums[frag_clamp] == GL_TRUE && !fixed && fpmode && (!blend || logicop || format == GL_RGBA16F_ARB)) {
printf("nVidia driver known *** MAJOR BUG ***: they don't clamp fragment program results with ARB_fp on either fp32 with no blending or fp16!\n");
opass = GL_TRUE;
}
if (nvidia_driver && clamped && !fixed && !fpmode && semantic == 0 && clamp_enums[vert_clamp] != GL_TRUE && clamp_enums[frag_clamp] == GL_TRUE) {
printf("nVidia driver known *** MAJOR BUG ***: they don't clamp fragment program results with fffp, vertex clamp off and fragment clamp on fp16/fp32!\n");
opass = GL_TRUE;
}
if (test_fog && fpmode) {
//printf("Unclear specification on GL_ARB_fog_*\n");
opass = GL_TRUE;
}
if (!opass) {
printf("%s: %s\n", (cpass ? "PASS" : "FAIL"), test_name);
printf(" Expected: %f %f %f %f\n", expected[0], expected[1], expected[2], expected[3]);
printf(" Observed: %f %f %f %f\n", probe[0], probe[1], probe[2], probe[3]);
}
return opass;
}
