int DoDataEncrypt(HWND hwnd, LPTSTR key, UINT numberOfRounds, bool isForwards){
    //fully functional as of Dec 06, 2013; 10:56am
#pragma region DECLARATIONS

    ///#pragma region n is a command to my editor for outlining purposes, does not affect the code at all

    LPTSTR buffer    = new TCHAR[CRYPTO_BUFFER_SIZE]; //our string of input data
    LPTSTR bufferOut;// = new TCHAR[CRYPTO_BUFFER_SIZE]; //our string of output data
    LPTSTR bufferKey;// = new TCHAR[CRYPTO_KEY_SIZE];
    LPTSTR roundKey  = new TCHAR[CRYPTO_KEY_SIZE];
    _tcscpy(roundKey, key);
    int inLenght; // simple check for possible buffer overflow

    //todo : add a zeroing function to these, set them all with a known slack value

    HWND hEdit;
    int debugReturn;
    GLint infoLogLength = 0; //used for errorchecking
    GLenum errString = glGetError();

#pragma endregion

#pragma region PREPARE_SHADER
#if SHADER_MODE
    glewExperimental = GL_TRUE; //due to compute shaders
    GLenum err = glewInit();
    if (GLEW_OK != err)
    {
        // Problem: glewInit failed, something is seriously wrong.
        fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
        const GLenum errString = glGetError();
        MessageBox(hwnd,
            _T(" glewInit() returned ")+(int)(GLint)err, //let's hope this doublecast from GLint to std int works
            _T("glewInit() failed, something is seriously wrong."),
            MB_OK | MB_ICONEXCLAMATION);

    }//end if
    //fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));
    //this section is a mix of book and Landon code.
    //const GLubyte* gluErrorString(GLenum errorCode);
    // BUG NOTE (Dec 12 2013, 10:52) : gglewInit was returning 1, but adding in the creator code for an openGL context in WinMain() appears to have resolved the issue


    // Create a shader, attach source, and compile.

    compute_shader = glCreateShader(GL_COMPUTE_SHADER);
    LPTSTR shaderName = _T("XOR.compute"); //
    GLchar * fSource = readShaderSourceT(shaderName); //(Dec 12 2013, 10:54)fScource returned null //(12:16 target file needs to be inside lower level file, probably "include" because of linking. Unsure due to multiple copies)//(12:20 not /include. not /Lib. It's for some reason the folder ABOVE the solution file)//(12:15 it has to be at the same level that the plaintext was DoFileLoad()ed from. That'll be annoying to fix, but it can wait.)
    if( fSource == NULL){
        const GLenum errString = glGetError();

        return SHADER_NOT_FOUND;
    }
    const GLchar ** compute_source = (const GLchar **)&fSource;
    glShaderSource(compute_shader, 1, compute_source, NULL);
    glCompileShader(compute_shader);

    //create a program, attach shader, link
    compute_program = glCreateProgram();
    glAttachShader(compute_program, compute_shader);
    glLinkProgram(compute_program);

    //TODO : set up the needed SSBO for the strings (after data import)
#endif
#pragma endregion
#pragma region DATA_IMPORTATION
    //hEdit = GetDlgItem(hwnd, IDC_MAIN_EDIT); /// dec 2, 4:27pm; not getting valid id, despite code being a copy from File Load Save
    hEdit = hEditGlobal;
    inLenght = GetWindowTextLength(hEdit); // simple check for possible buffer overflow


#pragma region SANITY_CHECKS
    if ( hEdit == 0 ){ //needs to check before DATA_TOO_BIG
        return PLAINTEXT_NOT_FOUND;
    }//end debugger if
    if ( _tcslen(key) > inLenght)
        return DATA_LESSTHAN_KEY; // also the result of a failure to aquire plaintext data
    if ( inLenght > CRYPTO_BUFFER_SIZE )
        return DATA_TOO_BIG;



    //int debugReturn;
    debugReturn =
        GetWindowText(hEdit, buffer, CRYPTO_BUFFER_SIZE); //dumps contents of 'hEdit' to 'buffer'.

#if DEBUG_OFF
    MessageBox(hwnd, key, "Notice",
                            MB_OK | MB_ICONINFORMATION);
#endif
#pragma endregion

#pragma region SHADER_STORAGE_BUFFER_OBJECTS
#if EXPERIMENT_ON
#pragma region KEY
    glGenBuffers(1, &keySSBO);
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, keySSBO);
    glBufferData(GL_SHADER_STORAGE_BUFFER,
        CRYPTO_KEY_SIZE*sizeof(TCHAR),
        NULL, //might not want to keep that as null, and replace with contents of LPTSTR key
        GL_STATIC_DRAW ); //might want GL_DYNAMIC_READ instead?

    GLint bufMask = GL_MAP_WRITE_BIT | GL_MAP_READ_BIT ; // the invalidate makes a big difference when re-writing
    // (Dec 12, 2:07 pm) invalidate bit removed, we're doing a full overwrite anyway


    bufferKey = (LPTSTR) glMapBufferRange( GL_SHADER_STORAGE_BUFFER, 0, CRYPTO_KEY_SIZE*sizeof(TCHAR), bufMask);
    // I'd rather use as simple of a string as I can afford
    //that appears to be bufferKey for now, will later use RoundKey
    if(bufferKey == NULL){
        errString = glGetError();
        return BUFFER_NOT_FOUND;
    }
    for (int i = 0; i < CRYPTO_KEY_SIZE; i++)
    {
        bufferKey[i] = roundKey[i]; // should move this section into the round loop
    }

    int chk;
    chk = glUnmapBuffer( GL_SHADER_STORAGE_BUFFER );
    errString = glGetError();


#if DEBUG_ON
    //should really be doing this before I unmap
    for (int i = 0; i < CRYPTO_KEY_SIZE; i++)
    {
        roundKey[i] = _T('0');
        roundKey[i] = bufferKey[i]; // should move this section into the round loop
    }
    MessageBox(hwnd,
            roundKey, //shaderName
            _T("Roundkey"),
            MB_OK | MB_ICONEXCLAMATION);
#endif

#pragma endregion
#pragma region TEXT
    if( bufferKey == NULL){
        errString = glGetError();
        return BUFFER_NOT_FOUND;
    }

    glGenBuffers(1, &txtSSBO);
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, txtSSBO);
    glBufferData(GL_SHADER_STORAGE_BUFFER,
        CRYPTO_BUFFER_SIZE*sizeof(TCHAR),
        NULL, //might not want to keep that as null, and replace with contents of LPTSTR key
        GL_STATIC_DRAW ); //might want GL_DYNAMIC_READ instead?

    bufferOut = (LPTSTR) glMapBufferRange( GL_SHADER_STORAGE_BUFFER, 0, CRYPTO_BUFFER_SIZE*sizeof(TCHAR), bufMask);
    for (int i = 0; i < CRYPTO_BUFFER_SIZE; i++)
    {
        bufferOut[i] = buffer[i];
    }
#if DEBUG_ON
    {
        LPTSTR checkout = new TCHAR[CRYPTO_BUFFER_SIZE];
        for (int i = 0; i < CRYPTO_BUFFER_SIZE; i++)
        {
            checkout[i] = bufferOut[i]; // should move this section into the round loop
        }
        MessageBox(hwnd,
                checkout, //contents of bufferOut
                _T("text buffer"),
                MB_OK | MB_ICONEXCLAMATION);
    }
#endif
//  glUnmapBuffer( GL_SHADER_STORAGE_BUFFER ); //holding onto this one until after the compute has run
    if( bufferKey == NULL){
        const GLenum errString = glGetError();
        return BUFFER_NOT_FOUND;
    }
#pragma endregion
    glBindBufferBase( GL_SHADER_STORAGE_BUFFER, 4, keySSBO );
    glBindBufferBase( GL_SHADER_STORAGE_BUFFER, 5, txtSSBO );

    errString = glGetError();
#if EXPERIMENT_OFF
    keyLengthLocation = glGetUniformLocation(compute_program, "keyByteLength");
    errString = glGetError();
#endif


#pragma endregion


#endif

#pragma endregion

    glUseProgram(compute_program);
    errString = glGetError();
    keyLengthLocation = 0;

    glUniform1ui(keyLengthLocation,  (int)CRYPTO_KEY_SIZE*sizeof(TCHAR)); // error 1282
    errString = glGetError();

#pragma region ACTUAL_ENCRYPTION
    if (isForwards == CRYPTO_FORWARDS)
    {
#if !SHADER_MODE
        for (int i = 0; i < numberOfRounds; i++)
        {
            //cpu functionality
            int chk = GetRoundKey(key, roundKey, i);

            CryptoCollisionCheck(hwnd, roundKey);
            encryptXORstep(hwnd, buffer, roundKey, bufferOut);
            _tcscpy(buffer,bufferOut); //so that the next loop will use the results of this loop
        }//end for number of rounds
#endif
#if SHADER_MODE

        infoLogLength = 0;

        glGetProgramiv(compute_program, GL_INFO_LOG_LENGTH, &infoLogLength) ;
        GLchar * debugLog = new GLchar[infoLogLength];
        glGetProgramInfoLog(compute_program, infoLogLength, &infoLogLength, debugLog);
        if( infoLogLength > 0 )
            MessageBoxA(hwnd,
                (LPSTR)debugLog,
                ("ProgramInfoLog"),
                MB_OK | MB_ICONEXCLAMATION);

        if ( CompileSuccessful(compute_shader) == FALSE)
                return SHADER_COMPILE_FAILED;
        if( LinkSuccessful(compute_program) == FALSE)
                return SHADER_LINK_FAILED;

        errString = glGetError();

        //glGetProgramResourceIndex(compute_program, GL_SHADER_STORAGE_BLOCK);

        { keyLengthLocation; } //for debug reference only

        for (int i = 0; i < numberOfRounds; i++)
        {
            int chk = GetRoundKey(key, roundKey, i);
            //getRoundKey
            glDispatchCompute(CRYPTO_DISPATCH_VEC3);
            errString = glGetError();
            glMemoryBarrier( GL_SHADER_STORAGE_BARRIER_BIT ); // makes all the workgroups wait for each other to finish
            errString = glGetError();
        }//end for number of rounds
        { keyLengthLocation; } //for debug reference only
    }//end if
#endif
    else { // CRYPTO BACKWARDS
        //still in CPU space until GPU is confirmed functional
        for (int i = numberOfRounds-1; i >= 0; i--)
        {
            int chk = GetRoundKey(key, roundKey, i);

            CryptoCollisionCheck(hwnd, roundKey); //doesn't modify anything, just dialogs an output of "at-risk" characters
            encryptXORstep(hwnd, buffer, roundKey, bufferOut);
            _tcscpy(buffer,bufferOut);  //so that the next loop will use the results of this loop
        }//end for number of rounds
    }//end else

#if DEBUG_ON
    {
        LPTSTR checkout = new TCHAR[CRYPTO_BUFFER_SIZE];
        for (int i = 0; i < CRYPTO_BUFFER_SIZE; i++)
        {
            checkout[i] = bufferOut[i]; // should move this section into the round loop
        }
        MessageBox(hwnd,
                checkout, //shaderName
                _T("ciphertext buffer"),
                MB_OK | MB_ICONEXCLAMATION);
    }
#endif

#pragma endregion
#pragma region DATA_EXPORTATION
    SetWindowText(hEdit, bufferOut); //sends the encrypted results to the edit window

    if (debugReturn > 0) //debugReturn is the number of characters GetWindowText spat out, or 0
        return NO_ERRORS_DETECTED;
    else
        return debugReturn; // from API : " If the window has no title bar or text, if the title bar is empty, or if the window or control handle is invalid, the return value is zero. To get extended error information, call GetLastError."
#pragma endregion
#if SHADER_MODE
    //delete shader once done with it
    //int chk;
    chk = glUnmapBuffer( GL_SHADER_STORAGE_BUFFER );
    glDeleteShader(compute_shader);
#endif
}//end DDE()