Sorry your browser is not supported!

// Test function (I use IanM Matrix plugin to find free resources)
function mem_test()

	// Load the main image
	main_image = find free image()
	load image "test.png", main_image

	// Load image into memory	(IS THIS DONE CORRECTLY?)
	main_mb = find free memblock()
	make memblock from image main_mb, main_image

	// Now I wish to get a part of that image and create a new one.
	// Lets say I want to have a part of 10x10 px starting at X 30 and Y 20 from the main image
	` Need help with this one!
	
	// After new memblock is created, a new image will be created
	new_image = find free image()
	make image from memblock new_image, new_mb

	// Delete the memblocks
	delete memblock main_mb
	delete memblock new_mb

endfunction

dwWidth  = memblock dword(main_mb, 0) // Offset 0, first 4 bytes in memblock
dwHeight = memblock dword(main_mb, 4) // 4 bytes offset, thus the next 4 bytes (a dword is 4 bytes) of the memblock
dwDepth  = memblock dword(main_db, 8) // The depth of a memblock made from an image is (probably?) always 32 bits.

function SetColour(mem as dword, x as dword, y as dword, col as dword)
    dwWidth  = memblock dword(mem, 0)
    offset   = 12 + (((dwWidth * y) + x) * 4) // Each pixel is assumed to be represented by 4 bytes, as is the case most of the time (depth = 32)
    write memblock dword mem, offset, col
endfunction

function GetColour(mem as dword, x as dword, y as dword)
    dwWidth  = memblock dword(mem, 0)
    offset   = 12 + (((dwWidth * y) + x) * 4)
    colour   = memblock dword(mem, offset)
endfunction colour

// Test function (I use IanM Matrix plugin to find free resources)
function mem_test()

	// Load the main image
	main_image = find free image()
	load image "test.png", main_image

	// Load image into memory	(IS THIS DONE CORRECTLY?)
	main_mb = find free memblock()
	make memblock from image main_mb, main_image
	dwWidth  = memblock dword(main_mb, 0) // Offset 0, first 4 bytes in memblock
	dwHeight = memblock dword(main_mb, 4) // 4 bytes offset, thus the next 4 bytes (a dword is 4 bytes) of the memblock
	dwDepth  = memblock dword(main_mb, 8) // The depth of a memblock made from an image is (probably?) always 32 bits.

	// Now I wish to get a part of that image and create a new one.
	// Lets say I want to have a part of 10x10 px starting at X 30 and Y 20 from the main image
	` Need help with this one!

	// Make a new memblock
	new_mb = find free memblock()
	make memblock new_mb, (10*10) + 12	// New image  = 10 x 10 px
	write memblock dword new_mb,0,dwWidth
	write memblock dword new_mb,4,dwHeight
	write memblock dword new_mb,8,dwDepth

	// Initial positions
	posx# = 30 : posy# = 20

	// Get each pixel and write it to the new memblock
	for IDY = 1 to 10 	// Every line

		for IDX = 1 to 10 // every pixel on each line


				// How would I correctly extract the pixels from one memblock (main_mb) to the new one (new_mb)?


			posx# = posx# + 1

		next IDX

		posy# = posy# + 1
		posx# = 30

	next IDY

	// After new memblock is created, a new image will be created
	global new_image
	new_image = find free object()
	make image from memblock new_image, new_mb

	// Delete both the memblocks
	delete memblock main_mb
	delete memblock new_mb

endfunction

function SubImage(img as dword, x as dword, y as dword, width as dword, height as dword)
    rem Create a memblock from the input image
    memIn = find free memblock()
    make memblock from image memIn, img
    
    rem We need to know the width of the input image in order to address it's pixels by 2d coordinates (X & Y)
    baseWidth  = memblock dword(memIn, 0)
    baseHeight = memblock dword(memIn, 4)   rem Store the height too, so that we will not end up with out of bounds coordinates / invalid sampling if requested to get pixel (48, 10) from a 32x32 image

    rem Verify the size of the sub-image
    if x + width > baseWidth    then width  = baseWidth - x     rem The sub-image must be rescaled to fit within the main image
    if y + height > baseHeight  then height = baseHeight - y
    rem If the initial X or Y coordinates are beyond the size of the main image the whole operation is illegal
    if x >= baseWidth or y >= baseHeight then Fail("Sub-image bounds illegal in this context!")
    
    rem Create a memblock for writing the sub-image data to and write its header
    memOut = find free memblock()
    rem The output memblock must be large enough to hold the image data, that is 4 bytes per pixel + 12 bytes for the header.
    memSize = (width * height * 4) + 12
    make memblock memOut, memSize
    write memblock dword memOut, 0, width
    write memblock dword memOut, 4, height
    write memblock dword memOut, 8, 32          rem We're assuming that all images are 32-bit here as well
    
    rem Copy pixels from the input to the output memblock
    rem Pixel indices start at 0 and range to width/height - 1, since the 0 counts towards the total dimensions
    for py = 0 to height - 1
        for px = 0 to width - 1
            rem The (px, py) coordinates are the pixels of the output sub-image.
            rem To retrieve the corresponding source image pixel coordinates, we simply need to add the x and y offsets provided as arguments to this function.
            pixelOffset  = ((y + py) * baseWidth) + x + px          rem This is the pixel number in the source image, counted left to right, top to bottom
            rem To get the pixel's position in the memory block we multiply its number by 4 (since each pixel is assumed to be stored as a DWORD; 4 bytes) 
            rem and add the size of the header section (12 bytes) to it.
            sourceColour = memblock dword(memIn, 12 + (pixelOffset * 4))
            
            rem The process is the same for the destination image, only that we don't need to add the x and y offsets
            pixelOffset  = (py * width) + px
            write memblock dword memOut, 12 + (pixelOffset * 4), sourceColour
        next px
    next py
    
    rem When we get here, all pixels in the supplied range (cut-off if the dimensions of the sub-image would have it go beyond the dimensions of the source image) 
    rem have been copied to memOut.
    rem Convert that to an image, clean up the used memblocks and return the created image ID
    imgOut = find free image()
    make image from memblock imgOut, memOut
    
    delete memblock memIn
    delete memblock memOut
endfunction imgOut
    

rem This is obviously not a great error-handling function; replace with whatever you require
function Fail(msg as string)
    exit prompt msg, "Error"
    end
endfunction

remstart
   -------------------------------------------------------------------
   program name: Memblock Bitmap Functions
   -------------------------------------------------------------------
   written by: Oli Burt
   date: 6th April 2009 - 9th April 2009
   -------------------------------------------------------------------
   comments:
   -------------------------------------------------------------------
remend
set display mode 640,480,32
hide mouse
sync on

mbbmp_make(1,640,480,32)
mbbmp_clear(1,rgb(255,255,255))
mbbmp_box(1,200,100,300,250,rgb(255,0,0))
mbbmp_line(1,20,300,400,260,rgb(0,255,0))
for i = 0 to 200
   x=rnd(639) : y=rnd(479)
   mbbmp_dot(1,x,y,rgb(0,255,255))
next i

make bitmap from memblock 1,1
copy bitmap 1,0

sync
wait key


delete memblock 1
end

`--------------
` Functions
`--------------
Function mbbmp_box(memblock,ax,ay,bx,by,colour)
  `Read Header
  width= memblock dword(memblock,0)
  height= memblock dword(memblock,4)
  byte_depth= memblock dword(memblock,8)/8
  `Edit Memblock
  for y = ay to by
    for x = ax to bx
      write memblock dword memblock,12+(x+y*width)*byte_depth, colour
    next x
  next x
Endfunction
`//

Function mbbmp_make(memblock,width,height,bit_depth)
  if memblock exist(memblock) = 0
    byte_depth= bit_depth/8
    make memblock memblock,12+width*height*byte_depth^2
    `Header (12 bytes)
    write memblock dword memblock,0,width
    write memblock dword memblock,4,height
    write memblock dword memblock,8,bit_depth
  endif
Endfunction
`//

Function mbbmp_dot(memblock,x,y,colour)
  `Read Header
  width= memblock dword(memblock,0)
  height= memblock dword(memblock,4)
  byte_depth= memblock dword(memblock,8)/8
  `Edit Memblock
  write memblock dword memblock,12+(x+y*width)*byte_depth, colour
Endfunction
`//

Function mbbmp_clear(memblock,colour)
  `Read Header
  width= memblock dword(memblock,0)
  height= memblock dword(memblock,4)
  byte_depth= memblock dword(memblock,8)/8
  `Edit Memblock
  for y = 0 to height-1
    for x = 0 to width-1
      write memblock dword memblock,12+(x+y*width)*byte_depth, colour
    next x
  next y
Endfunction
`//

Function mbbmp_line(memblock,ax,ay,bx,by,colour)
  `Read Header
  width= memblock dword(memblock,0)
  height= memblock dword(memblock,4)
  byte_depth= memblock dword(memblock,8)/8
  `Get Line Length (Hypotenuse of x/y triangle)
  xdif= ax-bx
  ydif= ay-by
  hyp= sqrt(xdif*xdif + ydif*ydif)
  `Edit Memblock
  for pass = 1 to hyp
    factor#= pass/(hyp*1.0)
    x= ax - int((ax-bx)*factor#+.5)
    y= ay - int((ay-by)*factor#+.5)
    write memblock dword memblock,12+(x+y*width)*byte_depth, colour
  next pass
Endfunction
`//

Function mbbmp_point(memblock,x,y)
  `Read Header
  width= memblock dword(memblock,0)
  height= memblock dword(memblock,4)
  byte_depth= memblock dword(memblock,8)/8
  `Read From Memblock
  colour = memblock dword(memblock,12+(x+y*width)*byte_depth)
Endfunction colour
`//

function GetColour(mem as dword, x as dword, y as dword)
    dwWidth  = memblock dword(mem, 0)
    offset   = 12 + (((dwWidth * y) + x) * 4)
    alpha    = memblock byte(mem, offset)
    red      = memblock byte(mem, offset + 1)
    green    = memblock byte(mem, offset + 2)
    blue     = memblock byte(mem, offset + 3)
    colour   = (alpha * (256 ^ 3)) + (red * (256 ^ 2)) + (green * 256) + blue ` This is the same dword as would be read directly with memblock dword(mem, offset)
endfunction colour