Creare un Engine grafico

[Revan1985]

Allora...
ho voglia quest'estate di creare un piccolo engine grafico [da usare al posto di Irrlicht], solo che...
non so da dove partire...
So usare c++, MFC [abbastanza, non troppo], C#.
Ora, non saprei da cominciare, quindi, se mi date dritte su :
Come iniziare,
Cosa conoscere[volevo farlo in dx, poi semmai anche ogl]
Come implementarlo

vi sarei grato.
Ringrazio in anticipo chi risponderà [spero in modo sensato]

[TheFury88]

Secondo me prima ti conviene fare un elenco delle funzioni che vuoi realizzare e concentrarti su quelle. Io ti consiglio di partire con l'importare modelli *.x che sono facilissimi per via del loro formato testuale. Studiati anche le matrici perchè vedrai che ti serviranno per importare i modelli.
http://www.visualcsharp.it/old_site/.../110.aspx.html
Poi concentrati sulla creazione di bounding box e sulla temporizzazione, perchè per far si che gli oggetti collidano devono , se non erro, muoversi tutti dellla stessa unità di misura.


EDIT: ti consiglio di usare il c++, e di salvare le funzioni in un file di intestazione per evitare di incasinare troppo il codice.

[Metflar]

Allora...
ho voglia quest'estate di creare un piccolo engine grafico [da usare al posto di Irrlicht], solo che...
non so da dove partire...
So usare c++, MFC [abbastanza, non troppo], C#.
Ora, non saprei da cominciare, quindi, se mi date dritte su :
Come iniziare,
Cosa conoscere[volevo farlo in dx, poi semmai anche ogl]
Come implementarlo

vi sarei grato.
Ringrazio in anticipo chi risponderà [spero in modo sensato]

in bocca al lupo!
p.s.io volevo realizzare una lib grafica 2d ma non sapevo da dove partire...

[Revan1985]

uhm....

una cosa...
allora, vorrei sviluppare sto motore in dx[che sarebbe buona], ma ho deciso di cambiare con OpenGL

solo, NeHe è mitico come C++/OpenGL, ma ha il brutto vizio di non usare Classi [cioè manca l'OO nei suoi tutorial]

conoscete qualche tutorial [anche inglese] che tratti le opengl sotto il lato OOP ?

grazie

[Hangman]

uhm....

una cosa...
allora, vorrei sviluppare sto motore in dx[che sarebbe buona], ma ho deciso di cambiare con OpenGL

solo, NeHe è mitico come C++/OpenGL, ma ha il brutto vizio di non usare Classi [cioè manca l'OO nei suoi tutorial]

conoscete qualche tutorial [anche inglese] che tratti le opengl sotto il lato OOP ?

grazie

Impara le nozioni e le API con NeHe e organizzati una struttura OO da solo

[Revan1985]

è quello che sto facendo, con i tutorial di Chad per l'oop su directX...
ma l'inizializzazione è completamente diversa

mi sa che faccio prima a fare da 0 io

[Eclipse]

http://www.ultimategameprogramming.c...=OpenGL&page=1

se non sai ancora farti una struttura oop tua vedi quella di engine esistenti

[Gyo15]

Ciao a tutti, scusate se mi intrometto...volevo fare solo una domanda: cosa è l' oop?

[Revan1985]

Object Oriented Programming

Programmazione orientata agli oggetti

quella che si usa di solito in c++ è procedurale [hai le tue funzioni, la main, quellle che ti servono, e fai quel che ti serve, il tutto di solito in 1 file, o magari 2-3 .h + il .ccp

La oop, invece, crei classi [su più file] e le usi a classi...
ora come spiegare quest'ultimo pezzo non saprei

[Hangman]

La procedurale si usa in C comunque, in C++ di norma si usano le classi

[Revan1985]

quando ho fatto alle superiori c++, abbiamo usato 2 volte le classi

[Eclipse]

quando ho fatto alle superiori c++, abbiamo usato 2 volte le classi

hai fatto c++ di merda allora

[Revan1985]

si, infatti nel 90% del codice c++ [ #ifndef, #ifdef mi perdo ]

[Revan1985]

allora, qualcosa o fatto [solo l'inizializzazione], am ho il prolema che non si killa da solo quando esco dal programma...

questo è il codice :

main.cpp

Spoiler:

#include "stdafx.h"
#include "CFramework.h"

int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd )
{
    CFramework* framework = new CFramework( hInstance );


    if( !framework->Initialize( "Dominium", 800, 600, 32, false ) );
    framework->Run();

    framework->Release();

    return 0;
}

CFramework.h

Spoiler:

#ifndef CFRAMEWORK_H
#define CFRAMEWORK_H

#include "stdafx.h"
#include "CGraphics.h"

class CFramework
{
public:
    CFramework( HINSTANCE hInstance );
    ~CFramework() { Release(); }
    bool Initialize( char* title, int width, int height, int bpp, bool fullscreen );
    void Run();
    void Release();
    static LRESULT CALLBACK StaticWndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam );
private:

    HWND        m_hWnd;
    HINSTANCE    m_hInstance;
    static LRESULT CALLBACK WndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam );

    CGraphics* graphic;

    int        m_WindowHeight;
    int        m_WindowWidth;
    int        m_bpp;
    int        m_fullscreen;
    char*    m_className;
    bool    m_loop;

};

#endif

CFramework.cpp

Spoiler:

#include "stdafx.h"
#include "CFramework.h"

CFramework::CFramework( HINSTANCE hInstance )
{
    this->m_hInstance = hInstance;
    this->m_loop = false;
}

void CFramework::Release()
{
    graphic->Release();
    UnregisterClass( m_className, this->m_hInstance );
}

bool CFramework::Initialize( char *title, int width, int height, int bpp, bool fullscreen )
{
    this->m_className = title;

    WNDCLASSEX    wc;

    wc.cbSize                = sizeof( WNDCLASSEX );
    wc.style                = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc            = StaticWndProc;
    wc.cbClsExtra            = 0;
    wc.cbWndExtra            = 0;
    wc.hInstance            = this->m_hInstance;
    wc.hIcon                = LoadIcon( NULL, IDI_APPLICATION );
    wc.hCursor                = LoadCursor( NULL, IDC_ARROW );
    wc.hbrBackground        = NULL;
    wc.lpszMenuName            = NULL;
    wc.lpszClassName        = title;
    wc.hIconSm                = LoadIcon( NULL, IDI_APPLICATION );

    if( !RegisterClassEx( &wc ) ) return false;

    this->m_hWnd = CreateWindowEx(    NULL,
                                    title,
                                    title,
                                    WS_OVERLAPPEDWINDOW | WS_VISIBLE |
                                    WS_SYSMENU | WS_CLIPCHILDREN |
                                    WS_CLIPSIBLINGS,
                                    100, 100,
                                    width, height,
                                    NULL,
                                    NULL,
                                    this->m_hInstance,
                                    NULL );
    if( !this->m_hWnd ) return false;

    ShowWindow( this->m_hWnd, SW_SHOW );
    UpdateWindow( this->m_hWnd );

    graphic = new CGraphics( this->m_hWnd );

    if( !graphic->Initialize() ) return false;

    return true;
}

void CFramework::Run()
{
    MSG msg;
    while(!this->m_loop)
    {
        if( PeekMessage( &msg, NULL, NULL, NULL, PM_REMOVE ) )
        {
            if( msg.message == WM_QUIT )
            {
                this->m_loop = true;
            }

            TranslateMessage( &msg );
            DispatchMessage( &msg );
        }
        else
        {
            graphic->Run();
        }
    }

}

LRESULT CALLBACK CFramework::StaticWndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
   if ( msg == WM_CREATE )
   {
       SetWindowLongPtr( hWnd, GWLP_USERDATA, (LONG)((CREATESTRUCT *)lParam)->lpCreateParams );
   }

   CFramework *targetApp = (CFramework*)GetWindowLongPtr( hWnd, GWLP_USERDATA );

   if ( targetApp )
   {
       return targetApp->WndProc( hWnd, msg, wParam, lParam );
   }

   return DefWindowProc( hWnd, msg, wParam, lParam );
}

LRESULT CALLBACK CFramework::WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
   switch ( message )
   {
   case WM_DESTROY:
       PostQuitMessage( 0 );
       return 0;
   case WM_KEYDOWN:
       // Send keystrokes to application to handle
       return 0;
   }
   return DefWindowProc( hWnd, message, wParam, lParam );
}

CGraphics.h

Spoiler:

#ifndef CGRAPHICS_H
#define CGRAPHICS_H

#include "stdafx.h"

class CGraphics
{
public:

    CGraphics( HWND hWnd );
    ~CGraphics() { Release(); }
    void Release();
    bool Initialize();
    void Run();
    LPDIRECT3DDEVICE9 GetDevice() { return this->d3dDevice; }
private:
    bool d3d_PP_Initialize();

    HWND                    d3dhWnd;
    D3DCAPS9                d3dCaps;
    LPDIRECT3D9                d3dObject;
    D3DDISPLAYMODE            d3dDisplaymode;
    LPDIRECT3DDEVICE9        d3dDevice;
    D3DPRESENT_PARAMETERS    d3dPP;
};

#endif

CGraphics.cpp

Spoiler:

#include "stdafx.h"
#include "CGraphics.h"

CGraphics::CGraphics( HWND hWnd )
{
    this->d3dObject = NULL;
    this->d3dDevice = NULL;
    this->d3dhWnd = hWnd;
}

void CGraphics::Release()
{
    if( this->d3dDevice != NULL )
    {
        this->d3dDevice->Release();
        this->d3dDevice = NULL;
    }

    if( this->d3dObject != NULL )
    {
        this->d3dObject->Release();
        this->d3dObject = NULL;
    }
}

bool CGraphics::Initialize()
{
    ZeroMemory( &this->d3dPP, sizeof( this->d3dPP ) );

    this->d3dObject = Direct3DCreate9( D3D_SDK_VERSION );

    if( this->d3dObject == NULL )
    {
        MessageBox( NULL, "Impossibile Inizializzare Direct3D?!?", "Errore", MB_OK | MB_ICONEXCLAMATION );
        return false;
    }

    if( FAILED( this->d3dObject->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &this->d3dDisplaymode ) ) )
    {
        MessageBox( NULL, "Eroore nel settaggio del Display Mode", "Errore", MB_OK | MB_ICONEXCLAMATION );
        return false;
    }

    if( FAILED( this->d3dObject->GetDeviceCaps( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &this->d3dCaps ) ) )
    {
        return false;
    }

    DWORD VertexProcessing = 0;

    if( this->d3dCaps.VertexProcessingCaps != 0 )
        VertexProcessing |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
    else
        VertexProcessing |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;

    this->d3dPP.Windowed = true;
    this->d3dPP.SwapEffect = D3DSWAPEFFECT_DISCARD;
    this->d3dPP.BackBufferCount = 1;
    this->d3dPP.EnableAutoDepthStencil = true;
    this->d3dPP.AutoDepthStencilFormat = D3DFMT_D16;

    if( FAILED( this->d3dObject->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, this->d3dhWnd,
                                                VertexProcessing, &this->d3dPP, &this->d3dDevice ) ) )
    {
        MessageBox( NULL, "Creazione D3D Device fallita! Controllare che le directX 9.0 siano installate", "Errore", MB_OK | MB_ICONINFORMATION );
        return false;
    }

    if( this->d3dDevice == NULL )
    {
        MessageBox( NULL, "D3D è equivalente a Null?!?", "Errore", MB_OK | MB_ICONINFORMATION );
        return false;
    }

    this->d3dDevice->SetRenderState( D3DRS_LIGHTING, false );
    this->d3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );

    return true;
}

void CGraphics::Run()
{
    this->d3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB( 0, 0, 0 ), 1.0f, 0 );
    this->d3dDevice->BeginScene();

    this->d3dDevice->EndScene();
    this->d3dDevice->Present( NULL, NULL, NULL, NULL );
}

il codice funziona da dio, parte, inizializza lo schermo [solo nero per ora], ma non mi killa l'applicazione, infatti nel taskmanager rimane

[Gyo15]

Scusate...stdafx.h che libreria è?