304 lines
7.8 KiB
C
304 lines
7.8 KiB
C
/*
|
|
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
|
|
*
|
|
* $Id: Device.c 1.2 1997/07/23 15:51:17 jon Exp JON $
|
|
* $Locker: JON $
|
|
*
|
|
* Device methods
|
|
*/
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
|
|
#include "drv.h"
|
|
#include "brassert.h"
|
|
|
|
|
|
BR_RCS_ID("$Id: Device.c 1.2 1997/07/23 15:51:17 jon Exp JON $");
|
|
|
|
|
|
#define DEVICE_TITLE "Direct3D v1.0"
|
|
#define DEVICE_VERSION BR_VERSION(1,0,0)
|
|
#define DEVICE_CREATOR "Argonaut Technologies Ltd."
|
|
#define DEVICE_PRODUCT "Microsoft DirectX (tm)"
|
|
|
|
|
|
/*
|
|
* Default dispatch table for device (defined at end of file)
|
|
*/
|
|
static const struct br_device_dispatch deviceDispatch;
|
|
|
|
|
|
/*
|
|
* Device info. template
|
|
*/
|
|
static const char deviceTitle[] = DEVICE_TITLE;
|
|
static const char deviceCreator[] = DEVICE_CREATOR;
|
|
static const char deviceProduct[] = DEVICE_PRODUCT;
|
|
|
|
#define F(f) offsetof(br_device, f)
|
|
#define A(a) ((br_uint_32)(a))
|
|
|
|
static const struct br_tv_template_entry deviceTemplateEntries[] = {
|
|
|
|
{BRT_IDENTIFIER_CSTR, 0, F(identifier), BRTV_QUERY | BRTV_ALL, BRTV_CONV_COPY, },
|
|
{BRT_TITLE_CSTR, 0, 0, BRTV_QUERY | BRTV_ALL, BRTV_CONV_DIRECT, (br_uint_32)DEVICE_TITLE},
|
|
{BRT_VERSION_U32, 0, 0, BRTV_QUERY | BRTV_ALL, BRTV_CONV_DIRECT, DEVICE_VERSION},
|
|
{BRT_CREATOR_CSTR, 0, 0, BRTV_QUERY | BRTV_ALL, BRTV_CONV_DIRECT, (br_uint_32)DEVICE_CREATOR},
|
|
{BRT_PRODUCT_CSTR, 0, 0, BRTV_QUERY | BRTV_ALL, BRTV_CONV_DIRECT, (br_uint_32)DEVICE_PRODUCT},
|
|
{BRT_BRENDER_VERSION_U32, 0, 0, BRTV_QUERY | BRTV_ALL, BRTV_CONV_DIRECT, __BRENDER__},
|
|
{BRT_DDI_VERSION_U32, 0, 0, BRTV_QUERY | BRTV_ALL, BRTV_CONV_DIRECT, __BRENDER_DDI__},
|
|
};
|
|
|
|
#undef F
|
|
#undef A
|
|
|
|
|
|
/*
|
|
* List of tokens which are not significant in matching (for output facilities)
|
|
*/
|
|
br_token insignificantMatchTokens[] = {
|
|
|
|
BRT(WINDOW_HANDLE_H),
|
|
BR_NULL_TOKEN
|
|
};
|
|
|
|
|
|
/*
|
|
* Set up a static device object
|
|
*/
|
|
br_device *DeviceD3DAllocate(char *identifier, char *arguments)
|
|
{
|
|
br_device *self;
|
|
|
|
/*
|
|
* Set up device block and resource anchor
|
|
*/
|
|
self = BrResAllocate(NULL, sizeof(*self), BR_MEMORY_OBJECT);
|
|
|
|
self->identifier = identifier;
|
|
self->dispatch = (struct br_device_dispatch *)&deviceDispatch;
|
|
self->device = self;
|
|
|
|
self->object_list = BrObjectListAllocate(self);
|
|
|
|
/*
|
|
* Open the DirectDraw library
|
|
*/
|
|
self->ddraw = LoadLibrary("ddraw");
|
|
|
|
if (self->ddraw == NULL) {
|
|
ObjectFree(self);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Look up some DirectDraw global functions
|
|
*/
|
|
self->DirectDrawCreate = GetProcAddress(self->ddraw, "DirectDrawCreate");
|
|
self->DirectDrawEnumerate = GetProcAddress(self->ddraw, "DirectDrawEnumerateA");
|
|
|
|
if (self->DirectDrawCreate == NULL || self->DirectDrawEnumerate == NULL) {
|
|
ObjectFree(self);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Create device specific tokens
|
|
*/
|
|
BrTokenCreate("DIRECTDRAW_DEVICE_GUID", BRT_POINTER);
|
|
BrTokenCreate("DIRECTDRAW_DEVICE_NAME", BRT_CONSTANT_STRING);
|
|
BrTokenCreate("DIRECTDRAW_DEVICE_DESC", BRT_CONSTANT_STRING);
|
|
BrTokenCreate("DIRECTDRAW_HAL_CAPS", BRT_POINTER);
|
|
BrTokenCreate("DIRECTDRAW_HEL_CAPS", BRT_POINTER);
|
|
BrTokenCreate("DIRECTDRAW_SURFACE_DESC", BRT_POINTER);
|
|
BrTokenCreate("DIRECTDRAW_SURFACE", BRT_POINTER);
|
|
BrTokenCreate("DIRECT3D_DEVICE_GUID", BRT_POINTER);
|
|
BrTokenCreate("DIRECT3D_DEVICE_NAME", BRT_CONSTANT_STRING);
|
|
BrTokenCreate("DIRECT3D_DEVICE_DESC", BRT_CONSTANT_STRING);
|
|
BrTokenCreate("DIRECT3D_HAL_DESC", BRT_POINTER);
|
|
BrTokenCreate("DIRECT3D_HEL_DESC", BRT_POINTER);
|
|
BrTokenCreate("REFRESH_RATE", BRT_UINT_32);
|
|
|
|
/*
|
|
* Setup copy of CPU capabilities
|
|
*/
|
|
HostInfo(&self->hostInfo, sizeof(self->hostInfo));
|
|
|
|
return self;
|
|
}
|
|
|
|
static void BR_CMETHOD_DECL(br_device_d3d, free)(br_device *self)
|
|
{
|
|
/*
|
|
* Remove attached objects
|
|
*/
|
|
BrObjectContainerFree((br_object_container *)self, BR_NULL_TOKEN, NULL, NULL);
|
|
|
|
/*
|
|
* Close the DirectDraw library
|
|
*/
|
|
if (self->ddraw != NULL)
|
|
FreeLibrary(self->ddraw);
|
|
|
|
/*
|
|
* Throw away self and attached resources
|
|
*/
|
|
BrResFreeNoCallback(self);
|
|
}
|
|
|
|
static char * BR_CMETHOD_DECL(br_device_d3d, identifier)(br_device *self)
|
|
{
|
|
return self->identifier;
|
|
}
|
|
|
|
static br_token BR_CMETHOD_DECL(br_device_d3d, type)(br_device *self)
|
|
{
|
|
return BRT_DEVICE;
|
|
}
|
|
|
|
static br_boolean BR_CMETHOD_DECL(br_device_d3d, isType)(br_device *self, br_token t)
|
|
{
|
|
return (t == BRT_DEVICE) || (t == BRT_OBJECT_CONTAINER) || (t == BRT_OBJECT);
|
|
}
|
|
|
|
static br_device *BR_CMETHOD_DECL(br_device_d3d, device)(br_device *self)
|
|
{
|
|
return self;
|
|
}
|
|
|
|
static br_int_32 BR_CMETHOD_DECL(br_device_d3d, space)(br_device *self)
|
|
{
|
|
return sizeof(br_device);
|
|
}
|
|
|
|
static struct br_tv_template * BR_CMETHOD_DECL(br_device_d3d,templateQuery)
|
|
(br_device *self)
|
|
{
|
|
if(self->templates.deviceTemplate == NULL)
|
|
self->templates.deviceTemplate = BrTVTemplateAllocate(self,
|
|
(br_tv_template_entry *)deviceTemplateEntries,
|
|
BR_ASIZE(deviceTemplateEntries));
|
|
|
|
return self->templates.deviceTemplate;
|
|
}
|
|
|
|
static void * BR_CMETHOD_DECL(br_device_d3d,listQuery)(br_device *self)
|
|
{
|
|
return self->object_list;
|
|
}
|
|
|
|
|
|
/*
|
|
* 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_device_d3d, 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(self, 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_device_d3d, 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 BrTokenValueComparePartial(tm->original, tm->query, insignificantMatchTokens);
|
|
}
|
|
|
|
void BR_CMETHOD_DECL(br_device_d3d, tokensMatchEnd)
|
|
(struct br_object_container *self, void *arg)
|
|
{
|
|
if(arg)
|
|
BrResFree(arg);
|
|
}
|
|
|
|
|
|
/*
|
|
* Default dispatch table for device
|
|
*/
|
|
static const struct br_device_dispatch deviceDispatch = {
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
BR_CMETHOD_REF(br_device_d3d, free),
|
|
BR_CMETHOD_REF(br_device_d3d, identifier),
|
|
BR_CMETHOD_REF(br_device_d3d, type),
|
|
BR_CMETHOD_REF(br_device_d3d, isType),
|
|
BR_CMETHOD_REF(br_device_d3d, device),
|
|
BR_CMETHOD_REF(br_device_d3d, space),
|
|
|
|
BR_CMETHOD_REF(br_device_d3d, templateQuery),
|
|
BR_CMETHOD_REF(br_object, query),
|
|
BR_CMETHOD_REF(br_object, queryBuffer),
|
|
BR_CMETHOD_REF(br_object, queryMany),
|
|
BR_CMETHOD_REF(br_object, queryManySize),
|
|
BR_CMETHOD_REF(br_object, queryAll),
|
|
BR_CMETHOD_REF(br_object, queryAllSize),
|
|
|
|
BR_CMETHOD_REF(br_device_d3d, listQuery),
|
|
BR_CMETHOD_REF(br_device_d3d, tokensMatchBegin),
|
|
BR_CMETHOD_REF(br_device_d3d, tokensMatch),
|
|
BR_CMETHOD_REF(br_device_d3d, tokensMatchEnd),
|
|
BR_CMETHOD_REF(br_object_container, addFront),
|
|
BR_CMETHOD_REF(br_object_container, removeFront),
|
|
BR_CMETHOD_REF(br_object_container, remove),
|
|
BR_CMETHOD_REF(br_object_container, find),
|
|
BR_CMETHOD_REF(br_object_container, findMany),
|
|
BR_CMETHOD_REF(br_object_container, count),
|
|
};
|
|
|