Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » OpenGL » einfach nur Pixel setzen

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
03.11.2005, 16:21 Uhr
Nick H.



Moin

ich will ne eigene 3d-Engine proggen
das is kein Problem mit der Mathematik dazu kenn ich mich aus
hab das ganze auch schon mal mit DirectX gemacht

aber nun möchte ich das ganze mit OpenGL machen
also wie mach ich das am einfachsten?

ich hab mir schon das NeHe Tutorial angeguckt
aber die laden da ja nen Haufen Zeug Shader und sowas, was ich alles ja nicht brauch

also wie sieht das am einfachsten aus, wenn ich nur folgendes können will:

-ein Vollbildfenster öffnen, mit beliebiger Auflösung und Farbtiefe
-an jeder beliebigen Stelle, möglichst schnell ein Pixel mit beliebiger Farbe setzen


mein Freund sagt SDL wäre dafür praktisch
aber ich will wirklich reines OpenGL benutzen, dass wird auch das schnellste sein
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
04.11.2005, 01:14 Uhr
Drager



SDL hat ja nix direkt mit opengl zu tun, sondern erzeugt dir ja nur ein fenster und andere nützliche funktionen..
ich finds sehr praktisch, da es halt auf vielen plattforem läuft und auch viel einfach zu initieren ist... ich glaub aber, dass du das auch mit glut kannst (was aber auch net das grund opengl ist..).. weiss ich jetzt aber net 100%, da ich das net benutze...

naja mit "glDrawPixels()" kannste pixels setzen, aber besonders schnell ist das net..


Shader braucht man am anfang erstmal net, sind aber später sehr hilfreich und verdammt schnell, im gegensatz zur cpu lösung... und man kann echt tolle effekte damit erzeugen (wasser,rauch,oberflächen etc.)


also an sich würd ich an deiner stelle, das mit SDL machen, und dann einfach mal ein primitiv zeichnen... damit man mal den grundstein in opengl hat..

Dieser Post wurde am 04.11.2005 um 01:15 Uhr von Drager editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
04.11.2005, 14:48 Uhr
Nick H.



klar kann man mit "glDrawPixels()" Pixel setzen
aber es geht um das Zeug drum rum
in dem Tutorial was ich gelesen hab wird das alles gemacht nur um ein leeres Fenster zu öffnen:


Code:
#include <windows.h>
#include <gl\glu.h>
#include <gl\gl.h>
#include <gl\glaux.h>

HGLRC hRC=NULL;
HDC hDC=NULL;
HWND hWnd=NULL;
HINSTANCE hInstance;

bool keys[256];
bool active=TRUE;
bool fullscreen=TRUE;

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
{
  if (height==0)
  {      
    height=1;    
  }
  glViewport(0, 0, width, height);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
}

int InitGL(GLvoid)
{
  glShadeModel(GL_SMOOTH);
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  glClearDepth(1.0f);
  glEnable(GL_DEPTH_TEST);
  glDepthFunc(GL_LEQUAL);
  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
  return TRUE;
}

int DrawGLScene(GLvoid)
{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glLoadIdentity();
  return TRUE;
}

GLvoid KillGLWindow(GLvoid)
{
  if (fullscreen)
  {
    ChangeDisplaySettings(NULL,0);
    ShowCursor(TRUE);
  }
  if (hRC)
  {
    if (!wglMakeCurrent(NULL,NULL))
    {
      MessageBox(NULL,"Entfernen des DC und RC fehlgeschlagen.","Fehler",MB_OK | MB_ICONINFORMATION);
    }
    if (!wglDeleteContext(hRC))
    {
      MessageBox(NULL,"Entfernen des RC fehlgeschlagen.","Fehler...",MB_OK | MB_ICONINFORMATION);
    }
    hRC=NULL;
  }

  if (hDC && !ReleaseDC(hWnd,hDC))
  {
     MessageBox(NULL,"Freigabe des Device Context fehlgeschlagen.","Fehler",MB_OK | MB_ICONINFORMATION);
     hDC=NULL;
  }

  if (hWnd && !DestroyWindow(hWnd))
  {
     MessageBox(NULL,"Konnte hWnd nicht löschen.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
     hWnd=NULL;
  }

  if (!UnregisterClass("OpenGL",hInstance))
  {
     MessageBox(NULL,"Konnte Klasse nicht entfernen.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
     hInstance=NULL;
  }
}

BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
  GLuint PixelFormat;
  WNDCLASS wc;
  DWORD dwExStyle;
  DWORD dwStyle;
  RECT WindowRect;
  WindowRect.left=(long)0;
  WindowRect.right=(long)width;
  WindowRect.top=(long)0;
  WindowRect.bottom=(long)height;
  fullscreen=fullscreenflag;
  hInstance = GetModuleHandle(NULL);
  wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
  wc.lpfnWndProc = (WNDPROC) WndProc;
  wc.cbClsExtra = 0;
  wc.cbWndExtra = 0;
  wc.hInstance = hInstance;
  wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  wc.hbrBackground = NULL;
  wc.lpszMenuName = NULL;
  wc.lpszClassName = "OpenGL";

  if (!RegisterClass(&wc))
  {
    MessageBox(NULL,"Konnte die Fensterklasse nicht registrieren.","ERROR",MB_OK|MB_ICONEXCLAMATION);
    return FALSE;
  }

  if (fullscreen)
  {
    DEVMODE dmScreenSettings;
    memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
    dmScreenSettings.dmSize=sizeof(dmScreenSettings);
    dmScreenSettings.dmPelsWidth = width;
    dmScreenSettings.dmPelsHeight = height;
    dmScreenSettings.dmBitsPerPel = bits;
    dmScreenSettings.dmFields=DM_BITSPERPEL|
    DM_PELSWIDTH|DM_PELSHEIGHT;

    if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
    {
      if (MessageBox(NULL,"Der gewünschte Vollbildmodus
                           wird nicht unterstützt, soll
                           stattdessen im Fenstermodus
                           ausgegeben werden?","OpenGL"
                           ,MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
      {
        fullscreen=FALSE;
      }
      else
      {
        return FALSE;
      }
    }
  }

  if (fullscreen)
  {
    dwExStyle=WS_EX_APPWINDOW;
    dwStyle=WS_POPUP;
    ShowCursor(FALSE);
  }
  else
  {
    dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
    dwStyle=WS_OVERLAPPEDWINDOW;
  }

  AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);

  if (!(hWnd=CreateWindowEx(dwExStyle,"OpenGL",title,WS_CLIPSIBLINGS | WS_CLIPCHILDREN | dwStyle, 0, 0, WindowRect.right-WindowRect.left,WindowRect.bottom-WindowRect.top,NULL,NULL,hInstance,NULL)))
  {
    KillGLWindow();
    MessageBox(NULL,"Fenster konnte nicht erstellt werden.","ERROR",MB_OK|MB_ICONEXCLAMATION);
    return FALSE;
  }

  static PIXELFORMATDESCRIPTOR pfd=
  {
    sizeof(PIXELFORMATDESCRIPTOR),1,PFD_DRAW_TO_WINDOW |PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, PFD_TYPE_RGBA, bits, 0, 0, 0, 0, 0, 0,0,0,0,0, 0, 0, 0,16,0,0,PFD_MAIN_PLANE,0,0, 0, 0
  };

  if (!(hDC=GetDC(hWnd)))
  {
    KillGLWindow();
    MessageBox(NULL,"Konnte keinen DC erstellen.","ERROR",MB_OK|MB_ICONEXCLAMATION);
    return FALSE;
  }

  if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))
  {
    KillGLWindow();
    MessageBox(NULL,"Konnte kein passendes Pixelformat finden.","ERROR",MB_OK|MB_ICONEXCLAMATION);
    return FALSE;
  }

  if(!SetPixelFormat(hDC,PixelFormat,&pfd))
  {
      KillGLWindow();
      MessageBox(NULL,"Konnte Pixelformat nicht setzen.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;
  }

  if (!(hRC=wglCreateContext(hDC)))
  {
    KillGLWindow();
    MessageBox(NULL,"Konnte keinen Rendering Context bekommen.","Fehler",MB_OK|MB_ICONEXCLAMATION);
    return FALSE;
  }

  if(!wglMakeCurrent(hDC,hRC))
  {
    KillGLWindow();
    MessageBox(NULL,"Konnte den Rendering Context nmicht aktivieren.","Fehler",MB_OK|MB_ICONEXCLAMATION);
    return FALSE;
  }

  ShowWindow(hWnd,SW_SHOW);
  SetForegroundWindow(hWnd);
  SetFocus(hWnd);
  ReSizeGLScene(width, height);

  if (!InitGL())
  {
    KillGLWindow();
    MessageBox(NULL,"Initialisierung fehlgeschlagen.","Fehler",MB_OK|MB_ICONEXCLAMATION);
    return FALSE;
  }
  return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  switch (uMsg)
  {
    case WM_ACTIVATE:
    {
      if (!HIWORD(wParam))
      {
        active=TRUE;
      }
      else
      {
        active=FALSE;
      }
      return 0;
    }

    case WM_SYSCOMMAND:
    {
      switch (wParam)
      {
        case SC_SCREENSAVE:
        case SC_MONITORPOWER:
        return 0;
      }
      break;
    }

    case WM_CLOSE:
    {
      PostQuitMessage(0);
      return 0;
    }

    case WM_KEYDOWN:
    {
      keys[wParam] = TRUE;
      return 0;
    }

    case WM_KEYUP:
    {
      keys[wParam] = FALSE;
      return 0;
    }

    case WM_SIZE:
    {
      ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));
      return 0;
    }
  }
  return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
  MSG msg;
  BOOL done=FALSE;

  if (MessageBox(NULL,"Soll im Vollbildmodus gestartet werden?","Vollbilmodus gewünscht?",MB_YESNO|MB_ICONQUESTION)==IDNO)
  {
    fullscreen=FALSE;
  }

  if (!CreateGLWindow("Opengl",640,480,16,fullscreen))
  {
    return 0;
  }

  while(!done)
  {
    if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
    {
      if (msg.message==WM_QUIT)
      {
        done=TRUE;
      }
      else
      {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
      }
    }
    else
    {
      if (active)
      {
        if (keys[VK_ESCAPE])
        {
          done=TRUE;
        }
        else
        {
          DrawGLScene();
          SwapBuffers(hDC);
        }
      }

      if (keys[VK_F1]) // Wird F1 gedrückt?
      {
        keys[VK_F1]=FALSE;
        KillGLWindow();
        fullscreen=!fullscreen;
        if (!CreateGLWindow("Lektion 1",640,480,16,fullscreen))
        {
          return 0;
        }
      }
    }
  }
  KillGLWindow();
  return (msg.wParam);
}


und ich denke da müsste man ein paar Sachen weglassen können
nur weiß ich nicht welche, aber ihr wisst das bestimmt
also könnt ihr mir ja sagen welche Sachen ich weglassen kann
um hinterher trotzdem noch Pixel setzen zu können
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
04.11.2005, 16:36 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


ne leider nicht. Außer evtl unten die Tastaturabfrage "Wird F1 gedrückt?"
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
04.11.2005, 18:29 Uhr
Nick H.



ich hab gehofft wenigstens das ein oder andere kann da weg
na egal hab trotzdem noch 4 Fragen:

1.bekom ich immer den Fehler das CDS_FULLSCREEN nicht gefunden werden kann
sonst findet er alles
was hat es damit aufsich? ist das vielleicht falsch geschrieben?

2.wenn ich CDS_FULLSCREEN einfach mal weglasse und das ganze dann dem Linker geb
meckert der für jede einzelne OpenGL Funktion
"undefined reference to ..." zB.: glViewport, glMatrixMode usw.
ich hab das Standard OpenGL benutzt das bei Dev-C++ dabei war
könnte das daran liegen das ich die opengl32.lib, die glaux.lib und die glu32.lib nicht eingebunden hab?
kann mir dann auch jemand sagen wie das bei Dev-C++ geht?
die Dateien haben immer eine .def Endung sind aber im LIB Ordner, der Rest müsste dann doch von allein gehen

3.kann ich das Koordinaten System bei OpenGL auch auf x nach rechts und y nach unten umstellen?

4.kann ich vielleicht die Pixel auch irgendwie über den Offset ansprechen?
am besten direkt über den Videospeicher, aber ich denke das geht nur bei DX...
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ OpenGL ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: