Sorry your browser is not supported!

#ifndef SHAREDMEMORY_H
#define SHAREDMEMORY_H

#include <Windows.h>

class sharedMemory
{
public:
	sharedMemory(void) {};
	~sharedMemory(void) {};

	bool CreateSharedMemory( int bufferSize, LPCWSTR name );

	template<typename T>
	void putInSharedMemory( T item )
	{
		CopyMemory((PVOID)pBuf, item, sizeof(T));
		UnmapViewOfFile(pBuf);
		CloseHandle(hMapFile);
	}

private:
	HANDLE hMapFile;
	LPCTSTR pBuf;

};

#endif //SHAREDMEMORY_H

#include "sharedMemory.h"
#include "utilities.h"

bool sharedMemory::CreateSharedMemory( int bufferSize, LPCWSTR name )
{
	hMapFile = CreateFileMapping(
		INVALID_HANDLE_VALUE,    // use paging file
		NULL,                    // default security 
		PAGE_READWRITE,          // read/write access
		0,                       // maximum object size (high-order DWORD) 
		bufferSize,              // maximum object size (low-order DWORD)  
		name);					 // name of mapping object

	if (hMapFile == NULL) 
	{ 
		utils::display( "Create File Mapping Failed!\n");
		return 1;
	}

	pBuf = (LPTSTR) MapViewOfFile(	hMapFile,   // handle to map object
									FILE_MAP_ALL_ACCESS, // read/write permission
									0,                   
									0,                   
									bufferSize);           

	if (pBuf == NULL) 
	{ 
		utils::display( "Create File Mapping Failed!\n");
		CloseHandle(hMapFile);
		return 1;
	}
	return 0;
}

	memStore.putInSharedMemory(&mWidth);
	memStore.putInSharedMemory(&mHeight);
	memStore.putInSharedMemory(&mDepth);

	for( int y=0; y<mHeight; y++){
		for( int x=0; x<mWidth; x++){
			for( int k=0; k<3; k++){
				memStore.putInSharedMemory(&mHeightMap[offset(x,y)]);
			}
			memStore.putInSharedMemory(&mAlpha);
		}			
	}

	bank = find free bank()
	memblock = find free memblock()
	image = find free image()
	
	map shared mem to bank "Shared_Memory", bank, 0
	make memblock from bank memblock, bank
	make image from memblock image, memblock
	for k = 0 to qtyMethods -1
		setpanelimage heightMapPanel(tab), 10000
	next k

#pragma once
#ifndef SHAREDMEMORY_H
#define SHAREDMEMORY_H

#include <Windows.h>

class sharedMemory
{
public:
	sharedMemory(void) {};
	~sharedMemory(void) { UnmapViewOfFile(pBuf); };

	bool CreateSharedMemory( int bufferSize, LPCWSTR name );
	bool closeFile();

	template<typename T>
	void putInSharedMemory( T item )
	{
		CopyMemory((PVOID)pBuf, item, sizeof(int));
	}

private:
	HANDLE hMapFile;
	LPCTSTR pBuf;

};

#endif SHAREDMEMORY_H

#include "sharedMemory.h"
#include "utilities.h"

bool sharedMemory::CreateSharedMemory( int bufferSize, LPCWSTR name )
{
	hMapFile = CreateFileMapping(
		INVALID_HANDLE_VALUE,    // use paging file
		NULL,                    // default security 
		PAGE_READWRITE,          // read/write access
		0,                       // maximum object size (high-order DWORD) 
		bufferSize,              // maximum object size (low-order DWORD)  
		name);					 // name of mapping object

	if (hMapFile == NULL) 
	{ 
		utils::display( "Create File Mapping Failed!\n");
		return 1;
	}

	pBuf = (LPTSTR) MapViewOfFile(	hMapFile,   // handle to map object
									FILE_MAP_ALL_ACCESS, // read/write permission
									0,                   
									0,                   
									bufferSize);           

	if (pBuf == NULL) 
	{ 
		utils::display( "Create File Mapping Failed!\n");
		CloseHandle(hMapFile);
		return 1;
	}

	utils::display( "Shared Memory allocated successfully!\n");

	return 0;
}


bool sharedMemory::closeFile()
{
	if( !UnmapViewOfFile(pBuf) ){
		utils::display( "File Failed to unmap!\n");
		return 1;
	}

	if( !CloseHandle(hMapFile) ){
		utils::display( "File Failed to close!\n");
		return 1;
	}

	return 0;
}

for( int it=1; it<mIterations; it++ ){
	progressMemStore.putInSharedMemory( &it );

.
.
.
}

bank = find free bank()
completeMarker = 3200
map shared mem to bank "Progress_Shared_Memory", bank, 4

repeat 
	progress = bank integer( bank, 0 )
	print "Progress: " + str$(progress) + " of " + str$(completeMarker)
until progress = completeMarker

delete bank bank

void heightMapGenerator::passHeightMapToSharedMemory()
{	
	const unsigned char alpha = 255;
	int offset = 12;	
	
	progressMemStore.putValue( mWidth, 0 );
	progressMemStore.putValue( mHeight, 4 );
	progressMemStore.putValue( mDepth, 8 );

	for( uint k=0; k<mHeightMap.size(); k++ )
	{
		unsigned char col = (unsigned char)mHeightMap[k]*255;
		for( uint v=0; v<3; v++ )
		{	
			progressMemStore.putValue( col, offset++ );
		}
		progressMemStore.putValue( alpha, offset++ );
	}
}

img = find free image()
	mb = find free memblock()
	make memblock from bank mb, sharedMemoryBank
	make image from memblock img, mb
	delete memblock mb

// Source.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include "SharedMemory.h"
#include <stdio.h>
#include <iostream>
#include <vector>

// Generate a grey-scale image, black on left to white on right.
std::vector<float> BuildImage(int sx, int sy)
{
	std::vector<float> Data;

	for (int y = 0; y < sy; ++y)
	{
		for (int x = 0; x < sx; ++x)
		{
			Data.push_back( x / (float)sx );
		}
	}

	return Data;
}


// Helper class - deals with offsets for me.
class Pusher
{
public:
	Pusher(sharedMemory& shm_, int Offset_ = 0) : shm(shm_), InitialOffset(Offset_), Offset(Offset_) { }

	template<typename T>
	void putValue( T item )
	{
		shm.putData( (LPCSTR)&item, sizeof(T), Offset );
		Offset += sizeof(T);
	}

	int GetSize() const { return Offset-InitialOffset; }

private:
	sharedMemory & shm;
	int InitialOffset;
	int Offset;
};

int _tmain(int argc, _TCHAR* argv[])
{
	sharedMemory progressMemStore;
	progressMemStore.CreateSharedMemory( 10*1024*1024, _T("MyBank") );

	std::cout << "Loading data to shared memory\n";
	std::vector<float> Data = BuildImage(256, 256);

	{
		Pusher p( progressMemStore, 8 );

		p.putValue<DWORD>(256);
		p.putValue<DWORD>(256);
		p.putValue<DWORD>(32);

		for (size_t i = 0; i < Data.size(); ++i)
		{
			unsigned char B = (unsigned char) (Data[i] * 255.0);
			for (int j = 0; j < 3; ++j)
			{
				p.putValue<BYTE>(B);
			}
			p.putValue<BYTE>(255);
		}
		progressMemStore.putValue<DWORD>( p.GetSize(), 4 );
	}

	int Percent = 0;
	do
	{
		std::cout << "Enter percentage completion: ";
		std::cin >> Percent;
		progressMemStore.putValue(Percent, 0);
	} while (Percent != 100);

	progressMemStore.closeFile();
}

void heightMapGenerator::passHeightMapToSharedMemory()
{	
	int complete = -99999;

	{
		Pusher p( progressMemStore, 8 );

		p.putValue<DWORD>(mWidth);
		p.putValue<DWORD>(mHeight);
		p.putValue<DWORD>(mDepth);

		for (size_t i = 0; i < mHeightMap.size(); ++i)
		{
			unsigned char B = (unsigned char) (mHeightMap[i] * 255.0);
			for (int j = 0; j < 3; ++j)
			{
				p.putValue<BYTE>(B);
			}
			p.putValue<BYTE>(255);
		}
		progressMemStore.putValue<DWORD>( p.GetSize(), 4 );
	}
	progressMemStore.putValue<DWORD>( complete, 0 );

}