├── .gitignore ├── docs ├── algos.md ├── hyperfastproject.md ├── imgs │ ├── BiplanarApprox.png │ ├── ColorDemo.gif │ ├── ExampleHires.JPG │ ├── ExampleText.JPG │ ├── FirstOrderNormError.JPG │ ├── GlobalPerfectNorm.png │ ├── HiresModeDemo.gif │ ├── LocalPerfectNorm.JPG │ ├── LoresModeDemo.gif │ ├── NormFinalError.png │ ├── PlanApproxNorm.JPG │ ├── RasterizingWithFiller.JPG │ ├── TextModeDemo.gif │ └── TwoPlanNormApproxError.png ├── introduction.md └── norm.md ├── osdk_build.bat ├── osdk_config.bat ├── osdk_execute.bat ├── osdk_showmap.bat ├── readme.md ├── release ├── glOric.h ├── glOric.s ├── v11 │ ├── glOric_v11.h │ └── glOric_v11.s ├── v12 │ ├── glOric_v12.h │ └── glOric_v12.s └── v13 │ ├── glOric.h │ └── glOric.s ├── src ├── addGeom.c ├── agent.c ├── angle2screen.c ├── bresfill.c ├── buffer2screen.c ├── caBuild.bat ├── camera.s ├── changeChar.c ├── colorDemo.c ├── colors.c ├── colors_c.c ├── config.h ├── config.inc ├── data │ ├── alphabet.h │ ├── geom.h │ └── traj.h ├── demo.c ├── externs.c ├── fill16.c ├── fill8.c ├── fill8_bis.c ├── fill8_bresrun.c ├── fill8_c.c ├── fillFace.c ├── geom.c ├── geomCube.c ├── geomHouse.c ├── geomPine.c ├── geomTower.c ├── glDrawFaces.c ├── glDrawParticles.c ├── glDrawParticles.s ├── glDrawSegments.c ├── glDrawSegments.s ├── glInitScreenBuffers.c ├── glOric.h ├── glOric.s ├── glOric_c.c ├── glOric_h.h ├── glOric_s.s ├── glProject.c ├── glProject8.s ├── glProjectArrays.s ├── glProjectPoint.s ├── glProject_s.s ├── guessIfFace2BeDrawn.c ├── hrsDemo.c ├── hrsDrawing.c ├── hzfill_c.c ├── isA1Right.c ├── kernel.s ├── keyboard.c ├── loadShape.c ├── loadShape_s.s ├── logic.c ├── logic_c.c ├── lrDrawLine.c ├── lrDrawLine.s ├── lrsDemo.c ├── lrsDrawing.c ├── main.c ├── makefile ├── math │ ├── atan2.s │ └── norm.s ├── osdk_build.bat ├── osdk_config.bat ├── osdk_execute.bat ├── osdk_showmap.bat ├── prepareBresrun.c ├── profbench.c ├── profile.h ├── profile.s ├── projection.s ├── raster │ ├── angle2screen.s │ ├── bresfill.h │ ├── buffer.s │ ├── fill8.s │ ├── fill8_bis.s │ ├── fillFace.s │ ├── filler.s │ ├── hfill.s │ ├── hzfill.s │ ├── hzfill_s.s │ ├── isA1Right.s │ ├── line.asm │ ├── line.s │ ├── line8.s │ ├── particules.s │ ├── prepareBresrun.s │ ├── raster8.s │ ├── reachScreen.s │ └── seg8.s ├── reachScreen.c ├── render │ ├── colors.h │ ├── face.s │ ├── glBuffer2Screen.s │ ├── glInitScreenBuffers.s │ ├── lrsDrawing.h │ ├── lrsSegments.s │ ├── zbuff.s │ └── zbuffer.h ├── retrieveFaceData.c ├── rtDemo.c ├── satur.c ├── scene.s ├── sortPoints.c ├── sprites.c ├── sprites_s.s ├── start.c ├── temp.s ├── txtDemo.c ├── util │ ├── display.s │ ├── keyboard.h │ ├── print.s │ ├── rand.s │ ├── screen.s │ └── util.h ├── xabuild.bat ├── zbuffer.c └── zplot_c.c ├── tests └── benchmark_results.txt ├── tools ├── atan2test.py ├── circletraj.py ├── decimal2bin.py ├── displayProfilingResults.py ├── fastatan.py ├── fastnorm.py ├── fastnorm2.py ├── fillclip.py ├── gloric.py └── optimizeLookUp.py └── walkthrough.c /.gitignore: -------------------------------------------------------------------------------- 1 | src/BUILD/* 2 | bresfill.asm 3 | logic.asm 4 | lrsDemo.asm 5 | zbuffer.asm 6 | lrsDrawing.asm 7 | *.lst 8 | *.o 9 | demo.asm 10 | *.lib 11 | *.map 12 | *.vice 13 | *.tap 14 | .vscode/settings.json 15 | BUILD/final.out 16 | BUILD/map.htm 17 | BUILD/symbols 18 | BUILD/xaerr.txt 19 | src/glOric_c.asm 20 | src/start.asm 21 | src/xa_labels.txt 22 | __pycache__ 23 | -------------------------------------------------------------------------------- /docs/hyperfastproject.md: -------------------------------------------------------------------------------- 1 | # Using glProject of glOric 2 | 3 | Here's an introduction of what I would call an "Hyper Fast Projection Routine" for Oric, named `glProject`. 4 | 5 | This function is of interest for people intending to render 3D scene on Oric in real time context because it computes screen coordinates from 3D coordinates and it does it fast .. terribly fast .. (about 500 cycles per point). 6 | 7 | Given the camera situation (position and orientation) and a screen configuration, this function gives screen 2d-coordinates of up to 64 projected 3d points. 8 | 9 | ```C 10 | 11 | // Camera Position 12 | extern signed char glCamPosX; 13 | extern signed char glCamPosY; 14 | extern signed char glCamPosZ; 15 | 16 | // Camera Orientation 17 | extern char glCamRotZ; 18 | extern char glCamRotX; 19 | 20 | void glProject (char points2D[], char points3D[], unsigned char glNbVertices, unsigned char options); 21 | ``` 22 | 23 | 24 | As input of the function, array `points3D` contains list of `glNbVertices` 3D points stored on 4 bytes: 3 bytes for X, Y and Z coordinates and a spare bytes for futur use. 25 | 26 | As output of function, array `points2D` if filled with `glNbVertices` 2D points stored on 4 bytes: 2 bytes for L and C (line and column coordinates) and 2 bytes for distance (between camera and point). 27 | 28 | For exemple, here's an exemple of how to project a 3D cube: 29 | 30 | ```C 31 | #include 32 | 33 | #define CUBE_SIZE 4 34 | #define NB_POINTS_CUBE 8 35 | 36 | const char ptsCube3D[]={ 37 | -CUBE_SIZE, -CUBE_SIZE, +CUBE_SIZE, 0 // P0 38 | ,-CUBE_SIZE, -CUBE_SIZE, -CUBE_SIZE, 0 // P1 39 | ,+CUBE_SIZE, -CUBE_SIZE, -CUBE_SIZE, 0 // P2 40 | ,+CUBE_SIZE, -CUBE_SIZE, +CUBE_SIZE, 0 // P3 41 | ,-CUBE_SIZE, +CUBE_SIZE, +CUBE_SIZE, 0 // P4 42 | ,-CUBE_SIZE, +CUBE_SIZE, -CUBE_SIZE, 0 // P5 43 | ,+CUBE_SIZE, +CUBE_SIZE, -CUBE_SIZE, 0 // P6 44 | ,+CUBE_SIZE, +CUBE_SIZE, +CUBE_SIZE, 0 // P7 45 | }; 46 | char ptsCube2D [NB_POINTS_CUBE * SIZEOF_2DPOINT]; 47 | 48 | glProject (ptsCube2D, ptsCube3D, NB_POINTS_CUBE, 0); 49 | ``` 50 | 51 | after the call to `glProject` array `points2D` contains 2D coordinates of points in `points3D` 52 | 53 | 54 | 55 | Provided you have a function `drawLine (X1, Y1, X2, Y2)` that draws a segment between points [X1, Y1] and [X2, Y2], it is possible to draw the cube with following instructions: 56 | 57 | ```c 58 | 59 | void lineBetweenPoints (idxPt1, idxPt2 ){ 60 | drawLine ( 61 | // L , C Point 1 62 | ptsCube2D [idxPt1*SIZEOF_2DPOINT + 0], 63 | ptsCube2D [idxPt1*SIZEOF_2DPOINT + 1], 64 | // L , C Point 2 65 | ptsCube2D [idxPt2*SIZEOF_2DPOINT + 0], 66 | ptsCube2D [idxPt2*SIZEOF_2DPOINT + 1] 67 | ); 68 | } 69 | 70 | lineBetweenPoints (0, 1); 71 | lineBetweenPoints (1, 2); 72 | lineBetweenPoints (2, 3); 73 | lineBetweenPoints (3, 0); 74 | lineBetweenPoints (4, 5); 75 | lineBetweenPoints (5, 6); 76 | lineBetweenPoints (6, 7); 77 | lineBetweenPoints (7, 4); 78 | lineBetweenPoints (0, 4); 79 | lineBetweenPoints (1, 5); 80 | lineBetweenPoints (2, 6); 81 | lineBetweenPoints (3, 7); 82 | 83 | ``` 84 | -------------------------------------------------------------------------------- /docs/imgs/BiplanarApprox.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/BiplanarApprox.png -------------------------------------------------------------------------------- /docs/imgs/ColorDemo.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/ColorDemo.gif -------------------------------------------------------------------------------- /docs/imgs/ExampleHires.JPG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/ExampleHires.JPG -------------------------------------------------------------------------------- /docs/imgs/ExampleText.JPG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/ExampleText.JPG -------------------------------------------------------------------------------- /docs/imgs/FirstOrderNormError.JPG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/FirstOrderNormError.JPG -------------------------------------------------------------------------------- /docs/imgs/GlobalPerfectNorm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/GlobalPerfectNorm.png -------------------------------------------------------------------------------- /docs/imgs/HiresModeDemo.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/HiresModeDemo.gif -------------------------------------------------------------------------------- /docs/imgs/LocalPerfectNorm.JPG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/LocalPerfectNorm.JPG -------------------------------------------------------------------------------- /docs/imgs/LoresModeDemo.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/LoresModeDemo.gif -------------------------------------------------------------------------------- /docs/imgs/NormFinalError.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/NormFinalError.png -------------------------------------------------------------------------------- /docs/imgs/PlanApproxNorm.JPG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/PlanApproxNorm.JPG -------------------------------------------------------------------------------- /docs/imgs/RasterizingWithFiller.JPG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/RasterizingWithFiller.JPG -------------------------------------------------------------------------------- /docs/imgs/TextModeDemo.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/TextModeDemo.gif -------------------------------------------------------------------------------- /docs/imgs/TwoPlanNormApproxError.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/oric-software/glOric/a272bddc1be6fd3c77eed47ee507ba48f27ed063/docs/imgs/TwoPlanNormApproxError.png -------------------------------------------------------------------------------- /docs/norm.md: -------------------------------------------------------------------------------- 1 | # Calcul de la norme euclidienne sur glOric 2 | 3 | Voici comment a été obtenu l'algorithme de calcul de la norme euclidienne: 4 | z = sqrt (x^2 + y^2) 5 | 6 | ![](imgs/GlobalPerfectNorm.png) 7 | 8 | Cette fonction et symétrique, on peut se concentrer uniquement sur les valeurs positives de x et y. 9 | 10 | Voici à quoi ressemble cette fonction sur l'espace des x et y positifs: 11 | 12 | ![](imgs/LocalPerfectNorm.JPG) 13 | 14 | Comme c'est très "plat", ma première idée avait été de l'approximer par un plan en interpolant linéairement entre les axes x=0 et y=x par un algo de la forme: 15 | 16 | ``` 17 | SI abs(x)>abs(y) 18 | Z = abs(x) + abs(y) * (sqrt(2) -1) 19 | SINON 20 | Z = abs(x) + abs(y) * (sqrt(2) -1) 21 | FINSI 22 | ``` 23 | 24 | Voici à quoi ressemble ce plan. 25 | 26 | ![](imgs/PlanApproxNorm.JPG) 27 | 28 | Obtenu en tapant :`if (x>y, x + y * (sqrt(2) -1), y + x * (sqrt(2) -1))` sur [academo.org](https://academo.org/demos/3d-surface-plotter/?expression=if(x%3Ey%2Cx%2By*(sqrt(2)-1)%2Cy%2Bx*(sqrt(2)-1))&xRange=0%2C+128&yRange=0%2C+128&resolution=25) 29 | 30 | L'intérêt c'est que le calcul n'implique que: 31 | - une comparaison 32 | - un adressage indexé (pour la multiplication par une constante qu'on peut mettre en abbaque) 33 | - une addition. 34 | 35 | Mais il s'est avéré que l'approximation par un plan était trop imprécise comme le montre la figure suivante représentant la différence entre la valeur réelle et l'approximation par un plan. 36 | 37 | ![](imgs/FirstOrderNormError.JPG) 38 | 39 | Obtenu en tapant :`if (x>y, sqrt (x^2 + y^2) - (x + y * (sqrt(2) -1)), sqrt (x^2 + y^2) -(y + x * (sqrt(2) -1)))` sur [academo.org](https://academo.org/demos/3d-surface-plotter/?expression=if(x%3Ey%2Csqrt(x%5E2%2By%5E2)-(x%2By*(sqrt(2)-1))%2Csqrt(x%5E2%2By%5E2)-(y%2Bx*(sqrt(2)-1)))&xRange=0%2C+128&yRange=0%2C+128&resolution=25) 40 | 41 | L'erreur arrive à plus de 10 en valeur absolue. 42 | 43 | Après avoir constaté que l'erreur était la plus grande au centre ma zone d'approximation (là où Y = X/2), j'ai décidé de faire une approximation par deux plans pluôt qu'un. 44 | 45 | ``` 46 | if ax >= ay: 47 | x, y = ax, ay 48 | else: 49 | x, y = ay, ax 50 | if y > x/2 : 51 | Z = C*x + D*Y 52 | else: 53 | Z = A*x + B*y 54 | ``` 55 | 56 | L'intérêt de cette forme reste qu'en assembleur, elle peut se réaliser par : 57 | - deux comparaisons 58 | - deux adressages indirect 59 | - une somme 60 | 61 | Par le calcul manuel je suis arrivé à : 62 | ``` 63 | A = 1.0 64 | B = math.sqrt(5) - 2 65 | C = math.sqrt(5)-math.sqrt(2) 66 | D = 2*math.sqrt(2) - math.sqrt(5) 67 | ``` 68 | 69 | Les résultats étaient déjà sympas comme le montre cette représentation de l'erreur (erreur inférieure à 3.5): 70 | 71 | ![](imgs/TwoPlanNormApproxError.png) 72 | 73 | Mais je ne me suis pas arrêté là .. 74 | 75 | J'ai utilisé cette combinaison de valeur comme point de départ d'une recherche de combinaison optimale, par regression linéaire des moindre carré sur l'erreur. 76 | 77 | Et, puisque les tables de multiplication A, B, C et D allaient être des abbaques, je me suis dit qu'il était possible d'y mettre autre chose qu'une fonction affine. Et j'ai décidé de faire rechercher (par l'ordinateur du 21ème siècle) une fonction polynomiale du second ordre pour chaque table A B C et D 78 | 79 | L'idée c'est de, tout en gardant le temps de calcul évoqué plus haut (puis que la fonction polynomiale sera mise en abbaque), disposer d'une fonction de calcul de la forme suivante: 80 | 81 | ``` 82 | if ax >= ay: 83 | x, y = ax, ay 84 | else: 85 | x, y = ay, ax 86 | if y > x/2 : 87 | Z = C2 * (x^2) + C1 * x + C0 + D2 * (y^2) + D1 * y + D0 88 | else: 89 | Z = A2 * (x^2) + A1 * x + A0 + B2 * (y^2) + B1 * y + B0 90 | ``` 91 | 92 | Car un choix précis des coefficients A0, A1, A2, B0, B1, B2, C0, C1, C2, D0, D1, D2 permet aux erreurs de se compenser !! 93 | 94 | L'erreur finale a cet aspect: 95 | 96 | ![](imgs/NormFinalError.png) 97 | 98 | L'erreur est inférieure à 2 en valeur absolu et elle est un peu plus centrée autour de 0. 99 | 100 | Après un tunning manuel de quelques valeurs proche de 0, je suis arrivé à une erreur inférieure à 11% (erreur d'arrondi comprise) sur tout le domaine de définition. 101 | 102 | Il est possible d'aller enconre plus loin dans la fidélité de l'approximation en utilisant un algo de backtracking pour le choix des arrondis. 103 | 104 | Le choix d'une approximation biplanaire a permis de diviser par trois le temps de calcul de la norme euclidienne. 105 | Sans trop sacrifier à la précision. 106 | 107 | |Courbe idéale| Courbe approximée| 108 | |--|--| 109 | |![](imgs/GlobalPerfectNorm.png)|![](imgs/BiplanarApprox.png)| 110 | -------------------------------------------------------------------------------- /osdk_build.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | 4 | :: 5 | :: Initial check. 6 | :: Verify if the SDK is correctly configurated 7 | :: 8 | IF "%OSDK%"=="" GOTO ErCfg 9 | 10 | 11 | :: 12 | :: Set the build paremeters 13 | :: 14 | CALL osdk_config.bat 15 | 16 | 17 | :: 18 | :: Launch the compilation of files 19 | :: 20 | CALL %OSDK%\bin\make.bat %OSDKFILE% 21 | GOTO End 22 | 23 | 24 | :: 25 | :: Outputs an error message 26 | :: 27 | :ErCfg 28 | ECHO == ERROR == 29 | ECHO The Oric SDK was not configured properly 30 | ECHO You should have a OSDK environment variable setted to the location of the SDK 31 | IF "%OSDKBRIEF%"=="" PAUSE 32 | GOTO End 33 | 34 | 35 | :End 36 | -------------------------------------------------------------------------------- /osdk_config.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | :: 4 | :: Set the build paremeters 5 | :: 6 | SET OSDKADDR=$500 7 | SET OSDKNAME=3DWALKTHROUGH 8 | SET OSDKCOMP=-O2 9 | REM SET OSDKLINK=-B 10 | 11 | SET OSDKFILE=release\glOric walkthrough 12 | 13 | 14 | 15 | :: List of files to put in the DSK file. 16 | :: Implicitely includes BUILD/%OSDKNAME%.TAP 17 | SET OSDKTAPNAME="3DWalkthrough" 18 | 19 | ::run99.tap ..\intro\build\intro.tap 20 | SET OSDKDNAME=" -- 3D Walkthrough --" 21 | SET OSDKINIST="?\"V1.1\":WAIT20:!RUNME.COM" 22 | -------------------------------------------------------------------------------- /osdk_execute.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | :: 4 | :: Initial check. 5 | :: Verify if the SDK is correctly configurated, 6 | :: 7 | IF "%OSDK%"=="" GOTO ErCfg 8 | 9 | :: 10 | :: Set the build paremeters 11 | :: 12 | CALL osdk_config.bat 13 | 14 | :: 15 | :: Run the emulator using the common batch 16 | :: 17 | CALL %OSDK%\bin\execute.bat 18 | GOTO End 19 | 20 | :: 21 | :: Outputs an error message about configuration 22 | :: 23 | :ErCfg 24 | ECHO == ERROR == 25 | ECHO The Oric SDK was not configured properly 26 | ECHO You should have a OSDK environment variable setted to the location of the SDK 27 | ECHO =========== 28 | IF "%OSDKBRIEF%"=="" PAUSE 29 | GOTO End 30 | 31 | :End 32 | -------------------------------------------------------------------------------- /osdk_showmap.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | :: 4 | :: Initial check. 5 | :: Verify if the SDK is correctly configurated 6 | :: 7 | IF "%OSDK%"=="" GOTO ErCfg 8 | 9 | :: 10 | :: Set the build paremeters 11 | :: 12 | CALL osdk_config.bat 13 | 14 | :: 15 | :: Generate the HTML file 16 | :: 17 | %OSDK%\bin\MemMap.exe build\symbols build\map.htm %OSDKNAME% %OSDK%\documentation\documentation.css 18 | 19 | :: 20 | :: Display the HTML file 21 | :: 22 | explorer build\map.htm 23 | 24 | GOTO End 25 | 26 | 27 | :: 28 | :: Outputs an error message 29 | :: 30 | :ErCfg 31 | ECHO == ERROR == 32 | ECHO The Oric SDK was not configured properly 33 | ECHO You should have a OSDK environment variable setted to the location of the SDK 34 | pause 35 | GOTO End 36 | 37 | 38 | :End 39 | 40 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | # glOric : Real Time 3D for Oric 2 | 3 | Project __glOric__ aims at providing Oric's developpers with an hyper fast 3D library to use in real time applications. 4 | 5 | ## Starting with glOric 6 | 7 | ### Installing Pre-requisites 8 | 9 | In order to use __glOric__, you have to first install a developpement environnement. The simplest way to do so is to download and install [OSDK](http://osdk.org/). 10 | 11 | Next, you will need a git client to retreive the source code of __glOric__ from its repository on github. Download and install [GIT](https://git-scm.com/). 12 | 13 | 14 | 15 | ### Downloading glOric project 16 | 17 | Getting glOric is simple. If you have a GIT client installed, just clone the [glOric repository](https://github.com/oric-software/glOric) 18 | ``` 19 | git clone --depth 1 --branch master https://github.com/oric-software/glOric.git 20 | ``` 21 | 22 | Or, if you don't have GIT client installed, you can download an [archive of the project](https://github.com/oric-software/glOric/archive/master.zip) 23 | 24 | 25 | 26 | ### Building glOric demos 27 | 28 | A good starting point in using glOric consists in building and testing demos that are provided with the project. 29 | 30 | 3 demos are provided : 31 | - a text based demo 32 | 33 | ![TextDemo](docs/imgs/TextModeDemo.gif) 34 | - a hires demo 35 | 36 | ![HiresDemo](docs/imgs/HiresModeDemo.gif) 37 | - a lores demo 38 | 39 | ![LoresDemo](docs/imgs/LoresModeDemo.gif) 40 | 41 | - a color demo 42 | 43 | ![ColorDemo](docs/imgs/ColorDemo.gif) 44 | 45 | 46 | #### Selecting a demo to build 47 | To choose between demos, open the `config.h` file located in the `src` directory of glOric and find the following section at the beginning of the file: 48 | 49 | ```C 50 | // Choose amongst TEXTDEMO, LRSDEMO, HRSDEMO, COLORDEMO 51 | #define COLORDEMO 52 | ``` 53 | 54 | Change the line to `#define HRSDEMO` if you want ot build the HIRES mode demo. 55 | 56 | Change the line to `#define LRSDEMO` if you want ot build the LORES mode demo. 57 | 58 | Change the line to `#define TEXTDEMO` if you want ot build the text mode demo. 59 | 60 | Change the line to `#define COLORDEMO` if you want ot build the color mode demo. 61 | 62 | #### Building the demo 63 | 64 | Once you have selected the demo you want to build, just open a shell command in the directory where you placed the source code and run following commands: 65 | 66 | ``` 67 | cd src 68 | osdk_build.bat && osdk_execute.bat 69 | ``` 70 | 71 | It should start an Oricutron with the selected demo running in it. 72 | 73 | #### Running the demo 74 | 75 | These sample demos consists in: 76 | - an intro in which the camera position and orientation is animated 77 | - followed by an interactive phase where you can manually move the camera in order to test real time interactive mode. 78 | 79 | In TEXT, LORES or COLOR mode sample demo , the camera is moved with the following keyboard commands: 80 | 81 | - Arrow (up / down) to go ( forward / backward ) 82 | - W / X to shift (left / right) 83 | - Arrow (left / right ) to rotate the camera 84 | - Q / A to pitch (up / down) 85 | - P / ; to go (up / down) 86 | 87 | As in HIRES mode sample demo, the camera is moved with the following keyboard commands: 88 | 89 | - Arrow (left / right ) to rotate around the object 90 | - Q / A to go (up / down) 91 | 92 | 93 | __Programing Interface__ is [described 94 | here](docs/hyperfastproject.md) and [discussed here](http://forum.defence-force.org/viewtopic.php?f=24&t=2049#p20993). 95 | 96 | __Demos__ are [provided and discussed here](http://forum.defence-force.org/viewtopic.php?f=21&t=2048#p20989). 97 | 98 | __Source Code__ is [here](src). 99 | 100 | For __Insight__ read the [article on the euclidian norm](docs/norm.md). 101 | 102 | 103 | __Screenshots__ 104 | ||| 105 | |--|--| 106 | |![](docs/imgs/ExampleText.JPG)|![](docs/imgs/ExampleHires.JPG)| 107 | 108 | ![](docs/imgs/RasterizingWithFiller.JPG) 109 | 110 | 111 | -------------------------------------------------------------------------------- /release/glOric.h: -------------------------------------------------------------------------------- 1 | /* ======================================= 2 | * glOric 3D v1.4 3 | * ======================================= 4 | * 3D graphic library for Oric 5 | * 6 | * by Jean-Baptiste PERIN 7 | * 8 | * advised by the great Mickael POINTIER 9 | * (a.k.a Dbug) 10 | * for insane optimizations 11 | * ======================================= 12 | * 13 | * Copyright 2020 Jean-Baptiste PERIN 14 | * Email: jbperin@gmail.com 15 | * 16 | * Website: https://github.com/oric-software/glOric 17 | * 18 | * ======================================= 19 | */ 20 | 21 | #ifndef GLORIC_H 22 | #define GLORIC_H 23 | 24 | #define GLORIC_VERSION 14 25 | 26 | #define SCREEN_WIDTH 40 27 | #define SCREEN_HEIGHT 26 28 | #define ADR_BASE_SCREEN 48000 29 | #define HIRES_SCREEN_ADDRESS 0xA000 30 | 31 | #define SIZEOF_3DPOINT 4 32 | #define SIZEOF_SEGMENT 4 33 | #define SIZEOF_PARTICLE 2 34 | #define SIZEOF_2DPOINT 4 35 | #define SIZEOF_FACE 4 36 | 37 | #define NB_LESS_LINES_4_COLOR 4 38 | 39 | // Camera Position use only low bytes 40 | extern signed char glCamPosX; 41 | extern signed char glCamPosY; 42 | extern signed char glCamPosZ; 43 | 44 | // Camera Orientation 45 | extern char glCamRotZ; // -128 -> 127 unit : 2PI/(2^8 - 1) 46 | extern char glCamRotX; 47 | 48 | // Geometry size 49 | extern unsigned char glNbVertices; 50 | extern unsigned char glNbFaces; 51 | extern unsigned char glNbSegments; 52 | extern unsigned char glNbParticles; 53 | extern unsigned char glNbSprites; 54 | 55 | // Geometry buffers 56 | extern signed char glVerticesX[]; 57 | extern signed char glVerticesY[]; 58 | extern signed char glVerticesZ[]; 59 | 60 | extern unsigned char glParticlesPt[]; 61 | extern unsigned char glParticlesChar[]; 62 | 63 | extern unsigned char glSegmentsPt1[]; 64 | extern unsigned char glSegmentsPt2[]; 65 | extern unsigned char glSegmentsChar[]; 66 | 67 | extern unsigned char glFacesPt1[]; 68 | extern unsigned char glFacesPt2[]; 69 | extern unsigned char glFacesPt3[]; 70 | extern unsigned char glFacesChar[]; 71 | 72 | 73 | // Geometry buffers 74 | // extern signed char glSpriteX[]; 75 | // extern signed char glSpriteY[]; 76 | // extern signed char glSpriteZ[]; 77 | 78 | 79 | // Render buffer 80 | extern char fbuffer[]; // frame buffer SCREEN_WIDTH * SCREEN_HEIGHT 81 | 82 | extern void glProjectArrays(); 83 | extern void glDrawFaces(); 84 | extern void glDrawSegments(); 85 | extern void glDrawParticles(); 86 | extern void glAddSprite(signed char X, signed char Y, signed char Z, signed char *sprite); 87 | extern void glDrawSprites(); 88 | extern void glInitScreenBuffers(); 89 | extern void glBuffer2Screen(); 90 | extern void glZPlot(signed char X, signed char Y, unsigned char dist, char char2disp); 91 | extern void glProjectPoint(signed char x, signed char y, signed char z, unsigned char options, signed char *ah, signed char *av, unsigned int *dist); 92 | extern void glProject (char points2D[], char points3D[], unsigned char nbVertices, unsigned char options); 93 | extern void glLoadShape( 94 | signed char X, 95 | signed char Y, 96 | signed char Z, 97 | unsigned char orientation, 98 | signed char geom[]); 99 | 100 | 101 | extern unsigned char sl_ori; 102 | extern signed char *sl_geom; 103 | extern signed char sl_X, sl_Y, sl_Z; 104 | 105 | void glLoadShape( 106 | signed char X, 107 | signed char Y, 108 | signed char Z, 109 | unsigned char orientation, 110 | signed char geom[]) { 111 | 112 | sl_X = X; 113 | sl_Y = Y; 114 | sl_Z = Z; 115 | sl_geom = geom; 116 | sl_ori = orientation; 117 | 118 | loadShape(); 119 | } 120 | 121 | #endif -------------------------------------------------------------------------------- /release/v11/glOric_v11.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef GLORIC_H 3 | #define GLORIC_H 4 | 5 | #define GLORIC_VERSION 11 6 | 7 | #define SCREEN_WIDTH 40 8 | #define SCREEN_HEIGHT 26 9 | #define ADR_BASE_SCREEN 48000 10 | #define HIRES_SCREEN_ADDRESS 0xA000 11 | 12 | #define SIZEOF_3DPOINT 4 13 | #define SIZEOF_SEGMENT 4 14 | #define SIZEOF_PARTICULE 2 15 | #define SIZEOF_2DPOINT 4 16 | #define SIZEOF_FACE 4 17 | 18 | #define NB_LESS_LINES_4_COLOR 4 19 | 20 | // Camera Position use only low bytes 21 | extern int CamPosX; 22 | extern int CamPosY; 23 | extern int CamPosZ; 24 | 25 | // Camera Orientation 26 | extern char CamRotZ; // -128 -> 127 unit : 2PI/(2^8 - 1) 27 | extern char CamRotX; 28 | 29 | // Geometry size 30 | extern unsigned char nbPoints; 31 | extern unsigned char nbFaces; 32 | extern unsigned char nbSegments; 33 | extern unsigned char nbParticules; 34 | 35 | // Geometry buffers 36 | extern signed char points3dX[]; 37 | extern signed char points3dY[]; 38 | extern signed char points3dZ[]; 39 | 40 | extern unsigned char particulesPt[]; 41 | extern unsigned char particulesChar[]; 42 | 43 | extern unsigned char segmentsPt1[]; 44 | extern unsigned char segmentsPt2[]; 45 | extern unsigned char segmentsChar[]; 46 | 47 | extern unsigned char facesPt1[]; 48 | extern unsigned char facesPt2[]; 49 | extern unsigned char facesPt3[]; 50 | extern unsigned char facesChar[]; 51 | 52 | // Render buffer 53 | extern char fbuffer[]; // frame buffer SCREEN_WIDTH * SCREEN_HEIGHT 54 | 55 | extern void glProjectArrays(); 56 | extern void glDrawFaces(); 57 | extern void glDrawSegments(); 58 | extern void glDrawParticules(); 59 | extern void initScreenBuffers(); 60 | extern void buffer2screen(char *); 61 | 62 | #endif -------------------------------------------------------------------------------- /release/v12/glOric_v12.h: -------------------------------------------------------------------------------- 1 | /* ======================================= 2 | * glOric 3D v1.2 3 | * ======================================= 4 | * 3D graphic library for Oric 5 | * 6 | * by Jean-Baptiste PERIN 7 | * 8 | * advised by the great Mickael POINTIER 9 | * (a.k.a Dbug) 10 | * for insane optimizations 11 | * ======================================= 12 | * 13 | * Copyright 2020 Jean-Baptiste PERIN 14 | * Email: jbperin@gmail.com 15 | * 16 | * Website: https://github.com/oric-software/glOric 17 | * 18 | * ======================================= 19 | */ 20 | 21 | #ifndef GLORIC_H 22 | #define GLORIC_H 23 | 24 | #define GLORIC_VERSION 12 25 | 26 | #define SCREEN_WIDTH 40 27 | #define SCREEN_HEIGHT 26 28 | #define ADR_BASE_SCREEN 48000 29 | #define HIRES_SCREEN_ADDRESS 0xA000 30 | 31 | #define SIZEOF_3DPOINT 4 32 | #define SIZEOF_SEGMENT 4 33 | #define SIZEOF_PARTICULE 2 34 | #define SIZEOF_2DPOINT 4 35 | #define SIZEOF_FACE 4 36 | 37 | #define NB_LESS_LINES_4_COLOR 4 38 | 39 | // Camera Position use only low bytes 40 | extern int CamPosX; 41 | extern int CamPosY; 42 | extern int CamPosZ; 43 | 44 | // Camera Orientation 45 | extern char CamRotZ; // -128 -> 127 unit : 2PI/(2^8 - 1) 46 | extern char CamRotX; 47 | 48 | // Geometry size 49 | extern unsigned char nbPoints; 50 | extern unsigned char nbFaces; 51 | extern unsigned char nbSegments; 52 | extern unsigned char nbParticules; 53 | 54 | // Geometry buffers 55 | extern signed char points3dX[]; 56 | extern signed char points3dY[]; 57 | extern signed char points3dZ[]; 58 | 59 | extern unsigned char particulesPt[]; 60 | extern unsigned char particulesChar[]; 61 | 62 | extern unsigned char segmentsPt1[]; 63 | extern unsigned char segmentsPt2[]; 64 | extern unsigned char segmentsChar[]; 65 | 66 | extern unsigned char facesPt1[]; 67 | extern unsigned char facesPt2[]; 68 | extern unsigned char facesPt3[]; 69 | extern unsigned char facesChar[]; 70 | 71 | // Render buffer 72 | extern char fbuffer[]; // frame buffer SCREEN_WIDTH * SCREEN_HEIGHT 73 | 74 | extern void glProjectArrays(); 75 | extern void glDrawFaces(); 76 | extern void glDrawSegments(); 77 | extern void glDrawParticules(); 78 | extern void initScreenBuffers(); 79 | extern void buffer2screen(char *); 80 | extern void zplot(signed char X, signed char Y, unsigned char dist, char char2disp); 81 | extern void projectPoint(signed char x, signed char y, signed char z, unsigned char options, signed char *ah, signed char *av, unsigned int *dist); 82 | #endif -------------------------------------------------------------------------------- /release/v13/glOric.h: -------------------------------------------------------------------------------- 1 | /* ======================================= 2 | * glOric 3D v1.3 3 | * ======================================= 4 | * 3D graphic library for Oric 5 | * 6 | * by Jean-Baptiste PERIN 7 | * 8 | * advised by the great Mickael POINTIER 9 | * (a.k.a Dbug) 10 | * for insane optimizations 11 | * ======================================= 12 | * 13 | * Copyright 2020 Jean-Baptiste PERIN 14 | * Email: jbperin@gmail.com 15 | * 16 | * Website: https://github.com/oric-software/glOric 17 | * 18 | * ======================================= 19 | */ 20 | 21 | #ifndef GLORIC_H 22 | #define GLORIC_H 23 | 24 | #define GLORIC_VERSION 13 25 | 26 | #define SCREEN_WIDTH 40 27 | #define SCREEN_HEIGHT 26 28 | #define ADR_BASE_SCREEN 48000 29 | #define HIRES_SCREEN_ADDRESS 0xA000 30 | 31 | #define SIZEOF_3DPOINT 4 32 | #define SIZEOF_SEGMENT 4 33 | #define SIZEOF_PARTICLE 2 34 | #define SIZEOF_2DPOINT 4 35 | #define SIZEOF_FACE 4 36 | 37 | #define NB_LESS_LINES_4_COLOR 4 38 | 39 | // Camera Position use only low bytes 40 | extern signed char glCamPosX; 41 | extern signed char glCamPosY; 42 | extern signed char glCamPosZ; 43 | 44 | // Camera Orientation 45 | extern char glCamRotZ; // -128 -> 127 unit : 2PI/(2^8 - 1) 46 | extern char glCamRotX; 47 | 48 | // Geometry size 49 | extern unsigned char glNbVertices; 50 | extern unsigned char glNbFaces; 51 | extern unsigned char glNbSegments; 52 | extern unsigned char glNbParticles; 53 | 54 | // Geometry buffers 55 | extern signed char glVerticesX[]; 56 | extern signed char glVerticesY[]; 57 | extern signed char glVerticesZ[]; 58 | 59 | extern unsigned char glParticlesPt[]; 60 | extern unsigned char glParticlesChar[]; 61 | 62 | extern unsigned char glSegmentsPt1[]; 63 | extern unsigned char glSegmentsPt2[]; 64 | extern unsigned char glSegmentsChar[]; 65 | 66 | extern unsigned char glFacesPt1[]; 67 | extern unsigned char glFacesPt2[]; 68 | extern unsigned char glFacesPt3[]; 69 | extern unsigned char glFacesChar[]; 70 | 71 | // Render buffer 72 | extern char fbuffer[]; // frame buffer SCREEN_WIDTH * SCREEN_HEIGHT 73 | 74 | extern void glProjectArrays(); 75 | extern void glDrawFaces(); 76 | extern void glDrawSegments(); 77 | extern void glDrawParticles(); 78 | extern void glInitScreenBuffers(); 79 | extern void glBuffer2Screen(); 80 | extern void glZPlot(signed char X, signed char Y, unsigned char dist, char char2disp); 81 | extern void glProjectPoint(signed char x, signed char y, signed char z, unsigned char options, signed char *ah, signed char *av, unsigned int *dist); 82 | extern void glProject (char points2D[], char points3D[], unsigned char nbVertices, unsigned char options); 83 | 84 | #endif -------------------------------------------------------------------------------- /src/addGeom.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_REWORKED_BUFFERS 2 | void glLoadShape( 3 | signed char X, 4 | signed char Y, 5 | signed char Z, 6 | unsigned char sizeX, 7 | unsigned char sizeY, 8 | unsigned char sizeZ, 9 | unsigned char orientation, 10 | signed char geom[]) { 11 | 12 | int kk=0; 13 | int ii; 14 | int npt,nfa, nseg, npart; 15 | npt = geom[kk++]; 16 | nfa = geom[kk++]; 17 | nseg = geom[kk++]; 18 | npart = geom[kk++]; 19 | for (ii = 0; ii < npt; ii++){ 20 | if (orientation == 0) { 21 | glVerticesX[glNbVertices] = X + sizeX * geom[kk++]; 22 | glVerticesY[glNbVertices] = Y + sizeY * geom[kk++]; 23 | } else { 24 | glVerticesY[glNbVertices] = Y + sizeY * geom[kk++]; 25 | glVerticesX[glNbVertices] = X + sizeX * geom[kk++]; 26 | } 27 | glVerticesZ[glNbVertices] = Z + sizeZ * geom[kk++]; 28 | glNbVertices ++; 29 | kk++; // skip unused byte 30 | } 31 | for (ii = 0; ii < nfa; ii++){ 32 | glFacesPt1[glNbFaces] = glNbVertices - (npt-geom[kk++]); // Index Point 1 33 | glFacesPt2[glNbFaces] = glNbVertices - (npt-geom[kk++]); // Index Point 2 34 | glFacesPt3[glNbFaces] = glNbVertices - (npt-geom[kk++]); // Index Point 3 35 | glFacesChar[glNbFaces] = geom[kk++]; // Character 36 | glNbFaces++; 37 | } 38 | for (ii = 0; ii < nseg; ii++){ 39 | glSegmentsPt1[glNbSegments] = glNbVertices - (npt-geom[kk++]); // Index Point 1 40 | glSegmentsPt2[glNbSegments] = glNbVertices - (npt-geom[kk++]); // Index Point 2 41 | glSegmentsChar[glNbSegments] = geom[kk++]; // Character 42 | glNbSegments++; 43 | kk++; // skip unused byte 44 | } 45 | for (ii = 0; ii < npart; ii++){ 46 | glParticlesPt[glNbParticles] = glNbVertices - (npt-geom[kk++]); // Index Point 47 | glParticlesChar[glNbParticles] = geom[kk++]; // Character 48 | glNbParticles++; 49 | } 50 | } 51 | #else // Not USE_REWORKED_BUFFERS 52 | void glLoadShape( 53 | signed char X, 54 | signed char Y, 55 | signed char Z, 56 | unsigned char sizeX, 57 | unsigned char sizeY, 58 | unsigned char sizeZ, 59 | unsigned char orientation, 60 | char geom[]) { 61 | // int ii, jj; 62 | int kk; 63 | // unsigned char oldNbPoints; 64 | // ii = (orientation == 0) ? 0 : -L; 65 | // jj = (orientation == 0) ? -L : 0; 66 | // oldNbPoints = glNbVertices; 67 | 68 | for (kk=0; kk< geom[0]; kk++){ 69 | points3d[glNbVertices * SIZEOF_3DPOINT + 0] = X + ((orientation == 0) ? sizeX * geom[4+kk*SIZEOF_3DPOINT+0]: sizeY * geom[4+kk*SIZEOF_3DPOINT+1]);// X + ii; 70 | points3d[glNbVertices * SIZEOF_3DPOINT + 1] = Y + ((orientation == 0) ? sizeY * geom[4+kk*SIZEOF_3DPOINT+1]: sizeX * geom[4+kk*SIZEOF_3DPOINT+0]);// Y + jj; 71 | points3d[glNbVertices * SIZEOF_3DPOINT + 2] = Z + geom[4+kk*SIZEOF_3DPOINT+2]*sizeZ;// ; 72 | glNbVertices++; 73 | } 74 | for (kk=0; kk< geom[1]; kk++){ 75 | faces[glNbFaces * SIZEOF_FACE + 0] = glNbVertices - (geom[0]-geom[4+geom[0]*SIZEOF_3DPOINT+kk*SIZEOF_FACE+0]); // Index Point 1 76 | faces[glNbFaces * SIZEOF_FACE + 1] = glNbVertices - (geom[0]-geom[4+geom[0]*SIZEOF_3DPOINT+kk*SIZEOF_FACE+1]); // Index Point 2 77 | faces[glNbFaces * SIZEOF_FACE + 2] = glNbVertices - (geom[0]-geom[4+geom[0]*SIZEOF_3DPOINT+kk*SIZEOF_FACE+2]); // Index Point 3 78 | faces[glNbFaces * SIZEOF_FACE + 3] = geom[4+geom[0]*SIZEOF_3DPOINT+kk*SIZEOF_FACE+3]; // Character 79 | glNbFaces++; 80 | } 81 | for (kk=0; kk< geom[2]; kk++){ 82 | segments[glNbSegments * SIZEOF_SEGMENT + 0] = glNbVertices - (geom[0]-geom[4+geom[0]*SIZEOF_3DPOINT+geom[1]*SIZEOF_FACE+kk*SIZEOF_SEGMENT + 0]); // Index Point 1 83 | segments[glNbSegments * SIZEOF_SEGMENT + 1] = glNbVertices - (geom[0]-geom[4+geom[0]*SIZEOF_3DPOINT+geom[1]*SIZEOF_FACE+kk*SIZEOF_SEGMENT + 1]); // Index Point 2 84 | segments[glNbSegments * SIZEOF_SEGMENT + 2] = geom[4+geom[0]*SIZEOF_3DPOINT+geom[1]*SIZEOF_FACE+kk*SIZEOF_SEGMENT + 2]; // Character 85 | glNbSegments++; 86 | } 87 | for (kk=0; kk< geom[3]; kk++){ 88 | particles[glNbParticles * SIZEOF_PARTICLE + 0] = glNbVertices - (geom[0]-geom[4 + geom[0]*SIZEOF_3DPOINT + geom[1]*SIZEOF_FACE + geom[2]*SIZEOF_SEGMENT + kk*SIZEOF_PARTICLE + 0]); // Index Point 89 | particles[glNbParticles * SIZEOF_PARTICLE + 1] = geom[4 + geom[0]*SIZEOF_3DPOINT + geom[1]*SIZEOF_FACE + geom[2]*SIZEOF_SEGMENT + kk*SIZEOF_PARTICLE + 1]; // Character 90 | glNbParticles++; 91 | } 92 | } 93 | #endif // USE_REWORKED_BUFFERS -------------------------------------------------------------------------------- /src/angle2screen.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_C_ANGLE2SCREEN 2 | void angle2screen() { 3 | P1X = (SCREEN_WIDTH - P1AH) >> 1; 4 | P1Y = (SCREEN_HEIGHT - P1AV) >> 1; 5 | P2X = (SCREEN_WIDTH - P2AH) >> 1; 6 | P2Y = (SCREEN_HEIGHT - P2AV) >> 1; 7 | P3X = (SCREEN_WIDTH - P3AH) >> 1; 8 | P3Y = (SCREEN_HEIGHT - P3AV) >> 1; 9 | } 10 | #endif // USE_C_ANGLE2SCREEN -------------------------------------------------------------------------------- /src/bresfill.c: -------------------------------------------------------------------------------- 1 | 2 | #include "config.h" 3 | #include "glOric.h" 4 | 5 | #include "render\zbuffer.h" 6 | #include "util\util.h" 7 | 8 | 9 | #ifdef USE_PROFILER 10 | #include "profile.h" 11 | #endif // USE_PROFILER 12 | 13 | 14 | extern signed char A1X; 15 | extern signed char A1Y; 16 | extern signed char A1destX; 17 | extern signed char A1destY; 18 | extern signed char A1dX; 19 | extern signed char A1dY; 20 | extern signed char A1err; 21 | extern signed char A1sX; 22 | extern signed char A1sY; 23 | extern char A1arrived; 24 | 25 | extern signed char A2X; 26 | extern signed char A2Y; 27 | extern signed char A2destX; 28 | extern signed char A2destY; 29 | extern signed char A2dX; 30 | extern signed char A2dY; 31 | extern signed char A2err; 32 | extern signed char A2sX; 33 | extern signed char A2sY; 34 | extern char A2arrived; 35 | extern unsigned char A1Right; 36 | 37 | #ifdef USE_SATURATION 38 | extern unsigned char A1XSatur; 39 | extern unsigned char A2XSatur; 40 | #endif // USE_SATURATION 41 | 42 | void fill8(); 43 | 44 | #ifdef USE_C_BRESFILL 45 | void hfill(); 46 | #endif // USE_C_BRESFILL 47 | 48 | #include "agent.c" 49 | 50 | // fillface 51 | extern signed char P1X, P1Y, P2X, P2Y, P3X, P3Y; 52 | extern signed char P1AH, P1AV, P2AH, P2AV, P3AH, P3AV; 53 | extern unsigned char distface; 54 | extern char ch2disp; 55 | 56 | #include "angle2screen.c" 57 | #include "fillFace.c" 58 | // fill8 59 | extern signed char pDepX; 60 | extern signed char pDepY; 61 | extern signed char pArr1X; 62 | extern signed char pArr1Y; 63 | extern signed char pArr2X; 64 | extern signed char pArr2Y; 65 | 66 | extern unsigned char log2_tab[]; 67 | extern signed char mDeltaY1, mDeltaX1, mDeltaY2, mDeltaX2; 68 | 69 | 70 | #include "prepareBresrun.c" 71 | 72 | #include "reachScreen.c" 73 | 74 | #include "satur.c" 75 | 76 | 77 | #include "fill8_bresrun.c" 78 | #include "isA1Right.c" 79 | 80 | #include "fill8_c.c" 81 | 82 | #ifdef USE_C_HFILL 83 | 84 | void hfill() { 85 | signed char dx, fx; 86 | signed char nbpoints; 87 | 88 | //printf ("p1x=%d p2x=%d py=%d dist= %d, char2disp= %d\n", p1x, p2x, dist, dist, char2disp);get(); 89 | 90 | #ifdef USE_COLOR 91 | if ((A1Y <= 0) || (A1Y >= SCREEN_HEIGHT-NB_LESS_LINES_4_COLOR)) 92 | return; 93 | #else 94 | if ((A1Y <= 0) || (A1Y >= SCREEN_HEIGHT)) 95 | return; 96 | #endif 97 | if (A1X > A2X) { 98 | #ifdef USE_COLOR 99 | dx = max(2, A2X); 100 | #else 101 | dx = max(0, A2X); 102 | #endif 103 | fx = min(A1X, SCREEN_WIDTH - 1); 104 | } else { 105 | #ifdef USE_COLOR 106 | dx = max(2, A1X); 107 | #else 108 | dx = max(0, A1X); 109 | #endif 110 | fx = min(A2X, SCREEN_WIDTH - 1); 111 | } 112 | 113 | nbpoints = fx - dx; 114 | 115 | if (nbpoints < 0) 116 | return; 117 | 118 | // printf ("dx=%d py=%d nbpoints=%d dist= %d, char2disp= %d\n", dx, py, nbpoints, dist, char2disp);get(); 119 | 120 | #ifdef USE_ZBUFFER 121 | zline(dx, A1Y, nbpoints, distface, ch2disp); 122 | #else 123 | // TODO : draw a line whit no z-buffer 124 | #endif 125 | } 126 | 127 | #endif // USE_C_HFILL 128 | -------------------------------------------------------------------------------- /src/buffer2screen.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_C_BUFFER2SCREEN 2 | void glBuffer2Screen() { 3 | memcpy((void*)ADR_BASE_LORES_SCREEN, fbuffer, SCREEN_HEIGHT* SCREEN_WIDTH); 4 | } 5 | #endif 6 | -------------------------------------------------------------------------------- /src/caBuild.bat: -------------------------------------------------------------------------------- 1 | set PATH_TO_ORICUTRON=C:\Users\Public\Orix 2 | REM set PATH_TO_ORICUTRON=C:\Users\tbpk7658\Applis\Orix 3 | REM C:\Users\Public\Oricutron 4 | set ORICUTRON=oricutron-sdl2.exe 5 | set PLATFORM=telestrat 6 | 7 | DEL glOric_c.asm start.asm *.o *.lst demoGlOric.tap %PATH_TO_ORICUTRON%\usbdrive\bin\d 8 | DEL glOric.lib 9 | 10 | ca65 -t%PLATFORM% camera.asm -g -l camera.lst -o camera.o --include-dir . 11 | ca65 -t%PLATFORM% temp.asm -g -l temp.lst -o temp.o --include-dir . 12 | ca65 -t%PLATFORM% fill8.asm -g -l fill8.lst -o fill8.o --include-dir . 13 | ca65 -t%PLATFORM% zbuff.asm -g -l zbuff.lst -o zbuff.o --include-dir . 14 | ca65 -t%PLATFORM% hzfill.asm -g -l hzfill.lst -o hzfill.o --include-dir . 15 | ca65 -t%PLATFORM% projection.asm -g -l projection.lst -o projection.o --include-dir . 16 | ca65 -t%PLATFORM% glProjectPoint.asm -g -l glProjectPoint.lst -o glProjectPoint.o --include-dir . 17 | ca65 -t%PLATFORM% scene.asm -g -l scene.lst -o scene.o --include-dir . 18 | 19 | cc65 glOric_c.c -D TARGET_ORIX -g -o glOric_c.asm 20 | ca65 -t%PLATFORM% glOric_c.asm -g -l glOric_c.lst -o glOric_c.o --include-dir . 21 | 22 | ar65 r glOric.lib camera.o temp.o fill8.o zbuff.o hzfill.o projection.o glProjectPoint.o scene.o glOric_c.o 23 | 24 | cc65 start.c -D TARGET_ORIX -g -o start.asm 25 | ca65 -t%PLATFORM% start.asm -g -l start.lst -o start.o --include-dir . 26 | 27 | cl65 -v -vm -m demo.map -Ln demo.vice -g -t%PLATFORM% start.o glOric.lib -o demoGlOric.tap 28 | 29 | IF EXIST demoGlOric.tap GOTO OkFile 30 | GOTO ErBld 31 | 32 | :OkFile 33 | copy demoGlOric.tap %PATH_TO_ORICUTRON%\usbdrive\bin\d 34 | 35 | PUSHD %PATH_TO_ORICUTRON% 36 | START .\%ORICUTRON% 37 | POPD 38 | 39 | :ErBld 40 | 41 | 42 | -------------------------------------------------------------------------------- /src/camera.s: -------------------------------------------------------------------------------- 1 | 2 | ;; ___ 3 | ;; / __\ __ _ _ __ ___ ___ _ __ __ _ 4 | ;; / / / _` || '_ ` _ \ / _ \| '__| / _` | 5 | ;; / /___ | (_| || | | | | || __/| | | (_| | 6 | ;; \____/ \__,_||_| |_| |_| \___||_| \__,_| 7 | 8 | 9 | #ifndef TARGET_ORIX 10 | #ifdef SAVE_ZERO_PAGE 11 | .text 12 | #else 13 | .zero 14 | #endif 15 | #else 16 | .text 17 | #endif ;; TARGET_ORIX 18 | 19 | ;; Camera Position 20 | _glCamPosX: .dsb 1 21 | _glCamPosY: .dsb 1 22 | _glCamPosZ: .dsb 1 23 | 24 | ;; Camera Orientation 25 | _glCamRotZ: .dsb 1 ;; -128 -> -127 unit : 2PI/(2^8 - 1) 26 | _glCamRotX: .dsb 1 27 | 28 | .text -------------------------------------------------------------------------------- /src/changeChar.c: -------------------------------------------------------------------------------- 1 | void change_char(char c, unsigned char patt01, unsigned char patt02, unsigned char patt03, unsigned char patt04, unsigned char patt05, unsigned char patt06, unsigned char patt07, unsigned char patt08) { 2 | unsigned char* adr; 3 | adr = (unsigned char*)(0xB400 + c * 8); 4 | *(adr++) = patt01; 5 | *(adr++) = patt02; 6 | *(adr++) = patt03; 7 | *(adr++) = patt04; 8 | *(adr++) = patt05; 9 | *(adr++) = patt06; 10 | *(adr++) = patt07; 11 | *(adr++) = patt08; 12 | } -------------------------------------------------------------------------------- /src/colors.c: -------------------------------------------------------------------------------- 1 | 2 | #include "config.h" 3 | 4 | 5 | #ifdef USE_COLOR 6 | 7 | #include "colors_c.c" 8 | 9 | #endif -------------------------------------------------------------------------------- /src/colors_c.c: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_ZBUFFER 3 | #include "render\zbuffer.h" 4 | #endif 5 | 6 | #include "render\colors.h" 7 | 8 | unsigned char tab_color [] = {INK_CYAN, INK_YELLOW, INK_MAGENTA, INK_BLUE, INK_GREEN, INK_RED, INK_CYAN, INK_YELLOW} ; 9 | 10 | 11 | void prepare_colors() { 12 | int ii, jj; 13 | 14 | for (ii = 0; ii<=LORES_SCREEN_HEIGHT-NB_LESS_LINES_4_COLOR ; ii++){ 15 | poke (LORES_SCREEN_ADDRESS+(ii*LORES_SCREEN_WIDTH)+0,HIRES_50Hz); 16 | #ifdef USE_ZBUFFER 17 | fbuffer[ii*LORES_SCREEN_WIDTH]=HIRES_50Hz; 18 | #endif // USE_ZBUFFER 19 | for (jj = 0; jj < 8; jj++) { 20 | poke (HIRES_SCREEN_ADDRESS+((ii*8+jj)*LORES_SCREEN_WIDTH)+1, tab_color[jj]); 21 | poke (HIRES_SCREEN_ADDRESS+((ii*8+jj)*LORES_SCREEN_WIDTH)+2, TEXT_50Hz); 22 | } 23 | } 24 | } 25 | 26 | // void spreadHiresAttributes() { 27 | // int ii, jj; 28 | // for (ii = 0; ii 2 | #include 3 | #include 4 | // #include 5 | 6 | #include "config.h" 7 | #include "glOric.h" 8 | 9 | #include "data/alphabet.h" 10 | //#include "traj.h" 11 | //#include "fill8.h" 12 | 13 | extern unsigned char une_fonction(); 14 | extern void lrsDemo(); 15 | 16 | /*extern void glProject (char *tabpoint2D, char *tabpoint3D, unsigned char glNbVertices, unsigned char opts); 17 | 18 | extern signed char glCamPosX, glCamPosY, glCamPosZ; 19 | extern signed char glCamRotZ, glCamRotX; 20 | 21 | 22 | unsigned char nbPts=0; 23 | char points3d[NB_MAX_VERTICES*SIZEOF_3DPOINT]; 24 | char points2d [NB_MAX_VERTICES*SIZEOF_2DPOINT]; 25 | 26 | */ 27 | char segments[NB_MAX_SEGMENTS*SIZEOF_SEGMENT]; 28 | unsigned char glNbSegments=0; 29 | char particles[NB_MAX_SEGMENTS*SIZEOF_PARTICLE]; 30 | unsigned char glNbParticles=0; 31 | 32 | 33 | 34 | #ifdef HRSDEMO 35 | void addCube(char X, char Y, char Z){ 36 | unsigned char ii, jj; 37 | for (jj=0; jj < NB_POINTS_CUBE; jj++){ 38 | points3d[(nbPts+jj)* SIZEOF_3DPOINT + 0] = ptsCube[jj*SIZEOF_3DPOINT + 0] + X; // X coord 39 | points3d[(nbPts+jj)* SIZEOF_3DPOINT + 1] = ptsCube[jj*SIZEOF_3DPOINT + 1] + Y; // Y coord 40 | points3d[(nbPts+jj)* SIZEOF_3DPOINT + 2] = ptsCube[jj*SIZEOF_3DPOINT + 2] + Z; // Z coord 41 | } 42 | for (jj=0; jj < NB_SEGMENTS_CUBE; jj++){ 43 | segments[(glNbSegments+jj)* SIZEOF_SEGMENT + 0] = segCube[jj*SIZEOF_SEGMENT + 0]+nbPts; // Index Point 1 44 | segments[(glNbSegments+jj)* SIZEOF_SEGMENT + 1] = segCube[jj*SIZEOF_SEGMENT + 1]+nbPts; // Index Point 2 45 | segments[(glNbSegments+jj)* SIZEOF_SEGMENT + 2] = segCube[jj*SIZEOF_SEGMENT + 2]; // Character 46 | } 47 | nbPts += NB_POINTS_CUBE; 48 | glNbSegments += NB_SEGMENTS_CUBE; 49 | } 50 | 51 | void hrDrawSegments(){ 52 | 53 | unsigned char ii = 0; 54 | unsigned char idxPt1, idxPt2; 55 | int OtherPixelX, OtherPixelY, CurrentPixelX, CurrentPixelY; 56 | for (ii = 0; ii< glNbSegments; ii++){ 57 | 58 | idxPt1 = segments[ii*SIZEOF_SEGMENT + 0]; 59 | idxPt2 = segments[ii*SIZEOF_SEGMENT + 1]; 60 | 61 | //OtherPixelX= (int)points2d[idxPt1*SIZEOF_2DPOINT + 0]; 62 | OtherPixelX=((int *)points2d)[idxPt1*2]; 63 | //OtherPixelY= (int)points2d[idxPt1*SIZEOF_2DPOINT + 2]; 64 | OtherPixelY=((int *)points2d)[idxPt1*2+1]; 65 | 66 | //CurrentPixelX=(int)points2d[idxPt2*SIZEOF_2DPOINT + 0]; 67 | CurrentPixelX=((int *)points2d)[idxPt2*2]; 68 | //CurrentPixelY=(int)points2d[idxPt2*SIZEOF_2DPOINT + 2]; 69 | CurrentPixelY=((int *)points2d)[idxPt2*2+1]; 70 | printf("%d %d %d %d \n", 71 | OtherPixelX, OtherPixelY, CurrentPixelX, CurrentPixelY); 72 | cgetc(); 73 | tgi_line(OtherPixelX,OtherPixelY,CurrentPixelX,CurrentPixelY); 74 | } 75 | } 76 | 77 | 78 | void hiresIntro (){ 79 | int i; 80 | 81 | 82 | glCamPosX = -24; 83 | glCamPosY = 0; 84 | glCamPosZ = 3; 85 | 86 | glCamRotZ = 64 ; 87 | glCamRotX = 2; 88 | 89 | for (i=0;i<2;) { 90 | glCamPosX = traj[i++]; 91 | glCamPosY = traj[i++]; 92 | glCamRotZ = traj[i++]; 93 | i = i % (NB_POINTS_TRAJ*SIZE_POINTS_TRAJ); 94 | glProject (points2d, points3d, nbPts,0); 95 | //memset ( 0xa000, 64, 8000); // clear screen 96 | hrDrawSegments(); 97 | //hrDrawFaces(); 98 | } 99 | 100 | //leaveSC(); 101 | 102 | } 103 | #endif 104 | int main () 105 | { 106 | 107 | //unsigned char val; 108 | signed char i; 109 | printf ("----------\n"); 110 | lrsDemo(); 111 | printf ("----------\n"); 112 | 113 | /* 114 | tgi_install (tgi_static_stddrv); 115 | 116 | tgi_init (); 117 | tgi_clear (); 118 | */ 119 | 120 | /*initBuffers();*/ 121 | 122 | /* 123 | blit_picture(1,1,william_pic[0]/6,william_pic[1], william_pic); 124 | */ 125 | //tgi_outtextxy (50,50,"hello"); 126 | /*tgi_setpixel(200,100); 127 | tgi_line(-10,-10,100,100); 128 | */ 129 | //tgi_line(128,96,128,128); 130 | /*glCamPosX = -24; 131 | glCamPosY = 0; 132 | glCamPosZ = 3; 133 | 134 | glCamRotZ = 64 ; 135 | glCamRotX = 2; 136 | */ 137 | /*nbPts =0 ; 138 | glNbSegments =0 ; 139 | addCube(-4, -4, 2);*/ 140 | 141 | /*glProject (points2d, points3d, nbPts, 0); 142 | for (i=0; i< 12; i+=4) { 143 | printf ("%d %d %d %d =>", 144 | points3d[i+0], 145 | points3d[i+1], 146 | points3d[i+2], 147 | points3d[i+3] 148 | ); 149 | printf ("%d %d %d %d\n", 150 | points2d[i+0], 151 | points2d[i+1], 152 | points2d[i+2], 153 | points2d[i+3] 154 | ); 155 | }*/ 156 | 157 | // addCube(4, 4, 10); 158 | //tgi_line(135,7, 128, 124); 159 | //hiresIntro(); 160 | 161 | /* 162 | //val = une_fonction(); 163 | printf("Value before glProject: %d %d %d %d \n", points2d[1]<<8+points2d[0], points2d[3]<<8+points2d[2], points2d[5]<<8+points2d[4], points2d[7]<<8+points2d[6]); 164 | 165 | 166 | glProject (points2d, points3d, nbPts, 0); 167 | aVal=*((int *)points2d); 168 | //hrDrawSegments(); 169 | printf("Value returned by glProject: %d %d %d %d %d \n", aVal, points2d[0], points2d[1], points2d[2], points2d[3]); 170 | printf("Value returned by glProject: %d %d %d %d \n", points2d[1]<<8+points2d[0], points2d[3]<<8+points2d[2], points2d[5]<<8+points2d[4], points2d[7]<<8+points2d[6]); 171 | */ 172 | /*tgi_line(points2d[1]<<8+points2d[0], points2d[3]<<8+points2d[2], points2d[5]<<8+points2d[4], points2d[7]<<8+points2d[6]);* 173 | */ 174 | cgetc(); 175 | 176 | //tgi_done(); 177 | 178 | return 0; 179 | } 180 | -------------------------------------------------------------------------------- /src/externs.c: -------------------------------------------------------------------------------- 1 | 2 | 3 | /* 4 | // Point 3D Coordinates 5 | extern int PointX; 6 | extern int PointY; 7 | extern int PointZ; 8 | 9 | // Point 2D Projected Coordinates 10 | extern char ResX; // -128 -> -127 11 | extern char ResY; 12 | 13 | // Intermediary Computation 14 | extern int DeltaX; 15 | extern int DeltaY; 16 | 17 | 18 | extern char Norm; 19 | extern char AngleH; 20 | extern char AngleV; 21 | 22 | 23 | extern int square; 24 | extern int thesqrt; 25 | 26 | extern char Numberl; 27 | extern char Numberh; 28 | 29 | extern char Squarel; 30 | extern char Squareh; 31 | 32 | extern char Square1; 33 | extern char Square2; 34 | extern char Square3; 35 | extern char Square4; 36 | 37 | // extern char N; 38 | 39 | // ATAN on 1 octant 40 | extern char ArcTang; 41 | extern char Angle; 42 | extern char Index; 43 | 44 | // ATAN2 45 | extern int TanX; 46 | extern int TanY; 47 | extern char Arctan8; 48 | extern int TmpX; 49 | extern int TmpY; 50 | //extern char Octant; 51 | extern char NegIt; 52 | extern char Ratio; 53 | 54 | // ATAN2_8 55 | extern char octant8; 56 | extern char x1; 57 | extern char x2; 58 | extern char y1; 59 | extern char y2; 60 | extern char atanres; 61 | 62 | 63 | // LINE 64 | extern char Point1X; 65 | extern char Point1Y; 66 | extern char Point2X; 67 | extern char Point2Y; 68 | extern int PosPrint; 69 | extern char char2Display; 70 | 71 | // 72 | // ===== Display.s ===== 73 | // 74 | extern unsigned char CurrentPixelX; // Coordinate X of edited pixel/byte 75 | extern unsigned char CurrentPixelY; // Coordinate Y of edited pixel/byte 76 | 77 | extern unsigned char OtherPixelX; // Coordinate X of other edited pixel/byte 78 | extern unsigned char OtherPixelY; // Coordinate Y of other edited pixel/byte 79 | 80 | */ -------------------------------------------------------------------------------- /src/fill8.c: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_C_FILL8 3 | void fill8() { 4 | 5 | prepare_bresrun(); 6 | 7 | // printf ("Dep = [%d, %d], Arr1 = [%d, %d], Arr2= [%d, %d]\n", pDepX,pDepY, pArr1X, pArr1Y, pArr2X, pArr2Y);get(); 8 | if (pDepY != pArr1Y) { 9 | //a1 = bres_agent(pDep[0],pDep[1],pArr1[0],pArr1[1]) 10 | //a2 = bres_agent(pDep[0],pDep[1],pArr2[0],pArr2[1]) 11 | A1X = pDepX; 12 | A2X = pDepX; 13 | A1Y = pDepY; 14 | A2Y = pDepY; 15 | 16 | A1destX = pArr1X; 17 | A1destY = pArr1Y; 18 | A1dX = abs(A1destX - A1X); 19 | A1dY = -abs(A1destY - A1Y); 20 | A1err = A1dX + A1dY; 21 | if ((A1err > 64) || (A1err < -63)) 22 | return; 23 | A1sX = (A1X < A1destX) ? 1 : -1; 24 | A1sY = (A1Y < A1destY) ? 1 : -1; 25 | A1arrived = ((A1X == A1destX) && (A1Y == A1destY)) ? 1 : 0; 26 | 27 | A2destX = pArr2X; 28 | A2destY = pArr2Y; 29 | A2dX = abs(A2destX - A2X); 30 | A2dY = -abs(A2destY - A2Y); 31 | A2err = A2dX + A2dY; 32 | if ((A2err > 64) || (A2err < -63)) 33 | return; 34 | 35 | A2sX = (A2X < A2destX) ? 1 : -1; 36 | A2sY = (A2Y < A2destY) ? 1 : -1; 37 | A2arrived = ((A2X == A2destX) && (A2Y == A2destY)) ? 1 : 0; 38 | 39 | mDeltaY1 = (A1Y - A1destY); 40 | mDeltaX1 = (A1X - A1destX ); 41 | mDeltaY2= (A2Y - A2destY); 42 | mDeltaX2 = (A2X - A2destX); 43 | 44 | isA1Right1 (); 45 | 46 | bresStepType1(); 47 | 48 | A1X = pArr1X; 49 | A1Y = pArr1Y; 50 | A1destX = pArr2X; 51 | A1destY = pArr2Y; 52 | A1dX = abs(A1destX - A1X); 53 | A1dY = -abs(A1destY - A1Y); 54 | A1err = A1dX + A1dY; 55 | A1sX = (A1X < A1destX) ? 1 : -1; 56 | A1sY = (A1Y < A1destY) ? 1 : -1; 57 | A1arrived = ((A1X == A1destX) && (A1Y == A1destY)) ? 1 : 0; 58 | 59 | bresStepType2(); 60 | } else { 61 | // a1 = bres_agent(pDep[0],pDep[1],pArr2[0],pArr2[1]) 62 | A1X = pDepX; 63 | A1Y = pDepY; 64 | A1destX = pArr2X; 65 | A1destY = pArr2Y; 66 | A1dX = abs(A1destX - A1X); 67 | A1dY = -abs(A1destY - A1Y); 68 | A1err = A1dX + A1dY; 69 | 70 | if ((A1err > 64) || (A1err < -63)) 71 | return; 72 | 73 | A1sX = (A1X < A1destX) ? 1 : -1; 74 | A1sY = (A1Y < A1destY) ? 1 : -1; 75 | 76 | A1arrived = ((A1X == A1destX) && (A1Y == A1destY)) ? 1 : 0; 77 | 78 | // a2 = bres_agent(pArr1[0],pArr1[1],pArr2[0],pArr2[1]) 79 | A2X = pArr1X; 80 | A2Y = pArr1Y; 81 | A2destX = pArr2X; 82 | A2destY = pArr2Y; 83 | A2dX = abs(A2destX - A2X); 84 | A2dY = -abs(A2destY - A2Y); 85 | A2err = A2dX + A2dY; 86 | 87 | if ((A2err > 64) || (A2err < -63)) 88 | return; 89 | 90 | A2sX = (A2X < A2destX) ? 1 : -1; 91 | A2sY = (A2Y < A2destY) ? 1 : -1; 92 | A2arrived = ((A2X == A2destX) && (A2Y == A2destY)) ? 1 : 0; 93 | 94 | isA1Right3(); 95 | bresStepType3() ; 96 | } 97 | } 98 | #endif // USE_C_FILL8 99 | -------------------------------------------------------------------------------- /src/fill8_bis.c: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_SATURATION 3 | #ifdef USE_C_BRESTYPE1 4 | void bresStepType1() { 5 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 6 | reachScreen (); 7 | // A1Right = (A1X > A2X); 8 | 9 | 10 | if (A1Right == 0) { 11 | initSatur_A1Left (); 12 | // printf ("bt1 A1L (%d: %d, %d) = A1XSatur=%d A2XSatur=%d\n", A1X, A2X, A1Y, A1XSatur, A2XSatur); get(); 13 | hzfill(); 14 | while ((A1arrived == 0) && (A1Y > 1)){ 15 | A1stepY_A1Left(); 16 | A2stepY_A1Left(); 17 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 18 | // A1Right = (A1X > A2X); 19 | // printf ("bt1 A1L (%d: %d, %d) = A1XSatur=%d A2XSatur=%d\n", A1X, A2X, A1Y, A1XSatur, A2XSatur); get(); 20 | hzfill(); 21 | } 22 | } else { 23 | initSatur_A1Right (); 24 | // printf ("bt1 A1R (%d: %d, %d) = A1XSatur=%d A2XSatur=%d\n", A1X, A2X, A1Y, A1XSatur, A2XSatur); get(); 25 | hzfill(); 26 | while ((A1arrived == 0) && (A1Y > 1)){ 27 | A1stepY_A1Right(); 28 | A2stepY_A1Right(); 29 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 30 | // A1Right = (A1X > A2X); 31 | // printf ("bt1 A1R (%d: %d, %d) = A1XSatur=%d A2XSatur=%d\n", A1X, A2X, A1Y, A1XSatur, A2XSatur); get(); 32 | hzfill(); 33 | } 34 | } 35 | } 36 | #endif // USE_C_BRESTYPE1 37 | 38 | 39 | #ifdef USE_C_BRESTYPE2 40 | void bresStepType2() { 41 | 42 | if (A1Right == 0) { 43 | initSatur_A1Left (); 44 | while ((A1arrived == 0) && (A2arrived == 0) && (A1Y > 1)) { 45 | A1stepY_A1Left(); 46 | A2stepY_A1Left(); 47 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 48 | // A1Right = (A1X > A2X); 49 | // printf ("bt2 A1L (%d: %d, %d) = A1XSatur=%d A2XSatur=%d\n", A1X, A2X, A1Y, A1XSatur, A2XSatur); get(); 50 | hzfill(); 51 | } 52 | } else { 53 | initSatur_A1Right (); 54 | while ((A1arrived == 0) && (A2arrived == 0) && (A1Y > 1)){ 55 | A1stepY_A1Right(); 56 | A2stepY_A1Right(); 57 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 58 | // A1Right = (A1X > A2X); 59 | // printf ("bt2 A1R (%d: %d, %d) = A1XSatur=%d A2XSatur=%d\n", A1X, A2X, A1Y, A1XSatur, A2XSatur); get(); 60 | hzfill(); 61 | } 62 | } 63 | 64 | } 65 | #endif // USE_C_BRESTYPE2 66 | 67 | #ifdef USE_C_BRESTYPE3 68 | void bresStepType3() { 69 | 70 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 71 | 72 | reachScreen (); 73 | 74 | // A1Right = (A1X > A2X); 75 | if (A1Right == 0) { 76 | initSatur_A1Left (); 77 | hzfill(); 78 | while ((A1arrived == 0) && (A2arrived == 0) && (A1Y > 1) ) { 79 | A1stepY_A1Left(); 80 | A2stepY_A1Left(); 81 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 82 | // A1Right = (A1X > A2X); 83 | hzfill(); 84 | } 85 | } else { 86 | initSatur_A1Right (); 87 | hzfill(); 88 | while ((A1arrived == 0) && (A2arrived == 0) && (A1Y > 1) ) { 89 | A1stepY_A1Right(); 90 | A2stepY_A1Right(); 91 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 92 | // A1Right = (A1X > A2X); 93 | hzfill(); 94 | } 95 | } 96 | } 97 | #endif // USE_C_BRESTYPE3 98 | 99 | #else // USE_SATURATION 100 | 101 | 102 | 103 | #ifdef USE_C_BRESTYPE1 104 | 105 | void bresStepType1() { 106 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 107 | reachScreen() ; 108 | // A1Right = (A1X > A2X); 109 | hzfill(); 110 | while ((A1arrived == 0) && (A1Y > 1)){ 111 | A1stepY(); 112 | A2stepY(); 113 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 114 | // A1Right = (A1X > A2X); 115 | hzfill(); 116 | 117 | } 118 | 119 | } 120 | #endif // USE_C_BRESTYPE1 121 | 122 | #ifdef USE_C_BRESTYPE2 123 | void bresStepType2() { 124 | // #ifdef USE_PROFILER 125 | // PROFILE_ENTER(ROUTINE_BRESRUNTYPE2); 126 | // #endif 127 | while ((A1arrived == 0) && (A2arrived == 0) && (A1Y > 1)) { 128 | A1stepY(); 129 | A2stepY(); 130 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 131 | // A1Right = (A1X > A2X); 132 | hzfill(); 133 | } 134 | 135 | } 136 | #endif // USE_C_BRESTYPE2 137 | 138 | #ifdef USE_C_BRESTYPE3 139 | 140 | void bresStepType3() { 141 | // #ifdef USE_PROFILER 142 | // PROFILE_ENTER(ROUTINE_BRESRUNTYPE3); 143 | // #endif 144 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 145 | reachScreen() ; 146 | 147 | // A1Right = (A1X > A2X); 148 | hzfill(); 149 | 150 | while ((A1arrived == 0) && (A2arrived == 0) && (A1Y > 1) ) { 151 | A1stepY(); 152 | A2stepY(); 153 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 154 | // A1Right = (A1X > A2X); 155 | hzfill(); 156 | } 157 | // #ifdef USE_PROFILER 158 | // PROFILE_LEAVE(ROUTINE_BRESRUNTYPE3); 159 | // #endif 160 | } 161 | 162 | #endif // USE_C_BRESTYPE3 163 | 164 | #endif // USE_SATURATION 165 | -------------------------------------------------------------------------------- /src/fill8_bresrun.c: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_SATURATION 3 | #ifdef USE_C_BRESTYPE1 4 | void bresStepType1() { 5 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 6 | reachScreen (); 7 | // A1Right = (A1X > A2X); 8 | 9 | 10 | if (A1Right == 0) { 11 | initSatur_A1Left (); 12 | // printf ("bt1 A1L (%d: %d, %d) = A1XSatur=%d A2XSatur=%d\n", A1X, A2X, A1Y, A1XSatur, A2XSatur); get(); 13 | hzfill(); 14 | while ((A1arrived == 0) && (A1Y > 1)){ 15 | A1stepY_A1Left(); 16 | A2stepY_A1Left(); 17 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 18 | // A1Right = (A1X > A2X); 19 | // printf ("bt1 A1L (%d: %d, %d) = A1XSatur=%d A2XSatur=%d\n", A1X, A2X, A1Y, A1XSatur, A2XSatur); get(); 20 | hzfill(); 21 | } 22 | } else { 23 | initSatur_A1Right (); 24 | // printf ("bt1 A1R (%d: %d, %d) = A1XSatur=%d A2XSatur=%d\n", A1X, A2X, A1Y, A1XSatur, A2XSatur); get(); 25 | hzfill(); 26 | while ((A1arrived == 0) && (A1Y > 1)){ 27 | A1stepY_A1Right(); 28 | A2stepY_A1Right(); 29 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 30 | // A1Right = (A1X > A2X); 31 | // printf ("bt1 A1R (%d: %d, %d) = A1XSatur=%d A2XSatur=%d\n", A1X, A2X, A1Y, A1XSatur, A2XSatur); get(); 32 | hzfill(); 33 | } 34 | } 35 | } 36 | #endif // USE_C_BRESTYPE1 37 | 38 | 39 | #ifdef USE_C_BRESTYPE2 40 | void bresStepType2() { 41 | 42 | if (A1Right == 0) { 43 | initSatur_A1Left (); 44 | while ((A1arrived == 0) && (A2arrived == 0) && (A1Y > 1)) { 45 | A1stepY_A1Left(); 46 | A2stepY_A1Left(); 47 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 48 | // A1Right = (A1X > A2X); 49 | // printf ("bt2 A1L (%d: %d, %d) = A1XSatur=%d A2XSatur=%d\n", A1X, A2X, A1Y, A1XSatur, A2XSatur); get(); 50 | hzfill(); 51 | } 52 | } else { 53 | initSatur_A1Right (); 54 | while ((A1arrived == 0) && (A2arrived == 0) && (A1Y > 1)){ 55 | A1stepY_A1Right(); 56 | A2stepY_A1Right(); 57 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 58 | // A1Right = (A1X > A2X); 59 | // printf ("bt2 A1R (%d: %d, %d) = A1XSatur=%d A2XSatur=%d\n", A1X, A2X, A1Y, A1XSatur, A2XSatur); get(); 60 | hzfill(); 61 | } 62 | } 63 | 64 | } 65 | #endif // USE_C_BRESTYPE2 66 | 67 | #ifdef USE_C_BRESTYPE3 68 | void bresStepType3() { 69 | 70 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); waitkey(); 71 | 72 | reachScreen (); 73 | 74 | // A1Right = (A1X > A2X); 75 | if (A1Right == 0) { 76 | initSatur_A1Left (); 77 | hzfill(); 78 | while ((A1arrived == 0) && (A2arrived == 0) && (A1Y > 1) ) { 79 | A1stepY_A1Left(); 80 | A2stepY_A1Left(); 81 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); waitkey(); 82 | // A1Right = (A1X > A2X); 83 | hzfill(); 84 | } 85 | } else { 86 | initSatur_A1Right (); 87 | hzfill(); 88 | while ((A1arrived == 0) && (A2arrived == 0) && (A1Y > 1) ) { 89 | A1stepY_A1Right(); 90 | A2stepY_A1Right(); 91 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 92 | // A1Right = (A1X > A2X); 93 | hzfill(); 94 | } 95 | } 96 | } 97 | #endif // USE_C_BRESTYPE3 98 | 99 | #else // USE_SATURATION 100 | 101 | 102 | 103 | #ifdef USE_C_BRESTYPE1 104 | 105 | void bresStepType1() { 106 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 107 | reachScreen() ; 108 | // A1Right = (A1X > A2X); 109 | hzfill(); 110 | while ((A1arrived == 0) && (A1Y > 1)){ 111 | A1stepY(); 112 | A2stepY(); 113 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 114 | // A1Right = (A1X > A2X); 115 | hzfill(); 116 | 117 | } 118 | 119 | } 120 | #endif // USE_C_BRESTYPE1 121 | 122 | #ifdef USE_C_BRESTYPE2 123 | void bresStepType2() { 124 | // #ifdef USE_PROFILER 125 | // PROFILE_ENTER(ROUTINE_BRESRUNTYPE2); 126 | // #endif 127 | while ((A1arrived == 0) && (A2arrived == 0) && (A1Y > 1)) { 128 | A1stepY(); 129 | A2stepY(); 130 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 131 | // A1Right = (A1X > A2X); 132 | hzfill(); 133 | } 134 | 135 | } 136 | #endif // USE_C_BRESTYPE2 137 | 138 | #ifdef USE_C_BRESTYPE3 139 | 140 | void bresStepType3() { 141 | // #ifdef USE_PROFILER 142 | // PROFILE_ENTER(ROUTINE_BRESRUNTYPE3); 143 | // #endif 144 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 145 | reachScreen() ; 146 | 147 | // A1Right = (A1X > A2X); 148 | hzfill(); 149 | 150 | while ((A1arrived == 0) && (A2arrived == 0) && (A1Y > 1) ) { 151 | A1stepY(); 152 | A2stepY(); 153 | // printf ("hf (%d: %d, %d) = %d %d\n", A1X, A2X, A1Y, distface, ch2disp); get(); 154 | // A1Right = (A1X > A2X); 155 | hzfill(); 156 | } 157 | // #ifdef USE_PROFILER 158 | // PROFILE_LEAVE(ROUTINE_BRESRUNTYPE3); 159 | // #endif 160 | } 161 | 162 | #endif // USE_C_BRESTYPE3 163 | 164 | #endif // USE_SATURATION 165 | -------------------------------------------------------------------------------- /src/fill8_c.c: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_C_FILL8 3 | void fill8() { 4 | 5 | prepare_bresrun(); 6 | 7 | // printf ("Dep = [%d, %d], Arr1 = [%d, %d], Arr2= [%d, %d]\n", pDepX,pDepY, pArr1X, pArr1Y, pArr2X, pArr2Y);waitkey(); 8 | if (pDepY != pArr1Y) { 9 | //a1 = bres_agent(pDep[0],pDep[1],pArr1[0],pArr1[1]) 10 | //a2 = bres_agent(pDep[0],pDep[1],pArr2[0],pArr2[1]) 11 | A1X = pDepX; 12 | A2X = pDepX; 13 | A1Y = pDepY; 14 | A2Y = pDepY; 15 | 16 | A1destX = pArr1X; 17 | A1destY = pArr1Y; 18 | A1dX = abs(A1destX - A1X); 19 | A1dY = -abs(A1destY - A1Y); 20 | A1err = A1dX + A1dY; 21 | if ((A1err > 64) || (A1err < -63)) 22 | return; 23 | A1sX = (A1X < A1destX) ? 1 : -1; 24 | A1sY = (A1Y < A1destY) ? 1 : -1; 25 | A1arrived = ((A1X == A1destX) && (A1Y == A1destY)) ? 1 : 0; 26 | 27 | A2destX = pArr2X; 28 | A2destY = pArr2Y; 29 | A2dX = abs(A2destX - A2X); 30 | A2dY = -abs(A2destY - A2Y); 31 | A2err = A2dX + A2dY; 32 | if ((A2err > 64) || (A2err < -63)) 33 | return; 34 | 35 | A2sX = (A2X < A2destX) ? 1 : -1; 36 | A2sY = (A2Y < A2destY) ? 1 : -1; 37 | A2arrived = ((A2X == A2destX) && (A2Y == A2destY)) ? 1 : 0; 38 | 39 | mDeltaY1 = (A1Y - A1destY); 40 | mDeltaX1 = (A1X - A1destX ); 41 | mDeltaY2= (A2Y - A2destY); 42 | mDeltaX2 = (A2X - A2destX); 43 | 44 | isA1Right1 (); 45 | 46 | bresStepType1(); 47 | 48 | A1X = pArr1X; 49 | A1Y = pArr1Y; 50 | A1destX = pArr2X; 51 | A1destY = pArr2Y; 52 | A1dX = abs(A1destX - A1X); 53 | A1dY = -abs(A1destY - A1Y); 54 | A1err = A1dX + A1dY; 55 | A1sX = (A1X < A1destX) ? 1 : -1; 56 | A1sY = (A1Y < A1destY) ? 1 : -1; 57 | A1arrived = ((A1X == A1destX) && (A1Y == A1destY)) ? 1 : 0; 58 | 59 | bresStepType2(); 60 | } else { 61 | // a1 = bres_agent(pDep[0],pDep[1],pArr2[0],pArr2[1]) 62 | A1X = pDepX; 63 | A1Y = pDepY; 64 | A1destX = pArr2X; 65 | A1destY = pArr2Y; 66 | A1dX = abs(A1destX - A1X); 67 | A1dY = -abs(A1destY - A1Y); 68 | A1err = A1dX + A1dY; 69 | 70 | if ((A1err > 64) || (A1err < -63)) 71 | return; 72 | 73 | A1sX = (A1X < A1destX) ? 1 : -1; 74 | A1sY = (A1Y < A1destY) ? 1 : -1; 75 | 76 | A1arrived = ((A1X == A1destX) && (A1Y == A1destY)) ? 1 : 0; 77 | 78 | // a2 = bres_agent(pArr1[0],pArr1[1],pArr2[0],pArr2[1]) 79 | A2X = pArr1X; 80 | A2Y = pArr1Y; 81 | A2destX = pArr2X; 82 | A2destY = pArr2Y; 83 | A2dX = abs(A2destX - A2X); 84 | A2dY = -abs(A2destY - A2Y); 85 | A2err = A2dX + A2dY; 86 | 87 | if ((A2err > 64) || (A2err < -63)) 88 | return; 89 | 90 | A2sX = (A2X < A2destX) ? 1 : -1; 91 | A2sY = (A2Y < A2destY) ? 1 : -1; 92 | A2arrived = ((A2X == A2destX) && (A2Y == A2destY)) ? 1 : 0; 93 | 94 | isA1Right3(); 95 | bresStepType3() ; 96 | } 97 | } 98 | #endif // USE_C_FILL8 99 | -------------------------------------------------------------------------------- /src/fillFace.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_C_FILLFACE 2 | void fillFace() { 3 | angle2screen(); 4 | 5 | // printf ("P1A: [%d, %d], P2A: [%d, %d], P3A [%d, %d]\n", P1AH, P1AV, P2AH, P2AV, P3AH, P3AV); 6 | // printf ("P1:[%d, %d], P2:[%d, %d], P3[%d, %d]\n", P1X, P1Y, P2X, P2Y, P3X, P3Y);waitkey(); 7 | // printf ("distface = %d char = %d\n",distface, ch2disp); 8 | // get(); 9 | 10 | // #ifdef USE_PROFILER 11 | // PROFILE_ENTER(ROUTINE_FILL8); 12 | // #endif 13 | fill8(); 14 | // #ifdef USE_PROFILER 15 | // PROFILE_LEAVE(ROUTINE_FILL8); 16 | // #endif 17 | } 18 | #endif // USE_C_FILLFACE 19 | -------------------------------------------------------------------------------- /src/geomCube.c: -------------------------------------------------------------------------------- 1 | #define CUBE_SIZE 1 2 | char geomCube []= { 3 | /* Nb Coords = */ 8, 4 | /* Nb Faces = */ 12, 5 | /* Nb Segments = */ 12, 6 | /* Nb Particles = */ 0, 7 | // Coord List : X, Y, Z, unused 8 | -CUBE_SIZE, -CUBE_SIZE, +CUBE_SIZE, 0, // P0 9 | -CUBE_SIZE, -CUBE_SIZE, -CUBE_SIZE, 0, // P1 10 | +CUBE_SIZE, -CUBE_SIZE, -CUBE_SIZE, 0, // P2 11 | +CUBE_SIZE, -CUBE_SIZE, +CUBE_SIZE, 0, // P3 12 | -CUBE_SIZE, +CUBE_SIZE, +CUBE_SIZE, 0, // P4 13 | -CUBE_SIZE, +CUBE_SIZE, -CUBE_SIZE, 0, // P5 14 | +CUBE_SIZE, +CUBE_SIZE, -CUBE_SIZE, 0, // P6 15 | +CUBE_SIZE, +CUBE_SIZE, +CUBE_SIZE, 0, // P7 16 | 17 | // Face List : idxPoint1, idxPoint2, idxPoint3, character 18 | 0, 1, 2, 77, //124, 0 19 | 0, 2, 3, 77, //92, 0 20 | 4, 5, 1, 78, //47, 0 21 | 4, 1, 0, 78, //124, 0 22 | 7, 6, 5, 79, //124, 0 23 | 7, 5, 4, 79, //124, 0 24 | 3, 2, 6, 80, //92, 0 25 | 3, 6, 7, 80, //47, 0 26 | 4, 0, 3, 81, //124, 0 27 | 4, 3, 7, 81, //124, 0 28 | 5, 1, 2, 82, //124, 0 29 | 5, 2, 6, 82, //124, 0 30 | 31 | // Segment List : idxPoint1, idxPoint2, idxPoint3, character 32 | 0, 1, 124, 0, //124, 0 33 | 1, 2, 45, 0, //92, 0 34 | 2, 3, 124, 0, //47, 0 35 | 3, 0, 45, 0, //124, 0 36 | 4, 5, 124, 0, //124, 0 37 | 5, 6, 45, 0, //124, 0 38 | 6, 7, 124, 0, //92, 0 39 | 7, 4, 45, 0, //47, 0 40 | 0, 4, 45, 0, //124, 0 41 | 1, 5, 45, 0, //124, 0 42 | 2, 6, 45, 0, //124, 0 43 | 3, 7, 45, 0 //124, 0 44 | 45 | // Particle List : idxPoint1, character 46 | }; 47 | -------------------------------------------------------------------------------- /src/geomHouse.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_COLOR 2 | #define TEXTURE_1 'b' 3 | #define TEXTURE_2 'g' 4 | #define TEXTURE_3 'y' 5 | #define TEXTURE_4 'c' 6 | #define TEXTURE_5 'm' 7 | #define TEXTURE_6 'r' 8 | #define TEXTURE_7 'f' 9 | #else 10 | #define TEXTURE_1 ',' 11 | #define TEXTURE_2 '.' 12 | #define TEXTURE_3 'u' 13 | #define TEXTURE_4 '*' 14 | #define TEXTURE_5 'o' 15 | #define TEXTURE_6 '+' 16 | #define TEXTURE_7 'x' 17 | 18 | #endif // USE_COLOR 19 | 20 | #define HOUSE_SIZE_X 12 21 | #define HOUSE_SIZE_Y 8 22 | #define HOUSE_SIZE_Z 4 23 | signed char geomHouse []= { 24 | /* Nb Coords = */ 10, 25 | /* Nb Faces = */ 11, 26 | /* Nb Segments = */ 14, 27 | /* Nb Particles = */ 0, 28 | // Coord List : X, Y, Z, unused 29 | HOUSE_SIZE_X, HOUSE_SIZE_Y, 0, 0, 30 | -HOUSE_SIZE_X, HOUSE_SIZE_Y, 0, 0, 31 | -HOUSE_SIZE_X,-HOUSE_SIZE_Y, 0, 0, 32 | HOUSE_SIZE_X,-HOUSE_SIZE_Y, 0, 0, 33 | HOUSE_SIZE_X, HOUSE_SIZE_Y, HOUSE_SIZE_Z*2, 0, 34 | -HOUSE_SIZE_X, HOUSE_SIZE_Y, HOUSE_SIZE_Z*2, 0, 35 | -HOUSE_SIZE_X,-HOUSE_SIZE_Y, HOUSE_SIZE_Z*2, 0, 36 | HOUSE_SIZE_X,-HOUSE_SIZE_Y, HOUSE_SIZE_Z*2, 0, 37 | HOUSE_SIZE_X, 0, HOUSE_SIZE_Z*3, 0, 38 | -HOUSE_SIZE_X, 0, HOUSE_SIZE_Z*3, 0, 39 | // Face List : idxPoint1, idxPoint2, idxPoint3, character 40 | 0, 1, 5, TEXTURE_6, 41 | 0, 4, 5, TEXTURE_6, 42 | 3, 2, 6, TEXTURE_6, 43 | 6, 3, 7, TEXTURE_6, 44 | 1, 2, 6, TEXTURE_5, 45 | 1, 6, 5, TEXTURE_5, 46 | 5, 6, 9, TEXTURE_5, 47 | 4, 5, 9, TEXTURE_3, 48 | 4, 9, 8, TEXTURE_3, 49 | 7, 6, 9, TEXTURE_3, 50 | 7, 9, 8, TEXTURE_3, 51 | // Segment List : idxPoint1, idxPoint2, character , unused 52 | 0, 1, '-', 0, 53 | 1, 2, '-', 0, 54 | 2, 3, '-', 0, 55 | 4, 5, '-', 0, 56 | 6, 7, '-', 0, 57 | 0, 4,'|', 0, 58 | 1, 5,'|', 0, 59 | 2, 6,'|', 0, 60 | 3, 7,'|', 0, 61 | 4, 8,'/', 0, 62 | 7, 8,'/', 0, 63 | 5, 9,'/', 0, 64 | 6, 9,'/', 0, 65 | 9, 8,'-', 0, 66 | 67 | // Particle List : idxPoint1, character 68 | }; 69 | -------------------------------------------------------------------------------- /src/geomPine.c: -------------------------------------------------------------------------------- 1 | #define TRUNC_HEIGHT 9 2 | #define PINE_WIDTH 9 3 | #define PINE_HEIGHT 27 4 | 5 | signed char geomPine []= { 6 | /* Nb Coords = */ 7, 7 | /* Nb Faces = */ 2, 8 | /* Nb Segments = */ 1, 9 | /* Nb Particles = */ 0, 10 | // Coord List : X, Y, Z, unused 11 | 0, 0, 0, 0, 12 | 0, 0, TRUNC_HEIGHT, 0, 13 | PINE_WIDTH, 0, TRUNC_HEIGHT, 0, 14 | 0, PINE_WIDTH, TRUNC_HEIGHT, 0, 15 | -PINE_WIDTH, 0, TRUNC_HEIGHT, 0, 16 | 0, -PINE_WIDTH, TRUNC_HEIGHT, 0, 17 | 0, 0, PINE_HEIGHT, 0, 18 | 19 | // Face List : idxPoint1, idxPoint2, idxPoint3, character 20 | 3, 5, 6, TEXTURE_2, 21 | 2, 4, 6, TEXTURE_2, 22 | // Segment List : idxPoint1, idxPoint2, character , unused 23 | 0, 1, '|', 0, 24 | // Particle List : idxPoint1, character 25 | 26 | }; -------------------------------------------------------------------------------- /src/geomTower.c: -------------------------------------------------------------------------------- 1 | #define TOWER_HEIGHT 3 2 | #define TOWER_SIZE_X 6 3 | #define TOWER_SIZE_Y 6 4 | #define TOWER_SIZE_Z 12 5 | char geomTower []= { 6 | /* Nb Coords = */ 9, 7 | /* Nb Faces = */ 6, //12, 8 | /* Nb Segments = */ 8, 9 | /* Nb Particles = */ 0, 10 | // Coord List : X, Y, Z, unused 11 | -TOWER_SIZE_X, -TOWER_SIZE_Y, 0, 0, 12 | -TOWER_SIZE_X, TOWER_SIZE_Y, 0, 0, 13 | TOWER_SIZE_X, TOWER_SIZE_Y, 0, 0, 14 | TOWER_SIZE_X, -TOWER_SIZE_Y, 0, 0, 15 | -TOWER_SIZE_X, -TOWER_SIZE_Y, TOWER_SIZE_Z*TOWER_HEIGHT, 0, 16 | -TOWER_SIZE_X, TOWER_SIZE_Y, TOWER_SIZE_Z*TOWER_HEIGHT, 0, 17 | TOWER_SIZE_X, TOWER_SIZE_Y, TOWER_SIZE_Z*TOWER_HEIGHT, 0, 18 | TOWER_SIZE_X, -TOWER_SIZE_Y, TOWER_SIZE_Z*TOWER_HEIGHT, 0, 19 | 0, 0, TOWER_SIZE_Z*(TOWER_HEIGHT+2), 0, 20 | // Face List : idxPoint1, idxPoint2, idxPoint3, character 21 | // 0, 3, 4, TEXTURE_1, 22 | // 3, 4, 7, TEXTURE_1, 23 | 0, 1, 4, TEXTURE_4, 24 | 1, 4, 5, TEXTURE_4, 25 | 1, 2, 5, TEXTURE_1, 26 | 2, 5, 6, TEXTURE_1, 27 | 3, 2, 7, TEXTURE_4, 28 | 2, 7, 6, TEXTURE_4, 29 | // 4, 5, 8, TEXTURE_6, 30 | // 5, 6, 8, TEXTURE_6, 31 | // 6, 7, 8, TEXTURE_6, 32 | // 7, 4, 8, TEXTURE_6, 33 | // Segment List : idxPoint1, idxPoint2, character, unused 34 | 0, 4, '|', 0, 35 | 3, 7, '|', 0, 36 | 2, 6, '|', 0, 37 | 1, 5, '|', 0, 38 | 4, 8, TEXTURE_6, 0, 39 | 5, 8, TEXTURE_6, 0, 40 | 6, 8, TEXTURE_6, 0, 41 | 7, 8, TEXTURE_6, 0, 42 | // Particle List : idxPoint1, character 43 | 44 | }; 45 | -------------------------------------------------------------------------------- /src/glDrawFaces.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_C_GLDRAWFACES 2 | 3 | void glDrawFaces() { 4 | unsigned char ii = 0; 5 | 6 | #ifdef USE_PROFILER 7 | PROFILE_ENTER(ROUTINE_GLDRAWFACES); 8 | #endif // USE_PROFILER 9 | // printf ("%d Points, %d Segments, %d Faces\n", glNbVertices, glNbSegments, glNbFaces); get(); 10 | for (ii = 0; ii < glNbFaces; ii++) { 11 | 12 | idxPt1 = glFacesPt1[ii] ; 13 | idxPt2 = glFacesPt2[ii] ; 14 | idxPt3 = glFacesPt3[ii] ; 15 | ch2disp = glFacesChar[ii]; 16 | 17 | #ifdef USE_PROFILER 18 | PROFILE_ENTER(ROUTINE_RETRIEVEFACEDATA); 19 | #endif 20 | retrieveFaceData(); 21 | #ifdef USE_PROFILER 22 | PROFILE_LEAVE(ROUTINE_RETRIEVEFACEDATA); 23 | #endif 24 | 25 | // printf ("P1 [%d, %d], P2 [%d, %d], P3 [%d %d]\n", P1AH, P1AV, P2AH, P2AV, P3AH, P3AV); get(); 26 | 27 | #ifdef USE_PROFILER 28 | PROFILE_ENTER(ROUTINE_SORTPOINTS); 29 | #endif 30 | sortPoints(); 31 | #ifdef USE_PROFILER 32 | PROFILE_LEAVE(ROUTINE_SORTPOINTS); 33 | #endif 34 | 35 | // printf ("AHs [%d, %d, %d] [%x, %x], %x], %x, %x, %x]\n", P1AH, P2AH, P3AH, m1, m2, m3, v1,v2,v3);get(); 36 | #ifdef USE_PROFILER 37 | PROFILE_ENTER(ROUTINE_GUESSIFFACEISVISIBE); 38 | #endif 39 | guessIfFace2BeDrawn(); 40 | #ifdef USE_PROFILER 41 | PROFILE_LEAVE(ROUTINE_GUESSIFFACEISVISIBE); 42 | #endif 43 | if (isFace2BeDrawn) { 44 | #ifdef USE_PROFILER 45 | PROFILE_ENTER(ROUTINE_FILLFACE); 46 | #endif 47 | fillFace(); 48 | #ifdef USE_PROFILER 49 | PROFILE_LEAVE(ROUTINE_FILLFACE); 50 | #endif 51 | } 52 | } 53 | #ifdef USE_PROFILER 54 | PROFILE_LEAVE(ROUTINE_GLDRAWFACES); 55 | #endif // USE_PROFILER 56 | 57 | } 58 | 59 | #endif // USE_C_GLDRAWFACES 60 | -------------------------------------------------------------------------------- /src/glDrawParticles.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_C_GLDRAWPARTICLES 2 | void glDrawParticles(){ 3 | unsigned char ii = 0; 4 | 5 | unsigned char idxPt, offPt, dchar; 6 | unsigned int dist; 7 | 8 | #ifdef USE_PROFILER 9 | PROFILE_ENTER(ROUTINE_GLDRAWPARTICLES); 10 | #endif // USE_PROFILER 11 | 12 | for (ii = 0; ii < glNbParticles; ii++) { 13 | idxPt = glParticlesPt[ii]; // ii*SIZEOF_SEGMENT +0 14 | ch2disp = glParticlesChar[ii]; // ii*SIZEOF_SEGMENT +2 15 | // printf ("particles : %d %d\n ", idxPt, ch2disp); 16 | dchar = points2dL[idxPt]-2 ; //FIXME : -2 to helps particle to be displayed 17 | P1X = (SCREEN_WIDTH -points2aH[idxPt]) >> 1; 18 | P1Y = (SCREEN_HEIGHT - points2aV[idxPt]) >> 1; 19 | #ifdef USE_ZBUFFER 20 | glZPlot(P1X, P1Y, dchar, ch2disp); 21 | #else 22 | // TODO : plot a point with no z-buffer 23 | plot(A1X, A1Y, ch2disp); 24 | #endif 25 | 26 | } 27 | #ifdef USE_PROFILER 28 | PROFILE_LEAVE(ROUTINE_GLDRAWPARTICLES); 29 | #endif // USE_PROFILER 30 | 31 | } 32 | #endif // USE_C_GLDRAWPARTICLES 33 | -------------------------------------------------------------------------------- /src/glDrawParticles.s: -------------------------------------------------------------------------------- 1 | #ifdef USE_ASM_GLDRAWPARTICLES 2 | ;; void glDrawParticles(){ 3 | _glDrawParticles: 4 | .( 5 | ;; unsigned char ii = 0; 6 | #ifdef SAFE_CONTEXT 7 | lda reg5 : pha 8 | #endif ;; SAFE_CONTEXT 9 | 10 | ldy _glNbParticles 11 | jmp glDrawParticles_nextParticle 12 | ;; for (ii = 0; ii < glNbParticles; ii++) { 13 | 14 | glDrawParticles_loop: 15 | 16 | ;; idxPt1 = glParticlesPt[ii]; ;; ii*SIZEOF_SEGMENT +0 17 | lda _glParticlesPt,y : sta _idxPt1 18 | ;; ch2disp = glParticlesChar[ii]; ;; ii*SIZEOF_SEGMENT +2 19 | lda _glParticlesChar,y : sta _ch2disp 20 | 21 | sty reg5 : ldy _idxPt1 22 | ;; dchar = points2dL[idxPt]-2 ; ;;FIXME : -2 to helps particle to be displayed 23 | lda _points2dL,y : sta _distpoint 24 | 25 | ;; P1X = (SCREEN_WIDTH -points2aH[idxPt]) >> 1; 26 | sec : lda #SCREEN_WIDTH : sbc _points2aH,y : cmp #$80 : ror 27 | sta _plotX 28 | 29 | ;; P1Y = (SCREEN_HEIGHT - points2aV[idxPt]) >> 1; 30 | sec : lda #SCREEN_HEIGHT : sbc _points2aV,y : cmp #$80 : ror 31 | sta _plotY 32 | 33 | #ifdef USE_ZBUFFER 34 | ;; glZPlot(P1X, P1Y, dchar, ch2disp); 35 | jsr _fastzplot 36 | #else 37 | ;; ;; TODO : plot a point with no z-buffer 38 | ;; plot(A1X, A1Y, ch2disp); 39 | #endif 40 | ldy reg5 41 | glDrawParticles_nextParticle: 42 | dey 43 | bmi glDrawParticles_done 44 | jmp glDrawParticles_loop 45 | ;; } 46 | 47 | glDrawParticles_done: 48 | 49 | #ifdef SAFE_CONTEXT 50 | ;; Restore context 51 | pla : sta reg5 52 | #endif ;; SAFE_CONTEXT 53 | ;; } 54 | .) 55 | rts 56 | #endif ;; USE_ASM_GLDRAWPARTICLES 57 | -------------------------------------------------------------------------------- /src/glDrawSegments.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_C_GLDRAWSEGMENTS 2 | void glDrawSegments() { 3 | unsigned char ii = 0; 4 | 5 | #ifdef USE_PROFILER 6 | PROFILE_ENTER(ROUTINE_GLDRAWSEGMENTS); 7 | #endif // USE_PROFILER 8 | 9 | for (ii = 0; ii < glNbSegments; ii++) { 10 | 11 | idxPt1 = glSegmentsPt1[ii]; 12 | idxPt2 = glSegmentsPt2[ii]; 13 | ch2disp = glSegmentsChar[ii]; 14 | 15 | // dmoy = (d1+d2)/2; 16 | 17 | #ifdef ANGLEONLY 18 | P1AH = points2aH[idxPt1]; 19 | P1AV = points2aV[idxPt1]; 20 | #else 21 | P1X = points2aH[idxPt1]; 22 | P1Y = points2aV[idxPt1]; 23 | #endif 24 | dmoy = points2dL[idxPt1]; 25 | 26 | 27 | #ifdef ANGLEONLY 28 | P2AH = points2aH[idxPt2]; 29 | P2AV = points2aV[idxPt2]; 30 | #else 31 | P2X = points2aH[idxPt2]; 32 | P2Y = points2aV[idxPt2]; 33 | #endif 34 | dmoy += points2dL[idxPt2]; 35 | 36 | dmoy = dmoy >> 1; 37 | 38 | 39 | //if (dmoy >= 256) { 40 | if ((dmoy & 0xFF00) != 0) 41 | continue; 42 | distseg = (unsigned char)((dmoy)&0x00FF); 43 | distseg--; // FIXME 44 | 45 | #ifdef ANGLEONLY 46 | P1X = (SCREEN_WIDTH - P1AH) >> 1; 47 | P1Y = (SCREEN_HEIGHT - P1AV) >> 1; 48 | P2X = (SCREEN_WIDTH - P2AH) >> 1; 49 | P2Y = (SCREEN_HEIGHT - P2AV) >> 1; 50 | #endif 51 | // printf ("dl ([%d, %d] , [%d, %d] => %d c=%d\n", P1X, P1Y, P2X, P2Y, distseg, ch2disp); waitkey(); 52 | lrDrawLine(); 53 | } 54 | #ifdef USE_PROFILER 55 | PROFILE_LEAVE(ROUTINE_GLDRAWSEGMENTS); 56 | #endif // USE_PROFILER 57 | } 58 | 59 | #endif // USE_C_GLDRAWSEGMENTS 60 | -------------------------------------------------------------------------------- /src/glDrawSegments.s: -------------------------------------------------------------------------------- 1 | #ifdef USE_ASM_GLDRAWSEGMENTS 2 | ;;void glDrawSegments() { 3 | _glDrawSegments: 4 | .( 5 | #ifdef USE_PROFILER 6 | PROFILE_ENTER(ROUTINE_GLDRAWSEGMENTS); 7 | #endif ;; USE_PROFILER 8 | 9 | #ifdef SAFE_CONTEXT 10 | ;; Save context 11 | pha:txa:pha:tya:pha 12 | lda reg3 : pha 13 | #endif ;; SAFE_CONTEXT 14 | 15 | ldy _glNbSegments 16 | jmp glDrawSegments_nextSegment 17 | ;; for (ii = 0; ii < glNbSegments; ii++) { 18 | 19 | glDrawSegments_loop: 20 | 21 | ;; idxPt1 = glSegmentsPt1[ii]; 22 | lda _glSegmentsPt1,y : sta _idxPt1 23 | ;; idxPt2 = glSegmentsPt2[ii]; 24 | lda _glSegmentsPt2,y : sta _idxPt2 25 | ;; ch2disp = glSegmentsChar[ii]; 26 | lda _glSegmentsChar,y : sta _ch2disp 27 | 28 | ;; ;; dmoy = (d1+d2)/2; 29 | sty reg3 30 | ldy _idxPt1 31 | #ifdef ANGLEONLY 32 | ;; P1AH = points2aH[idxPt1]; 33 | lda _points2aH, y : sta _P1AH 34 | ;; P1AV = points2aV[idxPt1]; 35 | lda _points2aV, y : sta _P1AV 36 | #else 37 | ;; P1X = points2aH[idxPt1]; 38 | lda _points2aH, y : sta _P1X 39 | ;; P1Y = points2aV[idxPt1]; 40 | lda _points2aV, y : sta _P1Y 41 | #endif 42 | ;; dmoy = points2dL[idxPt1]; 43 | lda _points2dL,y : sta _dmoy: lda _points2dH,y : sta _dmoy+1 44 | 45 | ldy _idxPt2 46 | #ifdef ANGLEONLY 47 | ;; P2AH = points2aH[idxPt2]; 48 | lda _points2aH, y : sta _P2AH 49 | ;; P2AV = points2aV[idxPt2]; 50 | lda _points2aV, y : sta _P2AV 51 | #else 52 | ;; P2X = points2aH[idxPt2]; 53 | lda _points2aH, y : sta _P2X 54 | ;; P2Y = points2aV[idxPt2]; 55 | lda _points2aV, y : sta _P2Y 56 | #endif 57 | ;; dmoy += points2dL[idxPt2]; 58 | clc: lda _points2dL,y : adc _dmoy: sta _dmoy : lda _points2dH,y : adc _dmoy+1 :sta _dmoy+1 59 | 60 | ;; dmoy = dmoy >> 1; 61 | ;; ;;if (dmoy >= 256) { 62 | ;; if ((dmoy & 0xFF00) != 0) 63 | ;; continue; 64 | lda _dmoy+1 65 | 66 | beq moynottoobig ;; FIXME :: it should be possible to deal with case *(dmoy+1) = 1 67 | lda #$FF 68 | sta _distseg 69 | bne glDrawSegments_drawline 70 | moynottoobig: 71 | lda _dmoy 72 | lsr 73 | sta _distseg 74 | ;; distseg = (unsigned char)((dmoy)&0x00FF); 75 | ;; distseg--; ;; FIXME 76 | 77 | glDrawSegments_drawline: 78 | dec _distseg 79 | 80 | #ifdef ANGLEONLY 81 | ;; P1X = (SCREEN_WIDTH - P1AH) >> 1; 82 | sec 83 | lda #SCREEN_WIDTH 84 | sbc _P1AH 85 | cmp #$80 86 | ror 87 | sta _P1X 88 | 89 | ;; P1Y = (SCREEN_HEIGHT - P1AV) >> 1; 90 | sec 91 | lda #SCREEN_HEIGHT 92 | sbc _P1AV 93 | cmp #$80 94 | ror 95 | sta _P1Y 96 | 97 | ;; P2X = (SCREEN_WIDTH - P2AH) >> 1; 98 | sec 99 | lda #SCREEN_WIDTH 100 | sbc _P2AH 101 | cmp #$80 102 | ror 103 | sta _P2X 104 | ;; P2Y = (SCREEN_HEIGHT - P2AV) >> 1; 105 | sec 106 | lda #SCREEN_HEIGHT 107 | sbc _P2AV 108 | cmp #$80 109 | ror 110 | sta _P2Y 111 | #endif 112 | ;; lrDrawLine(); 113 | jsr _lrDrawLine 114 | 115 | ldy reg3 116 | 117 | glDrawSegments_nextSegment: 118 | dey 119 | bmi glDrawSegments_done 120 | jmp glDrawSegments_loop 121 | ;; } 122 | 123 | glDrawSegments_done: 124 | #ifdef SAFE_CONTEXT 125 | ;; Restore context 126 | pla : sta reg3 127 | pla:tay:pla:tax:pla 128 | #endif ;; SAFE_CONTEXT 129 | 130 | #ifdef USE_PROFILER 131 | PROFILE_LEAVE(ROUTINE_GLDRAWSEGMENTS); 132 | #endif ;; USE_PROFILER 133 | .) 134 | rts 135 | #endif ;; USE_ASM_GLDRAWSEGMENTS 136 | -------------------------------------------------------------------------------- /src/glInitScreenBuffers.c: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_C_INITFRAMEBUFFER 3 | void glInitScreenBuffers() { 4 | #ifdef USE_COLOR 5 | int ii, jj; 6 | #endif 7 | memset(zbuffer, 0xFF, SCREEN_WIDTH * SCREEN_HEIGHT); 8 | 9 | #ifdef USE_COLOR 10 | for (ii=0; ii< SCREEN_HEIGHT; ii++){ 11 | for (jj=3; jj< SCREEN_WIDTH; jj++){ 12 | fbuffer[ii*SCREEN_WIDTH+jj] = 0x20; 13 | } 14 | } 15 | #else 16 | memset(fbuffer, 0x20, SCREEN_WIDTH * SCREEN_HEIGHT); // Space 17 | #endif 18 | } 19 | #endif // USE_C_INITFRAMEBUFFER 20 | -------------------------------------------------------------------------------- /src/glOric.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef GLORIC_H 3 | #define GLORIC_H 4 | 5 | 6 | extern void glProject (char *tabpoint2D, char *tabpoint3D, unsigned char glNbVertices, unsigned char options); 7 | 8 | // Camera Position 9 | extern signed char glCamPosX; 10 | extern signed char glCamPosY; 11 | extern signed char glCamPosZ; 12 | 13 | // Camera Orientation 14 | extern signed char glCamRotZ; // -128 -> 127 unit : 2PI/(2^8 - 1) 15 | extern signed char glCamRotX; 16 | 17 | // Geometry buffers ; 18 | extern unsigned char glNbVertices; 19 | extern unsigned char glNbFaces; 20 | extern unsigned char glNbSegments; 21 | extern unsigned char glNbParticles; 22 | 23 | #endif -------------------------------------------------------------------------------- /src/glOric.s: -------------------------------------------------------------------------------- 1 | 2 | #include "config.h" 3 | 4 | .zero 5 | 6 | #ifdef SAVE_ZERO_PAGE 7 | .text 8 | #endif 9 | 10 | #include "camera.s" 11 | 12 | #include "projection.s" 13 | 14 | #include "scene.s" 15 | 16 | 17 | #ifndef SAVE_ZERO_PAGE 18 | .text 19 | #endif 20 | 21 | 22 | 23 | #include "temp.s" 24 | 25 | 26 | #include "glProject_s.s" 27 | 28 | #include "lrDrawLine.s" -------------------------------------------------------------------------------- /src/glOric_c.c: -------------------------------------------------------------------------------- 1 | 2 | #include "config.h" 3 | #ifdef TARGET_ORIX 4 | #include 5 | #include 6 | #include 7 | #else 8 | #include "lib.h" 9 | #endif // TARGET_ORIX 10 | 11 | #include "glOric_h.h" 12 | 13 | #define max(a,b) (((a) > (b)) ? (a) : (b)) 14 | #define min(a,b) (((a) < (b)) ? (a) : (b)) 15 | #define abs(x) (((x)<0)?-(x):(x)) 16 | 17 | // from temp.(asm|s) 18 | 19 | extern unsigned char idxPt1, idxPt2, idxPt3; 20 | extern int d1, d2, d3; 21 | extern int dmoy; 22 | 23 | extern unsigned char idxPt1, idxPt2, idxPt3; 24 | 25 | extern unsigned char m1, m2, m3; 26 | extern unsigned char v1, v2, v3; 27 | extern unsigned char isFace2BeDrawn; 28 | 29 | // from 30 | 31 | extern signed char A1X; 32 | extern signed char A1Y; 33 | extern signed char A1destX; 34 | extern signed char A1destY; 35 | extern signed char A1dX; 36 | extern signed char A1dY; 37 | extern signed char A1err; 38 | extern signed char A1sX; 39 | extern signed char A1sY; 40 | extern char A1arrived; 41 | 42 | extern signed char A2X; 43 | extern signed char A2Y; 44 | extern signed char A2destX; 45 | extern signed char A2destY; 46 | extern signed char A2dX; 47 | extern signed char A2dY; 48 | extern signed char A2err; 49 | extern signed char A2sX; 50 | extern signed char A2sY; 51 | extern char A2arrived; 52 | 53 | extern unsigned char A1Right; 54 | extern unsigned char distface; 55 | extern unsigned char distseg; 56 | extern char ch2disp; 57 | extern signed char P1X, P1Y, P2X, P2Y, P3X, P3Y; 58 | extern signed char P1AH, P1AV, P2AH, P2AV, P3AH, P3AV; 59 | 60 | extern unsigned char log2_tab[]; 61 | extern signed char mDeltaY1, mDeltaX1, mDeltaY2, mDeltaX2; 62 | 63 | extern signed char pDepX; 64 | extern signed char pDepY; 65 | extern signed char pArr1X; 66 | extern signed char pArr1Y; 67 | extern signed char pArr2X; 68 | extern signed char pArr2Y; 69 | 70 | extern unsigned char lineIndex; 71 | extern unsigned char departX; 72 | extern unsigned char finX; 73 | extern signed char hLineLength; 74 | 75 | #ifdef USE_SATURATION 76 | extern unsigned char A1XSatur; 77 | extern unsigned char A2XSatur; 78 | #endif // USE_SATURATION 79 | 80 | 81 | extern unsigned char zbuffer[]; // z-depth buffer SCREEN_WIDTH * SCREEN_HEIGHT 82 | extern char fbuffer[]; // frame buffer SCREEN_WIDTH * SCREEN_HEIGHT 83 | 84 | 85 | // void waitkey(){ 86 | // #ifdef TARGET_ORIX 87 | // cgetc(); 88 | // #else 89 | // get(); 90 | // #endif 91 | // } 92 | 93 | #include "glInitScreenBuffers.c" 94 | 95 | #include "glProject.c" 96 | 97 | #include "retrieveFaceData.c" 98 | #include "sortPoints.c" 99 | #include "guessIfFace2BeDrawn.c" 100 | #include "angle2screen.c" 101 | #include "prepareBresrun.c" 102 | #include "isA1Right.c" 103 | #include "satur.c" 104 | #include "agent.c" 105 | #include "reachScreen.c" 106 | #include "hzfill_c.c" 107 | #include "fill8_bresrun.c" 108 | #include "fill8_c.c" 109 | #include "fillFace.c" 110 | #include "glDrawFaces.c" 111 | 112 | 113 | #include "zplot_c.c" 114 | #include "lrDrawLine.c" 115 | #include "glDrawSegments.c" 116 | 117 | #include "glDrawParticles.c" 118 | 119 | #include "buffer2screen.c" 120 | 121 | 122 | 123 | // void change_char(char c, unsigned char patt01, unsigned char patt02, unsigned char patt03, unsigned char patt04, unsigned char patt05, unsigned char patt06, unsigned char patt07, unsigned char patt08) { 124 | // unsigned char* adr; 125 | // adr = (unsigned char*)(0xB400 + c * 8); 126 | // *(adr++) = patt01; 127 | // *(adr++) = patt02; 128 | // *(adr++) = patt03; 129 | // *(adr++) = patt04; 130 | // *(adr++) = patt05; 131 | // *(adr++) = patt06; 132 | // *(adr++) = patt07; 133 | // *(adr++) = patt08; 134 | // } 135 | 136 | 137 | -------------------------------------------------------------------------------- /src/glOric_h.h: -------------------------------------------------------------------------------- 1 | /* 2 | * glOric by Jean-Baptiste PERIN 3 | * 4 | */ 5 | #ifndef GLORIC_H 6 | #define GLORIC_H 7 | 8 | #include "config.h" 9 | 10 | /* ___ 11 | * / __\ __ _ _ __ ___ ___ _ __ __ _ 12 | * / / / _` || '_ ` _ \ / _ \| '__| / _` | 13 | * / /___ | (_| || | | | | || __/| | | (_| | 14 | * \____/ \__,_||_| |_| |_| \___||_| \__,_| 15 | */ 16 | 17 | // Camera Position 18 | extern signed char glCamPosX; 19 | extern signed char glCamPosY; 20 | extern signed char glCamPosZ; 21 | 22 | // Camera Orientation 23 | extern signed char glCamRotZ; // -128 -> -127 unit : 2PI/(2^8 - 1) 24 | extern signed char glCamRotX; 25 | 26 | /* ___ _ _ _ 27 | * / _ \ _ __ ___ (_) ___ ___ | |_ (_) ___ _ __ 28 | * / /_)/| '__| / _ \ | | / _ \ / __|| __|| | / _ \ | '_ \ 29 | * / ___/ | | | (_) | | || __/| (__ | |_ | || (_) || | | | 30 | * \/ |_| \___/ _/ | \___| \___| \__||_| \___/ |_| |_| 31 | * |__/ 32 | */ 33 | 34 | extern unsigned char projOptions; 35 | extern unsigned char glNbVertices; 36 | 37 | extern signed char glVerticesX [NB_MAX_VERTICES]; 38 | extern signed char glVerticesY [NB_MAX_VERTICES]; 39 | extern signed char glVerticesZ [NB_MAX_VERTICES]; 40 | 41 | extern signed char points2aH [NB_MAX_VERTICES]; 42 | extern signed char points2aV [NB_MAX_VERTICES]; 43 | extern unsigned char points2dH [NB_MAX_VERTICES]; 44 | extern unsigned char points2dL [NB_MAX_VERTICES]; 45 | 46 | extern void glProjectArrays(); 47 | 48 | extern void glProjectPoint(signed char x, signed char y, signed char z, signed char options, signed char *ah, signed char *av, unsigned int *dist); 49 | 50 | /* __ 51 | * / _\ ___ ___ _ __ ___ 52 | * \ \ / __| / _ \| '_ \ / _ \ 53 | * _\ \ / (__ | __/| | | || __/ 54 | * \__/ \___| \___||_| |_| \___| 55 | */ 56 | 57 | extern unsigned char glNbParticles; 58 | extern unsigned char glNbSegments; 59 | extern unsigned char glNbFaces; 60 | 61 | extern unsigned char glParticlesPt [NB_MAX_PARTICLES]; 62 | extern unsigned char glParticlesChar [NB_MAX_PARTICLES]; 63 | 64 | extern unsigned char glSegmentsPt1 [NB_MAX_SEGMENTS]; 65 | extern unsigned char glSegmentsPt2 [NB_MAX_SEGMENTS]; 66 | extern unsigned char glSegmentsChar[NB_MAX_SEGMENTS]; 67 | 68 | extern unsigned char glFacesPt1 [NB_MAX_FACES]; 69 | extern unsigned char glFacesPt2 [NB_MAX_FACES]; 70 | extern unsigned char glFacesPt3 [NB_MAX_FACES]; 71 | extern unsigned char glFacesChar [NB_MAX_FACES]; 72 | 73 | extern void glDrawFaces(); 74 | extern void glDrawSegments(); 75 | extern void glDrawParticles(); 76 | extern void glInitScreenBuffers(); 77 | extern void glBuffer2Screen(); 78 | #endif // GLORIC_H 79 | -------------------------------------------------------------------------------- /src/glOric_s.s: -------------------------------------------------------------------------------- 1 | #include "config.h" 2 | 3 | #include "camera.s" 4 | 5 | #include "math/atan2.s" 6 | #include "math/norm.s" 7 | #include "glProjectPoint.s" 8 | 9 | #include "projection.s" 10 | 11 | #include "scene.s" 12 | 13 | #include "raster/angle2screen.s" 14 | // _angle2screen 15 | #include "raster/prepareBresrun.s" 16 | // _prepare_bresrun 17 | #include "raster/isA1Right.s" 18 | // _isA1Right1 19 | // _isA1Right3 20 | #include "raster/reachScreen.s" 21 | // _reachScreen 22 | #include "raster/hzfill.s" 23 | #include "raster/fill8_bis.s" 24 | // _A1stepY 25 | // _A2stepY 26 | // _hfill 27 | // _fill8 28 | // _bresStepType1 29 | // _bresStepType2 30 | // _bresStepType3 31 | #include "raster/fillFace.s" 32 | // _fillFace 33 | #include "temp.s" 34 | 35 | #include "render/zbuff.s" 36 | #include "raster/raster8.s" 37 | #include "render/face.s" 38 | // glDrawFaces 39 | // sortPoints 40 | // guessIfFace2BeDrawn 41 | // retrieveFaceData 42 | 43 | // SEGMENTS 44 | #include "util/print.s" 45 | #include "lrDrawLine.s" 46 | #include "glDrawSegments.s" 47 | 48 | #include "glDrawParticles.s" 49 | 50 | #include "kernel.s" 51 | #include "glProject_s.s" 52 | #include "util/screen.s" -------------------------------------------------------------------------------- /src/glProject.c: -------------------------------------------------------------------------------- 1 | 2 | 3 | #ifdef USE_C_ARRAYSPROJECT 4 | void glProjectArrays(){ 5 | unsigned char ii; 6 | signed char x, y, z; 7 | signed char ah, av; 8 | unsigned int dist ; 9 | unsigned char options=0; 10 | 11 | for (ii = 0; ii < glNbVertices; ii++){ 12 | x = glVerticesX[ii]; 13 | y = glVerticesY[ii]; 14 | z = glVerticesZ[ii]; 15 | 16 | glProjectPoint(x, y, z, options, &ah, &av, &dist); 17 | 18 | points2aH[ii] = ah; 19 | points2aV[ii] = av; 20 | points2dH[ii] = (signed char)((dist & 0xFF00)>>8) && 0x00FF; 21 | points2dL[ii] = (signed char) (dist & 0x00FF); 22 | 23 | } 24 | } 25 | #endif // USE_C_ARRAYSPROJECT -------------------------------------------------------------------------------- /src/glProjectArrays.s: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_ASM_ARRAYSPROJECT 3 | _glProjectArrays: 4 | .( 5 | ;; for (ii = 0; ii < glNbVertices; ii++){ 6 | ldy _glNbVertices 7 | glProjectArrays_loop: 8 | dey 9 | bmi glProjectArrays_done 10 | ;; x = glVerticesX[ii]; 11 | lda _glVerticesX, y 12 | sta _PointX 13 | ;; y = glVerticesY[ii]; 14 | lda _glVerticesY, y 15 | sta _PointY 16 | ;; z = glVerticesZ[ii]; 17 | lda _glVerticesZ, y 18 | sta _PointZ 19 | 20 | ;; glProjectPoint(x, y, z, options, &ah, &av, &dist); 21 | jsr _project_i8o8 : 22 | 23 | ;; points2aH[ii] = ah; 24 | lda _ResX 25 | sta _points2aH, y 26 | ;; points2aV[ii] = av; 27 | lda _ResY 28 | sta _points2aV, y 29 | ;; points2dH[ii] = (signed char)((dist & 0xFF00)>>8) && 0x00FF; 30 | lda _Norm+1 31 | sta _points2dH, y 32 | ;; points2dL[ii] = (signed char) (dist & 0x00FF); 33 | lda _Norm 34 | sta _points2dL, y 35 | 36 | ;; } 37 | jmp glProjectArrays_loop 38 | glProjectArrays_done: 39 | .) 40 | rts 41 | #endif ;; USE_ASM_ARRAYSPROJECT 42 | 43 | -------------------------------------------------------------------------------- /src/glProject_s.s: -------------------------------------------------------------------------------- 1 | 2 | .zero 3 | 4 | ptrpt3: 5 | ptrpt3L .dsb 1 6 | ptrpt3H .dsb 1 7 | ptrpt2: 8 | ptrpt2L .dsb 1 9 | ptrpt2H .dsb 1 10 | 11 | 12 | #ifdef SAVE_ZERO_PAGE 13 | .text 14 | #else 15 | .zero 16 | #endif 17 | 18 | nbPoints .dsb 1 19 | pOptions .dsb 1 20 | 21 | .text 22 | 23 | 24 | ;; void doFastProjection(){ 25 | _doFastProjection: 26 | .( 27 | ;; unsigned char ii = 0; 28 | 29 | ;; for (ii = glNbVertices-1; ii< 0; ii--){ 30 | 31 | ldx _glNbVertices 32 | dex 33 | txa ; ii = glNbVertices - 1 34 | asl 35 | asl ; ii * SIZEOF_3DPOINT (4) 36 | clc 37 | adc #$03 38 | tay 39 | 40 | ldx _glNbVertices 41 | dex 42 | txa ; ii = glNbVertices - 1 43 | asl 44 | asl ; ii * SIZEOF_2DPOINT (4) 45 | clc 46 | adc #$03 47 | tax 48 | 49 | dofastprojloop: 50 | ;; Status = points3d[ii*SIZEOF_3DPOINT + 3] 51 | dey 52 | ;; PointZ = points3d[ii*SIZEOF_3DPOINT + 2]; 53 | lda (ptrpt3),y 54 | sta _PointZ 55 | dey 56 | ;; PointY = points3d[ii*SIZEOF_3DPOINT + 1]; 57 | lda (ptrpt3),y 58 | sta _PointY 59 | dey 60 | ;; PointX = points3d[ii*SIZEOF_3DPOINT + 0]; 61 | lda (ptrpt3),y 62 | sta _PointX 63 | dey 64 | 65 | ;; project_i16(); 66 | ; jsr _project_i16 67 | jsr _project_i8o8 68 | 69 | tya 70 | pha 71 | txa 72 | tay 73 | 74 | #ifndef HRSDEMO 75 | ;; points2d[ii*SIZEOF_2DPOINT + 1] = ResY; 76 | 77 | lda _Norm+1 78 | sta (ptrpt2), y 79 | dey 80 | 81 | lda _Norm 82 | sta (ptrpt2), y 83 | dey 84 | 85 | lda _ResY 86 | sta (ptrpt2), y 87 | ;; points2d[ii*SIZEOF_2DPOINT + 0] = ResX; 88 | dey 89 | lda _ResX 90 | sta (ptrpt2), y 91 | 92 | #else 93 | lda _ResY+1 94 | sta (ptrpt2), y 95 | dey 96 | 97 | lda _ResY 98 | sta (ptrpt2), y 99 | dey 100 | 101 | lda _ResX+1 102 | sta (ptrpt2), y 103 | ;; points2d[ii*SIZEOF_2DPOINT + 0] = ResX; 104 | dey 105 | lda _ResX 106 | sta (ptrpt2), y 107 | 108 | #endif 109 | tya 110 | tax 111 | pla 112 | tay 113 | ;; } 114 | dex 115 | txa 116 | cmp #$FF 117 | bne dofastprojloop ;; FIXME : does not allows more than 127 points 118 | dofastprojdone: 119 | ;; } 120 | .) 121 | rts 122 | 123 | 124 | 125 | 126 | ;; void glProject (char *tabpoint2D, char *tabpoint3D, unsigned char glNbVertices, unsigned char options); 127 | _glProject 128 | .( 129 | ldx #6 : lda #4 : jsr enter : 130 | ldy #0 : lda (ap),y : sta reg0 : sta ptrpt2L : iny : lda (ap),y : sta reg0+1 : sta ptrpt2H : 131 | ldy #2 : lda (ap),y : sta reg0 : sta ptrpt3L : iny : lda (ap),y : sta reg0+1 : sta ptrpt3H : 132 | ldy #4 : lda (ap),y : sta tmp0 : sta nbPoints ; iny : lda (ap),y : sta tmp0+1 : 133 | ldy #6 : lda (ap),y : sta tmp0 : sta pOptions ; iny : lda (ap),y : sta tmp0+1 : 134 | 135 | jsr _doFastProjection 136 | jmp leave : 137 | .) 138 | 139 | -------------------------------------------------------------------------------- /src/guessIfFace2BeDrawn.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_C_GUESSIFFACE2BEDRAWN 2 | void guessIfFace2BeDrawn () { 3 | 4 | m1 = P1AH & ANGLE_MAX; 5 | m2 = P2AH & ANGLE_MAX; 6 | m3 = P3AH & ANGLE_MAX; 7 | v1 = P1AH & ANGLE_VIEW; 8 | v2 = P2AH & ANGLE_VIEW; 9 | v3 = P3AH & ANGLE_VIEW; 10 | 11 | isFace2BeDrawn = 0; 12 | if ((m1 == 0x00) || (m1 == ANGLE_MAX)) { 13 | if ((v1 == 0x00) || (v1 == ANGLE_VIEW)) { 14 | if ( 15 | ( 16 | (P1AH & 0x80) != (P2AH & 0x80)) || 17 | ((P1AH & 0x80) != (P3AH & 0x80))) { 18 | if ((abs(P3AH) < 127 - abs(P1AH))) { 19 | isFace2BeDrawn=1; 20 | } 21 | } else { 22 | isFace2BeDrawn=1; 23 | } 24 | } else { 25 | // P1 FRONT 26 | if ((m2 == 0x00) || (m2 == ANGLE_MAX)) { 27 | // P2 FRONT 28 | if ((m3 == 0x00) || (m3 == ANGLE_MAX)) { 29 | // P3 FRONT 30 | // _4_ 31 | if (((P1AH & 0x80) != (P2AH & 0x80)) || ((P1AH & 0x80) != (P3AH & 0x80))) { 32 | isFace2BeDrawn=1; 33 | } else { 34 | // nothing to do 35 | } 36 | } else { 37 | // P3 BACK 38 | // _3_ 39 | if ((P1AH & 0x80) != (P2AH & 0x80)) { 40 | if (abs(P2AH) < 127 - abs(P1AH)) { 41 | isFace2BeDrawn=1; 42 | } 43 | } else { 44 | if ((P1AH & 0x80) != (P3AH & 0x80)) { 45 | if (abs(P3AH) < 127 - abs(P1AH)) { 46 | isFace2BeDrawn=1; 47 | } 48 | } 49 | } 50 | 51 | if ((P1AH & 0x80) != (P3AH & 0x80)) { 52 | if (abs(P3AH) < 127 - abs(P1AH)) { 53 | isFace2BeDrawn=1; 54 | } 55 | } 56 | } 57 | } else { 58 | // P2 BACK 59 | // _2_ nothing to do 60 | if ((P1AH & 0x80) != (P2AH & 0x80)) { 61 | if (abs(P2AH) < 127 - abs(P1AH)) { 62 | isFace2BeDrawn=1; 63 | } 64 | } else { 65 | if ((P1AH & 0x80) != (P3AH & 0x80)) { 66 | if (abs(P3AH) < 127 - abs(P1AH)) { 67 | isFace2BeDrawn=1; 68 | } 69 | } 70 | } 71 | 72 | if ((P1AH & 0x80) != (P3AH & 0x80)) { 73 | if (abs(P3AH) < 127 - abs(P1AH)) { 74 | isFace2BeDrawn=1; 75 | } 76 | } 77 | } 78 | } 79 | } else { 80 | // P1 BACK 81 | // _1_ nothing to do 82 | } 83 | } 84 | #endif // USE_C_GUESSIFFACE2BEDRAWN 85 | -------------------------------------------------------------------------------- /src/hrsDemo.c: -------------------------------------------------------------------------------- 1 | 2 | #include "config.h" 3 | //#include "glOric.h" 4 | #include "glOric_h.h" 5 | 6 | #ifdef HRSDEMO 7 | 8 | // #include "data\geom.h" 9 | #include "data\traj.h" 10 | 11 | /* 12 | * GEOMETRY BUFFERS 13 | */ 14 | 15 | extern char points3d[]; // NB_MAX_VERTICES * SIZEOF_3DPOINT 16 | unsigned char nbPts = 0; 17 | extern char points2d[]; // NB_MAX_VERTICES * SIZEOF_2DPOINT 18 | extern char faces[]; 19 | extern unsigned char glNbFaces; 20 | extern unsigned char segments[]; 21 | extern unsigned char glNbSegments; 22 | extern unsigned char particles[]; 23 | extern unsigned char glNbParticles; 24 | 25 | void hiresIntro(); 26 | void hiresGameLoop(); 27 | void hrDrawFaces(); 28 | 29 | 30 | #include "addGeom.c" 31 | // #include "loadShape.c" 32 | #include "geomCube.c" 33 | 34 | void hiresDemo() { 35 | GenerateTables(); // for line8 36 | ComputeDivMod(); // for filler 37 | InitTables(); //for filler 38 | 39 | hires(); 40 | 41 | nbPts = 0; 42 | glNbSegments = 0; 43 | 44 | glLoadShape(-4, -4, 2, 4, 4, 4, 0, geomCube); 45 | glLoadShape(4, 4, 10, 4, 4, 4, 0, geomCube); 46 | // glLoadShape(-4, -4, 2, 0, geomCube); 47 | // glLoadShape(4, 4, 10, 0, geomCube); 48 | // printf ("%d Points, %d Particles, %d Segments, %d Faces\n", glNbVertices, glNbParticles, glNbSegments, glNbFaces); get(); 49 | hiresIntro(); 50 | 51 | hiresGameLoop(); 52 | } 53 | 54 | void hiresIntro() { 55 | int i, jj; 56 | 57 | //enterSC(); 58 | 59 | glCamPosX = -24; 60 | glCamPosY = 0; 61 | glCamPosZ = 3; 62 | 63 | glCamRotZ = 64; // -128 -> -127 unit : 2PI/(2^8 - 1) 64 | glCamRotX = 2; 65 | 66 | for (i = 0; i < 120;) { 67 | glCamPosX = traj[i++]; 68 | glCamPosY = traj[i++]; 69 | glCamRotZ = traj[i++]; 70 | i = i % (NB_POINTS_TRAJ * SIZE_POINTS_TRAJ); 71 | glProject(points2d, points3d, glNbVertices, 0); 72 | // for (jj=0; jj< glNbVertices; jj++){ 73 | // printf ("%d %d %d => %d %d \n", points3d[jj*SIZEOF_3DPOINT], points3d[jj*SIZEOF_3DPOINT+1], points3d[jj*SIZEOF_3DPOINT+2], points2d[jj*SIZEOF_2DPOINT], points2d[jj*SIZEOF_2DPOINT+1]);get(); 74 | // } 75 | 76 | memset(0xa000, 64, 8000); // clear screen 77 | hrDrawSegments(points2d, segments, glNbSegments); 78 | hrDrawFaces(); 79 | } 80 | 81 | // leaveSC(); 82 | } 83 | 84 | void hiresGameLoop() { 85 | char key; 86 | unsigned char i = 0; 87 | key = get(); 88 | glProject(points2d, points3d, nbPts, 0); 89 | 90 | while (1 == 1) { 91 | memset(0xa000, 64, 8000); // clear screen 92 | hrDrawSegments(points2d, segments, glNbSegments); 93 | hrDrawFaces(); 94 | key = get(); 95 | switch (key) // key 96 | { 97 | case 8: // gauche => tourne gauche 98 | i = (i + 3) % (192); 99 | break; 100 | case 9: // droite => tourne droite 101 | if (i == 0) 102 | i = 192 - 3; 103 | i = (i - 3); 104 | break; 105 | case 80: // P 106 | if (glCamPosZ < 5) { 107 | glCamPosZ += 1; 108 | } 109 | break; 110 | case 59: // ; 111 | if (glCamPosZ > 0) { 112 | glCamPosZ -= 1; 113 | } 114 | break; 115 | } 116 | glCamPosX = traj[i + 0]; 117 | glCamPosY = traj[i + 1]; 118 | glCamRotZ = traj[i + 2]; 119 | 120 | glProject(points2d, points3d, nbPts, 0); 121 | } 122 | } 123 | 124 | void hrDrawFaces() { 125 | hrDrawFace(points2d, 0, 1, 2, 2); 126 | hrDrawFace(points2d, 0, 2, 3, 2); 127 | //hrDrawFace(points2d, 0, 1, 5, 1); 128 | //hrDrawFace(points2d, 0, 5, 4, 1); 129 | hrDrawFace(points2d, 4, 5, 6, 0); 130 | hrDrawFace(points2d, 4, 6, 7, 0); 131 | } 132 | 133 | 134 | #endif -------------------------------------------------------------------------------- /src/hrsDrawing.c: -------------------------------------------------------------------------------- 1 | 2 | #include "config.h" 3 | #include "glOric.h" 4 | 5 | #ifdef USE_HIRES_RASTER 6 | extern unsigned int CurrentPattern; 7 | 8 | // 9 | // ====== Filler.s ========== 10 | 11 | extern unsigned char X0; 12 | extern unsigned char Y0; 13 | extern unsigned char X1; 14 | extern unsigned char Y1; 15 | 16 | extern unsigned char OtherPixelX, OtherPixelY, CurrentPixelX, CurrentPixelY; 17 | #endif // USE_HIRES_RASTER 18 | 19 | #ifdef HRSDEMO 20 | 21 | void hrDrawSegments(char p2d[], unsigned char segments[], unsigned char glNbSegments) { 22 | unsigned char ii = 0; 23 | unsigned char idxPt1, idxPt2; 24 | for (ii = 0; ii < glNbSegments; ii++) { 25 | idxPt1 = segments[ii * SIZEOF_SEGMENT + 0]; 26 | idxPt2 = segments[ii * SIZEOF_SEGMENT + 1]; 27 | //char2Display = segments[ii*SIZEOF_SEGMENT + 2]; 28 | 29 | OtherPixelX = p2d[idxPt1 * SIZEOF_2DPOINT + 0]; 30 | OtherPixelY = p2d[idxPt1 * SIZEOF_2DPOINT + 2]; 31 | CurrentPixelX = p2d[idxPt2 * SIZEOF_2DPOINT + 0]; 32 | CurrentPixelY = p2d[idxPt2 * SIZEOF_2DPOINT + 2]; 33 | if ((OtherPixelX > 0) && (OtherPixelX < 240) && (CurrentPixelY > 0) && (CurrentPixelY < 200)) { 34 | DrawLine8(); 35 | } 36 | } 37 | } 38 | 39 | #ifdef USE_HIRES_RASTER 40 | void AddTriangle(unsigned char x0, unsigned char y0, unsigned char x1, unsigned char y1, unsigned char x2, unsigned char y2, unsigned char pattern) { 41 | X0 = x0; 42 | Y0 = y0; 43 | X1 = x1; 44 | Y1 = y1; 45 | AddLineASM(); 46 | X0 = x0; 47 | Y0 = y0; 48 | X1 = x2; 49 | Y1 = y2; 50 | AddLineASM(); 51 | X0 = x2; 52 | Y0 = y2; 53 | X1 = x1; 54 | Y1 = y1; 55 | AddLineASM(); 56 | 57 | CurrentPattern = pattern << 3; 58 | FillTablesASM(); 59 | } 60 | 61 | void hrDrawFace(char p2d[], unsigned char idxPt1, unsigned char idxPt2, unsigned char idxPt3, unsigned char pattern) { 62 | AddTriangle( 63 | p2d[idxPt1 * SIZEOF_2DPOINT + 0], p2d[idxPt1 * SIZEOF_2DPOINT + 2], 64 | p2d[idxPt2 * SIZEOF_2DPOINT + 0], p2d[idxPt2 * SIZEOF_2DPOINT + 2], 65 | p2d[idxPt3 * SIZEOF_2DPOINT + 0], p2d[idxPt3 * SIZEOF_2DPOINT + 2], 66 | (pattern & 3)); 67 | } 68 | 69 | #endif // USE_HIRES_RASTER 70 | /* 71 | void hrDrawSegments2(){ 72 | unsigned char ii = 0; 73 | unsigned char idxPt1, idxPt2; 74 | int OtherPixelX, OtherPixelY, CurrentPixelX, CurrentPixelY; 75 | for (ii = 0; ii< glNbSegments; ii++){ 76 | 77 | idxPt1 = segments[ii*SIZEOF_SEGMENT + 0]; 78 | idxPt2 = segments[ii*SIZEOF_SEGMENT + 1]; 79 | 80 | //OtherPixelX= (int)points2d[idxPt1*SIZEOF_2DPOINT + 0]; 81 | OtherPixelX=((int *)points2d)[idxPt1*2]; 82 | //OtherPixelY= (int)points2d[idxPt1*SIZEOF_2DPOINT + 2]; 83 | OtherPixelY=((int *)points2d)[idxPt1*2+1]; 84 | 85 | //CurrentPixelX=(int)points2d[idxPt2*SIZEOF_2DPOINT + 0]; 86 | CurrentPixelX=((int *)points2d)[idxPt2*2]; 87 | //CurrentPixelY=(int)points2d[idxPt2*SIZEOF_2DPOINT + 2]; 88 | CurrentPixelY=((int *)points2d)[idxPt2*2+1]; 89 | printf("%d %d %d %d \n", 90 | OtherPixelX, OtherPixelY, CurrentPixelX, CurrentPixelY); 91 | //cgetc(); 92 | //tgi_line(OtherPixelX,OtherPixelY,CurrentPixelX,CurrentPixelY); 93 | } 94 | } 95 | 96 | 97 | void debugHiresIntro (){ 98 | int i; 99 | //hires(); 100 | 101 | glCamPosX = -24; 102 | glCamPosY = 0; 103 | glCamPosZ = 3; 104 | 105 | glCamRotZ = 64 ; 106 | glCamRotX = 2; 107 | 108 | for (i=0;i<2;) { 109 | glCamPosX = traj[i++]; 110 | glCamPosY = traj[i++]; 111 | glCamRotZ = traj[i++]; 112 | i = i % (NB_POINTS_TRAJ*SIZE_POINTS_TRAJ); 113 | glProject (points2d, points3d, nbPts, 0); 114 | //memset ( 0xa000, 64, 8000); // clear screen 115 | hrDrawSegments2(); 116 | //hrDrawFaces(); 117 | } 118 | 119 | //leaveSC(); 120 | 121 | } 122 | */ 123 | 124 | #endif // HRSDEMO -------------------------------------------------------------------------------- /src/hzfill_c.c: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_C_HZFILL 3 | 4 | void hzfill() { 5 | // signed char dx, fx; 6 | // signed char nbpoints; 7 | char* ptrFbuf; 8 | unsigned char* ptrZbuf; 9 | 10 | // printf ("A1Right=%d A1XSatur=%d A2XSatur=%d \n", A1Right, A1XSatur, A2XSatur);waitkey(); 11 | lineIndex = A1Y; 12 | if (A1Right != 0) { 13 | #ifdef USE_SATURATION 14 | if (A2XSatur != 0){ 15 | #ifdef USE_COLOR 16 | departX = COLUMN_OF_COLOR_ATTRIBUTE; 17 | #else 18 | departX = 0; 19 | #endif // USE_COLOR 20 | 21 | } else { 22 | departX = A2X; 23 | } 24 | #else // not USE_SATURATION 25 | #ifdef USE_COLOR 26 | departX = max(2, A2X); 27 | #else 28 | departX = max(0, A2X); 29 | #endif 30 | #endif // USE_SATURATION 31 | 32 | #ifdef USE_SATURATION 33 | if (A1XSatur != 0){ 34 | finX = SCREEN_WIDTH - 1; 35 | } else { 36 | finX = A1X; 37 | } 38 | #else // not USE_SATURATION 39 | finX = min(A1X, SCREEN_WIDTH - 1); 40 | #endif // USE_SATURATION 41 | 42 | 43 | } else { 44 | #ifdef USE_SATURATION 45 | if (A1XSatur != 0) { 46 | #ifdef USE_COLOR 47 | departX = COLUMN_OF_COLOR_ATTRIBUTE; 48 | #else 49 | departX = 0; 50 | #endif // USE_COLOR 51 | } else { 52 | departX = A1X; 53 | } 54 | #else // not USE_SATURATION 55 | #ifdef USE_COLOR 56 | departX = max(COLUMN_OF_COLOR_ATTRIBUTE, A1X); 57 | #else 58 | departX = max(0, A1X); 59 | #endif 60 | #endif // USE_SATURATION 61 | 62 | #ifdef USE_SATURATION 63 | if (A2XSatur !=0){ 64 | finX = SCREEN_WIDTH - 1; 65 | } else { 66 | finX = A2X; 67 | } 68 | #else // USE_SATURATION 69 | finX = min(A2X, SCREEN_WIDTH - 1); 70 | #endif // USE_SATURATION 71 | } 72 | // printf ("finX=%d, departX=%d \n", finX , departX);waitkey(); 73 | hLineLength = finX - departX; 74 | if (hLineLength < 0) return; 75 | 76 | ptrZbuf = zbuffer + lineIndex * SCREEN_WIDTH + departX; 77 | ptrFbuf = fbuffer + lineIndex * SCREEN_WIDTH + departX; 78 | 79 | 80 | while (hLineLength > 0) { 81 | // printf ("hLineLength=%d \n", hLineLength);waitkey(); 82 | if (distface < ptrZbuf[hLineLength]) { 83 | ptrFbuf[hLineLength] = ch2disp; 84 | ptrZbuf[hLineLength] = distface; 85 | } 86 | hLineLength --; 87 | } 88 | 89 | } 90 | 91 | #endif // USE_C_HZFILL -------------------------------------------------------------------------------- /src/isA1Right.c: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_C_ISA1RIGHT1 3 | void isA1Right1 (){ 4 | 5 | A1Right = 0; 6 | // log2_tab[]; 7 | if ((mDeltaX1 & 0x80) == 0){ 8 | 9 | if ((mDeltaX2 & 0x80) == 0){ 10 | // printf ("%d*%d %d*%d ", mDeltaY1, mDeltaX2, mDeltaY2,mDeltaX1);get (); 11 | A1Right = ((log2_tab[mDeltaX2] + log2_tab[mDeltaY1])/2) > ((log2_tab[mDeltaX1] + log2_tab[mDeltaY2])/2); 12 | // A1Right = mDeltaY1*mDeltaX2 > mDeltaY2*mDeltaX1; 13 | } else { 14 | A1Right = 0 ; // (mDeltaX1 < 0) 15 | } 16 | } else { 17 | if ((mDeltaX2 & 0x80) == 0){ 18 | A1Right = 1 ; // (mDeltaX1 < 0) 19 | } else { 20 | // printf ("%d*%d %d*%d ", mDeltaY1, -mDeltaX2, mDeltaY2,-mDeltaX1);get (); 21 | A1Right = ((log2_tab[abs(mDeltaX2)] + log2_tab[mDeltaY1])/2) < ((log2_tab[abs(mDeltaX1)] + log2_tab[mDeltaY2])/2); 22 | } 23 | } 24 | // if (((mDeltaX1 & 0x80) ^ (mDeltaX2 & 0x80)) == 0) { 25 | // A1Right = mDeltaY1*mDeltaX2 > mDeltaY2*mDeltaX1; // (DeltaY1/DeltaX1) > (DeltaY2/DeltaX2) ; 26 | // }else { 27 | // A1Right = (mDeltaX1 < 0) ; 28 | // } 29 | 30 | // A1Right = mDeltaY1*mDeltaX2 > mDeltaY2*mDeltaX1; 31 | 32 | 33 | // if (DeltaX1 == 0) { 34 | // A1Right = (DeltaX2 < 0); 35 | // } else { 36 | // if (DeltaX2 == 0){ 37 | // A1Right = (DeltaX1 > 0); 38 | // } else { 39 | // if (((DeltaX1 & 0x80) ^ (DeltaX2 & 0x80)) == 0) { 40 | // A1Right = DeltaY1*DeltaX2 > DeltaY2*DeltaX1; // (DeltaY1/DeltaX1) > (DeltaY2/DeltaX2) ; 41 | // }else { 42 | // A1Right = (DeltaX1 > 0) ; 43 | // } 44 | 45 | // } 46 | // } 47 | } 48 | #endif // USE_C_ISA1RIGHT1 49 | 50 | 51 | 52 | #ifdef USE_C_ISA1RIGHT3 53 | void isA1Right3 (){ 54 | A1Right = (A1X > A2X); 55 | } 56 | #endif // USE_C_ISA1RIGHT3 57 | 58 | -------------------------------------------------------------------------------- /src/keyboard.c: -------------------------------------------------------------------------------- 1 | #include "config.h" 2 | 3 | #include "util/keyboard.h" 4 | 5 | #ifdef USE_RT_KEYBOARD 6 | 7 | 8 | extern void move(char key); 9 | 10 | void keyPressed (char dif, char v){ 11 | 12 | // sprintf (status_string, "key pressed: %d %d ", dif, v); 13 | // AdvancedPrint(3,6 ,status_string); 14 | switch (v) { 15 | case 4 : 16 | switch (dif) { 17 | case 8: 18 | // KEY UP 19 | move(11); 20 | break; 21 | case 64: 22 | // KEY DOWN 23 | move(10); 24 | break; 25 | case 32: 26 | // KEY LEFT 27 | move(8); 28 | break; 29 | case -128: 30 | // KEY RIGHT 31 | move(9); 32 | break; 33 | } 34 | break; 35 | case 5: 36 | switch (dif) { 37 | case 8: 38 | // KEY P 39 | move(80); 40 | break; 41 | } 42 | break; 43 | case 3: 44 | switch (dif) { 45 | case 4: 46 | // KEY M 47 | move(59); 48 | break; 49 | } 50 | case 6: 51 | switch (dif) { 52 | case 32: 53 | // KEY Q 54 | move(81); 55 | break; 56 | } 57 | case 2: 58 | switch (dif) { 59 | case 32: 60 | // KEY W 61 | move(90); 62 | break; 63 | } 64 | case 1: 65 | switch (dif) { 66 | case 64: 67 | // KEY A 68 | move(65); 69 | break; 70 | } 71 | case 0: 72 | switch (dif) { 73 | case 64: 74 | // KEY X 75 | move(88); 76 | break; 77 | } 78 | } 79 | } 80 | void keyReleased (char dif, char v){ 81 | // sprintf (status_string, " key released: %d %d ", dif, v); 82 | // AdvancedPrint(3, 6,status_string); 83 | } 84 | 85 | 86 | void keyEvent() 87 | { 88 | char i,j; 89 | char mask=1; 90 | char diff; 91 | 92 | for (j=0;j<8;j++) 93 | { 94 | if ((diff = (oldKeyBank[j] ^ KeyBank [j])) != 0){ 95 | // printf ("diff = %d\n"); 96 | if ((KeyBank [j] & diff) == 0) { 97 | keyReleased (diff, j); 98 | } else { 99 | keyPressed (diff, j); 100 | } 101 | } 102 | oldKeyBank[j] = KeyBank [j]; 103 | } 104 | } 105 | #endif USE_RT_KEYBOARD -------------------------------------------------------------------------------- /src/loadShape_s.s: -------------------------------------------------------------------------------- 1 | 2 | 3 | ;; unsigned char sl_kk=0; 4 | _sl_kk .dsb 1 5 | ;; unsigned char sl_npt,sl_nfa, sl_nseg, sl_npart; 6 | _sl_npt .dsb 1 7 | _sl_nfa .dsb 1 8 | _sl_nseg .dsb 1 9 | _sl_npart .dsb 1 10 | ;; unsigned char sl_ii; 11 | _sl_ii .dsb 1 12 | ;; unsigned char sl_ori; 13 | _sl_ori .dsb 1 14 | ;; signed char *sl_geom; 15 | _sl_geom .dsb 2 16 | ;; signed char sl_X, sl_Y, sl_Z; 17 | _sl_X .dsb 1 18 | _sl_Y .dsb 1 19 | _sl_Z .dsb 1 20 | 21 | 22 | 23 | _loadShape: 24 | .( 25 | 26 | ;; sl_kk=0; 27 | lda #0: sta _sl_kk: 28 | 29 | lda _sl_geom : sta tmp5 : lda _sl_geom+1 : sta tmp5+1 : 30 | ;; sl_npt = sl_geom[sl_kk++]; 31 | ldy _sl_kk: lda (tmp5),y: sta _sl_npt: iny: 32 | ;; sl_nfa = sl_geom[sl_kk++]; 33 | lda (tmp5),y: sta _sl_nfa: iny: 34 | ;; sl_nseg = sl_geom[sl_kk++]; 35 | lda (tmp5),y: sta _sl_nseg: iny: 36 | ;; sl_npart = sl_geom[sl_kk++]; 37 | lda (tmp5),y: sta _sl_npart: iny: sty _sl_kk: 38 | 39 | 40 | lda _sl_npt 41 | sta _sl_ii 42 | bne startlooppoint 43 | jmp endlooppoint 44 | startlooppoint: 45 | 46 | lda _sl_ori 47 | bne case1 48 | ;; glVerticesX[glNbVertices] = sl_X + sl_geom[sl_kk++]; // X 49 | ldy _sl_kk: lda (tmp5),y: clc: adc _sl_X: ldy _glNbVertices: sta _glVerticesX,y: inc _sl_kk: 50 | ;; glVerticesY[glNbVertices] = sl_Y + sl_geom[sl_kk++]; // Y 51 | ldy _sl_kk: lda (tmp5),y: clc: adc _sl_Y: ldy _glNbVertices: sta _glVerticesY,y: inc _sl_kk: 52 | 53 | jmp endswitch 54 | case1: 55 | cmp #1 56 | bne case2 57 | ;; glVerticesY[glNbVertices] = sl_Y + sl_geom[sl_kk++]; // X 58 | ldy _sl_kk: lda (tmp5),y: clc: adc _sl_Y: ldy _glNbVertices: sta _glVerticesY,y: inc _sl_kk: 59 | ;; glVerticesX[glNbVertices] = sl_X - sl_geom[sl_kk++]; // -Y 60 | ldy _sl_kk: lda _sl_X: sec: sbc (tmp5),y: ldy _glNbVertices: sta _glVerticesX,y: inc _sl_kk: 61 | 62 | jmp endswitch 63 | case2: 64 | cmp #2 65 | bne case3 66 | ;; glVerticesX[glNbVertices] = sl_X - sl_geom[sl_kk++]; // -X 67 | ldy _sl_kk: lda _sl_X: sec: sbc (tmp5),y: ldy _glNbVertices: sta _glVerticesX,y: inc _sl_kk: 68 | ;; glVerticesY[glNbVertices] = sl_Y - sl_geom[sl_kk++]; // -Y 69 | ldy _sl_kk: lda _sl_Y: sec: sbc (tmp5),y: ldy _glNbVertices: sta _glVerticesY,y: inc _sl_kk: 70 | 71 | jmp endswitch 72 | case3: 73 | cmp #3 74 | bne endswitch 75 | ;; glVerticesY[glNbVertices] = sl_Y - sl_geom[sl_kk++]; // -X 76 | ldy _sl_kk: lda _sl_Y: sec: sbc (tmp5),y: ldy _glNbVertices: sta _glVerticesY,y: inc _sl_kk: 77 | ;; glVerticesX[glNbVertices] = sl_X + sl_geom[sl_kk++]; // Y 78 | ldy _sl_kk: lda _sl_X: clc: adc (tmp5),y: ldy _glNbVertices: sta _glVerticesX,y: inc _sl_kk: 79 | 80 | 81 | endswitch: 82 | 83 | ;; glVerticesZ[glNbVertices] = sl_Z + sl_geom[sl_kk++]; 84 | ldy _sl_kk: lda _sl_Z: clc: adc (tmp5),y: ldy _glNbVertices: sta _glVerticesZ,y: inc _sl_kk: 85 | ;; glNbVertices ++; 86 | ;; sl_kk++; // skip unused byte 87 | inc _glNbVertices: inc _sl_kk: 88 | 89 | 90 | 91 | dec _sl_ii 92 | lda _sl_ii 93 | beq endlooppoint 94 | jmp startlooppoint 95 | endlooppoint: 96 | 97 | 98 | lda _sl_nfa 99 | sta _sl_ii 100 | bne startloopfaces 101 | jmp endloopfaces 102 | startloopfaces: 103 | 104 | ;; glFacesPt1[glNbFaces] = glNbVertices - (sl_npt-sl_geom[sl_kk++]); // Index Point 1 105 | lda _glNbVertices: sec: sbc _sl_npt: ldy _sl_kk: clc: adc (tmp5),y: ldy _glNbFaces: sta _glFacesPt1,y: inc _sl_kk: 106 | ;; glFacesPt2[glNbFaces] = glNbVertices - (sl_npt-sl_geom[sl_kk++]); // Index Point 2 107 | lda _glNbVertices: sec: sbc _sl_npt: ldy _sl_kk: clc: adc (tmp5),y: ldy _glNbFaces: sta _glFacesPt2,y: inc _sl_kk: 108 | ;; glFacesPt3[glNbFaces] = glNbVertices - (sl_npt-sl_geom[sl_kk++]); // Index Point 3 109 | lda _glNbVertices: sec: sbc _sl_npt: ldy _sl_kk: clc: adc (tmp5),y: ldy _glNbFaces: sta _glFacesPt3,y: inc _sl_kk: 110 | ;; glFacesChar[glNbFaces] = sl_geom[sl_kk++]; // Character 111 | ldy _sl_kk: lda (tmp5),y: ldy _glNbFaces: sta _glFacesChar,y: inc _sl_kk: 112 | ;; glNbFaces++; 113 | inc _glNbFaces: 114 | 115 | 116 | dec _sl_ii 117 | lda _sl_ii 118 | beq endloopfaces 119 | jmp startloopfaces 120 | endloopfaces: 121 | 122 | lda _sl_nseg 123 | sta _sl_ii 124 | bne startloopsegments 125 | jmp endloopsegments 126 | startloopsegments: 127 | 128 | ;; glSegmentsPt1[glNbSegments] = glNbVertices - (sl_npt-sl_geom[sl_kk++]); // Index Point 1 129 | lda _glNbVertices: sec: sbc _sl_npt: ldy _sl_kk: clc: adc (tmp5),y: ldy _glNbSegments: sta _glSegmentsPt1,y: inc _sl_kk: 130 | ;; glSegmentsPt2[glNbSegments] = glNbVertices - (sl_npt-sl_geom[sl_kk++]); // Index Point 2 131 | lda _glNbVertices: sec: sbc _sl_npt: ldy _sl_kk: clc: adc (tmp5),y: ldy _glNbSegments: sta _glSegmentsPt2,y: inc _sl_kk: 132 | ; glSegmentsChar[glNbSegments] = sl_geom[sl_kk++]; // Character 133 | ldy _sl_kk: lda (tmp5),y: ldy _glNbSegments: sta _glSegmentsChar,y: inc _sl_kk: 134 | ;; glNbSegments++; 135 | ;; sl_kk++; // skip unused byte 136 | inc _glNbSegments: inc _sl_kk: 137 | 138 | dec _sl_ii 139 | lda _sl_ii 140 | beq endloopsegments 141 | jmp startloopsegments 142 | endloopsegments: 143 | 144 | lda _sl_npart 145 | sta _sl_ii 146 | bne startloopparticules 147 | jmp endloopparticules 148 | startloopparticules: 149 | 150 | ;; glParticlesPt[glNbParticles] = glNbVertices - (sl_npt-sl_geom[sl_kk++]); // Index Point 151 | lda _glNbVertices: sec: sbc _sl_npt: ldy _sl_kk: clc: adc (tmp5),y: ldy _glNbParticles: sta _glParticlesPt,y: inc _sl_kk: 152 | ;; glParticlesChar[glNbParticles] = sl_geom[sl_kk++]; // Character 153 | ldy _sl_kk: lda (tmp5),y: ldy _glNbParticles: sta _glParticlesChar,y: inc _sl_kk: 154 | ;; glNbParticles++; 155 | inc _glNbParticles: 156 | 157 | dec _sl_ii 158 | lda _sl_ii 159 | beq endloopparticules 160 | jmp startloopparticules 161 | endloopparticules: 162 | 163 | .) 164 | rts 165 | -------------------------------------------------------------------------------- /src/logic.c: -------------------------------------------------------------------------------- 1 | #include "config.h" 2 | #include "glOric.h" 3 | 4 | #include "util\util.h" 5 | 6 | #include "logic_c.c" -------------------------------------------------------------------------------- /src/logic_c.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_COLLISION_DETECTION 2 | extern unsigned char isAllowedPosition(signed char X, signed char Y, signed char Z); 3 | #endif 4 | 5 | void forward() { 6 | #ifdef USE_COLLISION_DETECTION 7 | signed int X, Y; 8 | X = glCamPosX; 9 | Y = glCamPosY; 10 | #endif 11 | 12 | if (-112 >= glCamRotZ) { 13 | glCamPosX--; 14 | } else if ((-112 < glCamRotZ) && (-80 >= glCamRotZ)) { 15 | glCamPosX--; 16 | glCamPosY--; 17 | } else if ((-80 < glCamRotZ) && (-48 >= glCamRotZ)) { 18 | glCamPosY--; 19 | } else if ((-48 < glCamRotZ) && (-16 >= glCamRotZ)) { 20 | glCamPosX++; 21 | glCamPosY--; 22 | } else if ((-16 < glCamRotZ) && (16 >= glCamRotZ)) { 23 | glCamPosX++; 24 | } else if ((16 < glCamRotZ) && (48 >= glCamRotZ)) { 25 | glCamPosX++; 26 | glCamPosY++; 27 | } else if ((48 < glCamRotZ) && (80 >= glCamRotZ)) { 28 | glCamPosY++; 29 | } else if ((80 < glCamRotZ) && (112 >= glCamRotZ)) { 30 | glCamPosX--; 31 | glCamPosY++; 32 | } else { 33 | glCamPosX--; 34 | } 35 | #ifdef USE_COLLISION_DETECTION 36 | if (!isAllowedPosition(glCamPosX, glCamPosY, glCamPosZ)) { 37 | glCamPosX = X; 38 | glCamPosY = Y; 39 | } 40 | #endif 41 | } 42 | void backward() { 43 | #ifdef USE_COLLISION_DETECTION 44 | signed int X, Y; 45 | X = glCamPosX; 46 | Y = glCamPosY; 47 | #endif 48 | if (-112 >= glCamRotZ) { 49 | glCamPosX++; 50 | } else if ((-112 < glCamRotZ) && (-80 >= glCamRotZ)) { 51 | glCamPosX++; 52 | glCamPosY++; 53 | } else if ((-80 < glCamRotZ) && (-48 >= glCamRotZ)) { 54 | glCamPosY++; 55 | } else if ((-48 < glCamRotZ) && (-16 >= glCamRotZ)) { 56 | glCamPosX--; 57 | glCamPosY++; 58 | } else if ((-16 < glCamRotZ) && (16 >= glCamRotZ)) { 59 | glCamPosX--; 60 | } else if ((16 < glCamRotZ) && (48 >= glCamRotZ)) { 61 | glCamPosX--; 62 | glCamPosY--; 63 | } else if ((48 < glCamRotZ) && (80 >= glCamRotZ)) { 64 | glCamPosY--; 65 | } else if ((80 < glCamRotZ) && (112 >= glCamRotZ)) { 66 | glCamPosX++; 67 | glCamPosY--; 68 | } else { 69 | glCamPosX++; 70 | } 71 | #ifdef USE_COLLISION_DETECTION 72 | if (!isAllowedPosition(glCamPosX, glCamPosY, glCamPosZ)) { 73 | glCamPosX = X; 74 | glCamPosY = Y; 75 | } 76 | #endif 77 | } 78 | void shiftLeft() { 79 | #ifdef USE_COLLISION_DETECTION 80 | signed int X, Y; 81 | X = glCamPosX; 82 | Y = glCamPosY; 83 | #endif 84 | if (-112 >= glCamRotZ) { 85 | glCamPosY--; 86 | } else if ((-112 < glCamRotZ) && (-80 >= glCamRotZ)) { 87 | glCamPosX++; 88 | glCamPosY--; 89 | } else if ((-80 < glCamRotZ) && (-48 >= glCamRotZ)) { 90 | glCamPosX--; 91 | } else if ((-48 < glCamRotZ) && (-16 >= glCamRotZ)) { 92 | glCamPosX++; 93 | glCamPosY++; 94 | } else if ((-16 < glCamRotZ) && (16 >= glCamRotZ)) { 95 | glCamPosY++; 96 | } else if ((16 < glCamRotZ) && (48 >= glCamRotZ)) { 97 | glCamPosX--; 98 | glCamPosY++; 99 | } else if ((48 < glCamRotZ) && (80 >= glCamRotZ)) { 100 | glCamPosX--; 101 | } else if ((80 < glCamRotZ) && (112 >= glCamRotZ)) { 102 | glCamPosX--; 103 | glCamPosY--; 104 | } else { 105 | glCamPosY--; 106 | } 107 | #ifdef USE_COLLISION_DETECTION 108 | if (!isAllowedPosition(glCamPosX, glCamPosY, glCamPosZ)) { 109 | glCamPosX = X; 110 | glCamPosY = Y; 111 | } 112 | #endif 113 | } 114 | void shiftRight() { 115 | #ifdef USE_COLLISION_DETECTION 116 | signed int X, Y; 117 | X = glCamPosX; 118 | Y = glCamPosY; 119 | #endif 120 | if (-112 >= glCamRotZ) { 121 | glCamPosY++; 122 | } else if ((-112 < glCamRotZ) && (-80 >= glCamRotZ)) { 123 | glCamPosX--; 124 | glCamPosY++; 125 | } else if ((-80 < glCamRotZ) && (-48 >= glCamRotZ)) { 126 | glCamPosX++; 127 | } else if ((-48 < glCamRotZ) && (-16 >= glCamRotZ)) { 128 | glCamPosX--; 129 | glCamPosY--; 130 | } else if ((-16 < glCamRotZ) && (16 >= glCamRotZ)) { 131 | glCamPosY--; 132 | } else if ((16 < glCamRotZ) && (48 >= glCamRotZ)) { 133 | glCamPosX++; 134 | glCamPosY--; 135 | } else if ((48 < glCamRotZ) && (80 >= glCamRotZ)) { 136 | glCamPosX++; 137 | } else if ((80 < glCamRotZ) && (112 >= glCamRotZ)) { 138 | glCamPosX++; 139 | glCamPosY++; 140 | } else { 141 | glCamPosX++; 142 | } 143 | #ifdef USE_COLLISION_DETECTION 144 | if (!isAllowedPosition(glCamPosX, glCamPosY, glCamPosZ)) { 145 | glCamPosX = X; 146 | glCamPosY = Y; 147 | } 148 | #endif 149 | } 150 | -------------------------------------------------------------------------------- /src/lrDrawLine.c: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_C_DRAWLINE 3 | void lrDrawLine() { 4 | 5 | signed char e2; 6 | char ch2dsp; 7 | 8 | A1X = P1X; 9 | A1Y = P1Y; 10 | A1destX = P2X; 11 | A1destY = P2Y; 12 | A1dX = abs(P2X - P1X); 13 | A1dY = -abs(P2Y - P1Y); 14 | A1sX = P1X < P2X ? 1 : -1; 15 | A1sY = P1Y < P2Y ? 1 : -1; 16 | A1err = A1dX + A1dY; 17 | 18 | if ((A1err > 64) || (A1err < -63)) 19 | return; 20 | 21 | if ((ch2disp == '/') && (A1sX == -1)) { 22 | ch2dsp = BACKSLASH; 23 | } else { 24 | ch2dsp = ch2disp; 25 | } 26 | 27 | while (1) { // loop 28 | // printf ("plot [%d, %d] %d %d\n", A1X, A1Y, distseg, ch2disp);waitkey (); 29 | #ifdef USE_ZBUFFER 30 | glZPlot(A1X, A1Y, distseg, ch2dsp); 31 | #else 32 | plot(A1X, A1Y, ch2dsp); 33 | #endif 34 | if ((A1X == A1destX) && (A1Y == A1destY)) 35 | break; 36 | //e2 = 2*err; 37 | e2 = (A1err < 0) ? ( 38 | ((A1err & 0x40) == 0) ? ( 39 | 0x80) 40 | : ( 41 | A1err << 1)) 42 | : ( 43 | ((A1err & 0x40) != 0) ? ( 44 | 0x7F) 45 | : ( 46 | A1err << 1)); 47 | if (e2 >= A1dY) { 48 | A1err += A1dY; // e_xy+e_x > 0 49 | A1X += A1sX; 50 | } 51 | if (e2 <= A1dX) { // e_xy+e_y < 0 52 | A1err += A1dX; 53 | A1Y += A1sY; 54 | } 55 | } 56 | } 57 | #endif // USE_C_DRAWLINE 58 | -------------------------------------------------------------------------------- /src/main.c: -------------------------------------------------------------------------------- 1 | #include "lib.h" 2 | 3 | #include "config.h" 4 | #include "glOric.h" 5 | 6 | void main() { 7 | #ifdef TEXTDEMO 8 | textDemo(); 9 | #endif 10 | #ifdef HRSDEMO 11 | hiresDemo(); 12 | #endif 13 | #ifdef LRSDEMO 14 | lrsDemo(); 15 | #endif 16 | #ifdef COLORDEMO 17 | colorDemo(); 18 | #endif 19 | #ifdef RTDEMO 20 | rtDemo(); 21 | #endif // RTDEMO 22 | #ifdef PROFBENCH 23 | profbench(); 24 | #endif // PROFBENCH 25 | } 26 | -------------------------------------------------------------------------------- /src/makefile: -------------------------------------------------------------------------------- 1 | 2 | .SUFFIXES: 3 | .SUFFIXES: .asm .c 4 | 5 | PATH_TO_ORICUTRON="C:\Users\Public\Orix" 6 | 7 | LIBNAME=glOric 8 | PROGNAME=d 9 | 10 | PLATFORM=telestrat 11 | 12 | XA="C:\Users\Public\osdk_1_15\Bin/xa.exe" 13 | 14 | AS=ca65 15 | ASFLAGS=-t$(PLATFORM) -g --include-dir . 16 | 17 | CC=cc65 18 | CFLAGS=-D TARGET_ORIX -g 19 | 20 | AR=ar65 21 | ARFLAGS=r 22 | 23 | LD=cl65 24 | LDFLAGS=-v -vm -g -t$(PLATFORM) 25 | 26 | #SRC_ASM= camera.asm temp.asm fill8.asm zbuff.asm hzfill.asm projection.asm glProjectPoint.asm scene.asm 27 | #SRC_C= glOric_c.c 28 | #OBJS= $(SRC_ASM:.asm=.o) $(SRC_C:.c=.o) 29 | 30 | %.o: %.asm 31 | $(AS) $(ASFLAGS) $^ -l $(@:.o=.lst) -o $@ 32 | 33 | %.asm: %.c 34 | $(CC) $(CFLAGS) $^ -o $@ 35 | 36 | #%.o: %.c 37 | # $(CC) $(CFLAGS) $^ -o $@ 38 | 39 | %.asm: %.s 40 | $(XA) -v -R -cc -e error.txt -l xa_labels.txt -DTARGET_ORIX -DSAVE_ZERO_PAGE $^ -o $(@:.asm=.o) 41 | co65 $(@:.asm=.o) -o $@ 42 | rm -f $(@:.asm=.o) 43 | 44 | #$(XA) -v -R -cc -e error.txt -l xa_labels.txt -DTARGET_ORIX -DSAVE_ZERO_PAGE glOric_s.s -o glOric_s.o 45 | #co65 glOric_s.o -o glOric_s.asm 46 | #%.o: %.asm 47 | # $(AS) $(ASFLAGS) $^ -l $(@:.o=.lst) -o $@ 48 | 49 | #GL: glOric_s.o start.o 50 | # $(LD) -m GL.map -Ln GL.vice $(LDFLAGS) start.o glOric_asm.o -o GL.tap 51 | # sed -re 's/al 00(.{4}) \.(.+)$$/\1 \2/' GL.vice | sort > $(PATH_TO_ORICUTRON)/symbols 52 | # cp GL.tap $(PATH_TO_ORICUTRON)/usbdrive/bin/d 53 | # cd $(PATH_TO_ORICUTRON) && ./oricutron.exe -s symbols & 54 | # cd - 55 | 56 | # cl65 -g -o GL -DTARGET_ORIX -DSAVE_ZERO_PAGE -ttelestrat start.c glOric_s.asm 57 | # cp GL $(PATH_TO_ORICUTRON)\usbdrive\bin\ 58 | 59 | $(PROGNAME).tap: glOric_s.o start.o 60 | $(LD) -m $(@:.tap=.map) -Ln $(@:.tap=.vice) $(LDFLAGS) $^ -o $(PROGNAME).tap 61 | sed -re 's/al 00(.{4}) \.(.+)$$/\1 \2/' $(@:.tap=.vice) | sort > $(PATH_TO_ORICUTRON)/symbols 62 | cp $@ $(PATH_TO_ORICUTRON)/usbdrive/bin/$(PROGNAME) 63 | 64 | 65 | all: $(PROGNAME).tap 66 | 67 | test: $(PROGNAME).tap 68 | cp $(PROGNAME).tap $(PATH_TO_ORICUTRON)\usbdrive\bin\$(PROGNAME) 69 | cd $(PATH_TO_ORICUTRON) && ./oricutron.exe -s symbols & 70 | cd - 71 | 72 | # $(SRC_C:.c=.asm) 73 | 74 | clean: 75 | rm -f *.o glOric_s.asm *.lst *.map *.vice error.txt xa_labels.txt $(PROGNAME).tap 76 | 77 | -------------------------------------------------------------------------------- /src/osdk_build.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | 4 | :: 5 | :: Initial check. 6 | :: Verify if the SDK is correctly configurated 7 | :: 8 | IF "%OSDK%"=="" GOTO ErCfg 9 | 10 | 11 | :: 12 | :: Set the build paremeters 13 | :: 14 | CALL osdk_config.bat 15 | 16 | 17 | :: 18 | :: Launch the compilation of files 19 | :: 20 | CALL %OSDK%\bin\make.bat %OSDKFILE% 21 | GOTO End 22 | 23 | 24 | :: 25 | :: Outputs an error message 26 | :: 27 | :ErCfg 28 | ECHO == ERROR == 29 | ECHO The Oric SDK was not configured properly 30 | ECHO You should have a OSDK environment variable setted to the location of the SDK 31 | IF "%OSDKBRIEF%"=="" PAUSE 32 | GOTO End 33 | 34 | 35 | :End 36 | -------------------------------------------------------------------------------- /src/osdk_config.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | :: 4 | :: Set the build paremeters 5 | :: 6 | SET OSDKADDR=$500 7 | SET OSDKNAME=GLORIC 8 | SET OSDKCOMP=-O2 9 | REM SET OSDKLINK=-B 10 | 11 | REM SET OSDKFILE=start glOric_c glOric_s 12 | 13 | SET OSDKFILE=main 14 | 15 | SET OSDKFILE=%OSDKFILE% glOric_s loadShape_s sprites_s glOric_c 16 | 17 | :: SET OSDKFILE=%OSDKFILE% raster\fill8 18 | :: SET OSDKFILE=%OSDKFILE% profile 19 | :: SET OSDKFILE=%OSDKFILE% glOric kernel 20 | SET OSDKFILE=%OSDKFILE% lrsDemo 21 | SET OSDKFILE=%OSDKFILE% hrsDemo 22 | SET OSDKFILE=%OSDKFILE% txtDemo 23 | SET OSDKFILE=%OSDKFILE% rtDemo 24 | SET OSDKFILE=%OSDKFILE% colorDemo 25 | :: SET OSDKFILE=%OSDKFILE% profbench 26 | :: SET OSDKFILE=%OSDKFILE% colors 27 | :: SET OSDKFILE=%OSDKFILE% glProject8 28 | :: SET OSDKFILE=%OSDKFILE% zbuffer 29 | :: SET OSDKFILE=%OSDKFILE% render\zbuff 30 | :: SET OSDKFILE=%OSDKFILE% lrsDrawing 31 | SET OSDKFILE=%OSDKFILE% hrsDrawing 32 | :: SET OSDKFILE=%OSDKFILE% geom 33 | :: SET OSDKFILE=%OSDKFILE% logic 34 | :: SET OSDKFILE=%OSDKFILE% keyboard 35 | :: SET OSDKFILE=%OSDKFILE% bresfill 36 | :: SET OSDKFILE=%OSDKFILE% math\atan2 math\norm 37 | :: SET OSDKFILE=%OSDKFILE% render\lrsSegments 38 | :: SET OSDKFILE=%OSDKFILE% render\face 39 | SET OSDKFILE=%OSDKFILE% raster\buffer raster\line8 40 | :: SET OSDKFILE=%OSDKFILE% raster\line 41 | :: SET OSDKFILE=%OSDKFILE% raster\seg8 42 | :: SET OSDKFILE=%OSDKFILE% raster\raster8 43 | :: SET OSDKFILE=%OSDKFILE% raster\particles 44 | SET OSDKFILE=%OSDKFILE% raster\filler 45 | :: SET OSDKFILE=%OSDKFILE% raster\hzfill 46 | :: 47 | :: SET OSDKFILE=%OSDKFILE% util\print util\screen 48 | SET OSDKFILE=%OSDKFILE% util\display 49 | :: SET OSDKFILE=%OSDKFILE% util\rand 50 | 51 | :: List of files to put in the DSK file. 52 | :: Implicitely includes BUILD/%OSDKNAME%.TAP 53 | SET OSDKTAPNAME="glOric" 54 | 55 | ::run99.tap ..\intro\build\intro.tap 56 | SET OSDKDNAME=" -- glOric --" 57 | SET OSDKINIST="?\"V1.1\":WAIT20:!RUNME.COM" 58 | -------------------------------------------------------------------------------- /src/osdk_execute.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | :: 4 | :: Initial check. 5 | :: Verify if the SDK is correctly configurated, 6 | :: 7 | IF "%OSDK%"=="" GOTO ErCfg 8 | 9 | :: 10 | :: Set the build paremeters 11 | :: 12 | CALL osdk_config.bat 13 | 14 | :: 15 | :: Run the emulator using the common batch 16 | :: 17 | CALL %OSDK%\bin\execute.bat 18 | GOTO End 19 | 20 | :: 21 | :: Outputs an error message about configuration 22 | :: 23 | :ErCfg 24 | ECHO == ERROR == 25 | ECHO The Oric SDK was not configured properly 26 | ECHO You should have a OSDK environment variable setted to the location of the SDK 27 | ECHO =========== 28 | IF "%OSDKBRIEF%"=="" PAUSE 29 | GOTO End 30 | 31 | :End 32 | -------------------------------------------------------------------------------- /src/osdk_showmap.bat: -------------------------------------------------------------------------------- 1 | @ECHO OFF 2 | 3 | :: 4 | :: Initial check. 5 | :: Verify if the SDK is correctly configurated 6 | :: 7 | IF "%OSDK%"=="" GOTO ErCfg 8 | 9 | :: 10 | :: Set the build paremeters 11 | :: 12 | CALL osdk_config.bat 13 | 14 | :: 15 | :: Generate the HTML file 16 | :: 17 | %OSDK%\bin\MemMap.exe build\symbols build\map.htm %OSDKNAME% %OSDK%\documentation\documentation.css 18 | 19 | :: 20 | :: Display the HTML file 21 | :: 22 | explorer build\map.htm 23 | 24 | GOTO End 25 | 26 | 27 | :: 28 | :: Outputs an error message 29 | :: 30 | :ErCfg 31 | ECHO == ERROR == 32 | ECHO The Oric SDK was not configured properly 33 | ECHO You should have a OSDK environment variable setted to the location of the SDK 34 | pause 35 | GOTO End 36 | 37 | 38 | :End 39 | 40 | -------------------------------------------------------------------------------- /src/prepareBresrun.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_C_BRESFILL 2 | void prepare_bresrun() { 3 | if (P1Y <= P2Y) { 4 | if (P2Y <= P3Y) { 5 | pDepX = P3X; 6 | pDepY = P3Y; 7 | pArr1X = P2X; 8 | pArr1Y = P2Y; 9 | pArr2X = P1X; 10 | pArr2Y = P1Y; 11 | } else { 12 | pDepX = P2X; 13 | pDepY = P2Y; 14 | if (P1Y <= P3Y) { 15 | pArr1X = P3X; 16 | pArr1Y = P3Y; 17 | pArr2X = P1X; 18 | pArr2Y = P1Y; 19 | } else { 20 | pArr1X = P1X; 21 | pArr1Y = P1Y; 22 | pArr2X = P3X; 23 | pArr2Y = P3Y; 24 | } 25 | } 26 | } else { 27 | if (P1Y <= P3Y) { 28 | pDepX = P3X; 29 | pDepY = P3Y; 30 | pArr1X = P1X; 31 | pArr1Y = P1Y; 32 | pArr2X = P2X; 33 | pArr2Y = P2Y; 34 | } else { 35 | pDepX = P1X; 36 | pDepY = P1Y; 37 | if (P2Y <= P3Y) { 38 | pArr1X = P3X; 39 | pArr1Y = P3Y; 40 | pArr2X = P2X; 41 | pArr2Y = P2Y; 42 | } else { 43 | pArr1X = P2X; 44 | pArr1Y = P2Y; 45 | pArr2X = P3X; 46 | pArr2Y = P3Y; 47 | } 48 | } 49 | } 50 | } 51 | #endif // USE_C_BRESFILL 52 | 53 | -------------------------------------------------------------------------------- /src/profbench.c: -------------------------------------------------------------------------------- 1 | #include "config.h" 2 | #include "profile.h" 3 | 4 | #ifdef PROFBENCH 5 | 6 | #include "glOric.h" 7 | // #include "data\geom.h" 8 | #include "util\keyboard.h" 9 | #include "data\traj.h" 10 | #include "geomHouse.c" 11 | #include "geomPine.c" 12 | #include "geomTower.c" 13 | void profbench() { 14 | int ii; 15 | unsigned char state, kk; 16 | change_char(36, 0x80, 0x40, 020, 0x10, 0x08, 0x04, 0x02, 0x01); 17 | 18 | glNbVertices = 0; 19 | glNbSegments = 0; 20 | glNbFaces = 0; 21 | glNbParticles = 0; 22 | 23 | glLoadShape(0, 0, 0, 0, geomHouse); 24 | glLoadShape(24, 12, 0, 0, geomPine); 25 | glLoadShape(24, -24, 0, 0, geomTower); 26 | 27 | // printf ("%d Points, %d Particles, %d Segments, %d Faces\n", glNbVertices, glNbParticles, glNbSegments, glNbFaces); get(); 28 | 29 | text(); 30 | 31 | initColors(); 32 | 33 | 34 | glCamPosX = 74; 35 | glCamPosY = 0; 36 | glCamPosZ = 6; 37 | 38 | glCamRotZ = -128; 39 | glCamRotX = 0; 40 | 41 | 42 | 43 | kernelInit(); 44 | 45 | ProfilerInitialize(); 46 | 47 | ii = 74; 48 | state = 0; 49 | 50 | while (state != 5) { 51 | 52 | ProfilerNextFrame(); 53 | 54 | PROFILE_ENTER(ROUTINE_GLOBAL); 55 | switch (state) { 56 | case 0: 57 | if (ii > 0) { 58 | glCamPosX -- ; 59 | ii--; 60 | } else { 61 | ii = 32; 62 | state = 1; 63 | } 64 | break; 65 | case 1: 66 | if (ii > 0) { 67 | glCamRotZ += 4 ; 68 | ii--; 69 | } else { 70 | ii = 24; 71 | state = 2; 72 | } 73 | break; 74 | case 2: 75 | if (ii > 0) { 76 | glCamPosX ++ ; 77 | ii--; 78 | } else { 79 | ii = 32; 80 | state = 3; 81 | } 82 | break; 83 | case 3: 84 | if (ii > 0) { 85 | glCamRotZ += 4 ; 86 | ii--; 87 | } else { 88 | ii = 64; 89 | state = 4; 90 | kk=0; 91 | } 92 | break; 93 | case 4: 94 | if (ii > 0) { 95 | glCamPosX = traj[kk++]; 96 | glCamPosY = traj[kk++]; 97 | glCamRotZ = traj[kk++]; 98 | kk = kk % (NB_POINTS_TRAJ * SIZE_POINTS_TRAJ); 99 | ii--; 100 | } else { 101 | ii = 64; 102 | state = 5; 103 | } 104 | break; 105 | } 106 | PROFILE_ENTER(ROUTINE_KEYEVENT); 107 | keyEvent(); 108 | PROFILE_LEAVE(ROUTINE_KEYEVENT); 109 | 110 | PROFILE_ENTER(ROUTINE_GLPROJECTARRAYS); 111 | glProjectArrays(); 112 | PROFILE_LEAVE(ROUTINE_GLPROJECTARRAYS); 113 | 114 | 115 | PROFILE_ENTER(ROUTINE_INITSCREENBUFFERS); 116 | glInitScreenBuffers(); 117 | PROFILE_LEAVE(ROUTINE_INITSCREENBUFFERS); 118 | 119 | glDrawFaces(); 120 | glDrawSegments(); 121 | glDrawParticles(); 122 | 123 | PROFILE_ENTER(ROUTINE_BUFFER2SCREEN); 124 | glBuffer2Screen(); 125 | PROFILE_LEAVE(ROUTINE_BUFFER2SCREEN); 126 | 127 | PROFILE_LEAVE(ROUTINE_GLOBAL); 128 | 129 | ProfilerDisplay(); 130 | 131 | } 132 | 133 | ProfilerTerminate(); 134 | cls(); 135 | kernelExit(); 136 | } 137 | void move(char key) { 138 | switch (key) { 139 | case 8: // gauche => tourne gauche 140 | glCamRotZ += 4; 141 | break; 142 | case 9: // droite => tourne droite 143 | glCamRotZ -= 4; 144 | break; 145 | case 10: // bas => recule 146 | backward(); 147 | break; 148 | case 11: // haut => avance 149 | forward(); 150 | break; 151 | case 80: // P 152 | glCamPosZ += 1; 153 | break; 154 | case 59: // ; 155 | glCamPosZ -= 1; 156 | break; 157 | case 81: // Q 158 | glCamRotX += 2; 159 | break; 160 | case 65: // A 161 | glCamRotX -= 2; 162 | break; 163 | case 90: // Z 164 | shiftLeft(); 165 | break; 166 | case 88: // X 167 | shiftRight(); 168 | break; 169 | } 170 | } 171 | 172 | #endif // PROFBENCH -------------------------------------------------------------------------------- /src/projection.s: -------------------------------------------------------------------------------- 1 | ;; ___ _ _ _ 2 | ;; / _ \ _ __ ___ (_) ___ ___ | |_ (_) ___ _ __ 3 | ;; / /_)/| '__| / _ \ | | / _ \ / __|| __|| | / _ \ | '_ \ 4 | ;; / ___/ | | | (_) | | || __/| (__ | |_ | || (_) || | | | 5 | ;; \/ |_| \___/ _/ | \___| \___| \__||_| \___/ |_| |_| 6 | ;; |__/ 7 | 8 | #ifdef SAVE_ZERO_PAGE 9 | .text 10 | #else 11 | .zero 12 | #endif 13 | 14 | ;;unsigned char projOptions=0; 15 | _projOptions .dsb 1 16 | 17 | ; #ifdef USE_REWORKED_BUFFERS 18 | ; ;;unsigned char nbCoords=0; 19 | ; _nbCoords .dsb 1 20 | ; #else 21 | ;;unsigned char glNbVertices=0; 22 | _glNbVertices .dsb 1 23 | ; #endif 24 | 25 | 26 | .text 27 | 28 | ;;char points3d[NB_MAX_VERTICES*SIZEOF_3DPOINT]; 29 | ;;.dsb 256-(*&255) 30 | ;;_points3d .dsb NB_MAX_VERTICES*SIZEOF_3DPOINT 31 | _points3d: 32 | _glVerticesX .dsb NB_MAX_VERTICES 33 | _glVerticesY .dsb NB_MAX_VERTICES 34 | _glVerticesZ .dsb NB_MAX_VERTICES 35 | #ifndef USE_REWORKED_BUFFERS 36 | _points3unused .dsb NB_MAX_VERTICES 37 | #endif ;; USE_REWORKED_BUFFERS 38 | 39 | 40 | ;;char points2d [NB_MAX_VERTICES*SIZEOF_2DPOINT]; 41 | ;;.dsb 256-(*&255) 42 | ;;_points2d .dsb NB_MAX_VERTICES*SIZEOF_2DPOINT 43 | 44 | 45 | ;;char points2d [NB_MAX_COORDS*SIZEOF_2DPOINT]; 46 | ;;.dsb 256-(*&255) 47 | ;;_points2d .dsb NB_MAX_COORDS*SIZEOF_2DPOINT 48 | _points2d: 49 | _points2aH .dsb NB_MAX_VERTICES 50 | _points2aV .dsb NB_MAX_VERTICES 51 | _points2dH .dsb NB_MAX_VERTICES 52 | _points2dL .dsb NB_MAX_VERTICES 53 | 54 | #include "glProjectArrays.s" 55 | -------------------------------------------------------------------------------- /src/raster/angle2screen.s: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_ASM_ANGLE2SCREEN 3 | 4 | 5 | ;; void angle2screen() { 6 | _angle2screen: 7 | .( 8 | 9 | #ifdef SAFE_CONTEXT 10 | ;; save context 11 | pha 12 | #endif ;; SAFE_CONTEXT 13 | ;; FIXME : deal with case of overflow 14 | ;; P1X = (SCREEN_WIDTH - P1AH) >> 1; 15 | sec : lda #SCREEN_WIDTH : sbc _P1AH : cmp #$80: ror : sta _P1X 16 | ;; P1Y = (SCREEN_HEIGHT - P1AV) >> 1; 17 | sec : lda #SCREEN_HEIGHT : sbc _P1AV : cmp #$80: ror : sta _P1Y 18 | ;; P2X = (SCREEN_WIDTH - P2AH) >> 1; 19 | sec : lda #SCREEN_WIDTH : sbc _P2AH : cmp #$80: ror : sta _P2X 20 | ;; P2Y = (SCREEN_HEIGHT - P2AV) >> 1; 21 | sec : lda #SCREEN_HEIGHT : sbc _P2AV : cmp #$80: ror : sta _P2Y 22 | ;; P3X = (SCREEN_WIDTH - P3AH) >> 1; 23 | sec : lda #SCREEN_WIDTH : sbc _P3AH : cmp #$80: ror : sta _P3X 24 | ;; P3Y = (SCREEN_HEIGHT - P3AV) >> 1; 25 | sec : lda #SCREEN_HEIGHT : sbc _P3AV : cmp #$80: ror : sta _P3Y 26 | 27 | 28 | #ifdef SAFE_CONTEXT 29 | ;; restore context 30 | pla 31 | #endif ;; SAFE_CONTEXT 32 | ;; } 33 | .) 34 | rts 35 | 36 | #endif ;; USE_ASM_ANGLE2SCREEN 37 | -------------------------------------------------------------------------------- /src/raster/bresfill.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BRESFILL_H 3 | #define BRESFILL_H 4 | 5 | 6 | extern void fillFace (); 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /src/raster/fillFace.s: -------------------------------------------------------------------------------- 1 | #ifdef USE_ASM_FILLFACE 2 | ;; void fillFace() 3 | _fillFace: 4 | .( 5 | ldy #0 : jsr _angle2screen : 6 | ldy #0 : jsr _fill8 : 7 | .) 8 | rts 9 | #endif ;; USE_ASM_FILLFACE 10 | 11 | -------------------------------------------------------------------------------- /src/raster/hfill.s: -------------------------------------------------------------------------------- 1 | #ifdef USE_ASM_HFILL 2 | 3 | 4 | // void hfill() { 5 | _hfill: 6 | .( 7 | ; #ifdef USE_PROFILER 8 | ; PROFILE_ENTER(ROUTINE_HFILL) 9 | ; #endif 10 | // save context 11 | pha:txa:pha:tya:pha 12 | lda reg0: pha ;; p1x 13 | lda reg1: pha ;; p2x 14 | lda reg2: pha ;; pY 15 | lda reg3: pha ;; dist 16 | lda reg4: pha ;; char2disp 17 | lda tmp0: pha ;; dx 18 | lda tmp1: pha ;; fx 19 | lda tmp2: pha ;; nbpoints 20 | lda tmp3: pha: lda tmp3+1: pha ;; save stack pointer 21 | 22 | // signed char dx, fx; 23 | // signed char nbpoints; 24 | 25 | // //printf ("p1x=%d p2x=%d py=%d dist= %d, char2disp= %d\n", p1x, p2x, dist, dist, char2disp);get(); 26 | 27 | // if ((A1Y <= 0) || (A1Y >= SCREEN_HEIGHT)) return; 28 | lda _A1Y ; Access Y coordinate 29 | bpl *+5 30 | jmp hfill_done 31 | #ifdef USE_COLOR 32 | cmp #SCREEN_HEIGHT-NB_LESS_LINES_4_COLOR 33 | #else 34 | cmp #SCREEN_HEIGHT 35 | #endif 36 | bcc *+5 37 | jmp hfill_done 38 | sta reg2 ; A1Y 39 | 40 | // if (A1X > A2X) { 41 | lda _A1X 42 | sta reg0 43 | sec 44 | sbc _A2X ; signed cmp to p2x 45 | .(:bvc skip : eor #$80: skip:.) 46 | bmi hfill_A2xOverOrEqualA1x 47 | #ifdef USE_COLOR 48 | // dx = max(2, A2X); 49 | lda _A2X 50 | sec 51 | sbc #COLUMN_OF_COLOR_ATTRIBUTE 52 | .(:bvc skip : eor #$80: skip:.) 53 | bmi hfill_A2xLowerThan3 54 | lda _A2X 55 | jmp hfill_A2xPositiv 56 | hfill_A2xLowerThan3: 57 | lda #COLUMN_OF_COLOR_ATTRIBUTE 58 | #else 59 | // dx = max(0, A2X); 60 | lda _A2X 61 | bpl hfill_A2xPositiv 62 | lda #0 63 | #endif 64 | hfill_A2xPositiv: 65 | sta tmp0 ; dx 66 | // fx = min(A1X, SCREEN_WIDTH - 1); 67 | lda _A1X 68 | sta tmp1 69 | sec 70 | sbc #SCREEN_WIDTH - 1 71 | .(:bvc skip : eor #$80: skip:.) 72 | bmi hfill_A1xOverScreenWidth 73 | lda #SCREEN_WIDTH - 1 74 | sta tmp1 75 | hfill_A1xOverScreenWidth: 76 | jmp hfill_computeNbPoints 77 | hfill_A2xOverOrEqualA1x: 78 | // } else { 79 | #ifdef USE_COLOR 80 | // dx = max(2, A1X); 81 | lda _A1X 82 | sec 83 | sbc #COLUMN_OF_COLOR_ATTRIBUTE 84 | .(:bvc skip : eor #$80: skip:.) 85 | bmi hfill_A1xLowerThan3 86 | lda _A1X 87 | jmp hfill_A1xPositiv 88 | hfill_A1xLowerThan3: 89 | lda #COLUMN_OF_COLOR_ATTRIBUTE 90 | #else 91 | // dx = max(0, A1X); 92 | lda _A1X 93 | bpl hfill_A1xPositiv 94 | lda #0 95 | #endif 96 | hfill_A1xPositiv: 97 | sta tmp0 98 | // fx = min(A2X, SCREEN_WIDTH - 1); 99 | lda _A2X ; p2x 100 | sta tmp1 101 | sec 102 | sbc #SCREEN_WIDTH - 1 103 | .(:bvc skip : eor #$80: skip:.) 104 | bmi hfill_A2xOverScreenWidth 105 | lda #SCREEN_WIDTH - 1 106 | sta tmp1 107 | hfill_A2xOverScreenWidth: 108 | // } 109 | hfill_computeNbPoints: 110 | // nbpoints = fx - dx; 111 | // if (nbpoints < 0) return; 112 | sec 113 | lda tmp1 114 | sbc tmp0 115 | bmi hfill_done 116 | sta tmp2 117 | 118 | // // printf ("dx=%d py=%d nbpoints=%d dist= %d, char2disp= %d\n", dx, py, nbpoints, dist, char2disp);get(); 119 | 120 | // #ifdef USE_ZBUFFER 121 | // zline(dx, A1Y, nbpoints, distface, ch2disp); 122 | clc 123 | lda sp 124 | sta tmp3 125 | adc #10 126 | sta sp 127 | lda sp+1 128 | sta tmp3+1 129 | adc #0 130 | sta sp+1 131 | lda tmp0 : ldy #0 : sta (sp),y ;; dx 132 | lda reg2 : ldy #2 : sta (sp),y ;; py 133 | lda tmp2 : ldy #4 : sta (sp),y ;; nbpoints 134 | lda _distface : ldy #6 : sta (sp),y ;; dist 135 | lda _ch2disp : ldy #8 : sta (sp),y ;; char2disp 136 | ldy #10 : jsr _zline 137 | lda tmp3 138 | sta sp 139 | lda tmp3+1 140 | sta sp+1 141 | // #else 142 | // // TODO : draw a line whit no z-buffer 143 | // #endif 144 | hfill_done: 145 | // restore context 146 | pla: sta tmp3+1 147 | pla: sta tmp3 148 | pla: sta tmp2 149 | pla: sta tmp1 150 | pla: sta tmp0 151 | pla: sta reg4 152 | pla: sta reg3 153 | pla: sta reg2 154 | pla: sta reg1 155 | pla: sta reg0 156 | pla:tay:pla:tax:pla 157 | // } 158 | ; #ifdef USE_PROFILER 159 | ; PROFILE_LEAVE(ROUTINE_HFILL) 160 | ; #endif 161 | .) 162 | rts 163 | 164 | #endif // USE_ASM_HFILL 165 | -------------------------------------------------------------------------------- /src/raster/hzfill.s: -------------------------------------------------------------------------------- 1 | #include "config.h" 2 | #ifdef USE_PROFILER 3 | #include "profile.h" 4 | #endif 5 | 6 | 7 | #include "raster/hzfill_s.s" 8 | 9 | -------------------------------------------------------------------------------- /src/raster/isA1Right.s: -------------------------------------------------------------------------------- 1 | #ifdef USE_ASM_ISA1RIGHT1 2 | 3 | 4 | #ifdef TARGET_ORIX 5 | ; tmp6 .dsb 2 6 | ; tmp7 .dsb 2 7 | #endif 8 | 9 | ;; void isA1Right1 () 10 | _isA1Right1: 11 | .( 12 | #ifdef SAFE_CONTEXT 13 | ;; save context 14 | pha:txa:pha:tya:pha 15 | lda tmp7 : pha 16 | lda tmp7+1 : pha 17 | lda tmp6 : pha 18 | lda tmp6+1 : pha 19 | #endif ;; SAFE_CONTEXT 20 | ;; if ((mDeltaX1 & 0x80) == 0){ 21 | lda #$00 : sta _A1Right 22 | lda _mDeltaX1 23 | bmi isA1Right1_mDeltaX1_negativ: 24 | 25 | ;; if ((mDeltaX2 & 0x80) == 0){ 26 | lda _mDeltaX2 27 | bmi isA1Right1_mDeltaX2_negativ_01 28 | ;; ;; printf ("%d*%d %d*%d ", mDeltaY1, mDeltaX2, mDeltaY2,mDeltaX1);get (); 29 | ;; A1Right = (log2_tab[mDeltaX2] + log2_tab[mDeltaY1]) > (log2_tab[mDeltaX1] + log2_tab[mDeltaY2]); 30 | ;; ;; A1Right = mDeltaY1*mDeltaX2 > mDeltaY2*mDeltaX1; 31 | 32 | ldx _mDeltaY1 33 | ldy _mDeltaX2 34 | clc 35 | lda _log2_tab,x 36 | adc _log2_tab,y 37 | ror ; to avoid modulo by overflow 38 | sta tmp7 39 | 40 | ldx _mDeltaX1 ; abs(mDeltaX1) 41 | ldy _mDeltaY2 42 | clc 43 | lda _log2_tab,x 44 | adc _log2_tab,y 45 | ror ; to avoid modulo by overflow 46 | sta tmp7+1 ; (log2_tab[abs(mDeltaX1)] + log2_tab[mDeltaY2]) 47 | 48 | cmp tmp7 49 | 50 | bcs isA1Right1_done 51 | 52 | lda #$01 : sta _A1Right 53 | 54 | jmp isA1Right1_done 55 | isA1Right1_mDeltaX2_negativ_01: 56 | ;; } else { 57 | lda #$00 : sta _A1Right 58 | ;; A1Right = 0 ; ;; (mDeltaX1 < 0) 59 | ;; } 60 | jmp isA1Right1_done 61 | isA1Right1_mDeltaX1_negativ: 62 | ;; } else { 63 | eor #$ff: sec: adc #$00: sta tmp6 ; tmp6 = abs(mDeltaX1) 64 | 65 | ;; if ((mDeltaX2 & 0x80) == 0){ 66 | lda _mDeltaX2 67 | bmi isA1Right1_mDeltaX2_negativ_02 68 | ;; A1Right = 1 ; ;; (mDeltaX1 < 0) 69 | lda #$01 : sta _A1Right 70 | jmp isA1Right1_done 71 | isA1Right1_mDeltaX2_negativ_02; 72 | ;; } else { 73 | ;; ;; printf ("%d*%d %d*%d ", mDeltaY1, -mDeltaX2, mDeltaY2,-mDeltaX1);get (); 74 | eor #$ff: sec: adc #$00: sta tmp6+1 ; tmp6+1 = abs(mDeltaX2) 75 | ;; A1Right = (log2_tab[abs(mDeltaX2)] + log2_tab[mDeltaY1]) < (log2_tab[abs(mDeltaX1)] + log2_tab[mDeltaY2]); 76 | 77 | ldx tmp6+1 ; abs(mDeltaX2) 78 | ldy _mDeltaY1 79 | clc 80 | lda _log2_tab,x 81 | adc _log2_tab,y 82 | ror ; to avoid modulo by overflow 83 | sta tmp7 ; log2_tab[abs(mDeltaX2)] + log2_tab[mDeltaY1] 84 | 85 | ldx tmp6 ; abs(mDeltaX1) 86 | ldy _mDeltaY2 87 | clc 88 | lda _log2_tab,x 89 | adc _log2_tab,y 90 | ror ; to avoid modulo by overflow 91 | sta tmp7+1 ; (log2_tab[abs(mDeltaX1)] + log2_tab[mDeltaY2]) 92 | 93 | cmp tmp7 94 | 95 | bcc isA1Right1_done 96 | 97 | lda #$01 : sta _A1Right 98 | 99 | ;; } 100 | ;; } 101 | 102 | isA1Right1_done: 103 | #ifdef SAFE_CONTEXT 104 | ;; restore context 105 | pla : sta tmp6+1 : 106 | pla : sta tmp6 : 107 | pla : sta tmp7+1 : 108 | pla : sta tmp7 : 109 | pla:tay:pla:tax:pla 110 | #endif ;; SAFE_CONTEXT 111 | .) 112 | rts 113 | #endif ;; USE_ASM_ISA1RIGHT1 114 | 115 | #ifdef USE_ASM_ISA1RIGHT3 116 | ;; void isA1Right3 () 117 | _isA1Right3: 118 | .( 119 | lda #$00 : sta _A1Right 120 | 121 | ;; A1Right = (A1X > A2X); 122 | lda _A2X 123 | sec 124 | sbc _A1X 125 | .(:bvc skip : eor #$80: skip:.) 126 | bpl isA1Right3_done 127 | 128 | lda #$01 : sta _A1Right 129 | isA1Right3_done: 130 | .) 131 | rts 132 | #endif ;; USE_ASM_ISA1RIGHT3 -------------------------------------------------------------------------------- /src/raster/line.asm: -------------------------------------------------------------------------------- 1 | .include "config.inc" ; #include "config.h" 2 | 3 | .importzp ptr1 4 | 5 | _PosPrint := ptr1 6 | 7 | 8 | 9 | _PrintX: .byte 0 10 | _PrintY: .byte 0 11 | 12 | .segment "CODE" 13 | 14 | .proc _computePosPrint 15 | 16 | lda #$BB 17 | sta _PosPrint+1 18 | clc 19 | lda #$80 20 | adc _PrintX 21 | ldx _PrintY 22 | beq prdone 23 | nxtline: 24 | adc #40 25 | bcc noincline 26 | inc _PosPrint+1 27 | clc 28 | noincline: 29 | dex 30 | bne nxtline 31 | prdone: 32 | sta _PosPrint 33 | 34 | rts 35 | .endproc 36 | 37 | err: .byte 0 38 | e2: .byte 0 39 | 40 | _Point1X: .byte 0 41 | _Point1Y: .byte 0 42 | _Point2X: .byte 0 43 | _Point2Y: .byte 0 44 | _char2Display: .byte 0 45 | 46 | dX: .byte 0 47 | dY: .byte 0 48 | stepX: .byte 0 49 | stepY: .byte 0 50 | 51 | .proc plotOrNot 52 | 53 | lda _Point1X 54 | bmi plotdone 55 | beq plotdone 56 | cmp #SCREEN_WIDTH 57 | bpl plotdone 58 | sta _PrintX 59 | lda _Point1Y 60 | bmi plotdone 61 | beq plotdone 62 | cmp SCREEN_HEIGHT 63 | bpl plotdone 64 | sta _PrintY 65 | jsr _computePosPrint 66 | lda _char2Display ;#42 67 | ldy #00 68 | sta (_PosPrint),y 69 | plotdone: 70 | rts 71 | .endproc 72 | 73 | ;--------------------------------------------------------------------------------- 74 | ; drawLine 75 | ;--------------------------------------------------------------------------------- 76 | 77 | .export _drawLine 78 | 79 | .proc _drawLine 80 | 81 | ;; save context 82 | pha 83 | txa 84 | pha 85 | tya 86 | pha 87 | 88 | 89 | ;lda _Point1X 90 | ;sta _PrintX 91 | ;lda _Point1Y 92 | ;sta _PrintY 93 | ;jsr _printChar 94 | ;lda #65 95 | ;ldy #00 96 | ;sta (_PosPrint),y 97 | 98 | 99 | ;; dx = abs(x1-x0); 100 | ;; sx = x0= 0 : 106 | bmi x1overx0 107 | ; dx = a 108 | sta dX 109 | ; sx = -1 110 | lda #$FF 111 | sta stepX 112 | jmp computeDy 113 | ; else 114 | x1overx0: 115 | ; dx = -a 116 | eor #$FF 117 | sec 118 | adc #$00 119 | sta dX 120 | ; sx =1 121 | lda #$01 122 | sta stepX 123 | ; endif 124 | computeDy: 125 | ;; dy = -abs(y1-y0); 126 | ;; sy = y0= 0 : 132 | bmi y1overy0 133 | ; dy = -a 134 | eor #$FF 135 | sec 136 | adc #$00 137 | sta dY 138 | ; sy = -1 139 | lda #$FF 140 | sta stepY 141 | jmp computeErr 142 | ; else 143 | y1overy0: 144 | ; dy = a 145 | sta dY 146 | ; sy = 1 147 | lda #$01 148 | sta stepY 149 | ; endif 150 | computeErr: 151 | ;; err = dx+dy; /* error value e_xy */ 152 | ; a = dx 153 | lda dX 154 | ; a = a + dy 155 | clc 156 | adc dY 157 | ; err = a 158 | sta err 159 | ;; while (true) /* loop */ 160 | drawloop: 161 | ;; PLOT (x0, y0) 162 | jsr plotOrNot 163 | ;; if (x0==x1 && y0==y1) break; 164 | ; a = x0 165 | lda _Point1X 166 | ; if a != x1 goto continue 167 | cmp _Point2X 168 | bne continue 169 | ; a = y0 170 | lda _Point1Y 171 | ; if a != y1 goto continue 172 | cmp _Point2Y 173 | bne continue 174 | ; goto endloop 175 | jmp endloop 176 | ;continue: 177 | continue: 178 | ;; e2 = 2*err; 179 | ; a = err 180 | lda err 181 | ; a = a << 2 182 | asl 183 | ; e2 = a 184 | sta e2 185 | ;; if (e2 >= dy) 186 | ; a = e2 (opt) 187 | ; if a < dy then goto dyovera 188 | cmp dY 189 | bmi dyovera 190 | ;; err += dy; /* e_xy+e_x > 0 */ 191 | ; a = err 192 | lda err 193 | ; a = a + dy 194 | clc 195 | adc dY 196 | ; err = a 197 | sta err 198 | ;; x0 += sx; 199 | ; a = x0 200 | lda _Point1X 201 | ; a = a + sx 202 | clc 203 | adc stepX 204 | ; x0 = a 205 | sta _Point1X 206 | ;dyovera: 207 | dyovera: 208 | ;; end if 209 | ;; if (e2 <= dx) /* e_xy+e_y < 0 */ 210 | ; a = dx 211 | lda dX 212 | ; if a < e2 then goto e2overdx 213 | cmp e2 214 | bmi e2overdx 215 | ;; err += dx; 216 | ; a = err 217 | lda err 218 | ; a = a + dx 219 | clc 220 | adc dX 221 | ; err = a 222 | sta err 223 | ;; y0 += sy; 224 | ; a = y0 225 | lda _Point1Y 226 | ; a = a + sy 227 | clc 228 | adc stepY 229 | ; y0 = a 230 | sta _Point1Y 231 | ;; end if 232 | ;e2overdx: 233 | e2overdx: 234 | ; goto drawloop 235 | jmp drawloop 236 | ;; end while 237 | ;endloop: 238 | endloop: 239 | 240 | ;; restore context 241 | pla 242 | tay 243 | pla 244 | tax 245 | pla 246 | 247 | rts 248 | .endproc 249 | 250 | -------------------------------------------------------------------------------- /src/raster/line.s: -------------------------------------------------------------------------------- 1 | #include "config.h" 2 | 3 | .zero 4 | _PosPrint .dsb 2 5 | 6 | .text 7 | 8 | _PrintX .dsb 1 9 | _PrintY .dsb 1 10 | 11 | _computePosPrint: 12 | .( 13 | lda #$BB 14 | sta _PosPrint+1 15 | clc 16 | lda #$80 17 | adc _PrintX 18 | ldx _PrintY 19 | beq prdone 20 | nxtline: 21 | adc #40 22 | bcc noincline 23 | inc _PosPrint+1 24 | clc 25 | noincline: 26 | dex 27 | bne nxtline 28 | prdone: 29 | sta _PosPrint 30 | .) 31 | rts 32 | 33 | 34 | err .dsb 1 35 | e2 .dsb 1 36 | 37 | 38 | dX .dsb 1 39 | dY .dsb 1 40 | stepX .dsb 1 41 | stepY .dsb 1 42 | 43 | plotOrNot: 44 | .( 45 | lda _Point1X 46 | bmi plotdone 47 | beq plotdone 48 | cmp #SCREEN_WIDTH 49 | bpl plotdone 50 | sta _PrintX 51 | lda _Point1Y 52 | bmi plotdone 53 | beq plotdone 54 | cmp #SCREEN_HEIGHT 55 | bpl plotdone 56 | sta _PrintY 57 | jsr _computePosPrint 58 | lda _char2Display ;#42 59 | ldy #00 60 | sta (_PosPrint),y 61 | plotdone: 62 | .) 63 | rts 64 | 65 | _drawLine: 66 | .( 67 | // save context 68 | pha:txa:pha:tya:pha 69 | 70 | 71 | ;lda _Point1X 72 | ;sta _PrintX 73 | ;lda _Point1Y 74 | ;sta _PrintY 75 | ;jsr _printChar 76 | ;lda #65 77 | ;ldy #00 78 | ;sta (_PosPrint),y 79 | 80 | 81 | // dx = abs(x1-x0); 82 | // sx = x0= 0 : 88 | bmi x1overx0 89 | ; dx = a 90 | sta dX 91 | ; sx = -1 92 | lda #$FF 93 | sta stepX 94 | jmp computeDy 95 | ; else 96 | x1overx0: 97 | ; dx = -a 98 | eor #$FF 99 | sec 100 | adc #$00 101 | sta dX 102 | ; sx =1 103 | lda #$01 104 | sta stepX 105 | ; endif 106 | computeDy: 107 | // dy = -abs(y1-y0); 108 | // sy = y0= 0 : 114 | bmi y1overy0 115 | ; dy = -a 116 | eor #$FF 117 | sec 118 | adc #$00 119 | sta dY 120 | ; sy = -1 121 | lda #$FF 122 | sta stepY 123 | jmp computeErr 124 | ; else 125 | y1overy0: 126 | ; dy = a 127 | sta dY 128 | ; sy = 1 129 | lda #$01 130 | sta stepY 131 | ; endif 132 | computeErr: 133 | // err = dx+dy; /* error value e_xy */ 134 | ; a = dx 135 | lda dX 136 | ; a = a + dy 137 | clc 138 | adc dY 139 | ; err = a 140 | sta err 141 | // if ((A1err >= 64) ||(A1err < -64)) return; 142 | sec 143 | sbc #$40 144 | .(:bvc skip : eor #$80: skip:.) 145 | bpl endloop 146 | lda err 147 | sec 148 | sbc #$C0 149 | .(:bvc skip : eor #$80: skip:.) 150 | bmi endloop 151 | 152 | // while (true) /* loop */ 153 | drawloop: 154 | // PLOT (x0, y0) 155 | jsr plotOrNot 156 | // if (x0==x1 && y0==y1) break; 157 | ; a = x0 158 | lda _Point1X 159 | ; if a != x1 goto continue 160 | cmp _Point2X 161 | bne continue 162 | ; a = y0 163 | lda _Point1Y 164 | ; if a != y1 goto continue 165 | cmp _Point2Y 166 | bne continue 167 | ; goto endloop 168 | jmp endloop 169 | ;continue: 170 | continue: 171 | // e2 = 2*err; 172 | ; a = err 173 | lda err 174 | ; a = a << 2 175 | asl 176 | ; e2 = a 177 | sta e2 178 | // if (e2 >= dy) 179 | ; a = e2 (opt) 180 | ; if a < dy then goto dyovera 181 | sec 182 | sbc dY 183 | .(:bvc skip : eor #$80: skip:.) 184 | bmi dyovera 185 | // err += dy; /* e_xy+e_x > 0 */ 186 | ; a = err 187 | lda err 188 | ; a = a + dy 189 | clc 190 | adc dY 191 | ; err = a 192 | sta err 193 | // x0 += sx; 194 | ; a = x0 195 | lda _Point1X 196 | ; a = a + sx 197 | clc 198 | adc stepX 199 | ; x0 = a 200 | sta _Point1X 201 | ;dyovera: 202 | dyovera: 203 | // end if 204 | // if (e2 <= dx) /* e_xy+e_y < 0 */ 205 | ; a = dx 206 | lda dX 207 | ; if a < e2 then goto e2overdx 208 | sec 209 | sbc e2 210 | bvc*+4 211 | eor #$80 212 | bmi e2overdx 213 | // err += dx; 214 | ; a = err 215 | lda err 216 | ; a = a + dx 217 | clc 218 | adc dX 219 | ; err = a 220 | sta err 221 | // y0 += sy; 222 | ; a = y0 223 | lda _Point1Y 224 | ; a = a + sy 225 | clc 226 | adc stepY 227 | ; y0 = a 228 | sta _Point1Y 229 | // end if 230 | ;e2overdx: 231 | e2overdx: 232 | ; goto drawloop 233 | jmp drawloop 234 | // end while 235 | ;endloop: 236 | endloop: 237 | 238 | // restore context 239 | pla:tay:pla:tax:pla 240 | 241 | .) 242 | rts 243 | -------------------------------------------------------------------------------- /src/raster/particules.s: -------------------------------------------------------------------------------- 1 | #include "config.h" 2 | 3 | #include "glDrawParticles.s" 4 | 5 | -------------------------------------------------------------------------------- /src/raster/reachScreen.s: -------------------------------------------------------------------------------- 1 | #ifdef USE_ASM_REACHSCREEN 2 | ;; void reachScreen() 3 | _reachScreen: 4 | .( 5 | jmp reachScreen_Lbresfill130 : 6 | reachScreen_Lbresfill129 7 | ldy #0 : jsr _A1stepY : 8 | ldy #0 : jsr _A2stepY : 9 | reachScreen_Lbresfill130 10 | lda _A1arrived 11 | bne reachScreen_done 12 | lda _A1Y : sec: 13 | #ifdef USE_COLOR 14 | sbc #SCREEN_HEIGHT-NB_LESS_LINES_4_COLOR 15 | #else 16 | sbc #SCREEN_HEIGHT 17 | #endif 18 | .(:bvc skip : eor #$80: skip:.) 19 | bmi *+5 : jmp reachScreen_Lbresfill129 20 | reachScreen_done 21 | .) 22 | rts 23 | #endif ;; USE_ASM_REACHSCREEN 24 | -------------------------------------------------------------------------------- /src/raster/seg8.s: -------------------------------------------------------------------------------- 1 | #include "config.h" 2 | #ifdef USE_PROFILER 3 | #include "profile.h" 4 | #endif // USE_PROFILER 5 | 6 | #include "glDrawSegments.s" 7 | 8 | -------------------------------------------------------------------------------- /src/reachScreen.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_C_REACHSCREEN 2 | void reachScreen(){ 3 | #ifdef USE_COLOR 4 | while ((A1Y >= SCREEN_HEIGHT-NB_LESS_LINES_4_COLOR) && (A1arrived == 0)){ 5 | #else 6 | while ((A1Y >= SCREEN_HEIGHT) && (A1arrived == 0)){ 7 | #endif 8 | A1stepY(); 9 | A2stepY(); 10 | } 11 | } 12 | #endif // USE_C_REACHSCREEN 13 | 14 | -------------------------------------------------------------------------------- /src/render/colors.h: -------------------------------------------------------------------------------- 1 | #ifndef COLORS_H 2 | #define COLORS_H 3 | 4 | #define LORES_SCREEN_ADDRESS 0xBB80 5 | #define HIRES_SCREEN_ADDRESS 0xA000 6 | 7 | #define LORES_SCREEN_WIDTH 40 8 | #define LORES_SCREEN_HEIGHT 26 9 | 10 | #define HIRES_SCREEN_WIDTH 240 11 | #define HIRES_SCREEN_HEIGHT 200 12 | 13 | 14 | #define INK_BLACK 0 15 | #define INK_RED 1 16 | #define INK_GREEN 2 17 | #define INK_YELLOW 3 18 | #define INK_BLUE 4 19 | #define INK_MAGENTA 5 20 | #define INK_CYAN 6 21 | #define INK_WHITE 7 22 | 23 | // Character Set modifier 24 | #define STANDARD_CHARSET 8 // Use Standard Charset 25 | #define ALTERNATE_CHARSET 9 // Use Alternate Charset 26 | #define DOUBLE_STANDARD_CHARSET 10 // Use Double Size Standard Charset 27 | #define DOUBLE_ALTERNATE_CHARSET 11 // Use Double Size Alternate Charset 28 | #define BLINKING_STANDARD_CHARSET 12 // Use Blinking Standard Charset 29 | #define BLINKING_ALTERNATE_CHARSET 13 // Use Blinking Alternate Charset 30 | #define DOUBLE_BLINK_STANDARD_CHARSET 14 // Use Double Size Blinking Standard Charset 31 | #define DOUBLE_BLINK_ALTERNATE_CHARSET 15 // Use Double Size Blinking Alternate Charset 32 | 33 | // Change Paper (background) color 34 | #define PAPER_BLACK 16 35 | #define PAPER_RED 17 36 | #define PAPER_GREEN 18 37 | #define PAPER_YELLOW 19 38 | #define PAPER_BLUE 20 39 | #define PAPER_MAGENTA 21 40 | #define PAPER_CYAN 22 41 | #define PAPER_WHITE 23 42 | 43 | // Video control attributes 44 | #define TEXT_60Hz 24 45 | #define TEXT_50Hz 26 46 | #define HIRES_60Hz 28 47 | #define HIRES_50Hz 30 48 | 49 | 50 | 51 | #endif // COLORS_H -------------------------------------------------------------------------------- /src/render/glBuffer2Screen.s: -------------------------------------------------------------------------------- 1 | #ifdef USE_ASM_BUFFER2SCREEN 2 | 3 | .text 4 | 5 | _glBuffer2Screen: 6 | .( 7 | ldy #$00 8 | 9 | buffer2screen_loop_01: 10 | 11 | lda _fbuffer, y 12 | sta ADR_BASE_LORES_SCREEN,y 13 | lda _fbuffer+256, y 14 | sta ADR_BASE_LORES_SCREEN+256,y 15 | lda _fbuffer+512, y 16 | sta ADR_BASE_LORES_SCREEN+512,y 17 | lda _fbuffer+768, y 18 | sta ADR_BASE_LORES_SCREEN+768,y 19 | iny 20 | bne buffer2screen_loop_01 21 | 22 | ldy #$10 23 | 24 | buffer2screen_loop_02: 25 | 26 | lda _fbuffer+1024, y 27 | sta ADR_BASE_LORES_SCREEN+1024,y 28 | dey 29 | bpl buffer2screen_loop_02 30 | 31 | .) 32 | rts 33 | 34 | 35 | #endif ;; USE_ASM_BUFFER2SCREEN 36 | -------------------------------------------------------------------------------- /src/render/glInitScreenBuffers.s: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_ASM_INITFRAMEBUFFER 3 | .text 4 | ;; void glInitScreenBuffers() 5 | _glInitScreenBuffers: 6 | .( 7 | 8 | lda #$FF 9 | ldx #SCREEN_WIDTH-1 10 | 11 | initScreenBuffersLoop_01: 12 | sta _zbuffer+SCREEN_WIDTH*0 , x 13 | sta _zbuffer+SCREEN_WIDTH*1 , x 14 | sta _zbuffer+SCREEN_WIDTH*2 , x 15 | sta _zbuffer+SCREEN_WIDTH*3 , x 16 | sta _zbuffer+SCREEN_WIDTH*4 , x 17 | sta _zbuffer+SCREEN_WIDTH*5 , x 18 | sta _zbuffer+SCREEN_WIDTH*6 , x 19 | sta _zbuffer+SCREEN_WIDTH*7 , x 20 | sta _zbuffer+SCREEN_WIDTH*8 , x 21 | sta _zbuffer+SCREEN_WIDTH*9 , x 22 | sta _zbuffer+SCREEN_WIDTH*10 , x 23 | sta _zbuffer+SCREEN_WIDTH*11 , x 24 | sta _zbuffer+SCREEN_WIDTH*12 , x 25 | sta _zbuffer+SCREEN_WIDTH*13 , x 26 | sta _zbuffer+SCREEN_WIDTH*14 , x 27 | sta _zbuffer+SCREEN_WIDTH*15 , x 28 | sta _zbuffer+SCREEN_WIDTH*16 , x 29 | sta _zbuffer+SCREEN_WIDTH*17 , x 30 | sta _zbuffer+SCREEN_WIDTH*18 , x 31 | sta _zbuffer+SCREEN_WIDTH*19 , x 32 | sta _zbuffer+SCREEN_WIDTH*20 , x 33 | sta _zbuffer+SCREEN_WIDTH*21 , x 34 | sta _zbuffer+SCREEN_WIDTH*22 , x 35 | sta _zbuffer+SCREEN_WIDTH*23 , x 36 | sta _zbuffer+SCREEN_WIDTH*24 , x 37 | sta _zbuffer+SCREEN_WIDTH*25 , x 38 | sta _zbuffer+SCREEN_WIDTH*26 , x 39 | dex 40 | bne initScreenBuffersLoop_01 41 | 42 | #ifndef USE_HORIZON 43 | lda #$20 44 | #endif ;; USE_HORIZON 45 | 46 | ldx #SCREEN_WIDTH-1 47 | 48 | initScreenBuffersLoop_02: 49 | #ifdef USE_HORIZON 50 | lda #$20 51 | #endif ;; USE_HORIZON 52 | sta _fbuffer+SCREEN_WIDTH*0 , x 53 | sta _fbuffer+SCREEN_WIDTH*1 , x 54 | sta _fbuffer+SCREEN_WIDTH*2 , x 55 | sta _fbuffer+SCREEN_WIDTH*3 , x 56 | sta _fbuffer+SCREEN_WIDTH*4 , x 57 | sta _fbuffer+SCREEN_WIDTH*5 , x 58 | sta _fbuffer+SCREEN_WIDTH*6 , x 59 | sta _fbuffer+SCREEN_WIDTH*7 , x 60 | sta _fbuffer+SCREEN_WIDTH*8 , x 61 | sta _fbuffer+SCREEN_WIDTH*9 , x 62 | sta _fbuffer+SCREEN_WIDTH*10 , x 63 | sta _fbuffer+SCREEN_WIDTH*11 , x 64 | sta _fbuffer+SCREEN_WIDTH*12 , x 65 | sta _fbuffer+SCREEN_WIDTH*13 , x 66 | #ifdef USE_HORIZON 67 | lda #102 ;; light green 68 | #endif ;; USE_HORIZON 69 | sta _fbuffer+SCREEN_WIDTH*14 , x 70 | sta _fbuffer+SCREEN_WIDTH*15 , x 71 | sta _fbuffer+SCREEN_WIDTH*16 , x 72 | sta _fbuffer+SCREEN_WIDTH*17 , x 73 | sta _fbuffer+SCREEN_WIDTH*18 , x 74 | sta _fbuffer+SCREEN_WIDTH*19 , x 75 | sta _fbuffer+SCREEN_WIDTH*20 , x 76 | sta _fbuffer+SCREEN_WIDTH*21 , x 77 | #ifndef USE_COLOR 78 | sta _fbuffer+SCREEN_WIDTH*22 , x 79 | sta _fbuffer+SCREEN_WIDTH*23 , x 80 | sta _fbuffer+SCREEN_WIDTH*24 , x 81 | sta _fbuffer+SCREEN_WIDTH*25 , x 82 | sta _fbuffer+SCREEN_WIDTH*26 , x 83 | #endif 84 | dex 85 | #ifdef USE_COLOR 86 | cpx #2 87 | beq initScreenBuffersDone 88 | #endif ;; USE_COLOR 89 | bpl initScreenBuffersLoop_02 90 | initScreenBuffersDone: 91 | .) 92 | rts 93 | 94 | 95 | #endif ;; USE_ASM_INITFRAMEBUFFER 96 | -------------------------------------------------------------------------------- /src/render/lrsDrawing.h: -------------------------------------------------------------------------------- 1 | #ifndef LRSDRAWING_H 2 | #define LRSDRAWING_H 3 | extern void change_char(char c, unsigned char patt01, unsigned char patt02, unsigned char patt03, unsigned char patt04, unsigned char patt05, unsigned char patt06, unsigned char patt07, unsigned char patt08); 4 | #ifdef USE_REWORKED_BUFFERS 5 | extern void glDrawFaces(); 6 | extern void glDrawSegments(); 7 | extern void glDrawParticles(); 8 | #else 9 | extern void lrDrawFaces(char points2d[], unsigned char faces[], unsigned char glNbFaces); 10 | extern void lrDrawSegments(char points2d[], unsigned char segments[], unsigned char glNbSegments); 11 | extern void lrDrawParticles(char points2d[], unsigned char particles[], unsigned char glNbParticles); 12 | 13 | #endif // USE_REWORKED_BUFFERS 14 | #endif // LRSDRAWING_H -------------------------------------------------------------------------------- /src/render/lrsSegments.s: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | .zero 5 | pSeg .dsb 2 6 | 7 | 8 | #ifdef SAVE_ZERO_PAGE 9 | .text 10 | #endif 11 | 12 | _Point1X .dsb 1 13 | _Point1Y .dsb 1 14 | _Point2X .dsb 1 15 | _Point2Y .dsb 1 16 | _char2Display .dsb 1 17 | 18 | 19 | idxPt1 .dsb 1 20 | idxPt2 .dsb 1 21 | //_char2Display .dsb 1 22 | 23 | #ifndef SAVE_ZERO_PAGE 24 | .text 25 | #endif 26 | 27 | #ifdef TEXTDEMO 28 | #ifndef USE_REWORKED_BUFFERS 29 | 30 | // void drawSegments(){ 31 | _drawSegments: 32 | .( 33 | // save context 34 | pha:txa:pha:tya:pha 35 | // unsigned char ii = 0; 36 | // unsigned char idxPt1, idxPt2; 37 | // for (ii = 0; ii< glNbSegments; ii++){ 38 | ;lda #_segments 56 | adc #$00 57 | sta pSeg+1 58 | ldy #$00 59 | lda (pSeg),y 60 | sta idxPt1 61 | 62 | // idxPt2 = segments[ii*SIZEOF_SEGMENT + 1]; 63 | iny 64 | lda (pSeg),y 65 | sta idxPt2 66 | 67 | // char2Display = segments[ii*SIZEOF_SEGMENT + 2]; 68 | iny 69 | lda (pSeg),y 70 | sta _char2Display 71 | 72 | // 73 | // Point1X = points2d[idxPt1*SIZEOF_2DPOINT + 0]; 74 | lda idxPt1 ; 75 | asl ; idxPt1 * SIZEOF_2DPOINT 76 | asl 77 | sta ptrpt2L 78 | lda #<_points2d 79 | clc 80 | adc ptrpt2L 81 | sta ptrpt2L 82 | lda #>_points2d 83 | adc #$00 84 | sta ptrpt2H 85 | 86 | ldy #$00 87 | lda (ptrpt2),y 88 | sta _Point1X 89 | 90 | // Point1Y = points2d[idxPt1*SIZEOF_2DPOINT + 1]; 91 | iny 92 | lda (ptrpt2),y 93 | sta _Point1Y 94 | 95 | // Point2X = points2d[idxPt2*SIZEOF_2DPOINT + 0]; 96 | lda idxPt2 ; 97 | asl ; idxPt2 * SIZEOF_2DPOINT 98 | asl 99 | sta ptrpt2L 100 | lda #<_points2d 101 | clc 102 | adc ptrpt2L 103 | sta ptrpt2L 104 | lda #>_points2d 105 | adc #$00 106 | sta ptrpt2H 107 | 108 | ldy #$00 109 | lda (ptrpt2),y 110 | sta _Point2X 111 | 112 | // Point2Y = points2d[idxPt2*SIZEOF_2DPOINT + 1]; 113 | iny 114 | lda (ptrpt2),y 115 | sta _Point2Y 116 | 117 | // drawLine (); 118 | jsr _drawLine 119 | // } 120 | dex 121 | txa 122 | cmp #$FF 123 | bne drwloop 124 | drwsgdone 125 | // } 126 | // restore context 127 | pla:tay:pla:tax:pla 128 | .) 129 | rts 130 | 131 | #endif // undef USE_REWORKED_BUFFERS 132 | 133 | #endif // TEXTDEMO 134 | 135 | 136 | 137 | 138 | 139 | /* 140 | // void fastdrawSegments(){ 141 | _fastDrawSegments: 142 | .( 143 | // save context 144 | pha:txa:pha:tya:pha 145 | 146 | 147 | // unsigned char ii = 0; 148 | // unsigned char idxPt1, idxPt2; 149 | // for (ii = 0; ii< glNbSegments; ii++){ 150 | ;lda #_segments 168 | adc #$00 169 | sta pSeg+1 170 | ldy #$00 171 | lda (pSeg),y 172 | sta idxPt1 173 | 174 | // idxPt2 = segments[ii*SIZEOF_SEGMENT + 1]; 175 | iny 176 | lda (pSeg),y 177 | sta idxPt2 178 | 179 | // char2Display = segments[ii*SIZEOF_SEGMENT + 2]; 180 | iny 181 | lda (pSeg),y 182 | sta _char2Display 183 | 184 | // 185 | // Point1X = points2d[idxPt1*SIZEOF_2DPOINT + 0]; 186 | lda idxPt1 ; 187 | asl ; idxPt1 * SIZEOF_2DPOINT 188 | asl 189 | sta ptrpt2L 190 | lda #<_points2d 191 | clc 192 | adc ptrpt2L 193 | sta ptrpt2L 194 | lda #>_points2d 195 | adc #$00 196 | sta ptrpt2H 197 | 198 | ldy #$00 199 | lda (ptrpt2),y 200 | sta _Point1X 201 | 202 | // Point1Y = points2d[idxPt1*SIZEOF_2DPOINT + 1]; 203 | iny 204 | lda (ptrpt2),y 205 | sta _Point1Y 206 | 207 | // Point2X = points2d[idxPt2*SIZEOF_2DPOINT + 0]; 208 | lda idxPt2 ; 209 | asl ; idxPt1 * SIZEOF_2DPOINT 210 | asl 211 | sta ptrpt2L 212 | lda #<_points2d 213 | clc 214 | adc ptrpt2L 215 | sta ptrpt2L 216 | lda #>_points2d 217 | adc #$00 218 | sta ptrpt2H 219 | 220 | ldy #$00 221 | lda (ptrpt2),y 222 | sta _Point2X 223 | 224 | // Point2Y = points2d[idxPt2*SIZEOF_2DPOINT + 1]; 225 | iny 226 | lda (ptrpt2),y 227 | sta _Point2Y 228 | 229 | // drawLine (); 230 | jsr _drawLine 231 | // } 232 | dex 233 | bpl drwloop 234 | drwsgdone 235 | // } 236 | // restore context 237 | pla:tay:pla:tax:pla 238 | .) 239 | rts 240 | */ 241 | -------------------------------------------------------------------------------- /src/render/zbuffer.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef ZBUFFER_H 3 | #define ZBUFFER_H 4 | 5 | #ifdef USE_MULTI40 6 | extern int multi40[]; 7 | #endif 8 | 9 | #ifdef USE_ZBUFFER 10 | 11 | 12 | #ifdef TARGET_ORIX 13 | char fbuffer [SCREEN_WIDTH*SCREEN_HEIGHT]; 14 | unsigned char zbuffer [SCREEN_WIDTH*SCREEN_HEIGHT]; 15 | #else 16 | extern unsigned char zbuffer[]; // z-depth buffer SCREEN_WIDTH * SCREEN_HEIGHT 17 | extern char fbuffer[]; // frame buffer SCREEN_WIDTH * SCREEN_HEIGHT 18 | #endif 19 | 20 | extern void glInitScreenBuffers(); 21 | 22 | extern void glBuffer2Screen(); 23 | extern void glZPlot(signed char X, signed char Y, unsigned char dist, char char2disp); 24 | 25 | #ifdef USE_ASM_ZLINE 26 | extern void zline(signed char dx, signed char py, unsigned char nbpoints, unsigned char dist, char char2disp); 27 | #endif 28 | 29 | #endif // USE_ZBUFFER 30 | #endif // ZBUFFER_H 31 | 32 | -------------------------------------------------------------------------------- /src/retrieveFaceData.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_C_RETRIEVEFACEDATA 2 | void retrieveFaceData(){ 3 | 4 | // printf ("face %d : %d %d %d\n",ii, idxPt1, idxPt2, idxPt3);get(); 5 | dmoy = points2dL[idxPt1]; //*((int*)(points2d + offPt1 + 2)); 6 | P1AH = points2aH[idxPt1]; 7 | P1AV = points2aV[idxPt1]; 8 | 9 | dmoy += points2dL[idxPt2]; //*((int*)(points2d + offPt2 + 2)); 10 | P2AH = points2aH[idxPt2]; 11 | P2AV = points2aV[idxPt2]; 12 | 13 | dmoy += points2dL[idxPt3]; //*((int*)(points2d + offPt3 + 2)); 14 | P3AH = points2aH[idxPt3]; 15 | P3AV = points2aV[idxPt3]; 16 | 17 | // printf ("dis %d %d %d\n",d1, d2, d3);get(); 18 | dmoy = dmoy / 3; 19 | if (dmoy >= 256) { 20 | dmoy = 256; 21 | } 22 | distface = (unsigned char)(dmoy & 0x00FF); 23 | 24 | // printf ("disface %d %d\n",dmoy, distface);get(); 25 | 26 | } 27 | #endif // USE_C_RETRIEVEFACEDATA 28 | -------------------------------------------------------------------------------- /src/satur.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_SATURATION 2 | 3 | // #define USE_C_INITSATUR_A1RIGHT 4 | #ifdef USE_C_INITSATUR_A1RIGHT 5 | void initSatur_A1Right() { 6 | if (A1X > SCREEN_WIDTH - 1) { 7 | A1XSatur = 1; 8 | } else if (A1X == SCREEN_WIDTH - 1) { 9 | if (A1sX == 1) { 10 | A1XSatur = 1; 11 | } else { 12 | A1XSatur = 0; 13 | } 14 | } else { 15 | A1XSatur = 0; 16 | } 17 | 18 | #ifndef USE_COLOR 19 | if (A2X < 0) { 20 | #else 21 | if (A2X < COLUMN_OF_COLOR_ATTRIBUTE) { 22 | #endif 23 | A2XSatur = 1; 24 | } 25 | #ifndef USE_COLOR 26 | else if (A2X == 0) { 27 | 28 | #else 29 | else if (A2X == COLUMN_OF_COLOR_ATTRIBUTE) { 30 | #endif 31 | if (A2sX == 1) { 32 | A2XSatur = 0; 33 | } else { 34 | A2XSatur = 1; 35 | } 36 | 37 | } else { 38 | A2XSatur = 0; 39 | } 40 | } 41 | #endif // USE_C_INITSATUR_A1RIGHT 42 | 43 | #ifdef USE_C_INITSATUR_A1LEFT 44 | void initSatur_A1Left() { 45 | if (A2X > SCREEN_WIDTH - 1) { 46 | A2XSatur = 1; 47 | } else if (A2X == SCREEN_WIDTH - 1) { 48 | if (A2sX == 1){ 49 | A2XSatur = 1; 50 | } else { 51 | A2XSatur = 0; 52 | } 53 | } else { 54 | A2XSatur = 0; 55 | } 56 | 57 | #ifndef USE_COLOR 58 | if (A1X < 0) { 59 | #else 60 | if (A1X < COLUMN_OF_COLOR_ATTRIBUTE) { 61 | #endif 62 | A1XSatur = 1; 63 | #ifndef USE_COLOR 64 | } else if (A1X == 0) { 65 | #else 66 | } else if (A1X == COLUMN_OF_COLOR_ATTRIBUTE) { 67 | #endif 68 | if (A1sX == 1){ 69 | A1XSatur = 0; 70 | } else { 71 | A1XSatur = 1; 72 | } 73 | } else { 74 | A1XSatur = 0; 75 | } 76 | } 77 | #endif // USE_C_INITSATUR_A1LEFT 78 | 79 | #ifdef USE_C_SWITCH_A1XSATUR 80 | void switch_A1XSatur(){ 81 | if (A1XSatur == 0) { 82 | A1XSatur = 1; 83 | } else { 84 | A1XSatur = 0; 85 | } 86 | } 87 | #endif //USE_C_SWITCH_A1XSATUR 88 | 89 | #ifdef USE_C_SWITCH_A2XSATUR 90 | void switch_A2XSatur(){ 91 | if (A2XSatur == 0) { 92 | A2XSatur = 1; 93 | } else { 94 | A2XSatur = 0; 95 | } 96 | } 97 | #endif //USE_C_SWITCH_A2XSATUR 98 | #endif // USE_SATURATION 99 | -------------------------------------------------------------------------------- /src/scene.s: -------------------------------------------------------------------------------- 1 | ;; __ 2 | ;; / _\ ___ ___ _ __ ___ 3 | ;; \ \ / __| / _ \| '_ \ / _ \ 4 | ;; _\ \ | (__ | __/| | | || __/ 5 | ;; \__/ \___| \___||_| |_| \___| 6 | 7 | #ifndef TARGET_ORIX 8 | #ifdef SAVE_ZERO_PAGE 9 | .text 10 | #else 11 | .zero 12 | #endif ;; SAVE_ZERO_PAGE 13 | #else 14 | .text 15 | #endif ;; TARGET_ORIX 16 | 17 | ;;unsigned char glNbSegments=0; 18 | _glNbSegments .dsb 1 19 | ;;unsigned char glNbParticles=0; 20 | _glNbParticles .dsb 1; 21 | ;;unsigned char glNbFaces=0; 22 | _glNbFaces .dsb 1; 23 | 24 | .text 25 | 26 | ;;char segments[NB_MAX_SEGMENTS*SIZEOF_SEGMENT]; 27 | ; .dsb 256-(*&255) 28 | ; _segments .dsb NB_MAX_SEGMENTS*SIZEOF_SEGMENT 29 | _segments: 30 | _glSegmentsPt1 .dsb NB_MAX_SEGMENTS 31 | _glSegmentsPt2 .dsb NB_MAX_SEGMENTS 32 | _glSegmentsChar .dsb NB_MAX_SEGMENTS 33 | 34 | 35 | ;;char particles[NB_MAX_SEGMENTS*SIZEOF_PARTICLE]; 36 | ; _particles .dsb NB_MAX_PARTICLES*SIZEOF_PARTICLE 37 | _particles: 38 | _glParticlesPt .dsb NB_MAX_PARTICLES 39 | _glParticlesChar .dsb NB_MAX_PARTICLES 40 | 41 | 42 | 43 | ; _faces .dsb NB_MAX_FACES*SIZEOF_FACE 44 | _faces: 45 | _glFacesPt1 .dsb NB_MAX_FACES 46 | _glFacesPt2 .dsb NB_MAX_FACES 47 | _glFacesPt3 .dsb NB_MAX_FACES 48 | _glFacesChar .dsb NB_MAX_FACES 49 | 50 | 51 | -------------------------------------------------------------------------------- /src/sortPoints.c: -------------------------------------------------------------------------------- 1 | #ifdef USE_C_SORTPOINTS 2 | void sortPoints(){ 3 | signed char tmpH, tmpV; 4 | if (abs(P2AH) < abs(P1AH)) { 5 | tmpH = P1AH; 6 | tmpV = P1AV; 7 | P1AH = P2AH; 8 | P1AV = P2AV; 9 | P2AH = tmpH; 10 | P2AV = tmpV; 11 | } 12 | if (abs(P3AH) < abs(P1AH)) { 13 | tmpH = P1AH; 14 | tmpV = P1AV; 15 | P1AH = P3AH; 16 | P1AV = P3AV; 17 | P3AH = tmpH; 18 | P3AV = tmpV; 19 | } 20 | if (abs(P3AH) < abs(P2AH)) { 21 | tmpH = P2AH; 22 | tmpV = P2AV; 23 | P2AH = P3AH; 24 | P2AV = P3AV; 25 | P3AH = tmpH; 26 | P3AV = tmpV; 27 | } 28 | } 29 | #endif // USE_C_SORTPOINTS -------------------------------------------------------------------------------- /src/sprites.c: -------------------------------------------------------------------------------- 1 | #include "glOric.h" 2 | 3 | extern signed char glSpriteX[]; 4 | extern signed char glSpriteY[]; 5 | extern signed char glSpriteZ[]; 6 | extern signed char *glSprites[]; 7 | extern unsigned char idxStar; 8 | extern unsigned char plotX, plotY,distpoint; 9 | extern char ch2disp; 10 | extern int PointX, PointY, PointZ, ResX, ResY; 11 | extern unsigned int Norm; 12 | 13 | 14 | extern unsigned char glSpriteNbCar; 15 | extern unsigned char glSpriteCarIdx; 16 | extern signed char *glTabSprite; 17 | 18 | extern unsigned char glNbSprites; 19 | // _glSpriteIdx .dsb 1 20 | 21 | // _glSpriteNbCar .dsb 1 22 | // _glSpriteCarIdx .dsb 1 23 | 24 | extern signed char glSpriteX[]; 25 | extern signed char glSpriteY[]; 26 | extern signed char glSpriteZ[]; 27 | extern signed char *glSprites[]; 28 | 29 | 30 | #ifdef USE_C_GLDRAWSPRITES 31 | 32 | void glAddSprite(signed char X, signed char Y, signed char Z, signed char *theSprite ) { 33 | glSpriteX[glNbSprites] = X; 34 | glSpriteY[glNbSprites] = Y; 35 | glSpriteZ[glNbSprites] = Z; 36 | glSprites[glNbSprites] = theSprite; 37 | glNbSprites += 1; 38 | } 39 | 40 | 41 | void glDrawSprites(){ 42 | 43 | for (idxStar = 0; idxStar < 16; idxStar++){ 44 | PointX = glSpriteX[idxStar]; 45 | PointY = glSpriteY[idxStar]; 46 | PointZ = glSpriteZ[idxStar]; 47 | glTabSprite = glSprites[idxStar]; 48 | project_i8o8(); 49 | 50 | // sX = (SCREEN_WIDTH - aH) >> 1; 51 | plotX = (SCREEN_WIDTH - (signed char)ResX) >> 1; 52 | // sY = (SCREEN_HEIGHT - aV) >> 1; 53 | plotY = (SCREEN_HEIGHT - (signed char)ResY) >> 1; 54 | 55 | distpoint = Norm; 56 | glSpriteCarIdx=0; 57 | for (glSpriteNbCar = glTabSprite[glSpriteCarIdx++]; glSpriteNbCar >0; glSpriteNbCar --){ 58 | plotX += glTabSprite[glSpriteCarIdx++]; 59 | plotY += glTabSprite[glSpriteCarIdx++]; 60 | ch2disp = glTabSprite[glSpriteCarIdx++]; 61 | fastzplot(); 62 | } 63 | 64 | } 65 | 66 | } 67 | #endif // USE_C_GLDRAWSPRITES 68 | -------------------------------------------------------------------------------- /src/sprites_s.s: -------------------------------------------------------------------------------- 1 | ;; FIXME #include "glOric.h" 2 | #define SCREEN_WIDTH 40 3 | #define SCREEN_HEIGHT 26 4 | ;; 5 | 6 | 7 | .zero 8 | _glTabSprite .dsb 2 9 | 10 | .text 11 | 12 | ;; unsigned char glSpriteNbCar; 13 | ;; unsigned char glSpriteCarIdx; 14 | #define NB_MAX_SPRITES 16 15 | 16 | _glNbSprites .dsb 1 17 | _glSpriteIdx .dsb 1 18 | 19 | _glSpriteNbCar .dsb 1 20 | _glSpriteCarIdx .dsb 1 21 | 22 | _glSpriteX .dsb NB_MAX_SPRITES 23 | _glSpriteY .dsb NB_MAX_SPRITES 24 | _glSpriteZ .dsb NB_MAX_SPRITES 25 | _glSprites .dsb 2*NB_MAX_SPRITES 26 | 27 | ; The sprite and display position will be read from the stack. 28 | ; sp+0 => X coordinate 29 | ; sp+2 => Y coordinate 30 | ; sp+4 => Z coordinate 31 | ; sp+6 => Adress of the sprite definition 32 | 33 | _glAddSprite: 34 | .( 35 | 36 | ldy #0 37 | lda (sp),y ; Access X coordinate 38 | ldy _glNbSprites 39 | sta _glSpriteX,y 40 | 41 | ldy #2 42 | lda (sp),y ; Access Y coordinate 43 | ldy _glNbSprites 44 | sta _glSpriteY,y 45 | 46 | ldy #4 47 | lda (sp),y ; Access Y coordinate 48 | ldy _glNbSprites 49 | sta _glSpriteZ,y 50 | 51 | ldy #6 52 | lda (sp),y ; Access Y coordinate 53 | sta tmp0 54 | ldy #7 55 | lda (sp),y ; Access Y coordinate 56 | sta tmp0+1 57 | lda _glNbSprites 58 | asl 59 | tay 60 | lda tmp0 61 | sta _glSprites,y 62 | iny 63 | lda tmp0+1 64 | sta _glSprites,y 65 | 66 | inc _glNbSprites 67 | 68 | 69 | 70 | ;;ldx #6 : lda #0 : jsr enter : 71 | ;; ldy #0 : lda (ap),y : sta tmp0 : iny : lda (ap),y : sta tmp0+1 : 72 | ;; ldy #0 : lda tmp0 : sta (ap),y : 73 | ;; ldy #2 : lda (ap),y : sta tmp0 : iny : lda (ap),y : sta tmp0+1 : 74 | ;; ldy #2 : lda tmp0 : sta (ap),y : 75 | ;; ldy #4 : lda (ap),y : sta tmp0 : iny : lda (ap),y : sta tmp0+1 : 76 | ;; ldy #4 : lda tmp0 : sta (ap),y : 77 | ;; lda _glNbSprites : sta tmp0 : 78 | ;; lda tmp0 : sta tmp0 : lda #0 : sta tmp0+1 : 79 | ;; clc : lda #<(_glSpriteX) : adc tmp0 : sta tmp0 : lda #>(_glSpriteX) : adc tmp0+1 : sta tmp0+1 : 80 | ;; ldy #0 : lda (ap),y : sta tmp1 : 81 | ;; ldy #0 : lda tmp1 : sta (tmp0),y : 82 | ;; lda _glNbSprites : sta tmp0 : 83 | ;; lda tmp0 : sta tmp0 : lda #0 : sta tmp0+1 : 84 | ;; clc : lda #<(_glSpriteY) : adc tmp0 : sta tmp0 : lda #>(_glSpriteY) : adc tmp0+1 : sta tmp0+1 : 85 | ;; ldy #2 : lda (ap),y : sta tmp1 : 86 | ;; ldy #0 : lda tmp1 : sta (tmp0),y : 87 | ;; lda _glNbSprites : sta tmp0 : 88 | ;; lda tmp0 : sta tmp0 : lda #0 : sta tmp0+1 : 89 | ;; clc : lda #<(_glSpriteZ) : adc tmp0 : sta tmp0 : lda #>(_glSpriteZ) : adc tmp0+1 : sta tmp0+1 : 90 | ;; ldy #4 : lda (ap),y : sta tmp1 : 91 | ;; ldy #0 : lda tmp1 : sta (tmp0),y : 92 | ;; lda _glNbSprites : sta tmp0 : 93 | ;; lda tmp0 : sta tmp0 : lda #0 : sta tmp0+1 : 94 | ;; lda tmp0 : asl : sta tmp0 : lda tmp0+1 : rol : sta tmp0+1 : 95 | ;; clc : lda #<(_glSprites) : adc tmp0 : sta tmp0 : lda #>(_glSprites) : adc tmp0+1 : sta tmp0+1 : 96 | ;; ldy #6 : lda (ap),y : sta tmp1 : iny : lda (ap),y : sta tmp1+1 : 97 | ;; ldy #0 : lda tmp1 : sta (tmp0),y : iny : lda tmp1+1 : sta (tmp0),y : 98 | ;; lda _glNbSprites : sta tmp0 : 99 | ;; lda tmp0 : sta tmp0 : lda #0 : sta tmp0+1 : 100 | ;; inc tmp0 : .( : bne skip : inc tmp0+1 :skip : .) : 101 | ;; lda tmp0 : sta _glNbSprites : 102 | ;; jmp leave : 103 | .) 104 | rts 105 | 106 | _glDrawSprites: 107 | .( 108 | ;;for (glSpriteIdx = 0; glSpriteIdx < 16; glSpriteIdx++) 109 | lda #0: sta _glSpriteIdx 110 | cmp _glNbSprites 111 | bne loopSprites 112 | rts 113 | loopSprites: 114 | 115 | ;;PointX = starX[glSpriteIdx]; 116 | ;;PointY = starY[glSpriteIdx]; 117 | ;;PointZ = starZ[glSpriteIdx]; 118 | ;;glTabSprite = starSprite[glSpriteIdx]; 119 | ldy _glSpriteIdx: 120 | lda _glSpriteX,y : sta _PointX: 121 | lda _glSpriteY,y : sta _PointY: 122 | lda _glSpriteZ,y : sta _PointZ: 123 | tya: 124 | asl: clc: adc #<(_glSprites): sta tmp0: 125 | lda #>(_glSprites): adc #0: sta tmp0+1: 126 | ldy #0: lda (tmp0),y: sta _glTabSprite: iny: lda (tmp0),y: sta _glTabSprite+1: 127 | 128 | ;; project_i8o8(); 129 | jsr _project_i8o8 130 | 131 | 132 | ;;// sX = (SCREEN_WIDTH - aH) >> 1; 133 | ;;plotX = (SCREEN_WIDTH - (signed char)ResX) >> 1; 134 | lda #SCREEN_WIDTH: sec: sbc _ResX: cmp #$80: ror : sta _plotX 135 | ;;// sY = (SCREEN_HEIGHT - aV) >> 1; 136 | ;;plotY = (SCREEN_HEIGHT - (signed char)ResY) >> 1; 137 | lda #SCREEN_HEIGHT: sec: sbc _ResY: cmp #$80: ror : sta _plotY 138 | ;;distpoint = Norm; 139 | lda _Norm: sta _distpoint 140 | ;;glSpriteCarIdx=0; 141 | lda #0: sta _glSpriteCarIdx 142 | ;;for (glSpriteNbCar = glTabSprite[glSpriteCarIdx++]; glSpriteNbCar >0; glSpriteNbCar --){ 143 | ldy _glSpriteCarIdx 144 | lda (_glTabSprite),y 145 | sta _glSpriteNbCar 146 | beq endloopcar 147 | inc _glSpriteCarIdx 148 | loopcar 149 | ;; 150 | ;; ;; plotX += glTabSprite[glSpriteCarIdx++]; 151 | ;; ;; plotY += glTabSprite[glSpriteCarIdx++]; 152 | ;; ;; ch2disp = glTabSprite[glSpriteCarIdx++]; 153 | ;; ;; fastzplot(); 154 | ldy _glSpriteCarIdx: lda (_glTabSprite),y: clc: adc _plotX: sta _plotX: inc _glSpriteCarIdx: 155 | ldy _glSpriteCarIdx: lda (_glTabSprite),y: clc: adc _plotY: sta _plotY: inc _glSpriteCarIdx: 156 | ldy _glSpriteCarIdx: lda (_glTabSprite),y: sta _ch2disp: inc _glSpriteCarIdx: 157 | jsr _fastzplot: 158 | dec _glSpriteNbCar 159 | beq endloopcar 160 | jmp loopcar 161 | endloopcar 162 | ;;} 163 | 164 | 165 | inc _glSpriteIdx 166 | lda _glSpriteIdx 167 | cmp _glNbSprites 168 | beq glDrawSprites_done 169 | jmp loopSprites 170 | 171 | glDrawSprites_done: 172 | .) 173 | rts 174 | -------------------------------------------------------------------------------- /src/temp.s: -------------------------------------------------------------------------------- 1 | 2 | 3 | #ifdef SAVE_ZERO_PAGE 4 | .text 5 | #else 6 | .zero 7 | #endif 8 | 9 | ; int d1, d2, d3; 10 | _d1 .dsb 2 11 | _d2 .dsb 2 12 | _d3 .dsb 2 13 | ; int dmoy; 14 | _dmoy .dsb 2 15 | 16 | ; unsigned char idxPt1, idxPt2, idxPt3; 17 | _idxPt1 .dsb 1 18 | _idxPt2 .dsb 1 19 | _idxPt3 .dsb 1 20 | 21 | ;unsigned char isFace2BeDrawn; 22 | _isFace2BeDrawn .dsb 1 23 | 24 | 25 | ; unsigned char m1, m2, m3; 26 | _m1 .dsb 1 27 | _m2 .dsb 1 28 | _m3 .dsb 1 29 | ; unsigned char v1, v2, v3; 30 | _v1 .dsb 1 31 | _v2 .dsb 1 32 | _v3 .dsb 1 33 | 34 | 35 | _plotX .dsb 1 36 | _plotY .dsb 1 37 | 38 | .text -------------------------------------------------------------------------------- /src/util/display.s: -------------------------------------------------------------------------------- 1 | ; http://miniserve.defence-force.org/svn/public/oric/routines/rasterization/linebench/ 2 | 3 | #include "config.h" 4 | #ifdef USE_HIRES_RASTER 5 | 6 | #define ROW_SIZE SCREEN_WIDTH/6 7 | 8 | .dsb 256-(*&255) 9 | 10 | _HiresAddrLow .dsb SCREEN_HEIGHT 11 | 12 | .dsb 256-(*&255) 13 | 14 | _HiresAddrHigh .dsb SCREEN_HEIGHT 15 | 16 | .dsb 256-(*&255) 17 | 18 | .byt 0 19 | _TableDiv6 .dsb SCREEN_WIDTH 20 | 21 | .dsb 256-(*&255) 22 | 23 | .byt 0 24 | _TableBit6Reverse 25 | .byt 32,16,8,4,2,1 26 | .byt 32,16,8,4,2,1 27 | .byt 32,16,8,4,2,1 28 | .byt 32,16,8,4,2,1 29 | .byt 32,16,8,4,2,1 30 | .byt 32,16,8,4,2,1 31 | .byt 32,16,8,4,2,1 32 | .byt 32,16,8,4,2,1 33 | .byt 32,16,8,4,2,1 34 | .byt 32,16,8,4,2,1 35 | 36 | .byt 32,16,8,4,2,1 37 | .byt 32,16,8,4,2,1 38 | .byt 32,16,8,4,2,1 39 | .byt 32,16,8,4,2,1 40 | .byt 32,16,8,4,2,1 41 | .byt 32,16,8,4,2,1 42 | .byt 32,16,8,4,2,1 43 | .byt 32,16,8,4,2,1 44 | .byt 32,16,8,4,2,1 45 | .byt 32,16,8,4,2,1 46 | 47 | .byt 32,16,8,4,2,1 48 | .byt 32,16,8,4,2,1 49 | .byt 32,16,8,4,2,1 50 | .byt 32,16,8,4,2,1 51 | .byt 32,16,8,4,2,1 52 | .byt 32,16,8,4,2,1 53 | .byt 32,16,8,4,2,1 54 | .byt 32,16,8,4,2,1 55 | .byt 32,16,8,4,2,1 56 | .byt 32,16,8,4,2,1 57 | 58 | .byt 32,16,8,4,2,1 59 | .byt 32,16,8,4,2,1 60 | .byt 32,16,8,4,2,1 61 | .byt 32,16,8,4,2,1 62 | .byt 32,16,8,4,2,1 63 | .byt 32,16,8,4,2,1 64 | .byt 32,16,8,4,2,1 65 | .byt 32,16,8,4,2,1 66 | .byt 32,16,8,4,2,1 67 | .byt 32,16,8,4,2,1 68 | 69 | .dsb 256-(*&255) 70 | 71 | .byt 0 72 | _TableBit6 73 | .byt 1,2,4,8,16,32|$80 74 | .byt 1,2,4,8,16,32|$80 75 | .byt 1,2,4,8,16,32|$80 76 | .byt 1,2,4,8,16,32|$80 77 | .byt 1,2,4,8,16,32|$80 78 | .byt 1,2,4,8,16,32|$80 79 | .byt 1,2,4,8,16,32|$80 80 | .byt 1,2,4,8,16,32|$80 81 | .byt 1,2,4,8,16,32|$80 82 | .byt 1,2,4,8,16,32|$80 83 | 84 | .byt 1,2,4,8,16,32|$80 85 | .byt 1,2,4,8,16,32|$80 86 | .byt 1,2,4,8,16,32|$80 87 | .byt 1,2,4,8,16,32|$80 88 | .byt 1,2,4,8,16,32|$80 89 | .byt 1,2,4,8,16,32|$80 90 | .byt 1,2,4,8,16,32|$80 91 | .byt 1,2,4,8,16,32|$80 92 | .byt 1,2,4,8,16,32|$80 93 | .byt 1,2,4,8,16,32|$80 94 | 95 | .byt 1,2,4,8,16,32|$80 96 | .byt 1,2,4,8,16,32|$80 97 | .byt 1,2,4,8,16,32|$80 98 | .byt 1,2,4,8,16,32|$80 99 | .byt 1,2,4,8,16,32|$80 100 | .byt 1,2,4,8,16,32|$80 101 | .byt 1,2,4,8,16,32|$80 102 | .byt 1,2,4,8,16,32|$80 103 | .byt 1,2,4,8,16,32|$80 104 | .byt 1,2,4,8,16,32|$80 105 | 106 | .byt 1,2,4,8,16,32|$80 107 | .byt 1,2,4,8,16,32|$80 108 | .byt 1,2,4,8,16,32|$80 109 | .byt 1,2,4,8,16,32|$80 110 | .byt 1,2,4,8,16,32|$80 111 | .byt 1,2,4,8,16,32|$80 112 | .byt 1,2,4,8,16,32|$80 113 | .byt 1,2,4,8,16,32|$80 114 | .byt 1,2,4,8,16,32|$80 115 | .byt 1,2,4,8,16,32|$80 116 | 117 | 118 | _GenerateTables 119 | .( 120 | 121 | ; Generate screen offset data 122 | .( 123 | lda #<$a000 124 | sta tmp0+0 125 | lda #>$a000 126 | sta tmp0+1 127 | 128 | ldx #0 129 | loop 130 | ; generate two bytes screen adress 131 | clc 132 | lda tmp0+0 133 | sta _HiresAddrLow,x 134 | adc #ROW_SIZE 135 | sta tmp0+0 136 | lda tmp0+1 137 | sta _HiresAddrHigh,x 138 | adc #0 139 | sta tmp0+1 140 | 141 | inx 142 | cpx #SCREEN_HEIGHT 143 | bne loop 144 | .) 145 | 146 | 147 | ; Generate multiple of 6 data table 148 | .( 149 | lda #0 ; cur div 150 | tay ; cur mod 151 | tax 152 | loop 153 | sta _TableDiv6,x 154 | iny 155 | cpy #6 156 | bne skip_mod 157 | ldy #0 158 | adc #0 ; carry = 1! 159 | skip_mod 160 | 161 | inx 162 | cpx #SCREEN_WIDTH 163 | bne loop 164 | .) 165 | .) 166 | rts 167 | 168 | 169 | 170 | #endif 171 | 172 | 173 | 174 | -------------------------------------------------------------------------------- /src/util/keyboard.h: -------------------------------------------------------------------------------- 1 | #ifndef KEYBOARD_H 2 | #define KEYBOARD_H 3 | 4 | 5 | extern void keyPressed (char dif, char v); 6 | 7 | extern void keyEvent(); 8 | 9 | extern char KeyBank[8]; 10 | extern char oldKeyBank[8]; 11 | 12 | 13 | #endif //KEYBOARD_H -------------------------------------------------------------------------------- /src/util/rand.s: -------------------------------------------------------------------------------- 1 | ;; 8-bits output Pseudo Random Number Generator 2 | ;; based on a 16-bit Galois linear feedback shift register with polynomial $0039. 3 | ;; found at https://wiki.nesdev.com/w/index.php/Random_number_generator 4 | 5 | ;; Typical usage is : 6 | ;; 7 | ;; initRand(deek(0x276)); 8 | ;; randValue = getRand(); 9 | 10 | #include "config.h" 11 | #ifdef USE_RANDOM 12 | _asmSeed .dsb 2 13 | 14 | asmRand: 15 | .( 16 | lda _asmSeed+1 17 | tay ; store copy of high byte 18 | ; compute _asmSeed+1 ($39>>1 = %11100) 19 | lsr ; shift to consume zeroes on left... 20 | lsr 21 | lsr 22 | sta _asmSeed+1 ; now recreate the remaining bits in reverse order... %111 23 | lsr 24 | eor _asmSeed+1 25 | lsr 26 | eor _asmSeed+1 27 | eor _asmSeed+0 ; recombine with original low byte 28 | sta _asmSeed+1 29 | ; compute _asmSeed+0 ($39 = %111001) 30 | tya ; original high byte 31 | sta _asmSeed+0 32 | asl 33 | eor _asmSeed+0 34 | asl 35 | eor _asmSeed+0 36 | asl 37 | asl 38 | asl 39 | eor _asmSeed+0 40 | sta _asmSeed+0 41 | .) 42 | rts 43 | 44 | ;; C Binding 45 | 46 | ;; void initRand(unsigned int seed); 47 | _initRand: 48 | .( 49 | ; ldx #6 : lda #0 : jsr enter : 50 | pha: tay: pha 51 | ldy #0 : lda (sp),y : sta _asmSeed : iny : lda (sp),y : sta _asmSeed+1 : 52 | ; jmp leave : 53 | pla: tay: pla 54 | .) 55 | rts 56 | 57 | ;; unsigned char getRand(void); 58 | _getRand: 59 | .( 60 | pha: tay: pha 61 | jsr asmRand 62 | tax 63 | pla: tay: pla 64 | .) 65 | rts 66 | 67 | 68 | #endif // USE_RANDOM -------------------------------------------------------------------------------- /src/util/screen.s: -------------------------------------------------------------------------------- 1 | 2 | .text 3 | 4 | _clearScreen: 5 | .( 6 | 7 | lda #$20 8 | 9 | ldx #40 10 | 11 | clrscrLoop: 12 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*0 , x 13 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*1 , x 14 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*2 , x 15 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*3 , x 16 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*4 , x 17 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*5 , x 18 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*6 , x 19 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*7 , x 20 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*8 , x 21 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*9 , x 22 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*10 , x 23 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*11 , x 24 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*12 , x 25 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*13 , x 26 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*14 , x 27 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*15 , x 28 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*16 , x 29 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*17 , x 30 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*18 , x 31 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*19 , x 32 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*20 , x 33 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*21 , x 34 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*22 , x 35 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*23 , x 36 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*24 , x 37 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*25 , x 38 | sta ADR_BASE_LORES_SCREEN+SCREEN_WIDTH*26 , x 39 | 40 | dex 41 | bne clrscrLoop: 42 | .) 43 | rts 44 | 45 | -------------------------------------------------------------------------------- /src/util/util.h: -------------------------------------------------------------------------------- 1 | #ifndef UTIL_H 2 | #define UTIL_H 3 | 4 | #define max(a,b) (((a) > (b)) ? (a) : (b)) 5 | #define min(a,b) (((a) < (b)) ? (a) : (b)) 6 | #define abs(x) (((x)<0)?-(x):(x)) 7 | 8 | #endif -------------------------------------------------------------------------------- /src/xabuild.bat: -------------------------------------------------------------------------------- 1 | 2 | DEL build\GLORIC.TAP %OSDK%\Oricutron\OSDK.TAP build\final.out %OSDK%\TMP\linked.s 3 | 4 | %OSDK%\bin\cpp.exe -lang-c++ -I %OSDK%\include -D__16BIT__ -D__NOFLOAT__ -DATMOS -DOSDKNAME_GLORIC -DOSDKVER=\"1.15\" -nostdinc start.c %OSDK%\TMP\start.c 5 | 6 | %OSDK%\bin\compiler.exe -Nstart -O2 %OSDK%\TMP\start.c 1>%OSDK%\TMP\start.c2 7 | 8 | %OSDK%\bin\cpp.exe -lang-c++ -imacros %OSDK%\macro\macros.h -DXA -traditional -P %OSDK%\TMP\start.c2 %OSDK%\TMP\start.s 9 | 10 | %OSDK%\bin\macrosplitter.exe %OSDK%\TMP\start.s %OSDK%\TMP\start 11 | 12 | %OSDK%\bin\cpp.exe -lang-c++ -I %OSDK%\include -D__16BIT__ -D__NOFLOAT__ -DATMOS -DOSDKNAME_GLORIC -DOSDKVER=\"1.15\" -nostdinc glOric_c.c %OSDK%\TMP\glOric_c.c 13 | 14 | %OSDK%\bin\compiler.exe -NglOric_c -O2 %OSDK%\TMP\glOric_c.c 1>%OSDK%\TMP\glOric_c.c2 15 | 16 | %OSDK%\bin\cpp.exe -lang-c++ -imacros %OSDK%\macro\macros.h -DXA -traditional -P %OSDK%\TMP\glOric_c.c2 %OSDK%\TMP\glOric_c.s 17 | 18 | %OSDK%\bin\macrosplitter.exe %OSDK%\TMP\glOric_c.s %OSDK%\TMP\glOric_c 19 | 20 | REM ECHO %OSDK%\bin\link65.exe -d %OSDK%\lib/ -o %OSDK%\TMP\linked.s -f -q %OSDK%\TMP\start %OSDK%\TMP\glOric_c glOric_s.s 1>%OSDK%\TMP\link.bat 21 | 22 | REM CALL %OSDK%\TMP\link.bat 23 | 24 | %OSDK%\bin\link65.exe -d %OSDK%\lib/ -o %OSDK%\TMP\linked.s -f -q %OSDK%\TMP\start %OSDK%\TMP\glOric_c glOric_s.s 25 | 26 | IF NOT EXIST %OSDK%\TMP\linked.s GOTO ErBld 27 | 28 | %OSDK%\bin\xa.exe -W -C %OSDK%\TMP\linked.s -o build\final.out -e build\xaerr.txt -l build\symbols -bt $500 -DASSEMBLER=XA -DOSDKNAME_GLORIC 29 | 30 | %OSDK%\bin\header.exe build\final.out build\GLORIC.tap $500 31 | 32 | %OSDK%\bin\taptap.exe ren build\GLORIC.tap "glOric" 0 33 | 34 | 35 | IF EXIST build\GLORIC.TAP GOTO OkFile 36 | GOTO ErBld 37 | 38 | :OkFile 39 | COPY build\GLORIC.TAP %OSDK%\Oricutron\OSDK.TAP 1>NUL 40 | COPY build\symbols %OSDK%\Oricutron\symbols 1>NUL 41 | 42 | PUSHD %OSDK%\Oricutron 43 | START oricutron.exe -t OSDK.TAP -s symbols 44 | POPD 45 | 46 | GOTO End 47 | 48 | :ErBld 49 | ECHO "ERREUR !!! " 50 | 51 | :End -------------------------------------------------------------------------------- /src/zbuffer.c: -------------------------------------------------------------------------------- 1 | #include "config.h" 2 | #include "glOric.h" 3 | 4 | #ifdef TARGET_ORIX 5 | #include 6 | #endif 7 | 8 | #ifdef USE_COLOR 9 | #include "render/colors.h" 10 | #endif 11 | 12 | #ifdef USE_ZBUFFER 13 | #include "render\zbuffer.h" 14 | 15 | 16 | //const int multi40[] = {0, 40, 80, 120, 160, 200, 240, 280, 320, 17 | // 360, 400, 440, 480, 520, 560, 600, 640, 680, 18 | // 720, 760, 800, 840, 880, 920, 960, 1000, 1040}; 19 | #include "glInitScreenBuffers.c" 20 | 21 | #include "glBuffer2Screen.c" 22 | 23 | #include "zplot_c.c" 24 | 25 | #ifdef USE_C_ZLINE 26 | 27 | void zline(signed char dx, 28 | signed char py, 29 | signed char nbpoints, 30 | unsigned char dist, 31 | char char2disp) { 32 | int offset; // offset os starting point 33 | char* ptrFbuf; // pointer to the frame buffer 34 | unsigned char* ptrZbuf; // pointer to z-buffer 35 | signed char nbp; 36 | 37 | nbp = nbpoints; 38 | #ifdef USE_MULTI40 39 | offset = multi40[py] + dx; 40 | #else 41 | offset = py * SCREEN_WIDTH + dx; 42 | #endif // USE_MULTI40 43 | 44 | ptrZbuf = zbuffer + offset; 45 | ptrFbuf = fbuffer + offset; 46 | 47 | // printf ("zline from [%d %d] . %d points at dist %d \n", dx, py, nbpoints,dist); 48 | 49 | while (nbp > 0) { 50 | if (dist < ptrZbuf[nbp]) { 51 | // printf ("p [%d %d] <- %d. was %d \n", dx+nbpoints, py, dist, ptrZbuf[nbpoints]); 52 | ptrFbuf[nbp] = char2disp; 53 | ptrZbuf[nbp] = dist; 54 | } 55 | nbp--; 56 | } 57 | } 58 | 59 | #endif //USE_C_ZLINE 60 | 61 | #endif // USE_ZBUFFER -------------------------------------------------------------------------------- /src/zplot_c.c: -------------------------------------------------------------------------------- 1 | 2 | #ifdef USE_C_ZPLOT 3 | 4 | void glZPlot(signed char X, 5 | signed char Y, 6 | unsigned char dist, 7 | char char2disp) { 8 | int offset; 9 | char* ptrFbuf; 10 | unsigned char* ptrZbuf; 11 | 12 | #ifdef USE_COLOR 13 | if ((Y <= 0) || (Y >= SCREEN_HEIGHT-NB_LESS_LINES_4_COLOR) || (X <= 2) || (X >= SCREEN_WIDTH)) 14 | return; 15 | #else 16 | if ((Y <= 0) || (Y >= SCREEN_HEIGHT) || (X <= 0) || (X >= SCREEN_WIDTH)) 17 | return; 18 | #endif 19 | 20 | #ifdef USE_MULTI40 21 | offset = multi40[Y] + X; // 22 | #else 23 | offset = Y*SCREEN_WIDTH+X; 24 | #endif 25 | 26 | ptrZbuf = zbuffer + offset; 27 | ptrFbuf = fbuffer + offset; 28 | 29 | // printf ("pl [%d %d] zbuff = %d , pointDist = %d\n", X, Y, *ptrZbuf, dist); 30 | if (dist < *ptrZbuf) { 31 | *ptrFbuf = char2disp; 32 | *ptrZbuf = dist; 33 | } 34 | } 35 | 36 | #endif 37 | 38 | -------------------------------------------------------------------------------- /tools/atan2test.py: -------------------------------------------------------------------------------- 1 | import math 2 | N=7 3 | 4 | with open('output.txt', 'w') as file: # Use file to refer to the file object 5 | 6 | 7 | for X in range (-N,N+1): 8 | for Y in range (-N,N+1): 9 | exp = round(math.atan2(Y,X)*(128.0/math.pi)) 10 | if (exp == 128): exp = -128 11 | file.write("""\ttx = %d; ty = %d; res = 0; atan2_8 (); if (res!=%d) printf("ERR atan2 (%%d, %%d) = %%d exp=%d\\n", tx, ty, res); 12 | \n"""%(X, Y 13 | , exp 14 | , exp 15 | )) 16 | #print (tmplt) 17 | 18 | -------------------------------------------------------------------------------- /tools/circletraj.py: -------------------------------------------------------------------------------- 1 | import math 2 | dist =24 3 | nbsteps = 64 4 | tabval = [] 5 | for ii in range (0, nbsteps): 6 | angle=ii * (2*math.pi/nbsteps) 7 | [px, py] = [round(dist*math.cos(angle)), round(dist*math.sin(angle))] 8 | angleZ = round((math.atan2(-py, -px)*(256/(2*math.pi))) ) 9 | tabval.append(px) 10 | tabval.append(py) 11 | tabval.append(angleZ) 12 | print (tabval) 13 | 14 | 15 | -------------------------------------------------------------------------------- /tools/decimal2bin.py: -------------------------------------------------------------------------------- 1 | hex2bin = dict('{:x} {:04b}'.format(x,x).split() for x in range(16)) 2 | bin2hex = dict('{:b} {:x}'.format(x,x).split() for x in range(16)) 3 | 4 | def float_dec2bin(d): 5 | neg = False 6 | if d < 0: 7 | d = -d 8 | neg = True 9 | hx = float(d).hex() 10 | p = hx.index('p') 11 | bn = ''.join(hex2bin.get(char, char) for char in hx[2:p]) 12 | return (('-' if neg else '') + bn.strip('0') + hx[p:p+2] 13 | + bin(int(hx[p+2:]))[2:]) 14 | 15 | def float_bin2dec(bn): 16 | neg = False 17 | if bn[0] == '-': 18 | bn = bn[1:] 19 | neg = True 20 | dp = bn.index('.') 21 | extra0 = '0' * (4 - (dp % 4)) 22 | bn2 = extra0 + bn 23 | dp = bn2.index('.') 24 | p = bn2.index('p') 25 | hx = ''.join(bin2hex.get(bn2[i:min(i+4, p)].lstrip('0'), bn2[i]) 26 | for i in range(0, dp+1, 4)) 27 | bn3 = bn2[dp+1:p] 28 | extra0 = '0' * (4 - (len(bn3) % 4)) 29 | bn4 = bn3 + extra0 30 | hx += ''.join(bin2hex.get(bn4[i:i+4].lstrip('0')) 31 | for i in range(0, len(bn4), 4)) 32 | hx = (('-' if neg else '') + '0x' + hx + bn2[p:p+2] 33 | + str(int('0b' + bn2[p+2:], 2))) 34 | return float.fromhex(hx) 35 | 36 | print (float_dec2bin(1/6)) 37 | -------------------------------------------------------------------------------- /tools/displayProfilingResults.py: -------------------------------------------------------------------------------- 1 | #------------------------------------------------------------------------------- 2 | # Name: module1 3 | # Purpose: 4 | # 5 | # Author: tbpk7658 6 | # 7 | # Created: 09/03/2020 8 | # Copyright: (c) tbpk7658 2020 9 | # Licence: 10 | #------------------------------------------------------------------------------- 11 | 12 | 13 | PATH_TO_PRINTER_OUT = 'C:\\Users\\tbpk7658\\Applis\\osdk_1_15\\Oricutron\\printer_out.txt' 14 | #PATH_TO_PRINTER_OUT = 'C:\\Users\\tbpk7658\\Documents\\Projets\\glOric\\tests\\benchmark_results.txt' 15 | 16 | def main(): 17 | ficin = open (PATH_TO_PRINTER_OUT, 'r') 18 | lines = ficin.readlines() 19 | ficin.close() 20 | 21 | dictNumCycle = {} 22 | for li in lines: 23 | #print (li) 24 | try: 25 | [fild1, fild2, fild3] = li.replace("\r","").replace("\n","").split(" ") 26 | #print (fild3, int(fild2,16), fild1) 27 | if fild3 in dictNumCycle.keys(): 28 | dictNumCycle[fild3] += int(fild2,16) 29 | else : 30 | dictNumCycle[fild3] = int(fild2,16) 31 | #print ("%s is now : %d"%(fild3, dictNumCycle[fild3])) 32 | except : 33 | pass 34 | 35 | for ke in dictNumCycle.keys(): 36 | print ("%20s => \t\t%8d cycles"%(ke, dictNumCycle[ke])) 37 | if __name__ == '__main__': 38 | main() 39 | -------------------------------------------------------------------------------- /tools/fastatan.py: -------------------------------------------------------------------------------- 1 | #------------------------------------------------------------------------------- 2 | # Name: module1 3 | # Purpose: 4 | # 5 | # Author: tbpk7658 6 | # 7 | # Created: 10/12/2019 8 | # Copyright: (c) tbpk7658 2019 9 | # Licence: 10 | #------------------------------------------------------------------------------- 11 | import math 12 | 13 | log_tab = [ 0 ] 14 | for x in range (1,256): log_tab.append(round(math.log2(x)*32)) 15 | 16 | # atan(2^(x/32))*128/pi 17 | atan_tab = [0 for x in range (0,256)] 18 | for x in range (1,256): atan_tab [x]= round(math.atan2(1,2**((255-x)/32))*127/math.pi) 19 | 20 | def main(): 21 | x , y = 1, 16 22 | print (math.atan2(y,x)*127/math.pi) 23 | v = 255 - abs(log_tab [x] - log_tab[y]) 24 | print (x, y , log_tab[x]/32, log_tab[y]/32, (log_tab [x] - log_tab[y])/16, v) 25 | print (atan_tab[v]) 26 | #print (v*) 27 | #print (log2tab [4] - log2tab[2]) 28 | print (atan_tab) 29 | pass 30 | 31 | if __name__ == '__main__': 32 | main() 33 | -------------------------------------------------------------------------------- /tools/fastnorm2.py: -------------------------------------------------------------------------------- 1 | import math 2 | from operator import itemgetter, attrgetter, methodcaller 3 | 4 | import matplotlib.pyplot as plt 5 | import numpy as np 6 | from mpl_toolkits import mplot3d 7 | 8 | [A0, A1, A2, B0, B1, B2, C0, C1, C2, D0, D1, D2] = [ 1.60431525e-02, 1.01438538e+00, -2.23050176e-04, 9 | -4.95743532e-03, 1.03966260e-01, 2.65156968e-03, 10 | -1.25399371e-02, 8.51173164e-01, -2.18092268e-04, 11 | 2.02032598e-03, 5.39223578e-01, 3.71083013e-04] 12 | 13 | 14 | tabmult_A = [round ( (A0)+ (A1)*i + (A2) *(i**2) ) for i in range (128) ] 15 | 16 | tabmult_B = [round ( (B0) + i*( B1) + (i**2)*( B2 ) ) for i in range (128) ] 17 | 18 | tabmult_C = [round ( (C0) + i*(C1) + (i**2)*( C2 ) ) for i in range (128) ] 19 | 20 | tabmult_D = [round ( ( D0) + i*( D1) + (i**2)*(D2) ) for i in range (128) ] 21 | 22 | 23 | 24 | def norm (x,y): 25 | return math.sqrt(x**2 + y**2) 26 | 27 | def fastnorm2 (px,py): 28 | ax, ay = abs(px), abs(py) 29 | if ax >= ay: 30 | x, y = ax, ay 31 | else: 32 | x, y = ay, ax 33 | if y > x/2 : 34 | # N = (math.sqrt(5)-math.sqrt(2))*x + (2*math.sqrt(2) - math.sqrt(5))*y 35 | #N = tabmult_sqrt5_m_sqrt2 [x] + tabmult_2sqrt2_m_sqrt5[y] 36 | N = tabmult_C [x] + tabmult_D[y] 37 | else: 38 | # N = x+(math.sqrt(5)/2 - 1)*y 39 | #N = x + tabmult_sqrt5_m2 [y] 40 | N = tabmult_A [x] + tabmult_B[y] 41 | return N 42 | 43 | nb_max = 127 44 | tab_err = [] 45 | def exploreDomain(): 46 | score, score2 = 0, 0 47 | for x in range (0, nb_max+1): 48 | for y in range (0,x+1): 49 | 50 | err = norm(x,y) - fastnorm2 (x,y) 51 | score += abs(err) 52 | if ((x!=0) or (y!=0)) : score2 += (100*abs(err))/norm(x,y) 53 | if (abs(err) > 0.5) : 54 | #print ("%d %d norm = %f err = %f"%(x,y,real_norm, err)) 55 | tab_err.append((x, y , abs(err), (100*abs(err))/norm(x,y))) 56 | #for i in range (0,len(tabmult),8): 57 | # print (', '.join(tabmult[i:i+8])) 58 | # if i%8 == 0 : print ("\n") 59 | print ("score = ", int(sum([abs(er[2]) for er in tab_err])), int(score), int(score2)) 60 | 61 | def analyseErr (x, y): 62 | print ("--------------") 63 | print ("X = %d , Y = %d, n = %f, err = %f"%(x, y, norm(x,y), norm(x,y) - fastnorm2(x,y))) 64 | if y > x/2 : 65 | print ("y > x/2") 66 | # N = (math.sqrt(5)-math.sqrt(2))*x + (2*math.sqrt(2) - math.sqrt(5))*y 67 | intN = tabmult_C [x] + tabmult_D[y] 68 | fltN = (C0) + x*(C1) + (x**2)*( C2 ) + ( D0) + y*( D1) + (y**2)*(D2) 69 | print ("tabmult_C [%d] =%d ins of %f, tabmult_D[%d]=%d ins of %f"%(x, tabmult_C [x],(C0) + x*(C1) + (x**2)*( C2 ) , y, tabmult_D[y], ( D0) + y*( D1) + (y**2)*(D2))) 70 | else: 71 | print ("y <= x/2") 72 | # N = x+(math.sqrt(5)/2 - 1)*y 73 | intN = tabmult_A [x] + tabmult_B[y] 74 | fltN = (A0)+ (A1)*x + (A2) *(x**2) + (B0) + y*( B1) + (y**2)*( B2 ) 75 | print ("tabmult_A [%d] = %d ins of %f tabmult_B[%d] = %d ins of %f"%(x, tabmult_A [x], (A0)+ (A1)*x + (A2) *(x**2),y , tabmult_B[y] , (B0) + y*( B1) + (y**2)*( B2 ))) 76 | print ("intN = %d , fltN = %f"%(intN, fltN)) 77 | 78 | def fixTable (): 79 | #tabmult_D[1]=0 #=> 2874 3966 5049 80 | tabmult_C [1] =0 81 | #tabmult_C [3] = 2 # was 3 s 1 => 2874 3965 82 | #tabmult_D[2]=2 # was 1 s 1.1 => 2874 3966 83 | #tabmult_C [2] = 1 # was 2 s1.1.1 => 2873 3965 84 | #tabmult_D[4]=3 # was 2 s1.1.1.1 => 2875 3966 85 | #tabmult_C [4] = 4# was 3 s1.1.1.2 => 2874 3966 86 | tabmult_D[3]=1 87 | tabmult_C [4] =4 88 | #tabmult_D[3]=1 89 | # tabmult_D[3]=1 90 | # tabmult_D[4]=2 91 | tabmult_D[5]=2 92 | # 93 | # tabmult_C [4]=4 94 | tabmult_C [5]=5 95 | #tabmult_C [6] =7 96 | # tabmult_C [6]=5 97 | # tabmult_C [10]=9 98 | # tabmult_B[3] = 1 99 | #tabmult_B[4] = 1 100 | pass 101 | 102 | known_issues = [ 103 | [6, 3] 104 | ] 105 | 106 | 107 | def exportTable (table2export): 108 | strres= "" 109 | ii=0 110 | for v in table2export: 111 | 112 | if (ii == 0): 113 | strres += "\t .byt %d"%(v) 114 | elif (ii % 8 == 0) : 115 | strres += ",\n\t .byt %d"%(v) 116 | else: 117 | strres += ", %d"%(v) 118 | ii += 1 119 | strres += "" 120 | return strres 121 | 122 | def main(): 123 | fixTable () 124 | 125 | print ("tabmult_A") 126 | print (exportTable (tabmult_A)) 127 | print ("tabmult_B") 128 | print (exportTable (tabmult_B)) 129 | print ("tabmult_C") 130 | print (exportTable (tabmult_C)) 131 | print ("tabmult_D") 132 | print (exportTable (tabmult_D)) 133 | #t1=np.linspace(0,127,128) 134 | 135 | #plt.plot(t1, np.asarray(tabmult_sqrt5_m2), 'r--') 136 | #plt.show() 137 | 138 | 139 | exploreDomain() 140 | 141 | 142 | #fig = plt.figure() 143 | #ax = plt.axes(projection='3d') 144 | 145 | #x_data = np.asarray([er[0] for er in tab_err]) 146 | #y_data = np.asarray([er[1] for er in tab_err]) 147 | #err_data = np.asarray([er[3] for er in tab_err]) 148 | 149 | #ax.scatter3D(x_data, y_data, err_data, cmap='binary'); 150 | #ax.contour3D(x_data, y_data, err_data, 50, cmap='binary') 151 | #plt.show() 152 | # print ("\n".join([str(er) for er in tab_err])) 153 | 154 | 155 | print ("--------------") 156 | stab = sorted(tab_err, key=itemgetter(2), reverse=True) 157 | print ("\n".join([str(er) for er in stab[0:5]])) 158 | print ("--------------") 159 | stab2 = sorted(tab_err, key=itemgetter(3), reverse=True) 160 | print ("\n".join([str(er) for er in stab2[0:20]])) 161 | print ("--------------") 162 | ii=0 163 | cur_err = stab2 [ii] 164 | while ([cur_err[0], cur_err[1]] in known_issues): 165 | ii+=1 166 | cur_err = stab2 [ii] 167 | analyseErr (cur_err[0], cur_err[1]) 168 | if __name__ == '__main__': 169 | main() 170 | 171 | 172 | --------------------------------------------------------------------------------