If the texture itself is seamless, it's not much of a problem and relatively easy to program.
A few weeks ago I wrote this piece of code:
function convertImage(mem, toImg, ang#)
s# = sin(ang#)
c# = cos(ang#)
rem Source Data
w1 = memblock dword(mem,0)
h1 = memblock dword(mem,4)
w12# = (w1+1)*0.5
h12# = (h1+1)*0.5
rem New Memblock
mem2 = 2
w = 256
h = 200
make memblock mem2, 12 + 4*w*h
write memblock dword mem2, 0, w
write memblock dword mem2, 4, h
write memblock dword mem2, 8, 32
rem Get Data
p = 12
w2# = w*0.5
h2# = h*0.5
fy# = 1.0/0.6
for y = 1 to h
rem Relative Y (to center) + scaled back
cy# = fy#*(y-h2#)
for x = 1 to w
rem Relative X
cx# = x-w2#
rem Rotate Back + Offset
nx# = w12# + c#*cx# - s#*cy#
ny# = h12# + s#*cx# + c#*cy#
rem Inside?
if nx# >= 1.0 and ny# >= 1.0 and nx# <= w1 and ny# <= h1
dec nx# : dec ny#
x1 = floor(nx#) : x2 = ceil(nx#)
y1 = floor(ny#) : y2 = ceil(ny#)
rx# = nx# - x1 : ry# = ny# - y1
pTL = 12 + 4*(x1 + w1*y1)
pTR = 12 + 4*(x2 + w1*y1)
pBL = 12 + 4*(x1 + w1*y2)
pBR = 12 + 4*(x2 + w1*y2)
cTL = memblock dword(mem,pTL) : cTR = memblock dword(mem,pTR) : cBL = memblock dword(mem,pBL) : cBR = memblock dword(mem,pBR)
c1 = blendColors(cTL,cTR,rx#) : c2 = blendColors(cBL,cBR,rx#) : color = blendColors(c1,c2,ry#)
write memblock dword mem2, p, color
else
write memblock dword mem2, p, 0x20606060
endif
rem next Pixel
inc p, 4
next
next
rem Apply
make image from memblock toImg, mem2
delete memblock mem2
endfunction
function blendColors(c1,c2,f#)
f1# = 1.0 - f#
r = f#*rgbr(c2) + f1#*rgbr(c1)
g = f#*rgbg(c2) + f1#*rgbg(c1)
b = f#*rgbb(c2) + f1#*rgbb(c1)
a = (c1 >> 24)
c = (a << 24) || (r << 16) || (g << 8) || b
endfunction c
Which will turn your texture into isometric perspective - can't guarantee it will work (with any texture) though, but I uploaded the whole package including an example texture that should hopefully work on any PC; you can press right/leftkey to rotate the point of view.
Setting the angle parameter to 45° in the code will create the usual isometric perspective. If you use this, you might want to play around with the fy# value just before the for loops in the first function. It sort of defines from what height you view the texture. I guess a value of 2.0 (or 1.0/0.5) would be the usual "two pixels right one pixel up" kind of thing.
Well, in general there are two approaches to converting the image with code:
1. You start from your texture and project each individual pixel into "isometric space" (formula being something like (screen x, screen y) = (texture_x - texture_y, -0.5*(texture_x + texture_y)) I believe), or..
2. and that's what the above code does, start from the desired output image, project the pixels back from "isometric space" to your texture and read the pixel colors from there (ideally interpolated, which is why the code blends 4 colors into one, just basic linear interpolation).
Otherwise, there probably are programs that are able to do this. If not, I should be able to compile a simple program that does the job relatively quickly - or you do it yourself, given the above code makes any sense to you.
