Jump to content
  • Advertisement
Sign in to follow this  

Importing Images

This topic is 3851 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Anyone know if it's possible to import images into a project file for Visual C++ Express 2008? I think it should be, but the help menu only described the process for Visual Studio, and I can't find the answer on the internet. It's not that big of a deal, but it seems there should be a way so you don't have to do it manually.

Share this post

Link to post
Share on other sites
By import i assume you mean make it as part of the exe itself and the answer is yes if you make it part of the resource for the exe. Look up something called ResEdit. and when you call the loadimage function it should have a filed where you can difine it as a resource and instead of useing its name you use a marco called MAKEINTORESOURCE and that will acomplish what you want.

Check up on the LoadBitmap function on msdn to figure out what fileds will need what info and get a copy of ResEdit as it is a free resource editor.

VC++ Express does not come with a built in reource editor but can still compile adn use the files so you should not have much of a problem after that.

One thing to note is it is not a good overal idea to make large images part of the exe small ones like icons and things of that sort are ok.

Inmages in the exe are stored in a bitmap form and thus take up quite abit of space so avoid makeing larger then needed Exe's.

Regards Jouei.

Share this post

Link to post
Share on other sites
Thanks muchly.

On a completely unrelated topic, does anyone have any tips on rotating a directional light? It's a recommended exercise for a tutorial I'm taking, but I can't think of where to start from.

Share this post

Link to post
Share on other sites
Well that all depends on what your useing is it a 3d eviroment is it Opengl or DiectX you need to clarify these things so pepole can answer you better :)

if its OpenGL google NeHe and it will give a list of a nicely sized cache of OpenGL tutorials if it is not then try to googl NeXe it is for direct 3d stuff

Regards Jouei.

Remmber to rate pepole on how they help you its there for that reason.

Share this post

Link to post
Share on other sites
Here's the code I'm trying to modify (not mine):

// include the basic windows header files and the Direct3D header file
#include <windows.h>
#include <windowsx.h>
#include <d3d9.h>
#include <d3dx9.h>

// define the screen resolution and keyboard macros
#define SCREEN_WIDTH 640
#define SCREEN_HEIGHT 480
#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEY_UP(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

// include the Direct3D Library files
#pragma comment (lib, "d3d9.lib")
#pragma comment (lib, "d3dx9.lib")

// global declarations
LPDIRECT3D9 d3d; // the pointer to our Direct3D interface
LPDIRECT3DDEVICE9 d3ddev; // the pointer to the device class
LPDIRECT3DVERTEXBUFFER9 t_buffer = NULL; // the pointer to the vertex buffer

// texture declarations
LPDIRECT3DTEXTURE9 texture_1; // our first texture

// function prototypes
void initD3D(HWND hWnd); // sets up and initializes Direct3D
void render_frame(void); // renders a single frame
void cleanD3D(void); // closes Direct3D and releases memory
void init_graphics(void); // 3D declarations
void init_light(void); // sets up the light and the material


// the WindowProc function prototype
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

// the entry point for any Windows program
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
HWND hWnd;

ZeroMemory(&wc, sizeof(WNDCLASSEX));

wc.cbSize = sizeof(WNDCLASSEX);
wc.lpfnWndProc = (WNDPROC)WindowProc;
wc.hInstance = hInstance;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.lpszClassName = L"WindowClass";


hWnd = CreateWindowEx(NULL, L"WindowClass", L"Our Direct3D Program",
NULL, NULL, hInstance, NULL);

ShowWindow(hWnd, nCmdShow);

// set up and initialize Direct3D

// enter the main loop:

MSG msg;

DWORD starting_point = GetTickCount();

if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
if (msg.message == WM_QUIT)



// check the 'escape' key
PostMessage(hWnd, WM_DESTROY, 0, 0);

while ((GetTickCount() - starting_point) < 25);

// clean up DirectX and COM

return msg.wParam;

// this is the main message handler for the program
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
return 0;
} break;

return DefWindowProc (hWnd, message, wParam, lParam);

// this function initializes and prepares Direct3D for use
void initD3D(HWND hWnd)
d3d = Direct3DCreate9(D3D_SDK_VERSION);


ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.Windowed = FALSE;
d3dpp.hDeviceWindow = hWnd;
d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
d3dpp.BackBufferWidth = SCREEN_WIDTH;
d3dpp.BackBufferHeight = SCREEN_HEIGHT;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;

// create a device class using this information and the info from the d3dpp stuct

init_graphics(); // call the function to initialize the cube
init_light(); // call the function to initialize the light and material

d3ddev->SetRenderState(D3DRS_LIGHTING, TRUE); // turn on the 3D lighting
d3ddev->SetRenderState(D3DRS_ZENABLE, TRUE); // turn on the z-buffer
d3ddev->SetRenderState(D3DRS_AMBIENT, D3DCOLOR_XRGB(50, 50, 50)); // ambient light


// this is the function used to render a single frame
void render_frame(void)
d3ddev->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
d3ddev->Clear(0, NULL, D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);


// select which vertex format we are using

// set the view transform
D3DXMATRIX matView; // the view transform matrix
&D3DXVECTOR3 (0.0f, 8.0f, 25.0f), // the camera position
&D3DXVECTOR3 (0.0f, 0.0f, 0.0f), // the look-at position
&D3DXVECTOR3 (0.0f, 1.0f, 0.0f)); // the up direction
d3ddev->SetTransform(D3DTS_VIEW, &matView);

// set the projection transform
D3DXMATRIX matProjection; // the projection transform matrix
D3DXToRadian(45), // the horizontal field of view
1.0f, // the near view-plane
100.0f); // the far view-plane
d3ddev->SetTransform(D3DTS_PROJECTION, &matProjection);

// set the world transform
static float index = 0.0f; index+=0.03f; // an ever-increasing float value
D3DXMATRIX matRotateY; // a matrix to store the rotation for each triangle
D3DXMatrixRotationY(&matRotateY, index); // the rotation matrix
d3ddev->SetTransform(D3DTS_WORLD, &(matRotateY)); // set the world transform

// select the vertex buffer to display
d3ddev->SetStreamSource(0, t_buffer, 0, sizeof(CUSTOMVERTEX));

// set the texture
d3ddev->SetTexture(0, texture_1);

// draw the textured square
d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 4, 2);
d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 8, 2);
d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 12, 2);
d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 16, 2);
d3ddev->DrawPrimitive(D3DPT_TRIANGLESTRIP, 20, 2);


d3ddev->Present(NULL, NULL, NULL, NULL);


// this is the function that cleans up Direct3D and COM
void cleanD3D(void)
t_buffer->Release(); // close and release the vertex buffer
texture_1->Release(); // close and release the texture
d3ddev->Release(); // close and release the 3D device
d3d->Release(); // close and release Direct3D


// this is the function that puts the 3D models into video RAM
void init_graphics(void)
// load the texture we will use

// create the vertices using the CUSTOMVERTEX struct
// side 1
{ -3.0f, 3.0f, -3.0f, 0, 0, -1, 0, 1, },
{ 3.0f, 3.0f, -3.0f, 0, 0, -1, 1, 1, },
{ -3.0f, -3.0f, -3.0f, 0, 0, -1, 0, 0, },
{ 3.0f, -3.0f, -3.0f, 0, 0, -1, 1, 0, },

// side 2
{ -3.0f, 3.0f, 3.0f, 0, 0, 1, 0, 1, },
{ -3.0f, -3.0f, 3.0f, 0, 0, 1, 0, 0, },
{ 3.0f, 3.0f, 3.0f, 0, 0, 1, 1, 1, },
{ 3.0f, -3.0f, 3.0f, 0, 0, 1, 1, 0, },

// side 3
{ -3.0f, 3.0f, 3.0f, 0, 1, 0, 0, 1, },
{ 3.0f, 3.0f, 3.0f, 0, 1, 0, 1, 1, },
{ -3.0f, 3.0f, -3.0f, 0, 1, 0, 0, 0, },
{ 3.0f, 3.0f, -3.0f, 0, 1, 0, 1, 0, },

// side 4
{ -3.0f, -3.0f, 3.0f, 0, -1, 0, 0, 1, },
{ -3.0f, -3.0f, -3.0f, 0, -1, 0, 0, 0, },
{ 3.0f, -3.0f, 3.0f, 0, -1, 0, 1, 1, },
{ 3.0f, -3.0f, -3.0f, 0, -1, 0, 1, 0, },

// side 5
{ 3.0f, 3.0f, -3.0f, 1, 0, 0, 1, 0, },
{ 3.0f, 3.0f, 3.0f, 1, 0, 0, 1, 1, },
{ 3.0f, -3.0f, -3.0f, 1, 0, 0, 0, 0, },
{ 3.0f, -3.0f, 3.0f, 1, 0, 0, 0, 1, },

// side 6
{ -3.0f, 3.0f, -3.0f, -1, 0, 0, 1, 0, },
{ -3.0f, -3.0f, -3.0f, -1, 0, 0, 0, 0, },
{ -3.0f, 3.0f, 3.0f, -1, 0, 0, 1, 1, },
{ -3.0f, -3.0f, 3.0f, -1, 0, 0, 0, 1, },
}; // that reminds me of programming in binary!

// create a vertex buffer interface called t_buffer

VOID* pVoid; // a void pointer

// lock t_buffer and load the vertices into it
t_buffer->Lock(0, 0, (void**)&pVoid, 0);
memcpy(pVoid, t_vert, sizeof(t_vert));


// this is the function that sets up the lights and materials
void init_light(void)
D3DLIGHT9 light; // create the light struct
D3DMATERIAL9 material; // create the material struct

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

D3DVECTOR vecDirection = {-1.0f, -0.3f, -1.0f}; // the direction of the light
light.Direction = vecDirection; // set the direction

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

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

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


I'm thinking I'll have to make a constantly increasing variable to represent radians around a circle, and then use sin/cos to make x and y values that I'll plug into the light's Direction. Sounds like the most efficient way to do it.

[Edited by - Plarin on May 26, 2008 10:14:18 PM]

Share this post

Link to post
Share on other sites
Okay, so when I tried to implement my little plan, I realized that the light struct had gone out of scope, so I don't really have any way to "update" it.

Is there any function I can call to change the properties of the light during runtime?

Share this post

Link to post
Share on other sites
Well i am not sure as i do not deal with direct3d myself. One thing you could do is check msdn.com its a microsft devlopment network archive of sorts.

or the other option is save the structure globaly so its allways there not by far the best solution but should work if it is a must.

Sorry i could not be of more help. I suggest geting this post moved to the DirectX forum if an admin is checking it it will probaly get a few more responses.

Or close this one Post and label it as sovled and start a nwe one in the directX forum. The latter of the two is better.

Regards Jouei.

Share this post

Link to post
Share on other sites
Sign in to follow this  

  • Advertisement

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!