fir <f...@W...gazeta.pl> napisał(a):

> przegladam np asma generowanego przez borlanda i mam tam cos takiego
>
> ; intersectionPoint = add(ray0, scalarMul(distPlane, rayV));
> ;
> mov ecx,dword ptr [esp+296]
> mov dword ptr [esp+488],ecx
> mov ecx,dword ptr [esp+300]
> mov dword ptr [esp+492],ecx
> mov ecx,dword ptr [esp+304]
> mov dword ptr [esp+496],ecx
> mov eax,dword ptr [esp+88]
> mov dword ptr [esp+112],eax
> fld dword ptr [esp+488]
> fmul dword ptr [esp+112]
> fstp dword ptr [esp+500]
> fld dword ptr [esp+492]
> fmul dword ptr [esp+112]
> fstp dword ptr [esp+504]
> fld dword ptr [esp+496]
> fmul dword ptr [esp+112]
> fstp dword ptr [esp+508]
> mov edx,dword ptr [esp+500]
> mov dword ptr [esp+512],edx
> mov edx,dword ptr [esp+504]
> mov dword ptr [esp+516],edx
> mov edx,dword ptr [esp+508]
> mov dword ptr [esp+520],edx
> mov ecx,dword ptr [esp+284]
> mov dword ptr [esp+524],ecx
> mov ecx,dword ptr [esp+288]
> mov dword ptr [esp+528],ecx
> mov ecx,dword ptr [esp+292]
> mov dword ptr [esp+532],ecx
> fld dword ptr [esp+524]
> fadd dword ptr [esp+512]
> fstp dword ptr [esp+536]
> fld dword ptr [esp+528]
> fadd dword ptr [esp+516]
> fstp dword ptr [esp+540]
> fld dword ptr [esp+532]
> fadd dword ptr [esp+520]
> fstp dword ptr [esp+544]
> mov eax,dword ptr [esp+536]
> mov dword ptr [esp+428],eax
> mov eax,dword ptr [esp+540]
> mov dword ptr [esp+432],eax
> mov eax,dword ptr [esp+544]
> mov dword ptr [esp+436],eax
>
> nie rozumiem blokow tych movow - skad to sie wzielo i co to jest, ?
> normalnie to wydawaloby sie ze wystarczylo by chyba cos takiego
>
> fld dword ptr [rayV.x]
> fmul dword ptr [dist]
> fstp dword ptr [m.x]
> fld dword ptr [rayV.y]
> fmul dword ptr [dist]
> fstp dword ptr [m.y]
> fld dword ptr [rayV.z]
> fmul dword ptr [dist]
> fstp dword ptr [m.z]
>
> fld dword ptr [m.x]
> fadd dword ptr [ray0.x]
> fstp dword ptr [out.x]
> fld dword ptr [m.y]
> fadd dword ptr [ray0.y]
> fstp dword ptr [out.y]
> fld dword ptr [m.z]
> fadd dword ptr [ray0.z]
> fstp dword ptr [out.z]
>
> albo jeszcze mniej :O jek wytlumaczyc te masywne bloki mov'ow ?
>
>
to chyba dlatego, ze genrator faktycznie rozwija funkcje inline ale
nie klopocze sie by scalic output jednej do inputu drugiej tylko
robi na odzielnych i w srodku kopiuje ;-)

ale pozatym generuje w miare poprawny chyba kod np dla

inline float intersectRaySphere(float3* rO, float3* rV, float3* sO, float sR)
{
static float3 Q;

Q = sub(sO,rO);
float c = length(&Q);
float v = dot(&Q,rV);
float d = sR*sR - (c*c - v*v);

// If there was no intersection, return -1
if (d < 0.0) return (-1.0f);

// Return the distance to the [first] intersecting point
return (v - sqrt(d));
}


_TEXT segment dword public use32 'CODE'
@intersectRaySphere$qp6float3t1t1f segment virtual
align 2
@@intersectRaySphere$qp6float3t1t1f proc near
?live16492@0:
@1533:
push ebp
mov ebp,esp
add esp,-24
push ebx
push esi
push edi
?live16492@16: ; EDI = rV
add esp,-8
mov esi,dword ptr [ebp+16]
mov ebx,dword ptr [ebp+8]
?live16492@48: ;
mov edi,dword ptr [ebp+12]
?live16492@64: ; EDI = rV
fld dword ptr [esi]
fsub dword ptr [ebx]
fstp dword ptr [ebp-24]
fld dword ptr [esi+4]
fsub dword ptr [ebx+4]
fstp dword ptr [ebp-20]
fld dword ptr [esi+8]
fsub dword ptr [ebx+8]
fstp dword ptr [ebp-16]
mov eax,dword ptr [ebp-24]
mov dword ptr [$afdngfia],eax
mov eax,dword ptr [ebp-20]
mov dword ptr [$afdngfia+4],eax
mov eax,dword ptr [ebp-16]
mov dword ptr [$afdngfia+8],eax
fld dword ptr [$afdngfia]
fmul dword ptr [$afdngfia]
fld dword ptr [$afdngfia+4]
fmul dword ptr [$afdngfia+4]
faddp st(1),st
fld dword ptr [$afdngfia+8]
fmul dword ptr [$afdngfia+8]
faddp st(1),st
fstp qword ptr [esp]
call @_sqrt
fstp dword ptr [ebp-4]
fld dword ptr [$afdngfia]
fmul dword ptr [edi]
add esp,8
fld dword ptr [$afdngfia+4]
fmul dword ptr [edi+4]
faddp st(1),st
fld dword ptr [$afdngfia+8]
fmul dword ptr [edi+8]
faddp st(1),st
fstp dword ptr [ebp-8]
?live16492@144: ;
fld dword ptr [ebp-4]
fmul dword ptr [ebp-4]
fld dword ptr [ebp-8]
fmul dword ptr [ebp-8]
fsubp st(1),st
fld dword ptr [ebp+20]
fmul dword ptr [ebp+20]
fsubrp st(1),st
fstp dword ptr [ebp-12]
fld dword ptr [ebp-12]
fcomp dword ptr [@1535]
fnstsw ax
sahf
jae short @1534
fld dword ptr [@1535+4]
jmp short @1536
@1534:
add esp,-8
fld dword ptr [ebp-12]
fstp qword ptr [esp]
call @_sqrt
fsubr dword ptr [ebp-8]
add esp,8
@1537:
@1536:
pop edi
pop esi
pop ebx
mov esp,ebp
pop ebp
ret
align 4
@1535:
db 0,0,0,0,0,0,128,191
@@intersectRaySphere$qp6float3t1t1f endp
@intersectRaySphere$qp6float3t1t1f ends


chyba nawet troche przyoptymalizowal uzywajac ebx esi i edi
zamiast odwolan do ramu,

z reki pewnie moglbym sie starac wlasnie powywalac ile sie da
odwolan do ramu na rzecz rejestrow i stacka fpu - ale musialbym
troche teraz doczytac o pisaniu asma na fpu, bo pozapominalem, nie
kojarze np jakich rejestrow mozna uzyc zamiast odwolan do ramu -







--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/