jetomit/avp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Moved inline assembly to a separate file for debugging.

Browse source 
Implemented GetTickCount/timeGetTime.

Added basic SDL/OpenGL support.

Draws something with no optimizations, but draws nothing with -O2. (What is
drawn looks like garbage.)
This commit is contained in:
Steven Fuller 2001-08-08 06:14:20 +00:00 • committed by Patryk Obara
parent 665f33b0f9
commit 9e5b7f430d
10 changed files with 947 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Makefile
View file

@ -6,11 +6,11 @@ CXXFLAGS = $(CFLAGS)
LDLIBS = -lm # /home/relnev/ElectricFence-2.2.2/libefence.a
CFLAGS += `sdl-config --cflags`
LDLIBS += -L/usr/X11R6/lib -lX11 -lXext `sdl-config --libs`
LDLIBS += -L/usr/X11R6/lib -lX11 -lXext -lGL `sdl-config --libs`
AFLAGS = -g -Iinclude/ -w+macro-params -w+orphan-labels -w+number-overflow
ROOT = main.c math.asm stubs.c stubs2.cpp winapi.c afont.c frustum.c kshape.c map.c maths.c md5.c mem3dc.c mem3dcpp.cpp module.c morph.c object.c shpanim.c sphere.c tables.c vdb.c version.c
ROOT = main.c math.asm mathline.c opengl.c stubs.c stubs2.cpp winapi.c afont.c frustum.c kshape.c map.c maths.c md5.c mem3dc.c mem3dcpp.cpp module.c morph.c object.c shpanim.c sphere.c tables.c vdb.c version.c
AVP = ai_sight.c avpview.c bh_agun.c bh_ais.c bh_alien.c bh_binsw.c bh_cable.c bh_corpse.c bh_deathvol.c bh_debri.c bh_dummy.c bh_fan.c bh_far.c bh_fhug.c bh_gener.c bh_ldoor.c bh_lift.c bh_light.c bh_lnksw.c bh_ltfx.c bh_marin.c bh_mission.c bh_near.c bh_pargen.c bh_plachier.c bh_plift.c bh_pred.c bh_queen.c bh_rubberduck.c bh_selfdest.c bh_snds.c bh_spcl.c bh_swdor.c bh_track.c bh_types.c bh_videoscreen.c bh_waypt.c bh_weap.c bh_xeno.c bonusabilities.c cconvars.cpp cdtrackselection.cpp cheatmodes.c comp_map.c comp_shp.c consolelog.cpp davehook.cpp deaths.c decal.c detaillevels.c dynamics.c dynblock.c equipmnt.c equiputl.cpp extents.c game.c game_statistics.c gamecmds.cpp gameflow.c gamevars.cpp hmodel.c hud.c inventry.c language.c lighting.c load_shp.c los.c maps.c mempool.c messagehistory.c missions.cpp movement.c paintball.c particle.c pfarlocs.c pheromon.c player.c pmove.c psnd.c psndproj.c pvisible.c savegame.c scream.cpp secstats.c sfx.c stratdef.c targeting.c track.c triggers.c weapons.c
SHAPES = cube.c
SUPPORT = consbind.cpp consbtch.cpp coordstr.cpp daemon.cpp r2base.cpp r2pos666.cpp reflist.cpp refobj.cpp scstring.cpp strtab.cpp strutil.c trig666.cpp wrapstr.cpp

3
TODO
View file

@ -1 +1,4 @@
* Debug, verify, and reimplant the inline functions in mathline.c to
inline.h

3
src/fixer.h
View file

@ -126,6 +126,9 @@ int GetFileAttributesA(const char *file);
int SetFilePointer(HANDLE file, int x, int y, int z);
int SetEndOfFile(HANDLE file);
unsigned int timeGetTime();
unsigned int GetTickCount();
#ifdef __cplusplus
};
#endif

71
src/main.c
View file

@ -2,6 +2,9 @@
#include <stdlib.h>
#include <string.h>
#include <SDL/SDL.h>
#include <GL/gl.h>
#include "fixer.h"
#include "3dc.h"
@ -32,11 +35,75 @@ int InitialiseWindowsSystem()
{
ScanDrawMode = ScanDrawD3DHardwareRGB;
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "SDL Init failed: %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
if (SDL_SetVideoMode(640, 480, 0, SDL_OPENGL) == NULL) {
fprintf(stderr, "SDL SetVideoMode failed: %s\n", SDL_GetError());
SDL_Quit();
exit(EXIT_FAILURE);
}
glViewport(0, 0, 640, 480);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1, 1, -1, 1, 1, 1000);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
return 0;
}
void CheckForWindowsMessages()
{
SDL_Event event;
if (SDL_PollEvent(&event)) {
do {
switch(event.type) {
case SDL_KEYDOWN:
break;
case SDL_KEYUP:
break;
case SDL_QUIT:
SDL_Quit();
exit(17); /* TODO tempy! */
break;
}
} while (SDL_PollEvent(&event));
}
}
void InGameFlipBuffers()
{
SDL_GL_SwapBuffers();
}
void ThisFramesRenderingHasBegun()
{
fprintf(stderr, "ThisFramesRenderingHasBegun()\n");
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void ThisFramesRenderingHasFinished()
{
fprintf(stderr, "ThisFramesRenderingHasFinished()\n");
}
int ExitWindowsSystem()
{
SDL_Quit();
return 0;
}
@ -176,9 +243,7 @@ int main(int argc, char *argv[])
ThisFramesRenderingHasFinished();
/* NOT YET
InGameFlipBuffers();
*/
FrameCounterHandler();
{
@ -209,7 +274,7 @@ int main(int argc, char *argv[])
RestartLevel();
}
break; /* TODO -- remove when loop works */
// break; /* TODO -- remove when loop works */
}
AvP.LevelCompleted = thisLevelHasBeenCompleted;

740
src/mathline.c Normal file
View file

@ -0,0 +1,740 @@
#include "3dc.h"
void ADD_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c);
void ADD_LL_PP(LONGLONGCH *c, LONGLONGCH *a);
void SUB_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c);
void SUB_LL_MM(LONGLONGCH *c, LONGLONGCH *a);
void MUL_I_WIDE(int a, int b, LONGLONGCH *c);
int CMP_LL(LONGLONGCH *a, LONGLONGCH *b);
void EQUALS_LL(LONGLONGCH *a, LONGLONGCH *b);
void NEG_LL(LONGLONGCH *a);
void ASR_LL(LONGLONGCH *a, int shift);
void IntToLL(LONGLONGCH *a, int *b);
int MUL_FIXED(int a, int b);
int DIV_FIXED(int a, int b);
#define DIV_INT(a, b) ((a) / (b))
int NarrowDivide(LONGLONGCH *a, int b);
int WideMulNarrowDiv(int a, int b, int c);
void RotateVector_ASM(VECTORCH *v, MATRIXCH *m);
void RotateAndCopyVector_ASM(VECTORCH *v1, VECTORCH *v2, MATRIXCH *m);
int FloatToInt(float);
#define f2i(a, b) { a = FloatToInt(b); }
void ADD_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c)
{
/*
_asm
{
mov esi,a
mov edi,b
mov ebx,c
mov eax,[esi]
mov edx,[esi+4]
add eax,[edi]
adc edx,[edi+4]
mov [ebx],eax
mov [ebx+4],edx
}
*/
__asm__("movl 0(%%esi), %%eax \n\t"
"movl 4(%%esi), %%edx \n\t"
"addl 0(%%edi), %%eax \n\t"
"adcl 4(%%edi), %%edx \n\t"
"movl %%eax, 0(%%ebx) \n\t"
"movl %%edx, 4(%%ebx) \n\t"
:
: "S" (a), "D" (b), "b" (c)
: "%eax", "%edx", "memory", "cc"
);
/*
__asm__("movl 0(%%esi), %%eax \n\t"
"movl 4(%%esi), %%edx \n\t"
"addl 0(%%edi), %%eax \n\t"
"adcl 4(%%edi), %%edx \n\t"
: "=a" (c->lo32), "=d" (c->hi32)
: "S" (a), "D" (b)
);
*/
}
/* ADD ++ */
void ADD_LL_PP(LONGLONGCH *c, LONGLONGCH *a)
{
/*
_asm
{
mov edi,c
mov esi,a
mov eax,[esi]
mov edx,[esi+4]
add [edi],eax
adc [edi+4],edx
}
*/
__asm__("movl 0(%%esi), %%eax \n\t"
"movl 4(%%esi), %%edx \n\t"
"addl %%eax, 0(%%edi) \n\t"
"adcl %%edx, 4(%%edi) \n\t"
:
: "D" (c), "S" (a)
: "%eax", "%edx", "memory", "cc"
);
}
/* SUB */
void SUB_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c)
{
/*
_asm
{
mov esi,a
mov edi,b
mov ebx,c
mov eax,[esi]
mov edx,[esi+4]
sub eax,[edi]
sbb edx,[edi+4]
mov [ebx],eax
mov [ebx+4],edx
}
*/
__asm__("movl 0(%%esi), %%eax \n\t"
"movl 4(%%esi), %%edx \n\t"
"subl 0(%%edi), %%eax \n\t"
"sbbl 4(%%edi), %%edx \n\t"
"movl %%eax, 0(%%ebx) \n\t"
"movl %%edx, 4(%%ebx) \n\t"
:
: "S" (a), "D" (b), "b" (c)
: "%eax", "%edx", "memory", "cc"
);
}
/* SUB -- */
void SUB_LL_MM(LONGLONGCH *c, LONGLONGCH *a)
{
/*
_asm
{
mov edi,c
mov esi,a
mov eax,[esi]
mov edx,[esi+4]
sub [edi],eax
sbb [edi+4],edx
}
*/
__asm__("movl 0(%%esi), %%eax \n\t"
"movl 4(%%esi), %%edx \n\t"
"subl %%eax, 0(%%edi) \n\t"
"sbbl %%edx, 4(%%edi) \n\t"
:
: "D" (c), "S" (a)
: "%eax", "%edx", "memory", "cc"
);
}
/*
MUL
This is the multiply we use, the 32 x 32 = 64 widening version
*/
void MUL_I_WIDE(int a, int b, LONGLONGCH *c)
{
/*
_asm
{
mov eax,a
mov ebx,c
imul b
mov [ebx],eax
mov [ebx+4],edx
}
*/
__asm__("imull %2 \n\t"
"movl %%eax, 0(%%ebx) \n\t"
"movl %%edx, 4(%%ebx) \n\t"
:
: "a" (a), "b" (c), "q" (b)
: "%edx", "memory", "cc"
);
}
/*
CMP
This substitutes for ==, >, <, >=, <=
*/
int CMP_LL(LONGLONGCH *a, LONGLONGCH *b)
{
int retval;
/*
_asm
{
mov ebx,a
mov ecx,b
mov eax,[ebx]
mov edx,[ebx+4]
sub eax,[ecx]
sbb edx,[ecx+4]
and edx,edx
jne llnz
and eax,eax
je llgs
llnz:
mov retval,1
and edx,edx
jge llgs
neg retval
llgs:
}
*/
/* TODO */
__asm__("movl 0(%%ebx), %%eax \n\t"
"movl 4(%%ebx), %%edx \n\t"
"subl 0(%%ecx), %%eax \n\t"
"sbbl 4(%%ecx), %%edx \n\t"
"xorl %0, %0 \n\t" /* hopefully it doesn't pick %eax or %edx */
"andl %%edx, %%edx \n\t"
"jne 0 \n\t" /* llnz */
"andl %%eax, %%eax \n\t"
"je 1 \n" /* llgs */
"0: \n\t" /* llnz */
"movl $1, %0 \n\t"
"andl %%edx, %%edx \n\t"
"jge 1 \n\t" /* llgs */
"negl %0 \n"
"1: \n\t" /* llgs */
: "=r" (retval)
: "b" (a), "c" (b)
: "%eax", "%edx", "memory", "cc"
);
return retval;
}
/* EQUALS */
void EQUALS_LL(LONGLONGCH *a, LONGLONGCH *b)
{
/*
_asm
{
mov edi,a
mov esi,b
mov eax,[esi]
mov edx,[esi+4]
mov [edi],eax
mov [edi+4],edx
}
*/
__asm__("movl 0(%%esi), %%eax \n\t"
"movl 4(%%esi), %%edx \n\t"
"movl %%eax, 0(%%edi) \n\t"
"movl %%edx, 4(%%edi) \n\t"
:
: "D" (a), "S" (b)
: "%eax", "%edx", "memory"
);
}
/* NEGATE */
void NEG_LL(LONGLONGCH *a)
{
/*
_asm
{
mov esi,a
not dword ptr[esi]
not dword ptr[esi+4]
add dword ptr[esi],1
adc dword ptr[esi+4],0
}
*/
__asm__("notl 0(%%esi) \n\t"
"notl 4(%%esi) \n\t"
"addl $1, 0(%%esi) \n\t"
"adcl $0, 4(%%esi) \n\t"
:
: "S" (a)
: "memory", "cc"
);
}
/* ASR */
void ASR_LL(LONGLONGCH *a, int shift)
{
/*
_asm
{
mov esi,a
mov eax,shift
and eax,eax
jle asrdn
asrlp:
sar dword ptr[esi+4],1
rcr dword ptr[esi],1
dec eax
jne asrlp
asrdn:
}
*/
__asm__("andl %%eax, %%eax \n\t"
"jle 0 \n" /* asrdn */
"1: \n\t" /* asrlp */
"sarl $1, 4(%%esi) \n\t"
"rcrl $1, 0(%%esi) \n\t"
"decl %%eax \n\t"
"jne 1 \n"
"0: \n\t"
:
: "S" (a), "a" (shift)
: "memory", "cc"
);
}
/* Convert int to LONGLONGCH */
void IntToLL(LONGLONGCH *a, int *b)
{
/*
_asm
{
mov esi,b
mov edi,a
mov eax,[esi]
cdq
mov [edi],eax
mov [edi+4],edx
}
*/
__asm__("movl 0(%%esi), %%eax \n\t"
"cdq \n\t"
"movl %%eax, 0(%%edi) \n\t"
"movl %%edx, 4(%%edi) \n\t"
:
: "S" (b), "D" (a)
: "%eax", "%edx", "memory", "cc"
);
}
/*
Fixed Point Multiply.
16.16 * 16.16 -> 16.16
or
16.16 * 0.32 -> 0.32
A proper version of this function ought to read
16.16 * 16.16 -> 32.16
but this would require a long long result
Algorithm:
Take the mid 32 bits of the 64 bit result
*/
/*
These functions have been checked for suitability for
a Pentium and look as if they would work adequately.
Might be worth a more detailed look at optimising
them though.
*/
int MUL_FIXED(int a, int b)
{
int retval;
/*
_asm
{
mov eax,a
imul b
shrd eax,edx,16
mov retval,eax
}
*/
/* TODO */
__asm__("imull %2 \n\t"
"shrdl $16, %%edx, %%eax \n\t"
: "=a" (retval)
: "a" (a), "q" (b)
: "%edx", "cc"
);
return retval;
}
/*
Fixed Point Divide - returns a / b
*/
int DIV_FIXED(int a, int b)
{
int retval;
/*
_asm
{
mov eax,a
cdq
rol eax,16
mov dx,ax
xor ax,ax
idiv b
mov retval,eax
}
*/
/* TODO */
__asm__("cdq \n\t"
"roll $16, %%eax \n\t"
"mov %%ax, %%dx \n\t"
"xor %%ax, %%ax \n\t"
"idivl %2 \n\t"
: "=a" (retval)
: "a" (a), "q" (b)
: "%edx", "cc"
);
return retval;
}
/*
Multiply and Divide Functions.
*/
/*
32/32 division
This macro is a function on some other platforms
*/
#define DIV_INT(a, b) ((a) / (b))
/*
A Narrowing 64/32 Division
*/
int NarrowDivide(LONGLONGCH *a, int b)
{
int retval;
/*
_asm
{
mov esi,a
mov eax,[esi]
mov edx,[esi+4]
idiv b
mov retval,eax
}
*/
__asm__("movl 0(%%esi), %%eax \n\t"
"movl 4(%%esi), %%edx \n\t"
"idivl %%ebx \n\t"
: "=a" (retval)
: "S" (a), "b" (b)
: "%edx", "cc"
);
return retval;
}
/*
This function performs a Widening Multiply followed by a Narrowing Divide.
a = (a * b) / c
*/
int WideMulNarrowDiv(int a, int b, int c)
{
#if 0 /* TODO: broken? */
int retval;
/*
_asm
{
mov eax,a
imul b
idiv c
mov retval,eax
}
*/
/* TODO */
__asm__("imull %2 \n\t"
"idivl %3 \n\t"
: "=a" (retval)
: "a" (a), "q" (b), "q" (c)
: "cc"
);
return retval;
#endif
return (a * b) / c;
}
/*
Function to rotate a VECTORCH using a MATRIXCH
This is the C function
x = MUL_FIXED(m->mat11, v->vx);
x += MUL_FIXED(m->mat21, v->vy);
x += MUL_FIXED(m->mat31, v->vz);
y = MUL_FIXED(m->mat12, v->vx);
y += MUL_FIXED(m->mat22, v->vy);
y += MUL_FIXED(m->mat32, v->vz);
z = MUL_FIXED(m->mat13, v->vx);
z += MUL_FIXED(m->mat23, v->vy);
z += MUL_FIXED(m->mat33, v->vz);
v->vx = x;
v->vy = y;
v->vz = z;
This is the MUL_FIXED inline assembler function
imul edx
shrd eax,edx,16
typedef struct matrixch {
int mat11; 0
int mat12; 4
int mat13; 8
int mat21; 12
int mat22; 16
int mat23; 20
int mat31; 24
int mat32; 28
int mat33; 32
} MATRIXCH;
*/
#if 0 /* TODO if these are needed */
static void RotateVector_ASM(VECTORCH *v, MATRIXCH *m)
{
_asm
{
mov esi,v
mov edi,m
mov eax,[edi + 0]
imul DWORD PTR [esi + 0]
shrd eax,edx,16
mov ecx,eax
mov eax,[edi + 12]
imul DWORD PTR [esi + 4]
shrd eax,edx,16
add ecx,eax
mov eax,[edi + 24]
imul DWORD PTR [esi + 8]
shrd eax,edx,16
add ecx,eax
mov eax,[edi + 4]
imul DWORD PTR [esi + 0]
shrd eax,edx,16
mov ebx,eax
mov eax,[edi + 16]
imul DWORD PTR [esi + 4]
shrd eax,edx,16
add ebx,eax
mov eax,[edi + 28]
imul DWORD PTR [esi + 8]
shrd eax,edx,16
add ebx,eax
mov eax,[edi + 8]
imul DWORD PTR [esi + 0]
shrd eax,edx,16
mov ebp,eax
mov eax,[edi + 20]
imul DWORD PTR [esi + 4]
shrd eax,edx,16
add ebp,eax
mov eax,[edi + 32]
imul DWORD PTR [esi + 8]
shrd eax,edx,16
add ebp,eax
mov [esi + 0],ecx
mov [esi + 4],ebx
mov [esi + 8],ebp
}
}
/*
Here is the same function, this time copying the result to a second vector
*/
static void RotateAndCopyVector_ASM(VECTORCH *v1, VECTORCH *v2, MATRIXCH *m)
{
_asm
{
mov esi,v1
mov edi,m
mov eax,[edi + 0]
imul DWORD PTR [esi + 0]
shrd eax,edx,16
mov ecx,eax
mov eax,[edi + 12]
imul DWORD PTR [esi + 4]
shrd eax,edx,16
add ecx,eax
mov eax,[edi + 24]
imul DWORD PTR [esi + 8]
shrd eax,edx,16
add ecx,eax
mov eax,[edi + 4]
imul DWORD PTR [esi + 0]
shrd eax,edx,16
mov ebx,eax
mov eax,[edi + 16]
imul DWORD PTR [esi + 4]
shrd eax,edx,16
add ebx,eax
mov eax,[edi + 28]
imul DWORD PTR [esi + 8]
shrd eax,edx,16
add ebx,eax
mov eax,[edi + 8]
imul DWORD PTR [esi + 0]
shrd eax,edx,16
mov ebp,eax
mov eax,[edi + 20]
imul DWORD PTR [esi + 4]
shrd eax,edx,16
add ebp,eax
mov eax,[edi + 32]
imul DWORD PTR [esi + 8]
shrd eax,edx,16
add ebp,eax
mov edx,v2
mov [edx + 0],ecx
mov [edx + 4],ebx
mov [edx + 8],ebp
}
}
#endif
/*
Square Root
Returns the Square Root of a 32-bit number
*/
extern int sqrt_temp1;
extern int sqrt_temp2;
int SqRoot32(int A)
{
#if 1
sqrt_temp1 = A;
/*
_asm
{
finit
fild A
fsqrt
fistp temp2
fwait
}
*/
__asm__("finit \n\t"
"fild sqrt_temp1 \n\t"
"fsqrt \n\t"
"fistp sqrt_temp2 \n\t"
"fwait \n\t"
:
:
: "memory", "cc"
);
return sqrt_temp2;
#else
{ /* TODO: clean this please */
double x = A;
double retvald = sqrt(x);
int retval = retvald;
return retval;
}
#endif
}
/*
This may look ugly (it is) but it is a MUCH faster way to convert "float" into "int" than
the function call "CHP" used by the WATCOM compiler.
*/
extern float fti_fptmp;
extern int fti_itmp;
int FloatToInt(float fptmp)
{
#if 1
fti_fptmp = fptmp;
/*
_asm
{
fld fptmp
fistp itmp
}
*/
__asm__("fld fti_fptmp \n\t"
"fistp fti_itmp \n\t"
:
:
: "memory", "cc"
);
return fti_itmp;
#else
return fptmp;
#endif
}

5
src/maths.c
View file

@ -1009,7 +1009,7 @@ void MatrixToEuler(MATRIXCH *m, EULER *e)
}
else CosMatrixPitch = 1;
SineMatrixYaw = WideMulNarrowDiv(
#if j_and_r_change
m->mat31 >> m2e_scale, ONE_FIXED_S, CosMatrixPitch);
@ -2090,9 +2090,12 @@ int PointInPolygon(int *point, int *polygon, int c, int ppsize)
/* go back to first point */
polyp = polygon;
dx = 0; /* TODO: uninitialized?? */
/* for each point */
while (0 != c)
{
/* is this line straddling the x co-ordinate of the point? */
/* if not it is not worth testing for intersection with the half-line */
/* we must be careful to get the strict and non-stict inequalities */

68
src/opengl.c Normal file
View file

@ -0,0 +1,68 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <SDL.h>
#include <GL/gl.h>
#include <GL/glext.h>
#include "fixer.h"
#include "3dc.h"
#include "platform.h"
#include "module.h"
#include "stratdef.h"
#include "projfont.h"
#include "savegame.h"
#include "krender.h"
#include "kshape.h"
#include "prototyp.h"
#include "d3d_hud.h"
extern IMAGEHEADER ImageHeaderArray[];
extern VIEWDESCRIPTORBLOCK *Global_VDB_Ptr;
static void *CurrTextureHandle;
void D3D_ZBufferedGouraudTexturedPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *renderVerticesPtr)
{
int texoffset;
void *TextureHandle;
int i;
texoffset = inputPolyPtr->PolyColour & ClrTxDefn;
if (texoffset) {
TextureHandle = (void *)ImageHeaderArray[texoffset].D3DHandle;
} else {
TextureHandle = CurrTextureHandle;
}
fprintf(stderr, "D3D_ZBufferedGouraudTexturedPolygon_Output(%p, %p)\n", inputPolyPtr, renderVerticesPtr);
fprintf(stderr, "\tRenderPolygon.NumberOfVertices = %d\n", RenderPolygon.NumberOfVertices);
fprintf(stderr, "\ttexoffset = %d (ptr = %p)\n", texoffset, texoffset ? (void *)ImageHeaderArray[texoffset].D3DHandle : CurrTextureHandle);
glBegin(GL_POLYGON);
for (i = 0; i < RenderPolygon.NumberOfVertices; i++) {
GLfloat x, y, z;
int x1, y1;
RENDERVERTEX *vertices = &renderVerticesPtr[i];
/* this is just random garbage */
// x1 = (vertices->X*(Global_VDB_Ptr->VDB_ProjX+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreX;
// y1 = (vertices->Y*(Global_VDB_Ptr->VDB_ProjY+1))/vertices->Z+Global_VDB_Ptr->VDB_CentreY;
x = vertices->X;
y = vertices->Y;
x = x/32768.0;
y = y/32768.0;
z = -1+-1.0f/vertices->Z;
glColor4ub(vertices->R, vertices->G, vertices->B, vertices->A);
glVertex3f(x, y, z);
fprintf(stderr, "Vertex %d: (%f, %f, %f) [%d, %d, %d] (%d, %d, %d, %d)\n", i, x, y, z, vertices->X, vertices->Y, vertices->Z, vertices->R, vertices->G, vertices->B, vertices->A);
}
glEnd();
CurrTextureHandle = TextureHandle;
}

39
src/stubs.c
View file

@ -18,20 +18,11 @@
#include "d3d_hud.h"
extern IMAGEHEADER ImageHeaderArray[];
/* winmain.c */
BOOL KeepMainRifFile = FALSE;
int HWAccel = 1;
/* win_func.cpp */
void CheckForWindowsMessages()
{
fprintf(stderr, "CheckForWindowsMessages()\n");
}
/* krender.c -- thought this file was unused */
void KDraw_Item_2dTexturePolygon(int *itemptr)
{
@ -476,16 +467,6 @@ BOOL UnlockExecuteBufferAndPrepareForUse()
return FALSE;
}
void ThisFramesRenderingHasBegun()
{
fprintf(stderr, "ThisFramesRenderingHasBegun()\n");
}
void ThisFramesRenderingHasFinished()
{
fprintf(stderr, "ThisFramesRenderingHasFinished()\n");
}
void SecondFlushD3DZBuffer()
{
fprintf(stderr, "SecondFlushD3DZBuffer()\n");
@ -535,26 +516,6 @@ BOOL EndD3DScene()
return FALSE;
}
static void *CurrTextureHandle;
void D3D_ZBufferedGouraudTexturedPolygon_Output(POLYHEADER *inputPolyPtr, RENDERVERTEX *renderVerticesPtr)
{
int texoffset;
void *TextureHandle;
texoffset = inputPolyPtr->PolyColour & ClrTxDefn;
if (texoffset) {
TextureHandle = (void *)ImageHeaderArray[texoffset].D3DHandle;
} else {
TextureHandle = CurrTextureHandle;
}
fprintf(stderr, "D3D_ZBufferedGouraudTexturedPolygon_Output(%p, %p)\n", inputPolyPtr, renderVerticesPtr);
fprintf(stderr, "\tRenderPolygon.NumberOfVertices = %d\n", RenderPolygon.NumberOfVertices);
fprintf(stderr, "\ttexoffset = %d (ptr = %p)\n", texoffset, texoffset ? (void *)ImageHeaderArray[texoffset].D3DHandle : CurrTextureHandle);
CurrTextureHandle = TextureHandle;
}
void D3D_ZBufferedGouraudPolygon_Output(POLYHEADER *inputPolyPtr,RENDERVERTEX *renderVerticesPtr)
{
fprintf(stderr, "D3D_ZBufferedGouraudPolygon_Output(%p, %p)\n", inputPolyPtr, renderVerticesPtr);

46
src/win95/inline.h
View file

@ -1111,7 +1111,7 @@ a = itmp;}
#else
#if 0
#if 1 /* GCC! */
void ADD_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c);
void ADD_LL_PP(LONGLONGCH *c, LONGLONGCH *a);
void SUB_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c);
@ -1134,10 +1134,12 @@ void RotateAndCopyVector_ASM(VECTORCH *v1, VECTORCH *v2, MATRIXCH *m);
int FloatToInt(float);
#define f2i(a, b) { a = FloatToInt(b); }
#endif
#else /* inline stuff */
/* ADD */
static __inline__ void ADD_LL(LONGLONGCH *a, LONGLONGCH *b, LONGLONGCH *c)
{
/*
@ -1319,21 +1321,21 @@ static __inline__ int CMP_LL(LONGLONGCH *a, LONGLONGCH *b)
}
*/
/* TODO */
__asm__("xorl %0, %0 \n\t"
"movl 0(%%ebx), %%eax \n\t"
__asm__("movl 0(%%ebx), %%eax \n\t"
"movl 4(%%ebx), %%edx \n\t"
"subl 0(%%ecx), %%eax \n\t"
"sbbl 4(%%ecx), %%edx \n\t"
"xorl %0, %0 \n\t" /* hopefully it doesn't pick %eax or %edx */
"andl %%edx, %%edx \n\t"
"jne llnz \n\t"
"jne 0 \n\t" /* llnz */
"andl %%eax, %%eax \n\t"
"je llgs \n"
"llnz: \n\t"
"je 1 \n" /* llgs */
"0: \n\t" /* llnz */
"movl $1, %0 \n\t"
"andl %%edx, %%edx \n\t"
"jge llgs \n\t"
"jge 1 \n\t" /* llgs */
"negl %0 \n"
"llgs: \n\t"
"1: \n\t" /* llgs */
: "=r" (retval)
: "b" (a), "c" (b)
: "%eax", "%edx", "memory", "cc"
@ -1411,13 +1413,13 @@ static __inline__ void ASR_LL(LONGLONGCH *a, int shift)
}
*/
__asm__("andl %%eax, %%eax \n\t"
"jle asrdn \n"
"asrlp: \n\t"
"jle 0 \n" /* asrdn */
"1: \n\t" /* asrlp */
"sarl $1, 4(%%esi) \n\t"
"rcrl $1, 0(%%esi) \n\t"
"decl %%eax \n\t"
"jne asrlp \n"
"asrdn: \n\t"
"jne 1 \n"
"0: \n\t"
:
: "S" (a), "a" (shift)
: "memory", "cc"
@ -1589,6 +1591,7 @@ __asm__("movl 0(%%esi), %%eax \n\t"
static __inline__ int WideMulNarrowDiv(int a, int b, int c)
{
#if 0 /* TODO: broken? */
int retval;
/*
_asm
@ -1607,6 +1610,8 @@ __asm__("imull %2 \n\t"
: "cc"
);
return retval;
#endif
return (a * b) / c;
}
/*
@ -1781,8 +1786,10 @@ static void RotateAndCopyVector_ASM(VECTORCH *v1, VECTORCH *v2, MATRIXCH *m)
extern int sqrt_temp1;
extern int sqrt_temp2;
#include <math.h>
static __inline__ int SqRoot32(int A)
{
#if 0
sqrt_temp1 = A;
/*
_asm
@ -1806,6 +1813,13 @@ __asm__("finit \n\t"
);
return sqrt_temp2;
#endif
{ /* TODO: clean this please */
double x = A;
double retvald = sqrt(x);
int retval = retvald;
return retval;
}
}
#endif
@ -1823,6 +1837,7 @@ extern int fti_itmp;
static __inline__ int FloatToInt(float fptmp)
{
#if 0
fti_fptmp = fptmp;
/*
_asm
@ -1839,6 +1854,9 @@ __asm__("fld fti_fptmp \n\t"
);
return fti_itmp;
#endif
return fptmp;
}
/*
@ -1851,6 +1869,8 @@ __asm__("fld fti_fptmp \n\t"
a = FloatToInt(b); \
}
#endif
#endif
int WideMul2NarrowDiv(int a, int b, int c, int d, int e);

33
src/winapi.c
View file

@ -6,6 +6,7 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/time.h>
#include "fixer.h"
@ -182,16 +183,34 @@ int SetEndOfFile(HANDLE file)
}
/* time in miliseconds */
int timeGetTime()
struct timeval tv0;
unsigned int timeGetTime()
{
fprintf(stderr, "timeGetTime()\n");
struct timeval tv1;
int secs, usecs;
return 0;
if (tv0.tv_sec == 0) {
gettimeofday(&tv0, NULL);
return 0;
}
gettimeofday(&tv1, NULL);
secs = tv1.tv_sec - tv0.tv_sec;
usecs = tv1.tv_usec - tv0.tv_usec;
if (usecs < 0) {
usecs += 1000000;
secs--;
}
printf("Ticks = %u\n", secs * 1000 + (usecs / 1000));
return secs * 1000 + (usecs / 1000);
}
int GetTickCount()
unsigned int GetTickCount()
{
fprintf(stderr, "GetTickCount()\n");
return 0;
return timeGetTime();
}