Calculator Community => TI Calculators => ASM => Topic started by: ACagliano on December 02, 2011, 03:15:47 pm
Title: Interaction with a 3D Space
Post by: ACagliano on December 02, 2011, 03:15:47 pm
I'm looking for someone with experience in programming interaction with a 3D space for my Star Trek game. At present, I only support 6 directions of movement: up, down, left, right, forward, and backwards. This is not truly 3D. I was thinking of using a pair of vectors...an x,y vector and a z vector, but I do not know how to code this. I will need someone to code this up for me.
In addition, if I go with the above, I will need to redo the routine in which we look to see if a ship is in your viewscreen. I'll need that coded, or at least assistance with that, as well.
Title: Re: Interaction with a 3D Space
Post by: Builderboy on December 02, 2011, 04:00:43 pm
Hmm could you explain how you are storing the coordinates of the ships right now? Do you also plan to take into account what direction the ships are facing? Do you want to include non-orthogonal angles?
Title: Re: Interaction with a 3D Space
Post by: ACagliano on December 02, 2011, 04:17:03 pm
Hmm could you explain how you are storing the coordinates of the ships right now? Do you also plan to take into account what direction the ships are facing? Do you want to include non-orthogonal angles?
Right now, the positions of a maximum of 30 ships are in the following format:
I doubt that would need to change. No, I only show one generic image if a ship is located in the viewscreen. What is a non-orthogonal angle?
Title: Re: Interaction with a 3D Space
Post by: Builderboy on December 02, 2011, 04:23:44 pm
What i mean by taking into account what direction ships are facing, how do you know if 1 ship is able to see another ship? And a non-orthogonal angle is an angle that is not a multiple of 90 degrees. Basically I am asking if the ships can rotate or look around, but looking at your data it doesn't seem to have any angle data at all?
Title: Re: Interaction with a 3D Space
Post by: ACagliano on December 02, 2011, 05:27:39 pm
I will be judging if a ship can see another as follows:
on the active axis (one that the ship is moving on), you can up to 100 units ahead of you and 50 units to the left and right, up and down. If a ship is behind you on the active axis, you don't see it. Similarly, if it is outside the 100 ahead x 100 up/down x 100 left/right, you cannot see it.
Thus, all I need in order to judge visibility is location. Angle data can be ship-specific. Now, I understand that this system may need to be adjusted, but it should work well without having each ship broadcast its angles as well.
Title: Re: Interaction with a 3D Space
Post by: Builderboy on December 02, 2011, 05:31:07 pm
Thus, all I need in order to judge visibility is location. Angle data can be ship-specific. Now, I understand that this system may need to be adjusted, but it should work well without having each ship broadcast its angles as well.
Wait so there is additional data for each ship than what you posted before?
Title: Re: Interaction with a 3D Space
Post by: ACagliano on December 02, 2011, 06:48:48 pm
Thus, all I need in order to judge visibility is location. Angle data can be ship-specific. Now, I understand that this system may need to be adjusted, but it should work well without having each ship broadcast its angles as well.
Wait so there is additional data for each ship than what you posted before?
There is alot of data that about ships that do not get broadcast. There is the offline/online status of your systems, health and max health of each system, shield health, weapons armed flag, shields raised flag, current traveling direction and speed of your ship, ect. However, all that gets broadcast to other calcs is your ID (so that a PTP can be sent), the username (so that you see a name, not 5 numbers), and the location (position and sector).
Title: Re: Interaction with a 3D Space
Post by: ben_g on December 03, 2011, 03:37:50 pm
Do you want to be able to rotate your ship, then fly in the direction it's facing instead of moving in only 6 directions? Or did i misunderstand your question? If you want this, you are going to need fixed point numbers or inflation by 256. Then you need a sine routine. When the ship is moving, you add sin(hdir + 90°) to the X coordinate, and sin(hdir) to thy Y coordinate, where hdir stands for the direction in the horizontal plane. If you then add movement along the Z axis, the controls remain simple and they might be good enough. If you however want to be able to fly in the 3 dimensions, then you need 2 direction variables. The math to calculate the coordinates will be slightly more complex too. Now you'll have to add sin(hdir + 90°) * sin(vdir + 90°) to your X coordinate, sin(hdir) * sin(vdir + 90°) to your Y coordinate, and sin(vdir) to your z coordinate. You should also keep in mind that if you want to be able to look in different directions, your 3D projection algorithm needs to support rotation of the camera, so a simple 1, 2 or 3 point perspective algorithm (like what you use when making 3D drawings) won't work anymore. You have to go with a perspective projection algorithm. If you don't already use one, you can find a good one on wikipedia, or I can pm you the code for mine, if you want.
Title: Re: Interaction with a 3D Space
Post by: ACagliano on December 03, 2011, 08:47:47 pm
You have it exactly right. I want to be able to rotate the ship and fly in the direction it's facing. I have three axises, x,y,and z. I have no idea how to do this in z80 :(
As for the looking in different directions, you are referring to the "view-screen" correct? If so, then yes. I can use a pretty standard space image when there are no ships in front of you...but the issue is looking ahead of you for a ship, then rendering it. Perhaps a perspective projection algorithm is what I need. But, since I have never done this before, i would have no idea how to mold it for my purposes.
Title: Re: Interaction with a 3D Space
Post by: ACagliano on December 05, 2011, 03:42:45 pm
Bump^^
I plan on remolding the menu GUI's a bit, just for the record.
Title: Re: Interaction with a 3D Space
Post by: ben_g on December 05, 2011, 04:28:55 pm
here is some code:
Spoiler For code:
Quote from: Z80 Assembly
;variables used for saving the location. replace locvars with the memory location they should be x .equ locVars y .equ x+2 z .equ y+2 hdir .equ z+2 vdir .equ hdir+1
;Variables used by the 3D engine. replace EngineVars with the memory location they should be. temp .equ EngineVars temp2 .equ temp+2 temp3 .equ temp2+2
;call this routine before rendering each screen Init3D: ldhl, (x) ld (xfrom), hl pushhl lda, (hdir) adda, 64 call SinA pushhl lda, (vdir) adda, 64 call SinA exde, hl popbc call MulFP popde addhl, de ld (xto), hl ldhl, (y) ld (yfrom), hl pushhl lda, (hdir) call SinA pushhl lda, (vdir) adda, 64 call SinA exde, hl popbc call MulFP popde addhl, de ld (yto), hl ldhl, (z) ld (zfrom), hl pushhl lda, (vdir) call SinA popde addhl, de ld (zto), hl ldhl, 0 ld (xup), hl ld (yup), hl ldhl, $0100 ld (zup), hl call InitView ret
;call this routine to move: Move: ldhl, (x) pushhl lda, (hdir) adda, 64 call SinA pushhl lda, (vdir) adda, 64 call SinA exde, hl popbc call MulFP exde, hl ldbc, speed call MulFP popde addhl, de ld (x), hl ldhl, (y) pushhl lda, (hdir) call SinA pushhl lda, (vdir) adda, 64 call SinA exde, hl popbc call MulFP exde, hl ldbc, speed call MulFP popde addhl, de ld (y), hl ldhl, (z) pushhl lda, (vdir) call SinA exde, hl ldbc, speed call MulFP popde addhl, de ld (z), hl ret
;the routines of the 3D engine.
InitView: ;call once every frame, before C3DTo2D ;IN: The engine's vars ;OUT: vars are initialised ;DESTROYS: all registers and the engine's variables ldhl, (xto) ldde, (xfrom) SubFP ld (xto), hl ldhl, (yto) ldde, (yfrom) SubFP ld (yto), hl ldhl, (zto) ldde, (zfrom) SubFP ld (zto), hl ldde, (xto) ldb, d \ ld c, e call MulFP ld (temp), hl ldde, (yto) ldb, d \ ld c, e call MulFP ldde, (temp) addhl, de ld (temp), hl ldde, (zto) ldb, d \ ld c, e call MulFP ldde, (temp) addhl, de call SqrtFP ld (temp), hl ldhl, (xto) ldde, (temp) call DivFP ld (xto), hl ldhl, (yto) ldde, (temp) call DivFP ld (yto), hl ldhl, (zto) ldde, (temp) call DivFP ld (zto), hl ldde, (xup) ldbc, (xto) call MulFP ld (temp), hl ldde, (yup) ldbc, (yto) call MulFP ldde, (temp) addhl, de ld (temp), hl ldde, (zup) ldbc, (zto) call MulFP ldde, (temp) addhl, de ld (temp), hl ldde, (temp) ldbc, (xto) call MulFP ldd, h \ ld e, l ldhl, (xup) SubFP ld (xup), hl ldde, (temp) ldbc, (yto) call MulFP ldd, h \ ld e, l ldhl, (yup) SubFP ld (yup), hl ldde, (temp) ldbc, (zto) call MulFP ldd, h \ ld e, l ldhl, (zup) SubFP ld (zup), hl ldde, (xup) ldb, d \ ld c, e call MulFP ld (temp), hl ldde, (yup) ldb, d \ ld c, e call MulFP ldde, (temp) addhl, de ld (temp), hl ldde, (zup) ldb, d \ ld c, e call MulFP ldde, (temp) addhl, de call sqrtFP ld (temp), hl ;Multiply (temp) with the tangent of (angle)/2, which is, in this test program, equal to 1, so we don't need to multiply ldhl, (xup) ldde, (temp) call DivFP ld (xup), hl ldhl, (yup) ldde, (temp) call DivFP ld (yup), hl ldhl, (zup) ldde, (temp) call DivFP ld (zup), hl ldde, (yup) ldbc, (zto) call MulFP ld (temp), hl ldde, (zup) ldbc, (yto) call MulFP ldd, h \ ld e, l ldhl, (temp) SubFP ld (xcross), hl ldde, (zup) ldbc, (xto) call MulFP ld (temp), hl ldde, (xup) ldbc, (zto) call MulFP ldd, h \ ld e, l ldhl, (temp) SubFP ld (ycross), hl ldde, (xup) ldbc, (yto) call MulFP ld (temp), hl ldde, (yup) ldbc, (xto) call MulFP ldd, h \ ld e, l ldhl, (temp) SubFP ld (zcross), hl ret
C3DTo2D: ;IN: xpoint, ypoint and zpoint vars ;OUT: screenx and screeny are set to the onscreen coordinates for the point ;Will not work if InitView wasn't called before this routine ;destroys all registers and xpoint, ypoint and zpoint ldhl, (xpoint) ldde, (xfrom) SubFP ld (xpoint), hl ldhl, (ypoint) ldde, (yfrom) SubFP ld (ypoint), hl ldhl, (zpoint) ldde, (zfrom) SubFP ld (zpoint), hl ldde, (xpoint) ldbc, (xto) call MulFP ld (temp), hl ldde, (ypoint) ldbc, (yto) call MulFP ldde, (temp) addhl, de ld (temp), hl ldde, (zpoint) ldbc, (zto) call MulFP ldde, (temp) addhl, de ld (temp), hl ld (screenz), hl ;kijk hier of het punt zichtbaar is bit 7, h jp nz, InValid ldde, (xpoint) ldbc, (xcross) call MulFP ld (temp2), hl ldde, (ypoint) ldbc, (ycross) call MulFP ldde, (temp2) addhl, de ld (temp2), hl ldde, (zpoint) ldbc, (zcross) call MulFP ;ld de, (temp2) ;ld bc, (zup) ;call MulFP ldde, (temp2) addhl, de ldde, (temp) call DivFP ld (screenx), hl ldde, (xpoint) ldbc, (xup) call MulFP ld (temp2), hl ldde, (ypoint) ldbc, (yup) call MulFP ldde, (temp2) addhl, de ld (temp2), hl ldde, (zpoint) ldbc, (zup) call MulFP ldde, (temp2) addhl, de ldde, (temp) call DivFP ld (screeny), hl ldhl, $0100 ldde, (screenx) SubFP ldb, h \ ld c, l ldde, 48 call MulFP ld (screenx), hl ldde, (screeny) ldhl, $0100 SubFP ldb, h \ ld c, l ldde, 32 call MulFP ld (screeny), hl lda, 1 ret InValid: lda, 0 ret
;These routines are for the math in the 3D engine.
;;;;;;;;;;;;;;;;;;;;;;;;;; MATH ROUTINES ;;;;;;;;;;;;;;;;;;;;;;;;;;;
SqrtA: LD (Asqr),A SRLA JR DataOver DataOver: LD (Bsqr),A LDB,A LD (Csqr),A iterate: LDA,(Bsqr) ldb, a LDa,(Asqr) LDD,A LDE,B dividedbyEreturnA: RLD RLA SUBE JR nc,$+3 ADDA,E LDE,A LDA,D CPL pushaf;1 LDa,(Bsqr) ldb, a popaf;0 ADDA,B SRLA LD (Bsqr),A LDa,(Bsqr) ldb, a LDA,(Csqr) DECA CPB JR z,done pushaf;1 LD (Csqr),a ldb, a popaf;0 JR iterate done: LDA,(Bsqr) RET
;SubFP: ; ;substracts 2 16-bit fixed-point numbers ; ;IN: hl, de ; ;OUT: hl - de in hl ; ;DESTROYS: a, hl ; or a ;clear carry flag ; sbc hl, de ; ret
Div16By8: ;divides a 16-bit number by an 8-bit number ;IN: hl and d ;OUT: hl = hl/d, remainder = a ;DESTROYS: a, b, c, d, hl xora ldb, 16 _D16b8Loop: addhl, hl rla jrc, _D16b8Overflow cpd jrc, _D16b8Skip _D16b8Overflow: subb incl _D16b8Skip: djnz _D16b8Loop ret
MulFP: ;Multiplies 2 16bit fixed-point numbers ;IN: de, bc ;OUT: de * bc in hl ;DESTROYS: af, bc, de, hl bit 7, d jr nz, _MulFP_FirstNeg bit 7, b jr nz, _MulFP_AnsNeg jr z, _MulFP_AnsPos _MulFP_FirstNeg: bit 7, b jr nz, _MulFP_AnsPos _MulFP_AnsNeg: lda, 1 pushaf;1 jr _MulFP_Cont _MulFP_AnsPos: lda, 0 pushaf;1 _MulFP_Cont: bit 7, b jr z, _MulFP_BCPos call NegBC _MulFP_BCPos: bit 7, d jr z, _MulFP_DEPos call NegDE _MulFP_DEPos: ldhl,0 lda,16 Mul16Loop: addhl,hl rle rld jp nc,NoMul16 addhl,bc jp nc,NoMul16 incde NoMul16: deca jp nz,Mul16Loop ldl, h ldh, e popaf;0 cp 1 call z, NegHL ret
;adding fixed-point numbers: ;load one of the numbers in hl, and the other in an other 16-bit register. ;then, do: add hl, <register>
DivFP: ;IN: hl, de ;OUT: hl = hl / de ;DESTROYS: af, hl, bc, d bit 7, d jr nz, _DivFP_FirstNeg bit 7, h jr nz, _DivFP_AnsNeg jr z, _DivFP_AnsPos _DivFP_FirstNeg: bit 7, h jr nz, _DivFP_AnsPos _DivFP_AnsNeg: lda, 1 pushaf jr _DivFP_Cont _DivFP_AnsPos: lda, 0 pushaf _DivFP_Cont: bit 7, h jr z, _DivFP_HLPos call NegHL _DivFP_HLPos: bit 7, d jr z, _DivFP_DEPos call NegDE _DivFP_DEPos lda, h ldh, l ldl, 0 pushhl;INPUTS: ahl = dividend de = divisor ;1 popix;OUTPUTS: ahl = quotient de = divisor ;0 ldhl,0 ldb,24 _Div24by16loop: addix,ix rla adchl,hl jrc,_Div24by16setbit ora sbchl,de addhl,de jrc,_Div24by16skip _Div24by16setbit: ora sbchl,de incix _Div24by16skip: djnz _Div24by16loop pushix;1 pophl;0 popaf cp 1 call z, NegHL ret
SqrtFP: ;##################################################### ;square root of fixed point hl ;input: hl ;output: hl=sqrt(hl)
sqrt_hl: lda, l ldl, h ldde, 0040h ; 40h appends "01" to D ldh, d ldb, 7
; need to clear the carry beforehand ora
_loopz: sbchl, de jr nc, $+3 addhl, de ccf rld rla adchl, hl rla adchl, hl djnz _loopz sbchl, de; optimised last iteration ccf rld ldh, d xora ldb, 4 shiftLoopz: srlh rra djnz shiftLoopz ldl, a ret
NegHL: xora subl ldl,a sbca,a subh ldh,a ret
NegBC: xora subc ldc,a sbca,a subb ldb,a ret
NegDE: xora sube lde,a sbca,a subd ldd,a ret
Generated by the BBify'r (http://clrhome.org/resources/bbify/ (http://clrhome.org/resources/bbify/))
Use it like the comments tell you. To render, AFTER calling Init3D, load the x, y and z coordinates in the xpoint, ypoint and zpoint variables (in signed 8.8 fixed-point format). Then call C3D to2D. If the point was behind the camera, a will be set to 0. If the point is in front of the camera, a will be 1. The screen coordinates will be stored in screenx and screeny, and the distance to the point will be stored in screenz.
For inputting those fixed-point numbers, I created a tool in java. If you want to use it, you can download it here: http://dl.dropbox.com/u/11215358/base%20converter.jar To use it to convert a decimal value into hexadecimal, fill in decimal and hexadecimal in the top field, type in the number , make sure the option 'Signed' is enabled and select '8.8 fixed-point' as format. Then click 'convert'. It will then generate the Hexadecimal code in the field at the bottom. Then just take the last 4 characters or add zeros to the front and you've got your hexadecimal number. For debugging, you can switch decimal and hexadecimal and type in a hex number.
Title: Re: Interaction with a 3D Space
Post by: ACagliano on December 05, 2011, 05:17:41 pm
Ok, question. The format I use has x, y,and z sector (1-byte for each) and an x, y, and z position within that sector (2-bytes each). Can these routines handle two-byte locations?
The two byte locations are they for 8.8, or for a full 2-byte position? Because I intended to have a full 0-65536 position range. Is it possible to do 16.16 or 16.8? lol
For ease of use, should I have the x, y, and z coordinates as 8.8 fixed point already?
As for speed...Well, I have a speed variable. (Speed). 0 = stopped, 1 = 1/4 impulse, 2 = 1/2 impulse, 3 = 3/4 imulse, 4 = full impulse, 5 = warp speed (100 x full impulse)
I also have variables preassigned. (PositionX), (PositionY), (PositionZ). Will simply replacing your (x), (y), and (z) with those break anything?
Can the memory areas from (temp) down be overwritten? Or should I use a memory area that I don't use?
Title: Re: Interaction with a 3D Space
Post by: ACagliano on December 06, 2011, 12:42:56 pm
Oh, question....In the code above, when you say "SubFP", do you mean "call SubFP"
Title: Re: Interaction with a 3D Space
Post by: ben_g on December 06, 2011, 01:55:55 pm
Sorry, I forgot to include it. Add this to your code:
#define SubFP xor a \ sbc hl, deAnd all numbers handled by the 3D engine are signed 8.8fixed-points (eccept for the angles). Speed stands for the number of units per secound. You can't use 16.8 for the position, but you can easily just send everything within 128 units to the 3D engine, in relative coordinates. Everything further than that will probably be to far to see anyway.
Title: Re: Interaction with a 3D Space
Post by: ACagliano on December 06, 2011, 02:05:32 pm
Shit, that was way over my head. Let me break this down to see if I understand.
1. The 3D engine uses 8.8 fixed point numbers. What impact does that have on my two-byte position variables?
2. I understand about speed. How do I make Speed variable?
3. Do I need to look for a ship, then call the 3D engine each time I find one? Or does one of those routines handle that?
After I get a handle on those concepts, I think I should be good.
Title: Re: Interaction with a 3D Space
Post by: ben_g on December 06, 2011, 03:34:55 pm
1. The 3D engine uses 8.8 fixed point numbers. What impact does that have on my two-byte position variables?
It's best that you keep using those variables, and to use it with the 3D engine, check the distance between the position of a chip (this doesn't need to be accurate), and if it's below the maximum viewing distance (for example: 100), then substract the player's coordinates from the coordinates of the ship and store in signed 8-bit variables. Then you use that as the integer part of the xpoint, ypoint and zpoint variables. Then set the from coordinates to 0 (or edit the 3D engine so they will always be treated as 0 (faster)). Then you just call C3Dto2D, and use the onscreen x and y coordinates as the location for drawing a scaled sprite, of which you calculate the size by the 'depth' (z-coordinate) of the point. Don't forget to check if the point is valid (a=1 after calling C3Dto2D), or the camera will look forward and backward.
2. I understand about speed. How do I make Speed variable?
The move routine I gave you is the only routine that uses the speed constant, so just replace the constant with the variable. Based on how your game works, It's best to set the x, y and z used in the routine to 0, then call it and add the integer parts of the outputs to your position. Then save the decimal parts and use them again for the next time you call the move routine. Also don't forget that these numbers are signed when handling them.
3. Do I need to look for a ship, then call the 3D engine each time I find one? Or does one of those routines handle that?
you need to handle that yourself. The 3D engine is still in an early stage so it can only convert individual points.
BTW: I forgot to answer this in my previous post, but yes, the temp variables can be overwritten, but only between the routines, so make sure the interrupt routine doesn't use them.
Title: Re: Interaction with a 3D Space
Post by: ACagliano on December 06, 2011, 05:09:50 pm
Ok. You should know, that the whole screen will not have a viewscreen. It will only be about 2/3 the height of the screen and 2/3 of the length of the screen. How does that affect the routine?
Oh, and how do I handle calculating distance between you and ships, taking into account sectors as well?
Title: Re: Interaction with a 3D Space
Post by: ben_g on December 07, 2011, 02:36:39 pm
The eastest way for the viewscreen is just render as fullscreen, then overlay with the HUD. It's not the most efficient way to do it, but for only a few ships, it should work.
For the distance, you can use the Pythagorean theorem. Use the sector as the upper byte and the coordinates as the lower bytes, then do this in 24-bit math: √((X2-X1)²+(Y2-Y1)²+(Z2-Z1)²).
Title: Re: Interaction with a 3D Space
Post by: ACagliano on December 07, 2011, 07:17:37 pm
The eastest way for the viewscreen is just render as fullscreen, then overlay with the HUD. It's not the most efficient way to do it, but for only a few ships, it should work.
For the distance, you can use the Pythagorean theorem. Use the sector as the upper byte and the coordinates as the lower bytes, then do this in 24-bit math: √((X2-X1)²+(Y2-Y1)²+(Z2-Z1)²).