spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

#include <iostream>
#include <windows.h>
#include <stdio.h>

#pragma comment (lib, "winmm.lib")

using namespace std;







// Resolution
int x_res = 0;
int y_res = 0;

// QualitySettings

int AA_Quality=10;

float CommaDivisor;
int CommaRange;

// CameraSettings
float CameraArc = 90;
float CameraArc_x = 0;
float CameraArc_y = 0;
// Compute the Comma position for the CamRay Angles
float CommaPos_x;
float CommaPos_y;

int pixelrate = 0;

// At first we need the class Pixel
// Declaration of the Classgroup pPixel 

class Pixel
{
public:

    // variables of the pixel
    float   Red;        // The red of the pixel
    float   Blue;       // The blue of the pixel    
    float   Green;      // The green of the pixel
    float   Alpha;      // The alpha of the pixel
    int     computed;   // how often is the pixel computed  

    void    PixelTrace(int &x_res, int &y_res);     //Function to get Pixeldata


    // Function to compute the pixel


    Pixel::Pixel()  // Construct the Pixel
    {
        Red         = 0;
        Blue        = 0;
        Green       = 0;
        Alpha       = 0;
        computed    = 1;
    }

    
};

////////////////
////////////////

class CamRay
{
public:

    // variables of the CamRay
    float   Red;        // The red of the pixel
    float   Blue;       // The blue of the pixel    
    float   Green;      // The green of the pixel
    float   Alpha;      // The alpha of the pixel
    float   Angle_y_start;
    float   Angle_x_start;
    float   Angle_y;
    float   Angle_x;
    float   y_pos;
    float   x_pos;
    float   z_pos;





    // Function to compute the pixel


    CamRay::CamRay()    
    {
        Red                 = 0;
        Blue                = 0;
        Green               = 0;
        Alpha               = 0;
        Angle_y_start       = 0;
        Angle_x_start       = 0;
        Angle_y             = 0;
        Angle_x             = 0;
        y_pos               = 0;
        x_pos               = 0;
        z_pos               = 0;

        //cout << "CamRay done"<<endl;
    }


        

void GenCamRay();           // Create new CamRay
    
};


class LightRay
{
public:

    // variables of the CamRay
    float   Red;        // The red of the pixel
    float   Blue;       // The blue of the pixel    
    float   Green;      // The green of the pixel
    float   Alpha;      // The alpha of the pixel
    float   Angle_y_start;
    float   Angle_x_start;
    float   Angle_y;
    float   Angle_x;
    float   y_pos;
    float   x_pos;
    float   z_pos;





    // Function to compute the pixel


    LightRay::LightRay()    
    {
        Red                 = 0;
        Blue                = 0;
        Green               = 0;
        Alpha               = 0;
        Angle_y             = 0;
        Angle_x             = 0;
        y_pos               = 0;
        x_pos               = 0;
        z_pos               = 0;
    }




void GenCamRay();           // Create new CamRay
    
};



////////////////
////////////////

class Camera
{
public:

    // variables of the CamRay
    float   Angle_y;        
    float   Angle_x;    
    float   Angle_z;    
    float   y_pos;
    float   x_pos;
    float   z_pos;








    Camera::Camera()    
    {

        Angle_z             = 0;
        Angle_y             = 0;
        Angle_x             = 0;
        y_pos               = 0;
        x_pos               = 0;
        z_pos               = 0;
    }

    
};


////////////////
////////////////

//  Variables 






// Prototypes of the funktions
//  Pixelfunktions


    void    GetResolution       (int &x_res, int &y_res);
    void    GetPixelAverage     (int &x_res, int &y_res);
    void    PixelGenerate       (int &x_res, int &y_res);
    
    void    GetCameraArc        (int &x_res, int &y_res, float &CameraArc_x , float &CameraArc_y , float &CameraArc);
    
    void    MainProcess         ();
    //////
    void    GenCamRay           ();
    void    GenLightRay         ();
    void    DeleteRays          ();
    //////
    void    GetPixelPos         ();
    int     CompPixelPos        (int res, float CameraArc_xy, float PixelAngel_xy );
    int     CheckPixelPos       (int res, int PixelPos);
    int     PixelPos_x;
    int     PixelPos_y;
    //////

    void    GetCommaRange       (int &Commarange , float &CommaDivisor);
    //////
    void    GetPixelRBG         ();
    float   CompPixelRBG        (float PixelColor, float RayColor);
    //////
    //////
    void    Anzeiger            ();


// Generate all Classes
Pixel       *pPixel     = NULL;
CamRay      *pCamRay    = NULL;
LightRay    *pLightRay  = NULL; 





/////////////////////////////////////////////////////////////////////
// MainFunction
int main()
{

    // Function GetReslution to get the resolution


    GetResolution(x_res, y_res);

    // Get the Camera X and Y Arc

    GetCameraArc(x_res, y_res, CameraArc_x , CameraArc_y , CameraArc);

    //  Generate Instances of the Pixel with ResolutionData

    PixelGenerate(x_res, y_res);

    // Initialize the Randomizer

    srand (timeGetTime ());

    // Get the Comma Range, because we dont render to anything without seeing it.

    GetCommaRange(CommaRange, CommaDivisor);

    //  Activate the MainProcess Iteration the Calculate the whole image

    MainProcess();



    getchar();
    getchar();

    return 0;

}








///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////

//Funktions

void MainProcess()  //This is the Main processing routine. Starts when all things are initialised 
{
    int kp = 0;
    do                      // Do while because rendering never ends. Or you press Excape
    {
        int kp2 = 0;
        do
        {
        GenCamRay();   // Camera generates a random Ray to get Pixeldata
        GenLightRay();
        GetPixelPos();
        GetPixelRBG();
        DeleteRays();
        kp2++;
        } while ( kp2 < 10 );

        kp++;
    



    } while ( kp < 1);
    Anzeiger();
    cout << "Finished !!!"<< endl;
}


///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////


void GetResolution(int &x_res,int &y_res)           // Get the resolution of the Picture (Only for the first tests)
{
    cout << "Picture resolution width         :"; 
    cin >> x_res;
    cout << "Picture resolution high          :"; 
    cin >> y_res;

    cout << "Resolution                       :" << x_res <<"*"<< y_res << endl;
}


    // Generate instance



///////////////////////////////////////////////////////////////////////



void PixelGenerate(int &x_res, int &y_res)      //  Generate all Pixels for the picture
{
    pPixel = new Pixel[x_res,y_res];
    cout << "Memory used for Pixels           :" << sizeof (pPixel) * x_res * y_res / 1024  << " kbyte" << endl;

} 



///////////////////////////////////////////////////////////////////////



// Function to get the Y and X angle of the Camera
void GetCameraArc(int &x_res, int &y_res, float &CameraArc_x , float &CameraArc_y , float &CameraArc)
{
if (y_res > x_res)
    {
    CameraArc_x = CameraArc / y_res * x_res;
    CameraArc_y = CameraArc;
    }
if (y_res < x_res)
    {
    CameraArc_y = CameraArc / x_res * y_res;
    CameraArc_x = CameraArc;
    }
if (y_res == x_res)
    {
    CameraArc_y = CameraArc;
    CameraArc_x = CameraArc;
    }
    
    cout << "CameraArc_x                      :" << CameraArc_x << endl;
    cout << "CameraArc_y                      :" << CameraArc_y << endl;

}

///////////////////////////////////////////////////////////////////////
// Get the Right-Comma-Range because the renderer dont have to render for example "CamAngle = 20.134213" when you have only 500 Pixels.... better "20.13"
void GetCommaRange(int &Commarange , float &CommaDivisor)
{

    // Get the Comma Range
    CommaRange = AA_Quality * ((x_res + y_res) / 2) / 20; 
                        
    // Get the Comma divisor



    if (CommaRange > 100)
    {
        CommaDivisor = 1000;
    }

    if (CommaRange > 1000)
    {
        CommaDivisor = 10000;
    }

    if (CommaRange > 10000)
    {
        CommaDivisor = 100000;
    }

    if (CommaRange > 100000)
    {   
        CommaDivisor = 1000000;
    }
    if (CommaRange < 100)
    {
        CommaDivisor = 10;
    }
}




///////////////////////////////////////////////////////////////////////










///////////////////////////////////////////////////////////////////////
// FUNCTIONS FOR THE MAINPROCESS
///////////////////////////////////////////////////////////////////////

// First we have to generate and declare a CamRay

void GenCamRay()          // Generate new cam ray
{
    
    pCamRay = new CamRay[1];  // Make new Camray
    pCamRay[1].Angle_x =    (rand()%static_cast<int>(CameraArc_x)) + (rand()%static_cast<int>(CommaRange))/CommaDivisor;
    pCamRay[1].Angle_y =    (rand()%static_cast<int>(CameraArc_y)) + (rand()%static_cast<int>(CommaRange))/CommaDivisor;

}

void DeleteRays()
{
     delete pCamRay;
     pCamRay = NULL;
}


void GenLightRay()
{
    pLightRay = new LightRay[1];
}

///////////////////////////////////////////////////////////////////////

void GetPixelPos()
{
    PixelPos_y      = CompPixelPos(y_res, CameraArc_y, pCamRay[1].Angle_y);
    PixelPos_x      = CompPixelPos(x_res, CameraArc_x, pCamRay[1].Angle_x);

    // If Mistake ...

    PixelPos_y = CheckPixelPos  (y_res, PixelPos_y);
    PixelPos_x = CheckPixelPos  (x_res, PixelPos_x);


//  cout << "CamAngleX: " << pCamRay[1].Angle_x << " CamAngleY: " << pCamRay[1].Angle_y << " PixelPosX: "<< PixelPos_x << " PixelPosY: " << PixelPos_y << endl; 


}

int CompPixelPos(int res, float CameraArc_xy, float PixelAngel_xy )
{
    int PixelPos = res / CameraArc_xy * PixelAngel_xy;

    return PixelPos;
}

int CheckPixelPos(int res, int PixelPos)
{
    if (PixelPos > res)
        return res;
        else
        return PixelPos;
}

///////////////////////////////////////////////////////////////////////
// Compute the Final PixelColor ( Not used at the moment )

void GetPixelRBG()
{
    


    pPixel[PixelPos_x,PixelPos_y].Red   = CompPixelRBG  (pPixel[PixelPos_x,PixelPos_y].Red,     pLightRay[1].Red);
    pPixel[PixelPos_x,PixelPos_y].Blue  = CompPixelRBG  (pPixel[PixelPos_x,PixelPos_y].Blue,    pLightRay[1].Blue);
    pPixel[PixelPos_x,PixelPos_y].Green = CompPixelRBG  (pPixel[PixelPos_x,PixelPos_y].Green,   pLightRay[1].Green);

    cout << " Y " << PixelPos_y << " X " << PixelPos_x << endl;
}

float   CompPixelRBG (float PixelColor, float RayColor)
{
    PixelColor =  (rand()%10)   ;


    return PixelColor;
}





////////////////////////////////////

//Anzeiger
void Anzeiger()
{
for     (int i = 1; i < y_res; i++)
{
    for ( int j = 1; j < x_res; j++)
    {
        cout << pPixel[i,j].Red;
    }
    cout << endl;
}

cout << pPixel[1,3].Red;
cout << pPixel[1,5].Red;
cout << pPixel[2,3].Red;
cout << pPixel[3,3].Red;
cout << pPixel[5,3].Red;
cout << pPixel[7,3].Red;

}

C-/C++-Quelltext

void PixelGenerate(int &x_res, int &y_res)      //  Generate all Pixels for the picture

{
    pPixel = new Pixel[x_res,y_res];
    cout << "Memory used for Pixels           :" << sizeof (pPixel) * x_res * y_res / 1024  << " kbyte" << endl;

}