void OpenGLInitialization( void ) { // We're drawing on a white background glClearColor(1.0, 1.0, 1.0, 1.0); // Convert our xyz curves into vertex arrays for (uint i=0; i<curves.Size(); i++) drawableCurves.Add( CurveToVertexArray( curves[i] ) ); // Covert our xyz curves into difference arrays. TODO: This is hard coded (our difference is // computed from either curve #0 or curve #6) for (uint i=0; i<curves.Size(); i++) errorCurves.Add( DifferenceToVertexArray( curves[i], curves[ i<6?0:6 ] ) ); // Load the shaders to draw our curves; set some parameters draw = new IGLUShaderProgram( "shaders/drawXYZCurve.vert.glsl", "shaders/drawXYZCurve.geom.glsl", "shaders/drawXYZCurve.frag.glsl" ); draw["xRange"] = vec2( 330.0f, 843.0f ); draw["yRange"] = vec2( -0.13f, 2.05f ); // Load the shader to draw our axes drawAxes = new IGLUShaderProgram( "shaders/drawAxes.vert.glsl", "shaders/drawAxes.frag.glsl" ); // Create the geometry for our axes axes = new IGLUVertexArray(); float axesData[] = { -0.90f, -0.88f, 0.95f, -0.88f, // x-axis line -0.88f, -0.88f, -0.88f, 0.95f, // y-axis line -0.90f, -0.6513f, -0.88f, -0.6513f, // 0.25 tick -0.90f, -0.4225f, -0.88f, -0.4225f, // 0.5 tick -0.90f, -0.1938f, -0.88f, -0.1938f, // 0.75 tick -0.90f, 0.035f, -0.88f, 0.035f, // 1.0 tick -0.90f, 0.2638f, -0.88f, 0.2638f, // 1.25 tick -0.90f, 0.4925f, -0.88f, 0.4925f, // 1.5 tick -0.90f, 0.7213f, -0.88f, 0.7213f, // 1.75 tick -0.90f, 0.95f, -0.88f, 0.95f, // 2.0 tick -0.7243f, -0.88f, -0.7243f, -0.91f, // 400 nm tick -0.5296f, -0.88f, -0.5296f, -0.91f, // 450 nm tick -0.3349f, -0.88f, -0.3349f, -0.91f, // 500 nm tick -0.1402f, -0.88f, -0.1402f, -0.91f, // 550 nm tick 0.0545f, -0.88f, 0.0545f, -0.91f, // 600 nm tick 0.24915f, -0.88f, 0.24915f, -0.91f, // 650 nm tick 0.4438f, -0.88f, 0.4438f, -0.91f, // 700 nm tick 0.6385f, -0.88f, 0.6385f, -0.91f, // 750 nm tick 0.8332f, -0.88f, 0.8332f, -0.91f, // 800 nm tick }; axes->SetVertexArray( sizeof( axesData ), axesData ); axes->EnableAttribute( IGLU_ATTRIB_VERTEX, 2, GL_FLOAT ); }
// Draw void display ( void ) { int j=0; glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glLineWidth( GLfloat(lineWidth) ); if (!useErrors) { // Bind and setup the shader draw->Enable(); draw["xRange"] = vec2( 330.0f, 843.0f ); draw["yRange"] = vec2( -0.13f, 2.05f ); draw["useXYZ"] = vec3( displayX ? 1.0f : 0.0f, displayY ? 1.0f : 0.0f, displayZ ? 1.0f : 0.0f ); // For each curve, check if it's selected to be display, if so, draw it for (uint i=0; i<drawableCurves.Size(); i++) { // Check if this curve was selected to be drawn if ( curveSelection[i]->GetValue() ) { draw["xColor"] = colorArr[j++]; draw["yColor"] = colorArr[j++]; draw["zColor"] = colorArr[j++]; drawableCurves[i]->DrawArrays( GL_LINE_STRIP, 0, 471 ); } } draw->Disable(); // After drawing the curve, draw the axes drawAxes->Enable(); axes->DrawArrays( GL_LINES, 0, 38 ); drawAxes->Disable(); } else { // Bind and setup the shader draw->Enable(); draw["xRange"] = vec2( 330.0f, 843.0f ); draw["yRange"] = vec2( -0.25f, 0.25f ); draw["useXYZ"] = vec3( displayX ? 1.0f : 0.0f, displayY ? 1.0f : 0.0f, displayZ ? 1.0f : 0.0f ); // For each curve, check if it's selected to be display, if so, draw it for (uint i=0; i<errorCurves.Size(); i++) { // Check if this curve was selected to be drawn if ( curveSelection[i]->GetValue() ) { draw["xColor"] = colorArr[j++]; draw["yColor"] = colorArr[j++]; draw["zColor"] = colorArr[j++]; errorCurves[i]->DrawArrays( GL_LINE_STRIP, 0, 471 ); } } draw->Disable(); } // Draw the labels for (int i=0; i<10; i++) IGLUDraw::DrawColorText( IGLU_FONT_VARIABLE, int(textOffsetFactor.X()*labels[i].x), int(textOffsetFactor.Y()*labels[i].y), color::Gray80, labels[i].name, textOffsetFactor.X() ); }
int main(int argc, char** argv) { // Load all the XYZ curves we might look at... curves.Add( new XYZ1931CIE1nm() ); curves.Add( new XYZ1931CIE10nm() ); curves.Add( new XYZ1931Binned30nm() ); curves.Add( new XYZSimpleGaussian1931() ); curves.Add( new XYZMultiLobeFit1931() ); curves.Add( new XYZMoonSpencer1945() ); curves.Add( new XYZ1964CIE1nm() ); curves.Add( new XYZSimpleGaussian1964() ); curves.Add( new XYZTannenbaum1974() ); // Setup our window IGLUWindow::Ptr myWin = new IGLUWindow( 800, 600, "XYZ Curve and Approximation Viewer \t [Press (+) for options.]" ); myWin->SetWindowProperties( IGLU_WINDOW_DOUBLE | IGLU_WINDOW_REDRAW_ON_IDLE ); myWin->SetDisplayCallback( display ); myWin->SetIdleCallback( idle ); myWin->SetKeyboardCallback( keys ); myWin->SetReshapeCallback( reshape ); myWin->SetPreprocessOnGLInit( OpenGLInitialization ); myWin->CreateWindow( argc, argv ); // We set the window up with a particular scaling for the label locations. // If we've changed the window resolution, we'll need to rescale textOffsetFactor = vec2( myWin->w()/800.0f, myWin->h()/600.0f ); // Create a widget window to allow us to interact/change our IGLUVariables uiWin = new IGLUWidgetWindow( 300, 600, "UI Widget Window" ); uiWin->AddWidget( &lineWidth ); uiWin->AddWidgetSpacer(); uiWin->AddWidget( &displayX ); uiWin->AddWidget( &displayY ); uiWin->AddWidget( &displayZ ); uiWin->AddWidgetSpacer(); // Convert these curves into vertex arrays for (uint i=0; i<curves.Size(); i++) { curveSelection.Add( new IGLUBool( i==0, curves[i]->CurveName() ) ); uiWin->AddWidget( curveSelection[i] ); } uiWin->AddWidgetSpacer(); uiWin->AddWidget( &useErrors ); myWin->SetWidgetWindow( uiWin ); // Start the FLTK interaction loop IGLUWindow::Run(); return 0; }
void IGLUShaderVariable::operator= ( const IGLUTexture *val ) { // Check for a valid shader index (else we have no variable to assign to!) if ( val == NULL || m_varIdx < 0 ) return; //Depending on whether we are binding image IGLUArray1D<IGLUShaderTexture *> *parentArr = 0; //Is the LHS a sampler or image type? bool lhsIsImage = IsImage(m_varType); if(lhsIsImage){ //Check for variable type mismatch if( HasImageTypeMismatch( val ) ) return; //We are going to modify the parent's array of images parentArr = &m_parent->m_activeImage; }else{ // Check for variable type mismatches. if ( HasTextureTypeMismatch( val ) ) return; parentArr = &m_parent->m_activeTex; } // OK. We now know we can do an assignment, lets get that setup. IGLUShaderTexture *ptr = 0; // 1) Look to see if we'd previously assigned a texture to this sampler // in the parent shader. If so, grab it's info. for (uint i=0; i < parentArr->Size(); i++) // Look through list of active samplers for the parent shader if ( (*parentArr)[i]->m_glslVarLoc == m_varIdx ) // Is this sampler the variable on the LHS of the assignment? ptr = (*parentArr)[i]; // If so, grab a pointer to its previously assigned tex struct. // 2) If we already have a data structure, lets replace/update that // texture with the one the user just specified. if (ptr) ptr->m_tex = val; // 3) If we haven't yet assigned a texture to this GLSL sampler, set up // a new structure with appropriate data, assign it the next available // texture unit (e.g., GL_TEXTURE4), and tell the shader to start // binding it whenever the shader is enabled. else { ptr = new IGLUShaderTexture(); // Create a structure for this sampler's texture. ptr->m_tex = val; // Remember the texture pointer for this sampler ptr->m_glslVarLoc = m_varIdx; // What's the linked uniform/sampler location in GLSL? ptr->m_texUnit = int( parentArr->Size() ); // What OpenGL texture unit did we assign? strncpy( ptr->m_texName, m_varName, 32 ); // Copy the GLSL sampler variable name. // Add this to the list of textures the shader knows about. parentArr->Add( ptr ); // Add a texture/unit/variable flag to the list store in the parent. // In particular, right now, this flag only stores if the variable/unit we've bound to // asks for a shadow sampler... In that case, we'll need to tell the texture we enable // that it should expect to be queried with a comparison operator, rather than as an image. m_parent->m_activeTexFlags.Add( IsShadowSampler( m_varType ) ? IGLU_SHADER_TEX_IS_SHADOW : IGLU_SHADER_TEX_DEFAULT ); // Tell the shader what texture unit to look on for this sampler m_parent->PushProgram(); glUniform1i( m_varIdx, ptr->m_texUnit ); m_parent->PopProgram(); } // If we're currently enabled, we'd better do the work the shader class // would normally do (in ShaderProgram::Enable()) to enable this texture. if (m_parent->IsEnabled() && ptr){ if(lhsIsImage) val->BindToImageUnit(ptr->m_texUnit); else val->Bind(GL_TEXTURE0 + ptr->m_texUnit); } }