none
Trying to get most lights to work RRS feed

  • Question

  • DirectX 9.0c SDK Aug '08
    Visual Studio Pro '08

    I have taken DirectX's Textures tutorial (Tutorial 5) and have added light functionality to it as well as made use of a new texture, but I know that's not important. Anyway, I can only get the ambient light to work.

    Please view the below code and tell me where I went wrong. I'm sorry it's not in a codebox, but the post editor was just being weird to me about it.
    The compiler never complained to me. No warnings or anything of the sort.

    I bolded the changes. I'm aware I'm calling init_light twice when I don't need to be, you don't need to tell me.

    One more question, when I prefix the L before my other apps I'm told there was a problem converting to wide char. I saw charac ter sets were responsible for that, but where do I change that setting?

    //-----------------------------------------------------------------------------
    // File: Textures.cpp
    //
    // Desc: Better than just lights and materials, 3D objects look much more
    //       convincing when texture-mapped. Textures can be thought of as a sort
    //       of wallpaper, that is shrinkwrapped to fit a texture. Textures are
    //       typically loaded from image files, and D3DX provides a utility to
    //       function to do this for us. Like a vertex buffer, Textures have
    //       Lock() and Unlock() functions to access (read or write) the image
    //       data. Textures have a width, height, miplevel, and pixel format. The
    //       miplevel is for "mipmapped" Textures, an advanced performance-
    //       enhancing feature which uses lower resolutions of the texture for
    //       objects in the distance where detail is less noticeable. The pixel
    //       format determines how the colors are stored in a texel. The most
    //       common formats are the 16-bit R5G6B5 format (5 bits of red, 6-bits of
    //       green and 5 bits of blue) and the 32-bit A8R8G8B8 format (8 bits each
    //       of alpha, red, green, and blue).
    //
    //       Textures are associated with geometry through texture coordinates.
    //       Each vertex has one or more sets of texture coordinates, which are
    //       named tu and tv and range from 0.0 to 1.0. Texture coordinates can be
    //       supplied by the geometry, or can be automatically generated using
    //       Direct3D texture coordinate generation (which is an advanced feature).
    //
    // Copyright (c) Microsoft Corporation. All rights reserved.
    //-----------------------------------------------------------------------------
    #include <Windows.h>
    #include <mmsystem.h>
    #include <d3dx9.h>
    #pragma warning( disable : 4996 ) // disable deprecated warning
    #include <strsafe.h>
    #pragma warning( default : 4996 )



    //-----------------------------------------------------------------------------
    // Global variables
    //-----------------------------------------------------------------------------
    LPDIRECT3D9             g_pD3D = NULL; // Used to create the D3DDevice
    LPDIRECT3DDEVICE9       g_pd3dDevice = NULL; // Our rendering device
    LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL; // Buffer to hold vertices
    LPDIRECT3DTEXTURE9      g_pTexture = NULL; // Our texture

    // A structure for our custom vertex type. We added texture coordinates
    struct CUSTOMVERTEX
    {
        D3DXVECTOR3 position; // The position
        D3DVECTOR NORMAL; //Normals to measure the axis perpendicular to a surface to assist lighting calculations.
        D3DCOLOR color;    // The color
    #ifndef SHOW_HOW_TO_USE_TCI //if SHOW_HOW_TO_USE_TCI is not defined yet...
        FLOAT tu, tv;   // The texture coordinates
    #endif
    };

    // Our custom FVF, which describes our custom vertex structure
    #ifdef SHOW_HOW_TO_USE_TCI //If the definition is made, define FVF for 3d transform, normals, and diffuse.
    #define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_DIFFUSE)
    #else
    #define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_DIFFUSE|D3DFVF_TEX1) //Define format for 3D transformed vertices, diffuse lighting, and textures
    #endif


    void init_light();    // sets up the light and the material. PROTOTYPE
    //-----------------------------------------------------------------------------
    // Name: InitD3D()
    // Desc: Initializes Direct3D
    //-----------------------------------------------------------------------------
    HRESULT InitD3D( HWND hWnd )
    {
        // Create the D3D object.
        if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
            return E_FAIL;

        // Set up the structure used to create the D3DDevice. Since we are now
        // using more complex geometry, we will create a device with a zbuffer.

        D3DPRESENT_PARAMETERS d3dpp;//Initialize struct containing buffer chain.

        ZeroMemory( &d3dpp, sizeof( d3dpp ) ); //Null memory block equal to my buffer size.

        d3dpp.Windowed = TRUE; //Programming in windowed mode.
        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; //Finished buffer images are deleted after use.
        d3dpp.BackBufferFormat = D3DFMT_UNKNOWN; //Format currently undefined.
        d3dpp.EnableAutoDepthStencil = TRUE; //Assist me in managing buffers.
        d3dpp.AutoDepthStencilFormat = D3DFMT_D16; //16 bit zBuf depth.

        // Create the D3DDevice
        if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                          D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                          &d3dpp, &g_pd3dDevice ) ) )
        {
            return E_FAIL;
        }

        init_light();

        // Turn off culling
        g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
        g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
        g_pd3dDevice->SetRenderState(D3DRS_AMBIENT, D3DCOLOR_XRGB(70, 70, 70)); //Set a dark ambient light.
        // Turn on the zbuffer
        g_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
        g_pd3dDevice->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE);
        return S_OK;
    }


    void init_light()
    {
        D3DLIGHT9 light;    // create the light struct
        D3DMATERIAL9 material;    // create the material struct

        ZeroMemory(&light, sizeof(light));    // clear out the light struct for use
        light.Type = D3DLIGHT_POINT;    // make the light type point light'
        light.Diffuse.r = 1.0f;    // .5 red
        light.Diffuse.g = 1.0f;    // .5 green
        light.Diffuse.b = 1.0f;    // .5 blue
        light.Diffuse.a = 1.0f;    // full alpha (we'll get to that soon)

        light.Specular.r = 1.0f;    // .5 red
        light.Specular.g = 0.0f;    // .5 green
        light.Specular.b = 0.0f;    // .5 blue
        light.Specular.a = 1.0f;    // full alpha (we'll get to that soon)

        light.Range = 500.0f;    // a range of 100
        light.Attenuation0 = 0.2f;    // no constant inverse attenuation
        light.Attenuation1 = 0.125f;    // only .125 inverse attenuation
        light.Attenuation2 = 0.0f;    // no square inverse attenuation

        D3DVECTOR vecPosition = {4.0f, 0.0f, 0.0f};    // the position of the light
        light.Position = vecPosition;    // set the position

        g_pd3dDevice->SetLight(0, &light);    // send the light struct properties to light #0
        g_pd3dDevice->LightEnable(0, TRUE);    // turn on light #0

       
        ZeroMemory(&material, sizeof(D3DMATERIAL9));    // clear out the struct for use
        material.Ambient.r = .5f;    // set the material to full red
        material.Ambient.g = .5f;    // set the material to full green
        material.Ambient.b = .5f;    // set the material to full blue
        material.Ambient.a = .5f;    // set the material to full alpha

        material.Diffuse.r = 1.0f;    // set the material to full red
        material.Diffuse.g = 1.0f;    // set the material to full green
        material.Diffuse.b = 1.0f;    // set the material to full blue
        material.Diffuse.a = 1.0f;    // set the material to full alpha

        material.Specular.r = 1.0f;
        material.Specular.g = 1.0f;
        material.Specular.b = 1.0f;
        material.Specular.a = 1.0f;
        material.Power = 50.0f;

        g_pd3dDevice->SetMaterial(&material);    // set the globably-used material to &material

        return;
    }

    //-----------------------------------------------------------------------------
    // Name: InitGeometry()
    // Desc: Create the Textures and vertex buffers
    //-----------------------------------------------------------------------------
    HRESULT InitGeometry()
    {
        // Use D3DX to create a texture from a file based image
        if( FAILED( D3DXCreateTextureFromFile( g_pd3dDevice, L"wood1.png", &g_pTexture ) ) )
        {
            // If texture is not in current folder, try parent folder
            if( FAILED( D3DXCreateTextureFromFile( g_pd3dDevice, L"..\\wood1.png", &g_pTexture ) ) )
            {
                MessageBox( NULL, L"Could not find wood1.png", L"Textures.exe", MB_OK );
                return E_FAIL;
            }
        }

        // Create the vertex buffer.
        if( FAILED( g_pd3dDevice->CreateVertexBuffer( 50 * 2 * sizeof( CUSTOMVERTEX ),
                                                      0, D3DFVF_CUSTOMVERTEX,
                                                      D3DPOOL_DEFAULT, &g_pVB, NULL ) ) )
        {
            return E_FAIL;
        }

        // Fill the vertex buffer. We are setting the tu and tv texture
        // coordinates, which range from 0.0 to 1.0
        CUSTOMVERTEX* pVertices;
        if( FAILED( g_pVB->Lock( 0, 0, ( void** )&pVertices, 0 ) ) ) //Lock vertex buffer in memory.
            return E_FAIL;
        for( DWORD i = 0; i < 50; i++ )
        {
            FLOAT theta = ( 2 * D3DX_PI * i ) / ( 50 - 1 );

            pVertices[2 * i + 0].position = D3DXVECTOR3( sinf( theta ), -1.0f, cosf( theta ) );
            pVertices[2 * i + 0].color = 0xffffffff;
    #ifndef SHOW_HOW_TO_USE_TCI
            pVertices[2 * i + 0].tu = ( ( FLOAT )i ) / ( 50 - 1 );
            pVertices[2 * i + 0].tv = 1.0f;
    #endif

            pVertices[2 * i + 1].position = D3DXVECTOR3( sinf( theta ), 1.0f, cosf( theta ) );
            pVertices[2 * i + 1].color = 0xff808080;
    #ifndef SHOW_HOW_TO_USE_TCI
            pVertices[2 * i + 1].tu = ( ( FLOAT )i ) / ( 50 - 1 );
            pVertices[2 * i + 1].tv = 0.0f;
    #endif
        }
        g_pVB->Unlock();

        return S_OK;
    }




    //-----------------------------------------------------------------------------
    // Name: Cleanup()
    // Desc: Releases all previously initialized objects
    //-----------------------------------------------------------------------------
    VOID Cleanup()
    {
        if( g_pTexture != NULL )
            g_pTexture->Release();

        if( g_pVB != NULL )
            g_pVB->Release();

        if( g_pd3dDevice != NULL )
            g_pd3dDevice->Release();

        if( g_pD3D != NULL )
            g_pD3D->Release();
    }



    //-----------------------------------------------------------------------------
    // Name: SetupMatrices()
    // Desc: Sets up the world, view, and projection transform matrices.
    //-----------------------------------------------------------------------------
    VOID SetupMatrices()
    {
        // Set up world matrix
        D3DXMATRIXA16 matWorld;
        D3DXMatrixIdentity( &matWorld );
        D3DXMatrixRotationX( &matWorld, timeGetTime() / 1000.0f );
        g_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );

        // Set up our view matrix. A view matrix can be defined given an eye point,
        // a point to lookat, and a direction for which way is up. Here, we set the
        // eye five units back along the z-axis and up three units, look at the
        // origin, and define "up" to be in the y-direction.
        static float rot = 0.0f; rot += .02f; //Used to scoot the camera over to the right to preview lights.
        D3DXVECTOR3 vEyePt( rot, 3.0f,-5.0f );
        D3DXVECTOR3 vLookatPt( 0.0f, 0.0f, 0.0f );
        D3DXVECTOR3 vUpVec( 0.0f, 1.0f, 0.0f );
        D3DXMATRIXA16 matView;
        D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookatPt, &vUpVec );
        g_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );

        // For the projection matrix, we set up a perspective transform (which
        // transforms geometry from 3D view space to 2D viewport space, with
        // a perspective divide making objects smaller in the distance). To build
        // a perpsective transform, we need the field of view (1/4 pi is common),
        // the aspect ratio, and the near and far clipping planes (which define at
        // what distances geometry should be no longer be rendered).
        D3DXMATRIXA16 matProj;
        D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI / 4, 1.0f, 1.0f, 100.0f );
        g_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
    }




    //-----------------------------------------------------------------------------
    // Name: Render()
    // Desc: Draws the scene
    //-----------------------------------------------------------------------------
    VOID Render()
    {
        // Clear the backbuffer and the zbuffer
        g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                             D3DCOLOR_XRGB( 0, 0, 255 ), 1.0f, 0 );

        // Begin the scene
        if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
        {
            // Setup the world, view, and projection matrices
            SetupMatrices();

            // Setup our texture. Using Textures introduces the texture stage states,
            // which govern how Textures get blended together (in the case of multiple
            // Textures) and lighting information. In this case, we are modulating
            // (blending) our texture with the diffuse color of the vertices.
            g_pd3dDevice->SetTexture( 0, g_pTexture );
            g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
            g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
            g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
            g_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE );

    #ifdef SHOW_HOW_TO_USE_TCI
            // Note: to use D3D texture coordinate generation, use the stage state
        // D3DTSS_TEXCOORDINDEX, as shown below. In this example, we are using
        // the position of the vertex in camera space (D3DTSS_TCI_CAMERASPACEPOSITION)
        // to generate texture coordinates. Camera space is the vertex position
        // multiplied by the World and View matrices.  The tex coord index (TCI) 
        // parameters are passed into a texture transform, which is a 4x4 matrix 
        // which transforms the x,y,z TCI coordinates into tu, tv texture coordinates.

        // In this example, the texture matrix is setup to transform the input
        // camera space coordinates (all of R^3) to projection space (-1,+1)
        // and finally to texture space (0,1).
        //    CameraSpace.xyzw = (input vertex position) * (WorldView)
        //    ProjSpace.xyzw = CameraSpace.xyzw * Projection           //move to -1 to 1
        //    TexSpace.xyzw = ProjSpace.xyzw * ( 0.5, -0.5, 1.0, 1.0 ) //scale to -0.5 to 0.5 (flip y)
        //    TexSpace.xyzw += ( 0.5, 0.5, 0.0, 0.0 )                  //shift to 0 to 1

        // Setting D3DTSS_TEXTURETRANSFORMFLAGS to D3DTTFF_COUNT4 | D3DTTFF_PROJECTED
        // tells D3D to divide the input texture coordinates by the 4th (w) component.
        // This divide is necessary when performing a perspective projection since
        // the TexSpace.xy coordinates prior to the homogeneous divide are not actually
        // in the 0 to 1 range.
        D3DXMATRIXA16 mTextureTransform;
        D3DXMATRIXA16 mProj;
        D3DXMATRIXA16 mTrans;
        D3DXMATRIXA16 mScale;

        g_pd3dDevice->GetTransform( D3DTS_PROJECTION, &mProj );
        D3DXMatrixTranslation( &mTrans, 0.5f, 0.5f, 0.0f );
        D3DXMatrixScaling( &mScale, 0.5f, -0.5f, 1.0f );
        mTextureTransform = mProj * mScale * mTrans;

        g_pd3dDevice->SetTransform( D3DTS_TEXTURE0, &mTextureTransform );
        g_pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4 | D3DTTFF_PROJECTED );
        g_pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION );
        #endif

            // Render the vertex buffer contents
            g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof( CUSTOMVERTEX ) );
            g_pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
            g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2 * 50 - 2 );

            // End the scene
            g_pd3dDevice->EndScene();
        }

        // Present the backbuffer contents to the display
        g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
    }




    //-----------------------------------------------------------------------------
    // Name: MsgProc()
    // Desc: The window's message handler
    //-----------------------------------------------------------------------------
    LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
    {
        switch( msg )
        {
            case WM_DESTROY:
                Cleanup();
                PostQuitMessage( 0 );
                return 0;
        }

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




    //-----------------------------------------------------------------------------
    // Name: WinMain()
    // Desc: The application's entry point
    //-----------------------------------------------------------------------------
    INT WINAPI wWinMain( HINSTANCE hInst, HINSTANCE, LPWSTR, INT )
    {
        // Register the window class
        WNDCLASSEX wc =
        {
            sizeof( WNDCLASSEX ), CS_CLASSDC, MsgProc, 0L, 0L,
            GetModuleHandle( NULL ), NULL, NULL, NULL, NULL,
            L"D3D Tutorial", NULL
        };
        RegisterClassEx( &wc );

        // Create the application's window
        HWND hWnd = CreateWindow( L"D3D Tutorial", L"D3D Tutorial 05: Textures",
                                  WS_OVERLAPPEDWINDOW, 100, 100, 300, 300,
                                  NULL, NULL, wc.hInstance, NULL );

        // Initialize Direct3D
        if( SUCCEEDED( InitD3D( hWnd ) ) )
        {
            // Create the scene geometry
            if( SUCCEEDED( InitGeometry() ) )
            {
                // Show the window
                ShowWindow( hWnd, SW_SHOWDEFAULT );
                UpdateWindow( hWnd );

                // Enter the message loop
                MSG msg;
                ZeroMemory( &msg, sizeof( msg ) );
                while( msg.message != WM_QUIT )
                {
                    if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
                    {
                        TranslateMessage( &msg );
                        DispatchMessage( &msg );
                    }
                    else
                    {
                        init_light();
                        Render();
                    }
                }
            }
        }

        UnregisterClass( L"D3D Tutorial", wc.hInstance );
        return 0;
    }




    • Edited by zyrolasting Monday, September 8, 2008 6:01 AM ...Can I please just edit my posts?
    • Moved by Yan-Fei Wei Monday, September 15, 2008 3:30 AM Not a Visual C++ issue (Moved from Visual C++ General to Off-Topic Posts (Do Not Post Here))
    Monday, September 8, 2008 5:55 AM

All replies

  •  

    Dear Zyrolasting,

     

    Thanks for participating on the MSDN Forum, but this forum section is reserved for Visual C++ General Questions. For DirectX question, you can post your question on the DirectX newsgroup, there you find DirectX experts and your question should be answered in no time.


    The people there will have enough experience with DirectX
    to give you the best advice or answer!

     

    Thanks!


    Please remember to mark the replies as answers if they help and unmark them if they provide no help. http://forums.msdn.microsoft.com/en-US/vcgeneral/thread/aad4f73b-59e2-4ead-8a11-a19752dfea0a
    Monday, September 15, 2008 3:29 AM