things I initialize at the beginning of the program I realize not all of these pertain to my issue I just copy and pasted what I had //overall initialized

//things openGL related I initialize earlier on in the project

glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );

glClearDepth( 1.0f );
glEnable(GL_ALPHA_TEST);

glEnable( GL_STENCIL_TEST );

glEnable(GL_DEPTH_TEST);
glDepthFunc( GL_LEQUAL );

glEnable(GL_CULL_FACE);
glFrontFace( GL_CCW );

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );

//we also initialize our shader programs
//(i added some shader program functions for definitions)

//this enum list is else where in code
//i figured it would help show you guys more about my
//shader compile creation function right under this enum list VVVVVV
/*enum eSHADER_ATTRIB_LOCATION
{ 
    VERTEX_ATTRIB = 0, 
    NORMAL_ATTRIB = 2,
    COLOR_ATTRIB,
    COLOR2_ATTRIB,
    FOG_COORD,
    TEXTURE_COORD_ATTRIB0 = 8,
    TEXTURE_COORD_ATTRIB1,
    TEXTURE_COORD_ATTRIB2,
    TEXTURE_COORD_ATTRIB3,
    TEXTURE_COORD_ATTRIB4,
    TEXTURE_COORD_ATTRIB5,
    TEXTURE_COORD_ATTRIB6,
    TEXTURE_COORD_ATTRIB7
}; */


//if we fail making our shader leave
if( !testShader.CreateShader( "SimpleShader.vp", "SimpleShader.fp", 3,
                               VERTEX_ATTRIB, "vVertexPos", 
                               NORMAL_ATTRIB,  "vNormal", 
                               TEXTURE_COORD_ATTRIB0, "vTexCoord" ) )
    return false;

if( !testScreenShader.CreateShader( "ScreenShader.vp", "ScreenShader.fp", 3,
                                    VERTEX_ATTRIB, "vVertexPos",
                                    NORMAL_ATTRIB, "vNormal",
                                    TEXTURE_COORD_ATTRIB0, "vTexCoord" ) )
    return false;

SHADER PROGRAM FUNCTIONS

bool CShaderProgram::CreateShader( const char* szVertexShaderName,
                                   const char* szFragmentShaderName, ... )
{
    //here are our handles for the openGL shaders
    int iGLVertexShaderHandle = -1, iGLFragmentShaderHandle = -1;

    //get our shader data
    char *vData = 0, *fData = 0;
    int vLength = 0, fLength = 0;

    LoadShaderFile( szVertexShaderName, &vData, &vLength );
    LoadShaderFile( szFragmentShaderName, &fData, &fLength );

    //data
    if( !vData )
        return false;

    //data
    if( !fData )
    {
        delete[] vData;
        return false;
    }

    //create both our shader objects
    iGLVertexShaderHandle = glCreateShader( GL_VERTEX_SHADER );
    iGLFragmentShaderHandle = glCreateShader( GL_FRAGMENT_SHADER );

    //well we got this far so we have dynamic data to clean up


    //load vertex shader
    glShaderSource( iGLVertexShaderHandle, 1, (const char**)(&vData), &vLength );

    //load fragment shader
    glShaderSource( iGLFragmentShaderHandle, 1, (const char**)(&fData), &fLength );

    //we are done with our data delete it
    delete[] vData;
    delete[] fData;

    //compile them both
    glCompileShader( iGLVertexShaderHandle );

    //get shader status
    int iShaderOk;
    glGetShaderiv( iGLVertexShaderHandle, GL_COMPILE_STATUS, &iShaderOk );

    if( iShaderOk == GL_FALSE )
    {
        char* buffer;

        //get what happend with our shader
        glGetShaderiv( iGLVertexShaderHandle, GL_INFO_LOG_LENGTH, &iShaderOk );
        buffer = new char[iShaderOk];
        glGetShaderInfoLog( iGLVertexShaderHandle, iShaderOk, NULL, buffer );

        //sprintf_s( buffer, "Failure Our Object For %s was not created", szFileName );
        MessageBoxA( NULL, buffer, szVertexShaderName, MB_OK );

        //delete our dynamic data
        free( buffer );

        glDeleteShader(iGLVertexShaderHandle);
        return false;
    }

    glCompileShader( iGLFragmentShaderHandle );

    //get shader status
    glGetShaderiv( iGLFragmentShaderHandle, GL_COMPILE_STATUS, &iShaderOk );

    if( iShaderOk == GL_FALSE )
    {
        char* buffer;

        //get what happend with our shader
        glGetShaderiv( iGLFragmentShaderHandle, GL_INFO_LOG_LENGTH, &iShaderOk );
        buffer = new char[iShaderOk];
        glGetShaderInfoLog( iGLFragmentShaderHandle, iShaderOk, NULL, buffer );

        //sprintf_s( buffer, "Failure Our Object For %s was not created", szFileName );
        MessageBoxA( NULL, buffer, szFragmentShaderName, MB_OK );

        //delete our dynamic data
        free( buffer );

        glDeleteShader(iGLFragmentShaderHandle);
        return false;
    }

    //lets check to see if the fragment shader compiled
    int iCompiled = 0;
    glGetShaderiv( iGLVertexShaderHandle, GL_COMPILE_STATUS, &iCompiled );

    if( !iCompiled )
    {
        //this shader did not compile leave
        return false;
    }

    //lets check to see if the fragment shader compiled
    glGetShaderiv( iGLFragmentShaderHandle, GL_COMPILE_STATUS, &iCompiled );

    if( !iCompiled )
    {
        char* buffer;

        //get what happend with our shader
        glGetShaderiv( iGLFragmentShaderHandle, GL_INFO_LOG_LENGTH, &iShaderOk );
        buffer = new char[iShaderOk];
        glGetShaderInfoLog( iGLFragmentShaderHandle, iShaderOk, NULL, buffer );

        //sprintf_s( buffer, "Failure Our Object For %s was not created", szFileName );
        MessageBoxA( NULL, buffer, szFragmentShaderName, MB_OK );

        //delete our dynamic data
        free( buffer );

        glDeleteShader(iGLFragmentShaderHandle);
        return false;
    }

    //make our new shader program
    m_iShaderProgramHandle = glCreateProgram();

    glAttachShader( m_iShaderProgramHandle, iGLVertexShaderHandle );
    glAttachShader( m_iShaderProgramHandle, iGLFragmentShaderHandle );

    glLinkProgram( m_iShaderProgramHandle );

    int iLinked = 0;
    glGetProgramiv( m_iShaderProgramHandle, GL_LINK_STATUS, &iLinked );

    if( !iLinked )
    {
        //we didn't link
        return false;
    }

    //NOW LETS CREATE ALL OUR HANDLES TO OUR PROPER LIKING

    //start from this parameter
    va_list parseList;
    va_start( parseList, szFragmentShaderName );

    //read in number of variables if any
    unsigned uiNum = 0;
    uiNum = va_arg( parseList, unsigned );

    //for loop through our attribute pairs
    int enumType = 0;
    for( unsigned x = 0; x < uiNum; ++x )
    {
        //specify our attribute locations
        enumType = va_arg( parseList, int );
        char* name = va_arg( parseList, char* );
        glBindAttribLocation( m_iShaderProgramHandle, enumType, name );
    }

    //end our list parsing
    va_end( parseList );

    //relink specify
    //we have custom specified our attribute locations
    glLinkProgram( m_iShaderProgramHandle );

    //fill our handles
    InitializeHandles( );

    //everything went great
    return true;
}

void CShaderProgram::InitializeHandles( void )
{
    m_uihMVP = glGetUniformLocation( m_iShaderProgramHandle, "mMVP" );

    m_uihWorld = glGetUniformLocation( m_iShaderProgramHandle, "mWorld" );

    m_uihView = glGetUniformLocation( m_iShaderProgramHandle, "mView" );

    m_uihProjection = glGetUniformLocation( m_iShaderProgramHandle, "mProjection" );

    /////////////////////////////////////////////////////////////////////////////////
    //texture handles

    m_uihDiffuseMap = glGetUniformLocation( m_iShaderProgramHandle, "diffuseMap" );
    if( m_uihDiffuseMap != -1 )
    {
        //store what texture index this handle will be in the shader
        glUniform1i( m_uihDiffuseMap, RM_DIFFUSE+GL_TEXTURE0 ); (0)+
    }

    m_uihNormalMap = glGetUniformLocation( m_iShaderProgramHandle, "normalMap" );
    if( m_uihNormalMap != -1 )
    {   
        //store what texture index this handle will be in the shader
        glUniform1i( m_uihNormalMap, RM_NORMAL+GL_TEXTURE0  ); (1)+
    }
}

void CShaderProgram::SetDiffuseMap( const unsigned& uihDiffuseMap )
{                     (0)+
    glActiveTexture( RM_DIFFUSE+GL_TEXTURE0 );
    glBindTexture( GL_TEXTURE_2D, uihDiffuseMap );
}

void CShaderProgram::SetNormalMap( const unsigned& uihNormalMap )
{                      (1)+
    glActiveTexture( RM_NORMAL+GL_TEXTURE0 );
    glBindTexture( GL_TEXTURE_2D, uihNormalMap );
}

//MY 2 TEST SHADERS also my math order is correct it pertains to my matrix ordering in my math library once again i've tested the basic rendering. rendering to the screen works fine ----------------------------------------SIMPLE SHADER-------------------------------------

//vertex shader looks like this

#version 330

in vec3 vVertexPos;
in vec3 vNormal;
in vec2 vTexCoord;

uniform mat4 mWorld;     // Model Matrix
uniform mat4 mView;  // Camera View Matrix
uniform mat4 mProjection;// Camera Projection Matrix

out vec2 vTexCoordVary; // Texture coord to the fragment program
out vec3 vNormalColor;

void main( void )
{
    //pass the texture coordinate
    vTexCoordVary = vTexCoord;
    vNormalColor = vNormal;

    //calculate our model view projection matrix
    mat4 mMVP = (( mWorld  * mView ) * mProjection );

    //result our position
    gl_Position = vec4( vVertexPos, 1 ) * mMVP;
}

//fragment shader looks like this

#version 330

in vec2 vTexCoordVary;
in vec3 vNormalColor;

uniform sampler2D diffuseMap;
uniform sampler2D normalMap;

out vec4 fragColor[2];

void main( void )
{
    //CORRECT
    fragColor[0] = texture( normalMap, vTexCoordVary );
    fragColor[1] = vec4( vNormalColor, 1.0 );
};

----------------------------------------SCREEN SHADER-------------------------------------

//vertext shader looks like this

#version 330

in vec3 vVertexPos; // This is the position of the vertex coming in
in vec2 vTexCoord; // This is the texture coordinate....

out vec2 vTexCoordVary; // Texture coord to the fragment program

void main( void )
{
    vTexCoordVary = vTexCoord;

    //set our position
    gl_Position = vec4( vVertexPos.xyz, 1.0f );
}

//fragment shader looks like this

#version 330

in vec2 vTexCoordVary;  // Incoming "varying" texture coordinate

uniform sampler2D diffuseMap;//the tile detail texture
uniform sampler2D normalMap; //the normal map from earlier

out vec4 vTheColorOfThePixel;

void main( void )
{

    //CORRECT
    vTheColorOfThePixel = texture( normalMap, vTexCoordVary );
};

.Class RenderTarget Main Functions

//here is my render targets create function
bool CRenderTarget::Create( const unsigned uiNumTextures,
                            unsigned uiWidth,
                            unsigned uiHeight,
                            int iInternalFormat,
                            bool bDepthWanted )
{
    if( uiNumTextures <= 0 )
        return false;

    //generate our variables
    glGenFramebuffers(1, &m_uifboHandle);

    // Initialize FBO
    glBindFramebuffer(GL_FRAMEBUFFER, m_uifboHandle);

    m_uiNumTextures = uiNumTextures;

    if( bDepthWanted )
        m_uiNumTextures += 1; 

    m_uiTextureHandle = new unsigned int[uiNumTextures];
    glGenTextures( uiNumTextures, m_uiTextureHandle );

    for( unsigned x = 0; x < uiNumTextures-1; ++x )
    {
        glBindTexture( GL_TEXTURE_2D, m_uiTextureHandle[x]);

        // Reserve space for our 2D render target
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        glTexImage2D(GL_TEXTURE_2D, 0, iInternalFormat, uiWidth, uiHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + x, GL_TEXTURE_2D, m_uiTextureHandle[x], 0); 
    }

    //if we need one for depth testing
    if( bDepthWanted )
    {
        glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_uiTextureHandle[uiNumTextures-1], 0);
        glFramebufferTexture2D(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_uiTextureHandle[uiNumTextures-1], 0);*/
        // Must attach texture to framebuffer. Has Stencil and depth
        glBindRenderbuffer(GL_RENDERBUFFER, m_uiTextureHandle[uiNumTextures-1]);
        glRenderbufferStorage(GL_RENDERBUFFER, /*GL_DEPTH_STENCIL*/GL_DEPTH24_STENCIL8, TEXTURE_WIDTH, TEXTURE_HEIGHT );
        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_uiTextureHandle[uiNumTextures-1]);
        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_uiTextureHandle[uiNumTextures-1]);
    }

    glBindFramebuffer(GL_FRAMEBUFFER, 0);

    //everything went fine
    return true;
}

void CRenderTarget::Bind(   const int& iTargetAttachmentLoc,
                            const unsigned& uiWhichTexture,
                            const bool bBindFrameBuffer )
{
    if( bBindFrameBuffer )
        glBindFramebuffer( GL_FRAMEBUFFER, m_uifboHandle );

    if( uiWhichTexture < m_uiNumTextures )
        glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + iTargetAttachmentLoc, m_uiTextureHandle[uiWhichTexture], 0);    
}

void CRenderTarget::UnBind( void )
{
    //default our binding
    glBindFramebuffer( GL_FRAMEBUFFER, 0 );
}

//this is all in a test project so here's my straight forward rendering function for testing

this render function does basic rendering steps keep in mind i have already tested my textures i have already tested my box thats being rendered all basic rendering works fine its just when i try to render to a texture then display it in a render surface that it does not work. Also I have tested my render surface it is bound exactly to the screen coordinate space

void TestRenderSteps( void )
{
    //Clear the color and the depth
    glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    //bind the shader program
    glUseProgram( testShader.m_iShaderProgramHandle );

    //1) grab the vertex buffer related to our rendering
    glBindBuffer( GL_ARRAY_BUFFER, CVertexBufferManager::GetInstance()->GetPositionNormalTexBuffer().GetBufferHandle() );

    //2) how our stream will be split here ( 4 bytes position, ..ext ) 
    CVertexBufferManager::GetInstance()->GetPositionNormalTexBuffer().MapVertexStride();

    //3) set the index buffer if needed
    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, CIndexBuffer::GetInstance()->GetBufferHandle() );

    //send the needed information into the shader
    testShader.SetWorldMatrix( boxPosition );
    testShader.SetViewMatrix( Static_Camera.GetView( ) );
    testShader.SetProjectionMatrix( Static_Camera.GetProjection( ) );

    testShader.SetDiffuseMap( iTextureID );
    testShader.SetNormalMap( iTextureID2 );

    GLenum buffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
    glDrawBuffers(2, buffers);

    //bind to our render target
    //RM_DIFFUSE, RM_NORMAL are enums (0 && 1)
    renderTarget.Bind( RM_DIFFUSE, 1, true );
    renderTarget.Bind( RM_NORMAL, 1, false); //false because buffer is already bound

    //i clear here just to clear the texture to make it a default value of white
    //by doing this i can see if what im rendering to my screen is just drawing to the screen
    //or if its my render target defaulted
    glClearColor( 1.0f, 1.0f, 1.0f, 1.0f );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    //i have this box object which i draw
    testBox.Draw();

    //the draw call looks like this 
    //my normal rendering works just fine so i know this draw is fine
    // glDrawElementsBaseVertex( m_sides[x].GetPrimitiveType(),
    //                           m_sides[x].GetPrimitiveCount() * 3,
    //                           GL_UNSIGNED_INT,
    //                           BUFFER_OFFSET(sizeof(unsigned int) * m_sides[x].GetStartIndex()),
    //                           m_sides[x].GetStartVertex( ) );

    //we unbind the target back to default
    renderTarget.UnBind();

    //i stop mapping my vertex format
    CVertexBufferManager::GetInstance()->GetPositionNormalTexBuffer().UnMapVertexStride();

    //i go back to default in using no shader program
    glUseProgram( 0 );

    //now that everything is drawn to the textures
    //lets draw our screen surface and pass it our 2 filled out textures

    //NOW RENDER THE TEXTURES WE COLLECTED TO THE SCREEN QUAD
    //bind the shader program
    glUseProgram( testScreenShader.m_iShaderProgramHandle );

    //1) grab the vertex buffer related to our rendering
    glBindBuffer( GL_ARRAY_BUFFER, CVertexBufferManager::GetInstance()->GetPositionTexBuffer().GetBufferHandle() );

    //2) how our stream will be split here
    CVertexBufferManager::GetInstance()->GetPositionTexBuffer().MapVertexStride();

    //3) set the index buffer if needed
    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, CIndexBuffer::GetInstance()->GetBufferHandle() );

    //pass our 2 filled out textures (in the shader im just using the diffuse
    //i wanted to see if i was rendering anything before i started getting into other techniques
    testScreenShader.SetDiffuseMap( renderTarget.GetTextureHandle(0) );  //SetDiffuseMap definitions in shader program class
    testScreenShader.SetNormalMap( renderTarget.GetTextureHandle(1) );   //SetNormalMap definitions in shader program class

    //DO the draw call drawing our screen rectangle
    glDrawElementsBaseVertex( m_ScreenRect.GetPrimitiveType(),
                              m_ScreenRect.GetPrimitiveCount() * 3,
                              GL_UNSIGNED_INT,
                              BUFFER_OFFSET(sizeof(unsigned int) * m_ScreenRect.GetStartIndex()),
                              m_ScreenRect.GetStartVertex( ) );*/

    //unbind our vertex mapping
    CVertexBufferManager::GetInstance()->GetPositionTexBuffer().UnMapVertexStride();

    //default to no shader program
    glUseProgram( 0 );
}

Last words:

1) I can render my box just fine

2) i can render my screen rect just fine

3) I cannot render my box into a texture then display it into my screen rect

4) This entire project is just a test project I made to test different rendering practices. So excuse any "ugly-ish" unclean code. This was made just on a fly run through when I was trying new test cases.