dev.gamez.lv Forum Index dev.gamez.lv
Latvian Game Developers Community
 
 FAQFAQ   SearchSearch   MemberlistMemberlist   UsergroupsUsergroups 

problēmas ar Ortho Mode..
Goto page 1, 2  Next
 
dev.gamez.lv Forum Index -> OpenGL
View previous topic :: View next topic  
Author Message
Digital-X



Joined: 11 Jan 2004
Posts: 79
PostPosted: Wed Aug 18, 2004 10:06 am    Post subject: problēmas ar Ortho Mode..
Bildei vajadzeetu paraadiities pa visu ekraanu, bet man vinju vispaar neraada! Confused
Kods te:
Code:
   OrthoMode(0, 0, 800, 600);
   glDisable(GL_DEPTH_TEST);
   glBindTexture(GL_TEXTURE_2D,  h_Texture[1]);
   glBegin(GL_QUADS);

      // Display the top left point of the 2D image
      glTexCoord2f(0.0f, 1.0f);   glVertex2f(0, 0);

      // Display the bottom left point of the 2D image
      glTexCoord2f(0.0f, 0.0f);   glVertex2f(0, SCREEN_HEIGHT);

      // Display the bottom right point of the 2D image
      glTexCoord2f(1.0f, 0.0f);   glVertex2f(SCREEN_WIDTH, SCREEN_HEIGHT);

      // Display the top right point of the 2D image
      glTexCoord2f(1.0f, 1.0f);   glVertex2f(SCREEN_WIDTH, 0);

   // Stop drawing
   glEnd();

   glEnable(GL_DEPTH_TEST);

   PerspectiveMode();


maybe kaads zin kas par probzu?
_________________
Security: http://www.netsec.lv/forums/
Back to top
View user's profile
gazz



Joined: 03 Jan 2004
Posts: 355
Location: Teika
PostPosted: Wed Aug 18, 2004 10:27 am    Post subject:
hmmm patiesi nezinu - man taws kods straadaa, mosh wienkaarshi ar textuuras ielaadi tew ir probleemas. Ieliku ieksh nehe 6 tutoriaalja - pieliku OrthoMode un PerspectiveMode funkcijas un ripo ka priex!
Back to top
View user's profile Send e-mail
bubu
Indago Uzvarētājs
Indago Uzvarētājs


Joined: 23 Mar 2004
Posts: 3223
Location: Riga
PostPosted: Wed Aug 18, 2004 10:29 am    Post subject:
Vo vo, ar tekstūru iespējams ir problēmas. Tu pamēģini izvadīt vienā krāsā iekrāsotu taisnstūri labāk, tad redzēs.
Back to top
View user's profile Send e-mail
GiGa
Indago Uzvarētājs
Indago Uzvarētājs


Joined: 25 Sep 2003
Posts: 887
PostPosted: Wed Aug 18, 2004 11:09 am    Post subject:
Varbuut paraadi kas tev sleepjas funkcijaa OrthoMode()? Varbuut tur esi kaadu matricu operaaciju aizmirsis?
_________________
Back to top
View user's profile Send e-mail
Digital-X



Joined: 11 Jan 2004
Posts: 79
PostPosted: Wed Aug 18, 2004 11:13 am    Post subject:
Hmm, taa arii meegginaashu, tikko izmeegginaaju uz Nehe 6 tut. tur viss sanaaca kaa naakas. Surprised
_________________
Security: http://www.netsec.lv/forums/
Back to top
View user's profile
Digital-X



Joined: 11 Jan 2004
Posts: 79
PostPosted: Wed Aug 18, 2004 11:23 am    Post subject:
Domaaju ka ar orthoMode funkciju viss ir kaartiibaa, jo man gaaja uz NH6 tuta..
P.S. interesanti ir tas, ka ja nokomentee: OrthoMode(0, 0, 800, 600);
tad ieloadotaa bilde paraadaas, tikai 3d videe...
_________________
Security: http://www.netsec.lv/forums/
Back to top
View user's profile
GiGa
Indago Uzvarētājs
Indago Uzvarētājs


Joined: 25 Sep 2003
Posts: 887
PostPosted: Wed Aug 18, 2004 11:28 am    Post subject:
Nu tad varbuut paraadi tomeer to funkciju Smile Varbuut tur esi aizmirsis kaadu glLoadIdentity vai glMatrixMode, kas tieshi ir izdariits NeHe's tutoriaalii tajaa vietaa, kur tu iespraud savu kodu...
_________________
Back to top
View user's profile Send e-mail
gazz



Joined: 03 Jan 2004
Posts: 355
Location: Teika
PostPosted: Wed Aug 18, 2004 11:31 am    Post subject:
es piem izmantoju shaadas:

Code:

void OrthoMode(int left, int top, int right, int bottom) {
   glMatrixMode(GL_PROJECTION);                       
   glPushMatrix();                                   
   glLoadIdentity();                               
   glOrtho( left, right, bottom, top, 0, 1 );   
   glMatrixMode(GL_MODELVIEW);                               
   glLoadIdentity();                                     
}

void PerspectiveMode() {
   glMatrixMode( GL_PROJECTION );                           
   glPopMatrix();                                           
   glMatrixMode( GL_MODELVIEW );                           
}
Back to top
View user's profile Send e-mail
Digital-X



Joined: 11 Jan 2004
Posts: 79
PostPosted: Wed Aug 18, 2004 11:33 am    Post subject:
Jaa, tieshi taas pashas!

Redzkur it:
Code:
/*
 *      This Code Was Created By Jeff Molofee 2000
 *      A HUGE Thanks To Fredric Echols For Cleaning Up
 *      And Optimizing The Base Code, Making It More Flexible!
 *      If You've Found This Code Useful, Please Let Me Know.
 *      Visit My Site At nehe.gamedev.net
 */

#include <windows.h>      // Header File For Windows
#include <stdio.h>         // Header File For Standard Input/Output
#include <gl\gl.h>         // Header File For The OpenGL32 Library
#include <gl\glu.h>         // Header File For The GLu32 Library
#include <gl\glaux.h>      // Header File For The Glaux Library

HDC         hDC=NULL;      // Private GDI Device Context
HGLRC      hRC=NULL;      // Permanent Rendering Context
HWND      hWnd=NULL;      // Holds Our Window Handle
HINSTANCE   hInstance;      // Holds The Instance Of The Application

bool   keys[256];         // Array Used For The Keyboard Routine
bool   active=TRUE;      // Window Active Flag Set To TRUE By Default
bool   fullscreen=TRUE;   // Fullscreen Flag Set To Fullscreen Mode By Default

GLfloat   xrot;            // X Rotation ( NEW )
GLfloat   yrot;            // Y Rotation ( NEW )
GLfloat   zrot;            // Z Rotation ( NEW )

GLuint   texture[1];         // Storage For One Texture ( NEW )   

LRESULT   CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);   // Declaration For WndProc

AUX_RGBImageRec *LoadBMP(char *Filename)            // Loads A Bitmap Image
{
   FILE *File=NULL;                           // File Handle

   if (!Filename)                              // Make Sure A Filename Was Given
   {
      return NULL;                           // If Not Return NULL
   }

   File=fopen(Filename,"r");                     // Check To See If The File Exists

   if (File)                                 // Does The File Exist?
   {
      fclose(File);                           // Close The Handle
      return auxDIBImageLoad(Filename);            // Load The Bitmap And Return A Pointer
   }

   return NULL;                              // If Load Failed Return NULL
}

int LoadGLTextures()                           // Load Bitmaps And Convert To Textures
{
   int Status=FALSE;                           // Status Indicator

   AUX_RGBImageRec *TextureImage[1];               // Create Storage Space For The Texture

   memset(TextureImage,0,sizeof(void *)*1);              // Set The Pointer To NULL

   // Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit
   if (TextureImage[0]=LoadBMP("Data/NeHe.bmp"))
   {
      Status=TRUE;                           // Set The Status To TRUE

      glGenTextures(1, &texture[0]);               // Create The Texture

      // Typical Texture Generation Using Data From The Bitmap
      glBindTexture(GL_TEXTURE_2D, texture[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);
      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
   }

   if (TextureImage[0])                           // If Texture Exists
   {
      if (TextureImage[0]->data)                     // If Texture Image Exists
      {
         free(TextureImage[0]->data);               // Free The Texture Image Memory
      }

      free(TextureImage[0]);                        // Free The Image Structure
   }

   return Status;                              // Return The Status
}

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)      // Resize And Initialize The GL Window
{
   if (height==0)                              // Prevent A Divide By Zero By
   {
      height=1;                              // Making Height Equal One
   }

   glViewport(0,0,width,height);                  // Reset The Current Viewport

   glMatrixMode(GL_PROJECTION);                  // Select The Projection Matrix
   glLoadIdentity();                           // Reset The Projection Matrix

   // Calculate The Aspect Ratio Of The Window
   gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

   glMatrixMode(GL_MODELVIEW);                     // Select The Modelview Matrix
   glLoadIdentity();                           // Reset The Modelview Matrix
}

int InitGL(GLvoid)                              // All Setup For OpenGL Goes Here
{
   if (!LoadGLTextures())                        // Jump To Texture Loading Routine ( NEW )
   {
      return FALSE;                           // If Texture Didn't Load Return FALSE
   }

   glEnable(GL_TEXTURE_2D);                     // Enable Texture Mapping ( NEW )
   glShadeModel(GL_SMOOTH);                     // Enable Smooth Shading
   glClearColor(0.0f, 0.0f, 0.0f, 0.5f);            // Black Background
   glClearDepth(1.0f);                           // Depth Buffer Setup
   glEnable(GL_DEPTH_TEST);                     // Enables Depth Testing
   glDepthFunc(GL_LEQUAL);                        // The Type Of Depth Testing To Do
   glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);   // Really Nice Perspective Calculations
   return TRUE;                              // Initialization Went OK
}

/**************************************************************************

SHEIT:

**************************************************************************/

void OrthoMode(int left, int top, int right, int bottom)
{
   glMatrixMode(GL_PROJECTION);                  
   glPushMatrix();                           
   glLoadIdentity();                        
   glOrtho( left, right, bottom, top, 0, 1 );   
   glMatrixMode(GL_MODELVIEW);                        
   glLoadIdentity();                              
}

void PerspectiveMode()                              
{
   glMatrixMode( GL_PROJECTION );                     
   glPopMatrix();                                 
   glMatrixMode( GL_MODELVIEW );                     
}


/**************************************************************************

END

**************************************************************************/

int DrawGLScene(GLvoid)                           // Here's Where We Do All The Drawing
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);   // Clear The Screen And The Depth Buffer
   glLoadIdentity();                           // Reset The View
   glTranslatef(0.0f,0.0f,-5.0f);

   glRotatef(xrot,1.0f,0.0f,0.0f);
   glRotatef(yrot,0.0f,1.0f,0.0f);
   glRotatef(zrot,0.0f,0.0f,1.0f);

   glBindTexture(GL_TEXTURE_2D, texture[0]);

   glBegin(GL_QUADS);
      // Front Face
      glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
      glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
      glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
      glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
      // Back Face
      glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
      glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
      glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
      glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
      // Top Face
      glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
      glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
      glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
      glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
      // Bottom Face
      glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
      glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
      glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
      glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
      // Right face
      glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
      glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
      glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
      glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
      // Left Face
      glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
      glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
      glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
      glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
   glEnd();

   xrot+=0.3f;
   yrot+=0.2f;
   zrot+=0.4f;


/**************************************************************************

SHEIT:

**************************************************************************/
   OrthoMode(0, 0, 800, 600);
   glDisable(GL_DEPTH_TEST);
   glBindTexture(GL_TEXTURE_2D,  texture[1]);
   glBegin(GL_QUADS);

      // Display the top left point of the 2D image
      glTexCoord2f(0.0f, 1.0f);   glVertex2f(0, 0);

      // Display the bottom left point of the 2D image
      glTexCoord2f(0.0f, 0.0f);   glVertex2f(0, 600);

      // Display the bottom right point of the 2D image
      glTexCoord2f(1.0f, 0.0f);   glVertex2f(800, 600);

      // Display the top right point of the 2D image
      glTexCoord2f(1.0f, 1.0f);   glVertex2f(800, 0);

   // Stop drawing
   glEnd();

   glEnable(GL_DEPTH_TEST);

   PerspectiveMode();
   return TRUE;                              // Keep Going
}

GLvoid KillGLWindow(GLvoid)                        // Properly Kill The Window
{
   if (fullscreen)                              // Are We In Fullscreen Mode?
   {
      ChangeDisplaySettings(NULL,0);               // If So Switch Back To The Desktop
      ShowCursor(TRUE);                        // Show Mouse Pointer
   }

   if (hRC)                                 // Do We Have A Rendering Context?
   {
      if (!wglMakeCurrent(NULL,NULL))               // Are We Able To Release The DC And RC Contexts?
      {
         MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
      }

      if (!wglDeleteContext(hRC))                  // Are We Able To Delete The RC?
      {
         MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
      }
      hRC=NULL;                              // Set RC To NULL
   }

   if (hDC && !ReleaseDC(hWnd,hDC))               // Are We Able To Release The DC
   {
      MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
      hDC=NULL;                              // Set DC To NULL
   }

   if (hWnd && !DestroyWindow(hWnd))               // Are We Able To Destroy The Window?
   {
      MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
      hWnd=NULL;                              // Set hWnd To NULL
   }

   if (!UnregisterClass("OpenGL",hInstance))         // Are We Able To Unregister Class
   {
      MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
      hInstance=NULL;                           // Set hInstance To NULL
   }
}

/*   This Code Creates Our OpenGL Window.  Parameters Are:               *
 *   title         - Title To Appear At The Top Of The Window            *
 *   width         - Width Of The GL Window Or Fullscreen Mode            *
 *   height         - Height Of The GL Window Or Fullscreen Mode         *
 *   bits         - Number Of Bits To Use For Color (8/16/24/32)         *
 *   fullscreenflag   - Use Fullscreen Mode (TRUE) Or Windowed Mode (FALSE)   */
 
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
   GLuint      PixelFormat;         // Holds The Results After Searching For A Match
   WNDCLASS   wc;                  // Windows Class Structure
   DWORD      dwExStyle;            // Window Extended Style
   DWORD      dwStyle;            // Window Style
   RECT      WindowRect;            // Grabs Rectangle Upper Left / Lower Right Values
   WindowRect.left=(long)0;         // Set Left Value To 0
   WindowRect.right=(long)width;      // Set Right Value To Requested Width
   WindowRect.top=(long)0;            // Set Top Value To 0
   WindowRect.bottom=(long)height;      // Set Bottom Value To Requested Height

   fullscreen=fullscreenflag;         // Set The Global Fullscreen Flag

   hInstance         = GetModuleHandle(NULL);            // Grab An Instance For Our Window
   wc.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;   // Redraw On Size, And Own DC For Window.
   wc.lpfnWndProc      = (WNDPROC) WndProc;               // WndProc Handles Messages
   wc.cbClsExtra      = 0;                           // No Extra Window Data
   wc.cbWndExtra      = 0;                           // No Extra Window Data
   wc.hInstance      = hInstance;                     // Set The Instance
   wc.hIcon         = LoadIcon(NULL, IDI_WINLOGO);         // Load The Default Icon
   wc.hCursor         = LoadCursor(NULL, IDC_ARROW);         // Load The Arrow Pointer
   wc.hbrBackground   = NULL;                           // No Background Required For GL
   wc.lpszMenuName      = NULL;                           // We Don't Want A Menu
   wc.lpszClassName   = "OpenGL";                        // Set The Class Name

   if (!RegisterClass(&wc))                           // Attempt To Register The Window Class
   {
      MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;                                 // Return FALSE
   }
   
   if (fullscreen)                                    // Attempt Fullscreen Mode?
   {
      DEVMODE dmScreenSettings;                        // Device Mode
      memset(&dmScreenSettings,0,sizeof(dmScreenSettings));   // Makes Sure Memory's Cleared
      dmScreenSettings.dmSize=sizeof(dmScreenSettings);      // Size Of The Devmode Structure
      dmScreenSettings.dmPelsWidth   = width;            // Selected Screen Width
      dmScreenSettings.dmPelsHeight   = height;            // Selected Screen Height
      dmScreenSettings.dmBitsPerPel   = bits;               // Selected Bits Per Pixel
      dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

      // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
      if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
      {
         // If The Mode Fails, Offer Two Options.  Quit Or Use Windowed Mode.
         if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
         {
            fullscreen=FALSE;      // Windowed Mode Selected.  Fullscreen = FALSE
         }
         else
         {
            // Pop Up A Message Box Letting User Know The Program Is Closing.
            MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
            return FALSE;                           // Return FALSE
         }
      }
   }

   if (fullscreen)                                    // Are We Still In Fullscreen Mode?
   {
      dwExStyle=WS_EX_APPWINDOW;                        // Window Extended Style
      dwStyle=WS_POPUP;                              // Windows Style
      ShowCursor(FALSE);                              // Hide Mouse Pointer
   }
   else
   {
      dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;         // Window Extended Style
      dwStyle=WS_OVERLAPPEDWINDOW;                     // Windows Style
   }

   AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);      // Adjust Window To True Requested Size

   // Create The Window
   if (!(hWnd=CreateWindowEx(   dwExStyle,                     // Extended Style For The Window
                        "OpenGL",                     // Class Name
                        title,                        // Window Title
                        dwStyle |                     // Defined Window Style
                        WS_CLIPSIBLINGS |               // Required Window Style
                        WS_CLIPCHILDREN,               // Required Window Style
                        0, 0,                        // Window Position
                        WindowRect.right-WindowRect.left,   // Calculate Window Width
                        WindowRect.bottom-WindowRect.top,   // Calculate Window Height
                        NULL,                        // No Parent Window
                        NULL,                        // No Menu
                        hInstance,                     // Instance
                        NULL)))                        // Dont Pass Anything To WM_CREATE
   {
      KillGLWindow();                        // Reset The Display
      MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;                        // Return FALSE
   }

   static   PIXELFORMATDESCRIPTOR pfd=            // pfd Tells Windows How We Want Things To Be
   {
      sizeof(PIXELFORMATDESCRIPTOR),            // Size Of This Pixel Format Descriptor
      1,                                 // Version Number
      PFD_DRAW_TO_WINDOW |                  // Format Must Support Window
      PFD_SUPPORT_OPENGL |                  // Format Must Support OpenGL
      PFD_DOUBLEBUFFER,                     // Must Support Double Buffering
      PFD_TYPE_RGBA,                        // Request An RGBA Format
      bits,                              // Select Our Color Depth
      0, 0, 0, 0, 0, 0,                     // Color Bits Ignored
      0,                                 // No Alpha Buffer
      0,                                 // Shift Bit Ignored
      0,                                 // No Accumulation Buffer
      0, 0, 0, 0,                           // Accumulation Bits Ignored
      16,                                 // 16Bit Z-Buffer (Depth Buffer) 
      0,                                 // No Stencil Buffer
      0,                                 // No Auxiliary Buffer
      PFD_MAIN_PLANE,                        // Main Drawing Layer
      0,                                 // Reserved
      0, 0, 0                              // Layer Masks Ignored
   };
   
   if (!(hDC=GetDC(hWnd)))                     // Did We Get A Device Context?
   {
      KillGLWindow();                        // Reset The Display
      MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;                        // Return FALSE
   }

   if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))   // Did Windows Find A Matching Pixel Format?
   {
      KillGLWindow();                        // Reset The Display
      MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;                        // Return FALSE
   }

   if(!SetPixelFormat(hDC,PixelFormat,&pfd))      // Are We Able To Set The Pixel Format?
   {
      KillGLWindow();                        // Reset The Display
      MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;                        // Return FALSE
   }

   if (!(hRC=wglCreateContext(hDC)))            // Are We Able To Get A Rendering Context?
   {
      KillGLWindow();                        // Reset The Display
      MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;                        // Return FALSE
   }

   if(!wglMakeCurrent(hDC,hRC))               // Try To Activate The Rendering Context
   {
      KillGLWindow();                        // Reset The Display
      MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;                        // Return FALSE
   }

   ShowWindow(hWnd,SW_SHOW);                  // Show The Window
   SetForegroundWindow(hWnd);                  // Slightly Higher Priority
   SetFocus(hWnd);                           // Sets Keyboard Focus To The Window
   ReSizeGLScene(width, height);               // Set Up Our Perspective GL Screen

   if (!InitGL())                           // Initialize Our Newly Created GL Window
   {
      KillGLWindow();                        // Reset The Display
      MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;                        // Return FALSE
   }

   return TRUE;                           // Success
}

LRESULT CALLBACK WndProc(   HWND   hWnd,         // Handle For This Window
                     UINT   uMsg,         // Message For This Window
                     WPARAM   wParam,         // Additional Message Information
                     LPARAM   lParam)         // Additional Message Information
{
   switch (uMsg)                           // Check For Windows Messages
   {
      case WM_ACTIVATE:                     // Watch For Window Activate Message
      {
         if (!HIWORD(wParam))               // Check Minimization State
         {
            active=TRUE;                  // Program Is Active
         }
         else
         {
            active=FALSE;                  // Program Is No Longer Active
         }

         return 0;                        // Return To The Message Loop
      }

      case WM_SYSCOMMAND:                     // Intercept System Commands
      {
         switch (wParam)                     // Check System Calls
         {
            case SC_SCREENSAVE:               // Screensaver Trying To Start?
            case SC_MONITORPOWER:            // Monitor Trying To Enter Powersave?
            return 0;                     // Prevent From Happening
         }
         break;                           // Exit
      }

      case WM_CLOSE:                        // Did We Receive A Close Message?
      {
         PostQuitMessage(0);                  // Send A Quit Message
         return 0;                        // Jump Back
      }

      case WM_KEYDOWN:                     // Is A Key Being Held Down?
      {
         keys[wParam] = TRUE;               // If So, Mark It As TRUE
         return 0;                        // Jump Back
      }

      case WM_KEYUP:                        // Has A Key Been Released?
      {
         keys[wParam] = FALSE;               // If So, Mark It As FALSE
         return 0;                        // Jump Back
      }

      case WM_SIZE:                        // Resize The OpenGL Window
      {
         ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width, HiWord=Height
         return 0;                        // Jump Back
      }
   }

   // Pass All Unhandled Messages To DefWindowProc
   return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

int WINAPI WinMain(   HINSTANCE   hInstance,         // Instance
               HINSTANCE   hPrevInstance,      // Previous Instance
               LPSTR      lpCmdLine,         // Command Line Parameters
               int         nCmdShow)         // Window Show State
{
   MSG      msg;                           // Windows Message Structure
   BOOL   done=FALSE;                        // Bool Variable To Exit Loop

   // Ask The User Which Screen Mode They Prefer
   if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
   {
      fullscreen=FALSE;                     // Windowed Mode
   }

   // Create Our OpenGL Window
   if (!CreateGLWindow("NeHe's Texture Mapping Tutorial",800,600,16,fullscreen))
   {
      return 0;                           // Quit If Window Was Not Created
   }

   while(!done)                           // Loop That Runs While done=FALSE
   {
      if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))   // Is There A Message Waiting?
      {
         if (msg.message==WM_QUIT)            // Have We Received A Quit Message?
         {
            done=TRUE;                     // If So done=TRUE
         }
         else                           // If Not, Deal With Window Messages
         {
            TranslateMessage(&msg);            // Translate The Message
            DispatchMessage(&msg);            // Dispatch The Message
         }
      }
      else                              // If There Are No Messages
      {
         // Draw The Scene.  Watch For ESC Key And Quit Messages From DrawGLScene()
         if ((active && !DrawGLScene()) || keys[VK_ESCAPE])   // Active?  Was There A Quit Received?
         {
            done=TRUE;                     // ESC or DrawGLScene Signalled A Quit
         }
         else                           // Not Time To Quit, Update Screen
         {
            SwapBuffers(hDC);               // Swap Buffers (Double Buffering)
         }

         if (keys[VK_F1])                  // Is F1 Being Pressed?
         {
            keys[VK_F1]=FALSE;               // If So Make Key FALSE
            KillGLWindow();                  // Kill Our Current Window
            fullscreen=!fullscreen;            // Toggle Fullscreen / Windowed Mode
            // Recreate Our OpenGL Window
            if (!CreateGLWindow("NeHe's Texture Mapping Tutorial",800,600,16,fullscreen))
            {
               return 0;                  // Quit If Window Was Not Created
            }
         }
      }
   }

   // Shutdown
   KillGLWindow();                           // Kill The Window
   return (msg.wParam);                     // Exit The Program
}
[/code]
_________________
Security: http://www.netsec.lv/forums/
Back to top
View user's profile
GiGa
Indago Uzvarētājs
Indago Uzvarētājs


Joined: 25 Sep 2003
Posts: 887
PostPosted: Wed Aug 18, 2004 11:44 am    Post subject:
Nu shitajaa peedeejaa kodaa ko Digital-X iepostoja visam buutu jaabuut ok, vai arii shitas ir tas variants, kur viss straadaa?(Ja jaa, tad iemet to, kas nestraadaa) Un taa OrthoMode izskatas, dereetu arii jebkuraa citaa liidziigaa vietaa...
_________________
Back to top
View user's profile Send e-mail
Digital-X



Joined: 11 Jan 2004
Posts: 79
PostPosted: Wed Aug 18, 2004 11:53 am    Post subject:
tas ko es iepostoju tas ir tas kur viss sanaaca :?

kopeeshu izmantotaats daljas... (koda ir daudz)
Code:

main.cpp
UINT h_Texture[50] = {0};
...
CreateHudTexture(h_Texture, "cube.bmp",1);
...
void RenderScene()
{
   
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glLoadIdentity();

   {LEVEL RENDERINGS}


//HUD Drawing!
   
OrthoMode(0, 0, 800, 600);
glDisable(GL_DEPTH_TEST);
   
   glBindTexture(GL_TEXTURE_2D,  h_Texture[1]);
   glBegin(GL_QUADS);
      // Display the top left point of the 2D image
      glTexCoord2f(0.0f, 1.0f);   glVertex2f(0, 0);
      // Display the bottom left point of the 2D image
      glTexCoord2f(0.0f, 0.0f);   glVertex2f(0, SCREEN_HEIGHT);
      // Display the bottom right point of the 2D image
      glTexCoord2f(1.0f, 0.0f);   glVertex2f(SCREEN_WIDTH, SCREEN_HEIGHT);
      // Display the top right point of the 2D image
      glTexCoord2f(1.0f, 1.0f);   glVertex2f(SCREEN_WIDTH, 0);

   // Stop drawing
   glEnd();

   glEnable(GL_DEPTH_TEST);

   PerspectiveMode();
   
SwapBuffers(g_hDC);   
}
==========================================
init.cpp

void CreateHudTexture(UINT textureArray[], LPSTR strFileName, int textureID)
{
   AUX_RGBImageRec *pBitmap = NULL;
   
   if(!strFileName)                           // Return from the function if no file name was passed in
      return;
   
   // We need to load the texture data, so we use a cool API that the glaux.lib offers.
   
   pBitmap = auxDIBImageLoad(strFileName);            // Load the bitmap and store the data
   
   if(pBitmap == NULL)                           // If we can't load the file, quit!
      exit(0);

   // Generate a texture with the associative texture ID stored in the array
   glGenTextures(1, &textureArray[textureID]);

   // Bind the texture to the texture arrays index and init the texture
   glBindTexture(GL_TEXTURE_2D, textureArray[textureID]);

   // Build Mipmaps (builds different versions of the picture for distances - looks better)
   gluBuild2DMipmaps(GL_TEXTURE_2D, 3, pBitmap->sizeX, pBitmap->sizeY, GL_RGB, GL_UNSIGNED_BYTE, pBitmap->data);

   // Lastly, we need to tell OpenGL the quality of our texture map.  GL_LINEAR_MIPMAP_LINEAR
   // is the smoothest.  GL_LINEAR_MIPMAP_NEAREST is faster than GL_LINEAR_MIPMAP_LINEAR,
   // but looks blochy and pixilated.  Good for slower computers though. 
      
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR);

   // Now we need to free the bitmap data that we loaded since openGL stored it as a texture

   if (pBitmap)                              // If we loaded the bitmap
   {
      if (pBitmap->data)                        // If there is texture data
      {
         free(pBitmap->data);                  // Free the texture data, we don't need it anymore
      }

      free(pBitmap);                           // Free the bitmap structure
   }
}
[/code]
_________________
Security: http://www.netsec.lv/forums/
Back to top
View user's profile
GiGa
Indago Uzvarētājs
Indago Uzvarētājs


Joined: 25 Sep 2003
Posts: 887
PostPosted: Wed Aug 18, 2004 12:01 pm    Post subject:
Un taatad, ja izkomentee orthomode, tad tas quad uzziimeejaas kaut kur, ja? Ja taa, tad es tieshaam nezinu, kas pa lietu, sorre Sad te vismaz neredz probleemu, jaameklee citaa vietaa...
_________________
Back to top
View user's profile Send e-mail
Digital-X



Joined: 11 Jan 2004
Posts: 79
PostPosted: Wed Aug 18, 2004 12:05 pm    Post subject:
jaa, tur ir tas pats diivainaakais! Confused Es domaaju ka jaaliek kautkaads glBlendFunc(). Bet ok, gan kautko izdomaashu Rolling Eyes
_________________
Security: http://www.netsec.lv/forums/
Back to top
View user's profile
GiGa
Indago Uzvarētājs
Indago Uzvarētājs


Joined: 25 Sep 2003
Posts: 887
PostPosted: Wed Aug 18, 2004 12:08 pm    Post subject:
Pag, pag, tev tur veel ir iesleegts blendings? Tad gan dereetu zinaat kas tev taja glBlendFunc ir salikts...
Un veel, neliek mieru man shitaa probleema Smile vieniiga vieta, kur vareetu buut proba ir taa OrthoMode... tu esi 100% paarliecinaats, ka shitaja progaa tev arii taa OrthoMode funkcija ir tieshi taada pati?
_________________
Back to top
View user's profile Send e-mail
Digital-X



Joined: 11 Jan 2004
Posts: 79
PostPosted: Wed Aug 18, 2004 12:18 pm    Post subject:
Jaa, 100% Paarliecinats! Very Happy Es meginaaju gan ar, gan bez. bez nesanaak, un ar arii nee. Bija shaads: glBlendFunc(GL_DST_COLOR,GL_ZERO);
_________________
Security: http://www.netsec.lv/forums/
Back to top
View user's profile
Display posts from previous:   
dev.gamez.lv Forum Index -> OpenGL All times are GMT + 2 Hours
Goto page 1, 2  Next
Page 1 of 2

 
Jump to:  
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum


Powered by phpBB © 2001, 2005 phpBB Group