Rekenhulp gevraagd...

[Swets]

Ik riep het al vanaf het begin: zorg ervoor dat je STL modelletjes kunt importeren, dan kun je alle vormen gebruiken die je wil. Net zoals ik zei 'zorg ervoor dat je van elk objecttype N instanties kunt hebben, want die vraag komt vanzelf'

Aan het gebruik van driehoeken en arrays van driehoeken die een object vormen was je toen nog lange niet toe kwa 'mindset'. Nu wel misschien?

Kwa aantal vlakken rondom: de prestaties van de hele rendering-pipeline zijn je beperkende factor. Ik denk dat je dat beperkt moet houden tot 6 ofzo.

hoe zit stl in elkaar?
ff zoeken zo...

ik had weer een klein beetje de linken (links?) naar de plaatjes in orde gemaakt... en het hele verhaal weer eens gelezen...

en dan zie ik toch weer dingen..... dit bijvoorbeeld:

Naar schermcoordinaten is dan simpelweg:

FoezelfactorX = 100
FoezelfactorY = 100
Xscherm = (560/2) + FoezelfactorX * (CoordX/CoordZ);
Yscherm = (480/2) - FoezelFactorY * (CoordY/CoordZ);

Met die foezelfactoren kun je nog wat spelen; zie dat als de zoomknop op je camera. Objecten wat verder weg zetten in de Z-richting en een wat hogere 'zoom' geeft een minder dramatisch perspectief dan een object vlak voor de lens met 'groothoek-zoom'.

wat kan ik hier mee.... ik had nog iets gelezen... maar kan het niet meer zo snel terug vinden... over dat perspectief beeld ...
shit... moet ik weer alles gaan zitten lezen.. :-)

[Swets]

@ dabit:

ik heb gisteren het hele verhaal nog eens zitten lezen... (en heb ook de plaatjes die ik terug kon vinden er weer bij gezet...)

maar ik heb toch nog een vraag, want ik geloof dat ik dat met die matrixen toch nog niet helemaal zo doet als jij het uitgelegd heb.... dit is een laat kwartje... dat nu begint te vallen geloof ik....


maar ik heb 3 funtie's ...

turnmatrix:

Code: Selecteer alles

// matrix invullen
//
//         0         1          2  3
//
//  0    [ cos(Rot), -sin(Rot), 0, 0]
//  1    [ sin(Rot), cos(Rot),  0, 0]
//  2    [ 0,        0,         1, 0]
//  3    [ 0,        0,         0, 1]

transmatrix:

Code: Selecteer alles

//matrix invullen
//
//          0   1   2  3
//
//  0    [  1,  0,  0, 0]
//  1    [  0,  1,  0, 0]
//  2    [  0,  0,  1, 0]
//  3    [ TX, TY, TZ, 1]

en een scalematrix:

Code: Selecteer alles

//matrix invullen
//
//          0   1   2  3
//
//  0    [ SX,  0,  0, 0]
//  1    [  0, SY,  0, 0]
//  2    [  0,  0, SZ, 0]
//  3    [  0,  0,  0, 1]

en die roep ik na elkaar aan
en dat werkt goed...

maar ik kan ook 1 keer het verhaal aanroepen, maar dan de matix als volgt vullen?:

Code: Selecteer alles

// matrix invullen
//
//         0         1          2  3
//
//  0    [ cos(Rot)* SX, -sin(Rot)      , 0    , 0]
//  1    [ sin(Rot)       , cos(Rot)*SY  , 0   , 0]
//  2    [ 0                 , 0                 ,1*SZ, 0]
//  3    [ TX               , TY               ,TZ    , 1]

en dan maar 1 keer rekenen...
heb ik dat goed begrepen?

[Swets]

hmmm dat gaat niet helemaal zo... :-)

ik heb draaien om x en y en z (daar had ik ook 3 aparte verhalen voor) samen gevoegd :

Code: Selecteer alles

lMatrix[0][0]:= cos(Yrotation) * cos(Zrotation) ; lMatrix[0][1]:= -(sin(Zrotation)) ; lMatrix[0][2]:= sin(Yrotation)                   ; lMatrix[0][3]:=0 ;
lMatrix[1][0]:= (sin(Zrotation))                ; lMatrix[1][1]:= cos(Xrotation)    ; lMatrix[1][2]:=-(sin(Xrotation)) * cos(Zrotation) ; lMatrix[1][3]:=0 ;
lMatrix[2][0]:= -(sin(Yrotation))               ; lMatrix[2][1]:= sin(Xrotation)    ; lMatrix[2][2]:= cos(Xrotation) * cos(Yrotation)   ; lMatrix[2][3]:=0 ;
lMatrix[3][0]:= 0                               ; lMatrix[3][1]:= 0                 ; lMatrix[3][2]:= 0                               ; lMatrix[3][3]:=1 ;

maar dat gaat niet goed......? dus iets doe ik niet goed...
ben nu regels van Simpson of formules van Mollweide aan het door lezen... maar veel snappen doe ik er nog niet van :-)

[DaBit]

Ja, dat kan, als je de matrixvermenigvuldiging helemaal uitschrijft (doe op papier hetzelfde als die 4x4 vermenigvuldigingsroutine).

Maar dat soort slimmigheidjes zijn hier een slecht idee:

- Voor de prestaties heb je het niet nodig; opbouwen transformatiematrix is maar relatief zelden nodig en een aanslag op je codegeheugen is het ook niet.
- Duidelijke, korte blokken code met een enkele en duidelijke functie zijn separaat te testen, debuggen, transplanteren naar een andere applicatie, en na 3 jaar is ook nog te snappen wat het doet. Tegen die tijd ben je slimmigheidjes allang weer vergeten.
- Datzelfde geld voor de samenstelling van de uiteindelijke transformatie. Als 1x vermenigvuldigen werkt dan werkt 3x vermenigvuldigen ook, en het is te volgen wat er gebeurt.
- Software is nooit af, dus die transformaties willen nog wel eens veranderen. Straks komt er iemand aan met een trackball-controller en die wil je dan met een quaternion doen ofzo. Met de gangbare rendering pipeline geen punt; extra functie die een 4x4 matrix produceert (en die functie kun je los testen), en op de gewenste plek in de pipeline ploppen. Maar als er overal 'slimme' shortcuts in zitten bijten ze je in de staart.


Als je een machine ontwerpt dan ga je schetsen en tekenen hoe het eruit moet zien, en je gaat op een gegeven moment de 83 verschillende boutjes vervangen door types met zoveel mogelijk dezelfde 5mm inbussleutel en zo min mogelijk verschillende, bijvoorbeeld. Dat je dan soms een gat dieper moet tappen of een beugeltje wat langer moet maken om dat boutje kwijt te kunnen hoort erbij, en iedereen vind het volkomen logisch en handig als je dat doet.

Ga je dan software kloppen, dan is het opeen normaal dat er voor elke plek een nieuw boutje met optimale diameter, lengte, spoed en kop verzonnen word...

Niet doen. Ook in software behoor je de boel te tekenen, uitvissen wat waar hoort, en het aantal speciaaltjes minimaliseren.

[Swets]

ik had nu dit:

Code: Selecteer alles

lMatrix[0][0]:= cos(Yrotation) * cos(Zrotation) ; lMatrix[0][1]:= -(sin(Zrotation))*cos(Xrotation) + cos(Zrotation)*sin(Yrotation)*sin(Xrotation) ; lMatrix[0][2]:=  sin(Zrotation) * sin(Xrotation) + Cos(Zrotation) * sin(Yrotation) * cos(Xrotation)  ; lMatrix[0][3]:=0 ;
lMatrix[1][0]:= (sin(Zrotation))*cos(Yrotation) ; lMatrix[1][1]:=   cos(Xrotation)* cos(Zrotation) + sin(Zrotation)*sin(Yrotation)*sin(Xrotation) ; lMatrix[1][2]:=-(Cos(Zrotation)) * Sin(Xrotation) + sin(Zrotation) * sin(Yrotation) * cos(Xrotation) ; lMatrix[1][3]:=0 ;
lMatrix[2][0]:= -(sin(Yrotation))               ; lMatrix[2][1]:=   sin(Xrotation) *cos(Yrotation)                                                ; lMatrix[2][2]:= cos(Xrotation) * cos(Yrotation)                                                      ; lMatrix[2][3]:=0 ;
lMatrix[3][0]:= 0                               ; lMatrix[3][1]:= 0                                                                               ; lMatrix[3][2]:= 0                                                                                    ; lMatrix[3][3]:=1 ;

[/size]
maar dat gaat ook nog niet helemaal goed....

maar jij zeg niet doen.... ik dacht misschien scheelt het een hoop in snelheid... ..

[DaBit]

Van zelf doen leer je het meeste, dus ik ga je een paar zweetdruppeltjes bezorgen..

Vermenigvuldiging van twee matrices is:


ma is matrix X, mb is matrix B, eerste getalletje is rij, tweede kolom.

Wat je nu moet doen is de matrices voor rotatie, translatie en schalen op een stuk papier pennen, en uitwerken d.m.v bovenstaand plaatje. Dan heb je de goede

Maar ook hier weer: je gaat er vanuit dat het er sneller van word, maar eigenlijk weet je het niet. Daarvoor moet je eerst weten hoeveel tijd het nu kost, en of er genoeg te winnen is om een sluipweg noodzakelijk te maken.
Dat zou mee moeten vallen.

[Swets]

nou , ik laat het maar ff zo... dit werkt goed... en makkelijk.... kan afzonderlijke draaien om alle assen... verschuiven verschalen...
allemaal aparte functies...

ik heb ook al diverse andere dingen gemaakt, en dit gebruikt...

ik kan alleen dat niet meer vinden over de die 2 verschillende camera achtige zicht dingen .... ehh tja... nou ja... ik nog maar een keer alles lezen... :-)

[Swets]

begint aardig te lukken

alles nog een beetje op poetsen....

[DaBit]

Ziet er leuk uit in ieder geval

[Swets]

Dit is nog steeds mijn meest geposte topic.. :-)

later ook nog dit gemaakt:

ik bedoel van af omgeveer 2 minuut 10 seconde.... realtime animatie van de assen.....
dat knipperen trouwens zag je niet op het echte scherm, alleen als je het scherm simuleerde op de computer.....

maar vroeg ik een 3d plaatje van de tekenkamer... daar maakte ik 2 plaatjes van... eentje als ondergrond.... en een 2de , waarvan ik 1 kleur doorzichtig maakte, die helemaal op de voorgrond lag....
waardoor de assen achter bepaalde dingen langs ging.....

en dat scherm met die sliders en getallen, was een hulpscherm... om de assen op de goede plek te verschalen/verschuiven/roteren...

ik gebruikte dit ook om het hele verhaal eerst te testen , voordat ik met de echte machine ging draaien.....

dat was wel fijn... toen ik DaBit zijn verhaaltje door had, ging het steeds lekkerder....
Ik heb hier net alles terug zitten lezen.... Pff wat een verhaal..... en wat een geduld heeft die DaBit.... :-)

[DaBit]

en wat een geduld heeft die DaBit.... :-)

Ach, soms duurt het wat langer, soms wat minder lang, maar ooit valt het emmertje wel