etc
/
BRender-v1.3.2
mirror of https://github.com/foone/BRender-v1.3.2.git
0
0
Fork 0
Code Issues Projects Releases Wiki Activity

Adding source of the v1.3.2 version of BRender

This commit is contained in:
Foone Turing 2022-05-03 13:10:13 -07:00
parent 619c8d9af3
commit 71e401db2e
1163 changed files with 324992 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
core/dosio/clock.asm Normal file
View File

@ -0,0 +1,104 @@
;; Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
;;
;; $Id: clock.asm 1.1 1997/12/10 16:40:58 jon Exp $
;; $Locker: $
;;
.386p
.model flat
if ADD_RCS_ID
.data
db '$Id: clock.asm 1.1 1997/12/10 16:40:58 jon Exp $',0
align 4
endif
.data
; Offset of BIOS RAM - system ticks
;
TIMER_OFFSET equ 046ch
; Port for mode control of 8253
;
PIT_MODE equ 43h
; Port for reading/writing count 0 of PIT
;
PIT_TIMER0 equ 40h
.code
extrn _HostRealWordRead:proc
; void DOSClockBegin(void);
;
public _DOSClockBegin
_DOSClockBegin proc
; Make sure real mode descriptors are setup
;
; Linear count
;
mov al,00110100b
out PIT_MODE,al
xor al,al
out PIT_TIMER0,al
out PIT_TIMER0,al
ret
_DOSClockBegin endp
; void DOSClockEnd(void);
;
public _DOSClockEnd
_DOSClockEnd proc
ret
_DOSClockEnd endp
; unsigned DOSClockRead(void);
;
public _DOSClockRead
_DOSClockRead proc
push es
push ecx
push edx
cli
; Read 1/18th ticks from BIOS work area
;
push 0
push TIMER_OFFSET
call _HostRealWordRead
add esp,8
mov dx,ax
; Mode 2, read downcount
;
xor al,al
out PIT_MODE,al
; Read the PIT downcount and save in timer area
;
in al,PIT_TIMER0
mov ah,al
in al,PIT_TIMER0
xchg al,ah
neg ax
sti
; Merge DX:AX into EAX
;
shl edx,16
mov dx,ax
mov eax,edx
pop edx
pop ecx
pop es
ret
_DOSClockRead endp
end

55
core/dosio/divtrap.c Normal file
View File

@ -0,0 +1,55 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: divtrap.c 1.1 1997/12/10 16:40:58 jon Exp $
* $Locker: $
*
* BIOS interface functions for drivers
*/
#include "brender.h"
#include "host.h"
#include "dosio.h"
BR_RCS_ID("$Id: divtrap.c 1.1 1997/12/10 16:40:58 jon Exp $")
static host_exception_hook div_hook;
extern void BR_ASM_CALL DivTrapHandler(void);
static int trapActive = BR_FALSE;
br_error BR_PUBLIC_ENTRY DOSDivTrapBegin(void)
{
br_error r;
host_info hi;
br_uint_16 cseg;
if(trapActive)
return BRE_ALLREADY_ACTIVE;
/*
* Make sure host is up to it
*/
HostInfo(&hi,sizeof(hi));
if(!(hi.capabilities & HOST_CAPS_EXCEPTION_HOOK))
return BRE_FAIL;
HostSelectorCS(&cseg);
r = HostExceptionHook(&div_hook, 0, (br_uint_32)DivTrapHandler, cseg);
if(r != BRE_OK)
return r;
trapActive = BR_TRUE;
return BRE_OK;
}
void BR_PUBLIC_ENTRY DOSDivTrapEnd(void)
{
if(!trapActive)
return;
HostExceptionUnhook(&div_hook);
}

241
core/dosio/divtraph.asm Normal file
View File

@ -0,0 +1,241 @@
;; Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
;;
;; $Id: divtraph.asm 1.1 1997/12/10 16:40:58 jon Exp $
;; $Locker: $
;;
;; Supress integer divide by zero exceptions by stepping on to the
;; next insn
;;
;; Assumes that exception always happens in USE32 code and data
;;
.386p
.model flat
if ADD_RCS_ID
.data
db '$Id: divtraph.asm 1.1 1997/12/10 16:40:58 jon Exp $',0
align 4
endif
.code
; Count incremented by overflow handler (lives in CS: so that handler can get to it
;
DivTrapCounter dd 0
_DivTrapHandler proc
; Set up a stack frame to get at the saved CS:EIP
;
; SS 32 | Application
; ESP 28 |
; EFLAGS 24 |
; CS 20 |
; EIP 16 |
;
; Error 12
; CS (Return) 8 | DPMI server
; EIP (Return) 4 |
;SS:EBP-> EBP 0
;
;
push ebp
mov ebp,esp
push eax
push esi
push es
; Get CS:EIP
;
les esi,[ebp+16]
; Eat up any valid insn prefixes
;
again:
lods byte ptr es:[esi]
cmp al,0f0h ; LOCK
je again
cmp al,02eh ; CS override
je again
cmp al,036h ; SS override
je again
cmp al,03eh ; DS override
je again
cmp al,026h ; ES override
je again
cmp al,064h ; FS override
je again
cmp al,065h ; GS override
je again
cmp al,066h ; Operand Size prefix
je again
cmp al,067h ; Address Size prefix - can't handle
je panic
; put insn in ah , get regmod byte into al
;
mov ah,al
lods byte ptr es:[esi]
; Check insn is a divide
;
cmp ah,0f6h ; byte (i)div
je insn_ok
cmp ah,0f7h ; word (i)div
jne panic
insn_ok:
; Check regmod for 16 bit address size
;
; - opcode field is either 6 or 7 (div vs. idiv)
;
mov ah,al
and ah,00110000b ; top 2 bits of opcode
cmp ah,00110000b
jne panic
; rm = 11iiixxx is register
;
cmp al,011000000b
jae restore
; Consume any data after insn
;
and al,011000111b ; get rid of opcode
; special case of disp32
;
cmp al,000000101b
je four_bytes
; account for any SIB
;
mov ah,al
and ah,000000111b
cmp ah,000000100b
jne no_sib
inc esi
no_sib:
; Consume displacement
;
and al,011000000b
cmp al,010000000b ; disp32
je four_bytes
cmp al,001000000b ; disp8
je one_byte
; No more insn data to be skipped
;
jmp restore
; Skip two bytes following regmod
;
four_bytes:
add esi,3
; Skip one byte following regmod
;
one_byte:
inc esi
restore:
; Incement counter
;
inc ds:DivTrapCounter ; XXX Assumes CS and DS are aliases
; Put new EIP back into stack and exit
;
mov [ebp+16],esi
pop es
pop esi
pop eax
pop ebp
retf
; Could not handle situation - chain to previous handler
;
panic:
db 0EAh ; JMP FAR
; Previous handler pointer (becomes part of above jump
;
old_db0_handler label fword
df 0
_DivTrapHandler endp
if 0
; int ASM_CALL DOSDivTrapBegin(void);
;
; Install divide exception handler
;
; Returns 0 if sucessful
;
_DOSDivTrapBegin proc
push ebx
; Fetch old exception handler
;
mov eax,0202h
mov bl,0
int 31h
jc failed
mov dword ptr ds:old_db0_handler,edx
mov word ptr ds:old_db0_handler+4,cx
; Set new exception handler
;
mov eax,0203h
mov bl,0
mov cx,cs
mov edx,offset _DivTrapHandler
int 31h
; Return success/fail flag
;
failed: sbb eax,eax
pop ebx
ret
_DOSDivTrapBegin endp
; int ASM_CALL DOSDivTrapEnd(void);
;
; Restore previous divide exception handler
;
_DOSDivTrapEnd proc
push ebx
; Set new exception handler
;
mov eax,0203h
mov bl,0
mov edx,dword ptr old_db0_handler
mov cx,word ptr old_db0_handler+4
int 31h
sbb eax,eax
pop ebx
ret
_DOSDivTrapEnd endp
endif
; int ASM_CALL DOSDivTrapCount(int reset);
;
; Returns number of divide traps that have happened
_DOSDivTrapCount proc
mov eax,DivTrapCounter
cmp dword ptr 4[esp],0
je done
mov DivTrapCounter,0
done: ret
_DOSDivTrapCount endp
end

73
core/dosio/dos_p.h Normal file
View File

@ -0,0 +1,73 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: dos_p.h 1.1 1997/12/10 16:40:59 jon Exp $
* $Locker: $
*
* Function prototypes for Brender DOS IO library
*/
#ifndef _DOS_P_H_
#define _DOS_P_H_
#ifdef __cplusplus
extern "C" {
#endif
#ifndef _NO_PROTOTYPES
/*
* Setup/teardown
*/
br_error BR_PUBLIC_ENTRY DOSBegin(void);
void BR_PUBLIC_ENTRY DOSEnd(void);
/*
* Mouse reading
*/
br_error BR_PUBLIC_ENTRY DOSMouseBegin(void);
void BR_PUBLIC_ENTRY DOSMouseEnd(void);
br_error BR_PUBLIC_ENTRY DOSMouseRead(br_int_32 *mouse_x, br_int_32 *mouse_y, br_uint_32 *mouse_buttons);
/*
* Reading system clock
*/
br_error BR_ASM_CALL DOSClockBegin(void);
br_error BR_ASM_CALL DOSClockEnd(void);
br_uint_32 BR_ASM_CALL DOSClockRead(void);
/*
* Keyboard UP/DOWN handling
*/
br_error BR_PUBLIC_ENTRY DOSKeyBegin(void);
void BR_PUBLIC_ENTRY DOSKeyEnd(void);
br_boolean BR_PUBLIC_ENTRY DOSKeyTest(br_uint_8 scancode,br_uint_8 qualifiers, br_uint_8 repeats);
br_error BR_PUBLIC_ENTRY DOSKeyEnableBIOS(br_boolean flag);
/*
* Divide overflow suppressor
*/
br_error BR_PUBLIC_ENTRY DOSDivTrapBegin(void);
void BR_PUBLIC_ENTRY DOSDivTrapEnd(void);
br_uint_32 BR_ASM_CALL DOSDivTrapCount(br_boolean reset);
/*
* Event queue for mouse and keyboard
*/
br_error BR_PUBLIC_ENTRY DOSEventBegin(void);
void BR_PUBLIC_ENTRY DOSEventEnd(void);
br_boolean BR_PUBLIC_ENTRY DOSEventWait(struct dosio_event *event, br_boolean block);
/*
* Backwards compatibility
*/
#define DOSGfxBegin BrDevBeginOld
#define DOSGfxEnd BrDevEndOld
#define DOSGfxPaletteSet BrDevPaletteSetOld
#define DOSGfxPaletteSetEntry BrDevPaletteSetEntryOld
#endif /* _NO_PROTOTYPES */
#ifdef __cplusplus
};
#endif
#endif

16
core/dosio/dos_x.afn Normal file
View File

@ -0,0 +1,16 @@
# Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
#
# $Id: dos_x.afn 1.1 1997/12/10 16:40:59 jon Exp $
# $Locker: $
#
# List of functions that need per compiler C<-> ASM glue
#
DOSClockBegin
DOSClockEnd
DOSClockRead
DOSDivTrapBegin
DOSDivTrapEnd
DOSDivTrapCount

40
core/dosio/dosio.h Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: dosio.h 1.1 1997/12/10 16:40:59 jon Exp $
* $Locker: $
*
* Definitions for DOS I/O library
*/
#ifndef _DOSIO_H_
#define _DOSIO_H_
/*
* DosClockRead Ticks per second
*/
#define BR_DOS_CLOCK_RATE 1192755L
/*
* Mouse button mask
*/
#define BR_MSM_BUTTONL 1
#define BR_MSM_BUTTONR 2
#define BR_MSM_BUTTONM 4
#ifndef EVENTQ_H_
#include "eventq.h"
#endif
#ifndef _KEYBOARD_H_
#include "keyboard.h"
#endif
#ifndef _DOS_P_H_
#include "dos_p.h"
#endif
#ifndef _DOS_X_H_
#include "dos_x.h"
#endif
#endif

22
core/dosio/dossetup.c Normal file
View File

@ -0,0 +1,22 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: dossetup.c 1.1 1997/12/10 16:40:59 jon Exp $
* $Locker: $
*
* Setup for DOSIO (registers DLLs for drivers)
*/
#include "brender.h"
#include "dosio.h"
BR_RCS_ID("$Id: dossetup.c 1.1 1997/12/10 16:40:59 jon Exp $")
br_error BR_PUBLIC_ENTRY DOSBegin(void)
{
return BRE_OK;
}
void BR_PUBLIC_ENTRY DOSEnd(void)
{
}

113
core/dosio/eventq.c Normal file
View File

@ -0,0 +1,113 @@
/*
* Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: eventq.c 1.1 1997/12/10 16:40:59 jon Exp $
* $Locker: $
*
* Event queue for mouse and keyboard events - events can be added to queue
* from both real-mode and protected mode
*/
#include <stddef.h>
#include "brender.h"
#include "host.h"
#include "dosio.h"
BR_RCS_ID("$Id: eventq.c 1.1 1997/12/10 16:40:59 jon Exp $")
#define MAX_EVENTS 50
host_real_memory _DOSEventMemory;
int _DOSEventQEnabled = 0;
br_error BR_PUBLIC_ENTRY DOSEventBegin(void)
{
host_info hi;
int s = sizeof(dosio_event_queue) + sizeof(dosio_event) * MAX_EVENTS;
if(_DOSEventQEnabled)
return BRE_ALLREADY_ACTIVE;
/*
* Make sure host is up to it
*/
HostInfo(&hi,sizeof(hi));
if(!(hi.capabilities & HOST_CAPS_REAL_MEMORY))
return BRE_FAIL;
/*
* Put event queue in a real mode buffer
*/
if(HostRealAllocate(&_DOSEventMemory, s))
return BRE_NO_MEMORY;
HostFarBlockFill(_DOSEventMemory.pm_off, _DOSEventMemory.pm_seg, 0, s);
HostFarWordWrite(_DOSEventMemory.pm_off + offsetof(dosio_event_queue,total), _DOSEventMemory.pm_seg, MAX_EVENTS);
_DOSEventQEnabled = 1;
return BRE_OK;
}
void BR_PUBLIC_ENTRY DOSEventEnd(void)
{
if(_DOSEventQEnabled == 0)
return;
/*
* Free up event queue
*/
_DOSEventQEnabled = 0;
HostRealFree(&_DOSEventMemory);
}
#define EVENTQ_GET(field)\
HostFarWordRead(_DOSEventMemory.pm_off + offsetof(dosio_event_queue,field), _DOSEventMemory.pm_seg)
#define EVENTQ_SET(field,value)\
HostFarWordWrite(_DOSEventMemory.pm_off + offsetof(dosio_event_queue,field), _DOSEventMemory.pm_seg,(br_uint_16)(value))
br_boolean BR_PUBLIC_ENTRY DOSEventWait(dosio_event *event, br_boolean block)
{
int t;
if(_DOSEventQEnabled == 0)
return BR_FALSE;
if(block) {
/*
* Busy wait on an incoming event
*/
while(EVENTQ_GET(head) == EVENTQ_GET(tail))
;
} else {
if(EVENTQ_GET(head) == EVENTQ_GET(tail))
return BR_FALSE;
}
t = EVENTQ_GET(tail);
/*
* Hostract event from queue
*/
HostFarBlockRead(
_DOSEventMemory.pm_off + offsetof(dosio_event_queue,slots) +
sizeof(*event) * t,
_DOSEventMemory.pm_seg,
(unsigned char *)event,
sizeof(*event));
/*
* Bump tail pointer over event
*/
t += 1;
if( t >= EVENTQ_GET(total))
t = 0;
EVENTQ_SET(tail, t);
EVENTQ_SET(count, EVENTQ_GET(count)-1);
return BR_TRUE;
}

83
core/dosio/eventq.h Normal file
View File

@ -0,0 +1,83 @@
/*
* Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: eventq.h 1.1 1997/12/10 16:40:59 jon Exp $
* $Locker: $
*
* Event queue for mouse and keyboard events - events can be added to queue
* from both real-mode and protected mode
*
* NB: the structures and equates in eventq.inc must match
*/
#ifndef _EVENTQ_H_
#define _EVENTQ_H_
typedef struct dosio_event {
br_uint_16 type;
br_uint_16 qualifiers;
br_uint_32 value_1;
br_uint_32 value_2;
} dosio_event;
/*
* Event types - matches those in brwap.h
*/
enum dosio_event_type {
DOSIO_EVENT_KEY_DOWN,
DOSIO_EVENT_KEY_UP,
/* value_1 == key code */
DOSIO_EVENT_POINTER1_DOWN,
DOSIO_EVENT_POINTER1_UP,
DOSIO_EVENT_POINTER2_DOWN,
DOSIO_EVENT_POINTER2_UP,
DOSIO_EVENT_POINTER3_DOWN,
DOSIO_EVENT_POINTER3_UP,
/* value_1 == x */
/* value_2 == y */
DOSIO_EVENT_POINTER_MOVE,
/* value_1 == x */
/* value_2 == y */
DOSIO_EVENT_MAX
};
enum dosio_event_qual {
DOSIO_QUAL_SHIFT = 1,
DOSIO_QUAL_CONTROL = 2,
DOSIO_QUAL_ALT = 4,
};
/*
* An event queue
*
*/
typedef struct dosio_event_queue {
/*
* Maximum number of events in buffer
*/
br_uint_16 total;
/*
* Number of events in queue
*/
br_uint_16 count;
/*
* Next free slot in which to add an event
*/
br_uint_16 head;
/*
* Next event slot to remove from queue
*/
br_uint_16 tail;
/*
* Array of event slots
*/
dosio_event slots[1];
} dosio_event_queue;
#endif

41
core/dosio/eventq.inc Normal file
View File

@ -0,0 +1,41 @@
;; Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
;;
;; $Id: eventq.inc 1.1 1997/12/10 16:40:59 jon Exp $
;; $Locker: $
;;
;; Structures and equates coresponding to eventq.h
;;
; Structure corresponding to dosio_event
;
event struc
etype word ?
qualifiers word ?
value_1 dword ?
value_2 dword ?
event ends
; Structure corresponding to dosio_event_queue
;
eventq struc
total word ?
count word ?
head word ?
tail word ?
slots word ?
eventq ends
DOSIO_QUAL_SHIFT equ 1
DOSIO_QUAL_CONTROL equ 2
DOSIO_QUAL_ALT equ 4
DOSIO_EVENT_KEY_DOWN equ 0
DOSIO_EVENT_KEY_UP equ 1
DOSIO_EVENT_POINTER1_DOWN equ 2
DOSIO_EVENT_POINTER1_UP equ 3
DOSIO_EVENT_POINTER2_DOWN equ 4
DOSIO_EVENT_POINTER2_UP equ 5
DOSIO_EVENT_POINTER3_DOWN equ 6
DOSIO_EVENT_POINTER3_UP equ 7
DOSIO_EVENT_POINTER_MOVE equ 8

211
core/dosio/kbdint.asm Normal file
View File

@ -0,0 +1,211 @@
;; Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
;;
;; $Id: kbdint.asm 1.1 1997/12/10 16:40:59 jon Exp $
;; $Locker: $
;;
;; Real mode interrupt handler that hooks INT15 and maintains a key matrix
;;
.386
_TEXT16 SEGMENT DWORD PUBLIC USE16 'CODE'
assume cs:_TEXT16
assume ds:_TEXT16
assume ss:_TEXT16
include scancode.inc
include eventq.inc
public _KeyboardHandler
public _KeyboardEnd
public _KeyboardOldSeg
public _KeyboardOldOff
public _KeyboardEventQSeg
public _KeyboardEventQOff
public _KeyboardEnableBIOS
public _KeyboardMap
JPRESSED MACRO scancode,label
test keyboard_map[scancode],QUAL_NONE
jnz label
ENDM
JNPRESSED MACRO scancode,label
test keyboard_map[scancode],QUAL_NONE
jz label
ENDM
_KeyboardHandler proc
; See if this is INT15, AH=4F
;
cmp ah,4fh
je hook_this
db 0eah
_KeyboardOldOff dw 0babeh
_KeyboardOldSeg dw 0deadh
; Got a keyboard interrupt
;
hook_this:
push eax
push ebx
push ecx
push edx
push edi
push ds
push es
mov bx,cs
mov ds,bx
mov bl,al
; If scancode is 0E0h (extended keycode), then set a flag and abort
;
cmp bl,0E0h
jne not_extended
mov extended_flag,080h
jmp done
not_extended:
; Put up/down state into ah
;
xor ah,ah
shl bl,1
cmc
rcl ah,1
shr bl,1
; Or Extended Bit into bl
; Remeber unextended keycode in cl
;
mov cl,bl
or bl,extended_flag
xor bh,bh
mov ds:extended_flag,bh
; Build up a qualifier mask
;
mov al,QUAL_NONE OR REPT_AUTO_REPT
JPRESSED <bx>,not_first
or al,REPT_FIRST_DOWN
not_first:
JNPRESSED <SC_LSHIFT>,no_lshift
or al,QUAL_SHIFT
no_lshift:
JNPRESSED <SC_RSHIFT>,no_rshift
or al,QUAL_SHIFT
no_rshift:
JNPRESSED <SC_CTRL>,no_lctrl
or al,QUAL_CTRL
no_lctrl:
JNPRESSED <SC_CTRL+SC_EXTENDED>,no_rctrl
or al,QUAL_CTRL
no_rctrl:
JNPRESSED <SC_ALT>,no_lalt
or al,QUAL_ALT
no_lalt:
JNPRESSED <SC_ALT+SC_EXTENDED>,no_ralt
or al,QUAL_ALT
no_ralt:
; ah contains 0 or 1, if 0 then QUAL_NONE bit of byte in key table is
; cleared and nothing else is done, otherwise QUAL_NONE bit is set,
; appropriate shift and repeat qualifiers are added and new the byte
; is stored in the keyboard table.
;
and ah,ah
jz key_up
mov keyboard_map[bx],al
movzx ecx,bx
mov bl,al
mov eax,DOSIO_EVENT_KEY_DOWN
jmp done_map
key_up: and keyboard_map[bx],NOT QUAL_NONE
movzx ecx,bx
mov bl,al
mov eax,DOSIO_EVENT_KEY_UP
done_map:
cmp _KeyboardEventQSeg,0
je done
; Generate an event - dosio qualifiers match scancode qualifiers (which match brwrap qualifiers)
;
and ebx,DOSIO_QUAL_SHIFT or DOSIO_QUAL_CONTROL or DOSIO_QUAL_ALT
xor edx,edx
les di,dword ptr _KeyboardEventQOff
call _EventAdd
done:
; See if things should not be sent to the BIOS
;
cmp _KeyboardEnableBIOS,0
jne to_bios
; Always pass some qualifiers throught to BIOS
;
and cl, not SC_EXTENDED
cmp cl,SC_ALT
je to_bios
cmp cl,SC_CTRL
je to_bios
cmp cl,SC_LSHIFT
je to_bios
cmp cl,SC_RSHIFT
je to_bios
cmp cl,SC_CAPSLOCK
je to_bios
cmp cl,SC_SCRLOCK
je to_bios
cmp cl,SC_NUMLOCK
je to_bios
; Clear carry on stack to mark key as consumed
;
mov bx,sp
and byte ptr ss:[bx+28],0feh
to_bios:
pop es
pop ds
pop edi
pop edx
pop ecx
pop ebx
pop eax
iret
_KeyboardHandler endp
; Include EventAdd() code
;
include rmeventq.inc
; Data
;
_KeyboardEventQOff dw 0
_KeyboardEventQSeg dw 0
; Flag , true if all keycodes are passed on to BIOS
;
_KeyboardEnableBIOS dw 0
_KeyboardMap label byte
keyboard_map db 256 dup(0)
extended_flag db 0
db 0
_KeyboardEnd db 0
_TEXT16 ends
end _KeyboardHandler

52
core/dosio/kbdint.hex Normal file
View File

@ -0,0 +1,52 @@
/*
* Generated by dumpc.pl
*/
/* 0000 */ 0x80,0xfc,0x4f,0x74,0x05,0xea,0xbe,0xba,0xad,0xde,0x66,0x50,0x66,0x53,0x66,0x51,
/* 0010 */ 0x66,0x52,0x66,0x57,0x1e,0x06,0x8c,0xcb,0x8e,0xdb,0x8a,0xd8,0x80,0xfb,0xe0,0x75,
/* 0020 */ 0x08,0xc6,0x06,0x44,0x02,0x80,0xe9,0x92,0x00,0x32,0xe4,0xd0,0xe3,0xf5,0xd0,0xd4,
/* 0030 */ 0xd0,0xeb,0x8a,0xcb,0x0a,0x1e,0x44,0x02,0x32,0xff,0x88,0x3e,0x44,0x02,0xb0,0x28,
/* 0040 */ 0xf6,0x87,0x44,0x01,0x08,0x75,0x02,0x0c,0x10,0xf6,0x06,0x6e,0x01,0x08,0x74,0x02,
/* 0050 */ 0x0c,0x01,0xf6,0x06,0x7a,0x01,0x08,0x74,0x02,0x0c,0x01,0xf6,0x06,0x61,0x01,0x08,
/* 0060 */ 0x74,0x02,0x0c,0x02,0xf6,0x06,0xe1,0x01,0x08,0x74,0x02,0x0c,0x02,0xf6,0x06,0x7c,
/* 0070 */ 0x01,0x08,0x74,0x02,0x0c,0x04,0xf6,0x06,0xfc,0x01,0x08,0x74,0x02,0x0c,0x04,0x22,
/* 0080 */ 0xe4,0x74,0x12,0x88,0x87,0x44,0x01,0x66,0x0f,0xb7,0xcb,0x8a,0xd8,0x66,0xb8,0x00,
/* 0090 */ 0x00,0x00,0x00,0xeb,0x11,0x80,0xa7,0x44,0x01,0xf7,0x66,0x0f,0xb7,0xcb,0x8a,0xd8,
/* 00a0 */ 0x66,0xb8,0x01,0x00,0x00,0x00,0x83,0x3e,0x40,0x01,0x00,0x74,0x0e,0x66,0x83,0xe3,
/* 00b0 */ 0x07,0x66,0x33,0xd2,0xc4,0x3e,0x3e,0x01,0xe8,0x41,0x00,0x83,0x3e,0x42,0x01,0x00,
/* 00c0 */ 0x75,0x2d,0x80,0xe1,0x7f,0x80,0xf9,0x38,0x74,0x25,0x80,0xf9,0x1d,0x74,0x20,0x80,
/* 00d0 */ 0xf9,0x2a,0x74,0x1b,0x80,0xf9,0x36,0x74,0x16,0x80,0xf9,0x3a,0x74,0x11,0x80,0xf9,
/* 00e0 */ 0x46,0x74,0x0c,0x80,0xf9,0x45,0x74,0x07,0x8b,0xdc,0x36,0x80,0x67,0x1c,0xfe,0x07,
/* 00f0 */ 0x1f,0x66,0x5f,0x66,0x5a,0x66,0x59,0x66,0x5b,0x66,0x58,0xcf,0x55,0x56,0x9c,0xfa,
/* 0100 */ 0x26,0x8b,0x6d,0x04,0x8b,0xf5,0x46,0x26,0x3b,0x35,0x72,0x02,0x33,0xf6,0x26,0x3b,
/* 0110 */ 0x75,0x06,0x74,0x26,0x66,0xc1,0xe3,0x10,0x8b,0xd8,0xc1,0xe5,0x02,0x8b,0xc5,0x03,
/* 0120 */ 0xed,0x03,0xe8,0x66,0x26,0x89,0x5b,0x08,0x66,0x26,0x89,0x4b,0x0c,0x66,0x26,0x89,
/* 0130 */ 0x53,0x10,0x26,0x89,0x75,0x04,0x26,0xff,0x45,0x02,0x9d,0x5e,0x5d,0xc3,0x00,0x00,
/* 0140 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 0150 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 0160 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 0170 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 0180 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 0190 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 01a0 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 01b0 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 01c0 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 01d0 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 01e0 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 01f0 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 0200 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 0210 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 0220 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 0230 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/* 0240 */ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*
* Generated by maptodef.pl
*/
#define SYM_EventAdd 0x00fc
#define SYM_KeyboardEnableBIOS 0x0142
#define SYM_KeyboardEnd 0x0246
#define SYM_KeyboardEventQOff 0x013e
#define SYM_KeyboardEventQSeg 0x0140
#define SYM_KeyboardHandler 0x0000
#define SYM_KeyboardMap 0x0144
#define SYM_KeyboardOldOff 0x0006
#define SYM_KeyboardOldSeg 0x0008

BIN
core/dosio/kbdint.obj Normal file
View File

Binary file not shown.

157
core/dosio/keyboard.c Normal file
View File

@ -0,0 +1,157 @@
/*
* Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: keyboard.c 1.2 1998/02/17 23:01:15 jon Exp $
* $Locker: $
*
* keyboard interrupt interface
*/
#include "brender.h"
#include "host.h"
#include "dosio.h"
BR_RCS_ID("$Id: keyboard.c 1.2 1998/02/17 23:01:15 jon Exp $")
/*
* Real mode interrupt handler for INT15
*/
static br_uint_8 keyboardHandler[] = {
#include "kbdint.hex"
};
static br_boolean keyboardActive = BR_FALSE;
static host_real_memory keyboardMemory;
static br_uint_16 keyboardOldOff;
static br_uint_16 keyboardOldSeg;
extern host_real_memory _DOSEventMemory;
extern br_boolean _DOSEventQEnabled;
/*
* Install a real mode interrupt handler on INT 15
*/
br_error BR_PUBLIC_ENTRY DOSKeyBegin(void)
{
host_info hi;
if(keyboardActive)
return BRE_ALLREADY_ACTIVE;
/*
* Make sure host is up to it
*/
HostInfo(&hi,sizeof(hi));
if(!((hi.capabilities & HOST_CAPS_REAL_MEMORY) &&
(hi.capabilities & HOST_CAPS_REAL_INT_HOOK) &&
(hi.capabilities & HOST_CAPS_REAL_INT_CALL)))
return BRE_FAIL;
/* Allocate a block of DOS memory for handler
*/
if(HostRealAllocate(&keyboardMemory, sizeof(keyboardHandler)))
return BRE_NO_MEMORY;
/*
* Copy real mode handler into block
*/
HostFarBlockWrite(keyboardMemory.pm_off, keyboardMemory.pm_seg, keyboardHandler, sizeof(keyboardHandler));
/*
* Get old real mode vector
*/
HostRealInterruptGet(0x15,&keyboardOldOff,&keyboardOldSeg);
/*
* Put chain address in realmode code
*/
HostFarWordWrite(SYM_KeyboardOldOff+keyboardMemory.pm_off, keyboardMemory.pm_seg, keyboardOldOff);
HostFarWordWrite(SYM_KeyboardOldSeg+keyboardMemory.pm_off, keyboardMemory.pm_seg, keyboardOldSeg);
/*
* If the event queue is initialised, then hook that
* into handler
*/
if(_DOSEventQEnabled) {
HostFarWordWrite(SYM_KeyboardEventQOff+keyboardMemory.pm_off, keyboardMemory.pm_seg, _DOSEventMemory.rm_off);
HostFarWordWrite(SYM_KeyboardEventQSeg+keyboardMemory.pm_off, keyboardMemory.pm_seg, _DOSEventMemory.rm_seg);
}
/* Set new real mode vector
*/
if(HostRealInterruptSet(0x15,(br_uint_16)(keyboardMemory.rm_off+SYM_KeyboardHandler),keyboardMemory.rm_seg)) {
HostRealFree(&keyboardMemory);
return BRE_FAIL;
}
keyboardActive = BR_TRUE;
return BRE_OK;
}
/*
* Clear down the custom keyboard handler
*/
void BR_PUBLIC_ENTRY DOSKeyEnd(void)
{
if(!keyboardActive)
return;
/* Set new real mode vector
*/
HostRealInterruptSet(0x15,keyboardOldOff,keyboardOldSeg);
/*
* Release memeory block
*/
HostRealFree(&keyboardMemory);
keyboardActive = BR_FALSE;
}
/*
* Enable or diable BIOS keystrokes, if enabled, then the
* keyboard handler passes all scancode on to the BIOS
*/
br_error BR_PUBLIC_ENTRY DOSKeyEnableBIOS(br_boolean flag)
{
if(!keyboardActive)
return BRE_NOT_ACTIVE;
HostFarWordWrite(SYM_KeyboardEnableBIOS+keyboardMemory.pm_off, keyboardMemory.pm_seg, (br_uint_16)(flag != 0));
return BRE_OK;
}
/*
* Test if a key on keyboard is depressed
*/
br_boolean BR_PUBLIC_ENTRY DOSKeyTest(br_uint_8 scancode,br_uint_8 qualifiers, br_uint_8 repeats)
{
br_uint_8 r;
br_uint_8 m;
m = HostFarByteRead(scancode + SYM_KeyboardMap + keyboardMemory.pm_off,keyboardMemory.pm_seg);
if(qualifiers == 0)
r = (m & (QUAL_NONE | repeats)) == (QUAL_NONE | repeats);
else
r = (m & (QUAL_ALL | repeats)) == (QUAL_NONE | qualifiers | repeats);
if (r) {
m &= ~repeats;
HostFarByteWrite(scancode + SYM_KeyboardMap + keyboardMemory.pm_off,keyboardMemory.pm_seg,m);
}
return r;
}
br_uint_8 BR_PUBLIC_ENTRY DOSKeyMap(br_uint_8 scancode)
{
return HostFarByteRead(scancode + SYM_KeyboardMap + keyboardMemory.pm_off,keyboardMemory.pm_seg);
}

124
core/dosio/keyboard.h Normal file
View File

@ -0,0 +1,124 @@
/*
* Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: keyboard.h 1.1 1997/12/10 16:41:00 jon Exp $
* $Locker: $
*
* Keyboard driver definitions and scancodes
*/
#ifndef _KEYBOARD_H_
#define _KEYBOARD_H_
#define SC_ESC 0x01
#define SC_1 0x02
#define SC_2 0x03
#define SC_3 0x04
#define SC_4 0x05
#define SC_5 0x06
#define SC_6 0x07
#define SC_7 0x08
#define SC_8 0x09
#define SC_9 0x0a
#define SC_0 0x0b
#define SC_MINUS 0x0c
#define SC_EQUALS 0x0d
#define SC_BACKSPACE 0x0e
#define SC_TAB 0x0f
#define SC_Q 0x10
#define SC_W 0x11
#define SC_E 0x12
#define SC_R 0x13
#define SC_T 0x14
#define SC_Y 0x15
#define SC_U 0x16
#define SC_I 0x17
#define SC_O 0x18
#define SC_P 0x19
#define SC_LSQUARE 0x1a
#define SC_RSQUARE 0x1b
#define SC_ENTER 0x1c
#define SC_CTRL 0x1d
#define SC_A 0x1e
#define SC_S 0x1f
#define SC_D 0x20
#define SC_F 0x21
#define SC_G 0x22
#define SC_H 0x23
#define SC_J 0x24
#define SC_K 0x25
#define SC_L 0x26
#define SC_SEMI 0x27
#define SC_QUOTE 0x28
#define SC_BACKQUOTE 0x29
#define SC_LSHIFT 0x2a
#define SC_BACKSLASH 0x2b
#define SC_Z 0x2c
#define SC_X 0x2d
#define SC_C 0x2e
#define SC_V 0x2f
#define SC_B 0x30
#define SC_N 0x31
#define SC_M 0x32
#define SC_COMMA 0x33
#define SC_DOT 0x34
#define SC_SLASH 0x35
#define SC_RSHIFT 0x36
#define SC_KP_ASTERISK 0x37
#define SC_ALT 0x38
#define SC_SPACE 0x39
#define SC_CAPSLOCK 0x3a
#define SC_F1 0x3b
#define SC_F2 0x3c
#define SC_F3 0x3d
#define SC_F4 0x3e
#define SC_F5 0x3f
#define SC_F6 0x40
#define SC_F7 0x41
#define SC_F8 0x42
#define SC_F9 0x43
#define SC_F10 0x44
#define SC_NUMLOCK 0x45
#define SC_SCRLOCK 0x45
#define SC_HOME 0x47
#define SC_C_UP 0x48
#define SC_PG_UP 0x49
#define SC_KP_MINUS 0x4a
#define SC_C_LEFT 0x4b
#define SC_KP_5 0x4c
#define SC_C_RIGHT 0x4d
#define SC_KP_PLUS 0x4e
#define SC_END 0x4f
#define SC_C_DOWN 0x50
#define SC_PG_DOWN 0x51
#define SC_INSERT 0x52
#define SC_DELETE 0x53
#define SC_EXTENDED 0x80
/*
* Shift qualifiers:
* specifiy the appropriate combination to detect only the shifted key,
* specify QUAL_NONE to detected only the unshifted key,
* specify no shift qualifiers to detected the key in any shift state.
*/
#define QUAL_SHIFT 0x01
#define QUAL_CTRL 0x02
#define QUAL_ALT 0x04
#define QUAL_NONE 0x08
#define QUAL_ALL 0x0f
/*
* Repeat control qualifiers:
* specify REPT_FIRST_DOWN to detect the key once for each downstroke,
* specify REPT_AUTO_REPT to detect the key once for each downstroke and once
* more for each subsequent keyboard auto-repeat,
* specify no repeat qualifiers to detect the key continuously while it is
* held down.
*/
#define REPT_FIRST_DOWN 0x10
#define REPT_AUTO_REPT 0x20
#endif

40
core/dosio/makefile Normal file
View File

@ -0,0 +1,40 @@
# Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
#
# $Id: makefile 1.1 1997/12/10 17:16:26 jon Exp $
# $Locker: $
#
# Makefile for BRender DOS IO support libary
#
#
.IMPORT: BR_SOURCE_DIR BR_MAKEFILE BR_TARGET_DIR BR_MAKE_DIR
.IMPORT .IGNORE: BR_EXTENDER
BR_BASE_TYPE=NONE
TARGET_TYPE:=LIB
CFLAGS+=-D__BR_V1DB__=0
LIB_PART:=dosio
TARGET_TYPE:=LIB
## Base library object files
##
OBJS_C=\
$(BLD_DIR)/divtrap$(OBJ_EXT)\
$(BLD_DIR)/dossetup$(OBJ_EXT)\
$(BLD_DIR)/eventq$(OBJ_EXT)\
$(BLD_DIR)/keyboard$(OBJ_EXT)\
$(BLD_DIR)/readmse$(OBJ_EXT)\
OBJS_ASM=\
$(BLD_DIR)/clock$(OBJ_EXT)\
$(BLD_DIR)/divtraph$(OBJ_EXT)\
EXPORT_INCLUDES=\
$(INC_DIR)/dosio.h\
$(INC_DIR)/eventq.h\
$(INC_DIR)/keyboard.h\
$(INC_DIR)/dos_x.h\
$(INC_DIR)/dos_p.h\
.INCLUDE: $(BR_MAKE_DIR)/$(BR_MAKEFILE)

151
core/dosio/mouint.asm Normal file
View File

@ -0,0 +1,151 @@
;; Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
;;
;; $Id: mouint.asm 1.1 1997/12/10 16:41:00 jon Exp $
;; $Locker: $
;;
;; Real mode interrupt handler for mouse events
;;
.386
include eventq.inc
_TEXT16 SEGMENT DWORD PUBLIC USE16 'CODE'
assume cs:_TEXT16
assume ds:_TEXT16
assume ss:_TEXT16
public _MouseHandler
public _MouseEnd
public _MouseEventQSeg
public _MouseEventQOff
; Mask values for interrupt handler
;
MASK_MOVE equ 1
MASK_L_DOWN equ 2
MASK_L_UP equ 4
MASK_R_DOWN equ 8
MASK_R_UP equ 16
MASK_M_DOWN equ 32
MASK_M_UP equ 64
; _MouseHandler - attached to mouse events
;
; Called with -
;
; AX: event mask
; BX: Buttons
; CX: X
; DX: Y
; SI: Raw X
; DI: Raw Y
;
_MouseHandler proc far
push eax
push ebx
push ecx
push edx
push si
push di
push ds
push es
; Set up DS
;
push cs
pop ds
; Remember state
;
mov _MouseButtons,bx
mov _MouseX,si
mov _MouseY,di
; Generate an event for each bit set in the mask
;
movsx ecx,si
movsx edx,di
xor ebx,ebx
mov si,ax
cmp _MouseEventQSeg,0
je done
les di,dword ptr _MouseEventQOff
test si,MASK_L_DOWN
je no_l_down
mov eax,DOSIO_EVENT_POINTER1_DOWN
call _EventAdd
no_l_down: test si,MASK_L_UP
je no_l_up
mov eax,DOSIO_EVENT_POINTER1_UP
call _EventAdd
no_l_up:
test si,MASK_M_DOWN
je no_m_down
mov eax,DOSIO_EVENT_POINTER2_DOWN
call _EventAdd
no_m_down: test si,MASK_M_UP
je no_m_up
mov eax,DOSIO_EVENT_POINTER2_UP
call _EventAdd
no_m_up:
test si,MASK_R_DOWN
je no_r_down
mov eax,DOSIO_EVENT_POINTER3_DOWN
call _EventAdd
no_r_down: test si,MASK_R_UP
je no_r_up
mov eax,DOSIO_EVENT_POINTER3_UP
call _EventAdd
no_r_up:
test si,MASK_MOVE
je no_move
mov eax,DOSIO_EVENT_POINTER_MOVE
call _EventAdd
no_move:
done:
pop es
pop ds
pop di
pop si
pop edx
pop ecx
pop ebx
pop eax
retf
_MouseHandler endp
; Include EventAdd() code
;
include rmeventq.inc
; Data
;
public _MouseEventQOff
public _MouseEventQSeg
public _MouseX
public _MouseY
public _MouseButtons
_MouseEventQOff dw 0
_MouseEventQSeg dw 0
_MouseX dw 0
_MouseY dw 0
_MouseButtons dw 0
_MouseEnd db 0
_TEXT16 ends
end

30
core/dosio/mouint.hex Normal file
View File

@ -0,0 +1,30 @@
/*
* Generated by dumpc.pl
*/
/* 0000 */ 0x66,0x50,0x66,0x53,0x66,0x51,0x66,0x52,0x56,0x57,0x1e,0x06,0x0e,0x1f,0x89,0x1e,
/* 0010 */ 0xf2,0x00,0x89,0x36,0xee,0x00,0x89,0x3e,0xf0,0x00,0x66,0x0f,0xbf,0xce,0x66,0x0f,
/* 0020 */ 0xbf,0xd7,0x66,0x33,0xdb,0x8b,0xf0,0x83,0x3e,0xec,0x00,0x00,0x74,0x6d,0xc4,0x3e,
/* 0030 */ 0xea,0x00,0xf7,0xc6,0x02,0x00,0x74,0x09,0x66,0xb8,0x02,0x00,0x00,0x00,0xe8,0x67,
/* 0040 */ 0x00,0xf7,0xc6,0x04,0x00,0x74,0x09,0x66,0xb8,0x03,0x00,0x00,0x00,0xe8,0x58,0x00,
/* 0050 */ 0xf7,0xc6,0x20,0x00,0x74,0x09,0x66,0xb8,0x04,0x00,0x00,0x00,0xe8,0x49,0x00,0xf7,
/* 0060 */ 0xc6,0x40,0x00,0x74,0x09,0x66,0xb8,0x05,0x00,0x00,0x00,0xe8,0x3a,0x00,0xf7,0xc6,
/* 0070 */ 0x08,0x00,0x74,0x09,0x66,0xb8,0x06,0x00,0x00,0x00,0xe8,0x2b,0x00,0xf7,0xc6,0x10,
/* 0080 */ 0x00,0x74,0x09,0x66,0xb8,0x07,0x00,0x00,0x00,0xe8,0x1c,0x00,0xf7,0xc6,0x01,0x00,
/* 0090 */ 0x74,0x09,0x66,0xb8,0x08,0x00,0x00,0x00,0xe8,0x0d,0x00,0x07,0x1f,0x5f,0x5e,0x66,
/* 00a0 */ 0x5a,0x66,0x59,0x66,0x5b,0x66,0x58,0xcb,0x55,0x56,0x9c,0xfa,0x26,0x8b,0x6d,0x04,
/* 00b0 */ 0x8b,0xf5,0x46,0x26,0x3b,0x35,0x72,0x02,0x33,0xf6,0x26,0x3b,0x75,0x06,0x74,0x26,
/* 00c0 */ 0x66,0xc1,0xe3,0x10,0x8b,0xd8,0xc1,0xe5,0x02,0x8b,0xc5,0x03,0xed,0x03,0xe8,0x66,
/* 00d0 */ 0x26,0x89,0x5b,0x08,0x66,0x26,0x89,0x4b,0x0c,0x66,0x26,0x89,0x53,0x10,0x26,0x89,
/* 00e0 */ 0x75,0x04,0x26,0xff,0x45,0x02,0x9d,0x5e,0x5d,0xc3,0x00,0x00,0x00,0x00,0x00,0x00,
/* 00f0 */ 0x00,0x00,0x00,0x00,0x00,
/*
* Generated by maptodef.pl
*/
#define SYM_EventAdd 0x00a8
#define SYM_MouseButtons 0x00f2
#define SYM_MouseEnd 0x00f4
#define SYM_MouseEventQOff 0x00ea
#define SYM_MouseEventQSeg 0x00ec
#define SYM_MouseHandler 0x0000
#define SYM_MouseX 0x00ee
#define SYM_MouseY 0x00f0

BIN
core/dosio/mouint.obj Normal file
View File

Binary file not shown.

146
core/dosio/readmse.c Normal file
View File

@ -0,0 +1,146 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: readmse.c 1.2 1998/07/13 21:49:54 jon Exp $
* $Locker: $
*
* Read mouse position from BIOS
*/
#include "brender.h"
#include "host.h"
#include "dosio.h"
BR_RCS_ID("$Id: readmse.c 1.2 1998/07/13 21:49:54 jon Exp $")
/*
* Real mode interrupt handler for mouse
*/
static unsigned char mouseHandler[] = {
#include "mouint.hex"
};
static br_boolean mouseActive = BR_FALSE;
static host_real_memory mouseMemory;
extern host_real_memory _DOSEventMemory;
extern int _DOSEventQEnabled;
static host_regs regs;
static br_int_16 ox, oy;
br_error BR_PUBLIC_ENTRY DOSMouseBegin(void)
{
host_info hi;
if(mouseActive)
return BRE_ALLREADY_ACTIVE;
/*
* Make sure host is up to it
*/
HostInfo(&hi,sizeof(hi));
if(!((hi.capabilities & HOST_CAPS_REAL_MEMORY) &&
(hi.capabilities & HOST_CAPS_REAL_INT_CALL)))
return BRE_FAIL;
/* Allocate a block of DOS memory for handler
*/
if(HostRealAllocate(&mouseMemory, sizeof(mouseHandler)))
return BRE_NO_MEMORY;
/*
* Copy real mode handler into block
*/
HostFarBlockWrite(mouseMemory.pm_off, mouseMemory.pm_seg, mouseHandler, sizeof(mouseHandler));
/*
* If the event queue is initialised, then hook that into handler
*/
if(_DOSEventQEnabled) {
HostFarWordWrite(SYM_MouseEventQOff+mouseMemory.pm_off, mouseMemory.pm_seg, _DOSEventMemory.rm_off);
HostFarWordWrite(SYM_MouseEventQSeg+mouseMemory.pm_off, mouseMemory.pm_seg, _DOSEventMemory.rm_seg);
}
/*
* Reset mouse driver
*/
regs.w.ax = 0;
HostRealInterruptCall(0x33,&regs);
/*
* Check mouse is installed
*/
if (regs.w.ax != 0xffff)
return BRE_FAIL;
/*
* Set real-mode handler
*/
regs.w.ax = 0x0C;
regs.w.cx = 0x7F;
regs.w.dx = mouseMemory.rm_off;
regs.w.es = mouseMemory.rm_seg;
HostRealInterruptCall(0x33,&regs);
/*
* Read initial mouse status
*/
regs.w.ax = 0x03;
HostRealInterruptCall(0x33,&regs);
ox = regs.w.cx;
oy = regs.w.dx;
HostFarWordWrite(SYM_MouseX+mouseMemory.pm_off, mouseMemory.pm_seg, ox);
HostFarWordWrite(SYM_MouseY+mouseMemory.pm_off, mouseMemory.pm_seg, oy);
HostFarWordWrite(SYM_MouseButtons+mouseMemory.pm_off, mouseMemory.pm_seg, 0);
mouseActive = BR_TRUE;
return BRE_OK;
}
void BR_PUBLIC_ENTRY DOSMouseEnd(void)
{
if(!mouseActive)
return;
/*
* Reset mouse driver
*/
regs.w.ax = 0;
HostRealInterruptCall(0x33,&regs);
/*
* Free handler
*/
HostRealFree(&mouseMemory);
mouseActive = BR_FALSE;
}
br_error BR_PUBLIC_ENTRY DOSMouseRead(br_int_32 *mouse_x,br_int_32 *mouse_y,br_uint_32 *mouse_buttons)
{
br_int_16 mx,my;
if(!mouseActive)
return BRE_NOT_ACTIVE;
mx = HostFarWordRead(SYM_MouseX+mouseMemory.pm_off, mouseMemory.pm_seg);
my = HostFarWordRead(SYM_MouseY+mouseMemory.pm_off, mouseMemory.pm_seg);
*mouse_buttons = HostFarWordRead(SYM_MouseButtons+mouseMemory.pm_off, mouseMemory.pm_seg);
*mouse_x += mx - ox;
*mouse_y += my - oy;
ox = mx;
oy = my;
return BRE_OK;
}

86
core/dosio/rmeventq.asm Normal file
View File

@ -0,0 +1,86 @@
;; Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
;;
;; $Id: rmeventq.asm 1.1 1997/12/10 16:41:00 jon Exp $
;; $Locker: $
;;
;; Real mode code for adding events to queue
;;
.386
include eventq.inc
_TEXT16 SEGMENT DWORD PUBLIC USE16 'CODE'
assume cs:_TEXT16
assume ds:_TEXT16
assume ss:_TEXT16
public _EventAdd
; _EventAdd - Add a new event to queue
;
; es:di - ptr to event queue structure
;
; ax = type
; bx = qualifier
; ecx = value1
; edx = value2
;
_EventAdd proc near
push bp
push si
; Make sure interrupts are disabled for this process
;
pushf
cli
; Fetch head pointer
;
mov bp,es:[di].eventq.head
; Move head pointer on around buffer
;
mov si,bp
inc si
cmp si,es:[di].eventq.total
jb no_wrap
xor si,si
no_wrap:
; Check we have not collided with tail
;
cmp si,es:[di].eventq.tail
je no_space
; Store event at head point
;
sal ebx,16
mov bx,ax
sal bp,2
mov ax,bp
add bp,bp
add bp,ax
mov dword ptr es:[di+bp+eventq.slots+event.etype],ebx
mov es:[di+bp].eventq.slots+event.value_1,ecx
mov es:[di+bp].eventq.slots+event.value_2,edx
; Save new head ptr
;
mov es:[di].eventq.head,si
; Keep track of number of outstanding events
;
inc es:[di].eventq.count
no_space: popf
pop si
pop bp
ret
_EventAdd endp
_TEXT16 ends
end

74
core/dosio/rmeventq.inc Normal file
View File

@ -0,0 +1,74 @@
;; Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
;;
;; $Id: rmeventq.inc 1.1 1997/12/10 16:41:00 jon Exp $
;; $Locker: $
;;
;; Real mode code for adding events to queue
;;
; _EventAdd - Add a new event to queue
;
; es:di - ptr to event queue structure
;
; ax = type
; bx = qualifier
; ecx = value1
; edx = value2
;
_EventAdd proc near
push bp
push si
; Make sure interrupts are disabled for this process
;
pushf
cli
; Fetch head pointer
;
mov bp,es:[di].eventq.head
; Move head pointer on around buffer
;
mov si,bp
inc si
cmp si,es:[di].eventq.total
jb no_wrap
xor si,si
no_wrap:
; Check we have not collided with tail
;
cmp si,es:[di].eventq.tail
je no_space
; Store event at head point
;
sal ebx,16
mov bx,ax
sal bp,2
mov ax,bp
add bp,bp
add bp,ax
mov dword ptr es:[di+bp+eventq.slots+event.etype],ebx
mov es:[di+bp].eventq.slots+event.value_1,ecx
mov es:[di+bp].eventq.slots+event.value_2,edx
; Save new head ptr
;
mov es:[di].eventq.head,si
; Keep track of number of outstanding events
;
inc es:[di].eventq.count
no_space: popf
pop si
pop bp
ret
_EventAdd endp

119
core/dosio/scancode.inc Normal file
View File

@ -0,0 +1,119 @@
;;
;; Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
;;
;; $Id: scancode.inc 1.1 1997/12/10 16:41:00 jon Exp $
;; $Locker: $
;;
;;
; Scancodes for IBM keyboard
;
SC_ESC equ 01h
SC_1 equ 02h
SC_2 equ 03h
SC_3 equ 04h
SC_4 equ 05h
SC_5 equ 06h
SC_6 equ 07h
SC_7 equ 08h
SC_8 equ 09h
SC_9 equ 0ah
SC_0 equ 0bh
SC_MINUS equ 0ch
SC_EQUALS equ 0dh
SC_BACKSPACE equ 0eh
SC_TAB equ 0fh
SC_Q equ 10h
SC_W equ 11h
SC_E equ 12h
SC_R equ 13h
SC_T equ 14h
SC_Y equ 15h
SC_U equ 16h
SC_I equ 17h
SC_O equ 18h
SC_P equ 19h
SC_LSQUARE equ 1ah
SC_RSQUARE equ 1bh
SC_ENTER equ 1ch
SC_CTRL equ 1dh
SC_A equ 1eh
SC_S equ 1fh
SC_D equ 20h
SC_F equ 21h
SC_G equ 22h
SC_H equ 23h
SC_J equ 24h
SC_K equ 25h
SC_L equ 26h
SC_SEMI equ 27h
SC_QUOTE equ 28h
SC_BACKQUOTE equ 29h
SC_LSHIFT equ 2ah
SC_BACKSLASH equ 2bh
SC_Z equ 2ch
SC_X equ 2dh
SC_C equ 2eh
SC_V equ 2fh
SC_B equ 30h
SC_N equ 31h
SC_M equ 32h
SC_COMMA equ 33h
SC_DOT equ 34h
SC_SLASH equ 35h
SC_RSHIFT equ 36h
SC_KP_ASTERISK equ 37h
SC_ALT equ 38h
SC_SPACE equ 39h
SC_CAPSLOCK equ 3ah
SC_F1 equ 3bh
SC_F2 equ 3ch
SC_F3 equ 3dh
SC_F4 equ 3eh
SC_F5 equ 3fh
SC_F6 equ 40h
SC_F7 equ 41h
SC_F8 equ 42h
SC_F9 equ 43h
SC_F10 equ 44h
SC_NUMLOCK equ 45h
SC_SCRLOCK equ 46h
SC_HOME equ 47h
SC_C_UP equ 48h
SC_PG_UP equ 49h
SC_KP_MINUS equ 4ah
SC_C_LEFT equ 4bh
SC_KP_5 equ 4ch
SC_C_RIGHT equ 4dh
SC_KP_PLUS equ 4eh
SC_END equ 4fh
SC_C_DOWN equ 50h
SC_PG_DOWN equ 51h
SC_INSERT equ 52h
SC_DELETE equ 53h
SC_EXTENDED equ 80h
; Shift qualifiers:
; specifiy the appropriate combination to detect only the shifted key,
; specify QUAL_NONE to detected only the unshifted key,
; specify no shift qualifiers to detected the key in any shift state.
;
QUAL_SHIFT equ 01h
QUAL_CTRL equ 02h
QUAL_ALT equ 04h
QUAL_NONE equ 08h
QUAL_ALL equ 0fh
; Repeat control qualifiers:
; specify QUAL_FIRST_DOWN to detect the key once for each downstroke,
; specify QUAL_AUTO_REPT to detect the key once for each downstroke and once
; more for each subsequent keyboard auto-repeat,
; specify no repeat qualifiers to detect the key continuously while it is
; held down.
;
REPT_FIRST_DOWN equ 10h
REPT_AUTO_REPT equ 20h

159
core/fmt/fmt.h Normal file
View File

@ -0,0 +1,159 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: fmt.h 1.2 1998/07/28 14:33:10 jon Exp $
* $Locker: $
*
* Definitions for foreign file format support
*/
#ifndef _FMT_H_
#define _FMT_H_
/*
* Structure for passing results back from foreign format loaders
*/
typedef struct br_fmt_results {
/*
* Pointers to tables of pointers to converted items
*/
br_actor **actors;
br_model **models;
br_light **lights;
br_camera **cameras;
br_vector4 **clip_planes;
br_bounds3 **bounds;
br_bounds3 **bounds_correct;
br_material **materials;
br_pixelmap **pixelmaps;
/*
* Size of each array
*/
br_uint_32 nactors;
br_uint_32 nmodels;
br_uint_32 nlights;
br_uint_32 ncameras;
br_uint_32 nclip_planes;
br_uint_32 nbounds;
br_uint_32 nbounds_correct;
br_uint_32 nmaterials;
br_uint_32 npixelmaps;
} br_fmt_results;
/*
* General options structure passed to all foreign format loaders
*/
typedef struct br_fmt_options {
/*
* Flags determining which items to convert
*/
br_uint_32 convert_flags;
} br_fmt_options;
/*
* Type of items to convert
*/
enum {
BR_FMT_ACTORS = 0x0001,
BR_FMT_MODELS = 0x0002,
BR_FMT_LIGHTS = 0x0004,
BR_FMT_CAMERAS = 0x0008,
BR_FMT_CLIP_PLANES = 0x0010,
BR_FMT_BOUNDS = 0x0020,
BR_FMT_BOUNDS_CORRECT = 0x0040,
BR_FMT_MATERIALS = 0x0080,
BR_FMT_PIXELMAPS = 0x0100,
BR_FMT_CONVERT_ALL = 0x7fff
};
/*
* Type definition for a message reporting callback
*/
typedef void BR_CALLBACK br_fmt_report_cbfn(char *string);
/*
* Options structure passed to 3DS format loader
*/
typedef struct br_3ds_options {
/*
* Conversion flags
*/
br_uint_32 flags;
/*
* Camera hither and yon values
*/
br_scalar hither;
br_scalar yon;
/*
* Scaling applied to models and hierarchy
*/
br_scalar scale;
/*
* Optional function pointer for reporting conversion messages
*/
br_fmt_report_cbfn *report;
} br_3ds_options;
/*
* 3DS conversion flags
*/
enum {
BR_3DS_FLAT_HIERARCHY = 0x00000001,
BR_3DS_SET_PERSPECTIVE = 0x00000002,
BR_3DS_CORRECT_AXES = 0x00000004,
BR_3DS_APPLY_MESH_MATRIX = 0x00000008,
BR_3DS_APPLY_PIVOT = 0x00000010,
BR_3DS_DUMMY_LIGHTS = 0x00000020,
BR_3DS_DUMMY_CAMERAS = 0x00000040,
BR_3DS_SET_HITHER = 0x00000080,
BR_3DS_SET_YON = 0x00000100,
BR_3DS_APPLY_SCALE = 0x00000200,
BR_3DS_KEEP_REPEATED_MODELS = 0x00000400,
BR_3DS_USE_MODEL_PIVOT = 0x00000800,
};
/*
* VUE format structures
*/
// Pointer to actor plus desired transform matrix.
struct vue_transform {
br_actor *actor; // slot for actor to be moved by vue
br_matrix34 mat; // by this matrix
};
// All desired actor transforms required for a single frame.
struct vue_frame {
struct vue_transform *transforms;//actor/transforms
int ntransforms; // number of transforms for that frame
};
typedef struct br_vue{
int nframes;
int ntransforms;
int frame_delta; // default=1
int current_frame; // initialised to zero
struct vue_frame *frames;
} br_vue;
#ifndef _FMT_P_H_
#include "fmt_p.h"
#endif
#endif

72
core/fmt/fmt_p.h Normal file
View File

@ -0,0 +1,72 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: fmt_p.h 1.1 1997/12/10 16:41:00 jon Exp $
* $Locker: $
*
* Function prototypes for foreign file format support
*/
#ifndef _FMT_P_H_
#define _FMT_P_H_
#ifdef __cplusplus
extern "C" {
#endif
/*
* 3D Studio .3DS files
*/
br_fmt_results * BR_PUBLIC_ENTRY BrFmt3DSLoad(char *name, br_fmt_options *fmt_options, br_3ds_options *options);
/*
* 3D Studio .ASC files
*/
br_uint_32 BR_PUBLIC_ENTRY BrFmtASCLoad(char *name, br_model **mtable, br_uint_16 max_models);
/*
* Eric Haines' NFF format
*/
br_model * BR_PUBLIC_ENTRY BrFmtNFFLoad(char *name);
/*
* Script files
*/
br_uint_32 BR_PUBLIC_ENTRY BrFmtScriptMaterialLoadMany(char *filename, br_material **materials, br_uint_16 num);
br_material * BR_PUBLIC_ENTRY BrFmtScriptMaterialLoad(char *filename);
br_uint_32 BR_PUBLIC_ENTRY BrFmtScriptMaterialSaveMany(char *filename, br_material **materials, br_uint_16 num);
br_uint_32 BR_PUBLIC_ENTRY BrFmtScriptMaterialSave(char *filename, br_material *ptr);
/*
* Windows .BMP files
*/
br_pixelmap * BR_PUBLIC_ENTRY BrFmtBMPLoad(char *name,br_uint_32 flags);
/*
* .TGA files
*/
br_pixelmap * BR_PUBLIC_ENTRY BrFmtTGALoad(char *name,br_uint_32 flags);
/*
* .GIF files
*/
br_pixelmap * BR_PUBLIC_ENTRY BrFmtGIFLoad(char *name,br_uint_32 flags);
/*
* .IFF/.LBM files
*/
br_pixelmap * BR_PUBLIC_ENTRY BrFmtIFFLoad(char *name,br_uint_32 flags);
/*
* .VUE files
*/
br_vue * BR_PUBLIC_ENTRY BrVueAllocate(int nframes, int ntransforms);
void BR_PUBLIC_ENTRY BrVueFree(br_vue *vue);
void BR_PUBLIC_ENTRY BrLoadVUE(char *file_name, br_actor * root, br_vue *vue);
void BR_PUBLIC_ENTRY BrApplyVue( br_vue *vue, br_actor * actors);
#ifdef __cplusplus
};
#endif
#endif

5418
core/fmt/load3ds.c Normal file
View File

File diff suppressed because it is too large Load Diff

599
core/fmt/load3ds.h Normal file
View File

@ -0,0 +1,599 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: load3ds.h 1.1 1997/12/10 16:41:01 jon Exp $
* $Locker: $
*
* Definitions for 3D-Studio .3DS format loader
*/
#ifndef _LOAD3DS_H_
#define _LOAD3DS_H_
/*
* Compile-time options
*/
#define USE_MATERIAL_OPACITY (FALSE)
#define USE_BR_MATF_TWO_SIDED (TRUE)
#define USE_BR_MATF_DECAL (TRUE)
#define USE_BR_MATF_PERSPECTIVE (TRUE)
#define TEST_WIREFRAME (FALSE)
#define REGISTRY_ADD (FALSE)
#define REPORT_MESSAGES (TRUE)
#define SHOW_KEYFRAME_DATA (FALSE)
/*
* Grey-scale conversion factors
*/
#define RED_GREYSCALE_FACTOR (0.3)
#define GREEN_GREYSCALE_FACTOR (0.6)
#define BLUE_GREYSCALE_FACTOR (0.1)
/*
* Flags added to the BRender face flags to indicate texture wrapping
*/
#define FACEF_UWRAP 0x40
#define FACEF_VWRAP 0x80
/*
* Miscellaneous definitions
*/
#define FENCE (65535)
#define HALF_IMAGE_PLANE_MM (21.2237408104802371)
#define MAX_DISPLAY_DEPTH (10)
/*
* General-purpose integer type
*/
typedef br_int_32 Int_t;
/*
* Four-byte float type
*/
typedef float Float_t;
/*
* Boolean type
*/
typedef int Bool_t;
#ifdef TRUE
#undef TRUE
#endif
#define TRUE (1)
#ifdef FALSE
#undef FALSE
#endif
#define FALSE (0)
/*
* Chunk identification tags
*/
typedef enum ChunkIdTag_t {
UNIDENTIFIED = 0x0000,
COLOR_F = 0x0010,
COLOR_24 = 0x0011,
INT_PERCENTAGE = 0x0030,
FLOAT_PERCENTAGE = 0x0031,
MAT_MAPNAME = 0xA300,
M3DMAGIC = 0x4D4D,
M3D_VERSION = 0x0002,
MDATA = 0x3D3D,
MESH_VERSION = 0x3D3E,
MASTER_SCALE = 0x0100,
LO_SHADOW_BIAS = 0x1400,
HI_SHADOW_BIAS = 0x1410,
SHADOW_MAP_SIZE = 0x1420,
SHADOW_SAMPLES = 0x1430,
SHADOW_RANGE = 0x1440,
SHADOW_FILTER = 0x1450,
AMBIENT_LIGHT = 0x2100,
O_CONSTS = 0x1500,
BIT_MAP = 0x1100,
SOLID_BGND = 0x1200,
V_GRADIENT = 0x1300,
USE_BIT_MAP = 0x1101,
USE_SOLID_BGND = 0x1201,
USE_V_GRADIENT = 0x1301,
FOG = 0x2200,
FOG_BGND = 0x2210,
DISTANCE_CUE = 0x2300,
DCUE_BGND = 0x2310,
USE_FOG = 0x2201,
USE_DISTANCE_CUE = 0x2301,
DEFAULT_VIEW = 0x3000,
VIEW_TOP = 0x3010,
VIEW_BOTTOM = 0x3020,
VIEW_LEFT = 0x3030,
VIEW_RIGHT = 0x3040,
VIEW_FRONT = 0x3050,
VIEW_BACK = 0x3060,
VIEW_USER = 0x3070,
VIEW_CAMERA = 0x3080,
MAT_ENTRY = 0xAFFF,
MAT_NAME = 0xA000,
MAT_AMBIENT = 0xA010,
MAT_DIFFUSE = 0xA020,
MAT_SPECULAR = 0xA030,
MAT_SHININESS = 0xA040,
MAT_TRANSPARENCY = 0xA050,
MAT_XPFALL = 0xA052,
MAT_USE_XPFALL = 0xA240,
MAT_REFBLUR = 0xA053,
MAT_USE_REFBLUR = 0xA250,
MAT_SELF_ILLUM = 0xA080,
MAT_TWO_SIDE = 0xA081,
MAT_DECAL = 0xA082,
MAT_ADDITIVE = 0xA083,
MAT_SHADING = 0xA100,
MAT_TEXMAP = 0xA200,
MAT_SXP_TEXT_DATA = 0xA320,
MAT_OPACMAP = 0xA210,
MAT_SXP_OPAC_DATA = 0xA322,
MAT_REFLMAP = 0xA220,
MAT_ACUBIC = 0xA310,
MAT_BUMPMAP = 0xA230,
MAT_SXP_BUMP_DATA = 0xA324,
NAMED_OBJECT = 0x4000,
N_TRI_OBJECT = 0x4100,
POINT_ARRAY = 0x4110,
POINT_FLAG_ARRAY = 0x4111,
FACE_ARRAY = 0x4120,
MSH_MAT_GROUP = 0x4130,
SMOOTH_GROUP = 0x4150,
TEX_VERTS = 0x4140,
MESH_MATRIX = 0x4160,
MESH_TEXTURE_INFO = 0x4170,
PROC_NAME = 0x4181,
PROC_DATA = 0x4182,
N_DIRECT_LIGHT = 0x4600,
DL_OFF = 0x4620,
DL_SPOTLIGHT = 0x4610,
DL_SHADOWED = 0x4630,
DL_LOCAL_SHADOW2 = 0x4641,
DL_SEE_CONE = 0x4650,
N_CAMERA = 0x4700,
CAM_SEE_CONE = 0x4710,
OBJ_HIDDEN = 0x4010,
OBJ_VIS_LOFTER = 0x4011,
OBJ_DOESNT_CAST = 0x4012,
OBJ_MATTE = 0x4013,
OBJ_FAST = 0x4014,
OBJ_PROCEDURAL = 0x4015,
OBJ_FROZEN = 0x4016,
KFDATA = 0xB000,
KFHDR = 0xB00A,
KFSEG = 0xB008,
KFCURTIME = 0xB009,
OBJECT_NODE_TAG = 0xB002,
CAMERA_NODE_TAG = 0xB003,
TARGET_NODE_TAG = 0xB004,
LIGHT_NODE_TAG = 0xB005,
SPOTLIGHT_NODE_TAG = 0xB007,
L_TARGET_NODE_TAG = 0xB006,
NODE_HDR = 0xB010,
PIVOT = 0xB013,
INSTANCE_NAME = 0xB011,
MORPH_SMOOTH = 0xB015,
BOUNDBOX = 0xB014,
POS_TRACK_TAG = 0xB020,
COL_TRACK_TAG = 0xB025,
ROT_TRACK_TAG = 0xB021,
SCL_TRACK_TAG = 0xB022,
MORPH_TRACK_TAG = 0xB026,
FOV_TRACK_TAG = 0xB023,
ROLL_TRACK_TAG = 0xB024,
HOT_TRACK_TAG = 0xB027,
FALL_TRACK_TAG = 0xB028,
MLIBMAGIC = 0x3DAA,
} ChunkIdTag_t;
/*
* Chunk flags
*/
typedef enum ChunkFlag_t {
GOT_COLOR_F = 0x00000001, /* generic */
GOT_COLOR_24 = 0x00000002, /* generic */
GOT_INT_PERCENTAGE = 0x00000001, /* generic */
GOT_FLOAT_PERCENTAGE = 0x00000002, /* generic */
GOT_MAT_MAPNAME = 0x00000004, /* generic */
GOT_M3DMAGIC = 0x00000000, /* req, once */
GOT_M3D_VERSION = 0x00000001, /* req, once */
GOT_MDATA = 0x00000002, /* req, once */
GOT_MESH_VERSION = 0x00000001, /* req, once */
GOT_MASTER_SCALE = 0x00000002, /* req, once */
GOT_LO_SHADOW_BIAS = 0x00000004, /* opt, once */
GOT_HI_SHADOW_BIAS = 0x00000008, /* opt, once */
GOT_SHADOW_MAP_SIZE = 0x00000010, /* opt, once */
GOT_SHADOW_SAMPLES = 0x00000020, /* opt, once */
GOT_SHADOW_RANGE = 0x00000040, /* opt, once */
GOT_SHADOW_FILTER = 0x00000080, /* opt, once */
GOT_AMBIENT_LIGHT = 0x00000100, /* opt, once */
/* COLOR_<X> req, once */
GOT_O_CONSTS = 0x00000200, /* opt, once */
GOT_BIT_MAP = 0x00000400, /* opt, once */
GOT_SOLID_BGND = 0x00000800, /* opt, once */
GOT_V_GRADIENT = 0x00001000, /* opt, once */
/* COLOR_<X> req, three */
GOT_USE_BIT_MAP = 0x00002000, /* opt, once */
GOT_USE_SOLID_BGND = 0x00004000, /* opt, once */
GOT_USE_V_GRADIENT = 0x00008000, /* opt, once */
GOT_FOG = 0x00010000, /* opt, once */
/* COLOR_<X> req, once */
GOT_FOG_BGND = 0x00000000, /* opt, flag */
GOT_DISTANCE_CUE = 0x00020000, /* opt, once */
GOT_DCUE_BGND = 0x00000000, /* opt, flag */
GOT_USE_FOG = 0x00040000, /* opt, once */
GOT_USE_DISTANCE_CUE = 0x00080000, /* opt, once */
GOT_DEFAULT_VIEW = 0x00100000, /* opt, once */
GOT_VIEW_TOP = 0x00000001, /* xopt, once */
GOT_VIEW_BOTTOM = 0x00000002, /* xopt, once */
GOT_VIEW_LEFT = 0x00000004, /* xopt, once */
GOT_VIEW_RIGHT = 0x00000008, /* xopt, once */
GOT_VIEW_FRONT = 0x00000010, /* xopt, once */
GOT_VIEW_BACK = 0x00000020, /* xopt, once */
GOT_VIEW_USER = 0x00000040, /* xopt, once */
GOT_VIEW_CAMERA = 0x00000080, /* xopt, once */
GOT_MAT_ENTRY = 0x00000000, /* opt, any */
GOT_MAT_NAME = 0x00000001, /* req, once */
GOT_MAT_AMBIENT = 0x00000002, /* req, once */
/* COLOR_<X> req, once */
GOT_MAT_DIFFUSE = 0x00000004, /* req, once */
/* COLOR_<X> req, once */
GOT_MAT_SPECULAR = 0x00000008, /* req, once */
/* COLOR_<X> req, once */
GOT_MAT_SHININESS = 0x00000010, /* req, once */
/* <X>_PERCENTAGE req, once */
GOT_MAT_TRANSPARENCY = 0x00000020, /* req, once */
/* <X>_PERCENTAGE req, once */
GOT_MAT_XPFALL = 0x00000040, /* opt, once */
/* <X>_PERCENTAGE req, once */
GOT_MAT_USE_XPFALL = 0x00000080, /* opt, once */
GOT_MAT_REFBLUR = 0x00000100, /* opt, once */
/* <X>_PERCENTAGE req, once */
GOT_MAT_USE_REFBLUR = 0x00000200, /* opt, once */
GOT_MAT_SELF_ILLUM = 0x00000000, /* opt, flag */
GOT_MAT_TWO_SIDE = 0x00000400, /* opt, once */
GOT_MAT_DECAL = 0x00000800, /* opt, once */
GOT_MAT_ADDITIVE = 0x00000000, /* opt, flag */
GOT_MAT_SHADING = 0x00001000, /* req, once */
GOT_MAT_TEXMAP = 0x00002000, /* opt, once */
/* <X>_PERCENTAGE req, once */
/* MAT_MAPNAME req, once */
GOT_MAT_SXP_TEXT_DATA = 0x00004000, /* opt, once */
GOT_MAT_OPACMAP = 0x00008000, /* opt, once */
/* <X>_PERCENTAGE req, once */
/* MAT_MAPNAME req, once */
GOT_MAT_SXP_OPAC_DATA = 0x00010000, /* opt, once */
GOT_MAT_REFLMAP = 0x00020000, /* opt, once */
/* <X>_PERCENTAGE req, once */
/* MAT_MAPNAME req, once */
GOT_MAT_ACUBIC = 0x00040000, /* opt, once */
GOT_MAT_BUMPMAP = 0x00080000, /* opt, once */
/* <X>_PERCENTAGE req, once */
/* MAT_MAPNAME req, once */
GOT_MAT_SXP_BUMP_DATA = 0x00100000, /* opt, once */
GOT_NAMED_OBJECT = 0x00000000, /* opt, any */
GOT_N_TRI_OBJECT = 0x00000001, /* xopt, once */
GOT_POINT_ARRAY = 0x00000001, /* req, once */
GOT_POINT_FLAG_ARRAY = 0x00000002, /* opt, once */
GOT_FACE_ARRAY = 0x00000004, /* req, once */
GOT_MSH_MAT_GROUP = 0x00000000, /* opt, any */
GOT_SMOOTH_GROUP = 0x00000001, /* opt, once */
GOT_TEX_VERTS = 0x00000008, /* opt, once */
GOT_MESH_MATRIX = 0x00000010, /* opt, once */
GOT_MESH_TEXTURE_INFO = 0x00000020, /* opt, once */
GOT_PROC_NAME = 0x00000040, /* opt, once */
GOT_PROC_DATA = 0x00000080, /* opt, once */
GOT_N_DIRECT_LIGHT = 0x00000002, /* xopt, once */
/* COLOR_<X> req, once */
GOT_DL_OFF = 0x00000001, /* opt, once */
GOT_DL_SPOTLIGHT = 0x00000002, /* opt, once */
GOT_DL_SHADOWED = 0x00000001, /* opt, once */
GOT_DL_LOCAL_SHADOW2 = 0x00000002, /* opt, once */
GOT_DL_SEE_CONE = 0x00000004, /* opt, once */
GOT_N_CAMERA = 0x00000004, /* xopt, once */
GOT_CAM_SEE_CONE = 0x00000001, /* opt, once */
GOT_OBJ_HIDDEN = 0x00000002, /* opt, once */
GOT_OBJ_VIS_LOFTER = 0x00000004, /* opt, once */
GOT_OBJ_DOESNT_CAST = 0x00000008, /* opt, once */
GOT_OBJ_MATTE = 0x00000010, /* opt, once */
GOT_OBJ_FAST = 0x00000020, /* opt, once */
GOT_OBJ_PROCEDURAL = 0x00000040, /* opt, once */
GOT_OBJ_FROZEN = 0x00000080, /* opt, once */
GOT_KFDATA = 0x00000004, /* opt, once */
GOT_KFHDR = 0x00000001, /* req, once */
GOT_KFSEG = 0x00000002, /* req, once */
GOT_KFCURTIME = 0x00000004, /* req, once */
GOT_OBJECT_NODE_TAG = 0x00000000, /* opt, any */
GOT_CAMERA_NODE_TAG = 0x00000000, /* opt, any */
GOT_TARGET_NODE_TAG = 0x00000000, /* opt, any */
GOT_LIGHT_NODE_TAG = 0x00000000, /* opt, any */
GOT_SPOTLIGHT_NODE_TAG = 0x00000000, /* opt, any */
GOT_L_TARGET_NODE_TAG = 0x00000000, /* opt, any */
GOT_NODE_HDR = 0x00000001, /* req, once */
GOT_PIVOT = 0x00000002, /* req, once */
GOT_INSTANCE_NAME = 0x00000004, /* opt, once */
GOT_MORPH_SMOOTH = 0x00000008, /* opt, once */
GOT_BOUNDBOX = 0x00000010, /* req, once */
GOT_POS_TRACK_TAG = 0x00000020, /* req, once */
GOT_COL_TRACK_TAG = 0x00000040, /* req, once */
GOT_ROT_TRACK_TAG = 0x00000080, /* req, once */
GOT_SCL_TRACK_TAG = 0x00000100, /* req, once */
GOT_MORPH_TRACK_TAG = 0x00000200, /* opt, once */
GOT_FOV_TRACK_TAG = 0x00000400, /* req, once */
GOT_ROLL_TRACK_TAG = 0x00000800, /* req, once */
GOT_HOT_TRACK_TAG = 0x00001000, /* req, once */
GOT_FALL_TRACK_TAG = 0x00002000 /* req, once */
} ChunkFlag_t;
/*
* RGB triple
*/
typedef struct Color_t {
Float_t red;
Float_t green;
Float_t blue;
} Color_t;
/*
* 3DS material shading types
*/
typedef enum MatShading_t {
WIREFRAME,
FLAT,
GOURAUD
} MatShading_t;
/*
* An entry in a linked list of pixmaps
*/
typedef struct PixmapList_t {
br_pixelmap *pixelmap;
struct PixmapList_t *next;
} PixmapList_t;
/*
* A pixmap reference
*/
typedef struct PixmapRef_t {
Bool_t is_reflection_map;
char *mat_mapname;
Float_t strength;
} PixmapRef_t;
/*
* A 3DS material entry
*/
typedef struct MatEntry_t {
char *mat_name;
Color_t mat_ambient;
Color_t mat_diffuse;
Color_t mat_specular;
Float_t mat_transparency;
Float_t mat_shininess;
MatShading_t mat_shading;
Bool_t mat_two_side;
Bool_t mat_decal;
PixmapRef_t pixmap_ref;
} MatEntry_t;
/*
* An entry in a linked list of 3DS materials
*/
typedef struct MaterialList_t {
MatShading_t mat_shading;
br_material *material;
struct MaterialList_t *next;
} MaterialList_t;
/*
* An array of points
*/
typedef struct PointArray_t {
br_uint_16 n_vertices;
br_vector3 *vertices;
} PointArray_t;
/*
* Intermediate face structure
*/
typedef struct Face_t {
br_uint_16 vertices[3];
br_uint_16 flags;
} Face_t;
/*
* An entry in a linked list of material groups
*/
typedef struct MshMatGroup_t {
MaterialList_t *material_link;
br_uint_16 n_indexes;
br_uint_16 *indexes;
struct MshMatGroup_t *next;
} MshMatGroup_t;
/*
* An array of faces, material groups and smoothing groups
*/
typedef struct FaceArray_t {
br_uint_16 n_faces;
Face_t *faces;
MshMatGroup_t *msh_mat_groups;
br_uint_16 *smooth_group;
} FaceArray_t;
/*
* An array of texture coordinates
*/
typedef struct TexVerts_t {
br_uint_16 n_texverts;
br_vector2 *texverts;
} TexVerts_t;
/*
* An intermediate triangle mesh structure
*/
typedef struct NTriObj_t {
PointArray_t point_array;
FaceArray_t face_array;
TexVerts_t tex_verts;
br_matrix34 mesh_matrix;
} NTriObj_t;
/*
* Spotlight parameters
*/
typedef struct DlSpotlight_t {
br_vector3 target;
Float_t cone_inner;
Float_t cone_outer;
} DlSpotlight_t;
/*
* Light parameters
*/
typedef struct NDLight_t {
br_vector3 posn;
Color_t color;
Bool_t is_off;
Bool_t is_spotlight;
DlSpotlight_t dl_spotlight;
} NDLight_t;
/*
* Camera parameters
*/
typedef struct NCamera_t {
br_vector3 posn;
br_vector3 target;
Float_t bank_angle;
Float_t focal_length;
} NCamera_t;
/*
* Light
*/
typedef struct Light_t {
br_uint_8 type;
br_colour colour;
br_angle cone_outer;
br_angle cone_inner;
Bool_t is_off;
} Light_t;
/*
* Camera
*/
typedef struct Camera_t {
br_angle field_of_view;
} Camera_t;
/*
* Model
*/
typedef struct Model_t {
br_model *fill_model;
br_model *wire_model;
} Model_t;
/*
* 3DS named object types
*/
typedef enum NamedObjType_t {
NONE,
LIGHT,
CAMERA,
MODEL
} NamedObjType_t;
/*
* An entry in a linked list of named objects
*/
typedef struct NamedObj_t {
char *name;
NamedObjType_t type;
union {
Light_t *light;
Model_t *model;
Camera_t *camera;
} data;
br_matrix34 to_world;
br_matrix34 from_world;
struct NamedObj_t *next;
} NamedObj_t;
/*
* Node header
*/
typedef struct NodeHdr_t {
Int_t index;
Int_t parent;
NamedObj_t *named_obj;
} NodeHdr_t;
/*
* An entry in a linked list of node tags, each
* of which contain additional model information
*/
typedef struct NodeTag_t {
NodeHdr_t node_hdr;
char *instance_name;
Bool_t has_pivot;
br_vector3 pivot;
Bool_t has_boundbox;
br_bounds boundbox;
struct NodeTag_t *next;
} NodeTag_t;
/*
* An item on the stack
*/
typedef struct Stack_t {
ChunkIdTag_t id_tag;
br_uint_32 length;
br_uint_32 done;
ChunkFlag_t flags;
union { Color_t color;
Float_t percent;
char *string;
MatShading_t mat_shading;
PixmapRef_t pixmap_ref;
MatEntry_t mat_entry;
PointArray_t point_array;
FaceArray_t face_array;
br_uint_16 *smooth_group;
MshMatGroup_t *msh_mat_group;
TexVerts_t tex_verts;
br_matrix34 mesh_matrix;
NTriObj_t n_tri_obj;
DlSpotlight_t dl_spotlight;
NDLight_t n_d_light;
NCamera_t n_camera;
NamedObj_t *named_obj;
NodeHdr_t node_hdr;
br_vector3 pivot;
br_bounds boundbox;
NodeTag_t *node_tag;
} data;
} Stack_t;
/*
* Parser states
*/
typedef enum State_t {
OK,
PARSE_ERROR,
OUT_OF_MEMORY
} State_t;
#endif

242
core/fmt/loadasc.c Normal file
View File

@ -0,0 +1,242 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: loadasc.c 1.1 1997/12/10 16:41:01 jon Exp $
* $Locker: $
*
* Loader for 3D-Studio .ASC format
*
*/
#include "brender.h"
#include "fmt.h"
BR_RCS_ID("$Id: loadasc.c 1.1 1997/12/10 16:41:01 jon Exp $")
/*
* Various keywords than can appear in 3D-Studio .ASC file
*/
#define K_NOP 0
#define K_AMBIENT_LIGHT 1
#define K_NAMED_OBJECT 2
#define K_TRI_MESH 3
#define K_VERTEX 4
#define K_FACE 5
#define K_SMOOTHING 6
#define K_MATERIAL 7
#define K_DIRECT_LIGHT 8
#define K_POSITION 9
#define K_LIGHT_COLOR 10
#define K_CAMERA 11
#define K_TARGET 12
#define K_BANK_ANGLE 13
#define K_EOF 255
static struct {
char *word;
short length;
short token;
#define K(word,token) {word,sizeof(word)-1,token,},
} Keywords[] = {
K("Ambient light color:", K_AMBIENT_LIGHT)
K("Named object: ", K_NAMED_OBJECT)
K("Tri-mesh,", K_TRI_MESH)
K("Vertex list:", K_NOP)
K("Vertex", K_VERTEX)
K("Face list:", K_NOP)
K("Face", K_FACE)
K("Smoothing:", K_SMOOTHING)
K("Material:", K_MATERIAL)
K("Direct light", K_DIRECT_LIGHT)
K("Position:", K_POSITION)
K("Light color:", K_LIGHT_COLOR)
K("Camera ", K_CAMERA)
K("Target ", K_TARGET)
K("Bank angle: ", K_BANK_ANGLE)
};
#undef K
#define MAX_LINE 512
#define MAX_NAME 64
#define TABLE_SIZE 16
static br_model *LoadModels;
static br_material *LoadMaterials;
static br_camera *LoadCameras;
static br_light *LoadLights;
static br_actor *LoadActors;
/*
* Load a 3D-Studio .ASC file and produce -
*
* Models
*
* TODO:
* Actors
* Materials
* Cameras
* Lights
*/
br_uint_32 BR_PUBLIC_ENTRY BrFmtASCLoad(char *name,
br_model **mtable, br_uint_16 max_models)
{
void *fh;
char line[MAX_LINE];
char object_name[MAX_NAME+1] = "";
char material_name[MAX_NAME+1] = "";
char *line_tail;
int token,cvert,cface,vnum,i;
float vx,vy,vz,vu,vv;
int fnum,fa,fb,fc,fab,fbc,fca;
br_model *mp = NULL;
int nmodels = 0,nvertices,nfaces;
int open_mode = BR_FS_MODE_TEXT;
/*
* Open input file
*/
fh = BrFileOpenRead(name,0,NULL,&open_mode);
if(fh == NULL)
BR_ERROR1("Could not open '%s' for reading",name);
/*
* Read lines from input file
*/
while(!BrFileEof(fh)) {
/*
* Pull next line and look at the front to see what it contains:
*/
if(BrFileGetLine(line,MAX_LINE,fh) == 0) {
token = K_NOP;
} else {
token = K_NOP;
for(i=0; i< BR_ASIZE(Keywords); i++) {
if(!BrStrNICmp(Keywords[i].word,line,Keywords[i].length)) {
token = Keywords[i].token;
line_tail = line+Keywords[i].length;
break;
}
}
}
/*
* Perform action for current line
*/
switch(token) {
case K_NAMED_OBJECT:
/*
* Extract name
*/
BrSScanf(line_tail,"\"%64[^\"]",object_name);
break;
case K_MATERIAL:
BrSScanf(line_tail,"\"%64[^\"]",material_name);
/*
* make sure a face has been read
*/
if(cface > 0)
mp->faces[cface-1].material = BrMaterialFind(material_name);
break;
case K_TRI_MESH:
/*
* Fail if no enough space in output table
*/
if(nmodels >= max_models)
return nmodels;
/*
* Allocate a new model and buffers
*/
BrSScanf(line_tail," Vertices: %d Faces: %d",&nvertices,&nfaces);
mp = BrModelAllocate((object_name[0] != '0')?object_name:NULL,nvertices,nfaces);
cvert = 0;
cface = 0;
/*
* Record model in output table
*/
mtable[nmodels++] = mp;
break;
case K_VERTEX:
/*
* Add vertex to current mesh
*/
vx = vy = vz = vu = vv = 0.0F;
BrSScanf(line_tail,"%d: X: %f Y: %f Z: %f U: %f V: %f",&vnum,&vx,&vy,&vz,&vu,&vv);
/*
* Only process if things are consistent
*/
if(cvert != vnum || cvert >= mp->nvertices)
break;
mp->vertices[cvert].p.v[0] = BrFloatToScalar(vx);
mp->vertices[cvert].p.v[1] = BrFloatToScalar(vy);
mp->vertices[cvert].p.v[2] = BrFloatToScalar(vz);
mp->vertices[cvert].map.v[0] = BrFloatToScalar(vu);
mp->vertices[cvert].map.v[1] = BrFloatToScalar(vv);
cvert++;
break;
case K_FACE:
/*
* Add face to current mesh
*/
BrSScanf(line_tail,"%d: A:%d B:%d C:%d AB:%d BC:%d CA:%d",
&fnum,&fa,&fb,&fc,&fab,&fbc,&fca);
/*
* Only process if things are consistent
*/
if(cface != fnum || cface >= mp->nfaces)
break;
mp->faces[cface].vertices[0] = fa;
mp->faces[cface].vertices[1] = fb;
mp->faces[cface].vertices[2] = fc;
mp->faces[cface].material = 0; /* default material */
mp->faces[cface].flags = (fab?0:1) | (fbc?0:2) | (fca?0:4);
cface++;
break;
case K_SMOOTHING:
/*
* Add smoothing group to last face
*/
if(cface > 0) {
mp->faces[cface-1].smoothing = 0;
while(i = BrStrToL(line_tail,&line_tail,0)) {
mp->faces[cface-1].smoothing |= 1<<((i-1) % 16);
while(*line_tail == ',' || *line_tail == ' ')
line_tail++;
}
}
break;
/*
* Ignore everything else
*/
case K_NOP:
default:
;
}
}
BrFileClose(fh);
return nmodels;
}

483
core/fmt/loadbmp.c Normal file
View File

@ -0,0 +1,483 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: loadbmp.c 1.1 1997/12/10 16:41:01 jon Exp $
* $Locker: $
*
* Loader for Windows .BMP format
* support for <=8 bit index palette based, 24 bit true colour
* TODO 16,32 bit BI_BITFIELD compression (no compression!)
*/
#include "brender.h"
#include "fmt.h"
BR_RCS_ID("$Id: loadbmp.c 1.1 1997/12/10 16:41:01 jon Exp $")
int FileNumCol(void *tmp);
#define RED 2
#define GRN 1
#define BLU 0
#define PAD 3
#define BI_RGB 0L
#define BI_RLE8 1L
#define BI_RLE4 2L
#define BI_BITFIELDS 3L
#define WIDTHBYTES(i) ((i+31)/32*4)
#define RLE_ESCAPE 0
#define RLE_EOL 0
#define RLE_EOF 1
#define RLE_JMP 2
static void *(*compressed_line_func)(br_pixelmap *pm,int line,void *fh);
static void *Uncompressed_4(br_pixelmap *pm,int line,void *fh);
static void *Uncompressed_8(br_pixelmap *pm,int line,void *fh);
static void *Uncompressed_24(br_pixelmap *pm,int line,void *fh);
static void *Compressed_8(br_pixelmap *pm,int line,void *fh);
static void *Compressed_4(br_pixelmap *pm,int line,void *fh);
#pragma pack (1)
typedef struct {
short bfType;
int bfSize; /* size of image file */
short bfReserved1;
short bfReserved2;
int bfOffBits; /* size of header (including palette) */
} BITMAPFILEHEADER;
typedef struct {
int biSize; /* size of BITMAPINFOHEADER always 0x28 */
int biWidth; /* width in pixels */
int biHeight; /* depth in pixels */
short biPlanes; /* always 1 */
short biBitCount; /* bits per pixel: 1,4,8,16,24,32 */
int biCompression; /* always 0, however spec exists for compression*/
int biSizeImage; /* number of bytes in image */
int biXPelsPerMeter; /* resolution */
int biYPelsPerMeter; /* resolution */
int biClrUsed; /* Number of colours users, 0=all ie. 8 bit=256 */
int biClrImportant; /* Number of important colours? 0=all */
} BITMAPINFOHEADER, *ptrBITMAPINFOHEADER;
typedef struct {
int bcSize; /* size of BITMAPINFOHEADER always 0x0c */
short bcWidth;
short bcHeight;
short bcPlanes;
short bcBitCount;
} BITMAPCOREHEADER, *ptrBITMAPCOREHEADER;
static struct {
char control;
char data;
} RLEcontrol;
static struct {
char blue,green,red;
} RGB3;
static struct {
char blue,green,red,pad;
} RGB4;
#pragma pack ()
br_pixelmap * BR_PUBLIC_ENTRY BrFmtBMPLoad(char *name,br_uint_32 flags)
{
void *fh;
int open_mode = BR_FS_MODE_BINARY;
br_pixelmap *pm,*palette;
int headersize,palettesize;
BITMAPINFOHEADER bi;
BITMAPCOREHEADER bc;
BITMAPFILEHEADER bf;
int size;
int NumColours;
int dwWidth =0;
int dwHeight=0;
short wPlanes,wBitCount;
br_uint_8 type;
int i;
fh = BrFileOpenRead(name,0,NULL,&open_mode);
if(fh == NULL)
BR_ERROR1("Could not open '%s' for reading",name);
if(BrFileRead(&bf,1,sizeof(bf),fh) != sizeof(bf))
BR_ERROR1("Unable to read header information from '%s'",name);
/*
* load header, check for sig.
*/
if(BrMemCmp(&bf.bfType,"BM",2))
BR_ERROR1("'%s' is not a valid BMP file",name);
if(BrFileRead(&bi,1,sizeof(bi),fh) != sizeof(bi))
BR_ERROR1("Unable to read bitmap info header from '%s'",name);
NumColours = FileNumCol(&bi);
palettesize = 0;
/*
* check for old/new header type
*/
switch(size = bi.biSize)
{
case(sizeof(BITMAPINFOHEADER)): headersize = sizeof(BITMAPFILEHEADER) + bi.biSize;
break;
case(sizeof(BITMAPCOREHEADER)): bc = *(BITMAPCOREHEADER*)&bi;
headersize = sizeof(BITMAPFILEHEADER) + bc.bcSize;
dwWidth = (int)bc.bcWidth;
dwHeight = (int)bc.bcHeight;
wPlanes = bc.bcPlanes;
wBitCount = bc.bcBitCount;
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = dwWidth;
bi.biHeight = dwHeight;
bi.biPlanes = wPlanes;
bi.biBitCount = wBitCount;
bi.biCompression = BI_RGB;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = NumColours;
bi.biClrImportant = NumColours;
BrFileAdvance(sizeof(BITMAPCOREHEADER) - sizeof(BITMAPINFOHEADER),fh);
break;
default:BR_ERROR1("'%s' is not a valid BMP file",name);
}
if(bi.biSizeImage == 0)
bi.biSizeImage = WIDTHBYTES(bi.biWidth * bi.biBitCount) * bi.biHeight;
if(bi.biClrUsed == 0)
bi.biClrUsed = FileNumCol(&bi);
/*
* read palette
*/
switch(bi.biBitCount)
{
case(1):BR_ERROR1("1 bit BMP '%s' not supported",name);
break;
case(4): /* promote 4 to 8 bit */
case(8):switch(bi.biCompression)
{
case(BI_RGB):compressed_line_func = (bi.biBitCount == 4)?Uncompressed_4:Uncompressed_8;
break;
case(BI_RLE4):compressed_line_func = Compressed_4;
break;
case(BI_RLE8):compressed_line_func = Compressed_8;
break;
case(BI_BITFIELDS):BR_ERROR1("BMP compression type BITFIELDS not supported in '%s'",name);
break;
}
type = BR_PMT_INDEX_8;
palette=BrPixelmapAllocate(BR_PMT_RGBX_888,1,256,NULL,0);
palette->identifier = BrResStrDup(palette, name);
if(size == sizeof(BITMAPCOREHEADER))
for(i=0; i<NumColours; i++, palettesize+=3)
{
if(BrFileRead(&RGB3,1,sizeof(RGB3),fh) != sizeof(RGB3))
BR_ERROR1("Unable to read palette from '%s'",name);
((char *)(palette->pixels))[i*4+RED] = RGB3.red;
((char *)(palette->pixels))[i*4+GRN] = RGB3.green;
((char *)(palette->pixels))[i*4+BLU] = RGB3.blue;
((char *)(palette->pixels))[i*4+PAD] = 0;
}
else
for(i=0; i<NumColours; i++,palettesize+=4)
{
if(BrFileRead(&RGB4,1,sizeof(RGB4),fh) != sizeof(RGB4))
BR_ERROR1("Unable to read palette from '%s'",name);
((char *)(palette->pixels))[i*4+RED] = RGB4.red;
((char *)(palette->pixels))[i*4+GRN] = RGB4.green;
((char *)(palette->pixels))[i*4+BLU] = RGB4.blue;
((char *)(palette->pixels))[i*4+PAD] = RGB4.pad;
}
break;
case(16):BR_ERROR1("16 bit BMP '%s' not supported",name);
break;
case(24):if(bi.biCompression == BI_RGB)
compressed_line_func = Uncompressed_24;
else BR_ERROR1("24 bit compressed file '%s' not supported",name);
type = BR_PMT_RGB_888;
break;
case(32):BR_ERROR1("32 bit BMP '%s' not supported",name);
break;
}
if(bf.bfOffBits != 0)
BrFileAdvance(bf.bfOffBits-headersize-palettesize,fh);
pm = BrPixelmapAllocate(type,bi.biWidth,bi.biHeight,NULL,0);
pm->identifier = BrResStrDup(pm, name);
pm->map = (type == BR_PMT_INDEX_8)?palette:NULL;
switch(bi.biCompression)
{
/*
* No compression
*/
case(BI_RGB):for(i=bi.biHeight-1;i>=0;i--)
if(compressed_line_func(pm,i,fh) == NULL)
BR_ERROR1("Unable to read image data from '%s'",name);
break;
/*
* Run length encoding
*/
case(BI_RLE4):
case(BI_RLE8):if(compressed_line_func(pm,0,fh) == NULL)
BR_ERROR1("Unable to read compressed image data from '%s'",name);
break;
case(BI_BITFIELDS):
break;
}
BrFileClose(fh);
return pm;
}
int FileNumCol(void *tmp)
{
int bits;
ptrBITMAPINFOHEADER bi;
ptrBITMAPCOREHEADER bc;
bi = ((ptrBITMAPINFOHEADER)tmp);
bc = ((ptrBITMAPCOREHEADER)tmp);
if (bi->biSize != sizeof(BITMAPCOREHEADER))
{
if(bi->biClrUsed != 0)
return bi->biClrUsed;
bits = bi->biBitCount;
}
else
bits = bc->bcBitCount;
switch(bits)
{
case(1):return 2;
break;
case(4):return 16;
break;
case(8):return 256;
break;
default:return 0; /* 24 bit has no palette */
}
}
static void *Uncompressed_4(br_pixelmap *pm,int line,void *fh)
{
int i;
char c;
for(i=0;i<pm->width;)
{
c = BrFileGetChar(fh);
((char *)(pm->pixels))[(line*pm->row_bytes)+i++] = (c >>4) & 0x0f;
((char *)(pm->pixels))[(line*pm->row_bytes)+i++] = (c & 0x0f);
}
if(((pm->width+1)/2) %4)
BrFileAdvance(4-(((pm->width+1)/2) %4),fh);
return pm;
}
static void *Uncompressed_8(br_pixelmap *pm,int line,void *fh)
{
if(BrFileRead(((char *)(pm->pixels)+line*pm->row_bytes),1,pm->width,fh) != pm->width)
return NULL;
if(pm->width %4) BrFileAdvance(4-(pm->width %4),fh);
return pm;
}
static void *Uncompressed_24(br_pixelmap *pm,int line,void *fh)
{
int i;
for(i=0;i<pm->width;i++)
{
if(BrFileRead(&RGB3,1,sizeof(RGB3),fh) != sizeof(RGB3))
return NULL;
((char *)(pm->pixels))[line*pm->row_bytes+i*3+RED] = RGB3.red;
((char *)(pm->pixels))[line*pm->row_bytes+i*3+GRN] = RGB3.green;
((char *)(pm->pixels))[line*pm->row_bytes+i*3+BLU] = RGB3.blue;
}
if((pm->width*3)%4) BrFileAdvance(4-((pm->width*3)%4),fh);
return pm;
}
static void *Compressed_8(br_pixelmap *pm,int line,void *fh)
{
char i;
long dx,dy;
char *mblock;
mblock = BrMemAllocate(pm->width,BR_MEMORY_SCRATCH);
for(dx=0,dy=pm->height-1;;)
{
if(BrFileRead(&RLEcontrol,1,sizeof(RLEcontrol),fh) != sizeof(RLEcontrol))
{
BrMemFree(mblock);
return NULL;
}
if(RLEcontrol.control == RLE_ESCAPE)
{
switch(RLEcontrol.data)
{
case(RLE_EOF):BrMemFree(mblock);
return pm;
break;
case(RLE_EOL):dx = 0;
BrMemCpy((char *)pm->pixels+ dy-- * pm->row_bytes,mblock,pm->width);
break;
case(RLE_JMP):dx += BrFileGetChar(fh);
dy += BrFileGetChar(fh);
break;
default:for(i=0;i<RLEcontrol.data;i++)
mblock[dx++] = BrFileGetChar(fh);
if(i & 1) BrFileAdvance(1,fh);
break;
}
}
else
for(i=0;i<RLEcontrol.control;i++)
mblock[dx++] = RLEcontrol.data;
}
}
static void *Compressed_4(br_pixelmap *pm,int line,void *fh)
{
char i,pixel;
long dx,dy;
char *mblock;
long offset;
mblock = BrMemAllocate(pm->width,BR_MEMORY_SCRATCH);
for(dx=0,dy=pm->height-1,offset=0;;)
{
if(BrFileRead(&RLEcontrol,1,sizeof(RLEcontrol),fh) != sizeof(RLEcontrol))
{
BrMemFree(mblock);
return NULL;
}
offset+=sizeof(RLEcontrol);
if(RLEcontrol.control == RLE_ESCAPE)
{
switch(RLEcontrol.data)
{
case(RLE_EOF):BrMemFree(mblock);
return pm;
break;
case(RLE_EOL):dx = 0;
BrMemCpy((char *)pm->pixels+ dy-- * pm->row_bytes,mblock,pm->width);
if(dy == 0)
{
BrMemFree(mblock);
return pm;
}
break;
case(RLE_JMP):dx += BrFileGetChar(fh);
dy += BrFileGetChar(fh);
offset += 2;
break;
default:i=RLEcontrol.data;
do
{ /* absolute */
pixel = BrFileGetChar(fh);
offset++;
mblock[dx++] = (pixel >> 4) & 0x0f;
i--;
if(i>0)
{
mblock[dx++] = (pixel & 0x0f);
i--;
}
}
while(i>0);
if(offset & 1)
{
BrFileAdvance(offset & 1,fh);
offset++;
}
break;
}
}
else
{ /* encoded */
i=RLEcontrol.control;
do
{
mblock[dx++] = (RLEcontrol.data >> 4) & 0x0f;
i--;
if(i>0)
{
mblock[dx++] = (RLEcontrol.data & 0x0f);
i--;
}
}
while(i>0);
}
}
}

380
core/fmt/loadgif.c Normal file
View File

@ -0,0 +1,380 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: loadgif.c 1.1 1997/12/10 16:41:02 jon Exp $
* $Locker: $
*
* Loader for CompuServ .GIF format (PC format, not MAC)
* support for 8 bit index palette based
* always BR_PMT_INDEX_8, 0 < palette entries < 256
*
* LZW compression algorithm from Supercharged Bitmapped Graphics by Steve Rimmer.
* algorithm from files taken by Rimmer from BBS. Author not mentioned
*/
#include "brender.h"
#include "fmt.h"
BR_RCS_ID("$Id: loadgif.c 1.1 1997/12/10 16:41:02 jon Exp $")
#define RED 2
#define GRN 1
#define BLU 0
#define PAD 3
#define IMAGEBLOCK ',' /* next block is image */
#define EXTENSION '!' /* next block is extension */
#define ENDOFBLOCK ':' /* end of block */
#define NO_CODE -1
#define UNEXPECTED_EOF NULL
#define BAD_CODE NULL
#define BAD_FIRSTCODE NULL
#define BAD_SYMBOLSIZE NULL
static void CopyLine(br_pixelmap *pm,char *linebuffer,short line);
static void *UnpackImage(br_pixelmap *pm,short bits,void *fh);
static void SkipExtension(void *fh);
enum {
BR_GIF_COLOURMAP = 0x80, /* (GIFheader.colourmapflags & x) , colourmap present */
BR_GIF_COLOURMAP_SIZE = 0x07, /* ((GIFheader.colourmapflags & x)+1) number of colour bits */
/* (1 << ((GIFheader.colourmapflags & x)+1)) number of colours */
/* 3 bytes per entry in colourmap */
BR_GIF_COLOURMAP_SORTED = 0x08, /* (GIFheader.colourmapflags > x) important colours first (GIF89a) */
BR_GIF_COLOURMAP_ORIGIN = 0x04, /* (1 << ((GIFheader.colourmapflags >> x) +1) is the */
/* number of bits/pixel GIF derived from. (GIF89a) */
BR_GIF_IMAGE_INTERLACED = 0x40, /* (ImageBlock.imageflags & x) image data is interlaced */
BR_GIF_IMAGE_SORTED = 0x20 /* (ImageBlock.imageflags & x) image colourmap sorted (GIF89a) */
};
#pragma pack (1)
static struct {
char sig[6]; /* GIF signature, 'GIF87a' or 'GIF89a' */
unsigned short screenwidth; /* screen width in pixels */
unsigned short screendepth; /* screen depth in pixels */
char colourmapflags;
char background;
char aspect; /* GIF87a = 0, GIF89a != 0 aspect ratio of pixels in image is */
/* (aspect + 15) / 64 */
} GIFheader;
static struct {
unsigned short left; /* coordinates of upper left of image relative to screen */
unsigned short top;
unsigned short width; /* width of image in pixels, number of bytes per unpacked line */
unsigned short depth; /* depth of image in pixels */
char imageflags; /* Flags similar to GIFheader.colourmapflags but for image block */
} ImageBlock;
static struct {
char red;
char green;
char blue;
} RGB; /* palette entry */
#pragma pack ()
static char BlockSize; /* size of GIF block */
br_pixelmap * BR_PUBLIC_ENTRY BrFmtGIFLoad(char *name,br_uint_32 flags)
{
void *fh;
int open_mode = BR_FS_MODE_BINARY;
br_pixelmap *pm,*palette;
unsigned char ch,foundimage;
br_int_32 global_palette_size,local_palette_size;
int i;
fh = BrFileOpenRead(name,0,NULL,&open_mode);
if(fh == NULL)
BR_ERROR1("Could not open '%s' for reading",name);
if(BrFileRead(&GIFheader,1,sizeof(GIFheader),fh) != sizeof(GIFheader))
BR_ERROR1("Unable to read header information from '%s'",name);
if(BrMemCmp(GIFheader.sig,"GIF",3))
BR_ERROR1("'%s' is not a valid GIF file",name);
if(GIFheader.colourmapflags & BR_GIF_COLOURMAP)
{
global_palette_size = (1 << ((GIFheader.colourmapflags & BR_GIF_COLOURMAP_SIZE)+1));
palette=BrPixelmapAllocate(BR_PMT_RGBX_888,1,256,NULL,0);
palette->identifier=BrResStrDup(palette,name);
for(i=0;i<global_palette_size;i++)
{
if(BrFileRead(&RGB,1,sizeof(RGB),fh) != sizeof(RGB))
BR_ERROR1("Unable to read global palette data from '%s'",name);
((char *)(palette->pixels))[i*4+RED] = RGB.red;
((char *)(palette->pixels))[i*4+GRN] = RGB.green;
((char *)(palette->pixels))[i*4+BLU] = RGB.blue;
}
}
/*
* Only read the first image block encountered. Skip any extension blocks
*/
foundimage=0;
while((ch=BrFileGetChar(fh)) == IMAGEBLOCK || ch == EXTENSION || ch == 0 || !foundimage)
{
switch(ch)
{
case(IMAGEBLOCK):foundimage = 1;
if(BrFileRead(&ImageBlock,1,sizeof(ImageBlock),fh) != sizeof(ImageBlock))
BR_ERROR1("Unable to read image data from '%s'",name);
/*
* check for local colourmap
*/
if(ImageBlock.imageflags & BR_GIF_COLOURMAP)
{
/*
* does local map contain more entries than global map
*/
local_palette_size = (1 << ((ImageBlock.imageflags & BR_GIF_COLOURMAP_SIZE)+1));
if(local_palette_size > global_palette_size)
{
BrPixelmapFree(palette);
palette = BrPixelmapAllocate(BR_PMT_RGBX_888,1,256,NULL,0);
palette->identifier=BrResStrDup(palette,name);
}
for(i=0;i<local_palette_size;i++)
{
if(BrFileRead(&RGB,1,sizeof(RGB),fh) != sizeof(RGB))
BR_ERROR1("Unable to read local palette data from '%s'",name);
((char *)(palette->pixels))[i*4+RED] = RGB.red;
((char *)(palette->pixels))[i*4+GRN] = RGB.green;
((char *)(palette->pixels))[i*4+BLU] = RGB.blue;
((char *)(palette->pixels))[i*4+PAD] = 0;
}
}
/* get initial code size and allocate pixelmap */
if(BrFileRead(&ch,1,1,fh) != 1)
BR_ERROR1("Unable to read image data from '%s'",name);
pm = BrPixelmapAllocate(BR_PMT_INDEX_8,ImageBlock.width,ImageBlock.depth,NULL,0);
pm->identifier = BrResStrDup(pm, name);
pm->map = palette;
if(UnpackImage(pm,ch,fh) == NULL)
BR_ERROR1("Unable to read image data from '%s'",name);
break;
case(EXTENSION):SkipExtension(fh);
} break;
}
BrFileClose(fh);
return pm;
}
static void *UnpackImage(br_pixelmap *pm,short bits,void *fh)
{
short bits2; /* bits + 1 */
short codesize; /* current code size in bits */
short codesize2; /* next codesize */
short nextcode; /* next available table entry */
short thiscode; /* code being expanded */
short oldtoken; /* last symbol decoded */
short currentcode; /* code just read */
short oldcode; /* code read before this one */
short bitsleft; /* number of bits left in *p */
short blocksize; /* bytes in next block */
short line=0; /* next line to write */
short byte=0; /* next byte to write */
short pass=0; /* pass number for interlaced pictures */
char *p; /* pointer to current byte in read buffer */
char *q; /* pointer past last byte in read buffer */
char b[255]; /* read buffer */
char *u; /* stack pointer into firstcodestack */
char *linebuffer; /* place to store current line */
static char firstcodestack[4096]; /* stack for first codes */
static char lastcodestack[4096]; /* stack for previous codes */
static short codestack[4096]; /* stack for links */
static short wordmasktable[] = {
0x0000,0x0001,0x0003,0x0007,
0x000f,0x001f,0x003f,0x007f,
0x00ff,0x01ff,0x03ff,0x07ff,
0x0fff,0x1fff,0x3fff,0x7fff
};
static short inctable[] = { 8,8,4,2,0 }; /* interlace increments */
static short starttable[] = { 0,4,2,1,0 }; /* interlace starts */
p = q = b;
bitsleft = 8;
if(bits < 2 || bits > 8) return BAD_SYMBOLSIZE;
bits2 = 1 << bits;
nextcode = bits2+2;
codesize2 = 1 << (codesize = bits + 1);
oldcode = oldtoken = NO_CODE;
linebuffer = BrMemAllocate(pm->width,BR_MEMORY_SCRATCH);
for(;;)
{
if(bitsleft == 8)
{
if(++p >= q &&
(((blocksize = BrFileGetChar(fh)) < 1) ||
(q = (p = b) + BrFileRead(b,1,blocksize,fh)) < (b+blocksize)))
{
BrMemFree(linebuffer);
return UNEXPECTED_EOF;
}
bitsleft = 0;
}
thiscode = *p;
if((currentcode=(codesize + bitsleft)) <= 8)
{
*p >>= codesize;
bitsleft = currentcode;
}
else
{
if(++p >= q &&
(((blocksize = BrFileGetChar(fh)) < 1) ||
(q = (p = b)+BrFileRead(b,1,blocksize,fh)) < (b+blocksize)))
{
BrMemFree(linebuffer);
return UNEXPECTED_EOF;
}
thiscode |= *p << (8-bitsleft);
if(currentcode <= 16)
*p >>= (bitsleft = currentcode-8);
else
{
if(++p >= q &&
(((blocksize = BrFileGetChar(fh)) <1) ||
(q = (p = b) + BrFileRead(b,1,blocksize,fh)) < (b+blocksize)))
{
BrMemFree(linebuffer);
return UNEXPECTED_EOF;
}
thiscode |= *p << (16-bitsleft);
*p >>= (bitsleft = currentcode-16);
}
}
thiscode &= wordmasktable[codesize];
currentcode = thiscode;
if(thiscode == (bits2+1)) break; /* found EOI */
if(thiscode > nextcode)
{
BrMemFree(linebuffer);
return BAD_CODE;
}
if(thiscode == bits2)
{
nextcode = bits2+2;
codesize2 = 1 << (codesize = (bits+1));
oldtoken = oldcode = NO_CODE;
continue;
}
u = firstcodestack;
if(thiscode == nextcode)
{
if(oldcode == NO_CODE)
{
BrMemFree(linebuffer);
return BAD_FIRSTCODE;
}
*u++ = (char)oldtoken;
thiscode = oldcode;
}
while (thiscode >= bits2)
{
*u++ = lastcodestack[thiscode];
thiscode = codestack[thiscode];
}
oldtoken = thiscode;
do
{
linebuffer[byte++] = (char)thiscode;
if(byte >= pm->width)
{
CopyLine(pm,linebuffer,line);
byte = 0;
/* check for interlaced image */
if(ImageBlock.imageflags & BR_GIF_IMAGE_INTERLACED)
{
line += inctable[pass];
if(line >= pm->height)
line = starttable[++pass];
}
else ++line;
}
if(u<=firstcodestack) break;
thiscode = *--u;
}
while(1);
if(nextcode < 4096 && oldcode != NO_CODE)
{
codestack[nextcode] = oldcode;
lastcodestack[nextcode] = (char)oldtoken;
if(++nextcode >= codesize2 && codesize < 12)
codesize2 = 1 << ++codesize;
}
oldcode = currentcode;
}
BrMemFree(linebuffer);
return pm;
}
static void CopyLine(br_pixelmap *pm,char *linebuffer,short line)
{
if(line>=0 && line<pm->height)
BrMemCpy((char *)pm->pixels+line*pm->row_bytes,linebuffer,pm->width);
}
static void SkipExtension(void *fh)
{
unsigned char ch;
ch=BrFileGetChar(fh); /* Extension type */
/* */
/* 0x0001 Plain text descriptor */
/* 0x00f9 Graphic control block */
/* 0x00fe Comment extension */
/* 0x00ff Application extension */
ch=BrFileGetChar(fh); /* block size */
BrFileAdvance(ch,fh);
}

262
core/fmt/loadiff.c Normal file
View File

@ -0,0 +1,262 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: loadiff.c 1.1 1997/12/10 16:41:02 jon Exp $
* $Locker: $
*
* Loader for Amiga .IFF/.LBM format
* support for 8 bit index palette based
*/
#include "brender.h"
#include "fmt.h"
BR_RCS_ID("$Id: loadiff.c 1.1 1997/12/10 16:41:02 jon Exp $")
static int readline(char *mblock,int bytes,void *fh);
static void planes2bytes(br_pixelmap *pm,char *block,int line);
#define RED 2
#define GRN 1
#define BLU 0
#define PAD 3
#define PACKET_SIZE 4 /* block size */
#define MAX_PALETTE 768 /* 256 colours */
#define RUN_LENGTH 0x80 /* rle bit field */
#define BITMAP_HEADER "BMHD"
#define COLOUR_MAP "CMAP"
#define IMAGE_DATA "BODY"
#define swapl(n) (((n & 0xff000000) >> 24) + \
((n & 0x00ff0000) >> 8) + \
((n & 0x0000ff00) << 8) + \
((n & 0x000000ff) <<24))
#define swapi(n) (((n & 0xff00) >> 8) | \
((n & 0x00ff) << 8))
#define pixels2bytes(n) ((n+7)/8)
#pragma pack (1)
static struct {
char type[4]; /* iff/lbm sig, 'FORM','LIST' or 'CAT ' */
unsigned int size; /* swapl(n) approx. size of file */
char subtype[4]; /* 'ILBM' - image planes or 'PBM ' - byte oriented */
} IFFheader;
static struct {
unsigned short w; /* width of image in pixels */
unsigned short h; /* height of image in pixels */
short x; /* x coord of uppr left of image relative to screen */
short y; /* y coord or uppr left of image relative to screen */
char nPlanes; /* number of colour planes required to display image (n/a)*/
char masking; /* image data interleaved with mask */
/* 0 - no mask, 1 - mask */
/* 2 - mask with transparent colour, 3 - lasso mask */
char compression; /* 0 - uncompressed image data, 1 - compressed (rle) */
char padl; /* pad byte n/a */
unsigned short transparentColour; /* colour index in image considered transparent */
char xAspect; /* aspect ratio */
char yAspect; /* aspect ratio */
short pageW; /* size of source screen */
short pageH; /* size of source screen */
} BMHD;
static struct {
char red;
char green;
char blue;
} RGB;
static unsigned char masktable[8] = {0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01 };
static unsigned char bittable[8] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80 };
#pragma pack ()
br_pixelmap * BR_PUBLIC_ENTRY BrFmtIFFLoad(char *name,br_uint_32 flags)
{
void *fh;
int open_mode = BR_FS_MODE_BINARY;
br_pixelmap *pm,*palette;
char block[4],*mblock;
unsigned int block_length;
br_uint_16 i,palette_size;
int bytes_per_line;
fh = BrFileOpenRead(name,0,NULL,&open_mode);
if(fh == NULL)
BR_ERROR1("Could not open '%s' for reading",name);
if(BrFileRead(&IFFheader,1,sizeof(IFFheader),fh) != sizeof(IFFheader))
BR_ERROR1("Unable to read header information from '%s'",name);
if(!BrMemCmp(IFFheader.type,"FORM",4) ||
!BrMemCmp(IFFheader.type,"LIST",4) ||
!BrMemCmp(IFFheader.type,"CAT ",4))
{
do
{
if(BrFileRead(block,1,PACKET_SIZE,fh) != PACKET_SIZE)
BR_ERROR1("Unable to read block descriptor from '%s'",name);
if(BrFileRead(&block_length,1,PACKET_SIZE,fh) != PACKET_SIZE)
BR_ERROR1("Unable to read block length from '%s'",name);
block_length = swapl(block_length);
if(block_length & 1)
++block_length; /* make block size even */
if(!BrMemCmp(block,BITMAP_HEADER,4))
{
/*
* Image block information header
*/
if(BrFileRead(&BMHD,1,sizeof(BMHD),fh) != sizeof(BMHD))
BR_ERROR1("Unable to read bitmap header in '%s'",name);
BMHD.w = swapi(BMHD.w);
BMHD.h = swapi(BMHD.h);
if(!BrMemCmp(IFFheader.subtype,"ILBM",4))
bytes_per_line = pixels2bytes(BMHD.w) * BMHD.nPlanes;
else
bytes_per_line = BMHD.w;
}
else if(!BrMemCmp(block,COLOUR_MAP,4))
{
/*
* Palette
*/
if(block_length <= MAX_PALETTE)
{
palette_size = block_length/3;
palette = BrPixelmapAllocate(BR_PMT_RGBX_888,1,256,NULL,0);
palette->identifier = BrResStrDup(palette, name);
for(i=0; i<palette_size; i++)
{
if(BrFileRead(&RGB,1,sizeof(RGB),fh) != sizeof(RGB))
BR_ERROR1("Unable to read palette from '%s'",name);
((char *)(palette->pixels))[i*4+RED] = RGB.red;
((char *)(palette->pixels))[i*4+GRN] = RGB.green;
((char *)(palette->pixels))[i*4+BLU] = RGB.blue;
((char *)(palette->pixels))[i*4+PAD] = 0;
}
}
}
else if(!BrMemCmp(block,IMAGE_DATA,4))
{
/*
* Raw image data
*/
pm = BrPixelmapAllocate(BR_PMT_INDEX_8,BMHD.w,BMHD.h,NULL,0);
pm->identifier = BrResStrDup(pm, name);
mblock = BrMemAllocate(bytes_per_line,BR_MEMORY_SCRATCH);
for(i=0;i<BMHD.h;i++)
{
if(BMHD.compression)
{
if(readline(mblock,bytes_per_line,fh) != bytes_per_line)
BR_ERROR1("Unable to read image data from '%s'",name);
}
else
{
if(BrFileRead(mblock,1,bytes_per_line,fh) != bytes_per_line)
BR_ERROR1("Unable to read image data from '%s'",name);
}
if(!BrMemCmp(IFFheader.subtype,"ILBM",4) ||
(!BrMemCmp(IFFheader.subtype,"PBM ",4) &&
BMHD.nPlanes < 8))
/* bitmap split into image planes */
planes2bytes(pm,mblock,i);
else
/* planar data */
BrMemCpy((char *)pm->pixels+i*pm->row_bytes,mblock,BMHD.w);
}
BrMemFree(mblock);
}
else BrFileAdvance(block_length,fh); /* skip unknown block */
}
while(!BrFileEof(fh) && BrMemCmp(block,IMAGE_DATA,4));
pm->map = palette; /* palette may be after image block in file */
BrFileClose(fh);
return pm;
}
else
BR_ERROR1("'%s' is not a valid IFF file",name);
return NULL;
}
static int readline(char *mblock,int bytes,void *fh)
{
short c,i, n = 0;
do
{
c = BrFileGetChar(fh) & 0xff;
if(c & RUN_LENGTH) /* run length */
{
if(c != 0x80)
{
i = ((~c) & 0xff)+2;
c = BrFileGetChar(fh);
while(i--)
mblock[n++] = (char)c;
}
}
else /* string */
{
i = (c & 0xff)+1;
while(i--)
mblock[n++] = BrFileGetChar(fh);
}
}
while(n < bytes);
return n;
}
static void planes2bytes(br_pixelmap *pm,char *block,int line)
{
int i,j,n;
char *src;
n = pixels2bytes(BMHD.w);
for(i=0;i<BMHD.w;++i) /* scan through pixels */
{
((char *)(pm->pixels))[line*pm->row_bytes+i] = 0;
src = block;
for(j=0; j<BMHD.nPlanes; ++j) /* fetch each planar pixel */
{
if(src[(i >> 3)] & masktable[i & 0x0007])
((char *)(pm->pixels))[line*pm->row_bytes+i] |= bittable[j];
src += n;
}
}
}

370
core/fmt/loadnff.c Normal file
View File

@ -0,0 +1,370 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: loadnff.c 1.1 1997/12/10 16:41:02 jon Exp $
* $Locker: $
*
* Loader for Eric Haines' NFF format
*/
#include "brender.h"
BR_RCS_ID("$Id: loadnff.c 1.1 1997/12/10 16:41:02 jon Exp $")
/*
* Current line buffer
*/
#define MAX_LINE 256
static char line[MAX_LINE];
/*
* Maintain a list of unique vertices
*/
static int used_vertices = 0;
#define VTX_POOL_SIZE 1024
#define VTX_HASH_SIZE 65536
typedef struct nff_vertex {
struct nff_vertex *next;
struct nff_vertex *hash_next;
br_vector3 v;
int n;
} nff_vertex;
static nff_vertex *temp_vertex_pool = NULL;
static nff_vertex *temp_vertex_hash[VTX_HASH_SIZE];
static nff_vertex *temp_vertex_chain;
static int pool_vertices = 0;
static void **pool_chain = NULL;
static int AddVertex(br_scalar x, br_scalar y, br_scalar z)
{
nff_vertex *vp;
int hash;
void **pp;
/*
* make hash value from X,Y & Z bit patterns
*
* Assumes that br_scalar is at least as big as 2 shorts
*/
hash = ((br_uint_16 *)&x)[0] + ((br_uint_16 *)&x)[1] +
((br_uint_16 *)&y)[0] + ((br_uint_16 *)&y)[1] +
((br_uint_16 *)&z)[0] + ((br_uint_16 *)&z)[1];
hash = hash % VTX_HASH_SIZE;
/*
* See if vertex already exists
*/
for(vp=temp_vertex_hash[hash]; vp; vp = vp->hash_next)
if(vp->v.v[0] == x && vp->v.v[1] == y && vp->v.v[2] == z)
return vp->n;
/*
* Create new vertex
*/
if(pool_vertices <=0) {
/*
* Refill pool (pool blocks are linked by pointers in first
*/
pp = BrResAllocate(NULL, VTX_POOL_SIZE * sizeof(*temp_vertex_pool) + sizeof (void *),BR_MEMORY_APPLICATION);
*pp = pool_chain;
pool_chain = pp;
temp_vertex_pool = (nff_vertex *)(pp+1);
pool_vertices = VTX_POOL_SIZE;
}
vp = temp_vertex_pool++;
pool_vertices--;
/*
* Fill in new vertex
*/
vp->v.v[0] = x;
vp->v.v[1] = y;
vp->v.v[2] = z;
/*
* Add new vertex to appropriate hash chain
*/
vp->hash_next = temp_vertex_hash[hash];
temp_vertex_hash[hash] = vp;
/*
* Add vertex to general chain
*/
vp->next = temp_vertex_chain;
temp_vertex_chain = vp;
return vp->n = used_vertices++;
}
/*
* Maintain a list of faces
*/
static int used_faces = 0;
static int allocated_faces = 0;
#define FACEALLOC_MIN 256
struct nff_face {
int v[3];
int patch;
};
static struct nff_face *temp_faces = NULL;
static int AddFace(int v1, int v2, int v3,int patch)
{
struct nff_face *fp;
/*
* Create new face
*/
if(used_faces >= allocated_faces) {
/*
* Allocate a new buffer if this one will overflow
*/
if(allocated_faces < FACEALLOC_MIN)
allocated_faces = FACEALLOC_MIN;
else
allocated_faces *= 2;
fp = BrResAllocate(NULL, sizeof(*fp) * allocated_faces, BR_MEMORY_APPLICATION);
BrMemCpy(fp,temp_faces,used_faces * sizeof(*fp));
BrResFree(temp_faces);
temp_faces = fp;
}
temp_faces[used_faces].v[0] = v1;
temp_faces[used_faces].v[1] = v2;
temp_faces[used_faces].v[2] = v3;
temp_faces[used_faces].patch = patch;
return used_faces++;
}
/*
* Read a line from input file, detecting EOF
*/
static void NextLine(void *fh)
{
if(BrFileGetLine(line,MAX_LINE,fh) == 0)
BR_ERROR0("Unexpected end of file");
}
br_model * BR_PUBLIC_ENTRY BrFmtNFFLoad(char *name)
{
void *fh;
int i,n;
char *cp;
br_model *model;
nff_vertex *vp;
void **pp,**next_pp;
int open_mode = BR_FS_MODE_TEXT;
fh = BrFileOpenRead(name,0,NULL,&open_mode);
if(fh == NULL)
BR_ERROR1("Could not open '%s' for reading",name);
/*
* Read lines from the input file
*/
while(!BrFileEof(fh)) {
BrFileGetLine(line,MAX_LINE,fh);
cp = line;
/*
* Eat white space of front of line
*/
/*
* Switch on the primitive
*/
switch(*cp++) {
/*
* Comment for the rest of the line
*/
case '#':
continue;
break;
/*
* viewing vectors and angles
*/
case 'v': {
float x,y,z,tx,ty,tz,ux,uy,uz,angle,hither;
int rx,ry;
NextLine(fh);
BrSScanf(line,"from %g %g %g",&x,&y,&z);
NextLine(fh);
BrSScanf(line,"at %g %g %g",&tx,&ty,&tz);
NextLine(fh);
BrSScanf(line,"up %g %g %g",&ux,&uy,&uz);
NextLine(fh);
BrSScanf(line,"angle %g",&angle);
NextLine(fh);
BrSScanf(line,"hither %g",&hither);
NextLine(fh);
BrSScanf(line,"resolution %d %d",&rx,&ry);
}
break;
/*
* background color
*/
case 'b': {
float r,g,b;
n = BrSScanf(cp,"%g %g %g",&r,&g,&b);
}
break;
/*
* positional light location
*/
case 'l': {
float x,y,z,r,g,b;
n = BrSScanf(cp,"%g %g %g %g %g %g",
&x,&y,&z,&r,&g,&b);
}
break;
/*
* object material properties
*/
case 'f': {
float r,g,b,kd,ks,shine,t,ior;
n = BrSScanf(cp,"%g %g %g %g %g %g %g %g",
&r,&g,&b,&kd,&ks,&shine,&t,&ior);
}
break;
/*
* cone or cylinder primitive
*/
case 'c': {
float bx,by,bz,br,ax,ay,az,ar;
NextLine(fh);
n = BrSScanf(line,"%g %g %g %g",&bx,&by,&bz,&br);
NextLine(fh);
n = BrSScanf(line,"%g %g %g %g",&ax,&ay,&az,&ar);
}
break;
/*
* sphere primitive
*/
case 's': {
float x,y,z,r;
n = BrSScanf(cp,"%g %g %g %g",&x,&y,&z,&r);
}
break;
/*
* polygon or patch primitive
*/
case 'p': {
float vx,vy,vz,nx,ny,nz;
int num_vertices,patch = 0;
int verts[3];
if(*cp == 'p') {
cp++;
patch = 1;
}
/*
* Find number of vertices from rest of line
*/
BrSScanf(cp,"%d",&num_vertices);
if(num_vertices <3)
BR_ERROR1("polygon has too few vertices: %d",num_vertices);
/*
* Process each line of polygon
*/
for(i=0; i< num_vertices; i++) {
NextLine(fh);
n = BrSScanf(line,"%g %g %g %g %g %g",
&vx,&vy,&vz,&nx,&ny,&nz);
if(n != (patch?6:3))
BR_ERROR1("Wrong number of components for vertex - %d",n);
if(i < 2) {
verts[i] = AddVertex(BrFloatToScalar(vx),
BrFloatToScalar(vy),
BrFloatToScalar(vz));
} else {
verts[2] = AddVertex(BrFloatToScalar(vx),
BrFloatToScalar(vy),
BrFloatToScalar(vz));
AddFace(verts[0],verts[1],verts[2],patch);
verts[1] = verts[2];
}
}
}
break;
/*
* Unknown
*/
default:
BR_ERROR1("FmtNFFLoad: Unknown NFF primitive - '%c'",*(cp-1));
break;
}
}
/*
* Convert temporary buffers into a model for p3d
*/
model = BrModelAllocate("nff_object",used_vertices,used_faces);
for(i=0, vp =temp_vertex_chain; i < used_vertices && vp; i++, vp=vp->next) {
model->vertices[vp->n].p.v[0] = vp->v.v[0];
model->vertices[vp->n].p.v[1] = vp->v.v[1];
model->vertices[vp->n].p.v[2] = vp->v.v[2];
}
for(i=0; i < used_faces; i++) {
model->faces[i].vertices[0] = temp_faces[i].v[0];
model->faces[i].vertices[1] = temp_faces[i].v[1];
model->faces[i].vertices[2] = temp_faces[i].v[2];
model->faces[i].material = NULL;
#if 0
model->faces[i].smoothing = 1;
#else
model->faces[i].smoothing = temp_faces[i].patch;
#endif
}
/*
* Release temporary buffers
*/
BrResFree(temp_faces);
for(pp = pool_chain; pp; pp = next_pp) {
next_pp = *pp;
BrResFree(pp);
}
return model;
}

593
core/fmt/loadscr.c Normal file
View File

@ -0,0 +1,593 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: loadscr.c 1.2 1998/03/05 20:23:50 jon Exp $
* $Locker: $
*
* Load a Material Script file
*/
#include "brddi.h"
BR_RCS_ID("$Id: loadscr.c 1.2 1998/03/05 20:23:50 jon Exp $")
/*
* Default material fields
*/
br_material _DefaultScriptMaterial = {
0,
NULL,
BR_COLOUR_RGB(255,255,255), /* colour */
255, /* opacity */
BR_UFRACTION(0.10), /* Indexed ka */
BR_UFRACTION(0.70), /* kd */
BR_UFRACTION(0.0), /* ks */
BR_SCALAR(20), /* power */
BR_MATF_LIGHT, /* flags */
{{
BR_VECTOR2(1,0), /* map transform */
BR_VECTOR2(0,1),
BR_VECTOR2(0,0),
}},
BR_MATM_DEPTH_TEST_LE |
BR_MATM_BLEND_MODE_STANDARD |
BR_MATM_MAP_WIDTH_LIMIT_WRAP |
BR_MATM_MAP_HEIGHT_LIMIT_WRAP, /* mode */
0,63, /* index base/range */
};
enum {
/*
* Keywords
*/
T_MATERIAL = T_KEYWORD,
/*
* Members of material
*/
T_IDENTIFIER,
T_NAME,
T_FLAGS,
T_COLOUR,
T_OPACITY,
T_AMBIENT,
T_KA,
T_DIFFUSE,
T_KD,
T_SPECULAR,
T_KS,
T_POWER,
T_MAP_TRANSFORM,
T_INDEX_BASE,
T_INDEX_RANGE,
T_COLOUR_MAP,
T_SCREEN_DOOR,
T_INDEX_SHADE,
T_INDEX_BLEND,
T_FOG_MIN,
T_FOG_MAX,
T_FOG_COLOUR,
T_INDEX_FOG,
T_SUBDIVIDE_TOLERANCE,
T_DEPTH_TEST,
T_BLEND_MODE,
T_MAP_WIDTH_LIMIT,
T_MAP_HEIGHT_LIMIT,
/*
* Material flags
*/
T_LIGHT,
T_PRELIT,
T_SMOOTH,
T_GOURAUD,
T_ENVIRONMENT,
T_ENVIRONMENT_I,
T_ENVIRONMENT_LOCAL,
T_ENVIRONMENT_L,
T_PERSPECTIVE,
T_DECAL,
T_ALWAYS_VISIBLE,
T_TWO_SIDED,
T_FORCE_FRONT,
T_FORCE_BACK,
T_DITHER,
T_EXTRA_SURFACE,
T_EXTRA_PRIMITIVE,
T_MAP_ANTIALIASING,
T_MAP_INTERPOLATION,
T_MIP_INTERPOLATION,
T_FOG_LOCAL,
T_SUBDIVIDE,
T_QUAD_MAPPING,
T_INHIBIT_DEPTH_WRITE,
/*
* Depth test modes
*/
T_GT,
T_GE,
T_EQ,
T_NE,
T_LE,
T_LT,
T_NV,
T_AL,
/*
* Blend modes
*/
T_STANDARD,
T_SUMMED,
T_DIMMED,
T_PREMULTIPLIED,
/*
* Width and height limit modes
*/
T_WRAP,
T_CLAMP,
T_MIRROR,
};
static br_lexer_keyword keywords[] = {
{ "material", T_MATERIAL, },
{ "identifier", T_IDENTIFIER, },
{ "name", T_NAME, },
{ "flags", T_FLAGS, },
{ "colour", T_COLOUR, },
{ "opacity", T_OPACITY, },
{ "ambient", T_AMBIENT, },
{ "ka", T_KA, },
{ "diffuse", T_DIFFUSE, },
{ "kd", T_KD, },
{ "specular", T_SPECULAR, },
{ "ks", T_KS, },
{ "power", T_POWER, },
{ "map_transform", T_MAP_TRANSFORM, },
{ "index_base", T_INDEX_BASE, },
{ "index_range", T_INDEX_RANGE, },
{ "colour_map", T_COLOUR_MAP, },
{ "screen_door", T_SCREEN_DOOR, },
{ "index_shade", T_INDEX_SHADE, },
{ "index_blend", T_INDEX_BLEND, },
{ "depth_test", T_DEPTH_TEST, },
{ "blend_mode", T_BLEND_MODE, },
{ "map_width_limit", T_MAP_WIDTH_LIMIT, },
{ "map_height_limit", T_MAP_HEIGHT_LIMIT, },
{ "light", T_LIGHT, },
{ "prelit", T_PRELIT, },
{ "smooth", T_SMOOTH, },
{ "gouraud", T_GOURAUD, },
{ "environment", T_ENVIRONMENT, },
{ "environment_i", T_ENVIRONMENT_I, },
{ "environment_local", T_ENVIRONMENT_LOCAL, },
{ "environment_l", T_ENVIRONMENT_L, },
{ "perspective", T_PERSPECTIVE, },
{ "decal", T_DECAL, },
{ "always_visible", T_ALWAYS_VISIBLE, },
{ "two_sided", T_TWO_SIDED, },
{ "force_z_0", T_FORCE_FRONT, },
{ "force_front", T_FORCE_FRONT, },
{ "force_back", T_FORCE_BACK, },
{ "dither", T_DITHER, },
{ "extra_surface", T_EXTRA_SURFACE, },
{ "extra_primitive", T_EXTRA_PRIMITIVE, },
{ "map_antialiasing", T_MAP_ANTIALIASING, },
{ "map_interpolation", T_MAP_INTERPOLATION, },
{ "mip_interpolation", T_MIP_INTERPOLATION, },
{ "fog_local", T_FOG_LOCAL, },
{ "fog_min", T_FOG_MIN, },
{ "fog_max", T_FOG_MAX, },
{ "fog_colour", T_FOG_COLOUR, },
{ "index_fog", T_INDEX_FOG, },
{ "subdivide_tolerance", T_SUBDIVIDE_TOLERANCE, },
{ "subdivide", T_SUBDIVIDE, },
{ "quad_mapping", T_QUAD_MAPPING, },
{ "inhibit_depth_write", T_INHIBIT_DEPTH_WRITE, },
{ "gt", T_GT },
{ "ge", T_GE },
{ "eq", T_EQ },
{ "ne", T_NE },
{ "le", T_LE },
{ "lt", T_LT },
{ "nv", T_NV },
{ "al", T_AL },
{ "greater", T_GT },
{ "greater_or_equal", T_GE },
{ "equal", T_EQ },
{ "not_equal", T_NE },
{ "less_or_equal", T_LE },
{ "less", T_LT },
{ "never", T_NV },
{ "always", T_AL },
{ "standard", T_STANDARD, },
{ "summed", T_SUMMED, },
{ "dimmed", T_DIMMED, },
{ "premultiplied", T_PREMULTIPLIED, },
{ "wrap", T_WRAP, },
{ "clamp", T_CLAMP, },
{ "mirror", T_MIRROR, },
};
static void BrLexerPrintPos(struct br_lexer *l)
{
char pos[256];
BrLexerPosition(l,pos, BR_ASIZE(pos));
BR_WARNING1("In file %s", pos);
}
STATIC br_uint_32 ParseMatFlags(br_lexer *l)
{
br_uint_32 f = 0;
BrLexerExpect(l,T_LSQUARE);
if(BrLexerCurrent(l) == T_RSQUARE) {
BrLexerAdvance(l);
return 0;
}
/*
* Read flag keywords until ]
*/
for(;;) {
switch(BrLexerCurrent(l)) {
case T_LIGHT: f |= BR_MATF_LIGHT; break;
case T_PRELIT: f |= BR_MATF_PRELIT; break;
case T_SMOOTH:
case T_GOURAUD: f |= BR_MATF_SMOOTH; break;
case T_ENVIRONMENT_I:
case T_ENVIRONMENT: f |= BR_MATF_ENVIRONMENT_I; break;
case T_ENVIRONMENT_L:
case T_ENVIRONMENT_LOCAL: f |= BR_MATF_ENVIRONMENT_L; break;
case T_PERSPECTIVE: f |= BR_MATF_PERSPECTIVE; break;
case T_DECAL: f |= BR_MATF_DECAL; break;
case T_ALWAYS_VISIBLE: f |= BR_MATF_ALWAYS_VISIBLE; break;
case T_TWO_SIDED: f |= BR_MATF_TWO_SIDED; break;
case T_FORCE_FRONT: f |= BR_MATF_FORCE_FRONT; break;
case T_FORCE_BACK: f |= BR_MATF_FORCE_BACK; break;
case T_DITHER: f |= BR_MATF_DITHER; break;
case T_MAP_ANTIALIASING: f |= BR_MATF_MAP_ANTIALIASING; break;
case T_MAP_INTERPOLATION: f |= BR_MATF_MAP_INTERPOLATION; break;
case T_MIP_INTERPOLATION: f |= BR_MATF_MIP_INTERPOLATION; break;
case T_FOG_LOCAL: f |= BR_MATF_FOG_LOCAL; break;
case T_SUBDIVIDE: f |= BR_MATF_SUBDIVIDE; break;
case T_QUAD_MAPPING: f |= BR_MATF_QUAD_MAPPING; break;
case T_INHIBIT_DEPTH_WRITE: f |= BR_MATF_INHIBIT_DEPTH_WRITE; break;
default:
BrLexerError(l, "Unknown material flag");
}
BrLexerAdvance(l);
if(BrLexerCurrent(l) == T_RSQUARE)
break;
BrLexerExpect(l,T_COMMA);
}
BrLexerExpect(l,T_RSQUARE);
return f;
}
STATIC br_material *ParseMaterial(br_lexer *l)
{
br_material *mat;
br_vector3 v3;
#if 0
br_token_value token_buffer[512];
int i;
#endif
mat = BrMaterialAllocate(NULL);
*mat = _DefaultScriptMaterial;
/*
* material = [
*/
BrLexerExpect(l,T_MATERIAL);
BrLexerExpect(l,T_EQUAL);
BrLexerExpect(l,T_LSQUARE);
while(BrLexerCurrent(l) != T_RSQUARE) {
switch(BrLexerCurrent(l)) {
case T_IDENTIFIER:
case T_NAME:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL); BrLexerCheck(l,T_STRING);
mat->identifier = BrResStrDup(mat,BrLexerString(l));
BrLexerAdvance(l);
break;
case T_FLAGS:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
mat->flags = ParseMatFlags(l);
break;
case T_COLOUR:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
if(BrParseVector(l, &v3.v[0],3) != 3)
BrLexerError(l,"Colour has too few entries");
mat->colour = BR_COLOUR_RGB(
BrScalarToInt(v3.v[0]),
BrScalarToInt(v3.v[1]),
BrScalarToInt(v3.v[2]));
break;
case T_OPACITY:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
mat->opacity = (br_uint_8)BrParseInteger(l);
break;
case T_KA:
case T_AMBIENT:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
mat->ka = (br_ufraction)BrParseScalar(l);
break;
case T_KD:
case T_DIFFUSE:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
mat->kd = (br_ufraction)BrParseScalar(l);
break;
case T_KS:
case T_SPECULAR:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
mat->ks = (br_ufraction)BrParseScalar(l);
break;
case T_POWER:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
mat->power = BrParseScalar(l);
break;
case T_MAP_TRANSFORM:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
BrParseMatrix(l, &mat->map_transform.m[0][0],2,3);
break;
case T_DEPTH_TEST:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
switch (BrLexerCurrent(l)) {
case T_GT:
mat->mode = (mat->mode & ~BR_MATM_DEPTH_TEST_MASK) | BR_MATM_DEPTH_TEST_GT;
break;
case T_GE:
mat->mode = (mat->mode & ~BR_MATM_DEPTH_TEST_MASK) | BR_MATM_DEPTH_TEST_GE;
break;
case T_EQ:
mat->mode = (mat->mode & ~BR_MATM_DEPTH_TEST_MASK) | BR_MATM_DEPTH_TEST_EQ;
break;
case T_NE:
mat->mode = (mat->mode & ~BR_MATM_DEPTH_TEST_MASK) | BR_MATM_DEPTH_TEST_NE;
break;
case T_LE:
mat->mode = (mat->mode & ~BR_MATM_DEPTH_TEST_MASK) | BR_MATM_DEPTH_TEST_LE;
break;
case T_LT:
mat->mode = (mat->mode & ~BR_MATM_DEPTH_TEST_MASK) | BR_MATM_DEPTH_TEST_LT;
break;
case T_NV:
mat->mode = (mat->mode & ~BR_MATM_DEPTH_TEST_MASK) | BR_MATM_DEPTH_TEST_NV;
break;
case T_AL:
mat->mode = (mat->mode & ~BR_MATM_DEPTH_TEST_MASK) | BR_MATM_DEPTH_TEST_AL;
break;
default:
BrLexerError(l, "Unknown depth test mode");
}
BrLexerAdvance(l);
break;
case T_BLEND_MODE:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
switch (BrLexerCurrent(l)) {
case T_STANDARD:
mat->mode = (mat->mode & ~BR_MATM_BLEND_MODE_MASK) | BR_MATM_BLEND_MODE_STANDARD;
break;
case T_SUMMED:
mat->mode = (mat->mode & ~BR_MATM_BLEND_MODE_MASK) | BR_MATM_BLEND_MODE_SUMMED;
break;
case T_DIMMED:
mat->mode = (mat->mode & ~BR_MATM_BLEND_MODE_MASK) | BR_MATM_BLEND_MODE_DIMMED;
break;
case T_PREMULTIPLIED:
mat->mode = (mat->mode & ~BR_MATM_BLEND_MODE_MASK) | BR_MATM_BLEND_MODE_PREMULTIPLIED;
break;
default:
BrLexerError(l, "Unknown blend mode");
}
BrLexerAdvance(l);
break;
case T_MAP_WIDTH_LIMIT:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
switch (BrLexerCurrent(l)) {
case T_WRAP:
mat->mode = (mat->mode & ~BR_MATM_MAP_WIDTH_LIMIT_MASK) | BR_MATM_MAP_WIDTH_LIMIT_WRAP;
break;
case T_CLAMP:
mat->mode = (mat->mode & ~BR_MATM_MAP_WIDTH_LIMIT_MASK) | BR_MATM_MAP_WIDTH_LIMIT_CLAMP;
break;
case T_MIRROR:
mat->mode = (mat->mode & ~BR_MATM_MAP_WIDTH_LIMIT_MASK) | BR_MATM_MAP_WIDTH_LIMIT_MIRROR;
break;
default:
BrLexerError(l, "Unknown width limit mode");
}
BrLexerAdvance(l);
break;
case T_MAP_HEIGHT_LIMIT:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
switch (BrLexerCurrent(l)) {
case T_WRAP:
mat->mode = (mat->mode & ~BR_MATM_MAP_HEIGHT_LIMIT_MASK) | BR_MATM_MAP_HEIGHT_LIMIT_WRAP;
break;
case T_CLAMP:
mat->mode = (mat->mode & ~BR_MATM_MAP_HEIGHT_LIMIT_MASK) | BR_MATM_MAP_HEIGHT_LIMIT_CLAMP;
break;
case T_MIRROR:
mat->mode = (mat->mode & ~BR_MATM_MAP_HEIGHT_LIMIT_MASK) | BR_MATM_MAP_HEIGHT_LIMIT_MIRROR;
break;
default:
BrLexerError(l, "Unknown width limit mode");
}
BrLexerAdvance(l);
break;
case T_INDEX_BASE:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
mat->index_base = (br_uint_8)BrParseInteger(l);
break;
case T_INDEX_RANGE:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
mat->index_range = (br_uint_8)BrParseInteger(l);
break;
case T_SUBDIVIDE_TOLERANCE:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
mat->subdivide_tolerance = (br_int_32)BrParseInteger(l);
break;
case T_COLOUR_MAP:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL); BrLexerCheck(l,T_STRING);
mat->colour_map = BrMapFind(BrLexerString(l));
BrLexerAdvance(l);
break;
case T_SCREEN_DOOR:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL); BrLexerCheck(l,T_STRING);
mat->screendoor = BrTableFind(BrLexerString(l));
BrLexerAdvance(l);
break;
case T_INDEX_SHADE:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL); BrLexerCheck(l,T_STRING);
mat->index_shade = BrTableFind(BrLexerString(l));
BrLexerAdvance(l);
break;
case T_INDEX_BLEND:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL); BrLexerCheck(l,T_STRING);
mat->index_blend = BrTableFind(BrLexerString(l));
BrLexerAdvance(l);
break;
#if 0
case T_EXTRA_SURFACE:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL); BrLexerCheck(l,T_STRING);
BrStringToTokenValue(token_buffer, sizeof(token_buffer),BrLexerString(l));
mat->extra_surf = index_blend = BrTableFind(BrLexerString(l));
BrLexerAdvance(l);
break;
#endif
case T_FOG_MIN:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
mat->fog_min = BrParseScalar(l);
break;
case T_FOG_MAX:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
mat->fog_max = BrParseScalar(l);
break;
case T_FOG_COLOUR:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL);
if(BrParseVector(l, &v3.v[0],3) != 3)
BrLexerError(l,"Fog colour has too few entries");
mat->fog_colour = BR_COLOUR_RGB(
BrScalarToInt(v3.v[0]),
BrScalarToInt(v3.v[1]),
BrScalarToInt(v3.v[2]));
break;
case T_INDEX_FOG:
BrLexerAdvance(l); BrLexerExpect(l,T_EQUAL); BrLexerCheck(l,T_STRING);
mat->index_fog = BrTableFind(BrLexerString(l));
BrLexerAdvance(l);
break;
default:
BrLexerPrintPos(l);
BR_WARNING1("Incorrect material member '%s' ignored",BrLexerString(l));
while (BrLexerCurrent(l) != T_SEMICOLON)
BrLexerAdvance(l);
}
BrLexerExpect(l,T_SEMICOLON);
}
/*
* ];
*/
BrLexerAdvance(l);
BrLexerExpect(l,T_SEMICOLON);
return mat;
};
static void BR_CALLBACK lexerError(struct br_lexer *l, char *string)
{
char pos[256];
BrLexerPosition(l,pos, BR_ASIZE(pos));
BR_FAILURE2("%s%s", pos, string);
}
#if 0
#include <stdio.h>
void BR_CALLBACK dumpLine(char *str, void *arg)
{
puts(str);
}
#endif
br_uint_32 BR_PUBLIC_ENTRY BrFmtScriptMaterialLoadMany(char *filename,br_material **materials,br_uint_16 num)
{
int count;
br_lexer *l;
br_error r;
l = BrLexerAllocate(keywords, BR_ASIZE(keywords));
if(l == NULL)
return 0;
BrLexerCommentSet(l,'#');
BrLexerErrorSet(l,lexerError);
#if 0
BrLexerDumpSet(l, dumpLine, NULL);
#endif
r = BrLexerPushFile(l,filename);
if(r != BRE_OK) {
BrLexerFree(l);
return 0;
}
/*
* Start up the pipleline
*/
BrLexerAdvance(l);
for (count=0; BrLexerCurrent(l) != T_EOF && count<num; count++)
materials[count] = ParseMaterial(l);
BrLexerFree(l);
return count;
}
br_material * BR_PUBLIC_ENTRY BrFmtScriptMaterialLoad(char *filename)
{
br_material *ptr;
return (BrFmtScriptMaterialLoadMany(filename,&ptr,1) != 1)?NULL:ptr;
}

588
core/fmt/loadtga.c Normal file
View File

@ -0,0 +1,588 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: loadtga.c 1.1 1997/12/10 16:41:02 jon Exp $
* $Locker: $
*
* Loader for .TGA format
* support for: 8 bit index palette based (16,24 bit palette)
* 15,16,24,32 bit true colour
* 15 & 16 bit are the same except for 1 field in header. (bits)
* mono (1 bit) bit not supported here
*/
#include "brender.h"
#include "fmt.h"
BR_RCS_ID("$Id: loadtga.c 1.1 1997/12/10 16:41:02 jon Exp $")
#define RED 2
#define GRN 1
#define BLU 0
#define PAD 3
#define YES 1
#define NO 0
static void * ReadLine_Uncomp_8(char *line,void *fh); /* 8 bit indexed, uncompressed */
static void * ReadLine_Comp_8(char *line,void *fh); /* 8 bit indexed, compressed */
static void * ReadLine_Uncomp_16(char *line,void *fh); /* 16 bit, uncompressed */
static void * ReadLine_Comp_16(char *line,void *fh); /* 16 bit, compressed */
static void * ReadLine_Uncomp_24(char *line,void *fh); /* 24 bit, uncompressed */
static void * ReadLine_Comp_24(char *line,void *fh); /* 24 bit, compressed */
static void * ReadLine_Uncomp_32(char *line,void *fh); /* 32 bit, uncompressed */
static void * ReadLine_Comp_32(char *line,void *fh); /* 32 bit, compressed */
static void CopyLine_8(br_pixelmap *pm,char *line,int row);
static void CopyLine_16(br_pixelmap *pm,char *line,int row);
static void CopyLine_24(br_pixelmap *pm,char *line,int row);
static void CopyLine_32(br_pixelmap *pm,char *line,int row);
enum {
BR_TGA_UNCOMPRESSED_PALETTE = 0x01,
BR_TGA_UNCOMPRESSED_RGB = 0x02,
BR_TGA_UNCOMPRESSED_MONO = 0x03, /* not supported here */
BR_TGA_COMPRESSED_PALETTE = 0x09,
BR_TGA_COMPRESSED_RGB = 0x0a,
BR_TGA_COMPRESSED_MONO = 0x0b /* not supported here */
};
enum {
BR_TGA_REVERSED_WIDTH = 0x10, /* right to left */
BR_TGA_REVERSED_DEPTH = 0x20 /* bottom to top */
};
static struct {
char image_type;
char pixel_bits;
char supported;
void * (*read_func)(char *line,void *fh); /* read 1 line of image data from file */
void (*copy_func)(br_pixelmap *map,char *line,int row); /* copy 1 line of data to pixelmap */
} Supported_TGA_types[]={
{BR_TGA_UNCOMPRESSED_PALETTE , 8, YES, ReadLine_Uncomp_8, CopyLine_8},
{BR_TGA_UNCOMPRESSED_RGB , 15, YES, ReadLine_Uncomp_16, CopyLine_16},
{BR_TGA_UNCOMPRESSED_RGB , 16, YES, ReadLine_Uncomp_16, CopyLine_16},
{BR_TGA_UNCOMPRESSED_RGB , 24, YES, ReadLine_Uncomp_24, CopyLine_24},
{BR_TGA_UNCOMPRESSED_RGB , 32, YES, ReadLine_Uncomp_32, CopyLine_32},
{BR_TGA_UNCOMPRESSED_MONO , 1, NO, NULL, NULL},
{BR_TGA_COMPRESSED_PALETTE , 8, YES, ReadLine_Comp_8, CopyLine_8},
{BR_TGA_COMPRESSED_RGB , 15, YES, ReadLine_Comp_16, CopyLine_16},
{BR_TGA_COMPRESSED_RGB , 16, YES, ReadLine_Comp_16, CopyLine_16},
{BR_TGA_COMPRESSED_RGB , 24, YES, ReadLine_Comp_24, CopyLine_24},
{BR_TGA_COMPRESSED_RGB , 32, YES, ReadLine_Comp_32, CopyLine_32},
{BR_TGA_COMPRESSED_MONO , 1, NO, NULL, NULL},
};
/*
* TGA header, this format allows for structure packing by compiler
*/
#pragma pack(1)
static struct {
char identsize; /* number of bytes between header and whatever next */
char colourmaptype; /* type of colourmap in file 0=RGB, 1=palette */
char imagetype; /* type of storage of image */
unsigned short colourmapstart; /* first colour index used in palette */
unsigned short colourmaplength; /* number of colours in palette from colourmapstart */
char colourmapbits; /* size of entry in palette table */
unsigned short xstart; /* offset between uppr lft of image & uppr lft of screen*/
unsigned short ystart;
unsigned short width; /* width in pixels */
unsigned short depth; /* depth in pixels */
char bits; /* number of bits of colour: 1,8,16,24,32 */
char descriptor; /* bit 5 : set, image stored starting with last line */
/* bit 4 : set, image stored pixels right to left */
/* bits 0-3: number of bits available for overlays (n/a)*/
} TGAheader;
static unsigned short RGB_16;
static struct {
char blue,green,red;
} RGB_24;
static struct {
char blue,green,red,x;
} RGB_32;
#pragma pack()
br_pixelmap * BR_PUBLIC_ENTRY BrFmtTGALoad(char *name,br_uint_32 flags)
{
void *fh;
int open_mode = BR_FS_MODE_BINARY,i;
br_pixelmap *pm;
br_uint_8 type;
br_int_32 ystart,yend,dy;
br_uint_32 bytes_per_line,palette_size;
unsigned char *mblock,supported;
fh = BrFileOpenRead(name,0,NULL,&open_mode);
if(fh == NULL)
BR_ERROR1("Could not open '%s' for reading",name);
if(BrFileRead(&TGAheader,1,sizeof(TGAheader),fh) !=sizeof(TGAheader))
BR_ERROR1("Unable to read header information from '%s'",name);
for(i=0,supported= 255; i<BR_ASIZE(Supported_TGA_types); i++)
if((Supported_TGA_types[i].image_type == TGAheader.imagetype) &
(Supported_TGA_types[i].pixel_bits == TGAheader.bits) &&
(Supported_TGA_types[i].supported))
supported=i;
if(supported == 255)
BR_ERROR2("TGA image type %d in file '%s' not supported",TGAheader.imagetype,name);
switch(TGAheader.bits)
{
case(8):type = BR_PMT_INDEX_8;
bytes_per_line = TGAheader.width;
palette_size = TGAheader.colourmaplength;
break;
case(15):type = BR_PMT_RGB_555;
bytes_per_line = TGAheader.width*2;
palette_size = 0;
break;
case(16):type = BR_PMT_RGB_565;
bytes_per_line = TGAheader.width*2;
palette_size = 0;
break;
case(24):type = BR_PMT_RGB_888;
bytes_per_line = TGAheader.width*3;
palette_size = 0;
break;
case(32):/*
* If flags & BR_PMT_RGBA_8888, pixelmap->type = flags
*/
type = (flags & BR_PMT_RGBA_8888)?BR_PMT_RGBA_8888:BR_PMT_RGBX_888;
bytes_per_line = TGAheader.width*4;
palette_size = 0;
break;
default:BR_ERROR2("%d bit TGA file '%s' not supported",TGAheader.bits,name);
break;
}
if(!(TGAheader.descriptor & BR_TGA_REVERSED_DEPTH))
{
ystart = TGAheader.depth-1;
yend = -1;
dy = -1;
}
else
{
ystart = 0;
yend = TGAheader.depth;
dy = 1;
}
/*
* Advance to start of palette/image, allocate pixelmap for image data
*/
BrFileAdvance(TGAheader.identsize,fh);
pm = BrPixelmapAllocate(type,TGAheader.width,TGAheader.depth,NULL,0);
pm->identifier=BrResStrDup(pm,name);
/*
* Get palette,allocate pixelmap for palette data
*/
if(TGAheader.colourmaptype)
{
switch(TGAheader.bits)
{
/*
* Allow for nasties that have true colour image with palette
*/
default:BrFileAdvance(TGAheader.colourmaplength * (( TGAheader.colourmapbits ) >> 3),fh);
break;
case(8):pm->map = BrPixelmapAllocate(BR_PMT_RGBX_888,1,256,NULL,0);
pm->map->identifier=BrResStrDup(pm->map,name);
switch(TGAheader.colourmapbits)
{
case(16):for(i=TGAheader.colourmapstart; i<TGAheader.colourmaplength; i++)
{
if(i >= 256) break;
if(BrFileRead(&RGB_16,1,sizeof(RGB_16),fh) != sizeof(RGB_16))
BR_ERROR1("Unable to read palette from '%s'",name);
((char *)(pm->map->pixels))[i*4+RED] = ((RGB_16 ) & 0x1f) << 3;
((char *)(pm->map->pixels))[i*4+GRN] = ((RGB_16 >> 5 ) & 0x1f) << 3;
((char *)(pm->map->pixels))[i*4+BLU] = ((RGB_16 >> 10) & 0x1f) << 3;
((char *)(pm->map->pixels))[i*4+PAD] = 0;
}
break;
case(24):for(i=TGAheader.colourmapstart; i<TGAheader.colourmaplength; i++)
{
if(i >= 256) break;
if(BrFileRead(&RGB_24,1,sizeof(RGB_24),fh) != sizeof(RGB_24))
BR_ERROR1("Unable to read palette from '%s'",name);
((char *)(pm->map->pixels))[i*4+RED] = RGB_24.red;
((char *)(pm->map->pixels))[i*4+GRN] = RGB_24.green;
((char *)(pm->map->pixels))[i*4+BLU] = RGB_24.blue;
((char *)(pm->map->pixels))[i*4+PAD] = 0;
}
break;
}
break;
}
}
/*
* Get image data
*/
mblock = BrMemAllocate(bytes_per_line,BR_MEMORY_SCRATCH);
for(i=ystart; i!=yend; i+=dy)
{
if(Supported_TGA_types[supported].read_func(mblock,fh) == NULL)
BR_ERROR1("Unable to read image data from '%s'",name);
Supported_TGA_types[supported].copy_func(pm,mblock,i);
}
BrFileClose(fh);
return pm;
}
static void *ReadLine_Uncomp_8(char *line,void *fh)
{
if(BrFileRead(line,1,TGAheader.width,fh) != TGAheader.width)
return NULL;
else
return line;
}
static void * ReadLine_Comp_8(char *line,void *fh)
{
unsigned char ch;
br_uint_32 size,n = 0;
int i;
do
{
if(BrFileRead(&ch,1,1,fh) != 1)
return NULL;
size = (ch & 0x7f)+1;
if(ch & 0x80) /* run of pixels */
{
if(BrFileRead(&ch,1,1,fh) != 1)
return NULL;
for(i=0; i< (int)size; i++)
line[n+i] = ch;
}
else /* string */
{
for(i=0; i<(int)size; i++)
{
if(BrFileRead(&ch,1,1,fh) != 1)
return NULL;
line[n+i] = ch;
}
}
n += size;
}
while (n < TGAheader.width);
return line;
}
static void * ReadLine_Uncomp_16(char *line,void *fh)
{
int i;
for(i=0;i<TGAheader.width;i++)
{
if(BrFileRead(&RGB_16,1,sizeof(RGB_16),fh) != sizeof(RGB_16))
return NULL;
line[i*2] = RGB_16 & 0xff;
line[i*2+1] = (RGB_16 >> 8) &0xff;
}
return line;
}
static void * ReadLine_Comp_16(char *line,void *fh)
{
unsigned char ch;
br_uint_32 size,n = 0;
int i;
do
{
if(BrFileRead(&ch,1,1,fh) != 1)
return NULL;
size = (ch & 0x7f)+1;
if(ch & 0x80) /* run of pixels */
{
if(BrFileRead(&RGB_16,1,sizeof(RGB_16),fh) != sizeof(RGB_16))
return NULL;
for(i=0; i<(int)size; i++)
{
line[(n+i)*2] = RGB_16 & 0xff;
line[(n+i)*2+1] = (RGB_16 >> 8) &0xff;
}
}
else /* string */
{
for(i=0; i<(int)size; i++)
{
if(BrFileRead(&RGB_16,1,sizeof(RGB_16),fh) != sizeof(RGB_16))
return NULL;
line[(n+i)*2] = RGB_16 & 0xff;
line[(n+i)*2+1] = (RGB_16 >> 8) &0xff;
}
}
n += size;
}
while (n < TGAheader.width);
return line;
}
static void * ReadLine_Uncomp_24(char *line,void *fh)
{
int i;
for(i=0;i<TGAheader.width;i++)
{
if(BrFileRead(&RGB_24,1,sizeof(RGB_24),fh) != sizeof(RGB_24))
return NULL;
line[i*3] = RGB_24.blue;
line[i*3+1] = RGB_24.green;
line[i*3+2] = RGB_24.red;
}
return line;
}
static void * ReadLine_Comp_24(char *line,void *fh)
{
unsigned char ch;
br_uint_32 size,n = 0;
int i;
do
{
if(BrFileRead(&ch,1,1,fh) != 1)
return NULL;
size = (ch & 0x7f)+1;
if(ch & 0x80) /* run of pixels */
{
if(BrFileRead(&RGB_24,1,sizeof(RGB_24),fh) != sizeof(RGB_24))
return NULL;
for(i=0; i<(int)size; i++)
{
line[(n+i)*3] = RGB_24.blue;
line[(n+i)*3+1] = RGB_24.green;
line[(n+i)*3+2] = RGB_24.red;
}
}
else /* string */
{
for(i=0; i<(int)size; i++)
{
if(BrFileRead(&RGB_24,1,sizeof(RGB_24),fh) != sizeof(RGB_24))
return NULL;
line[(n+i)*3] = RGB_24.blue;
line[(n+i)*3+1] = RGB_24.green;
line[(n+i)*3+2] = RGB_24.red;
}
}
n += size;
}
while (n < TGAheader.width);
return line;
}
static void * ReadLine_Uncomp_32(char *line,void *fh)
{
int i;
for(i=0;i<TGAheader.width;i++)
{
if(BrFileRead(&RGB_32,1,sizeof(RGB_32),fh) != sizeof(RGB_32))
return NULL;
line[i*4] = RGB_32.blue;
line[i*4+1] = RGB_32.green;
line[i*4+2] = RGB_32.red;
line[i*4+3] = RGB_32.x;
}
return line;
}
static void * ReadLine_Comp_32(char *line,void *fh)
{
unsigned char ch;
br_uint_32 size,n = 0;
int i;
do
{
if(BrFileRead(&ch,1,1,fh) != 1)
return NULL;
size = (ch & 0x7f)+1;
if(ch & 0x80) /* run of pixels */
{
if(BrFileRead(&RGB_32,1,sizeof(RGB_32),fh) != sizeof(RGB_32))
return NULL;
for(i=0; i<(int)size; i++)
{
line[(n+i)*4] = RGB_32.blue;
line[(n+i)*4+1] = RGB_32.green;
line[(n+i)*4+2] = RGB_32.red;
line[(n+i)*4+3] = RGB_32.red;
}
}
else /* string */
{
for(i=0; i<(int)size; i++)
{
if(BrFileRead(&RGB_32,1,sizeof(RGB_32),fh) != sizeof(RGB_32))
return NULL;
line[(n+i)*4] = RGB_32.blue;
line[(n+i)*4+1] = RGB_32.green;
line[(n+i)*4+2] = RGB_32.red;
line[(n+i)*4+3] = RGB_32.x;
}
}
n += size;
}
while (n < TGAheader.width);
return line;
}
static void CopyLine_8(br_pixelmap *pm,char *line,int row)
{
br_int_32 xstart,xend,dx;
int i,j;
if(TGAheader.descriptor & BR_TGA_REVERSED_WIDTH)
{
xstart = TGAheader.width-1;
xend = -1;
dx = -1;
}
else
{
xstart = 0;
xend = TGAheader.width;
dx = 1;
}
for(i=xstart,j=0; i!=xend; i+=dx,j++)
((char *)(pm->pixels))[(row*pm->row_bytes)+j]=line[i];
}
static void CopyLine_16(br_pixelmap *pm,char *line,int row)
{
br_int_32 xstart,xend,dx;
int i,j;
if(TGAheader.descriptor & BR_TGA_REVERSED_WIDTH)
{
xstart = TGAheader.width-1;
xend = -1;
dx = -1;
}
else
{
xstart = 0;
xend = TGAheader.width;
dx = 1;
}
for(i=xstart*2,j=0; i!=xend*2; i+=dx*2,j+=2)
{
((char *)(pm->pixels))[(row*pm->row_bytes)+j] = line[i ];
((char *)(pm->pixels))[(row*pm->row_bytes)+j+1] = line[i + dx];
}
}
static void CopyLine_24(br_pixelmap *pm,char *line,int row)
{
br_int_32 xstart,xend,dx;
int i,j;
if(TGAheader.descriptor & BR_TGA_REVERSED_WIDTH)
{
xstart = TGAheader.width-1;
xend = -1;
dx = -1;
}
else
{
xstart = 0;
xend = TGAheader.width;
dx = 1;
}
for(i=xstart*3,j=0; i!=xend*3; i+=dx*3,j+=3)
{
((char *)(pm->pixels))[(row*pm->row_bytes)+j] = line[i ];
((char *)(pm->pixels))[(row*pm->row_bytes)+j+1] = line[i + dx];
((char *)(pm->pixels))[(row*pm->row_bytes)+j+2] = line[i + dx*2];
}
}
static void CopyLine_32(br_pixelmap *pm,char *line,int row)
{
br_int_32 xstart,xend,dx;
int i,j;
if(TGAheader.descriptor & BR_TGA_REVERSED_WIDTH)
{
xstart = TGAheader.width-1;
xend = -1;
dx = -1;
}
else
{
xstart = 0;
xend = TGAheader.width;
dx = 1;
}
for(i=xstart*4,j=0; i!=xend*4; i+=dx*4,j+=4)
{
((char *)(pm->pixels))[(row*pm->row_bytes)+j] = line[i];
((char *)(pm->pixels))[(row*pm->row_bytes)+j+1] = line[i + dx];
((char *)(pm->pixels))[(row*pm->row_bytes)+j+2] = line[i + dx*2];
((char *)(pm->pixels))[(row*pm->row_bytes)+j+3] = line[i + dx*3];
}
}

173
core/fmt/loadvue.c Normal file
View File

@ -0,0 +1,173 @@
/*
* Copyright (c) 1993-1997 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: loadvue.c 1.1 1997/12/10 16:41:02 jon Exp $
* $Locker: $
*
* Loader for vue format
*
* TODO hierarchy support
*/
#include "brender.h"
#include "fmt.h"
BR_RCS_ID("$Id: loadvue.c 1.1 1997/12/10 16:41:02 jon Exp $")
//***************************************************************
// Allocate a vue
//***************************************************************
br_vue * BR_PUBLIC_ENTRY BrVueAllocate(int nframes, int ntransforms)
{
br_vue *vue;
//UASSERT(nframes >= 0);
//UASSERT(ntransforms >= 0);
vue = BrResAllocate(NULL,sizeof(*vue),BR_MEMORY_SCRATCH);
vue->frames = BrResAllocate(vue,sizeof(*vue->frames)*nframes,BR_MEMORY_SCRATCH);
vue->frames->transforms = BrResAllocate(vue,sizeof(*vue->frames->transforms)*ntransforms,BR_MEMORY_SCRATCH);
vue->nframes = nframes; // max number of frames
vue->ntransforms = ntransforms; // max number of transforms per frame
vue->frame_delta =1; // default frame step
return vue;
}
//***************************************************************
//***************************************************************
// Free a vue
//***************************************************************
void BR_PUBLIC_ENTRY BrVueFree(br_vue *vue)
{
BrResFree(vue);
}
//***************************************************************
//***************************************************************
// Grutuitously ripped off from robot.c!
//***************************************************************
void BR_PUBLIC_ENTRY BrLoadVUE(char *file_name, br_actor * root, br_vue *vue)
{
void *fileh;
int total_frames;
static int first=0;
int f = -1, i;
char buff[1024];
char name[80];
float v[4][3];
struct vue_transform *t =vue->frames->transforms ;
fileh = BrFileOpenRead(file_name,0,NULL,NULL);
if(fileh == NULL)
BR_ERROR1("Could not open '%s' for reading",file_name);
while (!BrFileEof(fileh)) {
BrFileGetLine(buff, 1024, fileh);
/* Is it a frame specification line? */
if (BrSScanf(buff, "frame %d", &i) > 0) {
if (f >= 0)
vue->frames[f].ntransforms = t - vue->frames[f].transforms;
else
first=i;
f = i-first;
vue->frames[f].transforms = t;
}
/* Or a transform specification? */
if (BrSScanf(buff,
"transform \"%[^\"]\" %f %f %f %f %f %f %f %f %f %f %f %f",
name,
&v[0][0], &v[0][1], &v[0][2],
&v[1][0], &v[1][1], &v[1][2],
&v[2][0], &v[2][1], &v[2][2],
&v[3][0], &v[3][1], &v[3][2]) > 0
) {
int k, l;
/* Found a transform so convert it to scalars */
for (k = 0; k < 4; k++)
for (l = 0; l < 3; l++)
t->mat.m[k][l] = BrFloatToScalar(v[k][l]);
// Corelates frame identifier with actor identifier.
t->actor = BrActorSearch(root, name);
if (t->actor != NULL)
t++;
}
}
BrFileClose(fileh);
if (f > 0)
vue->frames[f].ntransforms = t - vue->frames[f].transforms;
total_frames = f + 1;
vue->nframes=total_frames;
}
//***************************************************************
//***************************************************************
// Yes you guessed it, more grutuitous rip offs from robot.c!
//***************************************************************
// does the animation
//***************************************************************
void BR_PUBLIC_ENTRY BrApplyVue( br_vue *vue, br_actor * actors)
{
int i;
static br_transform store_root_transform;
int total_frames=vue->nframes;
int frame_delta=vue->frame_delta;
// Store current root actor transform.
BrTransformToTransform(&store_root_transform, &(actors->t));
// Play VUE file by loading transforms into actors.
if (total_frames != 0)
{
// Clamp frame number to valid range.
if (vue->current_frame < 0)
vue->current_frame = total_frames - 1;
if (vue->current_frame >= total_frames)
vue->current_frame = 0;
// Apply animation to world.
if (frame_delta != 0)
for (i = 0; i < vue->frames[vue->current_frame].ntransforms; i++)
vue->frames[vue->current_frame].transforms[i].actor->t.t.mat =
vue->frames[vue->current_frame].transforms[i].mat;
// Move to next frame.
vue->current_frame += frame_delta;
}
// Restore current world transform.
BrTransformToTransform(&(actors->t), &store_root_transform);
}
//***************************************************************

36
core/fmt/makefile Normal file
View File

@ -0,0 +1,36 @@
# Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
#
# $Id: makefile 1.1 1997/12/10 17:16:27 jon Exp $
# $Locker: $
#
# Makefile for BRender foreign file format support
#
.IMPORT: BR_SOURCE_DIR BR_MAKEFILE BR_TARGET_DIR BR_MAKE_DIR
LIB_PART:=brfm
TARGET_TYPE:=LIB
## Base library object files
##
OBJS_C=\
$(BLD_DIR)/load3ds$(OBJ_EXT)\
$(BLD_DIR)/loadasc$(OBJ_EXT)\
$(BLD_DIR)/loadbmp$(OBJ_EXT)\
$(BLD_DIR)/loadgif$(OBJ_EXT)\
$(BLD_DIR)/loadiff$(OBJ_EXT)\
$(BLD_DIR)/loadnff$(OBJ_EXT)\
$(BLD_DIR)/loadscr$(OBJ_EXT)\
$(BLD_DIR)/loadtga$(OBJ_EXT)\
$(BLD_DIR)/savescr$(OBJ_EXT)\
$(BLD_DIR)/loadvue$(OBJ_EXT)\
OBJS_ASM=\
EXPORT_INCLUDES=\
$(INC_DIR)/fmt.h\
$(INC_DIR)/fmt_p.h\
.INCLUDE: $(BR_MAKE_DIR)/$(BR_MAKEFILE)

247
core/fmt/savescr.c Normal file
View File

@ -0,0 +1,247 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: savescr.c 1.2 1998/03/05 20:24:07 jon Exp $
* $Locker: $
*
* Save a Material Script file
*/
#include "brender.h"
#include "fmt.h"
BR_RCS_ID("$Id: savescr.c 1.2 1998/03/05 20:24:07 jon Exp $")
/*
* The default material used to load a script
*/
extern br_material _DefaultScriptMaterial;
STATIC struct {
char *name;
int value;
} MaterialFlagNames[] = {
{ "light" , BR_MATF_LIGHT },
{ "prelit" , BR_MATF_PRELIT },
{ "smooth" , BR_MATF_SMOOTH },
{ "environment" , BR_MATF_ENVIRONMENT_I },
{ "environment_local" , BR_MATF_ENVIRONMENT_L },
{ "perspective" , BR_MATF_PERSPECTIVE },
{ "decal" , BR_MATF_DECAL },
{ "always_visible" , BR_MATF_ALWAYS_VISIBLE },
{ "two_sided" , BR_MATF_TWO_SIDED },
{ "force_front" , BR_MATF_FORCE_FRONT },
{ "force_back" , BR_MATF_FORCE_BACK },
{ "dither" , BR_MATF_DITHER },
{ "map_antialiasing" , BR_MATF_MAP_ANTIALIASING },
{ "map_interpolation" , BR_MATF_MAP_INTERPOLATION },
{ "mip_interpolation" , BR_MATF_MIP_INTERPOLATION },
{ "subdivide" , BR_MATF_SUBDIVIDE },
{ "fog_local" , BR_MATF_FOG_LOCAL },
{ "quad_mapping" , BR_MATF_QUAD_MAPPING },
{ "inhibit_depth_write" , BR_MATF_INHIBIT_DEPTH_WRITE},
};
STATIC struct {
char *name;
int value;
} DepthTestNames[] = {
{ "gt" , BR_MATM_DEPTH_TEST_GT },
{ "ge" , BR_MATM_DEPTH_TEST_GE },
{ "eq" , BR_MATM_DEPTH_TEST_EQ },
{ "ne" , BR_MATM_DEPTH_TEST_NE },
{ "le" , BR_MATM_DEPTH_TEST_LE },
{ "lt" , BR_MATM_DEPTH_TEST_LT },
{ "nv" , BR_MATM_DEPTH_TEST_NV },
{ "al" , BR_MATM_DEPTH_TEST_AL },
};
STATIC struct {
char *name;
int value;
} BlendModeNames[] = {
{ "standard" , BR_MATM_BLEND_MODE_STANDARD },
{ "summed" , BR_MATM_BLEND_MODE_SUMMED },
{ "dimmed" , BR_MATM_BLEND_MODE_DIMMED },
{ "premultiplied" , BR_MATM_BLEND_MODE_PREMULTIPLIED },
};
STATIC struct {
char *name;
int value;
} WidthLimitNames[] = {
{ "wrap" , BR_MATM_MAP_WIDTH_LIMIT_WRAP },
{ "clamp" , BR_MATM_MAP_WIDTH_LIMIT_CLAMP },
{ "mirror" , BR_MATM_MAP_WIDTH_LIMIT_MIRROR },
};
STATIC struct {
char *name;
int value;
} HeightLimitNames[] = {
{ "wrap" , BR_MATM_MAP_HEIGHT_LIMIT_WRAP },
{ "clamp" , BR_MATM_MAP_HEIGHT_LIMIT_CLAMP },
{ "mirror" , BR_MATM_MAP_HEIGHT_LIMIT_MIRROR },
};
STATIC void WriteScriptMaterial(br_material *mat, void *df)
{
int i,j;
BrFilePrintf(df,"\nmaterial = [\n");
if(mat->identifier)
BrFilePrintf(df," identifier = \"%s\";\n",mat->identifier);
/*
* Flags
*/
if(mat->flags != _DefaultScriptMaterial.flags) {
BrFilePrintf(df," flags = [");
for(i=0,j=0; i < BR_ASIZE(MaterialFlagNames); i++)
if(mat->flags & MaterialFlagNames[i].value) {
BrFilePrintf(df,"%s%s",j?", ":"",MaterialFlagNames[i].name);
j++;
}
BrFilePrintf(df,"];\n");
}
/*
* Lighting parameters
*/
if(mat->colour != _DefaultScriptMaterial.colour)
BrFilePrintf(df," colour = [%d,%d,%d];\n",
BR_RED(mat->colour),
BR_GRN(mat->colour),
BR_BLU(mat->colour));
if(mat->opacity != _DefaultScriptMaterial.opacity)
BrFilePrintf(df," opacity = %d;\n",mat->opacity);
if(mat->ka != _DefaultScriptMaterial.ka)
BrFilePrintf(df," ambient = %f;\n",BrScalarToFloat(BrUFractionToScalar(mat->ka)));
if(mat->kd != _DefaultScriptMaterial.kd)
BrFilePrintf(df," diffuse = %f;\n",BrScalarToFloat(BrUFractionToScalar(mat->kd)));
if(mat->ks != _DefaultScriptMaterial.ks)
BrFilePrintf(df," specular = %f;\n",BrScalarToFloat(BrUFractionToScalar(mat->ks)));
if(mat->power != _DefaultScriptMaterial.power)
BrFilePrintf(df," power = %f;\n",BrScalarToFloat(mat->power));
if(mat->index_base != _DefaultScriptMaterial.index_base)
BrFilePrintf(df," index_base = %d;\n",mat->index_base);
if(mat->index_range != _DefaultScriptMaterial.index_range)
BrFilePrintf(df," index_range = %d;\n",mat->index_range);
/*
* Map Transform
*/
for(i=0; i < 3; i++)
if(mat->map_transform.m[i][0] != _DefaultScriptMaterial.map_transform.m[i][0] ||
mat->map_transform.m[i][1] != _DefaultScriptMaterial.map_transform.m[i][1])
break;
if( i < 3) {
/*
* Matrices were different
*/
BrFilePrintf(df," map_transform = [\n");
for(i=0; i < 3; i ++)
BrFilePrintf(df,
" [%f,%f]%s\n",
BrScalarToFloat(mat->map_transform.m[i][0]),
BrScalarToFloat(mat->map_transform.m[i][1]),
i != 2?",":"");
BrFilePrintf(df," ];\n");
}
if((mat->mode & BR_MATM_DEPTH_TEST_MASK) != (_DefaultScriptMaterial.mode & BR_MATM_DEPTH_TEST_MASK))
for (i = 0; i < BR_ASIZE(DepthTestNames); i++)
if ((mat->mode & BR_MATM_DEPTH_TEST_MASK) == DepthTestNames[i].value) {
BrFilePrintf(df," depth_test = %s;\n",DepthTestNames[i].name);
break;
}
if((mat->mode & BR_MATM_BLEND_MODE_MASK) != (_DefaultScriptMaterial.mode & BR_MATM_BLEND_MODE_MASK))
for (i = 0; i < BR_ASIZE(BlendModeNames); i++)
if ((mat->mode & BR_MATM_BLEND_MODE_MASK) == BlendModeNames[i].value) {
BrFilePrintf(df," blend_mode = %s;\n",BlendModeNames[i].name);
break;
}
if((mat->mode & BR_MATM_MAP_WIDTH_LIMIT_MASK) != (_DefaultScriptMaterial.mode & BR_MATM_MAP_WIDTH_LIMIT_MASK))
for (i = 0; i < BR_ASIZE(WidthLimitNames); i++)
if ((mat->mode & BR_MATM_MAP_WIDTH_LIMIT_MASK) == WidthLimitNames[i].value) {
BrFilePrintf(df," map_width_limit = %s;\n",WidthLimitNames[i].name);
break;
}
if((mat->mode & BR_MATM_MAP_HEIGHT_LIMIT_MASK) != (_DefaultScriptMaterial.mode & BR_MATM_MAP_HEIGHT_LIMIT_MASK))
for (i = 0; i < BR_ASIZE(HeightLimitNames); i++)
if ((mat->mode & BR_MATM_MAP_HEIGHT_LIMIT_MASK) == HeightLimitNames[i].value) {
BrFilePrintf(df," map_height_limit = %s;\n",HeightLimitNames[i].name);
break;
}
/*
* Maps and Tables
*/
if(mat->colour_map && mat->colour_map->identifier)
BrFilePrintf(df," colour_map = \"%s\";\n",mat->colour_map->identifier);
if(mat->screendoor && mat->screendoor->identifier)
BrFilePrintf(df," screendoor = \"%s\";\n",mat->screendoor->identifier);
if(mat->index_shade && mat->index_shade->identifier)
BrFilePrintf(df," index_shade = \"%s\";\n",mat->index_shade->identifier);
if(mat->index_blend && mat->index_blend->identifier)
BrFilePrintf(df," index_blend = \"%s\";\n",mat->index_blend->identifier);
BrFilePrintf(df,"];\n");
}
/*
* Write out a material script
*/
br_uint_32 BR_PUBLIC_ENTRY BrFmtScriptMaterialSaveMany(char *filename,br_material **materials,br_uint_16 num)
{
void *df;
int i,count;
/*
* Open file and write header
*/
df = BrFileOpenWrite(filename,1);
if(df == NULL)
return 0;
/*
* Write a header
*/
BrFilePutLine("# BRender Material Script",df);
BrFilePutLine("#",df);
if(materials) {
for(i=0; i<num; i++)
WriteScriptMaterial(materials[i],df);
count = num;
} else {
BrMaterialEnum(NULL,(br_material_enum_cbfn *)WriteScriptMaterial,df);
count = BrMaterialCount(NULL);
}
BrFileClose(df);
return count;
}
br_uint_32 BR_PUBLIC_ENTRY BrFmtScriptMaterialSave(char *filename, br_material *ptr)
{
return BrFmtScriptMaterialSaveMany(filename,&ptr,1);
}

178
core/fw/assocarr.c Normal file
View File

@ -0,0 +1,178 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: assocarr.c 1.3 1998/02/27 18:10:44 jon Exp $
* $Locker: $
*
* Associative array handling code
*/
#include "fw.h"
#include <brassert.h>
#define MAX_ELEMENTS_INCREMENT 32
br_associative_array *BrAssociativeArrayAllocate()
{
br_associative_array *array;
array = (br_associative_array *)BrResAllocate(fw.res, sizeof(br_associative_array), BR_MEMORY_TOKEN_VALUE);
if (array == NULL)
return NULL;
array->tv = NULL;
array->max_elements = 0;
array->num_elements = 0;
return array;
}
br_error BrAssociativeArraySet(br_associative_array *array, br_token t, br_value v)
{
br_token_value *tv = NULL;
char *string;
br_uint_32 i;
ASSERT(array);
/*
* Look for the key in the array
*/
for (i = 0; i < array->num_elements; i++)
if (array->tv[i].t == t) {
tv = &array->tv[i];
break;
}
/*
* Add the key to the array if necessary
*/
if (tv == NULL) {
/*
* If necessary, expand the array
*/
if (array->num_elements >= array->max_elements) {
tv = (br_token_value *)BrResAllocate(array, (array->max_elements + MAX_ELEMENTS_INCREMENT) * sizeof(br_token_value), BR_MEMORY_APPLICATION );
if (tv == NULL)
return BRE_FAIL;
if (array->tv != NULL) {
BrMemCpy(tv, array->tv, array->num_elements * sizeof(br_token_value));
BrResFree(array->tv);
}
array->tv = tv;
array->max_elements += MAX_ELEMENTS_INCREMENT;
}
tv = &array->tv[array->num_elements];
array->num_elements++;
tv->t = t;
}
/*
* Copy the data, duplicating all strings. Other references are
* copied so they must remain valid if they are to be used
*/
switch (BrTokenType(tv->t)) {
case BRT_STRING:
if (v.str != NULL) {
string = BrResStrDup(array, v.str);
if (string == NULL)
return BRE_FAIL;
} else
string = NULL;
if (tv->v.str != NULL)
BrResFree(tv->v.str);
tv->v.str = string;
break;
default:
tv->v = v;
break ;
}
return BRE_OK;
}
br_error BrAssociativeArrayQuery(br_associative_array *array, br_token t, br_value *v)
{
br_uint_32 i;
ASSERT(array);
/*
* Look for the key in the array
*/
for (i = 0; i < array->num_elements; i++)
if (array->tv[i].t == t) {
/*
* Copy the data - string references are not duplicated, so
* they must be duplicated if they will be needed after the array
* is freed or the key is set to a new value
*/
*v = array->tv[i].v;
return BRE_OK;
}
return BRE_FAIL;
}
br_error BrAssociativeArrayRemove(br_associative_array *array, br_token t)
{
br_uint_32 i;
/*
* Look for the key in the array
*/
for (i = 0; i < array->num_elements; i++)
if (array->tv[i].t == t) {
/*
* Delete the old string copy if necessary
*/
if (BrTokenType(array->tv[i].t) == BRT_STRING && array->tv[i].v.str != NULL)
BrResFree(array->tv[i].v.str);
/*
* Copy the last element over to replace this one
*/
array->num_elements--;
array->tv[i] = array->tv[array->num_elements];
return BRE_OK;
}
return BRE_FAIL;
}

51
core/fw/blockops.asm Normal file
View File

@ -0,0 +1,51 @@
;; Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
;;
;; $Id: blockops.asm 1.1 1997/12/10 16:41:03 jon Exp $
;; $Locker: $
;;
;; Various operations on fixed 16.16 numbers
;;
.386p
.model flat,c
.data
db '$Id: blockops.asm 1.1 1997/12/10 16:41:03 jon Exp $',0
align 4
.code
; void BR_ASM_CALL BrBlockFill(void *dest_ptr, int value, int dwords);
;
BrBlockFill proc uses eax ecx edi es, dest:ptr dword, value:dword, count:dword
mov ax,ds
mov es,ax
mov eax,value
mov ecx,count
mov edi,dest
rep stosd
ret
BrBlockFill endp
; void BR_ASM_CALL BrBlockCopy(void *dest_ptr, void *src_ptr, int dwords);
;
BrBlockCopy proc uses ecx esi edi es, dest:ptr dword, src:ptr dword, count:dword
mov ax,ds
mov es,ax
mov esi,src
mov ecx,count
mov edi,dest
rep movsd
ret
BrBlockCopy endp
; void BR_ASM_CALL BrFarBlockCopy(void __far *dest_ptr, void *src_ptr, int dwords);
;
BrFarBlockCopy proc uses ecx esi edi es, dest:far ptr dword, src:ptr dword, count:dword
mov ecx,count
mov esi,src
les edi,dest
rep movsd
ret
BrFarBlockCopy endp
end

41
core/fw/blockops.h Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: blockops.h 1.1 1997/12/10 16:41:03 jon Exp $
* $Locker: $
*
* Memory operations, block fill, block copy etc. Thse are local to the
* library becuase some compiler's versions are not that good.
*/
#if defined(__WATCOMC__)
/*
* Inline block operations for Watcom C
*/
void BrIBlockFill(void *dest_ptr, int value, int dwords);
#pragma aux BrIBlockFill = \
"rep stosd" \
parm [edi] [eax] [ecx] ;
void BrIBlockCopy(void *dest_ptr, void *src_ptr, int dwords);
#pragma aux BrIBlockCopy = \
"rep movsd" \
parm [edi] [esi] [ecx] ;
/* Inline copy near block to far block
*/
void BrIFarBlockCopy(void __far *dest_ptr, void *src_ptr, int dwords);
#pragma aux BrIFarBlockCopy = \
"push es"\
"mov es,dx"\
"rep movsd"\
"pop es"\
parm [dx edi] [esi] [ecx] ;
#define BrBlockFill(d,v,c) BrIBlockFill(d,v,c)
#define BrBlockCopy(d,s,c) BrIBlockCopy(d,s,c)
#define BrFarBlockCopy(d,s,c) BrIFarBlockCopy(d,s,c)
#endif

45
core/fw/brassert.h Normal file
View File

@ -0,0 +1,45 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: brassert.h 1.1 1997/12/10 16:41:03 jon Exp $
* $Locker: $
*
* Assertion macros
*
* ASSERT() is for internal checks
* UASSERT() is for user checks
*/
/*
* This file should _NOT_ have checks for single inclusion -
* it is legitimate to re-include it with DEBUG or PARANOID set diffently
*/
#undef ASSERT
#if DEBUG
#define ASSERT(e) ((void)((e) || (_BrAssert(#e,__FILE__,__LINE__),1)))
#define ASSERT_MESSAGE(m,e) ((void)((e) || (_BrAssert(m " : " #e,__FILE__,__LINE__),1)))
void BR_RESIDENT_ENTRY _BrAssert(char *condition, char *file, unsigned line);
#define VERIFY(f) ASSERT(f)
#else
#define ASSERT(ignore) ((void) 0)
#define ASSERT_MESSAGE(ignore,ignoreMeToo) ((void) 0)
#define VERIFY(f) (void)(f)
#endif
#undef UASSERT
#if PARANOID
#define UASSERT(e) ((void)((e) || (_BrUAssert(#e,__FILE__,__LINE__),1)))
#define UASSERT_MESSAGE(m,e) ((void)((e) || (_BrUAssert(m " : " #e,__FILE__,__LINE__),1)))
void BR_RESIDENT_ENTRY _BrUAssert(char *condition, char *file, unsigned line);
#define UVERIFY(f) ASSERT(f)
#else
#define UASSERT(ignore) ((void) 0)
#define UASSERT_MESSAGE(ignore,ignoreMeToo) ((void) 0)
#define UVERIFY(f) (void)(f)
#endif

65
core/fw/brbegin.c Normal file
View File

@ -0,0 +1,65 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: brbegin.c 1.1 1997/12/10 16:41:03 jon Exp $
* $Locker: $
*
* Wrapper functions for all the various subsystem begins
*/
#include "fw.h"
#include "host.h"
#include <brassert.h>
BR_RCS_ID("$Id: brbegin.c 1.1 1997/12/10 16:41:03 jon Exp $")
static br_boolean active = BR_FALSE;
br_error BR_PUBLIC_ENTRY BrBegin(void)
{
if ( active )
return BRE_ALLREADY_ACTIVE;
/*
* Fire up other libraries
*/
BrFwBegin();
HostBegin();
BrPixelmapBegin();
active = BR_TRUE;
/*
* Call a hook that allows static devices at link time
*/
_BrBeginHook();
return BRE_OK;
}
br_error BR_PUBLIC_ENTRY BrEnd(void)
{
br_device *dev;
if(!active)
return BRE_NOT_ACTIVE;
_BrEndHook();
active = BR_FALSE;
/*
* Close down loaded devices
*/
while(BrDevFind(&dev, NULL) == BRE_OK)
if(dev)
BrDevRemove(dev);
BrPixelmapEnd();
HostEnd();
BrFwEnd();
return BRE_OK;
}

19
core/fw/brbhook.c Normal file
View File

@ -0,0 +1,19 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: brbhook.c 1.1 1997/12/10 16:41:03 jon Exp $
* $Locker: $
*
* DEfault begin/end hooks
*/
#include "brender.h"
BR_RCS_ID("$Id: brbhook.c 1.1 1997/12/10 16:41:03 jon Exp $")
void BR_CALLBACK _BrBeginHook(void)
{
}
void BR_CALLBACK _BrEndHook(void)
{
}

66
core/fw/brddi.h Normal file
View File

@ -0,0 +1,66 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: brddi.h 1.2 1998/11/12 13:14:23 johng Exp $
* $Locker: $
*
* Master include file for devices
*/
#ifndef _BRDDI_H_
#define _BRDDI_H_
#define __BRENDER_DDI__ BR_VERSION(1,1,0)
/*
* Pull in all the public definitions/declarations
*/
#ifndef _BRENDER_H_
#include "brender.h"
#endif
#ifndef _POOL_H_
#include "pool.h"
#endif
#ifndef _BREXCEPT_H_
#include "brexcept.h"
#endif
#ifndef _REGISTER_H_
#include "register.h"
#endif
#ifndef _TOKEN_H_
#include "token.h"
#endif
#ifndef _TOKENMAP_H_
#include "tokenmap.h"
#endif
#ifndef _LEXER_H_
#include "lexer.h"
#endif
#ifndef _BRIMAGE_H_
#include "brimage.h"
#endif
#ifndef _DEV_OBJS_H_
#include "dev_objs.cgh"
#endif
/*
* Pull in DDI prototypes
*/
#ifndef _NO_PROTOTYPES
#ifndef _BRDDI_P_H_
#include "brddi_p.h"
#endif
#endif
#endif

239
core/fw/brddi_p.h Normal file
View File

@ -0,0 +1,239 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: brddi_p.h 1.3 1998/11/12 13:14:55 johng Exp $
* $Locker: $
*
* Prototypes for functions that are exposed to device drivers
*/
#ifndef _BRDDI_P_H_
#define _BRDDI_P_H_
#ifndef _NO_PROTOTYPES
#ifdef __cplusplus
extern "C" {
#endif
br_boolean BR_RESIDENT_ENTRY BrNamePatternMatch(char *p, char *s);
/*
* Debugging printf
*/
int BR_RESIDENT_ENTRY BrLogPrintf(char *fmt,...);
/*
* resource.c
*/
br_uint_32 BR_RESIDENT_ENTRY BrResCheck(void *vres, int no_tag);
void BR_RESIDENT_ENTRY BrResDump(void *vres, br_putline_cbfn *putline, void *arg);
/*
* brexcept.c
*/
br_exception_handler * BR_RESIDENT_ENTRY _BrExceptionBegin(void);
void BR_RESIDENT_ENTRY _BrExceptionEnd(void);
void BR_RESIDENT_ENTRY _BrExceptionThrow(br_int_32 type, void *value);
br_exception BR_RESIDENT_ENTRY _BrExceptionValueFetch(br_exception type, void **evp);
void * BR_RESIDENT_ENTRY _BrExceptionResource(void);
/*
* error.c
*/
void BR_RESIDENT_ENTRY BrLastErrorSet(br_error type, void *value);
br_error BR_RESIDENT_ENTRY BrLastErrorGet(void **valuep);
/*
* token.c
*/
br_token BR_RESIDENT_ENTRY BrTokenCreate(char *identifier, br_token type);
char * BR_RESIDENT_ENTRY BrTokenIdentifier(br_token t);
br_token BR_RESIDENT_ENTRY BrTokenType(br_token t);
br_int_32 BR_RESIDENT_ENTRY BrTokenCount(char *pattern);
br_token BR_RESIDENT_ENTRY BrTokenFind(char *pattern);
br_int_32 BR_RESIDENT_ENTRY BrTokenFindMany(char *pattern, br_token *tokens, br_int_32 max_tokens);
/*
* tokenval.c
*/
br_tv_template * BR_RESIDENT_ENTRY BrTVTemplateAllocate(void *res, br_tv_template_entry *entries, int n_entries);
void BR_RESIDENT_ENTRY BrTVTemplateFree(br_tv_template *t);
br_error BR_RESIDENT_ENTRY BrTokenValueQuery(
br_uint_32 *pvalue, br_uint_32 *extra, br_size_t extra_size,
br_token t,
void *block,
br_tv_template *_template);
br_error BR_RESIDENT_ENTRY BrTokenValueQueryMany(
br_token_value *tv,
void *extra, br_size_t extra_size,
br_int_32 *pcount,
void *block,
br_tv_template *_template);
br_error BR_RESIDENT_ENTRY BrTokenValueQueryManySize(
br_size_t *psize,
br_token_value *tv,
void *block,
br_tv_template *_template);
br_error BR_RESIDENT_ENTRY BrTokenValueQueryAll(
br_token_value *buffer, br_size_t buffer_size,
void *block,
br_tv_template *_template);
br_error BR_RESIDENT_ENTRY BrTokenValueQueryAllSize(
br_size_t *psize,
void *block,
br_tv_template *_template);
br_error BR_RESIDENT_ENTRY BrTokenValueSet(
void *mem,
br_uint_32 *pcombined_mask,
br_token t,
br_uint_32 value,
br_tv_template *_template);
br_error BR_RESIDENT_ENTRY BrTokenValueSetMany(
void *mem,
br_int_32 *pcount,
br_uint_32 *pcombined_mask,
br_token_value *tv,
br_tv_template *_template);
void BR_RESIDENT_ENTRY BrTokenValueDump(br_token_value *tv, char *prefix, br_putline_cbfn *putline, void *arg);
br_error BR_RESIDENT_ENTRY BrStringToTokenValue(br_token_value *buffer, br_size_t buffer_size, char *str);
br_boolean BR_RESIDENT_ENTRY BrTokenValueCompare(br_token_value *tv1, br_token_value *tv2);
br_boolean BR_RESIDENT_ENTRY BrTokenValueComparePartial(br_token_value *tv1, br_token_value *tv2, br_token *insignificant);
/*
* diag.c
*/
void BR_RESIDENT_ENTRY _BrAssert(char *condition, char *file, unsigned line);
void BR_RESIDENT_ENTRY _BrUAssert(char *condition, char *file, unsigned line);
/*
* lexer.c
*/
struct br_lexer * BR_RESIDENT_ENTRY BrLexerAllocate(struct br_lexer_keyword *keywords, int nkeywords);
void BR_RESIDENT_ENTRY BrLexerFree(struct br_lexer * l);
char BR_RESIDENT_ENTRY BrLexerCommentSet(struct br_lexer * l, char eol_comment);
br_lexer_error_cbfn * BR_RESIDENT_ENTRY BrLexerErrorSet(struct br_lexer * l, br_lexer_error_cbfn *error);
br_error BR_RESIDENT_ENTRY BrLexerPushFile(struct br_lexer * l, char *file);
br_error BR_RESIDENT_ENTRY BrLexerPushString(struct br_lexer * l, char *string, char *name);
struct br_lexer_source * BR_RESIDENT_ENTRY BrLexerPop(struct br_lexer * l);
br_error BR_RESIDENT_ENTRY BrLexerDumpSet(struct br_lexer * l, br_putline_cbfn *putline, void *putline_arg);
void BR_RESIDENT_ENTRY BrLexerTokenError(struct br_lexer * l, br_lexer_token_id t);
void BR_RESIDENT_ENTRY BrLexerPosition(struct br_lexer * l, char *buf, br_size_t buf_size);
br_int_32 BR_RESIDENT_ENTRY BrParseInteger(struct br_lexer * l);
br_float BR_RESIDENT_ENTRY BrParseFloat(struct br_lexer * l);
br_fixed_ls BR_RESIDENT_ENTRY BrParseFixed(struct br_lexer * l);
br_int_32 BR_RESIDENT_ENTRY BrParseVectorFloat(struct br_lexer * l, br_float *v, br_int_32 max);
br_int_32 BR_RESIDENT_ENTRY BrParseVectorFixed(struct br_lexer * l, br_fixed_ls *v, br_int_32 max);
br_int_32 BR_RESIDENT_ENTRY BrParseMatrixFloat(struct br_lexer * l, br_float *m, br_int_32 width, br_int_32 max_h);
br_int_32 BR_RESIDENT_ENTRY BrParseMatrixFixed(struct br_lexer * l, br_fixed_ls *m, br_int_32 width, br_int_32 max_h);
#if BASED_FIXED
#define BrParseScalar BrParseFixed
#define BrParseVector BrParseVectorFixed
#define BrParseMatrix BrParseMatrixFixed
#endif
#if BASED_FLOAT
#define BrParseScalar BrParseFloat
#define BrParseVector BrParseVectorFloat
#define BrParseMatrix BrParseMatrixFloat
#endif
/*
* object.c
*/
br_error BR_CMETHOD_DECL(br_object,query)(struct br_object *self, br_uint_32 *pvalue, br_token t);
br_error BR_CMETHOD_DECL(br_object,queryBuffer)
(struct br_object *self, br_uint_32 *pvalue, br_uint_32 *buffer, br_size_t buffer_size, br_token t);
br_error BR_CMETHOD_DECL(br_object,queryMany)
(struct br_object *self, br_token_value *tv, void *extra, br_size_t extra_size, br_int_32 *pcount);
br_error BR_CMETHOD_DECL(br_object,queryManySize)
(struct br_object *self, br_size_t *pextra_size, br_token_value *tv);
br_error BR_CMETHOD_DECL(br_object,queryAll)
(struct br_object *self, br_token_value *buffer, br_size_t buffer_size);
br_error BR_CMETHOD_DECL(br_object,queryAllSize)
(struct br_object *self, br_size_t *psize);
/*
* objectc.c
*/
void * BR_RESIDENT_ENTRY BrObjectListAllocate(void *res);
br_error BR_CMETHOD_DECL(br_object_container, addFront)(struct br_object_container *self, struct br_object *ph);
br_error BR_CMETHOD_DECL(br_object_container, removeFront)(struct br_object_container *self, struct br_object **ph);
br_error BR_CMETHOD_DECL(br_object_container, remove)(struct br_object_container *self, struct br_object *ph);
br_error BR_CMETHOD_DECL(br_object_container, find)(struct br_object_container *self,
struct br_object **ph, br_token type, char *pattern, br_token_value *tv);
br_error BR_CMETHOD_DECL(br_object_container, findMany)(struct br_object_container *self,
struct br_object **objects, br_int_32 max_objects, br_int_32 *num_objects, br_token type, char *pattern, br_token_value *tv);
br_error BR_CMETHOD_DECL(br_object_container, count)(struct br_object_container *self,
br_uint_32 *pcount, br_token type, char *pattern, br_token_value *tv);
void * BR_CMETHOD_DECL(br_object_container, tokensMatchBegin)
(struct br_object_container *self, br_token t, br_token_value *tv);
br_boolean BR_CMETHOD_DECL(br_object_container, tokensMatch)
(struct br_object_container *self, struct br_object *h, void *arg);
void BR_CMETHOD_DECL(br_object_container, tokensMatchEnd)
(struct br_object_container *self, void *arg);
br_error BR_RESIDENT_ENTRY BrObjectContainerFree(struct br_object_container *self, br_token type, char *pattern, br_token_value *tv);
/*
* image.c
*/
struct br_image * BR_RESIDENT_ENTRY BrImageReference(char *name);
void BR_RESIDENT_ENTRY BrImageDereference(struct br_image *image);
void * BR_RESIDENT_ENTRY BrImageLookupName(struct br_image *img, char *name, br_uint_32 hint);
void * BR_RESIDENT_ENTRY BrImageLookupOrdinal(struct br_image *img, br_uint_32 ordinal);
br_boolean BR_RESIDENT_ENTRY BrImageAdd(br_image *ing);
br_boolean BR_RESIDENT_ENTRY BrImageRemove(br_image *img);
/*
* Entry/exit tracking hooksfor Watcom C++
*/
void BR_RESIDENT_ENTRY _EPI(void);
void BR_RESIDENT_ENTRY _PRO(void);
/*
* Registry lists
*/
void *BrRegistryClear(br_registry *reg);
int BrRegistryAddMany(br_registry *reg, void **item, int n);
int BrRegistryRemoveMany(br_registry *reg, void **item, int n);
void *BrRegistryFind(br_registry *reg, char *pattern);
int BrRegistryFindMany(br_registry *reg, char *pattern, void **item, int n);
int BrRegistryCount(br_registry *reg, char *pattern);
int BrRegistryEnum(br_registry *reg, char *pattern,
br_enum_cbfn *callback, void *arg);
void *BrRegistryNew(br_registry *reg);
void *BrRegistryAdd(br_registry *reg, void *item);
void *BrRegistryRemove(br_registry *reg, void *item);
void *BrRegistryNewStatic(br_registry *reg, br_registry_entry *base, int limit);
void *BrRegistryAddStatic(br_registry *reg, br_registry_entry *base, void *item);
void *BrRegistryRemoveStatic(br_registry *reg, void *item);
/*
* Nasty hack for finding out the last pixelmap that DevBegin() was called with
*/
br_pixelmap * BrDevLastBeginQuery(void);
void BrDevLastBeginSet(br_pixelmap *pm);
#ifdef __cplusplus
};
#endif
#endif
#endif

46
core/fw/brexcept.h Normal file
View File

@ -0,0 +1,46 @@
/*
* Copyright (c) 1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: brexcept.h 1.1 1997/12/10 16:41:04 jon Exp $
* $Locker: $
*
* Simple exception handling
*/
#ifndef _BREXCEPT_H_
#define _BREXCEPT_H_
#ifndef __H2INC__
#include <setjmp.h>
#endif
/*
* Exception types are the same as error types
*
* A value of zero is reserved
*/
typedef br_error br_exception;
/*
* Exception handler - allocated as a resource
*/
typedef struct br_exception_handler {
struct br_exception_handler *prev;
/*
* setjmp/longjmp context to throw to
*/
#ifndef __H2INC__
jmp_buf context;
#endif
} br_exception_handler;
/*
* Public macros
*/
#define BrExceptionBegin(evp) (_BrExceptionValueFetch((br_exception)setjmp(_BrExceptionCatch()->context),(evp)))
#define BrExceptionEnd() _BrExceptionEnd()
#define BrExceptionThrow(et,ev) _BrExceptionThrow((br_exception)(ev),(void *)(ev))
#define BR_EXCEPTION_RESOURCE _BrExceptionResource()
#endif

88
core/fw/brhton.h Normal file
View File

@ -0,0 +1,88 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: brhton.h 1.1 1997/12/10 16:41:04 jon Exp $
* $Locker: $
*
* Converting 'network' (big endian) byte order to host order
*
* This is a private implemenation - some platforms do not provide
* this functionality. For those that do, this file should define
* the operations in terms of the platform specific API
*/
#ifndef _BRHTON_H_
#define _BRHTON_H_
#if BR_ENDIAN_BIG
/*
* Network<->Host
*/
#define BrHtoNL(x) (x)
#define BrNtoHL(x) (x)
#define BrHtoNS(x) (x)
#define BrNtoHS(x) (x)
#define BrHtoNF(x) (x)
#define BrNtoHF(x) (x)
/*
* Big-Endian<->Host
*/
#define BrHtoBL(x) (x)
#define BrBtoHL(x) (x)
#define BrHtoBS(x) (x)
#define BrBtoHS(x) (x)
#define BrHtoBF(x) (x)
#define BrBtoHF(x) (x)
/*
* Little-Endian<->Host
*/
#define BrLtoHL(x) BrSwap32(x)
#define BrHtoLL(x) BrSwap32(x)
#define BrLtoHS(x) BrSwap16(x)
#define BrHtoLS(x) BrSwap16(x)
#define BrHtoLF(x) BrSwapFloat(x)
#define BrLtoHF(x) BrSwapFloat(x)
#endif
#if BR_ENDIAN_LITTLE
/*
* Network<->Host
*/
#define BrNtoHL(x) BrSwap32(x)
#define BrHtoNL(x) BrSwap32(x)
#define BrNtoHS(x) BrSwap16(x)
#define BrHtoNS(x) BrSwap16(x)
#define BrHtoNF(x) BrSwapFloat(x)
#define BrNtoHF(x) BrSwapFloat(x)
/*
* Big-Endian<->Host
*/
#define BrHtoBL(x) BrSwap32(x)
#define BrBtoHL(x) BrSwap32(x)
#define BrHtoBS(x) BrSwap16(x)
#define BrBtoHS(x) BrSwap16(x)
#define BrHtoBF(x) BrSwapFloat(x)
#define BrBtoHF(x) BrSwapFloat(x)
/*
* Little-Endian<->Host
*/
#define BrLtoHL(x) (x)
#define BrHtoLL(x) (x)
#define BrLtoHS(x) (x)
#define BrHtoLS(x) (x)
#define BrHtoLF(x) (x)
#define BrLtoHF(x) (x)
#endif
#endif

92
core/fw/brimage.h Normal file
View File

@ -0,0 +1,92 @@
/*
* Copyright (c) 1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: brimage.h 1.1 1997/12/10 16:41:04 jon Exp $
* $Locker: $
*
*/
#ifndef _BRIMAGE_H_
#define _BRIMAGE_H_
/*
* In-memory structure describing a loaded image
*/
typedef struct br_image_section {
char *name;
void *base;
br_size_t mem_offset;
br_size_t mem_size;
br_uint_32 data_offset;
br_uint_32 data_size;
} br_image_section;
typedef struct br_image {
/*
* Anchor block for list of images
*/
br_node node;
/*
* DLL name
*/
char *identifier;
/*
* Type of DLL - Resident, Host, Framework
*/
br_int_32 type;
/*
* Number of references to this DLL
*/
br_int_32 ref_count;
/*
* Table of exported functions
*/
br_uint_32 ordinal_base;
br_uint_32 n_functions;
void ** functions;
/*
* Name -> ordinal lookup
*/
br_uint_32 n_names;
char **names;
br_uint_16 *name_ordinals;
/*
* Table of imported image pointers
*/
br_uint_16 n_imports;
struct br_image ** imports;
/*
* Image sections
*/
br_uint_16 n_sections;
br_image_section *sections;
/*
* Type specific pointer
*/
void *type_pointer;
} br_image;
/*
* Possible types of DLL
*/
enum {
BR_IMG_FRAMEWORK = 1,
BR_IMG_RESIDENT,
BR_IMG_HOST,
};
/*
* Bogus type used to import functions
*/
typedef void BR_PUBLIC_ENTRY br_resident_fn();
#endif

165
core/fw/brlists.c Normal file
View File

@ -0,0 +1,165 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: brlists.c 1.2 1998/02/12 16:04:06 jon Exp $
* $Locker: $
*
* Doubly linked list support - has a full and simple version
*/
#include "fw.h"
BR_RCS_ID("$Id: brlists.c 1.2 1998/02/12 16:04:06 jon Exp $")
/**
** Full features list handling
**/
/*
* Initialse a list structure to be empty list
*/
void BR_RESIDENT_ENTRY BrNewList(struct br_list *list)
{
list->head = (struct br_node *)&(list->_null);
list->tail = (struct br_node *)&(list->head);
list->_null = NULL;
}
/*
* Add node at head of list
*/
void BR_RESIDENT_ENTRY BrAddHead(struct br_list *list, struct br_node *node)
{
node->prev = (struct br_node *)&(list->head);
node->next = list->head;
node->next->prev = node;
list->head = node;
}
/*
* Add node at tail of list
*/
void BR_RESIDENT_ENTRY BrAddTail(struct br_list *list, struct br_node *node)
{
node->next = (struct br_node *)&(list->_null);
node->prev = list->tail;
node->prev->next = node;
list->tail = node;
}
/*
* Take node of head of list and return pointer to it
*/
struct br_node * BR_RESIDENT_ENTRY BrRemHead(struct br_list *list)
{
struct br_node *n = list->head;
/*
* Trap case of empty list
*/
if(n == (struct br_node *)&(list->_null))
return NULL;
list->head = n->next;
n->next->prev = (struct br_node *)&(list->head);
return n;
}
/*
* Take node of tail of list and return pointer to it
*/
struct br_node * BR_RESIDENT_ENTRY BrRemTail(struct br_list *list)
{
struct br_node *n = list->tail;
/*
* Trap case of empty list
*/
if(n == (struct br_node *)&(list->head))
return NULL;
list->tail = n->prev;
n->prev->next = (struct br_node *)&(list->_null);
return n;
}
/*
* Add a node to list following the node 'here'
*/
void BR_RESIDENT_ENTRY BrInsert(struct br_list *list, struct br_node *here, struct br_node *node)
{
node->next=here->next;
node->prev=here;
here->next->prev = node;
here->next = node;
}
/*
* Remove a node from the containing list
*/
struct br_node * BR_RESIDENT_ENTRY BrRemove(struct br_node *node)
{
node->next->prev = node->prev;
node->prev->next = node->next;
return node;
}
/**
** Simple list handling
**/
void BR_RESIDENT_ENTRY BrSimpleNewList(struct br_simple_list *list)
{
list->head = NULL;
}
void BR_RESIDENT_ENTRY BrSimpleAddHead(struct br_simple_list *list, struct br_simple_node *node)
{
node->next = list->head;
node->prev = &list->head;
if(node->next)
node->next->prev = & node->next;
list->head = node;
}
struct br_simple_node * BR_RESIDENT_ENTRY BrSimpleRemHead(struct br_simple_list *list)
{
struct br_simple_node *node = list->head ;
if(node)
BrSimpleRemove(node);
return node;
}
void BR_RESIDENT_ENTRY BrSimpleInsert(struct br_simple_list *list, struct br_simple_node *here, struct br_simple_node *node)
{
node->next = here->next;
node->prev = &here->next;
if(node->next)
node->next->prev = & node->next;
here->next = node;
}
struct br_simple_node * BR_RESIDENT_ENTRY BrSimpleRemove(struct br_simple_node *node)
{
*(node->prev) = node->next;
if(node->next)
node->next->prev = node->prev;
node->prev = NULL;
node->next = NULL;
return node;
}

117
core/fw/brlists.h Normal file
View File

@ -0,0 +1,117 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: brlists.h 1.2 1998/05/20 11:55:54 jon Exp $
* $Locker: $
*
* Doubly linked list supoprt (Based on Amiga EXEC!)
*/
#ifndef _BRLISTS_H_
#define _BRLISTS_H_
/**
** Full featured doubly linked lists
**/
/*
* Anchor structure at front of list entries
*/
typedef struct br_node {
struct br_node *next;
struct br_node *prev;
} br_node;
/*
* Anchor structure for whole list - looks like two nodes overlapping.
* The _null memeber is always NULL, providing the termination at
* both ends of the list
*/
typedef struct br_list {
br_node *head;
br_node *_null;
br_node *tail;
} br_list;
#define BR_HEAD(l) (void *)(((struct br_list *)(l))->head)
#define BR_TAIL(l) (void *)(((struct br_list *)(l))->tail)
#define BR_NEXT(n) (void *)(((struct br_node *)(n))->next)
#define BR_PREV(n) (void *)(((struct br_node *)(n))->prev)
#define BR_INSERTED(n) (void *)(((struct br_node *)(n))->next)
#define BR_CHECK(l) BR_NEXT(BR_HEAD(l))
/*
* Walk a pointer forwards along a list
*
* eg:
* BR_FOR_LIST(sprites,sptr) {
* sptr->x = 10;
* }
*/
#define BR_FOR_LIST(list,ptr) for((ptr) = BR_HEAD(list); BR_NEXT(ptr); ptr = BR_NEXT(ptr))
/*
* Walk a pointer backwards along a list
*
* eg:
* BR_FOR_LIST_R(sprites,sptr) {
* sptr->x = 10;
* }
*/
#define BR_FOR_LIST_R(list,ptr) for((ptr) = BR_TAIL(list); BR_PREV(ptr); ptr = BR_PREV(ptr))
/*
* Macros around exported functions that hide type casting
*/
#define BR_ADDHEAD(l,n) BrAddHead((struct br_list *)(l),(struct br_node *)(n))
#define BR_ADDTAIL(l,n) BrAddTail((struct br_list *)(l),(struct br_node *)(n))
#define BR_REMHEAD(l) ((void *)BrRemHead((struct br_list *)(l)))
#define BR_REMTAIL(l) ((void *)BrRemTail((struct br_list *)(l)))
#define BR_INSERT(l,n1,n2) BrInsert((struct br_list *)(l),(struct br_node *)(n1),(struct br_node *)(n2))
#define BR_REMOVE(n) ((void *) BrRemove((struct br_node *)(n)))
/**
** Simple lists that only use a single head pointer
**/
typedef struct br_simple_node {
struct br_simple_node *next;
struct br_simple_node **prev;
} br_simple_node;
/*
* Anchor structure for whole list - just a single head pointer
*/
typedef struct br_simple_list {
struct br_simple_node *head;
} br_simple_list;
#define BR_SIMPLEHEAD(l) (void *)(((br_simple_list *)(l))->head)
#define BR_SIMPLENEXT(n) (void *)(((br_simple_node *)(n))->next)
#define BR_SIMPLEINSERTED(n) (void *)(((br_simple_node *)(n))->prev)
#define BR_SIMPLECHECK(l) BR_SIMPLEHEAD(l)
#define BR_FOR_SIMPLELIST(list,ptr) for((ptr)=BR_SIMPLEHEAD(list);(ptr);(ptr)=BR_SIMPLENEXT(ptr))
/*
* Macros around exported functions that hide type casting
*/
#define BR_SIMPLEADDHEAD(l,n) BrSimpleAddHead((br_simple_list *)(l),(br_simple_node *)(n))
#define BR_SIMPLEREMHEAD(l) ((void *) BrSimpleRemHead((br_simple_list *)(l)))
#define BR_SIMPLEINSERT(l,n1,n2) BrSimpleInsert((br_simple_list *)(l),(br_simple_node *)(n1),(br_simple_node *)(n2))
#define BR_SIMPLEREMOVE(n) ((void *) BrSimpleRemove((br_simple_node *)(n)))
/*
* Operations on list members that have "char *identifier" as the first entry
*/
typedef struct br_node_id {
br_node node;
char *identifier;
} br_node_id;
#endif

176
core/fw/brqsort.c Normal file
View File

@ -0,0 +1,176 @@
/*
* $Id: brqsort.c 1.1 1997/12/10 16:41:05 jon Exp $
* $Locker: $
*
* Local quicksort for brender
*
* Based on a public domain verion by Raymond Gardner,
* Englewood CO February 1991
*/
#include "brender.h"
BR_RCS_ID("$Id: brqsort.c 1.1 1997/12/10 16:41:05 jon Exp $")
#if defined(_MSC_VER)
#include <stdlib.h>
void BR_RESIDENT_ENTRY BrQsort(void *basep, unsigned int nelems, unsigned int size,
br_qsort_cbfn *comp)
{
qsort(basep, nelems, size, comp);
}
#elif defined(__IBMC__)
/*
* Pull qsort from a BRender specific DLL
*/
void _System BrSupport1(br_qsort_cbfn *comp, unsigned int size, void *basep, unsigned int nelems);
void BR_RESIDENT_ENTRY BrQsort(void *basep, unsigned int nelems, unsigned int size,
br_qsort_cbfn *comp)
{
BrSupport1(comp,size,basep,nelems);
}
#else
static void swap_chars(char *, char *, unsigned int);
#define SWAP_INTS 1
/*
** Compile with -DSWAP_INTS if your machine can access an int at an
** arbitrary location with reasonable efficiency. (Some machines
** cannot access an int at an odd address at all, so be careful.)
*/
#ifdef SWAP_INTS
static void swap_ints(char *, char *, unsigned int);
static void swap_int_1(char *ap, char *bp, unsigned int nints);
#define SWAP(a, b) (swap_func((char *)(a), (char *)(b), width))
#else
#define SWAP(a, b) (swap_chars((char *)(a), (char *)(b), size))
#endif
#define COMP(a, b) ((*comp)((void *)(a), (void *)(b)))
#define T 7 /* subfiles of T or fewer elements will */
/* be sorted by a simple insertion sort */
/* Note! T must be at least 3 */
void BR_RESIDENT_ENTRY BrQsort(void *basep, unsigned int nelems, unsigned int size,
br_qsort_cbfn *comp)
{
char *stack[40], **sp; /* stack and stack pointer */
char *i, *j, *limit; /* scan and limit pointers */
unsigned int thresh; /* size of T elements in bytes */
char *base; /* base pointer as char * */
#ifdef SWAP_INTS
unsigned int width; /* width of array element */
void (*swap_func)(char *, char *, unsigned int); /* swap func pointer*/
width = size; /* save size for swap routine */
swap_func = swap_chars; /* choose swap function */
if ( size == sizeof(int)) { /* size is == int */
swap_func = swap_int_1; /* use int swap function */
} else if ( size % sizeof(int) == 0 ) { /* size is multiple of ints */
width /= sizeof(int); /* set width in ints */
swap_func = swap_ints; /* use int swap function */
}
#endif
base = (char *)basep; /* set up char * base pointer */
thresh = T * size; /* init threshold */
sp = stack; /* init stack pointer */
limit = base + nelems * size;/* pointer past end of array */
for ( ;; ) { /* repeat until break... */
if ( (unsigned)(limit - base) > thresh ) { /* if more than T elements */
/* swap base with middle */
SWAP((((limit-base)/size)/2)*size+base, base);
i = base + size; /* i scans left to right */
j = limit - size; /* j scans right to left */
if ( COMP(i, j) > 0 ) /* Sedgewick's */
SWAP(i, j); /* three-element sort */
if ( COMP(base, j) > 0 ) /* sets things up */
SWAP(base, j); /* so that */
if ( COMP(i, base) > 0 ) /* *i <= *base <= *j */
SWAP(i, base); /* *base is pivot element */
for ( ;; ) { /* loop until break */
do /* move i right */
i += size; /* until *i >= pivot */
while ( COMP(i, base) < 0 );
do /* move j left */
j -= size; /* until *j <= pivot */
while ( COMP(j, base) > 0 );
if ( i > j ) /* if pointers crossed */
break; /* break loop */
SWAP(i, j); /* else swap elements, keep scanning*/
}
SWAP(base, j); /* move pivot into correct place */
if ( j - base > limit - i ) { /* if left subfile larger */
sp[0] = base; /* stack left subfile base */
sp[1] = j; /* and limit */
base = i; /* sort the right subfile */
} else { /* else right subfile larger*/
sp[0] = i; /* stack right subfile base */
sp[1] = limit; /* and limit */
limit = j; /* sort the left subfile */
}
sp += 2; /* increment stack pointer */
} else { /* else subfile is small, use insertion sort */
for ( j = base, i = j+size; i < limit; j = i, i += size )
for ( ; COMP(j, j+size) > 0; j -= size ) {
SWAP(j, j+size);
if ( j == base )
break;
}
if ( sp != stack ) { /* if any entries on stack */
sp -= 2; /* pop the base and limit */
base = sp[0];
limit = sp[1];
} else /* else stack empty, done */
break;
}
}
}
/*
** swap nbytes between a and b
*/
static void swap_chars(char *a, char *b, unsigned int nbytes)
{
char tmp;
do {
tmp = *a; *a++ = *b; *b++ = tmp;
} while ( --nbytes );
}
#ifdef SWAP_INTS
/*
** swap nints between a and b
*/
static void swap_ints(char *ap, char *bp, unsigned int nints)
{
int *a = (int *)ap, *b = (int *)bp;
int tmp;
do {
tmp = *a; *a++ = *b; *b++ = tmp;
} while ( --nints );
}
static void swap_int_1(char *ap, char *bp, unsigned int nints)
{
int *a = (int *)ap, *b = (int *)bp;
int tmp;
tmp = *a; *a++ = *b; *b++ = tmp;
}
#endif
#endif

120
core/fw/brstdlib.h Normal file
View File

@ -0,0 +1,120 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: brstdlib.h 1.1 1997/12/10 16:41:05 jon Exp $
* $Locker: $
*
* Wrappers around standard C library functions that are provided by the STD library
*/
#ifndef _BRSTDLIB_H_
#define _BRSTDLIB_H_
#include <stdarg.h>
#ifndef _NO_PROTOTYPES
#ifdef __cplusplus
extern "C" {
#endif
int BR_PUBLIC_ENTRY BrMemCmp( const void *s1, const void *s2, br_size_t n );
void * BR_PUBLIC_ENTRY BrMemCpy( void *s1, const void *s2, br_size_t n );
void * BR_PUBLIC_ENTRY BrMemSet( void *s, int c, br_size_t n );
char * BR_PUBLIC_ENTRY BrStrCat( char *s1, const char *s2 );
int BR_PUBLIC_ENTRY BrStrCmp( const char *s1, const char *s2 );
int BR_PUBLIC_ENTRY BrStrICmp( const char *s1, const char *s2 );
char * BR_PUBLIC_ENTRY BrStrCpy( char *s1, const char *s2 );
br_size_t BR_PUBLIC_ENTRY BrStrLen( const char *s );
int BR_PUBLIC_ENTRY BrStrNCmp( const char *s1, const char *s2, br_size_t n );
int BR_PUBLIC_ENTRY BrStrNICmp( const char *s1, const char *s2, br_size_t n );
char * BR_PUBLIC_ENTRY BrStrNCpy( char *s1, const char *s2, br_size_t n );
char * BR_PUBLIC_ENTRY BrStrChr( char *s1, char c);
char * BR_PUBLIC_ENTRY BrStrRChr( char *s1, char c);
void BR_PUBLIC_ENTRY BrAbort( void );
char * BR_PUBLIC_ENTRY BrGetEnv( const char *name );
float BR_PUBLIC_ENTRY BrStrToF( const char *nptr, char **endptr );
double BR_PUBLIC_ENTRY BrStrToD( const char *nptr, char **endptr );
long int BR_PUBLIC_ENTRY BrStrToL( const char *nptr, char **endptr, int base );
unsigned long BR_PUBLIC_ENTRY BrStrToUL( const char *nptr, char **endptr, int base );
br_boolean BR_PUBLIC_ENTRY BrIsAlpha(int c);
br_boolean BR_PUBLIC_ENTRY BrIsDigit(int c);
br_boolean BR_PUBLIC_ENTRY BrIsSpace(int c);
br_boolean BR_PUBLIC_ENTRY BrIsPrint(int c);
br_int_32 BR_RESIDENT_ENTRY BrVSScanf(char * str, char *fmt, va_list args);
br_int_32 BR_RESIDENT_ENTRY BrVSprintf(char * buf, char *fmt, va_list args);
br_int_32 BR_RESIDENT_ENTRY BrVSprintfN(char * buf, br_size_t buf_size, char *fmt, va_list args);
#ifdef __cplusplus
};
#endif
#endif
/*
* Compiler specific overrides
*/
#if defined(__USE_CLIB__)
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
/*
* Force stlib operations to be used directly
*/
#define BrMemCmp memcmp
#define BrMemCpy memcpy
#define BrMemSet memset
#define BrStrCat strcat
#define BrStrCmp strcmp
#define BrStrICmp stricmp
#define BrStrCpy strcpy
#define BrStrLen strlen
#define BrStrNCmp strncmp
#define BrStrNICmp strnicmp
#define BrStrNCpy strncpy
#define BrStrChr strchr
#define BrStrRChr strrchr
#define BrAbort abort
#define BrGetEnv getenv
#define BrStrToF strtod
#define BrStrToD strtod
#define BrStrToL strtol
#define BrStrToUL strtoul
#define BrIsAlpha isalpha
#define BrIsDigit isdigit
#define BrIsSpace isspace
#define BrIsPrint isprint
#define BrVSScanf vsscanf
#define BrVSprintf vsprintf
#elif defined(__WATCOMC__)
#elif defined(_MSC_VER)
#elif defined (__BORLANDC__)
#elif defined(__PROTON__)
#elif defined(__GNUC__) && defined(i386)
#endif
#endif

170
core/fw/bswap.c Normal file
View File

@ -0,0 +1,170 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: bswap.c 1.1 1997/12/10 16:41:05 jon Exp $
* $Locker: $
*
* Byte swap routines for net<->host conversion
*/
#include "fw.h"
#include "brassert.h"
#include "brhton.h"
BR_RCS_ID("$Id: bswap.c 1.1 1997/12/10 16:41:05 jon Exp $")
#ifndef __IBMC__
#undef _SWAP
#define _SWAP(a,b) { (a) ^= (b); (b) ^= (a); (a) ^= (b); }
/*
* Swap the bytes of a 4 byte word
*/
br_uint_32 BR_RESIDENT_ENTRY BrSwap32(br_uint_32 l)
{
union {
unsigned long l;
unsigned char c[4];
} u;
u.l = l;
_SWAP(u.c[0],u.c[3]);
_SWAP(u.c[1],u.c[2]);
return u.l;
}
/*
* Swap the bytes of a 2 byte word
*/
br_uint_16 BR_RESIDENT_ENTRY BrSwap16(br_uint_16 s)
{
union {
unsigned short s;
unsigned char c[2];
} u;
u.s = s;
_SWAP(u.c[0],u.c[1]);
return u.s;
}
/*
* Swap the bytes of a 4 byte float
*/
br_float BR_RESIDENT_ENTRY BrSwapFloat(br_float f)
{
union {
br_float f;
unsigned char c[4];
} u;
u.f = f;
_SWAP(u.c[0],u.c[3]);
_SWAP(u.c[1],u.c[2]);
return u.f;
}
/*
* Swap an array of items
*
*/
void * BR_RESIDENT_ENTRY BrSwapBlock(void *block, int count, int size)
{
br_uint_8 *cp;
int i,k;
ASSERT(block != NULL);
ASSERT(count != 0);
ASSERT(size != 0);
/*
* Go through block swapping elements of the appropriate size
*/
switch(size) {
case 1:
break;
/*
* Special case loops for the common sizes
*/
case 2:
for(i=0, cp = block; i< count; i++,cp+=2) {
_SWAP(cp[0],cp[1]);
}
break;
case 3:
for(i=0, cp = block; i< count; i++,cp+=3) {
_SWAP(cp[0],cp[2]);
}
break;
case 4:
for(i=0, cp = block; i< count; i++,cp+=4) {
_SWAP(cp[0],cp[3]);
_SWAP(cp[1],cp[2]);
}
break;
case 8:
for(i=0, cp = block; i< count; i++,cp+=8) {
_SWAP(cp[0],cp[7]);
_SWAP(cp[1],cp[6]);
_SWAP(cp[2],cp[5]);
_SWAP(cp[3],cp[4]);
}
break;
default:
/*
* Do any other strange size the long way
*/
for(i=0, cp = block; i< count; i++,cp+=size) {
for(k=0; k < size/2; k++)
_SWAP(cp[k],cp[size-k-1]);
}
break;
}
return block;
}
#else
/*
* Pull swap ops. from a BRender specific DLL
*/
br_uint_32 _System BrSupport2(br_uint_32 l);
br_uint_16 _System BrSupport3(br_uint_16 s);
br_float _System BrSupport4(br_float f);
void * _System BrSupport5(void *block, int count, int size);
br_uint_32 BR_RESIDENT_ENTRY BrSwap32(br_uint_32 l)
{
return BrSupport2(l);
}
br_uint_16 BR_RESIDENT_ENTRY BrSwap16(br_uint_16 s)
{
return BrSupport3(s);
}
br_float BR_RESIDENT_ENTRY BrSwapFloat(br_float f)
{
return BrSupport4(f);
}
void * BR_RESIDENT_ENTRY BrSwapBlock(void *block, int count, int size)
{
return BrSupport5(block, count, size);
}
#endif

47
core/fw/dataf_p.h Normal file
View File

@ -0,0 +1,47 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: dataf_p.h 1.1 1997/12/10 16:41:05 jon Exp $
* $Locker: $
*
* Prototypes for functions internal to framework
*/
#ifndef _DATAF_P_H_
#define _DATAF_P_H_
#ifndef _NO_PROTOTYPES
#ifdef __cplusplus
extern "C" {
#endif
/*
* datafile.c
*/
void *DfPop(int type, int *countp);
void DfPush(int type, void *value, int count);
void *DfTop(int type, int *countp);
int DfTopType(void);
int DfChunksInterpret(struct br_datafile *df, struct br_chunks_table *table);
br_uint_32 DfStructWriteArray(struct br_datafile *df, struct br_file_struct *str, void *base, int n);
br_uint_32 DfStructReadArray(struct br_datafile *df, struct br_file_struct *str,void *base, int n);
struct br_datafile *DfOpen(char *name, int write, br_token scalar_type);
void DfClose(struct br_datafile *df);
/*
* genfile.c
*/
int FopRead_END(struct br_datafile *df, br_uint_32 id, br_uint_32 length, br_uint_32 count);
int FopWrite_END(struct br_datafile *df);
int FopWrite_FILE_INFO(struct br_datafile *df, br_uint_32 type);
#ifdef __cplusplus
};
#endif
#endif
#endif

2327
core/fw/datafile.c Normal file
View File

File diff suppressed because it is too large Load Diff

464
core/fw/datafile.h Normal file
View File

@ -0,0 +1,464 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: datafile.h 1.5 1998/07/21 17:33:14 jon Exp $
* $Locker: $
*
* Constants and structures inside a 3d data file
*/
#ifndef _DATAFILE_H_
#define _DATAFILE_H_
#ifndef _BRHTON_H_
#include "brhton.h"
#endif
/*
* Version number written into new files
*/
#define BR_FILE_VERSION 2
/*
* File open modes
*/
#define DFOPEN_READ 0
#define DFOPEN_WRITE 1
#define DFOPEN_BINARY 2
/*
* File chunk IDs
*/
enum {
FID_END,
FID_IMAGE_PLANE, /* UNUSED */
FID_RLE_IMAGE_PLANE, /* UNUSED */
FID_OLD_PIXELMAP,
FID_MATERIAL_OLDEST,
FID_ADD_MATERIAL, /* UNUSED */
FID_OLD_ACTOR, /* UNUSED */
FID_OLD_ADD_SIBLING, /* UNUSED */
FID_OLD_ADD_CHILD, /* UNUSED */
FID_OLD_MATERIAL_INDEX,
FID_OLD_VERTICES,
FID_OLD_VERTICES_UV,
FID_OLD_FACES,
FID_OLD_MODEL,
FID_ADD_MODEL,
FID_ANIM,
FID_ANIM_TRANSFORM,
FID_ANIM_RATE,
FID_FILE_INFO,
FID_OLD_LIGHT, /* UNUSED */
FID_OLD_CAMERA, /* UNUSED */
FID_PIVOT,
FID_MATERIAL_INDEX,
FID_VERTICES,
FID_VERTEX_UV,
FID_OLD_FACES_1,
FID_FACE_MATERIAL,
FID_OLD_MODEL_1,
FID_COLOUR_MAP_REF,
FID_OPACITY_MAP_REF, /* UNUSED */
FID_INDEX_BLEND_REF,
FID_INDEX_SHADE_REF,
FID_SCREENDOOR_REF,
FID_PIXELS,
FID_ADD_MAP,
FID_ACTOR,
FID_ACTOR_MODEL,
FID_ACTOR_TRANSFORM,
FID_ACTOR_MATERIAL,
FID_ACTOR_LIGHT,
FID_ACTOR_CAMERA,
FID_ACTOR_BOUNDS,
FID_ACTOR_ADD_CHILD,
FID_TRANSFORM_MATRIX34,
FID_TRANSFORM_MATRIX34_LP,
FID_TRANSFORM_QUAT,
FID_TRANSFORM_EULER,
FID_TRANSFORM_LOOK_UP,
FID_TRANSFORM_TRANSLATION,
FID_TRANSFORM_IDENTITY,
FID_BOUNDS,
FID_LIGHT_OLD,
FID_CAMERA,
FID_FACES,
FID_OLD_MODEL_2,
FID_ACTOR_CLIP_PLANE,
FID_PLANE,
FID_SATURN_FACES,
FID_SATURN_MODEL,
FID_INDEX_FOG_REF,
FID_MATERIAL_OLD,
FID_PIXELMAP,
FID_MATERIAL,
FID_LIGHT,
FID_MODEL,
FID_VERTEX_COLOUR,
FID_VERTEX_NORMAL,
FID_FACE_COLOUR,
FID_FACE_EQUATION,
};
/*
* Data Stack types
*/
enum {
DFST_NONE,
DFST_IMAGE_PLANE,
DFST_PIXELMAP,
DFST_MATERIAL,
DFST_ACTOR,
DFST_MATERIAL_INDEX,
DFST_VERTICES,
DFST_FACES,
DFST_MODEL,
DFST_ANIM,
DFST_ANIM_NAME,
DFST_ANIM_TRANSFORM,
DFST_ANIM_COUNT,
DFST_ANIM_RATE,
DFST_FILE_INFO,
DFST_PIVOT,
DFST_TRANSFORM,
DFST_LIGHT,
DFST_CAMERA,
DFST_BOUNDS,
DFST_PLANE,
DFST_MARK,
DFST_SATURN_FACES,
DFST_SATURN_MODEL,
DFST_MAX
};
/*
* File info types
*/
enum {
FILE_TYPE_NONE,
/* FILE_TYPE_MODEL, */
FILE_TYPE_ACTORS,
/* FILE_TYPE_ANIMATION, */
FILE_TYPE_PIXELMAP,
FILE_TYPE_LIGHT,
FILE_TYPE_CAMERA,
FILE_TYPE_MATERIAL_OLD,
FILE_TYPE_MATERIAL,
/*
* Old Types
*/
FILE_TYPE_MODEL = 0xFACE,
FILE_TYPE_ANIMATION = 0x0A11,
FILE_TYPE_TREE = 0x5EED
};
/**
** General structure reading/writing system
**/
/*
* Member types
*/
enum {
FSM_INT_8,
FSM_UINT_8,
FSM_INT_16,
FSM_UINT_16,
FSM_INT_32,
FSM_UINT_32,
FSM_FIXED,
FSM_ANGLE,
FSM_FLOAT,
FSM_DOUBLE,
FSM_SCALAR,
FSM_FRACTION,
FSM_UFRACTION,
FSM_ENUM_8,
FSM_ENUM_16,
FSM_ENUM_32,
FSM_STRUCT,
FSM_ASCIZ,
FSM_COLOUR,
FSM_VECTOR2,
FSM_VECTOR3,
FSM_VECTOR4,
FSM_FVECTOR2,
FSM_FVECTOR3,
FSM_FVECTOR4,
FSM_FIXED_FRACTION,
FSM_FIXED_UFRACTION,
FSM_FLOAT_FRACTION,
FSM_FLOAT_UFRACTION,
FSM_FIXED_VECTOR2,
FSM_FIXED_VECTOR3,
FSM_FIXED_VECTOR4,
FSM_FLOAT_VECTOR2,
FSM_FLOAT_VECTOR3,
FSM_FLOAT_VECTOR4,
FSM_FIXED_FVECTOR2,
FSM_FIXED_FVECTOR3,
FSM_FIXED_FVECTOR4,
FSM_FLOAT_FVECTOR2,
FSM_FLOAT_FVECTOR3,
FSM_FLOAT_FVECTOR4,
FSM_COLOUR_ALPHA,
};
typedef struct br_file_struct_member {
br_uint_16 type; /* Type of member */
br_uint_32 offset; /* Offset in memory from base of structure */
char *name; /* text identifier for debug purposes */
void *extra; /* Any extra type data */
} br_file_struct_member;
typedef struct br_file_struct {
char *name;
br_uint_32 nmembers;
br_file_struct_member *members;
int mem_size;
} br_file_struct;
/*
* Some nasty macros to make building structure descriptions easier
* Requires that a macro _STRUCT_NAME be defined - the type of the
* structure being referenced
*/
#define _INT_8(m) {FSM_INT_8, offsetof(_STRUCT_NAME,m),#m}
#define _UINT_8(m) {FSM_UINT_8, offsetof(_STRUCT_NAME,m),#m}
#define _INT_16(m) {FSM_INT_16, offsetof(_STRUCT_NAME,m),#m}
#define _UINT_16(m) {FSM_UINT_16, offsetof(_STRUCT_NAME,m),#m}
#define _INT_32(m) {FSM_INT_32, offsetof(_STRUCT_NAME,m),#m}
#define _UINT_32(m) {FSM_UINT_32, offsetof(_STRUCT_NAME,m),#m}
#define _FIXED(m) {FSM_FIXED, offsetof(_STRUCT_NAME,m),#m}
#define _ANGLE(m) {FSM_ANGLE, offsetof(_STRUCT_NAME,m),#m}
#define _FLOAT(m) {FSM_FLOAT, offsetof(_STRUCT_NAME,m),#m}
#define _DOUBLE(m) {FSM_DOUBLE, offsetof(_STRUCT_NAME,m),#m}
#define _SCALAR(m) {FSM_SCALAR, offsetof(_STRUCT_NAME,m),#m}
#define _FRACTION(m) {FSM_FRACTION, offsetof(_STRUCT_NAME,m),#m}
#define _UFRACTION(m) {FSM_UFRACTION,offsetof(_STRUCT_NAME,m),#m}
#define _ENUM_8(m,e) {FSM_ENUM_8, offsetof(_STRUCT_NAME,m),#m,&(e)}
#define _ENUM_16(m,e) {FSM_ENUM_16, offsetof(_STRUCT_NAME,m),#m,&(e)}
#define _ENUM_32(m,e) {FSM_ENUM_32, offsetof(_STRUCT_NAME,m),#m,&(e)}
#define _STRUCT(m,s) {FSM_STRUCT, offsetof(_STRUCT_NAME,m),#m,&(s)}
#define _ASCIZ(m) {FSM_ASCIZ, offsetof(_STRUCT_NAME,m),#m}
#define _COLOUR(m) {FSM_COLOUR, offsetof(_STRUCT_NAME,m),#m}
#define _VECTOR2(m) {FSM_VECTOR2, offsetof(_STRUCT_NAME,m),#m}
#define _VECTOR3(m) {FSM_VECTOR3, offsetof(_STRUCT_NAME,m),#m}
#define _VECTOR4(m) {FSM_VECTOR4, offsetof(_STRUCT_NAME,m),#m}
#define _FVECTOR2(m) {FSM_FVECTOR2, offsetof(_STRUCT_NAME,m),#m}
#define _FVECTOR3(m) {FSM_FVECTOR3, offsetof(_STRUCT_NAME,m),#m}
#define _FVECTOR4(m) {FSM_FVECTOR4, offsetof(_STRUCT_NAME,m),#m}
#define _FIXED_FRACTION(m) {FSM_FIXED_FRACTION, offsetof(_STRUCT_NAME,m),#m}
#define _FIXED_UFRACTION(m) {FSM_FIXED_UFRACTION,offsetof(_STRUCT_NAME,m),#m}
#define _FLOAT_FRACTION(m) {FSM_FLOAT_FRACTION, offsetof(_STRUCT_NAME,m),#m}
#define _FLOAT_UFRACTION(m) {FSM_FLOAT_UFRACTION,offsetof(_STRUCT_NAME,m),#m}
#define _FIXED_VECTOR2(m) {FSM_FIXED_VECTOR2, offsetof(_STRUCT_NAME,m),#m}
#define _FIXED_VECTOR3(m) {FSM_FIXED_VECTOR3, offsetof(_STRUCT_NAME,m),#m}
#define _FIXED_VECTOR4(m) {FSM_FIXED_VECTOR4, offsetof(_STRUCT_NAME,m),#m}
#define _FLOAT_VECTOR2(m) {FSM_FLOAT_VECTOR2, offsetof(_STRUCT_NAME,m),#m}
#define _FLOAT_VECTOR3(m) {FSM_FLOAT_VECTOR3, offsetof(_STRUCT_NAME,m),#m}
#define _FLOAT_VECTOR4(m) {FSM_FLOAT_VECTOR4, offsetof(_STRUCT_NAME,m),#m}
#define _FIXED_FVECTOR2(m) {FSM_FIXED_FVECTOR2, offsetof(_STRUCT_NAME,m),#m}
#define _FIXED_FVECTOR3(m) {FSM_FIXED_FVECTOR3, offsetof(_STRUCT_NAME,m),#m}
#define _FIXED_FVECTOR4(m) {FSM_FIXED_FVECTOR4, offsetof(_STRUCT_NAME,m),#m}
#define _FLOAT_FVECTOR2(m) {FSM_FLOAT_FVECTOR2, offsetof(_STRUCT_NAME,m),#m}
#define _FLOAT_FVECTOR3(m) {FSM_FLOAT_FVECTOR3, offsetof(_STRUCT_NAME,m),#m}
#define _FLOAT_FVECTOR4(m) {FSM_FLOAT_FVECTOR4, offsetof(_STRUCT_NAME,m),#m}
#define _COLOUR_ALPHA(m) {FSM_COLOUR_ALPHA, offsetof(_STRUCT_NAME,m),#m}
#define _FILE_STRUCT(name)\
br_file_struct name##_F = {\
#name,\
BR_ASIZE(name##_FM),\
name##_FM,\
sizeof(_STRUCT_NAME),\
}
/*
* Structures for describing an enum
*/
typedef struct br_file_enum_member {
int value;
char *name;
} br_file_enum_member;
typedef struct br_file_enum {
br_uint_32 nmembers;
br_file_enum_member *members;
} br_file_enum;
/*
* Macros for building enums
*/
#define _ENUM_MEMBER(e) {e,#e}
#define _FILE_ENUM(name)\
br_file_enum name##_F = {\
BR_ASIZE(name##_FM),\
name##_FM,\
}
/*
* Constants used to grab bytes out of a byte array mapped onto each type
*/
#if BR_ENDIAN_BIG
#define BR_HTON_64(b) (b)
#define BR_HTON_32(b) (b)
#define BR_HTON_24(b) (b)
#define BR_HTON_16(b) (b)
#define BR_HTON_8(b) (b)
#define BR_HTON_F(b) (b)
#define BR_HTON_D(b) (b)
#define BR_NTOH_64(b) (b)
#define BR_NTOH_32(b) (b)
#define BR_NTOH_24(b) (b)
#define BR_NTOH_16(b) (b)
#define BR_NTOH_8(b) (b)
#define BR_NTOH_F(b) (b)
#define BR_NTOH_D(b) (b)
#endif
#if BR_ENDIAN_LITTLE
#define BR_HTON_64(b) (7-(b))
#define BR_HTON_32(b) (3-(b))
#define BR_HTON_24(b) (2-(b))
#define BR_HTON_16(b) (1-(b))
#define BR_HTON_8(b) (b)
#define BR_HTON_F(b) (3-(b))
#define BR_HTON_D(b) (7-(b))
#define BR_NTOH_64(b) (7-(b))
#define BR_NTOH_32(b) (3-(b))
#define BR_NTOH_24(b) (2-(b))
#define BR_NTOH_16(b) (1-(b))
#define BR_NTOH_8(b) (b)
#define BR_NTOH_F(b) (3-(b))
#define BR_NTOH_D(b) (7-(b))
#endif
struct br_file_primitives;
typedef struct br_datafile {
/*
* File handle
*/
void *h;
/*
* Primitives
*/
struct br_file_primitives *prims;
/*
* Scalar type
*/
br_token scalar_type;
/*
* Resource that any datafile allocations should be attached to
*/
void *res;
} br_datafile;
/*
* Table used to associate chunk ID's with handlers
*/
typedef struct br_chunks_table_entry {
br_uint_32 id;
br_uint_8 has_count;
int (*handler)(br_datafile *df, br_uint_32 id, br_uint_32 length, br_uint_32 count);
} br_chunks_table_entry;
typedef struct br_chunks_table {
int nentries;
br_chunks_table_entry *entries;
} br_chunks_table;
/*
* Vector of functions for reading and writing datafile primitives
*/
typedef struct br_file_primitives {
char *identifier;
/*
* High level file operations
*/
int (*skip) (br_datafile *df, br_uint_32 length);
int (*chunk_write) (br_datafile *df, br_uint_32 id, br_uint_32 length);
int (*chunk_read) (br_datafile *df, br_uint_32 *plength);
void (*count_write) (br_datafile *df, br_uint_32 count);
br_uint_32 (*count_read) (br_datafile *df);
int (*count_size) (br_datafile *df);
br_uint_32 (*struct_write) (br_datafile *df, br_file_struct *str, void *base);
br_uint_32 (*struct_read) (br_datafile *df, br_file_struct *str, void *base);
int (*struct_size) (br_datafile *df, br_file_struct *str, void *base);
int (*block_write) (br_datafile *df, void *base, int block_size, int block_stride, int block_count, int size);
void * (*block_read) (br_datafile *df, void *base, int *pcount, int size, int mtype);
int (*block_size) (br_datafile *df, void *base, int block_size, int block_stride, int block_count, int size);
int (*name_write) (br_datafile *df, char *name);
char * (*name_read) (br_datafile *df, char *name);
int (*name_size) (br_datafile *df, char *name);
} br_file_primitives;
#ifndef _DATAF_P_H_
#include "dataf_p.h"
#endif
#endif

34
core/fw/defdiag.c Normal file
View File

@ -0,0 +1,34 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: defdiag.c 1.1 1997/12/10 16:41:05 jon Exp $
* $Locker: $
*
* Default diagnostic handler that does nothing
*/
#include "brender.h"
BR_RCS_ID("$Id: defdiag.c 1.1 1997/12/10 16:41:05 jon Exp $")
static void BrNullWarning(char *message)
{
}
static void BrNullFailure(char *message)
{
}
/*
* DiagHandler structure
*/
br_errorhandler BrNullDiagHandler = {
"Null DiagHandler",
BrNullWarning,
BrNullFailure,
};
/*
* Global variable that can be overridden by linking something first
*/
br_diaghandler *_BrDefaultDiagHandler = &BrNullDiagHandler;

51
core/fw/deffile.c Normal file
View File

@ -0,0 +1,51 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: deffile.c 1.1 1997/12/10 16:41:06 jon Exp $
* $Locker: $
*
* Default file handler that does nothing
*/
#include "brender.h"
BR_RCS_ID("$Id: deffile.c 1.1 1997/12/10 16:41:06 jon Exp $")
static br_uint_32 BrNullAttributes(void)
{
return 0;
}
static void BrNullOther(void)
{
BR_FATAL0("Invald file system call");
}
/*
* Filesystem structure
*/
br_filesystem BrNullFilesystem = {
"Null Filesystem", /* identifier */
BrNullAttributes, /* attributes */
(void *)BrNullOther, /* open_read */
(void *)BrNullOther, /* openwrite */
(void *)BrNullOther, /* close */
(void *)BrNullOther, /* eof */
(void *)BrNullOther, /* getchar */
(void *)BrNullOther, /* putchar */
(void *)BrNullOther, /* read */
(void *)BrNullOther, /* write */
(void *)BrNullOther, /* getline */
(void *)BrNullOther, /* putline */
(void *)BrNullOther, /* advance */
};
/*
* Global variable that can be overridden by linking something first
*/
br_filesystem *_BrDefaultFilesystem = &BrNullFilesystem;

42
core/fw/defmem.c Normal file
View File

@ -0,0 +1,42 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: defmem.c 1.1 1997/12/10 16:41:06 jon Exp $
* $Locker: $
*
* Default memory handler that does nothing
*/
#include "brender.h"
BR_RCS_ID("$Id: defmem.c 1.1 1997/12/10 16:41:06 jon Exp $")
static void *BrNullAllocate(br_size_t size, br_uint_8 type)
{
return 0;
}
static void BrNullFree(void *mem)
{
}
static br_size_t BrNullInquire(br_uint_8 type)
{
return 0;
}
/*
* Allocator structure
*/
br_allocator BrNullAllocator = {
"Null",
BrNullAllocate,
BrNullFree,
BrNullInquire,
};
/*
* Global variable that can be overridden by linking something first
*/
br_allocator *_BrDefaultAllocator = &BrNullAllocator;

2972
core/fw/dev_objs.cgh Normal file
View File

File diff suppressed because it is too large Load Diff

528
core/fw/dev_objs.hpp Normal file
View File

@ -0,0 +1,528 @@
// Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
//
// $Id: dev_objs.hpp 1.7 1998/11/17 15:58:54 jon Exp $
// $Locker: $
//
// C++ Classes for BRender device interface
// Various structures and dispatch tables used to represent device objects
//
// The formatting of this file is important - it is parsed by classgen.pl to
// produce C headers.
#ifdef __CLASSGEN__
// Macros for declaring overloaded methods
#define CG_F(x) x##F
#define CG_X(x) x##X
#else
#define CG_PUBLIC
#define CG_F(x) x
#define CG_X(x) x
#endif
class br_object;
class br_object_container;
class br_device;
class br_facility;
class br_output_facility;
class br_device_pixelmap;
class br_device_clut;
class br_renderer_facility;
class br_renderer;
class br_geometry;
class br_geometry_format;
class br_geometry_stored;
class br_renderer_state_stored;
class br_map_stored;
class br_table_stored;
struct br_tv_template;
// The root abstract base class for all device objects
//
// Supports queries about the object, both for a few specific
// things (identifer, type & devce), and a more general set of
// token/value queries
class br_object {
public:
// Four slots reserved for the device implementor
//
virtual void BR_METHOD _reserved0(void);
virtual void BR_METHOD _reserved1(void);
virtual void BR_METHOD _reserved2(void);
virtual void BR_METHOD _reserved3(void);
virtual void BR_METHOD free(void);
virtual char * BR_METHOD identifier(void);
virtual br_token BR_METHOD type(void);
virtual br_boolean BR_METHOD isType(br_token t);
virtual class br_device * BR_METHOD device(void);
virtual br_int_32 BR_METHOD space(void);
protected:
virtual struct br_tv_template * BR_METHOD templateQuery(void) = 0;
public:
virtual br_error BR_METHOD query(br_uint_32 *pvalue, br_token t);
virtual br_error BR_METHOD queryBuffer(br_uint_32 *pvalue, br_uint_32 *buffer, br_size_t buffer_size, br_token t);
virtual br_error BR_METHOD queryMany(br_token_value *tv, void *extra, br_size_t extra_size, br_int_32 *pcount);
virtual br_error BR_METHOD queryManySize(br_size_t *pextra_size, br_token_value *tv);
virtual br_error BR_METHOD queryAll(br_token_value *buffer, br_size_t buffer_size);
virtual br_error BR_METHOD queryAllSize(br_size_t *psize);
};
// Abstract base class for an obect that can contain other objects
// Allows objects to be added, removed and enumerated.
class br_object_container : public br_object {
protected:
virtual void * BR_METHOD listQuery(void) = 0;
virtual void * BR_METHOD tokensMatchBegin(br_token t, br_token_value *tv);
virtual br_boolean BR_METHOD tokensMatch(class br_object *h, void *arg);
virtual void BR_METHOD tokensMatchEnd(void *arg);
public:
virtual br_error BR_METHOD addFront(class br_object *h);
virtual br_error BR_METHOD removeFront(class br_object **h);
virtual br_error BR_METHOD remove(class br_object *h);
virtual br_error BR_METHOD find(class br_object **ph, br_token type, char *pattern, br_token_value *tv);
virtual br_error BR_METHOD findMany(class br_object **objects, br_int_32 max_objects,
br_int_32 *pnum_objects, br_token type, char *pattern, br_token_value *tv);
virtual br_error BR_METHOD count(br_uint_32 *pcount, br_token type, char *pattern, br_token_value *tv);
};
// The device object - contains the various type objects
// for services the device has on offer
class br_device : public br_object_container {
public:
};
// Some facility that a device supports
class br_facility : public br_object_container {
public:
};
// A type of output that a device supports. (typically this would
// corespond to a screen mode).
//
// device_pixelmaps (and, if supported, CLUTs) can be instantiated from this
class br_output_facility : public br_facility {
public:
virtual br_error BR_METHOD validSource(br_boolean *bp, class br_object *h);
virtual br_error BR_METHOD pixelmapNew(class br_device_pixelmap **ppmap, br_token_value *tv);
virtual br_error BR_METHOD clutNew(class br_device_clut **pclut, br_token_value *tv);
virtual br_error BR_METHOD queryCapability(br_token_value *buffer_in, br_token_value *buffer_out,
br_size_t size_buffer_out);
};
// A drawable surface - compatibile with br_pixelmap. May represent
// the screen, the off-screen buffer a depth buffer or others.
class br_device_pixelmap : public br_object {
public:
// Public fields for compatibility with br_pixelmap
CG_PUBLIC char *pm_identifier ;
CG_PUBLIC BR_PIXELMAP_MEMBERS
virtual br_error BR_METHOD validSource(br_boolean *bp, class br_object *h);
virtual br_error BR_METHOD resize(br_int_32 width, br_int_32 height);
virtual br_error BR_METHOD match(class br_device_pixelmap **newpm, br_token_value *tv);
virtual br_error BR_METHOD allocateSub(class br_device_pixelmap **newpm, br_rectangle *rect);
// Operations on whole pixemap (with versions that include a hint dirty rectangle)
virtual br_error BR_METHOD copy(class br_device_pixelmap *src);
virtual br_error BR_METHOD copyTo(class br_device_pixelmap *src);
virtual br_error BR_METHOD copyFrom(class br_device_pixelmap *src);
virtual br_error BR_METHOD fill(br_uint_32 colour);
virtual br_error BR_METHOD doubleBuffer(class br_device_pixelmap *src);
virtual br_error BR_METHOD copyDirty(class br_device_pixelmap *src, br_rectangle *dirty, br_int_32 num_rects);
virtual br_error BR_METHOD copyToDirty(class br_device_pixelmap *src, br_rectangle *dirty, br_int_32 num_rects);
virtual br_error BR_METHOD copyFromDirty(class br_device_pixelmap *src, br_rectangle *dirty, br_int_32 num_rects);
virtual br_error BR_METHOD fillDirty(br_uint_32 colour, br_rectangle *dirty, br_int_32 num_rects);
virtual br_error BR_METHOD doubleBufferDirty(class br_device_pixelmap *src, br_rectangle *dirty, br_int_32 num_rects);
// Direct 2D rendering operations
virtual br_error BR_METHOD rectangle(br_rectangle *rect, br_uint_32 colour);
virtual br_error BR_METHOD rectangle2(br_rectangle *rect, br_uint_32 colour_tl, br_uint_32 colour_br);
virtual br_error BR_METHOD rectangleCopy(br_point *p, class br_device_pixelmap *src, br_rectangle *src_rect);
virtual br_error BR_METHOD rectangleCopyTo(br_point *p, class br_device_pixelmap *src, br_rectangle *src_rect);
virtual br_error BR_METHOD rectangleCopyFrom(br_point *p, class br_device_pixelmap *src, br_rectangle *src_rect);
virtual br_error BR_METHOD rectangleStretchCopy(br_rectangle *r,class br_device_pixelmap *s,br_rectangle *q);
virtual br_error BR_METHOD rectangleStretchCopyTo(br_rectangle *r,class br_device_pixelmap *s,br_rectangle *q);
virtual br_error BR_METHOD rectangleStretchCopyFrom(br_rectangle *r,class br_device_pixelmap *s,br_rectangle *q);
virtual br_error BR_METHOD rectangleFill(br_rectangle *rect, br_uint_32 colour);
virtual br_error BR_METHOD pixelSet(br_point *point, br_uint_32 colour);
virtual br_error BR_METHOD line(br_point *start, br_point *end, br_uint_32 colour);
virtual br_error BR_METHOD copyBits(br_point *point,
br_uint_8 *src,br_uint_16 s_stride,
br_rectangle *bit_rect,
br_uint_32 colour);
// Text
virtual br_error BR_METHOD text(br_point *point, br_font *font, char *text, br_uint_32 colour);
virtual br_error BR_METHOD textBounds(br_rectangle *rect, struct br_font *font, char *text);
// Row read/write
virtual br_error BR_METHOD rowSize(br_size_t *size);
virtual br_error BR_METHOD rowSet(void *buffer, br_size_t buffer_size, br_uint_32 row);
virtual br_error BR_METHOD rowQuery(void *buffer, br_size_t buffer_size, br_uint_32 row);
// Reading back
virtual br_error BR_METHOD pixelQuery(br_uint_32 *pcolour, br_point *point);
virtual br_error BR_METHOD pixelAddressQuery(void **pptr, br_uint_32 *pqual, br_point *point);
// Updating the pixelmap
virtual br_error BR_METHOD pixelAddressSet(void *ptr, br_uint_32 *qual);
virtual br_error BR_METHOD originSet(br_point *p);
// Flush any cached output
virtual br_error BR_METHOD flush(void);
// Syncronisation
virtual br_error BR_METHOD synchronise(br_token sync_type, br_boolean block);
// Locking/unlocking for direct pixel access
//
virtual br_error BR_METHOD directLock(br_boolean block);
virtual br_error BR_METHOD directUnlock(void);
// Locking/unlocking for direct pixel access
//
virtual br_error BR_METHOD getControls(br_display_controls *controls);
virtual br_error BR_METHOD setControls(br_display_controls *controls);
};
// A device Colour LookUp Table
//
// There may be multiple instances of this, if the device supports
// it. (eg: CLUT per wndows)
class br_device_clut : public br_object {
public:
virtual br_error BR_METHOD entrySet(br_int_32 index, br_colour entry);
virtual br_error BR_METHOD entryQuery(br_colour *entry, br_int_32 index);
virtual br_error BR_METHOD entrySetMany(br_int_32 index, br_int_32 count, br_colour *entries);
virtual br_error BR_METHOD entryQueryMany(br_colour *entries, br_int_32 index, br_int_32 count);
};
// A type of renderer - this class contains all instaniated renderers
// of this type, and the stored maps, tables and states associated
// with this type of renderer
class br_renderer_facility : public br_facility {
public:
virtual br_error BR_METHOD validDestination(br_boolean *bp, class br_object *h);
virtual br_error BR_METHOD rendererNew(class br_renderer **prenderer, br_token_value *tv);
};
// An active renderer
class br_renderer : public br_object_container {
public:
virtual br_error BR_METHOD validDestination(br_boolean *bp, class br_object *h);
// Creating new stored states
virtual br_error BR_METHOD stateStoredNew(class br_renderer_state_stored **pstate,
br_uint_32 mask, br_token_value *tv);
virtual br_error BR_METHOD stateStoredAvail(br_int_32 *psize, br_uint_32 mask, br_token_value *tv);
// Creating new stored input buffers
virtual br_error BR_METHOD bufferStoredNew(class br_buffer_stored **rtp,
br_token use, class br_device_pixelmap *pm, br_token_value *tv);
virtual br_error BR_METHOD bufferStoredAvail(br_int_32 *space,
br_token use, br_token_value *tv);
// Writing current state
virtual br_error BR_METHOD partSet(br_token part, br_int_32 index, br_token t, br_uint_32 pvalue);
virtual br_error BR_METHOD partSetMany(br_token part, br_int_32 index, br_token_value * tv, br_int_32 *pcount);
// Reading current state
virtual br_error BR_METHOD partQuery(br_token part, br_int_32 index, br_uint_32 *pvalue, br_token t);
virtual br_error BR_METHOD partQueryBuffer(br_token part, br_int_32 index, br_uint_32 *pvalue,
br_uint_32 *buffer, br_size_t buffer_size, br_token t);
virtual br_error BR_METHOD partQueryMany(br_token part, br_int_32 index,
br_token_value *tv, void *extra, br_size_t extra_size, br_int_32 *pcount);
virtual br_error BR_METHOD partQueryManySize(br_token part, br_int_32 index, br_size_t *pextra_size, br_token_value *tv);
virtual br_error BR_METHOD partQueryAll(br_token part, br_int_32 index, br_token_value *buffer, br_size_t buffer_size);
virtual br_error BR_METHOD partQueryAllSize(br_token part, br_int_32 index, br_size_t *psize);
// Find out the range of indices for a part
virtual br_error BR_METHOD partIndexQuery(br_token part, br_int_32 *pnindex);
// Special case state manipulation for ease of use
virtual br_error BR_METHOD CG_F(modelMul)(br_matrix34_f *m);
virtual br_error BR_METHOD CG_X(modelMul)(br_matrix34_x *m);
virtual br_error BR_METHOD CG_F(modelPopPushMul)(br_matrix34_f *m);
virtual br_error BR_METHOD CG_X(modelPopPushMul)(br_matrix34_x *m);
virtual br_error BR_METHOD modelInvert(void);
// State stacking and saving
virtual br_error BR_METHOD statePush(br_uint_32 mask);
virtual br_error BR_METHOD statePop(br_uint_32 mask);
virtual br_error BR_METHOD stateSave(class br_renderer_state_stored *h, br_uint_32 mask);
virtual br_error BR_METHOD stateRestore(class br_renderer_state_stored *h, br_uint_32 mask);
// Given a list of parts, produce a value for the push/pop/default/save/restore masks
virtual br_error BR_METHOD stateMask(br_uint_32 *mask, br_token *parts, int n_parts);
// Reset parts of state to the default
virtual br_error BR_METHOD stateDefault(br_uint_32 mask);
// Various queries based on current transforms
virtual br_error BR_METHOD CG_F(boundsTest)(br_token *r, br_bounds3_f *bounds);
virtual br_error BR_METHOD CG_X(boundsTest)(br_token *r, br_bounds3_x *bounds);
virtual br_error BR_METHOD CG_F(coverageTest)(br_float *r, br_bounds3_f *bounds);
virtual br_error BR_METHOD CG_X(coverageTest)(br_fixed_ls *r, br_bounds3_x *bounds);
virtual br_error BR_METHOD CG_F(viewDistance)(br_float *r);
virtual br_error BR_METHOD CG_X(viewDistance)(br_fixed_ls *r);
// Control current command mode
virtual br_error BR_METHOD commandModeSet(br_token mode);
virtual br_error BR_METHOD commandModeQuery(br_token *mode);
virtual br_error BR_METHOD commandModeDefault(void);
virtual br_error BR_METHOD commandModePush(void);
virtual br_error BR_METHOD commandModePop(void);
// Flush any cached output
virtual br_error BR_METHOD flush(br_boolean wait);
// Sync. waiting
virtual br_error BR_METHOD synchronise(br_token sync_type, br_boolean block);
#if 0
// Possible additions
//
virtual br_error modelToView
virtual br_error modelToScreen
virtual br_error viewToModel
virtual br_error viewToScreen
virtual br_error screenToModel
virtual br_error screenToView
#endif
#if 0
// Test hook
//
virtual br_error BR_METHOD testRender(br_token type,
union brp_vertex *v0,
union brp_vertex *v1,
union brp_vertex *v2);
#endif
// Query state performance
virtual br_error BR_METHOD partQueryCapability(br_token part, br_int_32 index, br_token_value *buffer,
br_size_t buffer_size);
virtual br_error BR_METHOD stateQueryPerformance(br_fixed_lu *speed);
virtual br_error BR_METHOD frameBegin(void);
virtual br_error BR_METHOD frameEnd(void);
virtual br_error BR_METHOD focusLossBegin(void);
virtual br_error BR_METHOD focusLossEnd(void);
};
// Stored renderer state
class br_renderer_state_stored : public br_object {
public:
};
// Abstract base class for some sort of geometry that can be stuffed into a renderer
class br_geometry : public br_object {
public:
}
// Stored geometry
class br_geometry_stored : public br_geometry {
public:
virtual br_error BR_METHOD render(class br_renderer *r);
virtual br_error BR_METHOD renderOnScreen(class br_renderer *r);
}
// Predefined geometry formats
class br_geometry_primitives : public br_geometry {
public:
virtual br_error BR_METHOD CG_F(render)(class br_renderer *r,
struct fmt_vertex *vertices, int nvertices, br_token type);
virtual br_error BR_METHOD CG_X(render)(class br_renderer *r,
struct fmt_vertex *vertices, int nvertices, br_token type);
virtual br_error BR_METHOD CG_F(renderOnScreen)(class br_renderer *r,
struct fmt_vertex *vertices, int nvertices, br_token type);
virtual br_error BR_METHOD CG_X(renderOnScreen)(class br_renderer *r,
struct fmt_vertex *vertices, int nvertices, br_token type);
virtual br_error BR_METHOD CG_F(storedNew)(class br_renderer *r,
class br_geometry_stored **psg,
struct fmt_vertex *vertices, int nvertices, br_token type, br_token_value *tv);
virtual br_error BR_METHOD CG_X(storedNew)(class br_renderer *r,
class br_geometry_stored **psg,
struct fmt_vertex *vertices, int nvertices, br_token type, br_token_value *tv);
virtual br_error BR_METHOD storedAvail(br_int_32 *psize, br_token_value *tv);
}
class br_geometry_v1_model : public br_geometry {
public:
virtual br_error BR_METHOD CG_F(render)(class br_renderer *r, struct v1model_f *model,
class br_renderer_state_stored *default_state,
br_token type);
virtual br_error BR_METHOD CG_X(render)(class br_renderer *r, struct v1model_x *model,
class br_renderer_state_stored *default_state,
br_token type);
virtual br_error BR_METHOD CG_F(renderOnScreen)(class br_renderer *r, struct v1model_f *model,
class br_renderer_state_stored *default_state,
br_token type);
virtual br_error BR_METHOD CG_X(renderOnScreen)(class br_renderer *r, struct v1model_x *model,
class br_renderer_state_stored *default_state,
br_token type);
virtual br_error BR_METHOD CG_F(storedNew)(class br_renderer *r, class br_geometry_stored **psg,
struct v1model_f *model, br_token type, br_token_value *tv);
virtual br_error BR_METHOD CG_X(storedNew)(class br_renderer *r, class br_geometry_stored **psg,
struct v1model_x *model, br_token type, br_token_value *tv);
virtual br_error BR_METHOD storedAvail(br_int_32 *psize, br_token_value *tv);
}
class br_geometry_v1_buckets : public br_geometry {
public:
virtual br_error BR_METHOD render(class br_renderer *r,
class br_primitive **buckets, br_int_32 nbuckets);
virtual br_error BR_METHOD renderOnScreen(class br_renderer *r,
class br_primitive **buckets, br_int_32 nbuckets);
}
class br_geometry_lighting : public br_geometry {
public:
virtual br_error BR_METHOD CG_F(render)(class br_renderer *r,
br_vector3_f *points, br_vector3_f *normals, br_colour *colour_in,
br_colour *colour_out, br_uint_16 *redirect, int pstride, int nstride,
int cinstride, int coutstride, int nvertices);
virtual br_error BR_METHOD CG_X(render)(class br_renderer *r,
br_vector3_x *points, br_vector3_x *normals, br_colour *colour_in,
br_colour *colour_out, br_uint_16 *redirect, int pstride, int nstride,
int cinstride, int coutstride, int nvertices);
}
// Stored texture map/table etc.
class br_buffer_stored : public br_object {
public:
virtual br_error BR_METHOD update(class br_device_pixelmap *pm, br_token_value *tv);
};
// Primitives library
class br_primitive_library : public br_object_container {
public:
virtual br_error BR_METHOD stateNew(class br_primitive_state **rps);
virtual br_error BR_METHOD bufferStoredNew(class br_buffer_stored **rtp,
br_token use, class br_device_pixelmap *pm, br_token_value *tv);
virtual br_error BR_METHOD bufferStoredAvail(br_int_32 *space,
br_token use, br_token_value *tv);
virtual br_error BR_METHOD flush(br_boolean wait);
virtual br_error BR_METHOD synchronise(br_token sync_type, br_boolean block);
// Given a list of parts, produce a bitmask
virtual br_error BR_METHOD mask(br_uint_32 *mask, br_token *parts, int n_parts);
};
// Primitives state
class br_primitive_state : public br_object {
public:
// Writing current state
virtual br_error BR_METHOD partSet(br_token part, br_int_32 index, br_token t, br_uint_32 value);
virtual br_error BR_METHOD partSetMany(br_token part, br_int_32 index, br_token_value * tv, br_int_32 *pcount);
// Reading current state
virtual br_error BR_METHOD partQuery(br_token part, br_int_32 index, br_uint_32 *pvalue, br_token t);
virtual br_error BR_METHOD partQueryBuffer(br_token part, br_int_32 index, br_uint_32 *pvalue,
br_uint_32 *buffer, br_size_t buffer_size, br_token t);
virtual br_error BR_METHOD partQueryMany(br_token part, br_int_32 index,
br_token_value *tv, void *extra, br_size_t extra_size, br_int_32 *pcount);
virtual br_error BR_METHOD partQueryManySize(br_token part, br_int_32 index, br_size_t *pextra_size, br_token_value *tv);
virtual br_error BR_METHOD partQueryAll(br_token state, br_int_32 index, br_token_value *buffer, br_size_t buffer_size);
virtual br_error BR_METHOD partQueryAllSize(br_token part, br_int_32 index, br_size_t *psize);
// Find out the range of indices for a part
virtual br_error BR_METHOD partIndexQuery(br_token part, br_int_32 *pnindex);
// Reset parts of state to the default
virtual br_error BR_METHOD stateDefault(br_uint_32 mask);
// Copy parts of state from one to another
virtual br_error BR_METHOD stateCopy(class br_primitive_state *source, br_uint_32 mask);
// Get a pointer to a primitive block representing the current state
//
virtual br_error BR_METHOD renderBegin(class brp_block **rpb,
br_boolean *block_changed, br_boolean *ranges_changed, br_boolean no_render,
br_int_32 prim_type);
virtual br_error BR_METHOD renderEnd(class brp_block *rpb);
// Find the current component transformations
//
virtual br_error BR_METHOD CG_F(rangesQuery)(br_float *offset, br_float *scale, br_int_32 max_comp);
virtual br_error BR_METHOD CG_X(rangesQuery)(br_fixed_ls *offset, br_fixed_ls *scale, br_int_32 max_comp);
// Query state performance
virtual br_error BR_METHOD partQueryCapability(br_token part, br_int_32 index, br_token_value *buffer,
br_size_t buffer_size);
virtual br_error BR_METHOD stateQueryPerformance(br_fixed_lu *speed);
};

403
core/fw/devlist.c Normal file
View File

@ -0,0 +1,403 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: devlist.c 1.1 1997/12/10 16:41:06 jon Exp $
* $Locker: $
*
* XXX Need to keep track of images that devices came from and dereference
* them in BrDevRemove
*/
#include "fw.h"
#include "brassert.h"
BR_RCS_ID("$Id: devlist.c 1.1 1997/12/10 16:41:06 jon Exp $")
extern br_framework_state BR_ASM_DATA fw ;
/* Add drivers specified in the BRENDER_DRIVERS configuration entry
* This is only done once, so check it has not already been done
*/
static br_error AddRequestedDrivers()
{
char devstr[256];
static br_boolean bAlreadyDone = BR_FALSE ;
if ( !fw.bAlreadyLoadedDrivers )
{
BrSystemConfigQueryString( BRT_BRENDER_DRIVERS_STR, devstr, BR_ASIZE(devstr) );
if ( *devstr != '\0' )
BrDevAddConfig(devstr);
fw.bAlreadyLoadedDrivers = BR_TRUE ;
}
return BRE_OK ;
}
/*
* Instantiate a device and add it to internal list given entry point
*/
static br_error devAdd(br_device **pdev, br_device_begin_fn *dev_begin, char *args, br_image *image)
{
int i;
br_device *dev;
struct br_open_device *new_slots;
/*
* Cal the driver entry point, which should return a pointer to
* device object, or NULL if things went wrong
*/
dev = dev_begin(args);
if(dev == NULL)
return BRE_FAIL;
/*
* Got device, find free slot
*/
for(i=0; i < fw.ndev_slots; i++) {
if(fw.dev_slots[i].dev == NULL) {
/*
* Fill in slot, including optional image pointer
*/
fw.dev_slots[i].dev = dev;
fw.dev_slots[i].image = image;
if(pdev)
*pdev = dev;
return BRE_OK;
}
}
/*
* Need to expand array
*/
new_slots = BrResAllocate(dev, (fw.ndev_slots+NDEV_SLOTS) * sizeof(*fw.dev_slots), BR_MEMORY_DRIVER );
if(new_slots == NULL) {
ObjectFree(dev);
return BRE_NO_MEMORY;
}
for(i=0; i < fw.ndev_slots; i++)
new_slots[i] = fw.dev_slots[i];
BrResFree(fw.dev_slots);
/*
* Fill in slot, including optional image pointer
*/
fw.dev_slots = new_slots;
new_slots[fw.ndev_slots].dev = dev;
new_slots[fw.ndev_slots].image = image;
fw.ndev_slots += NDEV_SLOTS;
if(pdev)
*pdev = dev;
return BRE_OK;
}
/*
* Instantiate a new device and add it to internal list given image name
*/
br_error BR_RESIDENT_ENTRY BrDevAdd(br_device **pdev, char * image, char *args)
{
br_image *dev_image;
br_device_begin_fn *dev_begin;
ASSERT(image != NULL);
/*
* Try and load up device
*/
dev_image = BrImageReference(image);
if(dev_image == NULL) {
return BRE_FAIL;
}
/*
* Look up the driver entry point
*/
dev_begin = BrImageLookupName(dev_image, "BrDrv1Begin",0);
if(dev_begin == NULL) {
BrImageDereference(dev_image);
return BRE_FAIL;
}
/*
* Add device to internal list, remebering the iamge pointer for later
*/
return devAdd(pdev, dev_begin, args, dev_image);
}
/*
* Add a driver that is already in memory by some other means (like being statically linked)
*/
br_error BR_RESIDENT_ENTRY BrDevAddStatic(br_device **pdev, br_device_begin_fn *dev_begin, char *args)
{
/*
* Add to internal list, with a NULL image pointer
*/
return devAdd(pdev, dev_begin, args, NULL);
}
/*
* See if a device is loaded, if not, load it
*/
br_error BR_RESIDENT_ENTRY BrDevCheckAdd(br_device **pdev, char *name, char *args)
{
/*
* Is device already there?
*/
if(BrDevFind(pdev, name) == BRE_OK)
return BRE_OK;
/*
* Add it
*/
return BrDevAdd(pdev, name, args);
}
/*
* Take a config string and split it into <dev_args>{;<dev_args>}
*
* Add each device in turn with it's arguments
*/
br_error BR_RESIDENT_ENTRY BrDevAddConfig(char *config)
{
char *end, *dev, *arg;
char tmp[512];
int n;
for(;;) {
/*
* Find next semi. or end of string
*/
for(end = config; *end != '\0' && *end != ';' ; end++)
;
n = end - config;
if(n) {
/*
* Make a copy of this device string
*/
BrMemCpy(tmp, config, n);
tmp[n] = '\0';
dev = tmp;
/*
* Find device arguments
*/
for(arg = tmp; *arg != '\0' && *arg != ',' && *arg != ':'; arg++)
;
if(*arg) {
*arg = '\0';
arg++;
}
/*
* Add the device
*/
while(BrIsSpace(*dev))
dev++;
n = BrStrLen(dev);
if(n) {
while(BrIsSpace(dev[n-1])) {
dev[n-1] = '\0';
n--;
}
BrDevAdd(NULL, dev, arg);
}
}
if(*end == ';')
config = end+1;
else
break;
}
return BRE_OK;
}
/*
* Close down device and remove it from list
*/
br_error BR_RESIDENT_ENTRY BrDevRemove(br_device *dev)
{
int i;
/*
* Find device in list
*/
for(i=0; i < fw.ndev_slots; i++) {
if(fw.dev_slots[i].dev == dev) {
/*
* Found it - release object
*/
ObjectFree(dev);
/*
* If there was an image associated with device, dereference it
*/
if(fw.dev_slots[i].image) {
BrImageDereference(fw.dev_slots[i].image);
}
fw.dev_slots[i].dev = NULL;
fw.dev_slots[i].image = NULL;
}
}
return BRE_OK;
}
/*
* Find a named device
*/
br_error BR_RESIDENT_ENTRY BrDevFind(struct br_device **pdev, char *pattern)
{
int i,c;
AddRequestedDrivers();
for(i=0,c=0; i < fw.ndev_slots; i++) {
if(fw.dev_slots[i].dev) {
if(BrNamePatternMatch(pattern,ObjectIdentifier(fw.dev_slots[i].dev))) {
if(pdev)
*pdev = fw.dev_slots[i].dev;
return BRE_OK;
}
}
}
return BRE_FAIL;
}
/*
* Fill in an array of pointers to loaded devices mathcing pattern
*/
br_error BR_RESIDENT_ENTRY BrDevFindMany(struct br_device **devices, br_int_32 *ndevices, br_int_32 max_devices, char *pattern)
{
int i,c;
AddRequestedDrivers();
for(i=0,c=0; i < fw.ndev_slots; i++) {
if(fw.dev_slots[i].dev &&
BrNamePatternMatch(pattern,ObjectIdentifier(fw.dev_slots[i].dev))) {
if(++c >= max_devices)
return BRE_OVERFLOW;
devices[c] = fw.dev_slots[i].dev;
}
}
if(ndevices)
*ndevices = c;
return BRE_OK;
}
/*
* Find number of loaded devices
*/
br_error BR_RESIDENT_ENTRY BrDevCount(br_int_32 *ndevices, char *pattern)
{
int i,c;
AddRequestedDrivers();
for(i=0,c=0; i < fw.ndev_slots; i++)
if(fw.dev_slots[i].dev &&
BrNamePatternMatch(pattern,ObjectIdentifier(fw.dev_slots[i].dev)))
c++;
if(ndevices)
*ndevices = c;
return BRE_OK;
}
/*
* Search over all loaded devices for a type of object
*/
br_error BR_RESIDENT_ENTRY BrDevContainedFind(struct br_object **ph, br_token type, char *pattern, br_token_value *tv)
{
int i;
AddRequestedDrivers();
for(i=0; i < fw.ndev_slots; i++)
if(fw.dev_slots[i].dev && (ObjectContainerFind(fw.dev_slots[i].dev, ph, type, pattern, tv) == BRE_OK))
return BRE_OK;
return BRE_FAIL;
}
br_error BR_RESIDENT_ENTRY BrDevContainedFindMany(struct br_object **objects, br_int_32 max_objects,
br_int_32 *pnum_objects, br_token type, char *pattern, br_token_value *tv)
{
int i;
br_int_32 n,total = 0;
br_error r;
AddRequestedDrivers();
for(i=0; i < fw.ndev_slots; i++) {
if(fw.dev_slots[i].dev) {
r = ObjectContainerFindMany(fw.dev_slots[i].dev, objects, max_objects, &n, type, pattern, tv);
if(r != BRE_OK)
return r;
objects += n;
max_objects -= n;
total += n;
}
}
if(pnum_objects)
*pnum_objects = total;
return BRE_OK;
}
br_error BR_RESIDENT_ENTRY BrDevContainedCount(br_int_32 *pcount, br_token type, char *pattern, br_token_value *tv)
{
int i;
br_int_32 n,total = 0;
br_error r;
AddRequestedDrivers();
for(i=0; i < fw.ndev_slots; i++) {
if(fw.dev_slots[i].dev) {
r = ObjectContainerCount(fw.dev_slots[i].dev, &n, type, pattern, tv);
if(r != BRE_OK)
return r;
total += n;
}
}
if(pcount)
*pcount = total;
return BRE_OK;
}

270
core/fw/devquery.c Normal file
View File

@ -0,0 +1,270 @@
/*
* Copyright (c) 1993-1996 Argonaut Technologies Limited. All rights reserved.
*
* $Id: devquery.c 1.2 1997/12/11 13:34:07 jon Exp $
* $Locker: $
*
* Routines for querying devices
*/
#include "brender.h"
#include "fw.h"
#include "brassert.h"
BR_RCS_ID("$Id: devquery.c 1.2 1997/12/11 13:34:07 jon Exp $")
STATIC br_boolean deviceEnum(br_device *dev, br_device_enum_cbfn *cbfn,
void *args)
{
br_size_t s;
void *mem;
br_token_value *tvp;
char *identifier = NULL, *creator = NULL, *title = NULL, *product = NULL,
*product_version = NULL;
br_uint_32 version = 0;
br_boolean terminate;
ObjectQueryAllSize((br_object *)dev, &s);
if(s) {
mem = BrMemAllocate(s, BR_MEMORY_APPLICATION);
tvp = (br_token_value *)mem;
ObjectQueryAll((br_object *)dev, mem, s);
while(tvp->t != BR_NULL_TOKEN){
switch(tvp->t){
case BRT_IDENTIFIER_CSTR :
identifier = tvp->v.cstr;
break;
case BRT_VERSION_U32 :
version = tvp->v.u32;
break;
case BRT_CREATOR_CSTR :
creator = tvp->v.cstr;
break;
case BRT_TITLE_CSTR :
title = tvp->v.cstr;
break;
case BRT_PRODUCT_CSTR :
product = tvp->v.cstr;
break;
case BRT_PRODUCT_VERSION_CSTR :
product_version = tvp->v.cstr;
break;
default :
break;
}
tvp++;
}
terminate = cbfn(identifier, version, creator, title, product,
product_version, args);
BrMemFree(mem);
}
return terminate;
}
br_error BR_PUBLIC_ENTRY BrDeviceEnum(br_device_enum_cbfn *cbfn, void *args)
{
char devices_str[512], *device_name, *device_args, *next_device;
br_device *device;
br_error r;
br_boolean pass_args = BR_TRUE;
br_boolean terminate = BR_FALSE;
int n;
UASSERT(cbfn != NULL);
BrSystemConfigQueryString(BRT_BRENDER_DEVICES_STR, devices_str,
BR_ASIZE(devices_str));
// If BRENDER_DEVICES is not set, use whatever value is
// in BRENDER_DEFAULT_DEVICE instead.
if (*devices_str == '\0') {
BrSystemConfigQueryString(BRT_DEFAULT_DEVICE_STR,
devices_str, BR_ASIZE(devices_str));
pass_args = BR_FALSE;
}
for (device_name = devices_str; !terminate && *device_name != '\0'; device_name = next_device) {
/*
* Parse devices string into device name, arguments
* string and next entry
*/
for (device_args = device_name; *device_args != '\0' && *device_args != ',' && *device_args != ';'; device_args++)
;
if (*device_args == ',') {
*device_args = '\0';
device_args++;
}
for (next_device = device_args; *next_device != '\0' && *next_device != ';'; next_device++)
;
if (*next_device != '\0') {
*next_device = '\0';
next_device++;
}
/*
* Trim white space from name
*/
while (BrIsSpace(*device_name))
device_name++;
n = BrStrLen(device_name);
if (n) {
while (BrIsSpace(device_name[n-1])) {
device_name[n-1] = '\0';
n--;
}
}
/*
* Pass the device to the callback, adding and removing if necessary
*/
if (n) {
r = BrDevFind(&device, device_name);
if (r == BRE_OK) {
terminate = deviceEnum(device, cbfn, args);
} else {
r = BrDevAdd(&device, device_name, pass_args? device_args: NULL);
if (r == BRE_OK) {
terminate = deviceEnum(device, cbfn, args);
BrDevRemove(device);
}
}
}
}
return BRE_OK;
}
STATIC br_boolean outfctyEnum(br_object *outfcty, br_outfcty_enum_cbfn *cbfn,
void *args)
{
br_size_t s;
void *mem;
br_token_value *tvp;
char *identifier = NULL;
br_outfcty_desc desc;
br_uint_32 version = 0;
br_boolean terminate = BR_FALSE;
desc.output_facility = (struct br_output_facility *)outfcty;
identifier = NULL;
desc.width = NULL;
desc.width_min = NULL;
desc.width_max = NULL;
desc.height = NULL;
desc.height_min = NULL;
desc.height_max = NULL;
desc.pmtype = 0;
desc.pmbits = 0;
desc.indexed = BR_FALSE;
desc.fullscreen = BR_TRUE;
ObjectQueryAllSize(outfcty, &s);
if(s) {
mem = BrMemAllocate(s, BR_MEMORY_APPLICATION);
tvp = (br_token_value *)mem;
ObjectQueryAll(outfcty, mem, s);
while(tvp->t != BR_NULL_TOKEN){
switch(tvp->t){
case BRT_IDENTIFIER_CSTR :
identifier = tvp->v.cstr;
break;
case BRT_WIDTH_I32 :
desc.width = tvp->v.i32;
break;
case BRT_WIDTH_MIN_I32 :
desc.width_min = tvp->v.i32;
break;
case BRT_WIDTH_MAX_I32 :
desc.width_max = tvp->v.i32;
break;
case BRT_HEIGHT_I32 :
desc.height = tvp->v.i32;
break;
case BRT_HEIGHT_MIN_I32 :
desc.height_min = tvp->v.i32;
break;
case BRT_HEIGHT_MAX_I32 :
desc.height_max = tvp->v.i32;
break;
case BRT_PIXEL_TYPE_U8 :
desc.pmtype = tvp->v.u8;
break;
case BRT_PIXEL_BITS_I32 :
desc.pmbits = tvp->v.i32;
break;
case BRT_INDEXED_B :
desc.indexed = tvp->v.b;
break;
case BRT_WINDOW_FULLSCREEN_B :
desc.fullscreen = tvp->v.b;
break;
default :
break;
}
tvp++;
}
terminate = cbfn(identifier, &desc, args);
BrMemFree(mem);
}
return terminate;
}
br_error BR_PUBLIC_ENTRY BrOutputFacilityEnum(char *name,
br_outfcty_enum_cbfn *cbfn,
void *args)
{
br_device *device;
br_object **objects;
br_int_32 max, n;
br_error r;
br_boolean terminate = BR_FALSE, remove = BR_FALSE;
if(BrDevFind(&device, name) == BRE_FAIL){
r = BrDevAdd(&device, name, NULL);
if(r != BRE_OK)
return r;
remove = BR_TRUE;
}
ObjectContainerCount(device, &max, BRT_OUTPUT_FACILITY, NULL, NULL);
objects = BrMemAllocate(max * sizeof(*objects), BR_MEMORY_APPLICATION);
ObjectContainerFindMany(device, objects, max, &n, BRT_OUTPUT_FACILITY, NULL, NULL);
ASSERT(max == n);
for(n = 0; (n < max) && !terminate; n++)
terminate = outfctyEnum(objects[n], cbfn, args);
BrMemFree(objects);
if(remove)
BrDevRemove(device);
return BRE_OK;
}

998
core/fw/devsetup.c Normal file
View File

@ -0,0 +1,998 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: devsetup.c 1.2 1997/12/11 13:33:10 jon Exp $
* $Locker: $
*
* XXX should condense all the BrXXXFind() functions into one,
* since the logic is the same for each!
*/
#include <stdio.h>
#include <stdarg.h>
#include "fw.h"
#include "host.h"
#include "brassert.h"
BR_RCS_ID("$Id: devsetup.c 1.2 1997/12/11 13:33:10 jon Exp $")
/*
* XXX A very nasty hack to get around limitiations of v1.1.x
*
* BrZbBegin() does not get access to the destination screen!
*/
static br_pixelmap *last_begin_screen;
br_pixelmap * BrDevLastBeginQuery(void)
{
return last_begin_screen;
}
void BrDevLastBeginSet(br_pixelmap *pm)
{
last_begin_screen = pm;
}
/*
* Produce a new output screen pixelmap from a list of token value pairs
*/
br_error BR_PUBLIC_ENTRY BrDevBeginVar(br_pixelmap **ppm, char *setup_string, ...)
{
va_list vl;
br_uint_32 i, n;
br_token_value tv[64];
/*
* Convert arguments to token/value pairs
*/
va_start(vl, setup_string);
for(i = 0, n = BR_NULL_TOKEN;; i++) {
if (i == BR_ASIZE(tv))
BR_FAILURE("Too many token value pairs");
if ((n = va_arg(vl, int)) == BR_NULL_TOKEN)
break;
*((int *)&tv[i].t) = n;
n = va_arg(vl, int);
*((int *)&tv[i].v.u32) = n;
}
tv[i].t = BR_NULL_TOKEN;
tv[i].v.u32 = 0;
va_end(vl);
return BrDevBeginTV(ppm, setup_string, tv);
}
/*
* Takes a setup string and produces a new output screen pixelmap
*/
br_error BR_PUBLIC_ENTRY BrDevBegin(br_pixelmap **ppm, char *setup_string)
{
return BrDevBeginTV(ppm, setup_string, NULL);
}
/*
* Takes a setup string and NULL terminated list of setup token-value pairs
* and produces a new output screen pixelmap
*/
br_error BR_PUBLIC_ENTRY BrDevBeginTV(br_pixelmap **ppm, char *setup_string, br_token_value *setup_tv)
{
char str[512], *args = NULL, *devname, *devargs;
char devices_str[512], *device_name, *device_args, *next_device;
br_token_value args_tv[64], *tv = NULL;
br_output_facility *output_facility;
br_device *device;
br_pixelmap *screen;
int i, n;
br_error r;
/*
* Find which argument string to use
*/
if(setup_string == NULL) {
BrSystemConfigQueryString(BRT_DEFAULT_DEVICE_STR, str, BR_ASIZE(str));
} else {
BrStrNCpy(str, setup_string, BR_ASIZE(str));
str[BR_ASIZE(str)-1] = '\0';
}
/*
* Parse argument string into device name and arguments string
*/
for(args = str; *args != '\0' && *args != ','; args++)
;
if(*args != '\0') {
*args = '\0';
args++;
}
/*
* Trim white space from name
*/
devname = str;
while(BrIsSpace(*devname))
devname++;
n = BrStrLen(devname);
if(n) {
while(BrIsSpace(devname[n-1])) {
devname[n-1] = '\0';
n--;
}
}
/*
* If device name is empty, search all loaded devices
*/
if(n == 0 || (n == 1 && devname[0] == '*')) {
/*
* convert arguments to token/value pairs
*/
if(*args && BrStringToTokenValue(args_tv, sizeof(args_tv), args) == BRE_OK)
tv = args_tv;
/*
* Merge in additional token/value pairs
*
* N.B. Existing arguments are assumed to be in args_tv
*/
if (setup_tv != NULL) {
if (tv == NULL)
tv = setup_tv;
else {
for (tv = setup_tv; tv->t != BR_NULL_TOKEN; tv++) {
for (i = 0; args_tv[i].t != BR_NULL_TOKEN; i++)
if (args_tv[i].t == tv->t)
break;
if (args_tv[i].t == BR_NULL_TOKEN) {
if (i+1 == BR_ASIZE(args_tv))
BR_FAILURE("Too many token value pairs");
args_tv[i+1].t = BR_NULL_TOKEN;
args_tv[i+1].v.u32 = 0;
}
args_tv[i] = *tv;
}
tv = args_tv;
}
}
/*
* Find output type in device
*/
r = BrDevContainedFind((br_object **)&output_facility, BRT_OUTPUT_FACILITY, NULL, tv);
if(r != BRE_OK)
return r;
} else {
/*
* Try to find named device, if not there, attempt to add it
*/
if(BrDevFind(&device, devname) != BRE_OK) {
devargs = NULL;
/*
* Look for arguments in the device configuration string
*/
if (BrSystemConfigQueryString(BRT_BRENDER_DEVICES_STR, devices_str, BR_ASIZE(devices_str)) == BRE_OK) {
for (device_name = devices_str; *device_name != '\0'; device_name = next_device) {
/*
* Parse devices string into device name, arguments
* string and next entry
*/
for (device_args = device_name; *device_args != '\0' && *device_args != ',' && *device_args != ';'; device_args++)
;
if (*device_args == ',') {
*device_args = '\0';
device_args++;
}
for (next_device = device_args; *next_device != '\0' && *next_device != ';'; next_device++)
;
if (*next_device != '\0') {
*next_device = '\0';
next_device++;
}
/*
* Trim white space from name
*/
while (BrIsSpace(*device_name))
device_name++;
n = BrStrLen(device_name);
if (n) {
while (BrIsSpace(device_name[n-1])) {
device_name[n-1] = '\0';
n--;
}
}
/*
* Look for the relevant entry
*/
if (BrStrICmp(devname, device_name) == 0) {
devargs = device_args;
break;
}
}
}
r = BrDevAdd(&device, devname, devargs);
if(r != BRE_OK)
return r;
}
/*
* convert arguments to token/value pairs
*/
if(*args && BrStringToTokenValue(args_tv, sizeof(args_tv), args) == BRE_OK)
tv = args_tv;
/*
* Merge in additional token/value pairs
*
* N.B. Existing arguments are assumed to be in args_tv
*/
if (setup_tv != NULL) {
if (tv == NULL)
tv = setup_tv;
else {
for (tv = setup_tv; tv->t != BR_NULL_TOKEN; tv++) {
for (i = 0; args_tv[i].t != BR_NULL_TOKEN; i++)
if (args_tv[i].t == tv->t)
break;
if (args_tv[i].t == BR_NULL_TOKEN) {
if (i+1 == BR_ASIZE(args_tv))
BR_FAILURE("Too many token value pairs");
args_tv[i+1].t = BR_NULL_TOKEN;
args_tv[i+1].v.u32 = 0;
}
args_tv[i] = *tv;
}
tv = args_tv;
}
}
/*
* Find output type in device
*/
r = ObjectContainerFind(device, (br_object **)&output_facility, BRT_OUTPUT_FACILITY, NULL, tv);
if(r != BRE_OK)
return r;
}
/*
* Create screen pixelmap from output_facility
*/
r = OutputFacilityPixelmapNew(output_facility, (br_device_pixelmap **)&screen, tv);
if(r != BRE_OK)
return r;
/*
* Horrible hack to let some V1.1 compatibility functions know what the
* last created screen was (a likely candidate for renderer destinations
* and palette ops.)
*/
BrDevLastBeginSet(screen);
*ppm = screen;
return BRE_OK;
}
/*
* Functions for backwards comatibility
*/
br_pixelmap * BR_PUBLIC_ENTRY BrDevBeginOld(char *setup_string)
{
br_pixelmap *s;
if(BrDevLastBeginQuery())
BR_ERROR0("Device already active");
if(BrDevBegin(&s, setup_string) != BRE_OK)
BR_ERROR0("Could not start driver");
return s;
}
void BR_PUBLIC_ENTRY BrDevEndOld(void)
{
if(BrDevLastBeginQuery())
BrPixelmapFree(BrDevLastBeginQuery());
BrDevLastBeginSet(NULL);
}
void BR_PUBLIC_ENTRY BrDevPaletteSetOld(br_pixelmap *pm)
{
if(BrDevLastBeginQuery())
BrPixelmapPaletteSet(BrDevLastBeginQuery(), pm);
}
void BR_PUBLIC_ENTRY BrDevPaletteSetEntryOld(int i,br_colour colour)
{
if(BrDevLastBeginQuery())
BrPixelmapPaletteEntrySet(BrDevLastBeginQuery(), i, colour);
}
/*
* Find a renderer from a destination pixelmap according to standard rules
*/
br_error BR_RESIDENT_ENTRY BrRendererFacilityFind(br_renderer_facility **prf,
br_device_pixelmap *destination, br_token scalar_type)
{
br_renderer_facility *renderer_facility = NULL;
br_error r;
br_output_facility *ot;
char object_name[] = "Default-Renderer-00000";
char image_name[] = "softrnd0";
br_boolean scalar_is_valid = BR_FALSE;
/*
* Construct names based on prefered scalar type
*/
switch(scalar_type) {
case BRT_FLOAT:
BrStrCpy(object_name+sizeof(object_name)-6,"Float");
image_name[sizeof(image_name)-2] = 'f';
scalar_is_valid = BR_TRUE;
break;
case BRT_FIXED:
BrStrCpy(object_name+sizeof(object_name)-6,"Fixed");
image_name[sizeof(image_name)-2] = 'x';
scalar_is_valid = BR_TRUE;
break;
}
/*
* Fire up a renderer
*
* 1) Query destination for renderer_facility
* 2) Query destination's output_facility for renderer
* 3) Try to find "Default-Renderer-XXX" in all devices
* 4) Add "softrndX" and try to find "Default-Renderer-XXX"
* 5) Try to find "Default-Renderer" in all devices
* 6) Add "softrend" and try to find "Default-Renderer"
*
* (XXX is Fixed or Float) (X is x or f)
*/
if(!renderer_facility && destination)
ObjectQuery(destination, (br_uint_32 *)&renderer_facility, BRT_RENDERER_FACILITY_O);
if(!renderer_facility && destination) {
ot = NULL;
r = ObjectQuery(destination, (br_uint_32 *)&ot, BRT_OUTPUT_FACILITY_O);
if(r == BRE_OK && ot)
ObjectQuery(ot, (br_uint_32 *)&renderer_facility, BRT_RENDERER_FACILITY_O);
}
if(scalar_is_valid) {
if(!renderer_facility)
BrDevContainedFind((br_object **)&renderer_facility, BRT_RENDERER_FACILITY, object_name, NULL);
}
if(!renderer_facility)
BrDevContainedFind((br_object **)&renderer_facility, BRT_RENDERER_FACILITY,"Default-Renderer",NULL);
if(scalar_is_valid) {
if(!renderer_facility) {
BrDevCheckAdd(NULL,image_name,NULL);
BrDevContainedFind((br_object **)&renderer_facility, BRT_RENDERER_FACILITY, object_name, NULL);
}
}
if(!renderer_facility) {
BrDevCheckAdd(NULL,"softrend",NULL);
BrDevContainedFind((br_object **)&renderer_facility, BRT_RENDERER_FACILITY,"Default-Renderer",NULL);
}
if(!renderer_facility)
return BRE_FAIL;
*prf = renderer_facility;
return BRE_OK;
}
/*
* Find a list of available renderers from a destination pixelmap according to standard rules
*
* If the array was not large enough BRE_OVERFLOW is returned, the array is
* filled with the as many facilities as possible and the count is the number
* of renderer facilities that were found.
*/
br_error BR_RESIDENT_ENTRY BrRendererFacilityListFind(br_renderer_facility **prf,
br_int_32 *num_rf, br_int_32 max_rf,
br_device_pixelmap *destination, br_token scalar_type)
{
br_renderer_facility **renderer_facility = NULL;
br_int_32 renderer_facility_size = 0, renderer_facility_count, i, j;
br_error r;
br_output_facility *ot;
char object_pattern[] = "*-Renderer-00000";
br_boolean scalar_is_valid = BR_FALSE;
br_token_value is_alternative[] = {
{ BRT_ALTERNATIVE_TO_DEFAULT_B, BR_TRUE },
{ BR_NULL_TOKEN }
};
char *identifier;
br_size_t identifier_len;
UASSERT(prf != NULL);
UASSERT(max_rf >= 1);
/*
* Construct names based on prefered scalar type
*/
switch(scalar_type) {
case BRT_FLOAT:
BrStrCpy(object_pattern+sizeof(object_pattern)-6,"Float");
scalar_is_valid = BR_TRUE;
break;
case BRT_FIXED:
BrStrCpy(object_pattern+sizeof(object_pattern)-6,"Fixed");
scalar_is_valid = BR_TRUE;
break;
}
/*
* Find a list of renderers
*
* 1) Query destination for renderer_facility list
* 2) Query destination's output_facility for renderer_facility list
* 3) Find default renderer with BrRendererFacilityFind and
* all other renderer facilities for which ALTERNATIVE_TO_DEFAULT
* is TRUE (and eliminating the non-scalar-specific versions when
* a scalar specific version exists with the same base)
*/
if(!renderer_facility && destination)
ObjectQuery(destination, (br_uint_32 *)&renderer_facility, BRT_RENDERER_FACILITY_OL);
if(!renderer_facility && destination) {
ot = NULL;
r = ObjectQuery(destination, (br_uint_32 *)&ot, BRT_OUTPUT_FACILITY_O);
if(r == BRE_OK && ot)
ObjectQuery(ot, (br_uint_32 *)&renderer_facility, BRT_RENDERER_FACILITY_OL);
}
/*
* Copy the list if it was found
*/
if (renderer_facility) {
for (*num_rf = 0; renderer_facility[*num_rf] != NULL; num_rf++);
if (*num_rf > max_rf) {
BrMemCpy(prf, renderer_facility, max_rf * sizeof(*renderer_facility));
return BRE_OVERFLOW;
} else {
BrMemCpy(prf, renderer_facility, *num_rf * sizeof(*renderer_facility));
return BRE_OK;
}
}
/*
* Build up a list otherwise
*/
*num_rf = 0;
/*
* First get the default renderer facility
*/
if (BrRendererFacilityFind(prf, destination, scalar_type) == BRE_OK)
(*num_rf)++;
/*
* Now search for alternatives
*/
if (scalar_is_valid) {
/*
* Search for all scalar-specific alternatives
*/
r = BrDevContainedFindMany((br_object **)&prf[*num_rf], max_rf - *num_rf,
&renderer_facility_count, BRT_RENDERER_FACILITY,
object_pattern, is_alternative);
if (r != BRE_OK && r != BRE_OVERFLOW)
return r;
*num_rf += renderer_facility_count;
/*
* Now search for non-scalar-specific alternatives
*/
r = BrDevContainedCount(&renderer_facility_size, BRT_RENDERER_FACILITY,
"*-Renderer", is_alternative);
if (r != BRE_OK)
return r;
renderer_facility = BrResAllocate(NULL, renderer_facility_size * sizeof(*renderer_facility), BR_MEMORY_SCRATCH);
if (renderer_facility == NULL)
return BRE_NO_MEMORY;
r = BrDevContainedFindMany((br_object **)renderer_facility, renderer_facility_size,
&renderer_facility_count, BRT_RENDERER_FACILITY,
"*-Renderer", is_alternative);
if (r != BRE_OK && r != BRE_OVERFLOW) {
BrResFree(renderer_facility);
return r;
}
if (renderer_facility_count != renderer_facility_size) {
BrResFree(renderer_facility);
return BRE_FAIL;
}
/*
* Weed out any for which there is an equivalent scalar-specific version
*/
for (i = 0; i < renderer_facility_count; i++) {
identifier = ObjectIdentifier(renderer_facility[i]);
identifier_len = (identifier != NULL)? BrStrLen(identifier): 0;
for (j = 0; j < *num_rf; j++)
if (BrStrNICmp(identifier, ObjectIdentifier(renderer_facility[j]), identifier_len) == 0)
break;
if (j != *num_rf)
continue;
if (*num_rf < max_rf)
prf[*num_rf] = renderer_facility[i];
(*num_rf)++;
}
BrResFree(renderer_facility);
} else {
/*
* Search for all non-scalar-specific alternatives
*/
r = BrDevContainedFindMany((br_object **)&prf[*num_rf], max_rf - *num_rf,
&renderer_facility_count, BRT_RENDERER_FACILITY,
"*-Renderer", is_alternative);
if (r != BRE_OK && r != BRE_OVERFLOW)
return r;
*num_rf += renderer_facility_count;
}
if (*num_rf > max_rf)
return BRE_OVERFLOW;
return BRE_OK;
}
/*
* Find a primtive library from a destination pixelmap according to standard rules
*/
br_error BR_RESIDENT_ENTRY BrPrimitiveLibraryFind(br_primitive_library **ppl,
br_device_pixelmap *destination, br_token scalar_type)
{
br_primitive_library *primitive_library = NULL;
br_error r;
br_output_facility *ot;
char object_name[] = "Default-Primitives-00000";
char image_name[] = "softprm0";
br_boolean scalar_is_valid = BR_FALSE;
/*
* Construct names based on prefered scalar type
*/
switch(scalar_type) {
case BRT_FLOAT:
BrStrCpy(object_name+sizeof(object_name)-6,"Float");
image_name[sizeof(image_name)-2] = 'f';
scalar_is_valid = BR_TRUE;
break;
case BRT_FIXED:
BrStrCpy(object_name+sizeof(object_name)-6,"Fixed");
image_name[sizeof(image_name)-2] = 'x';
scalar_is_valid = BR_TRUE;
break;
}
/*
* Fire up a renderer
*
* 1) Query destination for primitive_library
* 2) Query destination's output_facility for renderer
* 3) Try to find "Default-Primitives-XXX" in all devices
* 4) Add "softrndX" and try to find "Default-Renderer-XXX"
* 5) Try to find "Default-Primitives" in all devices
* 6) Add "softrend" and try to find "Default-Primitives"
*
* (XXX is Fixed or Float) (X is x or f)
*/
if(!primitive_library && destination)
ObjectQuery(destination, (br_uint_32 *)&primitive_library, BRT_PRIMITIVE_LIBRARY_O);
if(!primitive_library && destination) {
ot = NULL;
r = ObjectQuery(destination, (br_uint_32 *)&ot, BRT_OUTPUT_FACILITY_O);
if(r == BRE_OK && ot)
ObjectQuery(ot, (br_uint_32 *)&primitive_library, BRT_PRIMITIVE_LIBRARY_O);
}
if(scalar_is_valid) {
if(!primitive_library)
BrDevContainedFind((br_object **)&primitive_library, BRT_PRIMITIVE_LIBRARY, object_name, NULL);
}
if(!primitive_library)
BrDevContainedFind((br_object **)&primitive_library, BRT_PRIMITIVE_LIBRARY, "Default-Primitives", NULL);
if(scalar_is_valid) {
if(!primitive_library) {
BrDevCheckAdd(NULL, image_name, NULL);
BrDevContainedFind((br_object **)&primitive_library, BRT_PRIMITIVE_LIBRARY, object_name, NULL);
}
}
if(!primitive_library) {
BrDevCheckAdd(NULL,"softprim",NULL);
BrDevContainedFind((br_object **)&primitive_library, BRT_PRIMITIVE_LIBRARY, "Default-Primitives", NULL);
}
if(!primitive_library)
return BRE_FAIL;
*ppl = primitive_library;
return BRE_OK;
}
/*
* Find a list of available primitive libraries from a destination pixelmap according to standard rules
*
* If the array was not large enough BRE_OVERFLOW is returned, the array is
* filled with the as many libraries as possible and the count is the number
* of primitive libraries that were found.
*/
br_error BR_RESIDENT_ENTRY BrPrimitiveLibraryListFind(br_primitive_library **ppl,
br_int_32 *num_pl, br_int_32 max_pl,
br_device_pixelmap *destination, br_token scalar_type)
{
br_primitive_library **primitive_library = NULL;
br_int_32 primitive_library_size = 0, primitive_library_count, i, j;
br_error r;
br_output_facility *ot;
char object_pattern[] = "*-Primitives-00000";
br_boolean scalar_is_valid = BR_FALSE;
br_token_value is_alternative[] = {
{ BRT_ALTERNATIVE_TO_DEFAULT_B, BR_TRUE },
{ BR_NULL_TOKEN }
};
char *identifier;
br_size_t identifier_len;
UASSERT(ppl != NULL);
UASSERT(max_pl >= 1);
/*
* Construct names based on prefered scalar type
*/
switch(scalar_type) {
case BRT_FLOAT:
BrStrCpy(object_pattern+sizeof(object_pattern)-6,"Float");
scalar_is_valid = BR_TRUE;
break;
case BRT_FIXED:
BrStrCpy(object_pattern+sizeof(object_pattern)-6,"Fixed");
scalar_is_valid = BR_TRUE;
break;
}
/*
* Find a list of renderers
*
* 1) Query destination for primitive_library list
* 2) Query destination's output_facility for primitive_library list
* 3) Find default primitive library with BrPrimitiveLibraryFind and
* all other renderer facilities for which ALTERNATIVE_TO_DEFAULT
* is TRUE (and eliminating the non-scalar-specific versions when
* a scalar specific version exists with the same base)
*/
if(!primitive_library && destination)
ObjectQuery(destination, (br_uint_32 *)&primitive_library, BRT_PRIMITIVE_LIBRARY_OL);
if(!primitive_library && destination) {
ot = NULL;
r = ObjectQuery(destination, (br_uint_32 *)&ot, BRT_OUTPUT_FACILITY_O);
if(r == BRE_OK && ot)
ObjectQuery(ot, (br_uint_32 *)&primitive_library, BRT_PRIMITIVE_LIBRARY_OL);
}
/*
* Copy the list if it was found
*/
if (primitive_library) {
for (*num_pl = 0; primitive_library[*num_pl] != NULL; num_pl++);
if (*num_pl > max_pl) {
BrMemCpy(ppl, primitive_library, max_pl * sizeof(*primitive_library));
return BRE_OVERFLOW;
} else {
BrMemCpy(ppl, primitive_library, *num_pl * sizeof(*primitive_library));
return BRE_OK;
}
}
/*
* Build up a list otherwise
*/
*num_pl = 0;
/*
* First get the default renderer facility
*/
if (BrPrimitiveLibraryFind(ppl, destination, scalar_type) == BRE_OK)
(*num_pl)++;
/*
* Now search for alternatives
*/
if (scalar_is_valid) {
/*
* Search for all scalar-specific alternatives
*/
r = BrDevContainedFindMany((br_object **)&ppl[*num_pl], max_pl - *num_pl,
&primitive_library_count, BRT_PRIMITIVE_LIBRARY,
object_pattern, is_alternative);
if (r != BRE_OK && r != BRE_OVERFLOW)
return r;
*num_pl += primitive_library_count;
/*
* Now search for non-scalar-specific alternatives
*/
r = BrDevContainedCount(&primitive_library_size, BRT_PRIMITIVE_LIBRARY,
"*-Primitives", is_alternative);
if (r != BRE_OK)
return r;
primitive_library = BrResAllocate(NULL, primitive_library_size * sizeof(*primitive_library), BR_MEMORY_SCRATCH);
if (primitive_library == NULL)
return BRE_NO_MEMORY;
r = BrDevContainedFindMany((br_object **)primitive_library, primitive_library_size,
&primitive_library_count, BRT_PRIMITIVE_LIBRARY,
"*-Primitives", is_alternative);
if (r != BRE_OK && r != BRE_OVERFLOW) {
BrResFree(primitive_library);
return r;
}
if (primitive_library_count != primitive_library_size) {
BrResFree(primitive_library);
return BRE_FAIL;
}
/*
* Weed out any for which there is an equivalent scalar-specific version
*/
for (i = 0; i < primitive_library_count; i++) {
identifier = ObjectIdentifier(primitive_library[i]);
identifier_len = (identifier != NULL)? BrStrLen(identifier): 0;
for (j = 0; j < *num_pl; j++)
if (BrStrNICmp(identifier, ObjectIdentifier(primitive_library[j]), identifier_len) == 0)
break;
if (j != *num_pl)
continue;
if (*num_pl < max_pl)
ppl[*num_pl] = primitive_library[i];
(*num_pl)++;
}
BrResFree(primitive_library);
} else {
/*
* Search for all non-scalar-specific alternatives
*/
r = BrDevContainedFindMany((br_object **)&ppl[*num_pl], max_pl - *num_pl,
&primitive_library_count, BRT_PRIMITIVE_LIBRARY,
"*-Primitives", is_alternative);
if (r != BRE_OK && r != BRE_OVERFLOW)
return r;
*num_pl += primitive_library_count;
}
if (*num_pl > max_pl)
return BRE_OVERFLOW;
return BRE_OK;
}
br_error BR_RESIDENT_ENTRY BrGeometryFormatFind(br_geometry **pgf,
br_renderer *renderer,
br_renderer_facility *renderer_facility,
br_token scalar_type,
br_token format_type)
{
br_error r;
br_geometry *gf;
char object_name[] = "Default-Format-00000";
char image_name[] = "softfrm0";
br_boolean scalar_is_valid = BR_FALSE;
/*
* Construct names based on prefered scalar type
*/
switch(scalar_type) {
case BRT_FLOAT:
BrStrCpy(object_name+sizeof(object_name)-6,"Float");
image_name[sizeof(image_name)-2] = 'f';
scalar_is_valid = BR_TRUE;
break;
case BRT_FIXED:
BrStrCpy(object_name+sizeof(object_name)-6,"Fixed");
image_name[sizeof(image_name)-2] = 'x';
scalar_is_valid = BR_TRUE;
break;
}
/*
* See if the renderer itself knows about the format
*/
r = ObjectContainerFind(renderer, (br_object **)&gf, format_type, NULL, NULL);
if(r == BRE_OK) {
*pgf = gf;
return BRE_OK;
}
/*
* Find the renderer facility, if we don't know it already
*/
if(!renderer_facility)
ObjectQuery(renderer, (br_uint_32 *)&renderer_facility, BRT_RENDERER_FACILITY_O);
if(renderer_facility) {
/*
* Try the renderer's facility object
*/
r = ObjectContainerFind(renderer_facility, (br_object **)&gf, format_type, NULL, NULL);
if(r == BRE_OK) {
*pgf = gf;
return BRE_OK;
}
}
if(scalar_is_valid) {
/*
* Look for a default in all loaded devices
*/
r = BrDevContainedFind((br_object **)&gf, format_type, object_name, NULL);
if(r == BRE_OK) {
*pgf = gf;
return BRE_OK;
}
}
/*
* Look for a default in all loaded devices
*/
r = BrDevContainedFind((br_object **)&gf, format_type, "Default-Format", NULL);
if(r == BRE_OK) {
*pgf = gf;
return BRE_OK;
}
if(scalar_is_valid) {
/*
* Try adding a device called 'softfrmX'
*/
BrDevCheckAdd(NULL,image_name,NULL);
r = BrDevContainedFind((br_object **)&gf, format_type, object_name, NULL);
if(r == BRE_OK) {
*pgf = gf;
return BRE_OK;
}
}
/*
* Try adding a device called 'softform'
*/
BrDevCheckAdd(NULL,"softform",NULL);
r = BrDevContainedFind((br_object **)&gf, format_type, "Default-Format", NULL);
if(r == BRE_OK) {
*pgf = gf;
return BRE_OK;
}
return BRE_FAIL;
}

89
core/fw/diag.c Normal file
View File

@ -0,0 +1,89 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: diag.c 1.1 1997/12/10 16:41:06 jon Exp $
* $Locker: $
*
* Diagnostic handling support
*
* These routines are not called directly, but via macros. This is
* to allow the underlying diagnostic mechanism to be radically changed
* and allow various text scanning methods for message extraction
*
*/
#include <stdarg.h>
#include "fw.h"
BR_RCS_ID("$Id: diag.c 1.1 1997/12/10 16:41:06 jon Exp $")
static char _diag_scratch[128];
void BR_RESIDENT_ENTRY BrFailure(char *s,...)
{
va_list args;
static char failure_header[] = "Failure: ";
BrStrCpy(_diag_scratch,failure_header);
va_start(args,s);
BrVSprintf(_diag_scratch+(BR_ASIZE(failure_header)-1),s,args);
va_end(args);
if(fw.diag->failure == NULL)
BrAbort();
fw.diag->failure(_diag_scratch);
}
void BR_RESIDENT_ENTRY BrWarning(char *s,...)
{
va_list args;
static char warning_header[] = "Warning: ";
BrStrCpy(_diag_scratch,warning_header);
va_start(args,s);
BrVSprintf(_diag_scratch+(BR_ASIZE(warning_header)-1),s,args);
va_end(args);
if(fw.diag->warning == NULL)
BrAbort();
fw.diag->warning(_diag_scratch);
}
void BR_RESIDENT_ENTRY BrFatal(char *name, int line, char *s,...)
{
va_list args;
int n;
n = BrSprintf(_diag_scratch,"FATAL %s:%d\n",name,line);
va_start(args,s);
BrVSprintf(_diag_scratch+n,s,args);
va_end(args);
if(fw.diag->failure == NULL)
BrAbort();
fw.diag->failure(_diag_scratch);
}
void BR_RESIDENT_ENTRY _BrAssert(char *condition, char *file, unsigned line)
{
if(fw.diag->failure == NULL)
BrAbort();
BrSprintf(_diag_scratch,"ASSERTION FAILED %s:%d: \"%s\"\n",file,line,condition);
fw.diag->failure(_diag_scratch);
}
void BR_RESIDENT_ENTRY _BrUAssert(char *condition, char *file, unsigned line)
{
if(fw.diag->failure == NULL)
BrAbort();
BrSprintf(_diag_scratch,"ASSERTION FAILED %s:%d: \"%s\"\n",file,line,condition);
fw.diag->failure(_diag_scratch);
}

26
core/fw/error.c Normal file
View File

@ -0,0 +1,26 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: error.c 1.1 1997/12/10 16:41:06 jon Exp $
* $Locker: $
*
* Error value support
*/
#include "fw.h"
BR_RCS_ID("$Id: error.c 1.1 1997/12/10 16:41:06 jon Exp $")
br_error BR_RESIDENT_ENTRY BrLastErrorGet(void **valuep)
{
if(valuep)
valuep = fw.last_error_value;
return fw.last_error_type;
}
void BR_RESIDENT_ENTRY BrLastErrorSet(br_error type, void *value)
{
fw.last_error_type = type;
fw.last_error_value = value;
}

217
core/fw/file.c Normal file
View File

@ -0,0 +1,217 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: file.c 1.1 1997/12/10 16:41:07 jon Exp $
* $Locker: $
*
* Low level wrappers for file system access
*/
#include <stdarg.h>
#include "fw.h"
#include "brassert.h"
BR_RCS_ID("$Id: file.c 1.1 1997/12/10 16:41:07 jon Exp $")
/*
* Resource block used to represent an open file
*/
typedef struct br_file {
void *raw_file;
br_boolean writing;
int mode;
char name[1];
} br_file;
/*
* Resource destructor for files
*/
void BR_CALLBACK _BrFileFree(void *res, br_uint_8 res_class, br_size_t size)
{
br_file *file = res;
/*
* Close low level file
*/
ASSERT(fw.fsys->close != NULL);
fw.fsys->close(((br_file *)file)->raw_file);
}
br_uint_32 BR_PUBLIC_ENTRY BrFileAttributes(void)
{
ASSERT(fw.fsys->attributes != NULL);
return fw.fsys->attributes();
}
void * BR_PUBLIC_ENTRY BrFileOpenRead(char *name, br_size_t n_magics,
br_mode_test_cbfn *mode_test,
int *mode_result)
{
void *raw_file;
br_file *file;
int bin_mode = BR_FS_MODE_BINARY;
ASSERT(fw.fsys->open_read != NULL);
/*
* Invoke low level file access
*/
if(mode_result)
raw_file = fw.fsys->open_read(name,n_magics,mode_test,mode_result);
else
raw_file = fw.fsys->open_read(name,n_magics,mode_test,&bin_mode);
/*
* Catch failure
*/
if(raw_file == NULL)
return NULL;
/*
* Create a file block (which includes the name and mode)
*/
file = BrResAllocate(fw.res, sizeof(br_file) + BrStrLen(name)+1, BR_MEMORY_FILE);
file->writing = BR_FALSE;
if ( mode_result != NULL )
file->mode = *mode_result;
else
file->mode = BR_FS_MODE_BINARY;
file->raw_file = raw_file;
BrStrCpy(file->name,name);
return file;
}
void * BR_PUBLIC_ENTRY BrFileOpenWrite(char *name, int mode)
{
void *raw_file;
br_file *file;
ASSERT(fw.fsys->open_write != NULL);
UASSERT_MESSAGE("Invalid mode passed to BrFileOpenWrite.\n\r Must be BR_FS_MODE_TEXT or BR_FS_MODE_BINARY.",((mode== BR_FS_MODE_TEXT) || (mode == BR_FS_MODE_BINARY)));
raw_file = fw.fsys->open_write(name,mode);
/*
* Catch failure
*/
if(raw_file == NULL)
return NULL;
/*
* Create a file block (which includes the name and mode)
*/
file = BrResAllocate(fw.res, sizeof(br_file) + BrStrLen(name)+1, BR_MEMORY_FILE);
file->writing = BR_TRUE;
file->mode = mode;
file->raw_file = raw_file;
BrStrCpy(file->name,name);
return file;
}
void BR_PUBLIC_ENTRY BrFileClose(void *f)
{
UASSERT_MESSAGE("In BrFileClose",f!=NULL);
BrResFree(f);
}
int BR_PUBLIC_ENTRY BrFileEof(void *f)
{
ASSERT(fw.fsys->eof != NULL);
UASSERT_MESSAGE("In BrFileEof",f!=NULL);
return fw.fsys->eof(((br_file *)f)->raw_file);
}
int BR_PUBLIC_ENTRY BrFileGetChar(void *f)
{
ASSERT(fw.fsys->getchr != NULL);
UASSERT_MESSAGE("In BrFileGetChar",f!=NULL);
return fw.fsys->getchr(((br_file *)f)->raw_file);
}
void BR_PUBLIC_ENTRY BrFilePutChar(int c, void *f)
{
ASSERT(fw.fsys->putchr != NULL);
UASSERT_MESSAGE("In BrFilePutChar",f!=NULL);
fw.fsys->putchr(c,((br_file *)f)->raw_file);
}
int BR_PUBLIC_ENTRY BrFileRead(void *buf, int size, int n, void *f)
{
UASSERT_MESSAGE("In BrFileRead",f!=NULL);
UASSERT_MESSAGE("In BrFileRead",buf!=NULL);
ASSERT(fw.fsys->read != NULL);
return fw.fsys->read(buf,size,n,((br_file *)f)->raw_file);
}
int BR_PUBLIC_ENTRY BrFileWrite(void *buf, int size, int n, void *f)
{
UASSERT_MESSAGE("BrFileWrite",f!=NULL);
UASSERT_MESSAGE("BrFileWrite",buf!=NULL);
ASSERT(fw.fsys->write != NULL);
return fw.fsys->write(buf,size,n,((br_file *)f)->raw_file);
}
int BR_PUBLIC_ENTRY BrFileGetLine(char *buf, br_size_t buf_len, void * f)
{
UASSERT_MESSAGE("BrFileGetLine",f!=NULL);
ASSERT( ((br_file *)f)->raw_file );
return fw.fsys->getline(buf,buf_len,((br_file *)f)->raw_file);
}
void BR_PUBLIC_ENTRY BrFilePutLine(char *buf, void * f)
{
UASSERT_MESSAGE("BrFilePutLine",f!=NULL);
ASSERT(fw.fsys->putline != NULL);
fw.fsys->putline(buf,((br_file *)f)->raw_file);
}
void BR_PUBLIC_ENTRY BrFileAdvance(long int count, void *f)
{
UASSERT_MESSAGE("In BrFileAdvance",f!=NULL);
ASSERT(fw.fsys->advance != NULL);
fw.fsys->advance(count,((br_file *)f)->raw_file);
}
int BR_PUBLIC_ENTRY BrFilePrintf(void *f, char *fmt, ...)
{
int n;
va_list args;
UASSERT_MESSAGE("In BrFilePrintf",f!=NULL);
ASSERT(fw.fsys->write != NULL);
va_start(args, fmt);
n = BrVSprintf(BrScratchString(), fmt, args);
va_end(args);
fw.fsys->write(BrScratchString(), 1, n, ((br_file *)f)->raw_file);
return n;
}

5
core/fw/foo.c Normal file
View File

@ -0,0 +1,5 @@
hello
bar
bletch
widget

173
core/fw/formats.h Normal file
View File

@ -0,0 +1,173 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: formats.h 1.4 1998/09/21 14:50:54 johng Exp $
* $Locker: $
*
* All the geometry formats understood by the renderer
* This internal format is being generally release to remove the need for
* for duplicate copies of model data when accessing is required.
*/
#ifndef _FORMATS_H_
#define _FORMATS_H_
// This was for restricting our evaluation version.
#if EVAL
#define PAD_SIZE (2048-32)
#endif
/**
** Generic vertex structure used for geometry formats
**/
#if 0
struct fmt_vertex {
br_vector3 p; /* Point in model space */
br_vector2 map; /* Mapping coordinates */
br_vector3 n; /* Surface normal at vertex */
#if EVAL
br_int_8 _pad[PAD_SIZE];
#endif
};
struct fmt_vertex_x {
br_vector3_x p; /* Point in model space */
br_vector2_x map; /* Mapping coordinates */
br_vector3_x n; /* Surface normal at vertex */
#if EVAL
br_int_8 _pad[PAD_SIZE];
#endif
};
struct fmt_vertex_f {
br_vector3_f p; /* Point in model space */
br_vector2_f map; /* Mapping coordinates */
br_vector3_f n; /* Surface normal at vertex */
#if EVAL
br_int_8 _pad[PAD_SIZE];
#endif
};
/**
** Version 1.1 prepared model format
**/
struct v11face {
br_uint_16 vertices[3]; /* Vertices around face */
br_uint_16 edges[3]; /* Edges around face */
br_vector4 eqn; /* Plane equation as a 4 vector (Nx,Ny,Nz,D)*/
};
struct v11face_x {
br_uint_16 vertices[3]; /* Vertices around face */
br_uint_16 edges[3]; /* Edges around face */
br_vector4_x eqn; /* Plane equation as a 4 vector (Nx,Ny,Nz,D)*/
};
struct v11face_f {
br_uint_16 vertices[3]; /* Vertices around face */
br_uint_16 edges[3]; /* Edges around face */
br_vector4_f eqn; /* Plane equation as a 4 vector (Nx,Ny,Nz,D)*/
};
#endif
// This groups together all the faces with the same material.
struct v11group {
void *stored; /* Group material (or NULL) */
// struct v11face *faces; /* faces in group */
br_vector3_u16 *vertex_numbers;
br_vector3_u16 *edges;
br_vector4 * eqn;
br_colour *face_colours; /* Colour for geometry */
br_uint_16 *face_user; /* Per face user data */
br_uint_8 *face_flags; /* Per face flags */
// struct fmt_vertex *vertices; /* vertices in group */
br_vector3 * position;
br_vector2 * map;
br_vector3 * normal;
br_colour *vertex_colours; /* Colour for geometry */
br_uint_16 *vertex_user; /* Per vertex user data */
br_uint_16 nfaces; /* Number of faces in this group */
br_uint_16 nvertices; /* Number of vertices in this group */
br_uint_16 nedges; /* Number of edges in this group */
};
#if 0
struct v11group_x {
void *stored; /* Group material (or NULL) */
struct v11face_x *faces; /* faces in group */
br_colour *face_colours; /* Colour for geometry */
br_uint_16 *face_user; /* Per face user data */
br_uint_8 *face_flags; /* Per face flags */
struct fmt_vertex_x *vertices; /* vertices in group */
br_colour *vertex_colours; /* Colour for geometry */
br_uint_16 *vertex_user; /* Per vertex user data */
br_uint_16 nfaces; /* Number of faces in this group */
br_uint_16 nvertices; /* Number of vertices in this group */
br_uint_16 nedges; /* Number of edges in this group */
};
struct v11group_f {
void *stored; /* Group material (or NULL) */
struct v11face_f *faces; /* faces in group */
br_colour *face_colours; /* Colour for geometry */
br_uint_16 *face_user; /* Per face user data */
br_uint_8 *face_flags; /* Per face flags */
struct fmt_vertex_f *vertices; /* vertices in group */
br_colour *vertex_colours; /* Colour for geometry */
br_uint_16 *vertex_user; /* Per vertex user data */
br_uint_16 nfaces; /* Number of faces in this group */
br_uint_16 nvertices; /* Number of vertices in this group */
br_uint_16 nedges; /* Number of edges in this group */
};
#endif
struct v11model {
br_size_t size;
br_uint_32 flags;
br_uint_16 ngroups;
br_vector3 pivot;
struct v11group *groups;
br_bounds bounds;
br_scalar radius;
br_vector3 centre;
br_scalar centred_radius;
};
#if 0
struct v11model_x {
br_size_t size;
br_uint_32 flags;
br_uint_16 ngroups;
br_vector3_x pivot;
struct v11group_x *groups;
br_bounds3_x bounds;
br_fixed_ls radius;
br_vector3_x centre;
br_fixed_ls centred_radius;
};
struct v11model_f {
br_size_t size;
br_uint_32 flags;
br_uint_16 ngroups;
br_vector3_f pivot;
struct v11group_f *groups;
br_bounds3_f bounds;
float radius;
br_vector3_f centre;
float centred_radius;
};
#endif
#endif

155
core/fw/fw.h Normal file
View File

@ -0,0 +1,155 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: fw.h 1.1 1997/12/10 16:41:07 jon Exp $
* $Locker: $
*
* Internal types and structures for framework
*/
#ifndef _FW_H_
#define _FW_H_
/*
* Pull in all the public definitions/declarations
*/
#ifndef _BRDDI_H_
#include "brddi.h"
#endif
/*
* Private state of framework
*/
typedef struct br_framework_state {
/*
* Flag to indicate that framework is set up
*/
br_boolean active;
/*
* Various lists of registered items
*/
br_registry reg_resource_classes;
/*
* An index of registered resources by class
*/
br_resource_class *resource_class_index[BR_MAX_RESOURCE_CLASSES];
/*
* Collection of tokens
*/
br_list tokens;
br_token next_free_token;
/*
* Current filesystem, memory, and error handlers
*/
br_filesystem *fsys;
br_allocator *mem;
br_diaghandler *diag;
/*
* File write mode
*/
int open_mode;
/*
* Base resource of which everything else is a descendant
*/
void *res;
/*
* Global scratch space
*/
void *scratch_ptr;
br_size_t scratch_size;
br_size_t scratch_last;
int scratch_inuse;
/*
* error value
*/
br_error last_error_type;
void ** last_error_value;
/*
* List of loaded images
*/
br_list images;
/*
* Pointers to loaded devices and the images whence they came
*/
struct br_open_device *dev_slots;
br_int_32 ndev_slots;
br_associative_array *sys_config ;
br_boolean bAlreadyLoadedDrivers ;
} br_framework_state;
/*
* Device pointer and image from where it came (or NULL if device is static).
*/
typedef struct br_open_device {
struct br_device *dev;
struct br_image *image;
} br_open_device;
/*
* Global renderer state
*/
#ifdef __cplusplus
extern "C" {
#endif
extern br_framework_state BR_ASM_DATA fw;
#ifdef __cplusplus
};
#endif
/*
* Minimum scratch space to allocate for render temps.
*/
#define MIN_WORKSPACE 8192
#if DEBUG
/*
* Controls whether the source file/line of each
* resource allocation is tracked
*
* XXX Unimplemented
*/
#define BR_RES_TRACKING 1
/*
* True if resources are tagged with a magic number and pointer - allows validation
* and debug dumping
*/
#define BR_RES_TAGGING 1
#else
#define BR_RES_TRACKING 1
#define BR_RES_TAGGING 1
#endif
/*
* Initial number of device slots
*/
#define NDEV_SLOTS 16
/*
* Pull in private prototypes
*/
#ifndef _NO_PROTOTYPES
#ifndef _FW_IP_H_
#include "fw_ip.h"
#endif
#ifndef _FW_IX_H_
#include "fw_ix.h"
#endif
#endif
#endif

67
core/fw/fw_ip.h Normal file
View File

@ -0,0 +1,67 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: fw_ip.h 1.1 1997/12/10 16:41:07 jon Exp $
* $Locker: $
*
* Prototypes for functions internal to framework
*/
#ifndef _FW_IP_H_
#define _FW_IP_H_
#ifndef _NO_PROTOTYPES
#ifdef __cplusplus
extern "C" {
#endif
/*
* pool.c
*/
void BR_ASM_CALLBACK BrPoolAddChunk(br_pool *pool);
/*
* Debugging writes
*/
int BR_PUBLIC_ENTRY BrLogWrite(void *buffer, br_size_t s, br_size_t n);
/*
* file.c
*/
void BR_CALLBACK _BrFileFree(void *res, br_uint_8 res_class, br_size_t size);
/*
* token.c
*/
void BrTokenBegin(void);
br_token BrTokenFindType(br_token *ptype, char *base, br_token *types, br_int_32 ntypes);
/*
* object.c
*/
void BR_CALLBACK _BrObjectFree(void *res, br_uint_8 res_class, br_size_t size);
/*
* image.c
*/
void BR_CALLBACK _BrImageFree(void *res, br_uint_8 res_class, br_size_t size);
/*
* loader.c
*/
br_image *ImageLoad(char *name);
/*
* brbhook.c
*/
void BR_CALLBACK _BrBeginHook(void);
void BR_CALLBACK _BrEndHook(void);
#ifdef __cplusplus
};
#endif
#endif
#endif

23
core/fw/fw_ix.afn Normal file
View File

@ -0,0 +1,23 @@
# Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
#
# $Id: fw_ix.afn 1.1 1997/12/10 16:41:07 jon Exp $
# $Locker: $
#
# List of functions that need per compiler C<-> ASM glue
#
_reciprocal
fw
BrFixedAddCarry
_FontFixed3x5
_FontProp4x6
_FontProp7x9
_MemCopyBits_A
_MemFill_A
_MemRectFill_A
_MemCopy_A
_MemRectCopy_A
_MemPlot
_GetSysQual

46
core/fw/fw_ix.h Normal file
View File

@ -0,0 +1,46 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* Extra glue for C<->ASM generated via gemasmpr.pl
*/
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __IBMC__
#pragma map(_reciprocal,"__reciprocal")
#pragma map(fw,"_fw")
#pragma map(BrFixedAddCarry,"_BrFixedAddCarry")
#pragma map(_FontFixed3x5,"__FontFixed3x5")
#pragma map(_FontProp4x6,"__FontProp4x6")
#pragma map(_FontProp7x9,"__FontProp7x9")
#pragma map(_MemCopyBits_A,"__MemCopyBits_A")
#pragma map(_MemFill_A,"__MemFill_A")
#pragma map(_MemRectFill_A,"__MemRectFill_A")
#pragma map(_MemCopy_A,"__MemCopy_A")
#pragma map(_MemRectCopy_A,"__MemRectCopy_A")
#pragma map(_MemPlot,"__MemPlot")
#pragma map(_GetSysQual,"__GetSysQual")
#endif /* __IBMC__ */
#ifdef __HIGHC__
#pragma Alias(_reciprocal,"__reciprocal")
#pragma Alias(fw,"_fw")
#pragma Alias(BrFixedAddCarry,"_BrFixedAddCarry")
#pragma Alias(_FontFixed3x5,"__FontFixed3x5")
#pragma Alias(_FontProp4x6,"__FontProp4x6")
#pragma Alias(_FontProp7x9,"__FontProp7x9")
#pragma Alias(_MemCopyBits_A,"__MemCopyBits_A")
#pragma Alias(_MemFill_A,"__MemFill_A")
#pragma Alias(_MemRectFill_A,"__MemRectFill_A")
#pragma Alias(_MemCopy_A,"__MemCopy_A")
#pragma Alias(_MemRectCopy_A,"__MemRectCopy_A")
#pragma Alias(_MemPlot,"__MemPlot")
#pragma Alias(_GetSysQual,"__GetSysQual")
#endif /* __IBMC__ */
#ifdef __cplusplus
};
#endif

230
core/fw/fwimg.fns Normal file
View File

@ -0,0 +1,230 @@
# List of resident functions, gets converted to
# static C initialisers by resgen.pl
#
=BRCORE1
BrDevAdd
BrDevAddStatic
BrDevBegin
BrDevBeginVar
BrDevCheckAdd
BrDevContainedCount
BrDevContainedFind
BrDevContainedFindMany
BrDevCount
BrDevFind
BrDevFindMany
BrDevLastBeginQuery
BrDevLastBeginSet
BrDevRemove
BrFileAdvance
BrFileAttributes
BrFileClose
BrFileEof
BrFileGetChar
BrFileGetLine
BrFileOpenRead
BrFileOpenWrite
BrFilePrintf
BrFilePutChar
BrFilePutLine
BrFileRead
BrFileWrite
BrImageAdd
BrImageDereference
BrImageLookupName
BrImageLookupOrdinal
BrImageReference
BrImageRemove
BrIsAlpha
BrIsDigit
BrIsPrint
BrIsSpace
BrLexerAllocate
BrLexerCommentSet
BrLexerDumpSet
BrLexerErrorSet
BrLexerFree
BrLexerPop
BrLexerPosition
BrLexerPushFile
BrLexerPushString
BrLexerTokenError
BrMemAllocate
BrMemCalloc
BrMemCmp
BrMemCpy
BrMemFree
BrMemInquire
BrMemSet
BrMemStrDup
BrNamePatternMatch
BrObjectContainerFree
BrObjectListAllocate
BrParseFixed
BrParseFloat
BrParseInteger
BrParseMatrixFixed
BrParseMatrixFloat
BrParseVectorFixed
BrParseVectorFloat
BrPrimitiveLibraryFind
BrRendererFacilityFind
BrQsort
BrRegistryAdd
BrRegistryAddMany
BrRegistryClear
BrRegistryCount
BrRegistryEnum
BrRegistryFind
BrRegistryFindMany
BrRegistryNew
BrRegistryRemove
BrRegistryRemoveMany
BrRegistryNewStatic
BrRegistryAddStatic
BrRegistryRemoveStatic
BrResAdd
BrResAllocate
BrResCheck
BrResChildEnum
BrResClass
BrResDump
BrResFree
BrResFreeNoCallback
BrResIsChild
BrResRemove
BrResSize
BrResSizeTotal
BrResStrDup
BrScratchAllocate
BrScratchFlush
BrScratchFree
BrScratchInquire
BrScratchString
BrScratchStringSize
BrLastErrorSet
BrLastErrorGet
BrSprintf
BrSprintfN
BrSScanf
BrStrCat
BrStrCmp
BrStrCpy
BrStrICmp
BrStrLen
BrStrNCmp
BrStrNCpy
BrStrNICmp
BrStrRChr
BrStrToD
BrStrToF
BrStrToL
BrStrToUL
BrFloatFloor
BrFloatCeil
BrFloatSqrt
BrFloatPow
BrFloatAtan2
BrSwap16
BrSwap32
BrSwapBlock
BrSwapFloat
BrTokenCount
BrTokenCreate
BrTokenFind
BrTokenFindMany
BrTokenIdentifier
BrTokenType
BrTokenValueCompare
BrTokenValueComparePartial
BrTokenValueDump
BrTokenValueQuery
BrTokenValueQueryAll
BrTokenValueQueryAllSize
BrTokenValueQueryMany
BrTokenValueQueryManySize
BrTokenValueSet
BrTokenValueSetMany
BrStringToTokenValue
BrTVTemplateAllocate
BrTVTemplateFree
BrVSprintf
BrVSprintfN
BrVSScanf
BrLogPrintf
BrAbort
BrFailure
BrFatal
BrWarning
BrGetEnv
BrSimpleAddHead
BrSimpleInsert
BrSimpleNewList
BrSimpleRemHead
BrSimpleRemove
BrNewList
BrAddHead
BrAddTail
BrInsert
BrRemove
BrRemHead
BrRemTail
br_object:query
br_object:queryAll
br_object:queryAllSize
br_object:queryBuffer
br_object:queryMany
br_object:queryManySize
br_object_container:addFront
br_object_container:count
br_object_container:find
br_object_container:findMany
br_object_container:remove
br_object_container:removeFront
br_object_container:tokensMatch
br_object_container:tokensMatchBegin
br_object_container:tokensMatchEnd
_BrAssert
_BrExceptionBegin
_BrExceptionEnd
_BrExceptionResource
_BrExceptionThrow
_BrExceptionValueFetch
_BrUAssert
_EPI
_PRO

614
core/fw/fwimg.h Normal file
View File

@ -0,0 +1,614 @@
/*
* Table of exported names
*/
static char * namePointers_BRCORE1[] = {
"_BrAbort",
"_BrAddHead",
"_BrAddTail",
"_BrDevAdd",
"_BrDevAddStatic",
"_BrDevBegin",
"_BrDevBeginVar",
"_BrDevCheckAdd",
"_BrDevContainedCount",
"_BrDevContainedFind",
"_BrDevContainedFindMany",
"_BrDevCount",
"_BrDevFind",
"_BrDevFindMany",
"_BrDevLastBeginQuery",
"_BrDevLastBeginSet",
"_BrDevRemove",
"_BrFailure",
"_BrFatal",
"_BrFileAdvance",
"_BrFileAttributes",
"_BrFileClose",
"_BrFileEof",
"_BrFileGetChar",
"_BrFileGetLine",
"_BrFileOpenRead",
"_BrFileOpenWrite",
"_BrFilePrintf",
"_BrFilePutChar",
"_BrFilePutLine",
"_BrFileRead",
"_BrFileWrite",
"_BrFloatAtan2",
"_BrFloatCeil",
"_BrFloatFloor",
"_BrFloatPow",
"_BrFloatSqrt",
"_BrGetEnv",
"_BrImageAdd",
"_BrImageDereference",
"_BrImageLookupName",
"_BrImageLookupOrdinal",
"_BrImageReference",
"_BrImageRemove",
"_BrInsert",
"_BrIsAlpha",
"_BrIsDigit",
"_BrIsPrint",
"_BrIsSpace",
"_BrLastErrorGet",
"_BrLastErrorSet",
"_BrLexerAllocate",
"_BrLexerCommentSet",
"_BrLexerDumpSet",
"_BrLexerErrorSet",
"_BrLexerFree",
"_BrLexerPop",
"_BrLexerPosition",
"_BrLexerPushFile",
"_BrLexerPushString",
"_BrLexerTokenError",
"_BrLogPrintf",
"_BrMemAllocate",
"_BrMemCalloc",
"_BrMemCmp",
"_BrMemCpy",
"_BrMemFree",
"_BrMemInquire",
"_BrMemSet",
"_BrMemStrDup",
"_BrNamePatternMatch",
"_BrNewList",
"_BrObjectContainerFree",
"_BrObjectListAllocate",
"_BrParseFixed",
"_BrParseFloat",
"_BrParseInteger",
"_BrParseMatrixFixed",
"_BrParseMatrixFloat",
"_BrParseVectorFixed",
"_BrParseVectorFloat",
"_BrPrimitiveLibraryFind",
"_BrQsort",
"_BrRegistryAdd",
"_BrRegistryAddMany",
"_BrRegistryAddStatic",
"_BrRegistryClear",
"_BrRegistryCount",
"_BrRegistryEnum",
"_BrRegistryFind",
"_BrRegistryFindMany",
"_BrRegistryNew",
"_BrRegistryNewStatic",
"_BrRegistryRemove",
"_BrRegistryRemoveMany",
"_BrRegistryRemoveStatic",
"_BrRemHead",
"_BrRemTail",
"_BrRemove",
"_BrRendererFacilityFind",
"_BrResAdd",
"_BrResAllocate",
"_BrResCheck",
"_BrResChildEnum",
"_BrResClass",
"_BrResDump",
"_BrResFree",
"_BrResFreeNoCallback",
"_BrResIsChild",
"_BrResRemove",
"_BrResSize",
"_BrResSizeTotal",
"_BrResStrDup",
"_BrSScanf",
"_BrScratchAllocate",
"_BrScratchFlush",
"_BrScratchFree",
"_BrScratchInquire",
"_BrScratchString",
"_BrScratchStringSize",
"_BrSimpleAddHead",
"_BrSimpleInsert",
"_BrSimpleNewList",
"_BrSimpleRemHead",
"_BrSimpleRemove",
"_BrSprintf",
"_BrSprintfN",
"_BrStrCat",
"_BrStrCmp",
"_BrStrCpy",
"_BrStrICmp",
"_BrStrLen",
"_BrStrNCmp",
"_BrStrNCpy",
"_BrStrNICmp",
"_BrStrRChr",
"_BrStrToD",
"_BrStrToF",
"_BrStrToL",
"_BrStrToUL",
"_BrStringToTokenValue",
"_BrSwap16",
"_BrSwap32",
"_BrSwapBlock",
"_BrSwapFloat",
"_BrTVTemplateAllocate",
"_BrTVTemplateFree",
"_BrTokenCount",
"_BrTokenCreate",
"_BrTokenFind",
"_BrTokenFindMany",
"_BrTokenIdentifier",
"_BrTokenType",
"_BrTokenValueCompare",
"_BrTokenValueComparePartial",
"_BrTokenValueDump",
"_BrTokenValueQuery",
"_BrTokenValueQueryAll",
"_BrTokenValueQueryAllSize",
"_BrTokenValueQueryMany",
"_BrTokenValueQueryManySize",
"_BrTokenValueSet",
"_BrTokenValueSetMany",
"_BrVSScanf",
"_BrVSprintf",
"_BrVSprintfN",
"_BrWarning",
"__BrAssert",
"__BrExceptionBegin",
"__BrExceptionEnd",
"__BrExceptionResource",
"__BrExceptionThrow",
"__BrExceptionValueFetch",
"__BrUAssert",
"__EPI",
"__M_br_object_container_addFront",
"__M_br_object_container_count",
"__M_br_object_container_find",
"__M_br_object_container_findMany",
"__M_br_object_container_remove",
"__M_br_object_container_removeFront",
"__M_br_object_container_tokensMatch",
"__M_br_object_container_tokensMatchBegin",
"__M_br_object_container_tokensMatchEnd",
"__M_br_object_query",
"__M_br_object_queryAll",
"__M_br_object_queryAllSize",
"__M_br_object_queryBuffer",
"__M_br_object_queryMany",
"__M_br_object_queryManySize",
"__PRO",
};
/*
* Table of ordinals
*/
static br_uint_16 nameOrdinals_BRCORE1[] = {
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
53,
54,
55,
56,
57,
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
68,
69,
70,
71,
72,
73,
74,
75,
76,
77,
78,
79,
80,
81,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
92,
93,
94,
95,
96,
97,
98,
99,
100,
101,
102,
103,
104,
105,
106,
107,
108,
109,
110,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
121,
122,
123,
124,
125,
126,
127,
128,
129,
130,
131,
132,
133,
134,
135,
136,
137,
138,
139,
140,
141,
142,
143,
144,
145,
146,
147,
148,
149,
150,
151,
152,
153,
154,
155,
156,
157,
158,
159,
160,
161,
162,
163,
164,
165,
166,
167,
168,
169,
170,
171,
172,
173,
174,
175,
176,
177,
178,
179,
180,
181,
182,
183,
184,
185,
186,
187,
188,
189,
190,
};
/*
* Table of ordinals
*/
static void * functionPointers_BRCORE1[] = {
BrAbort , /* 0 */
BrAddHead , /* 1 */
BrAddTail , /* 2 */
BrDevAdd , /* 3 */
BrDevAddStatic , /* 4 */
BrDevBegin , /* 5 */
BrDevBeginVar , /* 6 */
BrDevCheckAdd , /* 7 */
BrDevContainedCount , /* 8 */
BrDevContainedFind , /* 9 */
BrDevContainedFindMany , /* 10 */
BrDevCount , /* 11 */
BrDevFind , /* 12 */
BrDevFindMany , /* 13 */
BrDevLastBeginQuery , /* 14 */
BrDevLastBeginSet , /* 15 */
BrDevRemove , /* 16 */
BrFailure , /* 17 */
BrFatal , /* 18 */
BrFileAdvance , /* 19 */
BrFileAttributes , /* 20 */
BrFileClose , /* 21 */
BrFileEof , /* 22 */
BrFileGetChar , /* 23 */
BrFileGetLine , /* 24 */
BrFileOpenRead , /* 25 */
BrFileOpenWrite , /* 26 */
BrFilePrintf , /* 27 */
BrFilePutChar , /* 28 */
BrFilePutLine , /* 29 */
BrFileRead , /* 30 */
BrFileWrite , /* 31 */
BrFloatAtan2 , /* 32 */
BrFloatCeil , /* 33 */
BrFloatFloor , /* 34 */
BrFloatPow , /* 35 */
BrFloatSqrt , /* 36 */
BrGetEnv , /* 37 */
BrImageAdd , /* 38 */
BrImageDereference , /* 39 */
BrImageLookupName , /* 40 */
BrImageLookupOrdinal , /* 41 */
BrImageReference , /* 42 */
BrImageRemove , /* 43 */
BrInsert , /* 44 */
BrIsAlpha , /* 45 */
BrIsDigit , /* 46 */
BrIsPrint , /* 47 */
BrIsSpace , /* 48 */
BrLastErrorGet , /* 49 */
BrLastErrorSet , /* 50 */
BrLexerAllocate , /* 51 */
BrLexerCommentSet , /* 52 */
BrLexerDumpSet , /* 53 */
BrLexerErrorSet , /* 54 */
BrLexerFree , /* 55 */
BrLexerPop , /* 56 */
BrLexerPosition , /* 57 */
BrLexerPushFile , /* 58 */
BrLexerPushString , /* 59 */
BrLexerTokenError , /* 60 */
BrLogPrintf , /* 61 */
BrMemAllocate , /* 62 */
BrMemCalloc , /* 63 */
BrMemCmp , /* 64 */
BrMemCpy , /* 65 */
BrMemFree , /* 66 */
BrMemInquire , /* 67 */
BrMemSet , /* 68 */
BrMemStrDup , /* 69 */
BrNamePatternMatch , /* 70 */
BrNewList , /* 71 */
BrObjectContainerFree , /* 72 */
BrObjectListAllocate , /* 73 */
BrParseFixed , /* 74 */
BrParseFloat , /* 75 */
BrParseInteger , /* 76 */
BrParseMatrixFixed , /* 77 */
BrParseMatrixFloat , /* 78 */
BrParseVectorFixed , /* 79 */
BrParseVectorFloat , /* 80 */
BrPrimitiveLibraryFind , /* 81 */
BrQsort , /* 82 */
BrRegistryAdd , /* 83 */
BrRegistryAddMany , /* 84 */
BrRegistryAddStatic , /* 85 */
BrRegistryClear , /* 86 */
BrRegistryCount , /* 87 */
BrRegistryEnum , /* 88 */
BrRegistryFind , /* 89 */
BrRegistryFindMany , /* 90 */
BrRegistryNew , /* 91 */
BrRegistryNewStatic , /* 92 */
BrRegistryRemove , /* 93 */
BrRegistryRemoveMany , /* 94 */
BrRegistryRemoveStatic , /* 95 */
BrRemHead , /* 96 */
BrRemTail , /* 97 */
BrRemove , /* 98 */
BrRendererFacilityFind , /* 99 */
BrResAdd , /* 100 */
BrResAllocate , /* 101 */
BrResCheck , /* 102 */
BrResChildEnum , /* 103 */
BrResClass , /* 104 */
BrResDump , /* 105 */
BrResFree , /* 106 */
BrResFreeNoCallback , /* 107 */
BrResIsChild , /* 108 */
BrResRemove , /* 109 */
BrResSize , /* 110 */
BrResSizeTotal , /* 111 */
BrResStrDup , /* 112 */
BrSScanf , /* 113 */
BrScratchAllocate , /* 114 */
BrScratchFlush , /* 115 */
BrScratchFree , /* 116 */
BrScratchInquire , /* 117 */
BrScratchString , /* 118 */
BrScratchStringSize , /* 119 */
BrSimpleAddHead , /* 120 */
BrSimpleInsert , /* 121 */
BrSimpleNewList , /* 122 */
BrSimpleRemHead , /* 123 */
BrSimpleRemove , /* 124 */
BrSprintf , /* 125 */
BrSprintfN , /* 126 */
BrStrCat , /* 127 */
BrStrCmp , /* 128 */
BrStrCpy , /* 129 */
BrStrICmp , /* 130 */
BrStrLen , /* 131 */
BrStrNCmp , /* 132 */
BrStrNCpy , /* 133 */
BrStrNICmp , /* 134 */
BrStrRChr , /* 135 */
BrStrToD , /* 136 */
BrStrToF , /* 137 */
BrStrToL , /* 138 */
BrStrToUL , /* 139 */
BrStringToTokenValue , /* 140 */
BrSwap16 , /* 141 */
BrSwap32 , /* 142 */
BrSwapBlock , /* 143 */
BrSwapFloat , /* 144 */
BrTVTemplateAllocate , /* 145 */
BrTVTemplateFree , /* 146 */
BrTokenCount , /* 147 */
BrTokenCreate , /* 148 */
BrTokenFind , /* 149 */
BrTokenFindMany , /* 150 */
BrTokenIdentifier , /* 151 */
BrTokenType , /* 152 */
BrTokenValueCompare , /* 153 */
BrTokenValueComparePartial , /* 154 */
BrTokenValueDump , /* 155 */
BrTokenValueQuery , /* 156 */
BrTokenValueQueryAll , /* 157 */
BrTokenValueQueryAllSize , /* 158 */
BrTokenValueQueryMany , /* 159 */
BrTokenValueQueryManySize , /* 160 */
BrTokenValueSet , /* 161 */
BrTokenValueSetMany , /* 162 */
BrVSScanf , /* 163 */
BrVSprintf , /* 164 */
BrVSprintfN , /* 165 */
BrWarning , /* 166 */
_BrAssert , /* 167 */
_BrExceptionBegin , /* 168 */
_BrExceptionEnd , /* 169 */
_BrExceptionResource , /* 170 */
_BrExceptionThrow , /* 171 */
_BrExceptionValueFetch , /* 172 */
_BrUAssert , /* 173 */
_EPI , /* 174 */
_M_br_object_container_addFront , /* 175 */
_M_br_object_container_count , /* 176 */
_M_br_object_container_find , /* 177 */
_M_br_object_container_findMany , /* 178 */
_M_br_object_container_remove , /* 179 */
_M_br_object_container_removeFront , /* 180 */
_M_br_object_container_tokensMatch , /* 181 */
_M_br_object_container_tokensMatchBegin , /* 182 */
_M_br_object_container_tokensMatchEnd , /* 183 */
_M_br_object_query , /* 184 */
_M_br_object_queryAll , /* 185 */
_M_br_object_queryAllSize , /* 186 */
_M_br_object_queryBuffer , /* 187 */
_M_br_object_queryMany , /* 188 */
_M_br_object_queryManySize , /* 189 */
_PRO , /* 190 */
};
static br_image Image_BRCORE1 = {
{0},
"BRCORE1", /* Identifier */
BR_IMG_RESIDENT, /* Image type */
0, /* Reference count */
1, /* Ordinal base */
BR_ASIZE(functionPointers_BRCORE1), /* Number of functions */
functionPointers_BRCORE1, /* Table of functions */
BR_ASIZE(namePointers_BRCORE1), /* Number of names */
namePointers_BRCORE1, /* Table of names */
nameOrdinals_BRCORE1, /* Table of name ordinals */
0, /* Number of imports */
NULL, /* Table of imports */
0, /* Number of sections */
NULL, /* Table of sections */
NULL, /* Type pointer */
};

220
core/fw/fwsetup.c Normal file
View File

@ -0,0 +1,220 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: fwsetup.c 1.2 1998/07/20 21:52:55 jon Exp $
* $Locker: $
*
*/
#include "fw.h"
#include "brassert.h"
#include "datafile.h"
#include "syscn_p.h"
#include "brmath.h"
BR_RCS_ID("$Id: fwsetup.c 1.2 1998/07/20 21:52:55 jon Exp $")
/*
* Global renderer state
*/
br_framework_state BR_ASM_DATA fw;
/*
* Various bits of default data
*/
extern br_diaghandler * BR_ASM_DATA _BrDefaultDiagHandler;
extern br_filesystem * BR_ASM_DATA _BrDefaultFilesystem;
extern br_allocator * BR_ASM_DATA _BrDefaultAllocator;
extern br_file_primitives _BrFilePrimsNull;
/*
* System resource classes
*/
static br_resource_class resourceClasses[] = {
/*
* These two classes have to be initialised by hand
*/
{0, "REGISTRY", BR_MEMORY_REGISTRY, NULL },
{0, "ANCHOR", BR_MEMORY_ANCHOR, NULL },
{0, "RESOURCE_CLASS", BR_MEMORY_RESOURCE_CLASS, NULL },
{0, "SCRATCH,", BR_MEMORY_SCRATCH, NULL, 16 },
{0, "STRING", BR_MEMORY_STRING, NULL, 1 },
{0, "FILE", BR_MEMORY_FILE, _BrFileFree },
{0, "POOL", BR_MEMORY_POOL, NULL, 16 },
{0, "EXCEPTION_HANDLER",BR_MEMORY_EXCEPTION_HANDLER,NULL },
{0, "TOKEN", BR_MEMORY_TOKEN, NULL },
{0, "TOKEN_MAP", BR_MEMORY_TOKEN_MAP, NULL, 8 },
{0, "DATAFILE", BR_MEMORY_DATAFILE, NULL },
{0, "LEXER", BR_MEMORY_LEXER, NULL },
{0, "OBJECT_LIST", BR_MEMORY_OBJECT_LIST, NULL },
{0, "OBJECT_LIST_ENTRY",BR_MEMORY_OBJECT_LIST_ENTRY,NULL },
{0, "APPLICATION", BR_MEMORY_APPLICATION, NULL },
{0, "IMAGE", BR_MEMORY_IMAGE, _BrImageFree },
{0, "IMAGE_ARENA", BR_MEMORY_IMAGE_ARENA, NULL },
{0, "IMAGE_SECTIONS", BR_MEMORY_IMAGE_SECTIONS, NULL },
{0, "IMAGE_NAMES", BR_MEMORY_IMAGE_NAMES, NULL },
{0, "OBJECT", BR_MEMORY_OBJECT, _BrObjectFree, 16 },
{0, "OBJECT_DATA", BR_MEMORY_OBJECT_DATA, NULL, 16 },
{0, "DRIVER", BR_MEMORY_DRIVER, NULL },
{0, "FMT_RESULTS", BR_MEMORY_FMT_RESULTS, NULL },
{0, "TOKEN_VALUE", BR_MEMORY_TOKEN_VALUE, NULL },
{0, "TOKEN_TEMPLATE", BR_MEMORY_TOKEN_TEMPLATE, NULL },
};
/*
* Resident image that is used to expose resident framework
* functions to loaded devices.
*/
#include "fwimg.h"
br_error BR_PUBLIC_ENTRY BrFwBegin(void)
{
int i;
if(fw.active)
return BRE_ALLREADY_ACTIVE;
/*
* Set handlers to use defaults
*/
if(fw.diag == NULL)
fw.diag = _BrDefaultDiagHandler;
if(fw.fsys == NULL)
fw.fsys = _BrDefaultFilesystem;
if(fw.mem == NULL)
fw.mem = _BrDefaultAllocator;
/*
* Set up initial state of file writing
*/
fw.open_mode = BR_FS_MODE_BINARY;
/*
* Initialise all registries
*/
BrRegistryNew(&fw.reg_resource_classes);
/*
* Fake the resource classes that are required to
* support the registry
*/
fw.resource_class_index[BR_MEMORY_REGISTRY] =
resourceClasses+0;
fw.resource_class_index[BR_MEMORY_ANCHOR] =
resourceClasses+1;
/*
* Allocate the zero sized base resource instance for
* the framework
*/
fw.res = BrResAllocate(NULL, 0, BR_MEMORY_ANCHOR);
/*
* Register all the system resource classes
*/
for(i=0; i < BR_ASIZE(resourceClasses); i++)
BrResClassAdd(resourceClasses+i);
/*
* Setup list of loaded images
*/
BrNewList(&fw.images);
/*
* Initialise table of devices
*/
fw.dev_slots = BrResAllocate(fw.res, NDEV_SLOTS * sizeof(*fw.dev_slots), BR_MEMORY_DRIVER );
fw.ndev_slots = NDEV_SLOTS;
/*
* Mark as active
*/
fw.active = BR_TRUE;
/*
* Set up tokens
*/
BrTokenBegin();
/*
* Set up default system configuration
*/
BrSystemConfigBegin();
// Mark default drivers as still to be loaded.
fw.bAlreadyLoadedDrivers = BR_FALSE ;
/*
* Set up resident framework image
*/
BrImageAdd(&Image_BRCORE1);
return BRE_OK;
}
br_error BR_PUBLIC_ENTRY BrFwEnd(void)
{
if(!fw.active)
return BRE_NOT_ACTIVE;
BrImageRemove(&Image_BRCORE1);
/*
* Free all resources ...
*/
BrResFree(fw.res);
/*
* Clear out fw structure
*/
BrMemSet(&fw, 0, sizeof(fw));
return BRE_OK;
}
/*
* User functions for setting new errorhandler, filesystem, or allocator
*/
br_diaghandler * BR_PUBLIC_ENTRY BrDiagHandlerSet(br_diaghandler *newdh)
{
br_diaghandler *old = fw.diag;
if(newdh == NULL)
fw.diag = _BrDefaultDiagHandler;
else
fw.diag = newdh;
return old;
}
br_filesystem * BR_PUBLIC_ENTRY BrFilesystemSet(br_filesystem *newfs)
{
br_filesystem *old = fw.fsys;
if(newfs == NULL)
fw.fsys = _BrDefaultFilesystem;
else
fw.fsys = newfs;
return old;
}
br_allocator * BR_PUBLIC_ENTRY BrAllocatorSet(br_allocator *newal)
{
br_allocator *old = fw.mem;
if(newal == NULL)
fw.mem = _BrDefaultAllocator;
else
fw.mem = newal;
return old;
}

90
core/fw/genfile.c Normal file
View File

@ -0,0 +1,90 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: genfile.c 1.1 1997/12/10 16:41:08 jon Exp $
* $Locker: $
*
* General per-chunk file operations
*
*/
#include <stddef.h>
#include "fw.h"
#include "brassert.h"
#include "datafile.h"
BR_RCS_ID("$Id: genfile.c 1.1 1997/12/10 16:41:08 jon Exp $")
/**
** End Marker
**/
int FopRead_END(br_datafile *df, br_uint_32 id, br_uint_32 length, br_uint_32 count)
{
return 1;
}
int FopWrite_END(br_datafile *df)
{
df->prims->chunk_write(df,FID_END,0);
return 0;
}
/**
** File Info
**/
struct file_info {
br_uint_32 type;
br_uint_32 version;
};
br_file_enum_member file_type_FM[] = {
_ENUM_MEMBER(FILE_TYPE_NONE),
_ENUM_MEMBER(FILE_TYPE_ACTORS),
_ENUM_MEMBER(FILE_TYPE_PIXELMAP),
_ENUM_MEMBER(FILE_TYPE_LIGHT),
_ENUM_MEMBER(FILE_TYPE_CAMERA),
_ENUM_MEMBER(FILE_TYPE_MATERIAL_OLD),
_ENUM_MEMBER(FILE_TYPE_MODEL),
_ENUM_MEMBER(FILE_TYPE_ANIMATION),
_ENUM_MEMBER(FILE_TYPE_TREE),
_ENUM_MEMBER(FILE_TYPE_MATERIAL)
};
STATIC _FILE_ENUM(file_type);
#define _STRUCT_NAME struct file_info
STATIC br_file_struct_member file_info_FM[] = {
_ENUM_32(type,file_type_F),
_UINT_32(version),
};
STATIC _FILE_STRUCT(file_info);
#undef _STRUCT_NAME
#if 0
int FopRead_FILE_INFO(br_datafile *df, br_uint_32 id, br_uint_32 length, br_uint_32 count)
{
struct file_info fi;
df->prims->struct_read(df,&file_info_F, &fi);
return fi.type;
}
#endif
int FopWrite_FILE_INFO(br_datafile *df, br_uint_32 type)
{
struct file_info fi;
fi.type = type;
fi.version = BR_FILE_VERSION;
df->prims->chunk_write(df,FID_FILE_INFO,df->prims->struct_size(df,&file_info_F, &fi));
df->prims->struct_write(df,&file_info_F, &fi);
return 0;
}

360
core/fw/image.c Normal file
View File

@ -0,0 +1,360 @@
/*
* Copyright (c) 1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: image.c 1.2 1998/06/23 13:46:15 jon Exp $
* $Locker: $
*
* Loadable image management
*/
#include "fw.h"
#include "host.h"
#include "brassert.h"
BR_RCS_ID("$Id: image.c 1.2 1998/06/23 13:46:15 jon Exp $")
#define ARENA_ALIGN 4096
br_boolean BR_RESIDENT_ENTRY BrImageAdd(br_image *img)
{
BR_ADDHEAD(&fw.images,img);
return BR_TRUE;
}
br_boolean BR_RESIDENT_ENTRY BrImageRemove(br_image *img)
{
BR_REMOVE(img);
return BR_TRUE;
}
/*
* Looks for an image in the currently loaded set
*/
br_image * BR_RESIDENT_ENTRY BrImageFind(char *pattern)
{
char *c;
br_image *img;
/*
* Remove extension
*/
if(c = BrStrRChr(pattern, '.')) {
if(!BrStrICmp(c, ".dll") || !BrStrICmp(c, ".bdd") || !BrStrICmp(c, ".bed"))
*c = '\0';
}
/*
* Look for image in currently loaded set
*/
BR_FOR_LIST(&fw.images,img)
if(BrNamePatternMatch(pattern, img->identifier))
return img;
return NULL;
}
/*
* Try to buil a br_image via the host image loader
*/
static br_image *imageLoadHost(char *name)
{
br_image *img;
void *host_image;
host_image = HostImageLoad(name);
if(host_image) {
img = BrResAllocate(NULL,sizeof(*img), BR_MEMORY_IMAGE);
img->identifier = BrResStrDup(img,name);
img->type = BR_IMG_HOST;
img->type_pointer = host_image;
return img;
}
return NULL;
}
/*
* Lookup a named image
*/
br_image * BR_RESIDENT_ENTRY BrImageReference(char *name)
{
char *suffix,*scratch = BrScratchString();
br_image *img;
#if 0
br_exception ex_type;
void *ex_value;
if(ex_type = BrExceptionCatch(&ex_value)) {
SET_ERROR(ex_type, ex_value);
return NULL;
}
#endif
/*
* See if image is already loaded...
*/
img = BrImageFind(name);
if(img) {
img->ref_count++;
return img;
}
/*
* Try to load an image from the filesystem
* The search order depends on the extension
*
* No Suffix:
* ImageLoad(xxx.BED) (If eval. version)
* ImageLoad(xxx.BDD)
* ImageLoadHost(xxx)
* ImageLoad(xxx.DLL)
*
* .BDD or .BED
* ImageLoad(xxx)
* ImageLoadHost(xxx)
*
* Any other suffix:
* ImageLoadHost(xxx)
* ImageLoad(xxx)
*/
for(suffix = name; *suffix && *suffix != '.'; suffix++)
;
if(*suffix == '\0') {
#if EVAL
BrStrCpy(scratch, name);
BrStrCat(scratch, ".BED");
img = ImageLoad(scratch);
#endif
if(!img) {
BrStrCpy(scratch, name);
BrStrCat(scratch, ".BDD");
img = ImageLoad(scratch);
}
if(!img)
img = imageLoadHost(name);
if(!img) {
BrStrCpy(scratch, name);
BrStrCat(scratch, ".DLL");
img = ImageLoad(scratch);
}
} else if(!BrStrICmp(suffix,".bdd") || !BrStrICmp(suffix,".bed")) {
if(!img)
img = ImageLoad(name);
if(!img)
img = imageLoadHost(name);
} else{
if(!img)
img = imageLoadHost(name);
if(!img)
img = ImageLoad(name);
}
/*
* Add image to framework resources and current list
*/
if(img) {
/* Splat any extension from the identifier to avoid problems when searching for loaded image. */
for(suffix = img->identifier; *suffix && *suffix != '.'; suffix++);
if(suffix) *suffix='\0';
BrResAdd(fw.res, img);
BrImageAdd(img);
img->ref_count++;
}
return img;
}
/*
* Find a symbol in an image file
*/
static void * imageLookupName(br_image *img, char *name, br_uint_32 hint)
{
int c,limit,base;
/*
* See if 'hint' matches
*/
if(hint < img->n_names && !BrStrCmp(name, img->names[hint]))
return img->functions[img->name_ordinals[hint]];
/*
* Binary search on name table
*
* XXX
*/
limit = img->n_names;
base = 0;
while(limit) {
/*
* Compare with halfway point
*/
c = BrStrCmp(name, img->names[base+limit/2]);
if(c < 0) {
/*
* Lower
*/
limit = limit/2;
} else if(c > 0) {
/*
* Higher
*/
base += limit/2+1;
limit = limit - (limit/2+1);
} else {
/*
* Hit
*/
return img->functions[img->name_ordinals[base+limit/2]];
}
}
/*
* No match
*/
return NULL;
}
/*
*Public entry point for looking up symbols
*
* Tries
* <name>
* <name> with any leading underbar removed
* '_'<name>
*/
void * BR_RESIDENT_ENTRY BrImageLookupName(br_image *img, char *name, br_uint_32 hint)
{
char *scratch = BrScratchString();
void *p;
/*
* If this is a host library - just pass the request on
*/
if(img->type == BR_IMG_HOST ) {
ASSERT(img->type_pointer);
return HostImageLookupName(img->type_pointer, name, hint);
}
/*
* Try the name as provided
*/
p = imageLookupName(img, name, hint);
if(p)
return p;
/*
* Drop any leading underbar
*/
if(*name == '_') {
p = imageLookupName(img, name+1, hint);
if(p)
return p;
}
/*
* Try adding a leading underbar
*/
scratch[0] = '_';
BrStrCpy(scratch+1,name);
p = imageLookupName(img, scratch, hint);
return p;
}
void * BR_RESIDENT_ENTRY BrImageLookupOrdinal(br_image *img, br_uint_32 ordinal)
{
if(img->type == BR_IMG_HOST) {
ASSERT(img->type_pointer);
return HostImageLookupOrdinal(img->type_pointer, ordinal);
}
ordinal -= img->ordinal_base;
/*
* Check that ordinal exists
*/
if(ordinal > img->n_functions)
return NULL;
return img->functions[ordinal];
}
void BR_RESIDENT_ENTRY BrImageDereference(br_image *image)
{
image->ref_count--;
if(image->ref_count > 0)
return;
switch(image->type) {
case BR_IMG_RESIDENT:
/*
* Resident images are locked in memory
* because they contain pointers into the
* program
*/
return;
case BR_IMG_HOST:
HostImageUnload(image->type_pointer);
break;
case BR_IMG_FRAMEWORK:
break;
}
/*
* Unlink image
*/
BR_REMOVE(image);
/*
* Free resource
*/
BrResFree(image);
}
void BR_RESIDENT_ENTRY BrImageFree(br_image *image)
{
int i;
/*
* Dereference all referenced DLLs
*/
for(i=0; i < image->n_imports; i++)
BrImageDereference(image->imports[i]);
}
/*
* Resource destructor
*/
void BR_CALLBACK _BrImageFree(void *res, br_uint_8 res_class, br_size_t size)
{
BrImageFree(res);
}

682
core/fw/lexer.c Normal file
View File

@ -0,0 +1,682 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: lexer.c 1.1 1997/12/10 16:41:08 jon Exp $
* $Locker: $
*
* Generic lexer
*/
#include "fw.h"
#include "brassert.h"
#define MAX_STRING 256
static void lexerAdvance(struct br_lexer * l);
static void lexerAdvanceDump(struct br_lexer * l);
/*
* Default error handler, does nothing
*/
static void BR_CALLBACK lexerError(struct br_lexer *l, char *string)
{
}
struct br_lexer * BR_RESIDENT_ENTRY BrLexerAllocate(struct br_lexer_keyword *keywords, int nkeywords)
{
struct br_lexer * l;
l = BrResAllocate(fw.res,sizeof(*l), BR_MEMORY_LEXER);
if(l == NULL)
return NULL;
l->keywords = keywords;
l->nkeywords = nkeywords;
l->advance = lexerAdvance;
l->source = NULL;
l->string_buffer = BrResAllocate(l, MAX_STRING, BR_MEMORY_LEXER);
l->string_buffer_size = MAX_STRING;
l->error = lexerError;
return l;
}
char BR_RESIDENT_ENTRY BrLexerCommentSet(struct br_lexer * l, char eol_comment)
{
char old = l->eol_comment;
l->eol_comment = eol_comment;
return old;
}
br_lexer_error_cbfn * BR_RESIDENT_ENTRY BrLexerErrorSet(struct br_lexer * l, br_lexer_error_cbfn *error)
{
br_lexer_error_cbfn *old = l->error;
if(error == NULL)
l->error = lexerError;
else
l->error = error;
if(old == lexerError)
return NULL;
else
return old;
}
void BR_RESIDENT_ENTRY BrLexerFree(struct br_lexer * l)
{
/*
* Free up lexer (will free up all sources and any files)
*/
BrResFree(l);
}
static void BR_CALLBACK fileGetchar(struct br_lexer_source *source)
{
source->next = BrFileGetChar(source->ptr);
}
br_error BR_RESIDENT_ENTRY BrLexerPushFile(struct br_lexer * l, char *file)
{
br_lexer_source *s;
void *f;
int mode = BR_FS_MODE_TEXT;
/*
* Try to open file
*/
f = BrFileOpenRead(file, 0, NULL, &mode);
if(f == NULL)
return BRE_FAIL;
s = BrResAllocate(l, sizeof(*s), BR_MEMORY_LEXER);
if(s == NULL)
return BRE_NO_MEMORY;
/*
* Attach file resource to source
*/
BrResAdd(s,f);
s->name = file;
s->line = 1;
s->getchar = fileGetchar;
s->ptr = f;
/*
* Setup first charater
*/
s->getchar(s);
/*
* Link onto front of list of sources
*/
s->prev = l->source;
l->source = s;
return BRE_OK;
}
static void BR_CALLBACK stringGetchar(struct br_lexer_source *source)
{
char *cp = source->ptr;
if(cp == NULL || *cp == '\0') {
source->next = BR_EOF;
} else {
source->next = *cp;
source->ptr = cp+1;
}
}
br_error BR_RESIDENT_ENTRY BrLexerPushString(struct br_lexer * l, char *string, char *name)
{
br_lexer_source *s;
s = BrResAllocate(l, sizeof(*s), BR_MEMORY_LEXER);
if(s == NULL)
return BRE_NO_MEMORY;
s->name = name;
s->line = 1;
s->getchar = stringGetchar;
s->ptr = string;
/*
* Setup first charater
*/
s->getchar(s);
/*
* Link onto front of list of sources
*/
s->prev = l->source;
l->source = s;
return BRE_OK;
}
struct br_lexer_source * BR_RESIDENT_ENTRY BrLexerPop(struct br_lexer * l)
{
br_lexer_source *s;
s = l->source;
if(s == NULL)
return s;
/*
* Set current source to previous
*/
l->source = s->prev;
BrResFree(s);
return s;
}
static void lexerAdvance(struct br_lexer * l)
{
int n;
br_boolean got_point;
for(;;) {
if(l->source == NULL) {
l->current.id = T_EOF;
return;
}
if(l->source->next == BR_EOF) {
/*
* End of current source - pop current and try again
*/
BrLexerPop(l);
continue;
} else if((l->eol_comment != '\0') && (l->source->next == l->eol_comment)) {
/*
* Comment - skip until EOL or EOF
*/
for(;;) {
l->source->getchar(l->source);
if(l->source->next == '\n' ||
l->source->next == BR_EOF)
break;
}
continue;
} else if(l->source->next == '\n') {
/*
* Newline - track line number
*/
l->source->line++;
l->source->getchar(l->source);
continue;
} else if(l->source->next == '"') {
/*
* Read a string - read characters until '"', newline, or EOF
*/
n = 0;
for(n=0; n < l->string_buffer_size; ) {
l->source->getchar(l->source);
if(l->source->next == '"' ||
l->source->next == '\n' ||
l->source->next == BR_EOF)
break;
l->string_buffer[n++] = (char)l->source->next;
}
if(l->source->next != '"') {
l->current.id = T_ERROR;
l->current.v.string = "Unterminated string";
l->source->getchar(l->source);
return;
}
l->string_buffer[n] = '\0';
l->current.v.string = l->string_buffer;
l->current.id = T_STRING;
l->source->getchar(l->source);
return;
} else if(BrIsSpace(l->source->next) || l->source->next == '\032') {
/*
* white space - ignore
*/
l->source->getchar(l->source);
continue;
} else if(BrIsAlpha(l->source->next) || l->source->next == '_') {
/*
* Idenitifier - read characters until not alpha, _ or 0-9
*/
l->string_buffer[0] = (char)l->source->next;
for(n=1; n < l->string_buffer_size-1; ) {
l->source->getchar(l->source);
if(!(BrIsAlpha(l->source->next) ||
BrIsDigit(l->source->next) ||
l->source->next == '_'))
break;
l->string_buffer[n++] = (char)l->source->next;
}
l->string_buffer[n] = '\0';
l->current.v.string = l->string_buffer;
/*
* Try to look up a keyword
*/
for(n=0; n < l->nkeywords; n++) {
if(l->keywords[n].name[0] == l->string_buffer[0] &&
!BrStrICmp(l->keywords[n].name,l->string_buffer)) {
/*
* Found a keyword - which are based at 128
*/
l->current.id = l->keywords[n].id;
return;
}
}
l->current.id = T_IDENT;
l->current.v.string = l->string_buffer;
return;
} else if(BrIsDigit(l->source->next)) {
/*
* Read a number
*/
l->string_buffer[0] = (char)l->source->next;
l->source->getchar(l->source);
got_point = BR_FALSE;
for(n=1; n < l->string_buffer_size-1; n++) {
switch(l->source->next) {
case '0': case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9': case 'x': case 'X':
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
l->string_buffer[n] = (char)l->source->next;
l->source->getchar(l->source);
break;
case '.':
got_point = BR_TRUE;
l->string_buffer[n] = (char)l->source->next;
l->source->getchar(l->source);
break;
default:
goto done;
}
}
done:
l->string_buffer[n] = '\0';
/*
* If this is not a real number, then generate an integer token
*/
if(got_point) {
l->current.v.real = BrStrToF(l->string_buffer, NULL);
l->current.id = T_REAL;
return;
} else {
l->current.v.integer = BrStrToL(l->string_buffer,0,0);
l->current.id = T_INTEGER;
return;
}
} else if(BrIsPrint(l->source->next)) {
/*
* All other printable characters turn into tokens
*/
l->current.id = l->source->next;
l->source->getchar(l->source);
return;
} else
l->current.id = T_ERROR;
l->current.v.string = "Unexpected character";
l->source->getchar(l->source);
return;
}
}
#if DEBUG
static void lexerAdvanceDump(struct br_lexer * l)
{
char *tname,*tvalue;
char val[40];
char tmp[256];
/*
* Do the normal advance operation
*/
lexerAdvance(l);
switch(l->current.id) {
case T_EOF:
tname = "EOF";
tvalue = NULL;
break;
case T_IDENT:
tname = "IDENT";
tvalue = l->current.v.string;
break;
case T_ERROR:
tname = "ERROR";
tvalue = l->current.v.string;
break;
case T_STRING:
tname = "STRING";
tvalue = l->current.v.string;
break;
case T_REAL:
tname = "REAL";
BrSprintfN(val, BR_ASIZE(val), "%g", l->current.v.real);
tvalue = val;
break;
case T_INTEGER:
tname = "INTEGER";
BrSprintfN(val, BR_ASIZE(val), "%d",l->current.v.integer);
tvalue = val;
break;
default:
if(l->current.id >= T_KEYWORD) {
tname = l->current.v.string;
tvalue = NULL;
} else if(BrIsPrint(l->current.id)) {
tname = val;
val[0] = l->current.id;
val[1] = '\0';
tvalue = NULL;
} else {
BrSprintfN(val, BR_ASIZE(val), "??? %d", l->current.id);
tname = val;
tvalue = NULL;
}
}
tmp[0] = '<';
BrStrCpy(tmp+1,tname);
if(tvalue) {
BrStrCat(tmp,":");
BrStrCat(tmp,tvalue);
}
BrStrCat(tmp,">");
l->putline(tmp, l->putline_arg);
}
#endif
br_error BR_RESIDENT_ENTRY BrLexerDumpSet(struct br_lexer * l, br_putline_cbfn *putline, void *putline_arg)
{
#if DEBUG
if(putline) {
l->advance = lexerAdvanceDump;
l->putline = putline;
l->putline_arg = putline_arg;
} else {
l->advance = lexerAdvance;
}
#endif
return BRE_OK;
}
void BR_RESIDENT_ENTRY BrLexerTokenError(struct br_lexer * l, br_lexer_token_id t)
{
int i;
char tmp[256];
if(l->current.id == T_ERROR) {
} else
switch(t) {
case T_EOF:
BrLexerError(l, "expected end of file");
break;
case T_ERROR:
BrLexerError(l, l->current.v.string);
break;
case T_IDENT:
BrLexerError(l, "expected an identifier");
break;
case T_STRING:
BrLexerError(l, "expected a string");
break;
case T_INTEGER:
BrLexerError(l, "expected an integer");
break;
case T_REAL:
BrLexerError(l, "expected a real number");
break;
default:
if(t >= T_KEYWORD) {
for(i=0; i < l->nkeywords; i++) {
if(l->keywords[i].id == t)
break;
}
if(i < l->nkeywords)
BrSprintfN(tmp, BR_ASIZE(tmp), "expected '%s'", l->keywords[i].name);
else
BrSprintfN(tmp, BR_ASIZE(tmp), "expected unknown keyword %d", t);
} else if(BrIsPrint(t)) {
BrSprintfN(tmp, BR_ASIZE(tmp), "expected '%c'", t);
} else {
BrSprintfN(tmp, BR_ASIZE(tmp), "expected unknown token %d", t);
}
BrLexerError(l, tmp);
}
/*
* Advance until expected token or EOF
*/
while(BrLexerCurrent(l) != t && BrLexerCurrent(l) != T_EOF) {
BrLexerAdvance(l);
}
}
/*
* Generate a string describing the current source position
*/
void BR_RESIDENT_ENTRY BrLexerPosition(struct br_lexer * l, char *buf, br_size_t buf_size)
{
ASSERT(buf_size >= 1);
if(l->source == NULL || l->source->name == NULL) {
buf[0] = '\0';
return;
}
BrSprintfN(buf, buf_size, "%s:%d ",l->source->name, l->source->line);
}
br_fixed_ls BR_RESIDENT_ENTRY BrParseFixed(struct br_lexer * l)
{
br_boolean neg = BR_FALSE;
br_fixed_ls x;
if(BrLexerCurrent(l) == T_PLUS)
BrLexerAdvance(l);
if(BrLexerCurrent(l) == T_DASH) {
neg = BR_TRUE;
BrLexerAdvance(l);
}
if(BrLexerCurrent(l) == T_REAL) {
x = BrFloatToFixed(BrLexerReal(l));
BrLexerAdvance(l);
} else if(BrLexerCurrent(l) == T_INTEGER) {
x = BrIntToFixed(BrLexerInteger(l));
BrLexerAdvance(l);
} else {
BrLexerError(l, "expecting a fixed");
BrLexerAdvance(l);
x = BrScalarToFixed(BR_SCALAR(0.0));
}
if(neg)
return -x;
else
return x;
}
br_float BR_RESIDENT_ENTRY BrParseFloat(struct br_lexer * l)
{
br_boolean neg = BR_FALSE;
br_float f;
if(BrLexerCurrent(l) == T_PLUS)
BrLexerAdvance(l);
if(BrLexerCurrent(l) == T_DASH) {
neg = BR_TRUE;
BrLexerAdvance(l);
}
if(BrLexerCurrent(l) == T_REAL) {
f = BrLexerReal(l);
BrLexerAdvance(l);
} else if(BrLexerCurrent(l) == T_INTEGER) {
f = (br_float)BrLexerInteger(l);
BrLexerAdvance(l);
} else {
BrLexerError(l, "expecting a float");
BrLexerAdvance(l);
f = 0.0F;
}
if(neg)
return -f;
else
return f;
}
br_int_32 BR_RESIDENT_ENTRY BrParseInteger(struct br_lexer * l)
{
br_boolean neg = BR_FALSE;
br_int_32 i;
if(BrLexerCurrent(l) == T_PLUS)
BrLexerAdvance(l);
if(BrLexerCurrent(l) == T_DASH) {
neg = BR_TRUE;
BrLexerAdvance(l);
}
if(BrLexerCurrent(l) == T_INTEGER) {
i = BrLexerInteger(l);
BrLexerAdvance(l);
} else {
BrLexerError(l, "expecting an integer");
BrLexerAdvance(l);
i = 0;
}
if(neg)
return -i;
else
return i;
}
br_int_32 BR_RESIDENT_ENTRY BrParseVectorFixed(struct br_lexer * l, br_fixed_ls *v, br_int_32 max)
{
int n;
BrLexerExpect(l, T_LSQUARE);
for(n=0;n < max; n++) {
*v++ = BrParseFixed(l);
if(BrLexerCurrent(l) == T_RSQUARE)
break;
BrLexerExpect(l, T_COMMA);
}
BrLexerExpect(l, T_RSQUARE);
return n+1;
}
br_int_32 BR_RESIDENT_ENTRY BrParseVectorFloat(struct br_lexer * l, br_float *v, br_int_32 max)
{
int n;
BrLexerExpect(l, T_LSQUARE);
for(n=0;n < max; n++) {
*v++ = BrParseFloat(l);
if(BrLexerCurrent(l) == T_RSQUARE)
break;
BrLexerExpect(l, T_COMMA);
}
BrLexerExpect(l, T_RSQUARE);
return n+1;
}
br_int_32 BR_RESIDENT_ENTRY BrParseMatrixFixed(struct br_lexer * l, br_fixed_ls *m, br_int_32 width, br_int_32 max_h)
{
int n;
BrLexerExpect(l, T_LSQUARE);
for(n=0; n < max_h; n++, m+= width) {
BrParseVectorFixed(l,m,width);
if(BrLexerCurrent(l) == T_RSQUARE)
break;
BrLexerExpect(l, T_COMMA);
}
BrLexerExpect(l, T_RSQUARE);
return n;
}
br_int_32 BR_RESIDENT_ENTRY BrParseMatrixFloat(struct br_lexer * l, br_float *m, br_int_32 width, br_int_32 max_h)
{
int n;
BrLexerExpect(l, T_LSQUARE);
for(n=0; n < max_h; n++, m+= width) {
BrParseVectorFloat(l,m,width);
if(BrLexerCurrent(l) == T_RSQUARE)
break;
BrLexerExpect(l, T_COMMA);
}
BrLexerExpect(l, T_RSQUARE);
return n;
}

197
core/fw/lexer.h Normal file
View File

@ -0,0 +1,197 @@
/*
* Copyright (c) 1993-1995 by Argonaut Technologies Limited. All rights reserved.
*
* $Id: lexer.h 1.1 1997/12/10 16:41:08 jon Exp $
* $Locker: $
*
* Generic lexer data structures
*/
#ifndef _LEXER_H_
#define _LEXER_H_
/*
* Predefined tokens
*/
typedef enum br_lexer_token_id {
T_EOF,
/*
* Built in tokens
*/
T_ERROR,
T_IDENT,
T_STRING,
T_INTEGER,
T_REAL,
/*
* Single characters
*/
T_EXCLAM = '!',
T_DQUOTE = '"',
T_HASH = '#',
T_DOLLAR = '$',
T_PERCENT = '%',
T_AMPERSAND = '&',
T_RQUOTE = '\'',
T_LPAREN = '(',
T_RPAREN = ')',
T_ASTERISK = '*',
T_PLUS = '+',
T_COMMA = ',',
T_DASH = '-',
T_PERIOD = '.',
T_SLASH = '/',
T_COLON = ':',
T_SEMICOLON = ';',
T_LANGLE = '<',
T_EQUAL = '=',
T_RANGLE = '>',
T_QUERY = '?',
T_COMAT = '@',
T_LSQUARE = '[',
T_BSLASH = '\\',
T_RSQUARE = ']',
T_CARET = '^',
T_UNDERBAR = '_',
T_LQUOTE = '`',
T_LBRACE = '{',
T_VBAR = '|',
T_RBRACE = '}',
T_TILDE = '~',
/*
* Keywords - start at 128
*/
T_KEYWORD = 128
} br_lexer_token_id;
/*
* A token - id + value
*/
typedef struct br_lexer_token {
/*
* Token ID
*/
br_lexer_token_id id;
/*
* Value
*/
union {
/*
* Integer
*/
br_int_32 integer;
/*
* Real number
*/
float real;
/*
* String
*/
char * string;
} v;
} br_lexer_token;
typedef void BR_CALLBACK br_lexer_getchar_cbfn(struct br_lexer_source *source);
typedef void BR_CALLBACK br_lexer_error_cbfn(struct br_lexer *l, char *string);
typedef struct br_lexer {
/*
* Current source of input charaters
*/
struct br_lexer_source *source;
/*
* Current token
*/
br_lexer_token current;
/*
* Keywords to recognise
*/
struct br_lexer_keyword *keywords;
br_int_32 nkeywords;
/*
* EOL comment character (or NULL if none)
*/
char eol_comment;
/*
* Function to advance to next token
*/
void (*advance)(struct br_lexer *self);
/*
* putline function for dump
*/
br_putline_cbfn *putline;
void *putline_arg;
/*
* Constructed string values are store here
*/
char *string_buffer;
br_int_32 string_buffer_size;
/*
* error handler
*/
br_lexer_error_cbfn *error;
} br_lexer;
typedef struct br_lexer_source {
struct br_lexer_source *prev;
/*
* Source name and line number for error reporting
*/
char *name;
br_int_32 line;
/*
* Next input character
*/
br_int_32 next;
/*
* Function to update input character
*/
br_lexer_getchar_cbfn *getchar;
/*
* Useful pointer for getchar fn.
*/
void *ptr;
} br_lexer_source;
typedef struct br_lexer_keyword {
char *name;
br_int_32 id;
} br_lexer_keyword;
/*
* Macros for examining current token and advancing
*/
#define BrLexerCurrent(l) ((l)->current.id)
#define BrLexerString(l) ((l)->current.v.string)
#define BrLexerInteger(l) ((l)->current.v.integer)
#define BrLexerReal(l) ((l)->current.v.real)
#define BrLexerAdvance(l) ((l)->advance(l))
#define BrLexerExpect(l,t) do {if(BrLexerCurrent(l) != (t)) BrLexerTokenError(l,t); else BrLexerAdvance(l);} while(0)
#define BrLexerCheck(l,t) do {if(BrLexerCurrent(l) != (t)) BrLexerTokenError(l,t);} while(0)
#define BrLexerError(l,s) ((l)->error(l,s))
#endif

380
core/fw/loader.c Normal file
View File

@ -0,0 +1,380 @@
/*
* Copyright (c) 1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: loader.c 1.1 1997/12/10 16:41:08 jon Exp $
* $Locker: $
*
* Win32 Image Loader - Can load EXEs and DLLs
*
*
* XXX Todo:
* Add exceptions
* Make more paranoid about reading sections and applying relocations
* Don't load unnecessary segments
* Throw away any segments that are not needed after loading (relocation)
*/
#include "fw.h"
#include "wincoff.h"
BR_RCS_ID("$Id: loader.c 1.1 1997/12/10 16:41:08 jon Exp $")
#define READ_BLOCK(var,fh) do { if (BrFileRead(&(var), 1, sizeof(var),(fh)) != sizeof(var)) return NULL; } while (0)
/*
* Attempts to load an image file into memory
*/
br_image *ImageLoad(char *name)
{
void *fh;
int mode = BR_FS_MODE_BINARY;
struct msdos_header dos_header;
struct coff_header coff_header;
struct nt_optional_header nt_header;
struct section_header section_header;
br_uint_32 pe;
br_image *img;
br_uint_8 *arena_base;
int arena_size,arena_align;
int i;
br_uint_32 offset;
unsigned int n;
/*
* Try name as is.
*/
fh = BrFileOpenRead(name,0, NULL, &mode);
if(fh == NULL)
return NULL;
/*
* Read MSDOS header
*/
READ_BLOCK(dos_header,fh);
/*
* Validate MSDOS header
*/
if(dos_header.magic != 0x5A4D)
return NULL;
/*
* Read PE signature
*/
if(dos_header.new_header_offset < sizeof(dos_header))
return NULL;
BrFileAdvance(dos_header.new_header_offset - sizeof(dos_header), fh);
READ_BLOCK(pe,fh);
/*
* Check magic number
*/
if(pe != 0x00004550)
return NULL;
/*
* Read base COFF header
*/
READ_BLOCK(coff_header,fh);
/*
* Check machine type
*/
if(coff_header.machine != IMAGE_FILE_MACHINE_I386)
return NULL; /* Wrong processor type */
if(coff_header.flags & IMAGE_FILE_RELOCS_STRIPPED)
return NULL; /* No base relocation */
if(!(coff_header.flags & IMAGE_FILE_EXECUTABLE_IMAGE))
return NULL; /* Not executable file */
if(!(coff_header.flags & IMAGE_FILE_32BIT_MACHINE))
return NULL; /* Not 32 bit machine */
if(coff_header.opt_header_size != sizeof(nt_header))
return NULL; /* Expecting NT coff file */
/*
* Read optional header
*/
READ_BLOCK(nt_header,fh);
img = BrResAllocate(NULL,sizeof(*img), BR_MEMORY_IMAGE);
img->type = BR_IMG_FRAMEWORK;
img->sections = BrResAllocate(img,
sizeof(br_image_section) * coff_header.n_sections,
BR_MEMORY_IMAGE_SECTIONS);
/*
* Check image alignment is a power of 2
*/
if((nt_header.section_alignment-1) & nt_header.section_alignment)
return NULL;
/*
* Read each section header
*/
for(i=0; i < coff_header.n_sections; i++) {
READ_BLOCK(section_header,fh);
/*
* Make copies of the parts of the header that
* are needed
*/
img->sections[i].name = BrResStrDup(img, section_header.section_name);
img->sections[i].mem_offset = section_header.rva;
img->sections[i].mem_size = section_header.virtual_size;
img->sections[i].data_size = section_header.data_size;
img->sections[i].data_offset = section_header.data_offset;
}
/*
* Allocate image arena (aligned)
*/
arena_size = nt_header.image_size;
arena_align = nt_header.section_alignment;
arena_base = BrResAllocate(img, arena_size + (arena_align-1), BR_MEMORY_IMAGE_ARENA);
arena_base = (br_uint_8 *) (((int)arena_base+arena_align-1) & (~(arena_align-1)));
/*
* Remember current offset into file
*/
offset = dos_header.new_header_offset +
sizeof(pe) +
sizeof(coff_header) +
sizeof(nt_header) +
coff_header.n_sections * sizeof(section_header);
/*
* Read each section into image arena
*/
for(i=0; i < coff_header.n_sections; i++) {
/*
* Ignore sections that have no raw data
*/
if((img->sections[i].data_offset == 0) ||
(img->sections[i].data_size == 0))
continue;
/*
* make sure we only ever go forwards in file
*/
if(offset > img->sections[i].data_offset)
return NULL; /* Section data not in order */
/*
* XXX Check that block is within arena
*/
/*
* Advance to start of section in file
*/
BrFileAdvance(img->sections[i].data_offset - offset, fh);
/*
* Record pointer to start of section
*/
img->sections[i].base = arena_base+img->sections[i].mem_offset;
/*
* Read the section into memory
*/
if((br_uint_32)BrFileRead(img->sections[i].base, 1, img->sections[i].data_size,fh)
!= img->sections[i].data_size)
return NULL;
offset = img->sections[i].data_offset + img->sections[i].data_size;
}
/*
* Close file
*/
BrFileClose(fh);
/*
* Exports
*/
if(nt_header.directories[DIRECTORY_EXPORT].size != 0) {
struct export_directory *ed;
ed = (export_directory *)(arena_base +
nt_header.directories[DIRECTORY_EXPORT].rva);
/*
* Fill in image structure with info from export directory
*/
img->identifier = (char *)(arena_base + ed->name);
img->ordinal_base = ed->ordinal_base;
img->n_functions = ed->n_entries;
img->functions = (void **)(arena_base + ed->export_table);
img->n_names = ed->n_names;
img->names = (char **)(arena_base + ed->name_table);
img->name_ordinals = (br_uint_16 *)(arena_base + ed->ordinal_table);
/*
* Relocate the tables of pointers
*/
for(n=0; n < img->n_functions; n++)
img->functions[n] = (void *)((br_uint_32)(img->functions[n]) + arena_base);
for(n=0; n < img->n_names; n++)
img->names[n] = (char *)((br_uint_32)(img->names[n]) + arena_base);
}
/*
* Imports
*/
if(nt_header.directories[DIRECTORY_IMPORT].size != 0) {
struct import_directory *id;
void **at;
br_uint_32 *lt;
br_image *import_img;
/*
* Count number of import DLLs
*/
n = 0;
for(id = (import_directory *)(arena_base +
nt_header.directories[DIRECTORY_IMPORT].rva);
id->lookup_table;
id++)
n++;
/*
* Allocate a table of pointers to imported DLL names
*/
img->imports = BrResAllocate(img, n * sizeof(*img->imports), BR_MEMORY_IMAGE_NAMES);
img->n_imports = n;
/*
* For each entry in the directory table...
*/
for(n = 0, id = (import_directory *)(arena_base +
nt_header.directories[DIRECTORY_IMPORT].rva);
id->lookup_table;
id++, n++) {
/*
* Get a handle onto referenced DLL
*/
import_img = BrImageReference((char *)(id->name + arena_base));
if(import_img == NULL) {
BR_ERROR1("Could not reference image %s",
(char *)(id->name + arena_base));
return NULL; /* could not find DLL */
}
img->imports[n] = import_img;
/*
* For each entry in lookup table
*/
at = (void **)(arena_base + id->address_table);
for(
lt = (br_uint_32 *)(arena_base + id->lookup_table);
*lt; lt++, at++) {
if(*lt & 0x80000000)
*at = BrImageLookupOrdinal(import_img, *lt & 0x7fffffff);
if(*at == NULL) {
BR_ERROR2("Could not resolve imported ordinal %s:%d",
(char *)(id->name + arena_base),*lt & 0x7fffffff);
return NULL;
}
else {
*at = BrImageLookupName(import_img, (char *)(*lt+arena_base+2),
*((br_uint_16 *)(*lt+arena_base)));
if(*at == NULL) {
BR_ERROR3("Could not resolve imported symbol %s:%s (%d)",
(char *)(id->name + arena_base),
(char *)(*lt+arena_base+2), *((br_uint_16 *)(*lt+arena_base)));
return NULL; /* Could not resolve symbol */
}
}
}
}
}
/*
* Base Relocation (only if the base needs to be moved)
*/
if(((br_uint_32)arena_base != nt_header.image_base) &&
(nt_header.directories[DIRECTORY_BASERELOC].size != 0)) {
basereloc_header *header;
br_uint_16 *entry;
br_uint_8 *fixup;
br_int_32 delta;
br_int_16 delta_h, delta_l;
offset = 0;
delta = (br_int_32)arena_base - nt_header.image_base;
delta_h = (br_uint_16)(delta >> 16);
delta_l = (br_uint_16)(delta & 0xFFFF);
/*
* Loop for each block in section
*/
while(offset < nt_header.directories[DIRECTORY_BASERELOC].size) {
header = (basereloc_header *)
(nt_header.directories[DIRECTORY_BASERELOC].rva + arena_base + offset);
offset += header->size;
/*
* Loop for each entry in block
*/
for(n=0, entry = (br_uint_16 *)(header+1);
n < (header->size - sizeof(basereloc_header)) / sizeof(br_uint_16);
n++, entry++) {
fixup = ENTRY_OFFSET(*entry) + header->rva + arena_base;
/*
* Check fixup is within arena
*/
if(fixup >= arena_base + arena_size)
return NULL; /* Fixup overrun */
/*
* Apply delta
*/
switch(ENTRY_TYPE(*entry)) {
case IMAGE_REL_BASED_ABSOLUTE:
/* Do nothing */
break;
case IMAGE_REL_BASED_HIGH:
*(br_int_16 *)fixup += delta_h;
break;
case IMAGE_REL_BASED_LOW:
*(br_int_16 *)fixup += delta_l;
break;
case IMAGE_REL_BASED_HIGHLOW:
*(br_int_32 *)fixup += delta;
break;
case IMAGE_REL_BASED_HIGHADJ:
case IMAGE_REL_BASED_MIPS_JMPADDR:
/* XXX todo */
default:
return NULL; /* Unknown fixup type */
}
}
}
}
return img;
}

63
core/fw/magicsym.asm Normal file
View File

@ -0,0 +1,63 @@
;; Copyright (c) 1992,1994-1995 Argonaut Technologies Limited. All rights reserved.
;;
;; $Id: magicsym.asm 1.1 1997/12/10 16:41:08 jon Exp $
;; $Locker: $
;;
;; Define any magic symbols generated by compilers - needed when not
;; linking against vendors runtime
;;
.486p
.model flat
ifdef __HIGHC__
.data
public _mwloc
_mwloc dd 0
endif
ifdef __WATCOMC__
ifdef __TARGET_MSC__
.data
; Pull in uSoft RTL
;
EXTRN __fltused:NEAR
; Supress Watcom RTL gubbins
;
public __8087
public __init_387_emulator
public _fltused_
__8087 dd 0
__init_387_emulator dd 0
_fltused_ dd 0
.code
PUBLIC __CHP
__CHP: push eax
fstcw [esp]
wait
push dword ptr [esp]
mov byte ptr 1[esp],01fh
fldcw [esp]
frndint
fldcw 4[esp]
wait
lea esp,8[esp]
ret
endif
endif
.code
public __PRO
public __EPI
__PRO label near
__EPI label near
ret
end

108
core/fw/makefile Normal file
View File

@ -0,0 +1,108 @@
# Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
#
# $Id: makefile 1.2 1998/11/12 13:15:14 johng Exp $
# $Locker: $
#
# Makefile for BRender Framework
#
.IMPORT: BR_SOURCE_DIR BR_MAKEFILE BR_TARGET_DIR BR_MAKE_DIR
BR_BASE_TYPE=NONE
LIB_PART:=brfw
TARGET_TYPE:=LIB
CFLAGS+=-D__BR_V1DB__=0
RES_IMAGE=fwimg
## Base library object files
##
OBJS_C=\
$(BLD_DIR)/brbegin$(OBJ_EXT)\
$(BLD_DIR)/brbhook$(OBJ_EXT)\
$(BLD_DIR)/brlists$(OBJ_EXT)\
$(BLD_DIR)/brqsort$(OBJ_EXT)\
$(BLD_DIR)/bswap$(OBJ_EXT)\
$(BLD_DIR)/datafile$(OBJ_EXT)\
$(BLD_DIR)/devlist$(OBJ_EXT)\
$(BLD_DIR)/devsetup$(OBJ_EXT)\
$(BLD_DIR)/diag$(OBJ_EXT)\
$(BLD_DIR)/error$(OBJ_EXT)\
$(BLD_DIR)/file$(OBJ_EXT)\
$(BLD_DIR)/fwsetup$(OBJ_EXT)\
$(BLD_DIR)/genfile$(OBJ_EXT)\
$(BLD_DIR)/image$(OBJ_EXT)\
$(BLD_DIR)/lexer$(OBJ_EXT)\
$(BLD_DIR)/loader$(OBJ_EXT)\
$(BLD_DIR)/mem$(OBJ_EXT)\
$(BLD_DIR)/object$(OBJ_EXT)\
$(BLD_DIR)/objectc$(OBJ_EXT)\
$(BLD_DIR)/pattern$(OBJ_EXT)\
$(BLD_DIR)/pool$(OBJ_EXT)\
$(BLD_DIR)/printf$(OBJ_EXT)\
$(BLD_DIR)/register$(OBJ_EXT)\
$(BLD_DIR)/resource$(OBJ_EXT)\
$(BLD_DIR)/resreg$(OBJ_EXT)\
$(BLD_DIR)/scratch$(OBJ_EXT)\
$(BLD_DIR)/token$(OBJ_EXT)\
$(BLD_DIR)/tokenval$(OBJ_EXT)\
$(BLD_DIR)/assocarr$(OBJ_EXT)\
$(BLD_DIR)/sys_conf$(OBJ_EXT)\
$(BLD_DIR)/devquery$(OBJ_EXT)\
OBJS_ASM=\
$(BLD_DIR)/blockops$(OBJ_EXT)\
$(BLD_DIR)/magicsym$(OBJ_EXT)\
EXPORT_INCLUDES=\
$(DDI_INC_DIR)/blockops.h\
$(DDI_INC_DIR)/brassert.h\
$(DDI_INC_DIR)/brddi.h\
$(DDI_INC_DIR)/brddi_p.h\
$(DDI_INC_DIR)/brexcept.h\
$(DDI_INC_DIR)/brhton.h\
$(DDI_INC_DIR)/brimage.h\
$(INC_DIR)/brlists.h\
$(DDI_INC_DIR)/datafile.h\
$(DDI_INC_DIR)/dataf_p.h\
$(DDI_INC_DIR)/dev_objs.cgh\
$(DDI_INC_DIR)/dev_objs.hpp\
$(DDI_INC_DIR)/formats.h\
$(DDI_INC_DIR)/lexer.h\
$(DDI_INC_DIR)/pretok.tok\
$(DDI_INC_DIR)/register.h\
$(DDI_INC_DIR)/shortcut.h\
$(DDI_INC_DIR)/timing.h\
$(DDI_INC_DIR)/tokenmap.h\
$(INC_DIR)/pretok.h\
$(INC_DIR)/brstdlib.h\
default: target
depend: pretok.c pretok.h
.INCLUDE: $(BR_MAKE_DIR)/$(BR_MAKEFILE)
"$(DDI_INC_DIR)/dev_objs.cgh": dev_objs.cgh
$(COPY_FORCE) $< $@
"$(INC_DIR)/pretok.h": pretok.h
$(COPY_FORCE) $< $@
# Build pre-defined token list
#
pretok.c toktype.c pretok.h .UPDATEALL: pretok.tok
-$(SET_WRITEABLE) pretok.h
-$(SET_WRITEABLE) pretok.c
-$(SET_WRITEABLE) toktype.c
perl $(BR_MAKE_DIR)/tokgen.pl $<
"$(DDI_INC_DIR)/pretok.tok": pretok.tok
$(COPY) $< $@
# Convert device classes into C headers
#
dev_objs.cgh: dev_objs.hpp
-$(SET_WRITEABLE) $@
+$(CPP) -D__CLASSGEN__ $< | $(PERL) $(BR_MAKE_DIR)/classgen.pl $(@:b) > $@

130
core/fw/mem.c Normal file
View File

@ -0,0 +1,130 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: mem.c 1.1 1997/12/10 16:41:08 jon Exp $
* $Locker: $
*
* Low level wrappers for allocator access
*/
#include "fw.h"
#include "brassert.h"
BR_RCS_ID("$Id: mem.c 1.1 1997/12/10 16:41:08 jon Exp $")
#define MEM_LOG 0
void * BR_RESIDENT_ENTRY BrMemAllocate(br_size_t size, br_uint_8 type)
{
void *b;
UASSERT(fw.resource_class_index[type] != NULL);
ASSERT(fw.mem->allocate != NULL);
b = fw.mem->allocate(size,type);
#if MEM_LOG
BrLogPrintf("BrMemAllocate(%d,%s) = %p\n",size,fw.resource_class_index[type]->identifier,b);
#endif
/*
* Clear block
*/
BrMemSet(b,0,size);
return b;
}
void BR_RESIDENT_ENTRY BrMemFree(void *block)
{
UASSERT(block != NULL);
#if 0
/*
* Breaks the modularity a bit - but make sure
* we are not trying to free a resource
*/
UASSERT(!BrResCheck(block,0));
#endif
#if MEM_LOG
BrLogPrintf("BrMemFree(%p)\n",block);
#endif
ASSERT(fw.mem->free != NULL);
fw.mem->free(block);
}
br_size_t BR_RESIDENT_ENTRY BrMemInquire(br_uint_8 type)
{
br_size_t i;
UASSERT(fw.resource_class_index[type] != NULL);
ASSERT(fw.mem->inquire != NULL);
i = fw.mem->inquire(type);
#if MEM_LOG
BrLogPrintf("BrMemInquire(%s) = %d\n",fw.resource_class_index[type]->identifier,i);
#endif
return i;
}
br_int_32 BR_RESIDENT_ENTRY BrMemAlign(br_uint_8 type)
{
br_int_32 i = 0;
UASSERT(fw.resource_class_index[type] != NULL);
if(fw.mem->align)
i = fw.mem->align(type);
return i;
}
/*
* calloc() equivalent
*/
void * BR_RESIDENT_ENTRY BrMemCalloc(int nelems, br_size_t size, br_uint_8 type)
{
void *b;
UASSERT(fw.resource_class_index[type] != NULL);
ASSERT(fw.mem->allocate != NULL);
b = fw.mem->allocate(size * nelems,type);
BrMemSet(b,0,size * nelems);
#if MEM_LOG
BrLogPrintf("BrMemCalloc(%d,%d,%s) = %p\n",nelems, size, fw.resource_class_index[type]->identifier ,b);
#endif
return b;
}
/*
* strdup() equivalent
*/
char * BR_RESIDENT_ENTRY BrMemStrDup(char *str)
{
int l;
char *nstr;
UASSERT(str != NULL);
l = BrStrLen(str);
#if MEM_LOG
BrLogPrintf("BrMemStrDup(%s)\n",str);
#endif
nstr = BrMemAllocate(l+1,BR_MEMORY_STRING);
BrStrCpy(nstr,str);
return nstr;
}

65
core/fw/object.c Normal file
View File

@ -0,0 +1,65 @@
/*
* Copyright (c) 1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: object.c 1.1 1997/12/10 16:41:09 jon Exp $
* $Locker: $
*
* Some generic methods for object support
*/
#include "fw.h"
#include "brassert.h"
BR_RCS_ID("$Id: object.c 1.1 1997/12/10 16:41:09 jon Exp $")
/*
* Token/Value support methods (via private templateQuery() method)
*/
br_error BR_CMETHOD_DECL(br_object,query)(br_object *self, br_uint_32 *pvalue, br_token t)
{
return BrTokenValueQuery(pvalue, NULL, 0, t, self, ObjectTemplateQuery(self));
}
br_error BR_CMETHOD_DECL(br_object,queryBuffer)
(br_object *self, br_uint_32 *pvalue, br_uint_32 *buffer, br_size_t buffer_size, br_token t)
{
return BrTokenValueQuery(pvalue, buffer, buffer_size, t, self, ObjectTemplateQuery(self));
}
br_error BR_CMETHOD_DECL(br_object,queryMany)
(br_object *self, br_token_value *tv, void *extra, br_size_t extra_size, br_int_32 *pcount)
{
return BrTokenValueQueryMany(tv, extra, extra_size, pcount, self, ObjectTemplateQuery(self));
}
br_error BR_CMETHOD_DECL(br_object,queryManySize)
(br_object *self, br_size_t *pextra_size, br_token_value *tv)
{
return BrTokenValueQueryManySize(pextra_size, tv, self, ObjectTemplateQuery(self));
}
br_error BR_CMETHOD_DECL(br_object,queryAll)
(br_object *self, br_token_value *buffer, br_size_t buffer_size)
{
return BrTokenValueQueryAll(buffer, buffer_size, self, ObjectTemplateQuery(self));
}
br_error BR_CMETHOD_DECL(br_object,queryAllSize)
(br_object *self, br_size_t *psize)
{
return BrTokenValueQueryAllSize(psize, self, ObjectTemplateQuery(self));
}
/*
* Resource destructor for BR_MEMORY_OBJECT
*/
void BR_CALLBACK _BrObjectFree(void *res, br_uint_8 res_class, br_size_t size)
{
br_object *o = res;
/*
* Assume the data is a br_object, and if a vtable is attached, call object destructor
*/
if(o && o->dispatch)
ObjectFree(o);
}

387
core/fw/objectc.c Normal file
View File

@ -0,0 +1,387 @@
/*
* Copyright (c) 1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: objectc.c 1.3 1998/07/15 18:32:32 johng Exp $
* $Locker: $
*
* Some generic methods for object container list management
*/
#include "fw.h"
#include "brassert.h"
BR_RCS_ID("$Id: objectc.c 1.3 1998/07/15 18:32:32 johng Exp $")
/*
* Parts that lists are constructed from
*/
struct object_list {
br_simple_list l;
};
struct object_list_entry {
br_simple_node n;
br_object *h;
};
/*
* Exported function to allocate the basic anchor structure
*/
void * BR_EXPORT BrObjectListAllocate(void *res)
{
struct object_list *hl;
hl = BrResAllocate(res, sizeof(struct object_list), BR_MEMORY_OBJECT_LIST);
BrSimpleNewList(&hl->l);
return hl;
}
/*
* Add a new object to the front of the list
*/
br_error BR_CMETHOD_DECL(br_object_container, addFront)(struct br_object_container *self, struct br_object *ph)
{
struct object_list *hl;
struct object_list_entry *he;
hl = ObjectContainerListQuery(self);
if(hl == NULL)
return BRE_FAIL;
/*
* Allocate a new list entry and add it to the list
*/
he = BrResAllocate(hl, sizeof(struct object_list_entry), BR_MEMORY_OBJECT_LIST_ENTRY);
if(he == NULL)
return BRE_NO_MEMORY;
he->h = ph;
BR_SIMPLEADDHEAD(&hl->l, he);
return BRE_OK;
}
/*
* Remove a particular object from the list
*/
br_error BR_CMETHOD_DECL(br_object_container, remove)(struct br_object_container *self, struct br_object *h)
{
struct object_list *hl;
struct object_list_entry *he;
hl = ObjectContainerListQuery(self);
if(hl == NULL)
return BRE_FAIL;
/*
* Find object on list
*/
BR_FOR_SIMPLELIST(&hl->l, he)
if(he->h == h)
break;
if(!(he && he->h == h))
return BRE_FAIL;
/*
* Take object off list and free anchor block
*/
BR_SIMPLEREMOVE(he);
BrResFree(he);
return BRE_OK;
}
/*
* Remove front element from list
*/
br_error BR_CMETHOD_DECL(br_object_container, removeFront)(struct br_object_container *self, struct br_object **ph)
{
struct object_list *hl;
struct object_list_entry *he;
hl = ObjectContainerListQuery(self);
if(hl == NULL)
return BRE_FAIL;
/*
* Take object of list and free it
*/
he = BR_SIMPLEREMHEAD(&hl->l);
if(he == NULL) {
*ph = NULL;
return BRE_FAIL;
}
/*
* Return object pointer to caller
*/
*ph = he->h;
BrResFree(he);
return BRE_OK;
}
/*
* Search list for tokens that:
* a) have a type (al tokens will match BR_NULL_TOKEN)
* b) have name mathing a pattern ( NULL will match all names)
* c) have properties matching a given token list (NULL will match all objects0
*
*
* How the token list is interpreted is controlled by three other methods:
*
* void * tokensMatchBegin(br_token type, br_tv_template *tv)
* Process the given token list for later matching - the void * pointer
* will me passed to the match routine.
*
* br_boolean tokensMatch(br_object *h, void * tvarg)
* See if a object matches (tvargs is void * from above)
* Returns true if object does match
*
* void tokensMatchEnd(void *tvarg)
* Perform any cleaning up.
*/
br_error BR_CMETHOD_DECL(br_object_container, find)(br_object_container *self,
br_object **ph, br_token type, char *pattern, br_token_value *tv)
{
struct object_list *hl;
struct object_list_entry *he;
void *tvarg;
br_error r = BRE_FAIL;
hl = ObjectContainerListQuery(self);
if(hl == NULL)
return BRE_FAIL;
if(tv)
tvarg = ObjectContainerTokensMatchBegin(self, type, tv);
/*
* Find first matching object in list
*/
BR_FOR_SIMPLELIST(&hl->l, he) {
if((type == BR_NULL_TOKEN || type == ObjectType(he->h)) &&
BrNamePatternMatch(pattern,ObjectIdentifier(he->h))) {
if(tv && !ObjectContainerTokensMatch(self, he->h, tvarg))
continue;
*ph = he->h;
r = BRE_OK;
}
}
if(tv)
ObjectContainerTokensMatchEnd(self, tvarg);
return r;
}
/*
* Find all objects that match above criteria (and that fit into destination buffer)
*/
br_error BR_CMETHOD_DECL(br_object_container, findMany)(br_object_container *self,
br_object **objects, br_int_32 max_objects, br_int_32 *num_objects, br_token type, char *pattern, br_token_value *tv)
{
struct object_list *hl;
struct object_list_entry *he;
void *tvarg;
int n=0;
hl = ObjectContainerListQuery(self);
if(hl == NULL)
return BRE_FAIL;
if(tv)
tvarg = ObjectContainerTokensMatchBegin(self,type,tv);
/*
* Find all matching objects in list
*/
BR_FOR_SIMPLELIST(&hl->l, he) {
/*
* If object matches, add to table
*/
if((type == BR_NULL_TOKEN || type == ObjectType(he->h)) &&
BrNamePatternMatch(pattern, ObjectIdentifier(he->h))) {
if(tv != NULL && ObjectContainerTokensMatch(self, he->h, tvarg) == BR_FALSE)
continue;
/*
* Save pointer if there is space in output table
*/
if(n < max_objects)
*objects++ = he->h;
n++;
}
}
if(tv)
ObjectContainerTokensMatchEnd(self, tvarg);
*num_objects = n;
if(n <= max_objects)
return BRE_OK;
else
return BRE_OVERFLOW;
}
/*
* Count number of matching objects
*/
br_error BR_CMETHOD_DECL(br_object_container, count)(br_object_container *self,
br_uint_32 *pcount, br_token type, char *pattern, br_token_value *tv)
{
struct object_list *hl;
struct object_list_entry *he;
void *tvarg;
int n = 0;
hl = ObjectContainerListQuery(self);
if(hl == NULL)
return BRE_FAIL;
if(tv)
tvarg = ObjectContainerTokensMatchBegin(self,type,tv);
/*
* Count all matching objects
*/
n = 0;
BR_FOR_SIMPLELIST(&hl->l, he) {
if((type == BR_NULL_TOKEN || type == ObjectType(he->h)) &&
BrNamePatternMatch(pattern,ObjectIdentifier(he->h))) {
if(tv != NULL && ObjectContainerTokensMatch(self, he->h, tvarg) == BR_FALSE)
continue;
n++;
}
}
if(tv)
ObjectContainerTokensMatchEnd(self, tvarg);
*pcount = n;
return BRE_OK;
}
/*
* Default token matching does nothing other than make all tokens match
*
* makes a copy of token/value list
*/
struct token_match {
br_token_value *original;
br_token_value *query;
br_int_32 n;
void *extra;
br_size_t extra_size;
};
void * BR_CMETHOD_DECL(br_object_container, tokensMatchBegin)
(struct br_object_container *self, br_token t, br_token_value *tv)
{
struct token_match *tm;
br_int_32 i;
if(tv == NULL)
return NULL;
tm = BrResAllocate(fw.res, sizeof(*tm), BR_MEMORY_APPLICATION);
tm->original = tv;
for(i=0; tv[i].t != BR_NULL_TOKEN; i++)
;
tm->n = i+1;
tm->query = BrResAllocate(tm, tm->n * sizeof(br_token_value), BR_MEMORY_APPLICATION);
BrMemCpy(tm->query,tv, i * sizeof(br_token_value));
return (void *) tm;
}
br_boolean BR_CMETHOD_DECL(br_object_container, tokensMatch)
(struct br_object_container *self, br_object *h, void *arg)
{
struct token_match *tm = arg;
br_size_t s;
br_int_32 n;
if(arg == NULL)
return BR_TRUE;
/*
* Make a query on the object and then compare with the original tokens
*/
ObjectQueryManySize(h, &s,tm->query);
if(s > tm->extra_size) {
if(tm->extra)
BrResFree(tm->extra);
tm->extra = BrResAllocate(tm, s, BR_MEMORY_APPLICATION);
tm->extra_size = s;
}
ObjectQueryMany(h, tm->query, tm->extra, tm->extra_size, &n);
/*
* Ensure that all tokens were found
*/
if (tm->query[n].t != BR_NULL_TOKEN)
return BR_FALSE;
/*
* Compare the two token lists
*/
return BrTokenValueCompare(tm->original, tm->query);
}
void BR_CMETHOD_DECL(br_object_container, tokensMatchEnd)
(struct br_object_container *self, void *arg)
{
if(arg)
BrResFree(arg);
}
/*
* Utility function to free all the objects in a container
*/
br_error BR_EXPORT BrObjectContainerFree(br_object_container *self, br_token type, char *pattern, br_token_value *tv)
{
br_error r;
br_object **handles;
br_int_32 count,n,i;
r = ObjectContainerCount(self, &count, type, pattern, tv);
if(r != BRE_OK)
return r;
if(count == 0)
return BRE_OK;
handles = BrMemAllocate(count * sizeof(*handles), BR_MEMORY_DRIVER);
r = ObjectContainerFindMany(self, handles, count, &n, type, pattern, tv);
for(i=0; i < n; i++) {
ObjectContainerRemove(self,handles[i]);
ObjectFree(handles[i]);
}
BrMemFree(handles);
return BRE_OK;
}

110
core/fw/pattern.c Normal file
View File

@ -0,0 +1,110 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: pattern.c 1.1 1997/12/10 16:41:09 jon Exp $
* $Locker: $
*
* Pattern matcher
*/
#include "fw.h"
#include "brassert.h"
BR_RCS_ID("$Id: pattern.c 1.1 1997/12/10 16:41:09 jon Exp $")
/*
* Compare a pattern against a string
*
* Return true if pattern matches string
*
* Patterns have the magic characters '*' and '?'
*
* '*' matches 0 or more characters
* '?' matches any single character
* '/' terminates the pattern
*
* Patterns are anchored at start and end of string
*
* Recursive approach, implemented with tail recursion -
*
* match (p,s)
*
* case first(p) in
*
* NULL - TRUE if s is empty else FALSE
*
* '*' - TRUE if match rest(q) against any substring from s to end of s
* else
* FALSE
*
* '?' - TRUE if first(s) != NULL and match(rest(p),rest(r))
*
* default - TRUE if first(p) == first(s) and match(rest(p),rest(r))
*
*/
#if 1 /* case insensitive for the moment */
#define UPPER(c) (( (c) >= 'a' && (c) <= 'z' )?((c) - ('a'-'A')):(c))
#define MATCH_CHAR(a,b) (UPPER(a) == UPPER(b))
#else
#define MATCH_CHAR(a,b) ((a) == (b))
#endif
br_boolean BR_RESIDENT_ENTRY BrNamePatternMatch(char *p, char *s)
{
char *cp;
/*
* A NULL pattern matches everything
*/
if(p == NULL)
return BR_TRUE;
/*
* A NULL string never matches
*/
if(s == NULL)
return BR_FALSE;
for(;;) switch(*p) {
case '/':
case '\0':
/*
* Empty pattern only matches empty string
*/
return *s == '\0';
case '*':
/*
* Match p+1 in any position from s to end of s
*/
cp = s;
do
if(BrNamePatternMatch(p+1,cp))
return 1;
while (*cp++);
return BR_FALSE;
case '?':
/*
* Match any character followed by matching(p+1, s+1)
*/
if(*s == '\0')
return BR_FALSE;
p++, s++; /* Tail recurse */
continue;
default:
/*
* Match this character followed by matching(p+1, s+1)
*/
if(!MATCH_CHAR(*s,*p))
return BR_FALSE;
p++, s++; /* Tail recurse */
continue;
}
}

151
core/fw/pool.c Normal file
View File

@ -0,0 +1,151 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: pool.c 1.1 1997/12/10 16:41:09 jon Exp $
* $Locker: $
*
* Memory pool allocation (fixed size objects)
*/
#include "fw.h"
#include "brassert.h"
BR_RCS_ID("$Id: pool.c 1.1 1997/12/10 16:41:09 jon Exp $")
#if BR_POOL_DEBUG
#undef PoolAllocate
#undef PoolFree
#endif
br_pool * BR_PUBLIC_ENTRY BrPoolAllocate(int block_size, int chunk_size, br_uint_8 mem_type)
{
br_pool * pool = BrResAllocate(NULL,sizeof(*pool),BR_MEMORY_POOL);
pool->free = NULL;
if(block_size < sizeof(br_pool_block))
block_size = sizeof(br_pool_block);
pool->block_size = (block_size + BR_POOL_ALIGN) & ~BR_POOL_ALIGN;
pool->chunk_size = chunk_size;
pool->mem_type = mem_type;
#if BR_POOL_DEBUG
pool->count = 0;
pool->max_count = 0;
#endif
return pool;
}
void BR_PUBLIC_ENTRY BrPoolFree(br_pool *pool)
{
UASSERT(BrResCheck(pool,1));
UASSERT(BrResClass(pool) == BR_MEMORY_POOL);
UASSERT(pool != NULL);
BrResFree(pool);
}
/*
* Goes through the child resources of the pool,
* and for each one that has a class matching the
* pool's mem_type, divides it up into blocks and
* adds them to the free list
*/
STATIC int BR_CALLBACK PoolBlockRelink(char *chunk, br_pool *pool)
{
br_uint_32 size;
br_pool_block *free_ptr;
/*
* Ignore blocks that are not of the appropriate type
*/
if(BrResClass(chunk) != (br_uint_8) pool->mem_type)
return 0;
/*
* Go through block linking it into free list
*/
free_ptr = pool->free;
for(size = BrResSize(chunk);
size >= pool->block_size;
size -= pool->block_size) {
((br_pool_block *)chunk)->next = free_ptr;
free_ptr = (br_pool_block *)chunk;
chunk += pool->block_size;
}
pool->free = free_ptr;
return 0;
}
/*
* Add another chunk of blocks to the end of the
* pool
*/
void BR_ASM_CALLBACK BrPoolAddChunk(br_pool *pool)
{
br_pool_block *bp;
/*
* Allocate a new block of the appropriate size
*/
bp = BrResAllocate(pool,pool->block_size * pool->chunk_size,
(br_uint_8)pool->mem_type);
/*
* Link the block in chunk into free list
*/
PoolBlockRelink((char *)bp, pool);
}
void * BR_PUBLIC_ENTRY BrPoolBlockAllocate(br_pool *pool)
{
br_pool_block *bp;
if(pool->free == NULL)
BrPoolAddChunk(pool);
#if BR_POOL_DEBUG
if(++pool->count > pool->max_count)
pool->max_count = pool->count;
#endif
bp = pool->free;
pool->free = bp->next;
return bp;
}
void BR_PUBLIC_ENTRY BrPoolBlockFree(br_pool *pool,void *b)
{
br_pool_block *bp = (br_pool_block *)b;
bp->next = pool->free;
pool->free = bp;
#if BR_POOL_DEBUG
pool->count--;
#endif
}
void BR_PUBLIC_ENTRY BrPoolEmpty(br_pool *pool)
{
/*
* Clear out free list
*/
pool->free = NULL;
/*
* Go through each child resource and add
* appropriate chunks to the free list
*/
BrResChildEnum(pool, (br_resenum_cbfn *)PoolBlockRelink, pool);
#if BR_POOL_DEBUG
pool->count = 0;
pool->max_count = 0;
#endif
}

524
core/fw/pretok.c Normal file
View File

@ -0,0 +1,524 @@
{ {0,}, "ABGR_1_5_5_5", BRT_NONE, BRT_ABGR_1_5_5_5, 12},
{ {0,}, "ABGR_4_4_4_4", BRT_NONE, BRT_ABGR_4_4_4_4, 12},
{ {0,}, "ABGR_8_8_8_8", BRT_NONE, BRT_ABGR_8_8_8_8, 12},
{ {0,}, "ACCEPT", BRT_NONE, BRT_ACCEPT, 6},
{ {0,}, "AINDEX_4_4", BRT_NONE, BRT_AINDEX_4_4, 10},
{ {0,}, "AINDEX_8_8", BRT_NONE, BRT_AINDEX_8_8, 10},
{ {0,}, "ALL", BRT_NONE, BRT_ALL, 3},
{ {0,}, "ALPHA", BRT_NONE, BRT_ALPHA, 5},
{ {0,}, "ALTERNATIVE_TO_DEFAULT_B", BRT_BOOLEAN, BRT_ALTERNATIVE_TO_DEFAULT_B, 22},
{ {0,}, "ALWAYS", BRT_NONE, BRT_ALWAYS, 6},
{ {0,}, "AMBIENT", BRT_NONE, BRT_AMBIENT, 7},
{ {0,}, "AMBIENT_F", BRT_FLOAT, BRT_AMBIENT_F, 7},
{ {0,}, "AMBIENT_X", BRT_FIXED, BRT_AMBIENT_X, 7},
{ {0,}, "ANGLE", BRT_NONE, BRT_ANGLE, 5},
{ {0,}, "ANGLE_CULL_B", BRT_BOOLEAN, BRT_ANGLE_CULL_B, 10},
{ {0,}, "ANGLE_INNER_A", BRT_ANGLE, BRT_ANGLE_INNER_A, 11},
{ {0,}, "ANGLE_OUTER_A", BRT_ANGLE, BRT_ANGLE_OUTER_A, 11},
{ {0,}, "ANTIALIASING_T", BRT_TOKEN, BRT_ANTIALIASING_T, 12},
{ {0,}, "ANTIALIASING_TL", BRT_TOKEN_LIST, BRT_ANTIALIASING_TL, 12},
{ {0,}, "ARGB_1_5_5_5", BRT_NONE, BRT_ARGB_1_5_5_5, 12},
{ {0,}, "ARGB_4_4_4_4", BRT_NONE, BRT_ARGB_4_4_4_4, 12},
{ {0,}, "ARGB_8_8_8_8", BRT_NONE, BRT_ARGB_8_8_8_8, 12},
{ {0,}, "ATTENUATION_C_F", BRT_FLOAT, BRT_ATTENUATION_C_F, 13},
{ {0,}, "ATTENUATION_C_X", BRT_FIXED, BRT_ATTENUATION_C_X, 13},
{ {0,}, "ATTENUATION_HINT_T", BRT_TOKEN, BRT_ATTENUATION_HINT_T, 16},
{ {0,}, "ATTENUATION_L_F", BRT_FLOAT, BRT_ATTENUATION_L_F, 13},
{ {0,}, "ATTENUATION_L_X", BRT_FIXED, BRT_ATTENUATION_L_X, 13},
{ {0,}, "ATTENUATION_Q_F", BRT_FLOAT, BRT_ATTENUATION_Q_F, 13},
{ {0,}, "ATTENUATION_Q_X", BRT_FIXED, BRT_ATTENUATION_Q_X, 13},
{ {0,}, "ATTENUATION_TYPE_T", BRT_TOKEN, BRT_ATTENUATION_TYPE_T, 16},
{ {0,}, "A_4", BRT_NONE, BRT_A_4, 3},
{ {0,}, "A_8", BRT_NONE, BRT_A_8, 3},
{ {0,}, "BEST_QUALITY", BRT_NONE, BRT_BEST_QUALITY, 12},
{ {0,}, "BEST_SPEED", BRT_NONE, BRT_BEST_SPEED, 10},
{ {0,}, "BGRA_4_4_4_4", BRT_NONE, BRT_BGRA_4_4_4_4, 12},
{ {0,}, "BGRA_8_8_8_8", BRT_NONE, BRT_BGRA_8_8_8_8, 12},
{ {0,}, "BGRX_8_8_8_8", BRT_NONE, BRT_BGRX_8_8_8_8, 12},
{ {0,}, "BGR_2_3_2", BRT_NONE, BRT_BGR_2_3_2, 9},
{ {0,}, "BGR_5_6_5", BRT_NONE, BRT_BGR_5_6_5, 9},
{ {0,}, "BGR_8_8_8", BRT_NONE, BRT_BGR_8_8_8, 9},
{ {0,}, "BLENDED", BRT_NONE, BRT_BLENDED, 7},
{ {0,}, "BLENDER_PROGRAM_P", BRT_POINTER, BRT_BLENDER_PROGRAM_P, 15},
{ {0,}, "BLEND_B", BRT_BOOLEAN, BRT_BLEND_B, 5},
{ {0,}, "BLEND_CONSTANT", BRT_NONE, BRT_BLEND_CONSTANT, 14},
{ {0,}, "BLEND_DIMMED", BRT_NONE, BRT_BLEND_DIMMED, 12},
{ {0,}, "BLEND_MODE_T", BRT_TOKEN, BRT_BLEND_MODE_T, 10},
{ {0,}, "BLEND_MODE_TL", BRT_TOKEN_LIST, BRT_BLEND_MODE_TL, 10},
{ {0,}, "BLEND_PREMULTIPLIED", BRT_NONE, BRT_BLEND_PREMULTIPLIED, 19},
{ {0,}, "BLEND_STANDARD", BRT_NONE, BRT_BLEND_STANDARD, 14},
{ {0,}, "BLEND_SUMMED", BRT_NONE, BRT_BLEND_SUMMED, 12},
{ {0,}, "BLUE", BRT_NONE, BRT_BLUE, 4},
{ {0,}, "BOOLEAN", BRT_NONE, BRT_BOOLEAN, 7},
{ {0,}, "BOTTOM_TOP", BRT_NONE, BRT_BOTTOM_TOP, 10},
{ {0,}, "BOUNDS", BRT_NONE, BRT_BOUNDS, 6},
{ {0,}, "BOUNDS_B", BRT_BOOLEAN, BRT_BOUNDS_B, 6},
{ {0,}, "BRENDER_DEVELOPER_B", BRT_BOOLEAN, BRT_BRENDER_DEVELOPER_B, 17},
{ {0,}, "BRENDER_DEVICES_STR", BRT_STRING, BRT_BRENDER_DEVICES_STR, 15},
{ {0,}, "BRENDER_DRIVERS_STR", BRT_STRING, BRT_BRENDER_DRIVERS_STR, 15},
{ {0,}, "BRENDER_PATH_STR", BRT_STRING, BRT_BRENDER_PATH_STR, 12},
{ {0,}, "BRENDER_USE_CMOV_B", BRT_BOOLEAN, BRT_BRENDER_USE_CMOV_B, 16},
{ {0,}, "BRENDER_USE_MMX_B", BRT_BOOLEAN, BRT_BRENDER_USE_MMX_B, 15},
{ {0,}, "BRENDER_VERSION_U32", BRT_UINT_32, BRT_BRENDER_VERSION_U32, 15},
{ {0,}, "BUCKET_SORT", BRT_NONE, BRT_BUCKET_SORT, 11},
{ {0,}, "BUFFER", BRT_NONE, BRT_BUFFER, 6},
{ {0,}, "BUFFER_STORED", BRT_NONE, BRT_BUFFER_STORED, 13},
{ {0,}, "BUMP_O", BRT_OBJECT, BRT_BUMP_O, 4},
{ {0,}, "BUMP_TVL", BRT_TOKEN_VALUE_LIST, BRT_BUMP_TVL, 4},
{ {0,}, "CACHED_B", BRT_BOOLEAN, BRT_CACHED_B, 6},
{ {0,}, "CACHED_SIZE_U32", BRT_UINT_32, BRT_CACHED_SIZE_U32, 11},
{ {0,}, "CACHED_TOTAL_U32", BRT_UINT_32, BRT_CACHED_TOTAL_U32, 12},
{ {0,}, "CAN_SHARE_B", BRT_BOOLEAN, BRT_CAN_SHARE_B, 9},
{ {0,}, "CLAMP", BRT_NONE, BRT_CLAMP, 5},
{ {0,}, "CLIP", BRT_NONE, BRT_CLIP, 4},
{ {0,}, "CLIPPING_B", BRT_BOOLEAN, BRT_CLIPPING_B, 8},
{ {0,}, "CLIP_MAX_I32", BRT_INT_32, BRT_CLIP_MAX_I32, 8},
{ {0,}, "CLONE", BRT_NONE, BRT_CLONE, 5},
{ {0,}, "CLUT_MAX_I32", BRT_INT_32, BRT_CLUT_MAX_I32, 8},
{ {0,}, "CLUT_O", BRT_OBJECT, BRT_CLUT_O, 4},
{ {0,}, "COLOUR_B", BRT_BOOLEAN, BRT_COLOUR_B, 6},
{ {0,}, "COLOUR_BUFFER_O", BRT_OBJECT, BRT_COLOUR_BUFFER_O, 13},
{ {0,}, "COLOUR_I32", BRT_INT_32, BRT_COLOUR_I32, 6},
{ {0,}, "COLOUR_KEY_B", BRT_BOOLEAN, BRT_COLOUR_KEY_B, 10},
{ {0,}, "COLOUR_MAP_1_O", BRT_OBJECT, BRT_COLOUR_MAP_1_O, 12},
{ {0,}, "COLOUR_MAP_O", BRT_OBJECT, BRT_COLOUR_MAP_O, 10},
{ {0,}, "COLOUR_MAP_TVL", BRT_TOKEN_VALUE_LIST, BRT_COLOUR_MAP_TVL, 10},
{ {0,}, "COLOUR_RGB", BRT_NONE, BRT_COLOUR_RGB, 10},
{ {0,}, "COLOUR_SOURCE_T", BRT_TOKEN, BRT_COLOUR_SOURCE_T, 13},
{ {0,}, "COLOUR_T", BRT_TOKEN, BRT_COLOUR_T, 6},
{ {0,}, "COLOUR_TL", BRT_TOKEN_LIST, BRT_COLOUR_TL, 6},
{ {0,}, "COLOUR_WRITE_B", BRT_BOOLEAN, BRT_COLOUR_WRITE_B, 12},
{ {0,}, "COMPOSITING", BRT_NONE, BRT_COMPOSITING, 11},
{ {0,}, "COMPOSITING_WITH_INCREASE", BRT_NONE, BRT_COMPOSITING_WITH_INCREASE, 25},
{ {0,}, "COMPOSITING_WITH_REDUCTION", BRT_NONE, BRT_COMPOSITING_WITH_REDUCTION, 26},
{ {0,}, "CONSTANT", BRT_NONE, BRT_CONSTANT, 8},
{ {0,}, "CONSTANT_STRING", BRT_NONE, BRT_CONSTANT_STRING, 15},
{ {0,}, "COPY_BITS_F", BRT_FLOAT, BRT_COPY_BITS_F, 9},
{ {0,}, "COPY_BITS_X", BRT_FIXED, BRT_COPY_BITS_X, 9},
{ {0,}, "COPY_DESTINATION_TVL", BRT_TOKEN_VALUE_LIST, BRT_COPY_DESTINATION_TVL, 16},
{ {0,}, "COPY_F", BRT_FLOAT, BRT_COPY_F, 4},
{ {0,}, "COPY_SOURCE_TVL", BRT_TOKEN_VALUE_LIST, BRT_COPY_SOURCE_TVL, 11},
{ {0,}, "COPY_X", BRT_FIXED, BRT_COPY_X, 4},
{ {0,}, "CREATOR_CSTR", BRT_CONSTANT_STRING, BRT_CREATOR_CSTR, 7},
{ {0,}, "CULL", BRT_NONE, BRT_CULL, 4},
{ {0,}, "CULLED_B", BRT_BOOLEAN, BRT_CULLED_B, 6},
{ {0,}, "CULL_B", BRT_BOOLEAN, BRT_CULL_B, 4},
{ {0,}, "DDI_VERSION_U32", BRT_UINT_32, BRT_DDI_VERSION_U32, 11},
{ {0,}, "DECAL_B", BRT_BOOLEAN, BRT_DECAL_B, 5},
{ {0,}, "DEFAULT", BRT_NONE, BRT_DEFAULT, 7},
{ {0,}, "DEFAULT_BASE_I32", BRT_INT_32, BRT_DEFAULT_BASE_I32, 12},
{ {0,}, "DEFAULT_DEVICE_STR", BRT_STRING, BRT_DEFAULT_DEVICE_STR, 14},
{ {0,}, "DEFAULT_RANGE_I32", BRT_INT_32, BRT_DEFAULT_RANGE_I32, 13},
{ {0,}, "DEPTH", BRT_NONE, BRT_DEPTH, 5},
{ {0,}, "DEPTH_15", BRT_NONE, BRT_DEPTH_15, 8},
{ {0,}, "DEPTH_31", BRT_NONE, BRT_DEPTH_31, 8},
{ {0,}, "DEPTH_BIAS_F", BRT_FLOAT, BRT_DEPTH_BIAS_F, 10},
{ {0,}, "DEPTH_BIAS_X", BRT_FIXED, BRT_DEPTH_BIAS_X, 10},
{ {0,}, "DEPTH_BUFFER_O", BRT_OBJECT, BRT_DEPTH_BUFFER_O, 12},
{ {0,}, "DEPTH_FP15", BRT_NONE, BRT_DEPTH_FP15, 10},
{ {0,}, "DEPTH_FP16", BRT_NONE, BRT_DEPTH_FP16, 10},
{ {0,}, "DEPTH_TEST_T", BRT_TOKEN, BRT_DEPTH_TEST_T, 10},
{ {0,}, "DEPTH_TEST_TL", BRT_TOKEN_LIST, BRT_DEPTH_TEST_TL, 10},
{ {0,}, "DEPTH_WRITE_B", BRT_BOOLEAN, BRT_DEPTH_WRITE_B, 11},
{ {0,}, "DESTINATION_O", BRT_OBJECT, BRT_DESTINATION_O, 11},
{ {0,}, "DEVICE", BRT_NONE, BRT_DEVICE, 6},
{ {0,}, "DEVICE_CLUT", BRT_NONE, BRT_DEVICE_CLUT, 11},
{ {0,}, "DEVICE_PIXELMAP", BRT_NONE, BRT_DEVICE_PIXELMAP, 15},
{ {0,}, "DIBSECTION", BRT_NONE, BRT_DIBSECTION, 10},
{ {0,}, "DIFFUSE_F", BRT_FLOAT, BRT_DIFFUSE_F, 7},
{ {0,}, "DIFFUSE_X", BRT_FIXED, BRT_DIFFUSE_X, 7},
{ {0,}, "DIRECT", BRT_NONE, BRT_DIRECT, 6},
{ {0,}, "DIRECT3D_HAL", BRT_NONE, BRT_DIRECT3D_HAL, 12},
{ {0,}, "DIRECT3D_RAMP", BRT_NONE, BRT_DIRECT3D_RAMP, 13},
{ {0,}, "DIRECT3D_RENDER_METHOD_T", BRT_TOKEN, BRT_DIRECT3D_RENDER_METHOD_T, 22},
{ {0,}, "DIRECT3D_RGB", BRT_NONE, BRT_DIRECT3D_RGB, 12},
{ {0,}, "DIRECTDRAW", BRT_NONE, BRT_DIRECTDRAW, 10},
{ {0,}, "DIRECTDRAW_DEVICENAME_CSTR", BRT_CONSTANT_STRING, BRT_DIRECTDRAW_DEVICENAME_CSTR, 21},
{ {0,}, "DIRECTION_V3_F", BRT_VECTOR3_FLOAT, BRT_DIRECTION_V3_F, 9},
{ {0,}, "DIRECTION_V3_X", BRT_VECTOR3_FIXED, BRT_DIRECTION_V3_X, 9},
{ {0,}, "DIRECT_F", BRT_FLOAT, BRT_DIRECT_F, 6},
{ {0,}, "DIRECT_X", BRT_FIXED, BRT_DIRECT_X, 6},
{ {0,}, "DITHER", BRT_NONE, BRT_DITHER, 6},
{ {0,}, "DITHER_B", BRT_BOOLEAN, BRT_DITHER_B, 6},
{ {0,}, "DITHER_COLOUR_B", BRT_BOOLEAN, BRT_DITHER_COLOUR_B, 13},
{ {0,}, "DITHER_COLOUR_T", BRT_TOKEN, BRT_DITHER_COLOUR_T, 13},
{ {0,}, "DITHER_COLOUR_TL", BRT_TOKEN_LIST, BRT_DITHER_COLOUR_TL, 13},
{ {0,}, "DITHER_MAP_B", BRT_BOOLEAN, BRT_DITHER_MAP_B, 10},
{ {0,}, "DITHER_MAP_T", BRT_TOKEN, BRT_DITHER_MAP_T, 10},
{ {0,}, "DITHER_MAP_TL", BRT_TOKEN_LIST, BRT_DITHER_MAP_TL, 10},
{ {0,}, "DIVERT_T", BRT_TOKEN, BRT_DIVERT_T, 6},
{ {0,}, "DONT_CARE", BRT_NONE, BRT_DONT_CARE, 9},
{ {0,}, "DOUBLE_TEXTURE_B", BRT_BOOLEAN, BRT_DOUBLE_TEXTURE_B, 14},
{ {0,}, "D_15", BRT_NONE, BRT_D_15, 4},
{ {0,}, "D_16", BRT_NONE, BRT_D_16, 4},
{ {0,}, "D_24", BRT_NONE, BRT_D_24, 4},
{ {0,}, "D_31", BRT_NONE, BRT_D_31, 4},
{ {0,}, "D_32", BRT_NONE, BRT_D_32, 4},
{ {0,}, "D_FP15", BRT_NONE, BRT_D_FP15, 6},
{ {0,}, "D_FP16", BRT_NONE, BRT_D_FP16, 6},
{ {0,}, "ENABLE", BRT_NONE, BRT_ENABLE, 6},
{ {0,}, "ENVIRONMENT_INFINITE", BRT_NONE, BRT_ENVIRONMENT_INFINITE, 20},
{ {0,}, "ENVIRONMENT_LOCAL", BRT_NONE, BRT_ENVIRONMENT_LOCAL, 17},
{ {0,}, "EQUAL", BRT_NONE, BRT_EQUAL, 5},
{ {0,}, "EVEN_ODD", BRT_NONE, BRT_EVEN_ODD, 8},
{ {0,}, "FACILITY", BRT_NONE, BRT_FACILITY, 8},
{ {0,}, "FACILITY_O", BRT_OBJECT, BRT_FACILITY_O, 8},
{ {0,}, "FIXED", BRT_NONE, BRT_FIXED, 5},
{ {0,}, "FLOAT", BRT_NONE, BRT_FLOAT, 5},
{ {0,}, "FOG_B", BRT_BOOLEAN, BRT_FOG_B, 3},
{ {0,}, "FOG_MAX_F", BRT_FLOAT, BRT_FOG_MAX_F, 7},
{ {0,}, "FOG_MAX_X", BRT_FIXED, BRT_FOG_MAX_X, 7},
{ {0,}, "FOG_MIN_F", BRT_FLOAT, BRT_FOG_MIN_F, 7},
{ {0,}, "FOG_MIN_X", BRT_FIXED, BRT_FOG_MIN_X, 7},
{ {0,}, "FOG_RGB", BRT_COLOUR_RGB, BRT_FOG_RGB, 3},
{ {0,}, "FOG_SCALE_U8", BRT_UINT_8, BRT_FOG_SCALE_U8, 9},
{ {0,}, "FOG_T", BRT_TOKEN, BRT_FOG_T, 3},
{ {0,}, "FOG_TL", BRT_TOKEN_LIST, BRT_FOG_TL, 3},
{ {0,}, "FONT_NORMAL_O", BRT_OBJECT, BRT_FONT_NORMAL_O, 11},
{ {0,}, "FONT_NORMAL_P", BRT_POINTER, BRT_FONT_NORMAL_P, 11},
{ {0,}, "FORCE_BACK_B", BRT_BOOLEAN, BRT_FORCE_BACK_B, 10},
{ {0,}, "FORCE_FRONT_B", BRT_BOOLEAN, BRT_FORCE_FRONT_B, 11},
{ {0,}, "FORMAT_T", BRT_TOKEN, BRT_FORMAT_T, 6},
{ {0,}, "GEOMETRY", BRT_NONE, BRT_GEOMETRY, 8},
{ {0,}, "GEOMETRY_LIGHTING", BRT_NONE, BRT_GEOMETRY_LIGHTING, 17},
{ {0,}, "GEOMETRY_MAP", BRT_NONE, BRT_GEOMETRY_MAP, 12},
{ {0,}, "GEOMETRY_PRIMITIVES", BRT_NONE, BRT_GEOMETRY_PRIMITIVES, 19},
{ {0,}, "GEOMETRY_STORED", BRT_NONE, BRT_GEOMETRY_STORED, 15},
{ {0,}, "GEOMETRY_V1_BUCKETS", BRT_NONE, BRT_GEOMETRY_V1_BUCKETS, 19},
{ {0,}, "GEOMETRY_V1_MODEL", BRT_NONE, BRT_GEOMETRY_V1_MODEL, 17},
{ {0,}, "GEOMETRY_X", BRT_NONE, BRT_GEOMETRY_X, 10},
{ {0,}, "GEOMETRY_Y", BRT_NONE, BRT_GEOMETRY_Y, 10},
{ {0,}, "GEOMETRY_Z", BRT_NONE, BRT_GEOMETRY_Z, 10},
{ {0,}, "GREATER", BRT_NONE, BRT_GREATER, 7},
{ {0,}, "GREATER_OR_EQUAL", BRT_NONE, BRT_GREATER_OR_EQUAL, 16},
{ {0,}, "GREEN", BRT_NONE, BRT_GREEN, 5},
{ {0,}, "HANDLE", BRT_NONE, BRT_HANDLE, 6},
{ {0,}, "HEIGHT_I32", BRT_INT_32, BRT_HEIGHT_I32, 6},
{ {0,}, "HEIGHT_MAX_I32", BRT_INT_32, BRT_HEIGHT_MAX_I32, 10},
{ {0,}, "HEIGHT_MIN_I32", BRT_INT_32, BRT_HEIGHT_MIN_I32, 10},
{ {0,}, "HEIGHT_OPTIMUM_I32", BRT_INT_32, BRT_HEIGHT_OPTIMUM_I32, 14},
{ {0,}, "HEIGHT_T", BRT_TOKEN, BRT_HEIGHT_T, 6},
{ {0,}, "HEIGHT_TL", BRT_TOKEN_LIST, BRT_HEIGHT_TL, 6},
{ {0,}, "HIDDEN", BRT_NONE, BRT_HIDDEN, 6},
{ {0,}, "HIDDEN_BUFFER", BRT_NONE, BRT_HIDDEN_BUFFER, 13},
{ {0,}, "HIDDEN_SURFACE", BRT_NONE, BRT_HIDDEN_SURFACE, 14},
{ {0,}, "HITHER_Z_F", BRT_FLOAT, BRT_HITHER_Z_F, 8},
{ {0,}, "HITHER_Z_X", BRT_FIXED, BRT_HITHER_Z_X, 8},
{ {0,}, "HOST_MEMORY_U32", BRT_UINT_32, BRT_HOST_MEMORY_U32, 11},
{ {0,}, "IDENTIFIER_CSTR", BRT_CONSTANT_STRING, BRT_IDENTIFIER_CSTR, 10},
{ {0,}, "INDEX", BRT_NONE, BRT_INDEX, 5},
{ {0,}, "INDEXA_4_4", BRT_NONE, BRT_INDEXA_4_4, 10},
{ {0,}, "INDEXA_8_8", BRT_NONE, BRT_INDEXA_8_8, 10},
{ {0,}, "INDEXED_B", BRT_BOOLEAN, BRT_INDEXED_B, 7},
{ {0,}, "INDEX_1", BRT_NONE, BRT_INDEX_1, 7},
{ {0,}, "INDEX_2", BRT_NONE, BRT_INDEX_2, 7},
{ {0,}, "INDEX_4", BRT_NONE, BRT_INDEX_4, 7},
{ {0,}, "INDEX_8", BRT_NONE, BRT_INDEX_8, 7},
{ {0,}, "INDEX_BASE_I32", BRT_INT_32, BRT_INDEX_BASE_I32, 10},
{ {0,}, "INDEX_BLEND_O", BRT_OBJECT, BRT_INDEX_BLEND_O, 11},
{ {0,}, "INDEX_BLEND_TVL", BRT_TOKEN_VALUE_LIST, BRT_INDEX_BLEND_TVL, 11},
{ {0,}, "INDEX_FOG_O", BRT_OBJECT, BRT_INDEX_FOG_O, 9},
{ {0,}, "INDEX_FOG_TVL", BRT_TOKEN_VALUE_LIST, BRT_INDEX_FOG_TVL, 9},
{ {0,}, "INDEX_LIGHT_O", BRT_OBJECT, BRT_INDEX_LIGHT_O, 11},
{ {0,}, "INDEX_LIGHT_TVL", BRT_TOKEN_VALUE_LIST, BRT_INDEX_LIGHT_TVL, 11},
{ {0,}, "INDEX_RANGE_I32", BRT_INT_32, BRT_INDEX_RANGE_I32, 11},
{ {0,}, "INDEX_SHADE_O", BRT_OBJECT, BRT_INDEX_SHADE_O, 11},
{ {0,}, "INDEX_SHADE_TVL", BRT_TOKEN_VALUE_LIST, BRT_INDEX_SHADE_TVL, 11},
{ {0,}, "INI_STR", BRT_STRING, BRT_INI_STR, 3},
{ {0,}, "INTEL", BRT_NONE, BRT_INTEL, 5},
{ {0,}, "INTEL_386", BRT_NONE, BRT_INTEL_386, 9},
{ {0,}, "INTEL_486", BRT_NONE, BRT_INTEL_486, 9},
{ {0,}, "INTEL_PENTIUM", BRT_NONE, BRT_INTEL_PENTIUM, 13},
{ {0,}, "INTEL_PENTIUM_PRO", BRT_NONE, BRT_INTEL_PENTIUM_PRO, 17},
{ {0,}, "INTENSITY_REDUCTION", BRT_NONE, BRT_INTENSITY_REDUCTION, 19},
{ {0,}, "INTERLACE_B", BRT_BOOLEAN, BRT_INTERLACE_B, 9},
{ {0,}, "INT_16", BRT_NONE, BRT_INT_16, 6},
{ {0,}, "INT_32", BRT_NONE, BRT_INT_32, 6},
{ {0,}, "INT_8", BRT_NONE, BRT_INT_8, 5},
{ {0,}, "KEY_IS_TRANSPARENT", BRT_NONE, BRT_KEY_IS_TRANSPARENT, 18},
{ {0,}, "LEFT_RIGHT", BRT_NONE, BRT_LEFT_RIGHT, 10},
{ {0,}, "LENGTH_PRESERVING", BRT_NONE, BRT_LENGTH_PRESERVING, 17},
{ {0,}, "LESS", BRT_NONE, BRT_LESS, 4},
{ {0,}, "LESS_OR_EQUAL", BRT_NONE, BRT_LESS_OR_EQUAL, 13},
{ {0,}, "LIGHT", BRT_NONE, BRT_LIGHT, 5},
{ {0,}, "LIGHTING_B", BRT_BOOLEAN, BRT_LIGHTING_B, 8},
{ {0,}, "LIGHTING_VOLUME_P", BRT_POINTER, BRT_LIGHTING_VOLUME_P, 15},
{ {0,}, "LIGHT_MAX_I32", BRT_INT_32, BRT_LIGHT_MAX_I32, 9},
{ {0,}, "LIGHT_VERTICES", BRT_NONE, BRT_LIGHT_VERTICES, 14},
{ {0,}, "LINE", BRT_NONE, BRT_LINE, 4},
{ {0,}, "LINEAR", BRT_NONE, BRT_LINEAR, 6},
{ {0,}, "LPDIRECTDRAWSURFACE_P", BRT_POINTER, BRT_LPDIRECTDRAWSURFACE_P, 19},
{ {0,}, "MAPPING_SOURCE_T", BRT_TOKEN, BRT_MAPPING_SOURCE_T, 14},
{ {0,}, "MAP_ANTIALIASING_T", BRT_TOKEN, BRT_MAP_ANTIALIASING_T, 16},
{ {0,}, "MAP_ANTIALIASING_TL", BRT_TOKEN_LIST, BRT_MAP_ANTIALIASING_TL, 16},
{ {0,}, "MAP_HEIGHT_LIMIT_1_T", BRT_TOKEN, BRT_MAP_HEIGHT_LIMIT_1_T, 18},
{ {0,}, "MAP_HEIGHT_LIMIT_T", BRT_TOKEN, BRT_MAP_HEIGHT_LIMIT_T, 16},
{ {0,}, "MAP_HEIGHT_LIMIT_TL", BRT_TOKEN_LIST, BRT_MAP_HEIGHT_LIMIT_TL, 16},
{ {0,}, "MAP_INTERPOLATION_MAG_T", BRT_TOKEN, BRT_MAP_INTERPOLATION_MAG_T, 21},
{ {0,}, "MAP_INTERPOLATION_MAG_TL", BRT_TOKEN_LIST, BRT_MAP_INTERPOLATION_MAG_TL, 21},
{ {0,}, "MAP_INTERPOLATION_MIN_T", BRT_TOKEN, BRT_MAP_INTERPOLATION_MIN_T, 21},
{ {0,}, "MAP_INTERPOLATION_MIN_TL", BRT_TOKEN_LIST, BRT_MAP_INTERPOLATION_MIN_TL, 21},
{ {0,}, "MAP_INTERPOLATION_T", BRT_TOKEN, BRT_MAP_INTERPOLATION_T, 17},
{ {0,}, "MAP_INTERPOLATION_TL", BRT_TOKEN_LIST, BRT_MAP_INTERPOLATION_TL, 17},
{ {0,}, "MAP_MATRIX_M23_F", BRT_MATRIX23_FLOAT, BRT_MAP_MATRIX_M23_F, 10},
{ {0,}, "MAP_MATRIX_M23_X", BRT_MATRIX23_FIXED, BRT_MAP_MATRIX_M23_X, 10},
{ {0,}, "MAP_WIDTH_LIMIT_1_T", BRT_TOKEN, BRT_MAP_WIDTH_LIMIT_1_T, 17},
{ {0,}, "MAP_WIDTH_LIMIT_T", BRT_TOKEN, BRT_MAP_WIDTH_LIMIT_T, 15},
{ {0,}, "MAP_WIDTH_LIMIT_TL", BRT_TOKEN_LIST, BRT_MAP_WIDTH_LIMIT_TL, 15},
{ {0,}, "MATCH_TVL", BRT_TOKEN_VALUE_LIST, BRT_MATCH_TVL, 5},
{ {0,}, "MATRIX", BRT_NONE, BRT_MATRIX, 6},
{ {0,}, "MATRIX23_FIXED", BRT_NONE, BRT_MATRIX23_FIXED, 14},
{ {0,}, "MATRIX23_FLOAT", BRT_NONE, BRT_MATRIX23_FLOAT, 14},
{ {0,}, "MATRIX34_FIXED", BRT_NONE, BRT_MATRIX34_FIXED, 14},
{ {0,}, "MATRIX34_FLOAT", BRT_NONE, BRT_MATRIX34_FLOAT, 14},
{ {0,}, "MATRIX4_FIXED", BRT_NONE, BRT_MATRIX4_FIXED, 13},
{ {0,}, "MATRIX4_FLOAT", BRT_NONE, BRT_MATRIX4_FLOAT, 13},
{ {0,}, "MAX_V2_F", BRT_VECTOR2_FLOAT, BRT_MAX_V2_F, 3},
{ {0,}, "MAX_V2_I", BRT_VECTOR2_INTEGER, BRT_MAX_V2_I, 3},
{ {0,}, "MAX_V2_X", BRT_VECTOR2_FIXED, BRT_MAX_V2_X, 3},
{ {0,}, "MEMORY_MAPPED_B", BRT_BOOLEAN, BRT_MEMORY_MAPPED_B, 13},
{ {0,}, "MIN_V2_F", BRT_VECTOR2_FLOAT, BRT_MIN_V2_F, 3},
{ {0,}, "MIN_V2_I", BRT_VECTOR2_INTEGER, BRT_MIN_V2_I, 3},
{ {0,}, "MIN_V2_X", BRT_VECTOR2_FIXED, BRT_MIN_V2_X, 3},
{ {0,}, "MIP", BRT_NONE, BRT_MIP, 3},
{ {0,}, "MIPS", BRT_NONE, BRT_MIPS, 4},
{ {0,}, "MIP_INTERPOLATION_T", BRT_TOKEN, BRT_MIP_INTERPOLATION_T, 17},
{ {0,}, "MIP_INTERPOLATION_TL", BRT_TOKEN_LIST, BRT_MIP_INTERPOLATION_TL, 17},
{ {0,}, "MIP_MAX_U8", BRT_UINT_8, BRT_MIP_MAX_U8, 7},
{ {0,}, "MIP_MIN_U8", BRT_UINT_8, BRT_MIP_MIN_U8, 7},
{ {0,}, "MIP_MODIFIER_I8", BRT_INT_8, BRT_MIP_MODIFIER_I8, 12},
{ {0,}, "MIP_MOD_ABSOLUTE_B", BRT_BOOLEAN, BRT_MIP_MOD_ABSOLUTE_B, 16},
{ {0,}, "MIP_PER_PIXEL", BRT_NONE, BRT_MIP_PER_PIXEL, 13},
{ {0,}, "MIP_PER_PRIMITIVE", BRT_NONE, BRT_MIP_PER_PRIMITIVE, 17},
{ {0,}, "MIRROR", BRT_NONE, BRT_MIRROR, 6},
{ {0,}, "MODEL", BRT_NONE, BRT_MODEL, 5},
{ {0,}, "MODEL_TO_SCREEN_M4_F", BRT_MATRIX4_FLOAT, BRT_MODEL_TO_SCREEN_M4_F, 15},
{ {0,}, "MODEL_TO_SCREEN_M4_X", BRT_MATRIX4_FIXED, BRT_MODEL_TO_SCREEN_M4_X, 15},
{ {0,}, "MODEL_TO_VIEW_HINT_T", BRT_TOKEN, BRT_MODEL_TO_VIEW_HINT_T, 18},
{ {0,}, "MODEL_TO_VIEW_M34_F", BRT_MATRIX34_FLOAT, BRT_MODEL_TO_VIEW_M34_F, 13},
{ {0,}, "MODEL_TO_VIEW_M34_X", BRT_MATRIX34_FIXED, BRT_MODEL_TO_VIEW_M34_X, 13},
{ {0,}, "MODE_U32", BRT_UINT_32, BRT_MODE_U32, 4},
{ {0,}, "MODULATE_ALPHA_B", BRT_BOOLEAN, BRT_MODULATE_ALPHA_B, 14},
{ {0,}, "MODULATE_B", BRT_BOOLEAN, BRT_MODULATE_B, 8},
{ {0,}, "MOTOROLA", BRT_NONE, BRT_MOTOROLA, 8},
{ {0,}, "NEAREST", BRT_NONE, BRT_NEAREST, 7},
{ {0,}, "NEVER", BRT_NONE, BRT_NEVER, 5},
{ {0,}, "NONE", BRT_NONE, BRT_NONE, 4},
{ {0,}, "NOT_EQUAL", BRT_NONE, BRT_NOT_EQUAL, 9},
{ {0,}, "NO_RENDER", BRT_NONE, BRT_NO_RENDER, 9},
{ {0,}, "OBJECT", BRT_NONE, BRT_OBJECT, 6},
{ {0,}, "OBJECT_CONTAINER", BRT_NONE, BRT_OBJECT_CONTAINER, 16},
{ {0,}, "OBJECT_LIST", BRT_NONE, BRT_OBJECT_LIST, 11},
{ {0,}, "ODD_EVEN", BRT_NONE, BRT_ODD_EVEN, 8},
{ {0,}, "OFFSCREEN", BRT_NONE, BRT_OFFSCREEN, 9},
{ {0,}, "ONE_SIDED", BRT_NONE, BRT_ONE_SIDED, 9},
{ {0,}, "OPACITY_F", BRT_FLOAT, BRT_OPACITY_F, 7},
{ {0,}, "OPACITY_SOURCE_T", BRT_TOKEN, BRT_OPACITY_SOURCE_T, 14},
{ {0,}, "OPACITY_X", BRT_FIXED, BRT_OPACITY_X, 7},
{ {0,}, "ORIGIN_V2_I", BRT_VECTOR2_INTEGER, BRT_ORIGIN_V2_I, 6},
{ {0,}, "OUTPUT", BRT_NONE, BRT_OUTPUT, 6},
{ {0,}, "OUTPUT_FACILITY", BRT_NONE, BRT_OUTPUT_FACILITY, 15},
{ {0,}, "OUTPUT_FACILITY_O", BRT_OBJECT, BRT_OUTPUT_FACILITY_O, 15},
{ {0,}, "PARALLEL", BRT_NONE, BRT_PARALLEL, 8},
{ {0,}, "PARTIAL", BRT_NONE, BRT_PARTIAL, 7},
{ {0,}, "PARTS_TL", BRT_TOKEN_LIST, BRT_PARTS_TL, 5},
{ {0,}, "PARTS_U32", BRT_UINT_32, BRT_PARTS_U32, 5},
{ {0,}, "PERSPECTIVE", BRT_NONE, BRT_PERSPECTIVE, 11},
{ {0,}, "PERSPECTIVE_B", BRT_BOOLEAN, BRT_PERSPECTIVE_B, 11},
{ {0,}, "PERSPECTIVE_T", BRT_TOKEN, BRT_PERSPECTIVE_T, 11},
{ {0,}, "PERSPECTIVE_TL", BRT_TOKEN_LIST, BRT_PERSPECTIVE_TL, 11},
{ {0,}, "PIXELMAP_MAX_I32", BRT_INT_32, BRT_PIXELMAP_MAX_I32, 12},
{ {0,}, "PIXEL_BITS_I32", BRT_INT_32, BRT_PIXEL_BITS_I32, 10},
{ {0,}, "PIXEL_CHANNELS_I32", BRT_INT_32, BRT_PIXEL_CHANNELS_I32, 14},
{ {0,}, "PIXEL_CHANNELS_TL", BRT_TOKEN_LIST, BRT_PIXEL_CHANNELS_TL, 14},
{ {0,}, "PIXEL_GET_F", BRT_FLOAT, BRT_PIXEL_GET_F, 9},
{ {0,}, "PIXEL_GET_X", BRT_FIXED, BRT_PIXEL_GET_X, 9},
{ {0,}, "PIXEL_SET_F", BRT_FLOAT, BRT_PIXEL_SET_F, 9},
{ {0,}, "PIXEL_SET_X", BRT_FIXED, BRT_PIXEL_SET_X, 9},
{ {0,}, "PIXEL_TYPE_U8", BRT_UINT_8, BRT_PIXEL_TYPE_U8, 10},
{ {0,}, "PLANE", BRT_NONE, BRT_PLANE, 5},
{ {0,}, "PLANE_V4_F", BRT_VECTOR4_FLOAT, BRT_PLANE_V4_F, 5},
{ {0,}, "PLANE_V4_X", BRT_VECTOR4_FIXED, BRT_PLANE_V4_X, 5},
{ {0,}, "POINT", BRT_NONE, BRT_POINT, 5},
{ {0,}, "POINTER", BRT_NONE, BRT_POINTER, 7},
{ {0,}, "POINTER_LIST", BRT_NONE, BRT_POINTER_LIST, 12},
{ {0,}, "POSITION_V3_F", BRT_VECTOR3_FLOAT, BRT_POSITION_V3_F, 8},
{ {0,}, "POSITION_V3_X", BRT_VECTOR3_FIXED, BRT_POSITION_V3_X, 8},
{ {0,}, "POWERPC", BRT_NONE, BRT_POWERPC, 7},
{ {0,}, "POWER_OF_2", BRT_NONE, BRT_POWER_OF_2, 10},
{ {0,}, "PREFER_SHARE_B", BRT_BOOLEAN, BRT_PREFER_SHARE_B, 12},
{ {0,}, "PRELIGHTING_B", BRT_BOOLEAN, BRT_PRELIGHTING_B, 11},
{ {0,}, "PRIMITIVE", BRT_NONE, BRT_PRIMITIVE, 9},
{ {0,}, "PRIMITIVES", BRT_NONE, BRT_PRIMITIVES, 10},
{ {0,}, "PRIMITIVE_BLOCK_P", BRT_POINTER, BRT_PRIMITIVE_BLOCK_P, 15},
{ {0,}, "PRIMITIVE_CUSTOM_P", BRT_POINTER, BRT_PRIMITIVE_CUSTOM_P, 16},
{ {0,}, "PRIMITIVE_FILTER_P", BRT_POINTER, BRT_PRIMITIVE_FILTER_P, 16},
{ {0,}, "PRIMITIVE_LIBRARY", BRT_NONE, BRT_PRIMITIVE_LIBRARY, 17},
{ {0,}, "PRIMITIVE_LIBRARY_O", BRT_OBJECT, BRT_PRIMITIVE_LIBRARY_O, 17},
{ {0,}, "PRIMITIVE_LIBRARY_OL", BRT_OBJECT_LIST, BRT_PRIMITIVE_LIBRARY_OL, 17},
{ {0,}, "PRIMITIVE_LIBRARY_P", BRT_POINTER, BRT_PRIMITIVE_LIBRARY_P, 17},
{ {0,}, "PRIMITIVE_STATE", BRT_NONE, BRT_PRIMITIVE_STATE, 15},
{ {0,}, "PRIVATE", BRT_NONE, BRT_PRIVATE, 7},
{ {0,}, "PRODUCT_CSTR", BRT_CONSTANT_STRING, BRT_PRODUCT_CSTR, 7},
{ {0,}, "PRODUCT_VERSION_CSTR", BRT_CONSTANT_STRING, BRT_PRODUCT_VERSION_CSTR, 15},
{ {0,}, "QUAD", BRT_NONE, BRT_QUAD, 4},
{ {0,}, "QUADRATIC", BRT_NONE, BRT_QUADRATIC, 9},
{ {0,}, "QUAD_STRIP", BRT_NONE, BRT_QUAD_STRIP, 10},
{ {0,}, "RADII", BRT_NONE, BRT_RADII, 5},
{ {0,}, "RADIUS_CULL_B", BRT_BOOLEAN, BRT_RADIUS_CULL_B, 11},
{ {0,}, "RADIUS_INNER_F", BRT_FLOAT, BRT_RADIUS_INNER_F, 12},
{ {0,}, "RADIUS_INNER_X", BRT_FIXED, BRT_RADIUS_INNER_X, 12},
{ {0,}, "RADIUS_OUTER_F", BRT_FLOAT, BRT_RADIUS_OUTER_F, 12},
{ {0,}, "RADIUS_OUTER_X", BRT_FIXED, BRT_RADIUS_OUTER_X, 12},
{ {0,}, "RED", BRT_NONE, BRT_RED, 3},
{ {0,}, "REGISTRY_STR", BRT_STRING, BRT_REGISTRY_STR, 8},
{ {0,}, "REJECT", BRT_NONE, BRT_REJECT, 6},
{ {0,}, "RENDERER", BRT_NONE, BRT_RENDERER, 8},
{ {0,}, "RENDERER_FACILITY", BRT_NONE, BRT_RENDERER_FACILITY, 17},
{ {0,}, "RENDERER_FACILITY_O", BRT_OBJECT, BRT_RENDERER_FACILITY_O, 17},
{ {0,}, "RENDERER_FACILITY_OL", BRT_OBJECT_LIST, BRT_RENDERER_FACILITY_OL, 17},
{ {0,}, "RENDERER_MAX_I32", BRT_INT_32, BRT_RENDERER_MAX_I32, 12},
{ {0,}, "RENDERER_O", BRT_OBJECT, BRT_RENDERER_O, 8},
{ {0,}, "RENDERER_STATE_STORED", BRT_NONE, BRT_RENDERER_STATE_STORED, 21},
{ {0,}, "RENDER_B", BRT_BOOLEAN, BRT_RENDER_B, 6},
{ {0,}, "RGB", BRT_NONE, BRT_RGB, 3},
{ {0,}, "RGBA_4_4_4_4", BRT_NONE, BRT_RGBA_4_4_4_4, 12},
{ {0,}, "RGBA_8_8_8_8", BRT_NONE, BRT_RGBA_8_8_8_8, 12},
{ {0,}, "RGBX_8_8_8_8", BRT_NONE, BRT_RGBX_8_8_8_8, 12},
{ {0,}, "RGB_2_3_2", BRT_NONE, BRT_RGB_2_3_2, 9},
{ {0,}, "RGB_5_6_5", BRT_NONE, BRT_RGB_5_6_5, 9},
{ {0,}, "RGB_8_8_8", BRT_NONE, BRT_RGB_8_8_8, 9},
{ {0,}, "RIGHT_LEFT", BRT_NONE, BRT_RIGHT_LEFT, 10},
{ {0,}, "SCREEN_DOOR_O", BRT_OBJECT, BRT_SCREEN_DOOR_O, 11},
{ {0,}, "SCREEN_DOOR_TVL", BRT_TOKEN_VALUE_LIST, BRT_SCREEN_DOOR_TVL, 11},
{ {0,}, "SEPARATE_SPECULAR_B", BRT_BOOLEAN, BRT_SEPARATE_SPECULAR_B, 17},
{ {0,}, "SHARED_B", BRT_BOOLEAN, BRT_SHARED_B, 6},
{ {0,}, "SMOOTH_1_B", BRT_BOOLEAN, BRT_SMOOTH_1_B, 8},
{ {0,}, "SMOOTH_B", BRT_BOOLEAN, BRT_SMOOTH_B, 6},
{ {0,}, "SMOOTH_OPACITY_B", BRT_BOOLEAN, BRT_SMOOTH_OPACITY_B, 14},
{ {0,}, "SPACE_T", BRT_TOKEN, BRT_SPACE_T, 5},
{ {0,}, "SPECULAR_F", BRT_FLOAT, BRT_SPECULAR_F, 8},
{ {0,}, "SPECULAR_POWER_F", BRT_FLOAT, BRT_SPECULAR_POWER_F, 14},
{ {0,}, "SPECULAR_POWER_X", BRT_FIXED, BRT_SPECULAR_POWER_X, 14},
{ {0,}, "SPECULAR_X", BRT_FIXED, BRT_SPECULAR_X, 8},
{ {0,}, "SPOT", BRT_NONE, BRT_SPOT, 4},
{ {0,}, "SPOT_INNER_F", BRT_FLOAT, BRT_SPOT_INNER_F, 10},
{ {0,}, "SPOT_INNER_X", BRT_FIXED, BRT_SPOT_INNER_X, 10},
{ {0,}, "SPOT_OUTER_F", BRT_FLOAT, BRT_SPOT_OUTER_F, 10},
{ {0,}, "SPOT_OUTER_X", BRT_FIXED, BRT_SPOT_OUTER_X, 10},
{ {0,}, "SPRITE", BRT_NONE, BRT_SPRITE, 6},
{ {0,}, "SQUARE", BRT_NONE, BRT_SQUARE, 6},
{ {0,}, "STANDARD_BLEND", BRT_NONE, BRT_STANDARD_BLEND, 14},
{ {0,}, "STATE_RESTORE", BRT_NONE, BRT_STATE_RESTORE, 13},
{ {0,}, "STEREO_B", BRT_BOOLEAN, BRT_STEREO_B, 6},
{ {0,}, "STEREO_T", BRT_TOKEN, BRT_STEREO_T, 6},
{ {0,}, "STEREO_TL", BRT_TOKEN_LIST, BRT_STEREO_TL, 6},
{ {0,}, "STORED_STATE_O", BRT_OBJECT, BRT_STORED_STATE_O, 12},
{ {0,}, "STRETCHDIBITS", BRT_NONE, BRT_STRETCHDIBITS, 13},
{ {0,}, "STRETCH_COPY_DESTINATION_TVL", BRT_TOKEN_VALUE_LIST, BRT_STRETCH_COPY_DESTINATION_TVL, 24},
{ {0,}, "STRETCH_COPY_F", BRT_FLOAT, BRT_STRETCH_COPY_F, 12},
{ {0,}, "STRETCH_COPY_SOURCE_TVL", BRT_TOKEN_VALUE_LIST, BRT_STRETCH_COPY_SOURCE_TVL, 19},
{ {0,}, "STRETCH_COPY_T", BRT_TOKEN, BRT_STRETCH_COPY_T, 12},
{ {0,}, "STRETCH_COPY_TL", BRT_TOKEN_LIST, BRT_STRETCH_COPY_TL, 12},
{ {0,}, "STRETCH_COPY_X", BRT_FIXED, BRT_STRETCH_COPY_X, 12},
{ {0,}, "STRING", BRT_NONE, BRT_STRING, 6},
{ {0,}, "SUBDIVIDE", BRT_NONE, BRT_SUBDIVIDE, 9},
{ {0,}, "SUBDIVIDE_TOLERANCE_I32", BRT_INT_32, BRT_SUBDIVIDE_TOLERANCE_I32, 19},
{ {0,}, "SURFACE", BRT_NONE, BRT_SURFACE, 7},
{ {0,}, "SURFACE_B", BRT_BOOLEAN, BRT_SURFACE_B, 7},
{ {0,}, "SURFACE_C_CUSTOM_P", BRT_POINTER, BRT_SURFACE_C_CUSTOM_P, 16},
{ {0,}, "SURFACE_C_FILTER_P", BRT_POINTER, BRT_SURFACE_C_FILTER_P, 16},
{ {0,}, "SURFACE_V_CUSTOM_P", BRT_POINTER, BRT_SURFACE_V_CUSTOM_P, 16},
{ {0,}, "SURFACE_V_FILTER_P", BRT_POINTER, BRT_SURFACE_V_FILTER_P, 16},
{ {0,}, "SYCHRONISE_I32", BRT_INT_32, BRT_SYCHRONISE_I32, 10},
{ {0,}, "TEXTURE_1_O", BRT_OBJECT, BRT_TEXTURE_1_O, 9},
{ {0,}, "TEXTURE_MEMORY_U32", BRT_UINT_32, BRT_TEXTURE_MEMORY_U32, 14},
{ {0,}, "TEXTURE_O", BRT_OBJECT, BRT_TEXTURE_O, 7},
{ {0,}, "TEXTURE_TVL", BRT_TOKEN_VALUE_LIST, BRT_TEXTURE_TVL, 7},
{ {0,}, "TITLE_CSTR", BRT_CONSTANT_STRING, BRT_TITLE_CSTR, 5},
{ {0,}, "TOKEN", BRT_NONE, BRT_TOKEN, 5},
{ {0,}, "TOKEN_LIST", BRT_NONE, BRT_TOKEN_LIST, 10},
{ {0,}, "TOKEN_VALUE_LIST", BRT_NONE, BRT_TOKEN_VALUE_LIST, 16},
{ {0,}, "TOP_BOTTOM", BRT_NONE, BRT_TOP_BOTTOM, 10},
{ {0,}, "TRANSFORM_B", BRT_BOOLEAN, BRT_TRANSFORM_B, 9},
{ {0,}, "TRIANGLE", BRT_NONE, BRT_TRIANGLE, 8},
{ {0,}, "TRI_FAN", BRT_NONE, BRT_TRI_FAN, 7},
{ {0,}, "TRI_STRIP", BRT_NONE, BRT_TRI_STRIP, 9},
{ {0,}, "TWO_SIDED", BRT_NONE, BRT_TWO_SIDED, 9},
{ {0,}, "TYPE_T", BRT_TOKEN, BRT_TYPE_T, 4},
{ {0,}, "UINT_16", BRT_NONE, BRT_UINT_16, 7},
{ {0,}, "UINT_32", BRT_NONE, BRT_UINT_32, 7},
{ {0,}, "UINT_8", BRT_NONE, BRT_UINT_8, 6},
{ {0,}, "UNKNOWN", BRT_NONE, BRT_UNKNOWN, 7},
{ {0,}, "UPDATE_DATA_B", BRT_BOOLEAN, BRT_UPDATE_DATA_B, 11},
{ {0,}, "USES_PRIMITIVE_LIBRARY_B", BRT_BOOLEAN, BRT_USES_PRIMITIVE_LIBRARY_B, 22},
{ {0,}, "USE_BACKGROUND_ALPHA_B", BRT_BOOLEAN, BRT_USE_BACKGROUND_ALPHA_B, 20},
{ {0,}, "USE_CONSTANT_ALPHA_B", BRT_BOOLEAN, BRT_USE_CONSTANT_ALPHA_B, 18},
{ {0,}, "USE_CONSTANT_FOG_B", BRT_BOOLEAN, BRT_USE_CONSTANT_FOG_B, 16},
{ {0,}, "USE_NO_3D_B", BRT_BOOLEAN, BRT_USE_NO_3D_B, 9},
{ {0,}, "USE_NO_DEPTH_B", BRT_BOOLEAN, BRT_USE_NO_DEPTH_B, 12},
{ {0,}, "USE_T", BRT_TOKEN, BRT_USE_T, 3},
{ {0,}, "V1BUCKETS", BRT_NONE, BRT_V1BUCKETS, 9},
{ {0,}, "V1INSERT_ARG1_P", BRT_POINTER, BRT_V1INSERT_ARG1_P, 13},
{ {0,}, "V1INSERT_ARG2_P", BRT_POINTER, BRT_V1INSERT_ARG2_P, 13},
{ {0,}, "V1INSERT_ARG3_P", BRT_POINTER, BRT_V1INSERT_ARG3_P, 13},
{ {0,}, "V1INSERT_FUNCTION_P", BRT_POINTER, BRT_V1INSERT_FUNCTION_P, 17},
{ {0,}, "V1MODEL", BRT_NONE, BRT_V1MODEL, 7},
{ {0,}, "V1ORDER_TABLE_P", BRT_POINTER, BRT_V1ORDER_TABLE_P, 13},
{ {0,}, "V1PRIMITIVE_HEAP_P", BRT_POINTER, BRT_V1PRIMITIVE_HEAP_P, 16},
{ {0,}, "VECTOR2_FIXED", BRT_NONE, BRT_VECTOR2_FIXED, 13},
{ {0,}, "VECTOR2_FLOAT", BRT_NONE, BRT_VECTOR2_FLOAT, 13},
{ {0,}, "VECTOR2_INTEGER", BRT_NONE, BRT_VECTOR2_INTEGER, 15},
{ {0,}, "VECTOR3_FIXED", BRT_NONE, BRT_VECTOR3_FIXED, 13},
{ {0,}, "VECTOR3_FLOAT", BRT_NONE, BRT_VECTOR3_FLOAT, 13},
{ {0,}, "VECTOR3_INTEGER", BRT_NONE, BRT_VECTOR3_INTEGER, 15},
{ {0,}, "VECTOR4_FIXED", BRT_NONE, BRT_VECTOR4_FIXED, 13},
{ {0,}, "VECTOR4_FLOAT", BRT_NONE, BRT_VECTOR4_FLOAT, 13},
{ {0,}, "VECTOR4_INTEGER", BRT_NONE, BRT_VECTOR4_INTEGER, 15},
{ {0,}, "VERSION_U32", BRT_UINT_32, BRT_VERSION_U32, 7},
{ {0,}, "VERTEX", BRT_NONE, BRT_VERTEX, 6},
{ {0,}, "VERTEX_DBL", BRT_NONE, BRT_VERTEX_DBL, 10},
{ {0,}, "VERTEX_SGL", BRT_NONE, BRT_VERTEX_SGL, 10},
{ {0,}, "VERTICAL_BLANK", BRT_NONE, BRT_VERTICAL_BLANK, 14},
{ {0,}, "VIDEO_MEMORY_U32", BRT_UINT_32, BRT_VIDEO_MEMORY_U32, 12},
{ {0,}, "VIEW", BRT_NONE, BRT_VIEW, 4},
{ {0,}, "VIEW_TO_ENVIRONMENT_HINT_T", BRT_TOKEN, BRT_VIEW_TO_ENVIRONMENT_HINT_T, 24},
{ {0,}, "VIEW_TO_ENVIRONMENT_M34_F", BRT_MATRIX34_FLOAT, BRT_VIEW_TO_ENVIRONMENT_M34_F, 19},
{ {0,}, "VIEW_TO_ENVIRONMENT_M34_X", BRT_MATRIX34_FIXED, BRT_VIEW_TO_ENVIRONMENT_M34_X, 19},
{ {0,}, "VIEW_TO_SCREEN_HINT_T", BRT_TOKEN, BRT_VIEW_TO_SCREEN_HINT_T, 19},
{ {0,}, "VIEW_TO_SCREEN_M4_F", BRT_MATRIX4_FLOAT, BRT_VIEW_TO_SCREEN_M4_F, 14},
{ {0,}, "VIEW_TO_SCREEN_M4_X", BRT_MATRIX4_FIXED, BRT_VIEW_TO_SCREEN_M4_X, 14},
{ {0,}, "WIDTH_I32", BRT_INT_32, BRT_WIDTH_I32, 5},
{ {0,}, "WIDTH_MAX_I32", BRT_INT_32, BRT_WIDTH_MAX_I32, 9},
{ {0,}, "WIDTH_MIN_I32", BRT_INT_32, BRT_WIDTH_MIN_I32, 9},
{ {0,}, "WIDTH_OPTIMUM_I32", BRT_INT_32, BRT_WIDTH_OPTIMUM_I32, 13},
{ {0,}, "WIDTH_T", BRT_TOKEN, BRT_WIDTH_T, 5},
{ {0,}, "WIDTH_TL", BRT_TOKEN_LIST, BRT_WIDTH_TL, 5},
{ {0,}, "WINDOW_BUFFER_METHOD_T", BRT_TOKEN, BRT_WINDOW_BUFFER_METHOD_T, 20},
{ {0,}, "WINDOW_FULLSCREEN_B", BRT_BOOLEAN, BRT_WINDOW_FULLSCREEN_B, 17},
{ {0,}, "WINDOW_HANDLE_H", BRT_HANDLE, BRT_WINDOW_HANDLE_H, 13},
{ {0,}, "WINDOW_NAME_CSTR", BRT_CONSTANT_STRING, BRT_WINDOW_NAME_CSTR, 11},
{ {0,}, "WINDOW_PROCEDURE_P", BRT_POINTER, BRT_WINDOW_PROCEDURE_P, 16},
{ {0,}, "WING", BRT_NONE, BRT_WING, 4},
{ {0,}, "WORD_BYTES_I32", BRT_INT_32, BRT_WORD_BYTES_I32, 10},
{ {0,}, "WRAP", BRT_NONE, BRT_WRAP, 4},
{ {0,}, "WRITABLE_BASE_I32", BRT_INT_32, BRT_WRITABLE_BASE_I32, 13},
{ {0,}, "WRITABLE_RANGE_I32", BRT_INT_32, BRT_WRITABLE_RANGE_I32, 14},
{ {0,}, "XBGR_1_5_5_5", BRT_NONE, BRT_XBGR_1_5_5_5, 12},
{ {0,}, "XBGR_8_8_8_8", BRT_NONE, BRT_XBGR_8_8_8_8, 12},
{ {0,}, "XRGB_1_5_5_5", BRT_NONE, BRT_XRGB_1_5_5_5, 12},
{ {0,}, "XRGB_8_8_8_8", BRT_NONE, BRT_XRGB_8_8_8_8, 12},
{ {0,}, "XYZ_16_16_16", BRT_NONE, BRT_XYZ_16_16_16, 12},
{ {0,}, "XYZ_8_8_8", BRT_NONE, BRT_XYZ_8_8_8, 9},
{ {0,}, "YON_Z_F", BRT_FLOAT, BRT_YON_Z_F, 5},
{ {0,}, "YON_Z_X", BRT_FIXED, BRT_YON_Z_X, 5},
{ {0,}, "YUV_16", BRT_NONE, BRT_YUV_16, 6},
{ {0,}, "ZERO_IS_TRANSPARENT", BRT_NONE, BRT_ZERO_IS_TRANSPARENT, 19},
{ {0,}, "ZTRANSPARENCY_B", BRT_BOOLEAN, BRT_ZTRANSPARENCY_B, 13},
{ {0,}, "Z_WRITE_ALWAYS", BRT_NONE, BRT_Z_WRITE_ALWAYS, 14},
{ {0,}, "Z_WRITE_CONDITIONAL", BRT_NONE, BRT_Z_WRITE_CONDITIONAL, 19},
{ {0,}, "Z_WRITE_CONDITIONAL_NO_Z", BRT_NONE, BRT_Z_WRITE_CONDITIONAL_NO_Z, 24},
{ {0,}, "Z_WRITE_NEVER", BRT_NONE, BRT_Z_WRITE_NEVER, 13},
{ {0,}, "Z_WRITE_T", BRT_TOKEN, BRT_Z_WRITE_T, 7},
{ {0,}, "Z_WRITE_TL", BRT_TOKEN_LIST, BRT_Z_WRITE_TL, 7},
#define NEXT_FREE_TOKEN 525

1094
core/fw/pretok.h Normal file
View File

File diff suppressed because it is too large Load Diff

955
core/fw/pretok.tok Normal file
View File

@ -0,0 +1,955 @@
# Starting set of tokens - duplication is OK
#
## Token types
##
# Name Extention
$none
$boolean _B
$pointer _P
$token _T
$int_8 _I8
$uint_8 _U8
$int_16 _I16
$uint_16 _U16
$int_32 _I32
$uint_32 _U32
$fixed _X
$float _F
$angle _A
$colour_rgb _RGB
$object _O
$handle _H
$vector2_integer _V2_I
$vector3_integer _V3_I
$vector4_integer _V4_I
$vector2_fixed _V2_X
$vector3_fixed _V3_X
$vector4_fixed _V4_X
$vector2_float _V2_F
$vector3_float _V3_F
$vector4_float _V4_F
$matrix23_fixed _M23_X
$matrix34_fixed _M34_X
$matrix4_fixed _M4_X
$matrix23_float _M23_F
$matrix34_float _M34_F
$matrix4_float _M4_F
$string _STR
$constant_string _CSTR
$object_list _OL
$token_list _TL
$pointer_list _PL
$token_value_list _TVL
## General tokens
##
# Name Type
# Tokens to represent object types
#
#
OBJECT none
OBJECT_CONTAINER none
DEVICE none
FACILITY none
OUTPUT_FACILITY none
DEVICE_PIXELMAP none
DEVICE_CLUT none
RENDERER_FACILITY none
RENDERER none
RENDERER_STATE_STORED none
BUFFER_STORED none
GEOMETRY none
GEOMETRY_STORED none
GEOMETRY_PRIMITIVES none
GEOMETRY_V1_MODEL none
GEOMETRY_V1_BUCKETS none
GEOMETRY_LIGHTING none
PRIMITIVE_LIBRARY none
PRIMITIVE_STATE none
# Tokens used for DEVICE object information
#
IDENTIFIER constant_string
VERSION uint_32 # Version number - vvvv.rrrmm (eg: 0x00010102 = 1.1.2)
BRENDER_VERSION uint_32 # Version of framework that driver was built against
DDI_VERSION uint_32 # Version of DDI that driver was built against
CREATOR constant_string # Organisation or person who built driver
TITLE constant_string # Human readable string identifying driver and version
PRODUCT constant_string # Product, if any that this driver is associated with
PRODUCT_VERSION constant_string # Version of product that driver is associated with
STEREO boolean
STEREO token
STEREO token_list
NONE none
ODD_EVEN none
EVEN_ODD none
LEFT_RIGHT none
RIGHT_LEFT none
TOP_BOTTOM none
BOTTOM_TOP none
CLUT object
# Tokens used for OUTPUT_FACILITY object information
#
IDENTIFIER constant_string
WIDTH int_32
WIDTH_MIN int_32
WIDTH_MAX int_32
HEIGHT int_32
HEIGHT_MIN int_32
HEIGHT_MAX int_32
PIXEL_TYPE uint_8
PIXEL_BITS int_32
WORD_BYTES int_32
PIXEL_CHANNELS int_32
PIXEL_CHANNELS token_list
INDEX none
RED none
GREEN none
BLUE none
DEPTH none
ALPHA none
INDEXED boolean
MEMORY_MAPPED boolean
PRIMITIVE_LIBRARY object
PRIMITIVE_LIBRARY object_list # List of primitive libraries suitable for this type of pixelmap
RENDERER_FACILITY object
RENDERER_FACILITY object_list # List of renderer facilities suitable for this type of pixelmap
PIXELMAP_MAX int_32
CLUT_MAX int_32
VIDEO_MEMORY uint_32
TEXTURE_MEMORY uint_32
HOST_MEMORY uint_32
MODE uint_32
# Tokens for 2d pixelmap querying
#
MATCH token_value_list
COPY_SOURCE token_value_list
COPY_DESTINATION token_value_list
COPY fixed
COPY float
STRETCH_COPY_SOURCE token_value_list
STRETCH_COPY_DESTINATION token_value_list
STRETCH_COPY token
STRETCH_COPY token_list
STRETCH_COPY fixed
STRETCH_COPY float
COPY_BITS fixed
COPY_BITS float
SYCHRONISE int_32
PIXEL_GET fixed
PIXEL_GET float
PIXEL_SET fixed
PIXEL_SET float
DIRECT fixed
DIRECT float
# Tokens used for DEVICE_PIXELMAP object information
#
IDENTIFIER constant_string
WIDTH int_32
HEIGHT int_32
PIXEL_TYPE uint_8
PIXEL_BITS int_32
WORD_BYTES int_32
PIXEL_CHANNELS int_32
PIXEL_CHANNELS token_list
INDEX none
RED none
GREEN none
BLUE none
DEPTH none
ALPHA none
INDEXED boolean
OUTPUT_FACILITY object
FACILITY object
ORIGIN vector2_integer
FONT_NORMAL pointer
FONT_NORMAL object
CLUT object
PRIMITIVE_LIBRARY object
PRIMITIVE_LIBRARY object_list # List of primitive libraries suitable for this pixelmap
RENDERER_FACILITY object
RENDERER_FACILITY object_list # List of renderer facilities suitable for this pixelmap
# Tokens used for DEVICE_CLUT object information
#
IDENTIFIER constant_string
DEFAULT_BASE int_32
DEFAULT_RANGE int_32
WRITABLE_BASE int_32
WRITABLE_RANGE int_32
# br_device_pixelmap_match
#
USE token
CLONE none
DEPTH none
OFFSCREEN none # candiate for doubleBuffer
HIDDEN none # Can render but will never double buffer
HIDDEN_BUFFER none # Can render to and will use as texture
NO_RENDER none # Cannot display, render to or use as texture
BUFFER none # Will use as a texture, but cannot display or render to
PIXEL_TYPE uint_8
PIXEL_BITS int_32
RENDERER object
WIDTH int_32
HEIGHT int_32
# Used for all pixelmap creation routines -
# Makes garuantees about how pixelmap will be used
#
# If true app will never try to invoke 3d rendering
USE_NO_3D boolean
# If true app will never try create a depth buffer for this pixelmap
USE_NO_DEPTH boolean
# Tokens used for RENDERER_FACILITY object information
#
IDENTIFIER constant_string
LIGHT_MAX int_32
CLIP_MAX int_32
RENDERER_MAX int_32
PARTS token_list
ALTERNATIVE_TO_DEFAULT boolean # Can be used instead of default
USES_PRIMITIVE_LIBRARY boolean # Uses a primitive library for rasterisation
# Tokens used for RENDERER object information
#
IDENTIFIER constant_string
LIGHT_MAX int_32
CLIP_MAX int_32
RENDERER_FACILITY object
FACILITY object
PARTS token_list
# Tokens used for BUFFER_STORED object information
#
SHARED boolean
CACHED boolean
CACHED_SIZE uint_32
CACHED_TOTAL uint_32
UPDATE_DATA boolean
# tokens for bufferAdd/Update
#
CAN_SHARE boolean
PREFER_SHARE boolean
# Tokens used for GEOMETRY_STORED object information
#
CACHED boolean
CACHED_SIZE uint_32
CACHED_TOTAL uint_32
# Tokens used for RENDERER_STATE_STORED object information
#
PARTS uint_32
PARTS token_list
CACHED boolean
CACHED_SIZE uint_32
CACHED_TOTAL uint_32
# Tokens used for GEOMETRY_FORMAT object information
#
FORMAT token
RENDERER_FACILITY object
FACILITY object
# Tokens used for PRIMITIVE_LIBRARY object information
#
PARTS token_list
ALTERNATIVE_TO_DEFAULT boolean # Can be used instead of default
# Tokens used for PRIMITIVE_STATE object information
#
PARTS token_list
CACHED boolean
CACHED_SIZE uint_32
CACHED_TOTAL uint_32
# Tokens used for br_renderer_type::newRenderer
#
DESTINATION object
OUTPUT_FACILITY object
PRIMITIVE_LIBRARY pointer
# Tokens used for different parts of renderer state
#
CULL none
SURFACE none
MATRIX none
ENABLE none
LIGHT none
CLIP none
BOUNDS none
HIDDEN_SURFACE none
PRIMITIVE none
OUTPUT none
# Tokens used for primitive state (handled by primitive layer)
#
SMOOTH boolean
SMOOTH_OPACITY boolean
DECAL boolean
DEPTH_WRITE boolean
COLOUR_WRITE boolean
BLEND boolean
MODULATE boolean
MODULATE_ALPHA boolean
COLOUR_KEY boolean
PERSPECTIVE boolean
PERSPECTIVE token
PERSPECTIVE token_list
NONE none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
SUBDIVIDE none
# Amount of error allowed for subdivision.
# 0 is default
# -ve is more tolerant
# +ve is less tolerant
#
# Useful range should be -100 -> +100
#
SUBDIVIDE_TOLERANCE int_32
DITHER_COLOUR boolean
DITHER_COLOUR token
DITHER_COLOUR token_list
NONE none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
# This should be nuked - superceded by MAP_INTERPOLATION
#
DITHER_MAP boolean
DITHER_MAP token
DITHER_MAP token_list
NONE none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
COLOUR boolean
COLOUR token
COLOUR token_list
NONE none
RGB none
INDEX none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
INDEX_BASE int_32
INDEX_RANGE int_32
ANTIALIASING token
ANTIALIASING token_list
NONE none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
MAP_ANTIALIASING token
MAP_ANTIALIASING token_list
NONE none
MIP none
MIP_PER_PIXEL none
MIP_PER_PRIMITIVE none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
MAP_INTERPOLATION token
MAP_INTERPOLATION token_list
NONE none
NEAREST none
DITHER none
LINEAR none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
MAP_INTERPOLATION_MAG token
MAP_INTERPOLATION_MAG token_list
NONE none
NEAREST none
DITHER none
LINEAR none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
MAP_INTERPOLATION_MIN token
MAP_INTERPOLATION_MIN token_list
NONE none
NEAREST none
DITHER none
LINEAR none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
MIP_INTERPOLATION token
MIP_INTERPOLATION token_list
NONE none
NEAREST none
LINEAR none
DITHER none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
FOG token
FOG token_list
NONE none
LINEAR none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
FOG colour_rgb
FOG_MIN float
FOG_MIN fixed
FOG_MAX float
FOG_MAX fixed
DEPTH_TEST token
DEPTH_TEST token_list
GREATER none
GREATER_OR_EQUAL none
EQUAL none
NOT_EQUAL none
LESS_OR_EQUAL none
LESS none
NEVER none
ALWAYS none
NONE none
MAP_WIDTH_LIMIT token
MAP_WIDTH_LIMIT token_list
WRAP none
CLAMP none
MIRROR none
DEFAULT none
MAP_HEIGHT_LIMIT token
MAP_HEIGHT_LIMIT token_list
WRAP none
CLAMP none
MIRROR none
DEFAULT none
WIDTH token
WIDTH token_list
HEIGHT token
HEIGHT token_list
WIDTH_OPTIMUM int_32
HEIGHT_OPTIMUM int_32
PRIMITIVE_BLOCK pointer # Private - allows a primitive block to be passed in for debugging/testing
# Some common buffers
#
TEXTURE object
COLOUR_MAP object
INDEX_SHADE object
INDEX_BLEND object
SCREEN_DOOR object
INDEX_LIGHT object
BUMP object
INDEX_FOG object
TEXTURE token_value_list
COLOUR_MAP token_value_list
INDEX_SHADE token_value_list
INDEX_BLEND token_value_list
SCREEN_DOOR token_value_list
INDEX_LIGHT token_value_list
BUMP token_value_list
INDEX_FOG token_value_list
# Unknown buffer use
#
UNKNOWN none
# Tokens used for culling state (handled by renderer)
#
TYPE token
NONE none
ONE_SIDED none
TWO_SIDED none
SPACE token
VIEW none
MODEL none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
# Tokens used for surface state (handled by renderer)
#
LIGHTING boolean
PRELIGHTING boolean
SEPARATE_SPECULAR boolean
FORCE_FRONT boolean
FORCE_BACK boolean
DEPTH_BIAS float
DEPTH_BIAS fixed
COLOUR_SOURCE token
NONE none
SURFACE none
GEOMETRY none
PRIMITIVE none
VERTEX none
OPACITY_SOURCE token
NONE none
SURFACE none
GEOMETRY none
PRIMITIVE none
VERTEX none
MAPPING_SOURCE token
NONE none
ENVIRONMENT_LOCAL none
ENVIRONMENT_INFINITE none
GEOMETRY_MAP none
GEOMETRY_X none
GEOMETRY_Y none
GEOMETRY_Z none
QUAD none
COLOUR int_32
COLOUR colour_rgb
OPACITY fixed
OPACITY float
AMBIENT fixed
AMBIENT float
DIFFUSE fixed
DIFFUSE float
SPECULAR fixed
SPECULAR float
SPECULAR_POWER fixed
SPECULAR_POWER float
MAP_MATRIX matrix23_float
MAP_MATRIX matrix23_fixed
SURFACE_C_CUSTOM pointer
SURFACE_C_FILTER pointer
SURFACE_V_CUSTOM pointer
SURFACE_V_FILTER pointer
PRIMITIVE_CUSTOM pointer
PRIMITIVE_FILTER pointer
# Tokens used for light state
#
TYPE token
NONE none
DIRECT none
POINT none
SPOT none
AMBIENT none
SPACE token
VIEW none
MODEL none
DEFAULT none
BEST_SPEED none
BEST_QUALITY none
POSITION vector3_float
POSITION vector3_fixed
DIRECTION vector3_float
DIRECTION vector3_fixed
COLOUR colour_rgb
SPOT_OUTER fixed
SPOT_OUTER float
SPOT_INNER fixed
SPOT_INNER float
RADIUS_OUTER fixed # Cutoff radius and outer radius for linear falloff
RADIUS_OUTER float
RADIUS_INNER fixed
RADIUS_INNER float
ANGLE_OUTER angle # Cutoff angle
ANGLE_INNER angle
ATTENUATION_L fixed
ATTENUATION_L float
ATTENUATION_C fixed
ATTENUATION_C float
ATTENUATION_Q fixed
ATTENUATION_Q float
# Flag indicating that radius/angle cutoff is to be used on point and spot lights
RADIUS_CULL boolean
ANGLE_CULL boolean
# Type of attenuation - quadratic or using inner and outer radii
ATTENUATION_TYPE token
QUADRATIC none
RADII none
ATTENUATION_HINT token
CONSTANT none
LINEAR none
QUADRATIC none
LIGHTING_VOLUME pointer
# Boolean that can be set to cull a light from affecting a particular model
CULLED boolean
# Tokens used for clip state
#
TYPE token
NONE none
PLANE none
PLANE vector4_float
PLANE vector4_fixed
# Tokens used for bounds state
#
MIN vector2_integer
MIN vector2_fixed
MIN vector2_float
MAX vector2_integer
MAX vector2_fixed
MAX vector2_float
# Tokens used for matrix state
#
MODEL_TO_VIEW matrix34_float
MODEL_TO_VIEW matrix34_fixed
MODEL_TO_VIEW_HINT token
NONE none
LENGTH_PRESERVING none
VIEW_TO_SCREEN matrix4_float
VIEW_TO_SCREEN matrix4_fixed
VIEW_TO_SCREEN_HINT token
NONE none
PERSPECTIVE none
PARALLEL none
VIEW_TO_ENVIRONMENT matrix34_float
VIEW_TO_ENVIRONMENT matrix34_fixed
VIEW_TO_ENVIRONMENT_HINT token
NONE none
DONT_CARE none
MODEL_TO_SCREEN matrix4_float
MODEL_TO_SCREEN matrix4_fixed
HITHER_Z float
HITHER_Z fixed
YON_Z float
YON_Z fixed
# Tokens used for output state
#
COLOUR_BUFFER object
DEPTH_BUFFER object
# Tokens used for enable state
#
CULL boolean
TRANSFORM boolean
SURFACE boolean
CLIPPING boolean
BOUNDS boolean
RENDER boolean
# Tokens used for hidden surface state
#
TYPE token
NONE none
BUCKET_SORT none
DIVERT token
NONE none
ALL none
BLENDED none
V1ORDER_TABLE pointer
V1PRIMITIVE_HEAP pointer
V1INSERT_FUNCTION pointer
V1INSERT_ARG1 pointer
V1INSERT_ARG2 pointer
V1INSERT_ARG3 pointer
STORED_STATE object
# Currently known primtive types
#
SPRITE none
POINT none
LINE none
TRIANGLE none
QUAD none
STATE_RESTORE none
# Geometry formats
#
PRIMITIVES none
V1MODEL none
V1BUCKETS none
LIGHT_VERTICES none
# Tokens decribing sync. types
#
VERTICAL_BLANK none # In vertical blank
RENDERER none # Rendering finished
# Tokens for on screen check results
#
PARTIAL none
ACCEPT none
REJECT none
# Tokens to represent scalar types
#
FLOAT none
FIXED none
# Tokens for image pixel formats - descriptions are big-endian
#
INDEX_1 none
INDEX_2 none
INDEX_4 none
INDEX_8 none
XRGB_1_5_5_5 none
XBGR_1_5_5_5 none
ARGB_1_5_5_5 none
ABGR_1_5_5_5 none
RGB_5_6_5 none
BGR_5_6_5 none
RGB_2_3_2 none
BGR_2_3_2 none
RGB_8_8_8 none
BGR_8_8_8 none
XRGB_8_8_8_8 none
XBGR_8_8_8_8 none
BGRX_8_8_8_8 none
RGBX_8_8_8_8 none
ARGB_8_8_8_8 none
ABGR_8_8_8_8 none
BGRA_8_8_8_8 none
RGBA_8_8_8_8 none
ARGB_4_4_4_4 none
ABGR_4_4_4_4 none
BGRA_4_4_4_4 none
RGBA_4_4_4_4 none
D_16 none
D_24 none
D_32 none
A_8 none
INDEXA_8_8 none
INDEXA_4_4 none
AINDEX_8_8 none
AINDEX_4_4 none
XYZ_8_8_8 none
XYZ_16_16_16 none
YUV_16 none
PRIVATE none # Some 'other' format
# Tokens for texture requirements
#
SQUARE none
POWER_OF_2 none
ZERO_IS_TRANSPARENT none
KEY_IS_TRANSPARENT none
# Tokens for generic Windows driver
#
WINDOW_NAME constant_string
WINDOW_PROCEDURE pointer
WINDOW_HANDLE handle
WINDOW_FULLSCREEN boolean
WINDOW_BUFFER_METHOD token
WING none
STRETCHDIBITS none
DIBSECTION none
DIRECTDRAW none
# DirectDraw specific tokens
DIRECTDRAW_DEVICENAME constant_string
LPDIRECTDRAWSURFACE pointer
# Tokens for Direct3D driver
DIRECT3D_RENDER_METHOD token
DIRECT3D_RAMP none
DIRECT3D_RGB none
DIRECT3D_HAL none
# Tokens for system configuration
REGISTRY string
INI string
BRENDER_PATH string
BRENDER_DRIVERS string
DEFAULT_DEVICE string
BRENDER_DEVICES string
BRENDER_DEVELOPER boolean
BRENDER_USE_MMX boolean
BRENDER_USE_CMOV boolean
# Tokens for host processor info
#
INTEL none
POWERPC none
MIPS none
ALPHA none
MOTOROLA none
INTEL_386 none
INTEL_486 none
INTEL_PENTIUM none
INTEL_PENTIUM_PRO none
# Support Z-buffer write modes.
Z_WRITE token
Z_WRITE token_list
Z_WRITE_NEVER none
Z_WRITE_ALWAYS none
Z_WRITE_CONDITIONAL_NO_Z none
Z_WRITE_CONDITIONAL none
# Indicates whether a transparent texturemap is Z transparent.
ZTRANSPARENCY boolean
# Support for alpha blending modes.
BLEND_MODE token
BLEND_MODE token_list
BLEND_STANDARD none
BLEND_SUMMED none
BLEND_DIMMED none
BLEND_PREMULTIPLIED none
BLEND_CONSTANT none
# Depth buffer extensions
D_15 none
D_31 none
D_FP15 none
D_FP16 none
#Alpha extensions
A_4 none
#New Primitives
VERTEX_SGL none
VERTEX_DBL none
TRI_STRIP none
TRI_FAN none
QUAD_STRIP none
#Interlacing
INTERLACE boolean
#Dithering
DITHER boolean
#Complex blender program -- for extra_prim field of material
BLENDER_PROGRAM pointer
# br_device_pixelmap_match extensions.
#
DEPTH_15 none
DEPTH_31 none
DEPTH_FP15 none
DEPTH_FP16 none
# Extra material extensions.
SMOOTH_1 boolean
MAP_HEIGHT_LIMIT_1 token
MAP_WIDTH_LIMIT_1 token
COLOUR_MAP_1 object
TEXTURE_1 object
DOUBLE_TEXTURE boolean
FOG_SCALE uint_8
USE_CONSTANT_ALPHA boolean
USE_CONSTANT_FOG boolean
USE_BACKGROUND_ALPHA boolean
MIP_MODIFIER int_8
MIP_MIN uint_8
MIP_MAX uint_8
MIP_MOD_ABSOLUTE boolean
# More blend tokens
INTENSITY_REDUCTION none
COMPOSITING_WITH_REDUCTION none
STANDARD_BLEND none
COMPOSITING none
COMPOSITING_WITH_INCREASE none
FOG boolean

84
core/fw/printf.c Normal file
View File

@ -0,0 +1,84 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: printf.c 1.1 1997/12/10 16:41:09 jon Exp $
* $Locker: $
*
* Various printf's that are exported
*/
#include <stdarg.h>
#include "fw.h"
BR_RCS_ID("$Id: printf.c 1.1 1997/12/10 16:41:09 jon Exp $")
br_int_32 BR_RESIDENT_ENTRY BrSprintf(char * buf, char *fmt, ...)
{
int n;
va_list args;
va_start(args, fmt);
n = BrVSprintf(buf, fmt, args);
va_end(args);
return n;
}
br_int_32 BR_RESIDENT_ENTRY BrSprintfN(char * buf, br_size_t buf_size, char *fmt, ...)
{
int n;
va_list args;
va_start(args, fmt);
n = BrVSprintf(buf, fmt, args);
va_end(args);
return n;
#if 0
unsigned int n;
char tmp[512];
va_list args;
va_start(args, fmt);
n = BrVSprintf(tmp, fmt, args);
va_end(args);
if(n > buf_size-1) {
n = buf_size-1;
}
BrStrNCpy(buf, tmp, n);
buf[n] = '\0';
return n;
#endif
}
int BR_RESIDENT_ENTRY BrLogPrintf(char *fmt, ...)
{
int n;
va_list args;
va_start(args, fmt);
n = BrVSprintf(BrScratchString(), fmt, args);
va_end(args);
BrLogWrite(BrScratchString(), 1, n);
return n;
}
br_int_32 BR_RESIDENT_ENTRY BrSScanf(char *str, char *fmt, ...)
{
int n;
va_list args;
va_start(args, fmt);
n = BrVSScanf(str, fmt, args);
va_end(args);
return n;
}

367
core/fw/register.c Normal file
View File

@ -0,0 +1,367 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: register.c 1.1 1997/12/10 16:41:09 jon Exp $
* $Locker: $
*
* Generic code for lists of registered items. Used for models, materials,
* textures, tables, cameras, lights, scenes
*
* Each registry is a doubly linked list of chunks of data, the second
* member of an item should be a pointer the the item's name
*/
#include "fw.h"
#include "brassert.h"
BR_RCS_ID("$Id: register.c 1.1 1997/12/10 16:41:09 jon Exp $")
/*
* Initialise a registry
*/
void *BrRegistryNew(br_registry *reg)
{
UASSERT(reg != NULL);
/*
* Intitialise linked list
*/
BrNewList(&reg->list);
/*
* List is empty
*/
reg->count = 0;
return reg;
}
/*
* Release all items on a registry
*/
void *BrRegistryClear(br_registry *reg)
{
br_registry_entry *e;
UASSERT(reg != NULL);
while(e = BR_HEAD(&reg->list), BR_NEXT(e)) {
BR_REMOVE(e);
BrResFree(e);
}
/*
* List is empty
*/
reg->count = 0;
return reg;
}
/*
* Add one new item to a registry
*/
void *BrRegistryAdd(br_registry *reg, void *item)
{
br_registry_entry *e;
UASSERT(reg != NULL);
UASSERT(item != NULL);
e = BrResAllocate(fw.res,sizeof(*e),BR_MEMORY_REGISTRY);
e->item = item;
BR_ADDHEAD(reg,e);
reg->count++;
return item;
}
/*
* Add items from a table of pointers to a registry
*/
int BrRegistryAddMany(br_registry *reg, void **items, int n)
{
int i;
UASSERT(reg != NULL);
UASSERT(items != NULL);
/*
* Walk through table adding items
*/
for(i=0; i < n; i++)
BrRegistryAdd(reg,*items++);
return n;
}
/*
* Remove a single item from the registry
*/
void *BrRegistryRemove(br_registry *reg, void *item)
{
br_registry_entry *e;
void *r;
UASSERT(reg != NULL);
UASSERT(item != NULL);
/*
* Find item in list
*/
BR_FOR_LIST(&reg->list,e)
if(e->item == item)
break;
/*
* If item was not in list, return NULL
*/
if(!BR_NEXT(e))
return NULL;
/*
* Take item of list, remember contents, and free node
*/
BR_REMOVE(e);
r = e->item;
BrResFree(e);
reg->count--;
return r;
}
/*
* Remove a table of referenced items from a registry
*/
int BrRegistryRemoveMany(br_registry *reg, void **items, int n)
{
int i,r;
UASSERT(reg != NULL);
UASSERT(items != NULL);
/*
* Remove all the items from a table, keeping a count of how
* many were actually removed
*/
for(i=0, r=0; i < n; i++)
if(BrRegistryRemove(reg,*items++))
r++;
return r;
}
/*
* Find the first item in registry whose name matches a given pattern
*
* If no item can be found, then call a find_failed hook if it exists
*/
void *BrRegistryFind(br_registry *reg, char *pattern)
{
br_registry_entry *e;
UASSERT(reg != NULL);
/*
* Find item in list
*/
BR_FOR_LIST(&reg->list,e)
if(BrNamePatternMatch(pattern,e->item->identifier))
return e->item;
if(reg->find_failed_hook)
return reg->find_failed_hook(pattern);
else
return NULL;
}
int BrRegistryFindMany(br_registry *reg, char *pattern, void **items, int max)
{
br_registry_entry *e;
int n=0;
/*
* Find all matching items in list
*/
BR_FOR_LIST(&reg->list,e) {
/*
* make sure there is space in output table
*/
if(n >= max)
break;
/*
* If entry matches, add to table
*/
if(BrNamePatternMatch(pattern,e->item->identifier)) {
*items++ = e->item;
n++;
}
}
return n;
}
/*
* Count how many items in registry match pattern
*
* If pattern == NULL, return total in registry
*/
int BrRegistryCount(br_registry *reg, char *pattern)
{
br_registry_entry *e;
int n;
UASSERT(reg != NULL);
if(pattern == NULL)
return reg->count;
/*
* Find all matching items in list
*/
n = 0;
BR_FOR_LIST(&reg->list,e)
if(BrNamePatternMatch(pattern,e->item->identifier))
n++;
return n;
}
/*
* Call a function for every item in a registry. Stop early if callback
* returns !=0, and return that value
*/
int BrRegistryEnum(br_registry *reg, char *pattern,
br_enum_cbfn *callback, void *arg)
{
br_registry_entry *e;
int r;
UASSERT(reg != NULL);
UASSERT(callback != NULL);
/*
* If pattern in NULL, invoke callback for _EVERYTHING_
* else invoke callback for items that match pattern
*/
if(pattern == NULL) {
BR_FOR_LIST_R(&reg->list,e)
if(r = callback(e->item,arg))
return r;
} else {
BR_FOR_LIST_R(&reg->list,e)
if(BrNamePatternMatch(pattern,e->item->identifier))
if(r = callback(e->item,arg))
return r;
}
return 0;
}
/**
** Variants for statically allocated registries
**/
#if EVAL
/*
* Initialise a registry
*/
void *BrRegistryNewStatic(br_registry *reg, br_registry_entry *base, int limit)
{
int i;
UASSERT(reg != NULL);
UASSERT(base != NULL);
/*
* Intitialise linked list
*/
BrNewList(&reg->list);
/*
* Clear static entries
*/
for(i = 0; i < limit; i++)
base[i].node.next = NULL;
/*
* List is empty
*/
reg->count = 0;
return reg;
}
/*
* Add one new item to a registry - assumes at least one unused entry exists
*/
void *BrRegistryAddStatic(br_registry *reg, br_registry_entry *base, void *item)
{
br_registry_entry *e;
UASSERT(reg != NULL);
UASSERT(base != NULL);
UASSERT(item != NULL);
for(e = base; e->node.next != NULL; e++);
e->item = item;
BR_ADDHEAD(reg, e);
reg->count++;
return item;
}
/*
* Remove a single item from the registry
*/
void *BrRegistryRemoveStatic(br_registry *reg, void *item)
{
br_registry_entry *e;
void *r;
UASSERT(reg != NULL);
UASSERT(item != NULL);
/*
* Find item in list
*/
BR_FOR_LIST(&reg->list,e)
if(e->item == item)
break;
/*
* If item was not in list, return NULL
*/
if(!BR_NEXT(e))
return NULL;
/*
* Take item off list, remember contents, and free node
*/
BR_REMOVE(e);
r = e->item;
e->node.next = NULL;
reg->count--;
return r;
}
#else
void *BrRegistryNewStatic(br_registry *reg, br_registry_entry *base, int limit)
{
return NULL;
}
void *BrRegistryAddStatic(br_registry *reg, br_registry_entry *base, void *item)
{
return NULL;
}
void *BrRegistryRemoveStatic(br_registry *reg, void *item)
{
return NULL;
}
#endif

51
core/fw/register.h Normal file
View File

@ -0,0 +1,51 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: register.h 1.1 1997/12/10 16:41:10 jon Exp $
* $Locker: $
*
*
*/
#ifndef _REGISTER_H_
#define _REGISTER_H_
/*
* An entry in a registry - doubly linked list and pointers to data
*
* It is assumed that the second first thing in the data structure is a pointer
* to the item's name
*/
typedef struct br_registry_entry {
struct br_node node;
struct {
br_uint_32 reserved;
char *identifier;
} *item;
} br_registry_entry;
typedef void * BR_CALLBACK br_find_failed_cbfn(char *pattern);
typedef br_uint_32 BR_CALLBACK br_enum_cbfn (void *item, void *arg);
/*
* Base structure for registry
*/
typedef struct br_registery {
/*
* Anchor structure
*/
struct br_list list;
/*
* Number of items in list
*/
int count;
/*
* Hook that is called when RegistryFind fails
*/
br_find_failed_cbfn *find_failed_hook;
} br_registry;
#endif

548
core/fw/resource.c Normal file
View File

@ -0,0 +1,548 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: resource.c 1.1 1997/12/10 16:41:10 jon Exp $
* $Locker: $
*
* Generic code for maintaining a hierachy of resources
*
* Each resource has -
* A class (one of the BR_RES_xxx constants)
* A size
* A block of memory of 'size' bytes
* 0 or more child resources
*
* XXX
* Add optional source file/line tracking
*/
#include "fw.h"
#include "brassert.h"
BR_RCS_ID("$Id: resource.c 1.1 1997/12/10 16:41:10 jon Exp $")
/*
* The granularity of resource sizes
*/
#define BR_RES_GRANULARITY_SHIFT 2
#define BR_RES_GRANULARITY (1<<BR_RES_GRANULARITY_SHIFT)
#define BR_RES_MAGIC 0xDEADBEEF
#define BR_RES_DEFAULT_ALIGN 4
/*
* The control structure prepended onto resource blocks
*/
struct resource_header {
br_simple_node node;
br_simple_list children;
#if BR_ENDIAN_LITTLE
br_uint_8 size_l; /* 24 bits of size */
br_uint_8 size_m;
br_uint_8 size_h;
#elif BR_ENDIAN_BIG
br_uint_8 size_h; /* 24 bits of size */
br_uint_8 size_m;
br_uint_8 size_l;
#else
#error No byte sex
#endif
br_uint_8 class; /* Class of resource */
#if BR_RES_TAGGING
void *magic_ptr;
int magic_num;
#endif
};
/*
* Return size of a resource block
*/
#define RES_SIZE_GET(r)\
(((r)->size_l << BR_RES_GRANULARITY_SHIFT) | \
((r)->size_m << (8+BR_RES_GRANULARITY_SHIFT)) | \
((r)->size_h << (16+BR_RES_GRANULARITY_SHIFT)))
/*
* Set size of a resource block
*/
#define RES_SIZE_SET(r,s) do {\
(r)->size_l = (s) >> BR_RES_GRANULARITY_SHIFT; \
(r)->size_m = (s) >> (8+BR_RES_GRANULARITY_SHIFT); \
(r)->size_h = (s) >> (16+BR_RES_GRANULARITY_SHIFT); \
} while(0)
#define ALIGN(ptr,a) (((br_int_32)(ptr)+((a)-1)) & ~((a)-1))
#if BR_RES_TAGGING
#define ISRESOURCE(res) ((res->magic_ptr == res) && (res->magic_num == BR_RES_MAGIC))
#else
#define ISRESOURCE(res) 1
#endif
/*
* Align the resource pointer
*/
STATIC void *ResToUser(struct resource_header *r)
{
br_int_32 align;
/*
* Find the required alignment
*/
ASSERT(fw.resource_class_index[r->class] != NULL);
align = fw.resource_class_index[r->class]->alignment;
if(align <= 0)
align = BR_RES_DEFAULT_ALIGN;
/*
* Check for no-zero and power of 2
*/
ASSERT(align && (((align-1) & align) == 0));
/*
* Move over the resource_header
*/
r++;
/*
* Bump pointer up to next boundary
*/
return (void *)ALIGN(r,align);
}
/*
* Unalign the resource pointer
*/
STATIC struct resource_header *UserToRes(void *r)
{
br_uint_8 *p = r;
/*
* the last byte of the resource will always be non-zero -
* the class id, or the magic number
*
* Move pointer back until we hit it
*/
while(*(p - 1) == 0)
p--;
return ((struct resource_header *)p) - 1;
}
/*
* Create a new resource block of the given class, with 'size' bytes associated
* with it.
*
* If parent is not NULL it adds the new resource as a child
*
* Returns a pointer to the first byte of the resource data
*/
void * BR_RESIDENT_ENTRY BrResAllocate(void *vparent, br_size_t size, br_uint_8 res_class)
{
struct resource_header *res;
struct resource_header *parent;
br_int_32 malign,calign,pad, actual_pad;
UASSERT(fw.resource_class_index[res_class] != NULL);
/*
* Work out size (rounded up to granularity)
*/
size = ALIGN(size+sizeof(struct resource_header),BR_RES_GRANULARITY);
/*
* Get memory alignment
*/
malign = BrMemAlign(res_class);
ASSERT(malign && (((malign-1) & malign) == 0));
/*
* Get class alignment
*/
calign = fw.resource_class_index[res_class]->alignment;
if(calign <= 0)
calign = BR_RES_DEFAULT_ALIGN;
ASSERT(calign && (((calign-1) & calign) == 0));
/*
* Work out how much padding to add at end of block
*/
pad = (calign-1) & ~(malign-1);
res = BrMemAllocate(size + pad, res_class);
/*
* Since loads of BrResAllocate calls check for NULL returns we
* might as well return NULL sometimes!
*/
if (res == NULL)
return NULL;
/*
* Check to see if memory allocator lied about alignment
*/
actual_pad = (ALIGN(res,calign)-((br_int_32)res));
ASSERT(actual_pad <= pad);
if(actual_pad > pad)
BR_FAILURE0("Memory allocator broke alignment");
res->class = res_class;
RES_SIZE_SET(res,size);
BrSimpleNewList(&res->children);
#if BR_RES_TAGGING
res->magic_num = BR_RES_MAGIC;
res->magic_ptr = res;
#endif
if(vparent) {
parent = UserToRes(vparent);
BR_SIMPLEADDHEAD(&parent->children,res);
}
/*
* Return pointer to used data
*/
return ResToUser(res);
}
/*
* Release a resource block - first calls BrResFree() for any child resources
*
* Removes resource from any parent list
*
* If the resource class has a destructor, that function is called
*/
STATIC void BrResInternalFree(struct resource_header *res, br_boolean callback)
{
int c;
void *r;
UASSERT(ISRESOURCE(res));
/*
* Ignore free requests on things that are already being freed
*/
if(res->class == BR_MEMORY_FREE)
return;
UASSERT(fw.resource_class_index[res->class] != NULL);
/*
* Remember class ID and mark object as being freed
*/
c = res->class;
r = ResToUser(res);
res->class = BR_MEMORY_FREE;
if(callback) {
/*
* Call class destructor
*/
if(fw.resource_class_index[c]->free_cb)
fw.resource_class_index[c]->free_cb(
r,(br_uint_8)c, RES_SIZE_GET(res));
}
/*
* Free any children
*/
while(BR_SIMPLEHEAD(&res->children))
BrResInternalFree((struct resource_header *)BR_SIMPLEREMOVE(BR_SIMPLEHEAD(&res->children)), BR_TRUE);
/*
* Remove from any parent list
*/
if(BR_SIMPLEINSERTED(res))
BR_SIMPLEREMOVE(res);
#if BR_RES_TAGGING
/*
* Make sure memory is no longer tagged as a resource
*/
res->magic_num = 1;
res->magic_ptr = NULL;
#endif
/*
* Release block
*/
BrMemFree(res);
}
/*
* Public entry for ResFree
*/
void BR_RESIDENT_ENTRY BrResFree(void *vres)
{
UASSERT(vres != NULL);
BrResInternalFree(UserToRes(vres), BR_TRUE);
}
void BR_RESIDENT_ENTRY BrResFreeNoCallback(void *vres)
{
UASSERT(vres != NULL);
BrResInternalFree(UserToRes(vres), BR_FALSE);
}
/*
* Add a resource as a child of another
*/
void * BR_RESIDENT_ENTRY BrResAdd(void *vparent, void *vres)
{
struct resource_header *res = UserToRes(vres);
struct resource_header *parent = UserToRes(vparent);
UASSERT(vres != NULL);
UASSERT(vparent != NULL);
UASSERT(ISRESOURCE(res));
UASSERT(ISRESOURCE(parent));
/*
* Remove from any parent list
*/
if(BR_SIMPLEINSERTED(res))
BR_SIMPLEREMOVE(res);
BR_SIMPLEADDHEAD(&parent->children,res);
return vres;
}
/*
* Remove resource from parent
*/
void * BR_RESIDENT_ENTRY BrResRemove(void *vres)
{
struct resource_header *res = UserToRes(vres);
UASSERT(vres != NULL);
UASSERT(ISRESOURCE(res));
BR_SIMPLEREMOVE(res);
return vres;
}
/*
* Return the class of a given resource
*/
br_uint_8 BR_RESIDENT_ENTRY BrResClass(void * vres)
{
struct resource_header *res = UserToRes(vres);
UASSERT(vres != NULL);
UASSERT(ISRESOURCE(res));
return res->class;
}
#if 0
/*
* Return the parent of a given resource
*/
void * BR_RESIDENT_ENTRY BrResParent(void * vres)
{
struct resource_header *res = UserToRes(vres);
UASSERT(vres != NULL);
UASSERT(ISRESOURCE(res));
return res->parent?ResToUser(res->parent):NULL;
}
#endif
/*
* Return the parent of a given resource
*/
br_boolean BR_RESIDENT_ENTRY BrResIsChild(void *vparent, void *vchild)
{
struct resource_header *parent = UserToRes(vparent);
struct resource_header *child = UserToRes(vchild);
struct resource_header *cp;
UASSERT(vparent != NULL);
UASSERT(vchild != NULL);
UASSERT(ISRESOURCE(parent));
UASSERT(ISRESOURCE(child));
BR_FOR_SIMPLELIST(&parent->children,cp)
if(cp == child)
return BR_TRUE;
return BR_FALSE;
}
/*
* Return the size of a given resource
*/
br_uint_32 BR_RESIDENT_ENTRY BrResSize(void *vres)
{
struct resource_header *res = UserToRes(vres);
UASSERT(vres != NULL);
UASSERT(ISRESOURCE(res));
return RES_SIZE_GET(res) - sizeof(struct resource_header);
}
/*
* Return the size of a resource, plus that of all it's children
*/
static br_uint_32 BR_CALLBACK ResSizeTotal(void *vres, br_uint_32 *ptotal)
{
/*
* Accumulate this size...
*/
ptotal += BrResSize(vres);
/*
* ...then add the sizes of all the children
*/
BrResChildEnum(vres, (br_resenum_cbfn *)ResSizeTotal, (void *)ptotal);
return 0;
}
br_uint_32 BR_RESIDENT_ENTRY BrResSizeTotal(void *vres)
{
br_uint_32 total = 0;
ResSizeTotal(vres, &total);
return total;
}
/*
* Invoke a callback for each of the children of a resource
*/
br_uint_32 BR_RESIDENT_ENTRY BrResChildEnum(void *vres, br_resenum_cbfn *callback, void *arg)
{
struct resource_header *res = UserToRes(vres);
struct resource_header *rp;
br_uint_32 r;
UASSERT(vres != NULL);
UASSERT(ISRESOURCE(res));
ASSERT(callback != NULL);
BR_FOR_SIMPLELIST(&res->children,rp)
if(r = callback(ResToUser(rp),arg))
return r;
return 0;
}
/*
* If tagging is enabled, then returns true if *vres is a resource
* block, otherwise returns no_tag
*/
br_uint_32 BR_RESIDENT_ENTRY BrResCheck(void *vres, int no_tag)
{
#if BR_RES_TAGGING
struct resource_header *res = UserToRes(vres);
return (res->magic_ptr == res) && (res->magic_num == BR_RES_MAGIC);
#else
return no_tag;
#endif
}
/*
* strdup() equivalent
*/
char * BR_RESIDENT_ENTRY BrResStrDup(void *vparent, char *str)
{
int l;
char *nstr;
UASSERT(str != NULL);
l = BrStrLen(str);
nstr = BrResAllocate(vparent,l+1,BR_MEMORY_STRING);
BrStrCpy(nstr,str);
return nstr;
}
#if DEBUG
/*
* Debug function that will dump a resource hierachy
*
* Invokes a callback with each text line of the dump
*/
STATIC void InternalResourceDump(struct resource_header *res, br_putline_cbfn *putline, void *arg, int level)
{
int i;
char *cp = BrScratchString();
struct resource_header *child;
br_resource_class *rclass;
/*
* Blank out first bit of line
*/
for(i=0; i< level*2; i++)
*cp++ = ' ';
/*
* Describe resource
*/
rclass= fw.resource_class_index[(unsigned char )res->class];
if(rclass == NULL) {
BrSprintf(cp, "0x%08x ??? (%02X)", res+1, res->class);
putline(BrScratchString(),arg);
return;
}
BrSprintf(cp, "0x%08x %-20s %d", ResToUser(res), rclass->identifier, RES_SIZE_GET(res));
putline(BrScratchString(),arg);
/*
* Display any children
*/
BR_FOR_SIMPLELIST(&res->children,child)
InternalResourceDump(child, putline, arg, level+1);
}
#endif
void BR_RESIDENT_ENTRY BrResDump(void *vres, br_putline_cbfn *putline, void *arg)
{
#if DEBUG
struct resource_header *res = UserToRes(vres);
InternalResourceDump(res, putline, arg, 0);
#endif
}
/*
* REturn the name for a resource class
*/
char * BR_RESIDENT_ENTRY BrResClassIdentifier(br_uint_8 res_class)
{
br_resource_class *rclass;
rclass = fw.resource_class_index[res_class];
return rclass?rclass->identifier:"<NULL>";
}

107
core/fw/resreg.c Normal file
View File

@ -0,0 +1,107 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: resreg.c 1.1 1997/12/10 16:41:10 jon Exp $
* $Locker: $
*
* Resource class management
*/
#include "fw.h"
#include "brassert.h"
BR_RCS_ID("$Id: resreg.c 1.1 1997/12/10 16:41:10 jon Exp $")
/*
* Resource Classes
*/
br_resource_class * BR_PUBLIC_ENTRY BrResClassAdd(br_resource_class *rclass)
{
br_resource_class *r;
UASSERT(rclass != NULL);
/*
* The registry resource is initally faked
*/
UASSERT(rclass->res_class == BR_MEMORY_REGISTRY ||
rclass->res_class == BR_MEMORY_ANCHOR ||
fw.resource_class_index[rclass->res_class] == NULL);
r = BrRegistryAdd(&fw.reg_resource_classes,rclass);
if(r != NULL)
fw.resource_class_index[rclass->res_class] = r;
return r; r;
}
br_resource_class * BR_PUBLIC_ENTRY BrResClassRemove(br_resource_class *rclass)
{
br_resource_class *r;
UASSERT(rclass != NULL);
UASSERT(fw.resource_class_index[rclass->res_class] != NULL);
r = BrRegistryRemove(&fw.reg_resource_classes,rclass);
if(r != NULL)
fw.resource_class_index[rclass->res_class] = NULL;
return r;
}
br_resource_class * BR_PUBLIC_ENTRY BrResClassFind(char *pattern)
{
return BrRegistryFind(&fw.reg_resource_classes,pattern);
}
br_resclass_find_cbfn * BR_PUBLIC_ENTRY BrResClassFindHook(br_resclass_find_cbfn *hook)
{
br_resclass_find_cbfn * old =
(br_resclass_find_cbfn *) fw.reg_resource_classes.find_failed_hook;
fw.reg_resource_classes.find_failed_hook = (br_find_failed_cbfn *)hook;
return old;
}
br_uint_32 BR_PUBLIC_ENTRY BrResClassAddMany(br_resource_class **items, int n)
{
int i;
for(i=0; i < n; i++)
BrResClassAdd(*items++);
return n;
}
br_uint_32 BR_PUBLIC_ENTRY BrResClassRemoveMany(br_resource_class **items, int n)
{
int i,r;
for(i=0, r=0; i < n; i++)
if(BrResClassRemove(*items++))
r++;
return r;
}
br_uint_32 BR_PUBLIC_ENTRY BrResClassFindMany(char *pattern, br_resource_class **items, int max)
{
return BrRegistryFindMany(&fw.reg_resource_classes, pattern, (void **)items, max);
}
br_uint_32 BR_PUBLIC_ENTRY BrResClassCount(char *pattern)
{
return BrRegistryCount(&fw.reg_resource_classes,pattern);
}
br_uint_32 BR_PUBLIC_ENTRY BrResClassEnum(char *pattern,
br_resclass_enum_cbfn *callback, void *arg)
{
return BrRegistryEnum(&fw.reg_resource_classes,pattern,(br_enum_cbfn *)callback,arg);
}

99
core/fw/scratch.c Normal file
View File

@ -0,0 +1,99 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: scratch.c 1.1 1997/12/10 16:41:10 jon Exp $
* $Locker: $
*
* Manage a temporary scratchpad for the rest of the system
*
* Will only allow 1 buffer to be allocated at any time
*/
#include "fw.h"
#include "brassert.h"
BR_RCS_ID("$Id: scratch.c 1.1 1997/12/10 16:41:10 jon Exp $")
/*
* Allocate a scratch buffer of the given size
*/
void *BR_RESIDENT_ENTRY BrScratchAllocate(br_size_t size)
{
if(fw.scratch_inuse)
BR_ERROR0("Scratchpad not available");
fw.scratch_last = size;
if(size > fw.scratch_size) {
if(fw.scratch_ptr)
BrResFree(fw.scratch_ptr);
fw.scratch_ptr = BrResAllocate(fw.res,size,BR_MEMORY_SCRATCH);
#if 0
fw.scratch_size = BrResSize(fw.scratch_ptr);
#else
fw.scratch_size = size;
#endif
}
fw.scratch_inuse = 1;
return fw.scratch_ptr;
}
/*
* Release a scratch buffer
*/
void BR_RESIDENT_ENTRY BrScratchFree(void *scratch)
{
UASSERT(fw.scratch_ptr == scratch);
fw.scratch_inuse = 0;
#if 0
BrResFree(fw.scratch_ptr);
fw.scratch_ptr = NULL;
fw.scratch_size = 0;
#endif
}
/*
* Free any allocated scratch buffer
*/
void BR_RESIDENT_ENTRY BrScratchFlush(void)
{
if(fw.scratch_inuse)
BR_ERROR0("Scratchpad cannot be flushed while in use");
if(fw.scratch_ptr)
BrResFree(fw.scratch_ptr);
fw.scratch_ptr = NULL;
fw.scratch_size = 0;
}
/*
* Find out how much scratch space is 'easily' available
*/
/*
* Initialised to a value because IBM Cset++ LIB hides the symbol
* otherwise ???
*/
static char scratchString[512] = "SCRATCH";
br_size_t BR_RESIDENT_ENTRY BrScratchInquire(void)
{
return fw.scratch_size;
}
char *BR_RESIDENT_ENTRY BrScratchString(void)
{
return scratchString;
}
br_size_t BR_RESIDENT_ENTRY BrScratchStringSize(void)
{
return BR_ASIZE(scratchString);
}

18
core/fw/scrstr.c Normal file
View File

@ -0,0 +1,18 @@
/*
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: scrstr.c 1.1 1997/12/10 16:41:10 jon Exp $
* $Locker: $
*
* A global scratchpad string used for printf and error operations
*/
#include "fw.h"
BR_RCS_ID("$Id: scrstr.c 1.1 1997/12/10 16:41:10 jon Exp $")
/*
* Initialised to a value because IBM Cset++ LIB hides the symbol
* otherwise ???
*/
char _br_scratch_string[512] = "SCRATCH";
br_size_t _br_scratch_string_size = BR_ASIZE(_br_scratch_string);

73
core/fw/shortcut.h Normal file
View File

@ -0,0 +1,73 @@
/*
* Copyright (c) 1992,1993-1995 Argonaut Technologies Limited. All rights reserved.
*
* $Id: shortcut.h 1.1 1997/12/10 16:41:10 jon Exp $
* $Locker: $
*
* Some shortcut macros to make matrix, euler, and quaternion access
* shorter to read
*/
/*
* Matrices
*/
#define M(x,y) mat->m[x][y]
#define A(x,y) A->m[x][y]
#define B(x,y) B->m[x][y]
#define C(x,y) C->m[x][y]
/*
* Quaternions
*/
#define lX (l->x)
#define lY (l->y)
#define lZ (l->z)
#define lW (l->w)
#define rX (r->x)
#define rY (r->y)
#define rZ (r->z)
#define rW (r->w)
#define qX (q->x)
#define qY (q->y)
#define qZ (q->z)
#define qW (q->w)
#define tX (t.x)
#define tY (t.y)
#define tZ (t.z)
#define tW (t.w)
#define qqX (qq->x)
#define qqY (qq->y)
#define qqZ (qq->z)
#define qqW (qq->w)
#define qi(c) (((br_scalar *)(q))[c])
/*
* Euler angles
*/
#define eX (euler->a)
#define eY (euler->b)
#define eZ (euler->c)
#define eO (euler->order)
/*
* Scalars
*/
#define S1 BR_SCALAR(1.0)
#define S0 BR_SCALAR(0.0)
/*
* For digging around in points etc - makes things slightly easier to read
*/
#define X 0
#define Y 1
#define Z 2
#define W 3
#define U 0
#define V 1

1129
core/fw/sys_conf.c Normal file
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More