505 lines
13 KiB
C
505 lines
13 KiB
C
/*
|
|
* Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
|
|
*
|
|
* Primitive state methods
|
|
*/
|
|
#include <stddef.h>
|
|
#include <string.h>
|
|
|
|
#include "drv.h"
|
|
#include "brassert.h"
|
|
|
|
|
|
/*
|
|
* Default dispatch table for primitive state (defined at end of file)
|
|
*/
|
|
static struct br_primitive_state_dispatch primitiveStateDispatch;
|
|
|
|
/*
|
|
* Primitive state info. template
|
|
*/
|
|
/*
|
|
* Shortcuts for template flags
|
|
*/
|
|
#define S BRTV_SET
|
|
#define Q BRTV_QUERY
|
|
#define A BRTV_ALL
|
|
|
|
#if BASED_FIXED
|
|
#define AX BRTV_ALL
|
|
#else
|
|
#define AX 0
|
|
#endif
|
|
|
|
#if BASED_FLOAT
|
|
#define AF BRTV_ALL
|
|
#else
|
|
#define AF 0
|
|
#endif
|
|
|
|
#define F(f) offsetof(struct br_primitive_state, f)
|
|
|
|
static struct br_tv_template_entry primitiveStateTemplateEntries[] = {
|
|
{BRT(IDENTIFIER_CSTR), F(identifier), Q | A, BRTV_CONV_COPY, },
|
|
{BRT(PARTS_TL), &PrimPartsTokensMyst, Q | A | BRTV_ABS, BRTV_CONV_LIST, },
|
|
};
|
|
#undef F
|
|
|
|
static struct br_tv_template primitiveStateTemplate = {
|
|
BR_ASIZE(primitiveStateTemplateEntries),
|
|
primitiveStateTemplateEntries
|
|
};
|
|
|
|
/*
|
|
* Set up a static device object
|
|
*/
|
|
struct br_primitive_state * PrimitiveStateMystAllocate(struct br_primitive_library *plib)
|
|
{
|
|
struct br_primitive_state * self;
|
|
|
|
self = BrResAllocate(DRIVER_RESOURCE, sizeof(*self), BR_MEMORY_OBJECT);
|
|
if(self == NULL)
|
|
return NULL;
|
|
|
|
self->plib = plib;
|
|
self->dispatch = &primitiveStateDispatch;
|
|
|
|
/* All of these left in, because they might be available on later upgrades */
|
|
self->prim.map_antialiasing = BRT_NONE;
|
|
self->prim.map_interpolation = BRT_NONE;
|
|
self->prim.mip_interpolation = BRT_NONE;
|
|
// self->prim.fog_type = BRT_LINEAR;
|
|
self->prim.fog_type = BRT_NONE;
|
|
self->prim.fog_colour = 0xff0000;
|
|
self->prim.fog_min = 256.0f;
|
|
self->prim.fog_max = 512.0f;
|
|
self->prim.alpha_on = BR_FALSE;
|
|
|
|
MystiqueInitConstantRanges(self);
|
|
|
|
/*
|
|
* Setup initial state
|
|
*/
|
|
ObjectContainerAddFront(plib,(br_object *)self);
|
|
|
|
return self;
|
|
}
|
|
|
|
static void BR_CMETHOD_DECL(br_primitive_state_mystique, free)(br_primitive_state *self)
|
|
{
|
|
ObjectContainerRemove(self->plib, (br_object *)self);
|
|
|
|
BrResFreeNoCallback(self);
|
|
}
|
|
|
|
static br_token BR_CMETHOD_DECL(br_primitive_state_mystique, type)(br_primitive_state *self)
|
|
{
|
|
return BRT_PRIMITIVE_STATE;
|
|
}
|
|
|
|
static br_boolean BR_CMETHOD_DECL(br_primitive_state_mystique, isType)(br_primitive_state *self, br_token t)
|
|
{
|
|
return (t == BRT_PRIMITIVE_STATE) || (t == BRT_OBJECT_CONTAINER) || (t == BRT_OBJECT);
|
|
}
|
|
|
|
static br_int_32 BR_CMETHOD_DECL(br_primitive_state_mystique, space)(br_primitive_state *self)
|
|
{
|
|
return sizeof(br_primitive_state);
|
|
}
|
|
|
|
static struct br_tv_template * BR_CMETHOD_DECL(br_primitive_state_mystique,templateQuery)
|
|
(br_primitive_state *self)
|
|
{
|
|
primitiveStateTemplate.res = DRIVER_RESOURCE;
|
|
return &primitiveStateTemplate;
|
|
}
|
|
|
|
/*
|
|
* Templates for state set/query
|
|
*/
|
|
#define F(f) offsetof(struct br_primitive_state, f)
|
|
|
|
static br_tv_template_entry primitiveTemplateEntries[] = {
|
|
{BRT(SMOOTH_B), F(prim.flags), Q | S | A, BRTV_CONV_BIT, PRIMF_SMOOTH, 1},
|
|
{BRT(PERSPECTIVE_B), F(prim.flags), Q | S | A, BRTV_CONV_BIT, PRIMF_PERSPECTIVE, 1},
|
|
{BRT(DECAL_B), F(prim.flags), Q | S | A, BRTV_CONV_BIT, PRIMF_DECAL, 1},
|
|
{BRT(DEPTH_WRITE_B), F(prim.flags), Q | S | A, BRTV_CONV_BIT, PRIMF_DEPTH_WRITE, 1},
|
|
{BRT(COLOUR_WRITE_B), F(prim.flags), Q | S | A, BRTV_CONV_BIT, PRIMF_COLOUR_WRITE, 1},
|
|
{BRT(BLEND_B), F(prim.flags), Q | S | A, BRTV_CONV_BIT, PRIMF_BLEND, 1},
|
|
{BRT(MODULATE_B), F(prim.flags), Q | S | A, BRTV_CONV_BIT, PRIMF_MODULATE, 1},
|
|
|
|
{BRT(COLOUR_T), F(prim.colour_type), Q | S | A, BRTV_CONV_COPY,0, 1},
|
|
{BRT(COLOUR_B), F(prim.colour_type), Q | S | A, BRTV_CONV_BOOL_TOKEN,BRT_DEFAULT, 1},
|
|
|
|
{BRT(COLOUR_MAP_O), F(prim.colour_map), Q | S | A, BRTV_CONV_COPY},
|
|
{BRT(TEXTURE_O), F(prim.colour_map), Q | S | A, BRTV_CONV_COPY},
|
|
|
|
{BRT(MAP_ANTIALIASING_T), F(prim.map_antialiasing), Q | A | S, BRTV_CONV_COPY},
|
|
{BRT(MAP_INTERPOLATION_T), F(prim.map_interpolation), Q | A | S, BRTV_CONV_COPY},
|
|
{BRT(MIP_INTERPOLATION_T), F(prim.mip_interpolation), Q | A | S, BRTV_CONV_COPY},
|
|
|
|
{BRT(FOG_T), F(prim.fog_type), Q | A | S, BRTV_CONV_COPY},
|
|
{BRT(FOG_RGB), F(prim.fog_colour), Q | A | S, BRTV_CONV_COPY},
|
|
{BRT(FOG_MIN_X), F(prim.fog_min), Q | A | S, BRTV_CONV_FIXED_FLOAT},
|
|
{BRT(FOG_MAX_X), F(prim.fog_max), Q | A | S, BRTV_CONV_FIXED_FLOAT},
|
|
{BRT(FOG_MIN_F), F(prim.fog_min), Q | A | S, BRTV_CONV_COPY},
|
|
{BRT(FOG_MAX_F), F(prim.fog_max), Q | A | S, BRTV_CONV_COPY},
|
|
{BRT(OPACITY_X), F(prim.alpha_val), Q | A | S, BRTV_CONV_FIXED_FLOAT},
|
|
{BRT(OPACITY_F), F(prim.alpha_val), Q | A | S, BRTV_CONV_COPY},
|
|
|
|
|
|
};
|
|
|
|
static br_tv_template primitiveTemplate = {
|
|
BR_ASIZE(primitiveTemplateEntries),
|
|
primitiveTemplateEntries
|
|
};
|
|
|
|
static br_tv_template_entry outputTemplateEntries[] = {
|
|
{BRT(COLOUR_BUFFER_O), F(out.colour), Q | S | A, BRTV_CONV_COPY},
|
|
{BRT(DEPTH_BUFFER_O), F(out.depth), Q | S | A, BRTV_CONV_COPY},
|
|
};
|
|
|
|
static br_tv_template outputTemplate = {
|
|
BR_ASIZE(outputTemplateEntries),
|
|
outputTemplateEntries
|
|
};
|
|
|
|
static br_tv_template *findTemplate(br_token part)
|
|
{
|
|
switch(part) {
|
|
case BRT_PRIMITIVE:
|
|
return &primitiveTemplate;
|
|
case BRT_OUTPUT:
|
|
return &outputTemplate;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static br_error BR_CMETHOD_DECL(br_primitive_state_mystique, partSet)(
|
|
struct br_primitive_state *self,
|
|
br_token part,
|
|
br_int_32 index,
|
|
br_token t,
|
|
br_uint_32 value)
|
|
{
|
|
br_error r;
|
|
br_tv_template *tp = findTemplate(part);
|
|
br_uint_32 m;
|
|
|
|
/*
|
|
* If the part was unknown, punt
|
|
*/
|
|
if(tp == NULL)
|
|
return BRE_DEV_FAIL;
|
|
|
|
/*
|
|
* Do the set...
|
|
*/
|
|
m = 0;
|
|
r = BrTokenValueSet(self, &m, t, value, tp);
|
|
|
|
/*
|
|
* If unrecognised, no changes
|
|
*/
|
|
if(r != BRE_OK)
|
|
return r;
|
|
|
|
/*
|
|
* Update timestamps
|
|
*/
|
|
switch(part) {
|
|
case BRT_PRIMITIVE:
|
|
self->prim.timestamp = Timestamp();
|
|
if(m)
|
|
self->prim.timestamp_major = Timestamp();
|
|
break;
|
|
|
|
case BRT_OUTPUT:
|
|
self->out.timestamp = Timestamp();
|
|
if(m)
|
|
self->out.timestamp_major = Timestamp();
|
|
break;
|
|
}
|
|
|
|
return BRE_OK;
|
|
}
|
|
|
|
static br_error BR_CMETHOD_DECL(br_primitive_state_mystique, partSetMany)(
|
|
struct br_primitive_state *self,
|
|
br_token part,
|
|
br_int_32 index,
|
|
br_token_value * tv,
|
|
br_int_32 *pcount)
|
|
{
|
|
br_error r;
|
|
br_tv_template *tp = findTemplate(part);
|
|
br_uint_32 m;
|
|
br_int_32 c;
|
|
|
|
/*
|
|
* If the part was unknown, punt
|
|
*/
|
|
if(tp == NULL)
|
|
return BRE_DEV_FAIL;
|
|
|
|
/*
|
|
* Do the set...
|
|
*/
|
|
m = 0;
|
|
r = BrTokenValueSetMany(self, &c, &m, tv, tp);
|
|
|
|
/*
|
|
* If unrecognised, no changes
|
|
*/
|
|
if(r != BRE_OK || c == 0)
|
|
return r;
|
|
|
|
/*
|
|
* Pass count back on to caller
|
|
*/
|
|
if(pcount)
|
|
*pcount = c;
|
|
|
|
/*
|
|
* Update timestamps
|
|
*/
|
|
switch(part) {
|
|
case BRT_PRIMITIVE:
|
|
self->prim.timestamp = Timestamp();
|
|
if(m)
|
|
self->prim.timestamp_major = Timestamp();
|
|
break;
|
|
|
|
case BRT_OUTPUT:
|
|
self->out.timestamp = Timestamp();
|
|
if(m)
|
|
self->out.timestamp_major = Timestamp();
|
|
break;
|
|
}
|
|
|
|
return BRE_OK;
|
|
}
|
|
|
|
static br_error BR_CMETHOD_DECL(br_primitive_state_mystique, partQuery)(
|
|
struct br_primitive_state *self,
|
|
br_token part,
|
|
br_int_32 index,
|
|
br_uint_32 *pvalue,
|
|
br_token t)
|
|
{
|
|
br_tv_template *tp = findTemplate(part);
|
|
|
|
if(tp == NULL)
|
|
return BRE_DEV_FAIL;
|
|
|
|
return BrTokenValueQuery(pvalue, NULL, NULL, t, self, tp);
|
|
}
|
|
|
|
static br_error BR_CMETHOD_DECL(br_primitive_state_mystique, partQueryBuffer)(
|
|
struct br_primitive_state *self,
|
|
br_token part,
|
|
br_int_32 index,
|
|
br_uint_32 *pvalue,
|
|
br_uint_32 *buffer,
|
|
br_size_t buffer_size,
|
|
br_token t)
|
|
{
|
|
br_tv_template *tp = findTemplate(part);
|
|
|
|
if(tp == NULL)
|
|
return BRE_DEV_FAIL;
|
|
|
|
return BrTokenValueQuery(pvalue, buffer, buffer_size, t, self, tp);
|
|
}
|
|
|
|
static br_error BR_CMETHOD_DECL(br_primitive_state_mystique, partQueryMany)(
|
|
struct br_primitive_state *self,
|
|
br_token part,
|
|
br_int_32 index,
|
|
br_token_value *tv,
|
|
void *extra,
|
|
br_size_t extra_size,
|
|
br_int_32 *pcount)
|
|
{
|
|
br_tv_template *tp = findTemplate(part);
|
|
|
|
if(tp == NULL)
|
|
return BRE_DEV_FAIL;
|
|
|
|
return BrTokenValueQueryMany(tv, extra, extra_size, pcount, self, tp);
|
|
}
|
|
|
|
static br_error BR_CMETHOD_DECL(br_primitive_state_mystique, partQueryManySize)(
|
|
struct br_primitive_state *self,
|
|
br_token part,
|
|
br_int_32 index,
|
|
br_size_t *pextra_size,
|
|
br_token_value *tv)
|
|
{
|
|
br_tv_template *tp = findTemplate(part);
|
|
|
|
if(tp == NULL)
|
|
return BRE_DEV_FAIL;
|
|
|
|
return BrTokenValueQueryManySize(pextra_size, tv, self, tp);
|
|
}
|
|
|
|
static br_error BR_CMETHOD_DECL(br_primitive_state_mystique, partQueryAll)(
|
|
struct br_primitive_state *self,
|
|
br_token part,
|
|
br_int_32 index,
|
|
br_token_value *buffer,
|
|
br_size_t buffer_size)
|
|
{
|
|
br_tv_template *tp = findTemplate(part);
|
|
|
|
if(tp == NULL)
|
|
return BRE_DEV_FAIL;
|
|
|
|
return BrTokenValueQueryAll(buffer, buffer_size, self, tp);
|
|
}
|
|
|
|
static br_error BR_CMETHOD_DECL(br_primitive_state_mystique, partQueryAllSize)(
|
|
struct br_primitive_state *self,
|
|
br_token part,
|
|
br_int_32 index,
|
|
br_size_t *psize)
|
|
{
|
|
br_tv_template *tp = findTemplate(part);
|
|
|
|
if(tp == NULL)
|
|
return BRE_DEV_FAIL;
|
|
|
|
return BrTokenValueQueryAllSize(psize, self, tp);
|
|
}
|
|
|
|
static br_error BR_CMETHOD_DECL(br_primitive_state_mystique, partIndexQuery)(
|
|
struct br_primitive_state *self,
|
|
br_token part,
|
|
br_int_32 *pnindex)
|
|
{
|
|
int n;
|
|
|
|
switch(part) {
|
|
case BRT_OUTPUT:
|
|
case BRT_PRIMITIVE:
|
|
n = 1;
|
|
break;
|
|
|
|
default:
|
|
n = 0;
|
|
}
|
|
|
|
if(pnindex) {
|
|
*pnindex = n;
|
|
return BRE_OK;
|
|
} else {
|
|
return BRE_DEV_FAIL;
|
|
}
|
|
|
|
}
|
|
|
|
static br_error BR_CMETHOD_DECL(br_primitive_state_mystique, stateDefault)(
|
|
struct br_primitive_state *self,
|
|
br_uint_32 mask)
|
|
{
|
|
/*
|
|
* Clear everything down
|
|
*
|
|
* Could use inputSet and OutputSet?
|
|
*/
|
|
if(mask & MASK_STATE_PRIMITIVE) {
|
|
self->prim.flags = PRIMF_COLOUR_WRITE | PRIMF_DEPTH_WRITE;
|
|
self->prim.colour_map = NULL;
|
|
self->prim.colour_type = BRT_DEFAULT;
|
|
|
|
self->prim.timestamp = Timestamp();
|
|
self->prim.timestamp_major = Timestamp();
|
|
}
|
|
|
|
if(mask & MASK_STATE_OUTPUT) {
|
|
self->out.colour = NULL;
|
|
self->out.depth = NULL;
|
|
|
|
self->out.timestamp = Timestamp();
|
|
self->out.timestamp_major = Timestamp();
|
|
}
|
|
|
|
return BRE_OK;
|
|
}
|
|
|
|
|
|
static br_error BR_CMETHOD_DECL(br_primitive_state_mystique, stateCopy)(
|
|
struct br_primitive_state *self,
|
|
struct br_primitive_state *source,
|
|
br_uint_32 mask)
|
|
{
|
|
if((mask & MASK_STATE_PRIMITIVE) && (self->prim.timestamp != source->prim.timestamp))
|
|
self->prim = source->prim;
|
|
|
|
if((mask & MASK_STATE_OUTPUT) && ((self->out.timestamp != source->out.timestamp) ||
|
|
(self->out.colour->pm_base_x != source->out.colour->pm_base_x) ||
|
|
(self->out.colour->pm_base_y != source->out.colour->pm_base_y)
|
|
) )
|
|
self->out = source->out;
|
|
|
|
if((mask & MASK_STATE_CACHE) &&
|
|
((self->cache.timestamp_prim != source->cache.timestamp_prim) ||
|
|
(self->cache.timestamp_out != source->cache.timestamp_out) ||
|
|
(self->cache.last_type != source->cache.last_type)))
|
|
self->cache = source->cache;
|
|
|
|
return BRE_OK;
|
|
}
|
|
|
|
|
|
|
|
void PrimitiveStateMystClearTemplates(void)
|
|
{
|
|
CLEAR_TEMPLATE(primitiveState);
|
|
CLEAR_TEMPLATE(output);
|
|
CLEAR_TEMPLATE(primitive);
|
|
}
|
|
|
|
/*
|
|
* Default dispatch table for device
|
|
*/
|
|
static struct br_primitive_state_dispatch primitiveStateDispatch = {
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, free),
|
|
BR_CMETHOD_REF(br_object_mystique, identifier),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, type),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, isType),
|
|
BR_CMETHOD_REF(br_object_mystique, device),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, space),
|
|
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, 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_primitive_state_mystique, partSet),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, partSetMany),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, partQuery),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, partQueryBuffer),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, partQueryMany),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, partQueryManySize),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, partQueryAll),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, partQueryAllSize),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, partIndexQuery),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, stateDefault),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, stateCopy),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, renderBegin),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, renderEnd),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, rangesQueryF),
|
|
BR_CMETHOD_REF(br_primitive_state_mystique, rangesQueryX),
|
|
};
|
|
|