random-mirrors/librw
1
0
Fork 0
mirror of https://github.com/aap/librw.git synced 2024-11-25 05:05:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

using proper types

Browse Source
This commit is contained in:
aap 2017-08-05 01:44:37 +02:00
parent 9a26a380a8
commit 4653f7e81e
14 changed files with 155 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/d3d/d3d8.cpp
View File

@ -378,7 +378,7 @@ defaultInstanceCB(Geometry *geo, InstanceData *inst)
} }
for(int32 i = 0; i < geo->numTexCoordSets; i++){ for(int32 i = 0; i < geo->numTexCoordSets; i++){
instV2d(VERT_FLOAT2, dst, &geo->texCoords[i][2*inst->minVert], instTexCoords(VERT_FLOAT2, dst, &geo->texCoords[i][2*inst->minVert],
inst->numVertices, inst->stride); inst->numVertices, inst->stride);
dst += 8; dst += 8;
} }
@ -409,7 +409,7 @@ defaultUninstanceCB(Geometry *geo, InstanceData *inst)
} }
for(int32 i = 0; i < geo->numTexCoordSets; i++){ for(int32 i = 0; i < geo->numTexCoordSets; i++){
uninstV2d(VERT_FLOAT2, &geo->texCoords[i][2*inst->minVert], src, uninstTexCoords(VERT_FLOAT2, &geo->texCoords[i][2*inst->minVert], src,
inst->numVertices, inst->stride); inst->numVertices, inst->stride);
src += 8; src += 8;
} }

4
src/d3d/d3d9.cpp
View File

@ -506,7 +506,7 @@ defaultInstanceCB(Geometry *geo, InstanceDataHeader *header)
for(int32 n = 0; n < geo->numTexCoordSets; n++){ for(int32 n = 0; n < geo->numTexCoordSets; n++){
for(i = 0; dcl[i].usage != D3DDECLUSAGE_TEXCOORD || dcl[i].usageIndex != n; i++) for(i = 0; dcl[i].usage != D3DDECLUSAGE_TEXCOORD || dcl[i].usageIndex != n; i++)
; ;
instV2d(vertFormatMap[dcl[i].type], verts + dcl[i].offset, instTexCoords(vertFormatMap[dcl[i].type], verts + dcl[i].offset,
geo->texCoords[n], geo->texCoords[n],
header->totalNumVertex, header->totalNumVertex,
header->vertexStream[dcl[i].stream].stride); header->vertexStream[dcl[i].stream].stride);
@ -554,7 +554,7 @@ defaultUninstanceCB(Geometry *geo, InstanceDataHeader *header)
for(int32 n = 0; n < geo->numTexCoordSets; n++){ for(int32 n = 0; n < geo->numTexCoordSets; n++){
for(i = 0; dcl[i].usage != D3DDECLUSAGE_TEXCOORD || dcl[i].usageIndex != n; i++) for(i = 0; dcl[i].usage != D3DDECLUSAGE_TEXCOORD || dcl[i].usageIndex != n; i++)
; ;
uninstV2d(vertFormatMap[dcl[i].type], uninstTexCoords(vertFormatMap[dcl[i].type],
geo->texCoords[n], geo->texCoords[n],
verts[dcl[i].stream] + dcl[i].offset, verts[dcl[i].stream] + dcl[i].offset,
header->totalNumVertex, header->totalNumVertex,

4
src/d3d/xbox.cpp
View File

@ -321,7 +321,7 @@ defaultInstanceCB(Geometry *geo, InstanceDataHeader *header)
sel = (fmt >> (i*4 + 8)) & 0xF; sel = (fmt >> (i*4 + 8)) & 0xF;
if(sel == 0) if(sel == 0)
break; break;
instV2d(v2dFormatMap[sel], dst, geo->texCoords[i], instTexCoords(v2dFormatMap[sel], dst, geo->texCoords[i],
header->numVertices, header->stride); header->numVertices, header->stride);
dst += sel == 4 ? 4 : 2*vertexFormatSizes[sel]; dst += sel == 4 ? 4 : 2*vertexFormatSizes[sel];
} }
@ -360,7 +360,7 @@ defaultUninstanceCB(Geometry *geo, InstanceDataHeader *header)
sel = (fmt >> (i*4 + 8)) & 0xF; sel = (fmt >> (i*4 + 8)) & 0xF;
if(sel == 0) if(sel == 0)
break; break;
uninstV2d(v2dFormatMap[sel], geo->texCoords[i], src, uninstTexCoords(v2dFormatMap[sel], geo->texCoords[i], src,
header->numVertices, header->stride); header->numVertices, header->stride);
src += sel == 4 ? 4 : 2*vertexFormatSizes[sel]; src += sel == 4 ? 4 : 2*vertexFormatSizes[sel];
} }

36
src/geometry.cpp
View File

@ -40,11 +40,11 @@ Geometry::create(int32 numVerts, int32 numTris, uint32 flags)
geo->triangles = nil; geo->triangles = nil;
if(!(geo->flags & NATIVE) && geo->numVertices){ if(!(geo->flags & NATIVE) && geo->numVertices){
if(geo->flags & PRELIT) if(geo->flags & PRELIT)
geo->colors = new uint8[4*geo->numVertices]; geo->colors = new RGBA[geo->numVertices];
if((geo->flags & TEXTURED) || (geo->flags & TEXTURED2)) if((geo->flags & TEXTURED) || (geo->flags & TEXTURED2))
for(int32 i = 0; i < geo->numTexCoordSets; i++) for(int32 i = 0; i < geo->numTexCoordSets; i++)
geo->texCoords[i] = geo->texCoords[i] =
new float32[2*geo->numVertices]; new TexCoords[geo->numVertices];
geo->triangles = new Triangle[geo->numTriangles]; geo->triangles = new Triangle[geo->numTriangles];
} }
geo->morphTargets = new MorphTarget[1]; geo->morphTargets = new MorphTarget[1];
@ -54,9 +54,9 @@ Geometry::create(int32 numVerts, int32 numTris, uint32 flags)
m->vertices = nil; m->vertices = nil;
m->normals = nil; m->normals = nil;
if(!(geo->flags & NATIVE) && geo->numVertices){ if(!(geo->flags & NATIVE) && geo->numVertices){
m->vertices = new float32[3*geo->numVertices]; m->vertices = new V3d[geo->numVertices];
if(geo->flags & NORMALS) if(geo->flags & NORMALS)
m->normals = new float32[3*geo->numVertices]; m->normals = new V3d[geo->numVertices];
} }
geo->matList.init(); geo->matList.init();
geo->meshHeader = nil; geo->meshHeader = nil;
@ -275,9 +275,9 @@ Geometry::addMorphTargets(int32 n)
m->vertices = nil; m->vertices = nil;
m->normals = nil; m->normals = nil;
if(!(this->flags & NATIVE)){ if(!(this->flags & NATIVE)){
m->vertices = new float32[3*this->numVertices]; m->vertices = new V3d[this->numVertices];
if(this->flags & NORMALS) if(this->flags & NORMALS)
m->normals = new float32[3*this->numVertices]; m->normals = new V3d[this->numVertices];
} }
} }
this->numMorphTargets += n; this->numMorphTargets += n;
@ -290,15 +290,15 @@ Geometry::calculateBoundingSphere(void)
MorphTarget *m = &this->morphTargets[i]; MorphTarget *m = &this->morphTargets[i];
V3d min { 1000000.0f, 1000000.0f, 1000000.0f }; V3d min { 1000000.0f, 1000000.0f, 1000000.0f };
V3d max { -1000000.0f, -1000000.0f, -1000000.0f }; V3d max { -1000000.0f, -1000000.0f, -1000000.0f };
float32 *v = m->vertices; V3d *v = m->vertices;
for(int32 j = 0; j < this->numVertices; j++){ for(int32 j = 0; j < this->numVertices; j++){
if(v[0] > max.x) max.x = v[0]; if(v->x > max.x) max.x = v->x;
if(v[0] < min.x) min.x = v[0]; if(v->x < min.x) min.x = v->x;
if(v[1] > max.y) max.y = v[1]; if(v->y > max.y) max.y = v->y;
if(v[1] < min.y) min.y = v[1]; if(v->y < min.y) min.y = v->y;
if(v[2] > max.z) max.z = v[2]; if(v->z > max.z) max.z = v->z;
if(v[2] < min.z) min.z = v[2]; if(v->z < min.z) min.z = v->z;
v += 3; v++;
} }
m->boundingSphere.center = scale(add(min, max), 1/2.0f); m->boundingSphere.center = scale(add(min, max), 1/2.0f);
max = sub(max, m->boundingSphere.center); max = sub(max, m->boundingSphere.center);
@ -322,15 +322,15 @@ void
Geometry::allocateData(void) Geometry::allocateData(void)
{ {
if(this->flags & PRELIT) if(this->flags & PRELIT)
this->colors = new uint8[4*this->numVertices]; this->colors = new RGBA[this->numVertices];
if((this->flags & TEXTURED) || (this->flags & TEXTURED2)) if((this->flags & TEXTURED) || (this->flags & TEXTURED2))
for(int32 i = 0; i < this->numTexCoordSets; i++) for(int32 i = 0; i < this->numTexCoordSets; i++)
this->texCoords[i] = this->texCoords[i] =
new float32[2*this->numVertices]; new TexCoords[this->numVertices];
MorphTarget *m = this->morphTargets; MorphTarget *m = this->morphTargets;
m->vertices = new float32[3*this->numVertices]; m->vertices = new V3d[this->numVertices];
if(this->flags & NORMALS) if(this->flags & NORMALS)
m->normals = new float32[3*this->numVertices]; m->normals = new V3d[this->numVertices];
// TODO: morph targets (who cares anyway?) // TODO: morph targets (who cares anyway?)
} }

2
src/gl/gl3pipe.cpp
View File

@ -205,7 +205,7 @@ defaultInstanceCB(Geometry *geo, InstanceDataHeader *header)
for(int32 n = 0; n < geo->numTexCoordSets; n++){ for(int32 n = 0; n < geo->numTexCoordSets; n++){
for(a = attribs; a->index != ATTRIB_TEXCOORDS0+n; a++) for(a = attribs; a->index != ATTRIB_TEXCOORDS0+n; a++)
; ;
instV2d(VERT_FLOAT2, verts + a->offset, instTexCoords(VERT_FLOAT2, verts + a->offset,
geo->texCoords[n], geo->texCoords[n],
header->totalNumVertex, a->stride); header->totalNumVertex, a->stride);
} }

7
src/gl/gl3plugins.cpp
View File

@ -382,7 +382,7 @@ skinInstanceCB(Geometry *geo, InstanceDataHeader *header)
for(int32 n = 0; n < geo->numTexCoordSets; n++){ for(int32 n = 0; n < geo->numTexCoordSets; n++){
for(a = attribs; a->index != ATTRIB_TEXCOORDS0+n; a++) for(a = attribs; a->index != ATTRIB_TEXCOORDS0+n; a++)
; ;
instV2d(VERT_FLOAT2, verts + a->offset, instTexCoords(VERT_FLOAT2, verts + a->offset,
geo->texCoords[n], geo->texCoords[n],
header->totalNumVertex, a->stride); header->totalNumVertex, a->stride);
} }
@ -390,8 +390,9 @@ skinInstanceCB(Geometry *geo, InstanceDataHeader *header)
// Weights // Weights
for(a = attribs; a->index != ATTRIB_WEIGHTS; a++) for(a = attribs; a->index != ATTRIB_WEIGHTS; a++)
; ;
float *w = skin->weights;
instV4d(VERT_FLOAT4, verts + a->offset, instV4d(VERT_FLOAT4, verts + a->offset,
skin->weights, (V4d*)w,
header->totalNumVertex, a->stride); header->totalNumVertex, a->stride);
// Indices // Indices
@ -399,7 +400,7 @@ skinInstanceCB(Geometry *geo, InstanceDataHeader *header)
; ;
// not really colors of course but what the heck // not really colors of course but what the heck
instColor(VERT_RGBA, verts + a->offset, instColor(VERT_RGBA, verts + a->offset,
skin->indices, (RGBA*)skin->indices,
header->totalNumVertex, a->stride); header->totalNumVertex, a->stride);
glGenBuffers(1, &header->vbo); glGenBuffers(1, &header->vbo);

62
src/gl/wdgl.cpp
View File

@ -395,20 +395,20 @@ instance(rw::ObjPipeline *rwpipe, Atomic *atomic)
a[i].stride = offset; a[i].stride = offset;
uint8 *p = header->data + a->offset; uint8 *p = header->data + a->offset;
float32 *vert = geo->morphTargets->vertices; V3d *vert = geo->morphTargets->vertices;
for(int32 i = 0; i < geo->numVertices; i++){ for(int32 i = 0; i < geo->numVertices; i++){
packattrib(p, vert, a); packattrib(p, (float32*)vert, a);
vert += 3; vert++;
p += a->stride; p += a->stride;
} }
a++; a++;
if(geo->numTexCoordSets){ if(geo->numTexCoordSets){
p = header->data + a->offset; p = header->data + a->offset;
float32 *texcoord = geo->texCoords[0]; TexCoords *texcoord = geo->texCoords[0];
for(int32 i = 0; i < geo->numVertices; i++){ for(int32 i = 0; i < geo->numVertices; i++){
packattrib(p, texcoord, a, 512.0f); packattrib(p, (float32*)texcoord, a, 512.0f);
texcoord += 2; texcoord++;
p += a->stride; p += a->stride;
} }
a++; a++;
@ -416,10 +416,10 @@ instance(rw::ObjPipeline *rwpipe, Atomic *atomic)
if(geo->flags & Geometry::NORMALS){ if(geo->flags & Geometry::NORMALS){
p = header->data + a->offset; p = header->data + a->offset;
float32 *norm = geo->morphTargets->normals; V3d *norm = geo->morphTargets->normals;
for(int32 i = 0; i < geo->numVertices; i++){ for(int32 i = 0; i < geo->numVertices; i++){
packattrib(p, norm, a); packattrib(p, (float32*)norm, a);
norm += 3; norm++;
p += a->stride; p += a->stride;
} }
a++; a++;
@ -428,15 +428,15 @@ instance(rw::ObjPipeline *rwpipe, Atomic *atomic)
if(geo->flags & Geometry::PRELIT){ if(geo->flags & Geometry::PRELIT){
// TODO: this seems too complicated // TODO: this seems too complicated
p = header->data + a->offset; p = header->data + a->offset;
uint8 *color = geo->colors; RGBA *color = geo->colors;
float32 f[4]; float32 f[4];
for(int32 i = 0; i < geo->numVertices; i++){ for(int32 i = 0; i < geo->numVertices; i++){
f[0] = color[0]/255.0f; f[0] = color->red/255.0f;
f[1] = color[1]/255.0f; f[1] = color->green/255.0f;
f[2] = color[2]/255.0f; f[2] = color->blue/255.0f;
f[3] = color[3]/255.0f; f[3] = color->alpha/255.0f;
packattrib(p, f, a); packattrib(p, (float32*)f, a);
color += 4; color++;
p += a->stride; p += a->stride;
} }
a++; a++;
@ -457,10 +457,10 @@ uninstance(rw::ObjPipeline *rwpipe, Atomic *atomic)
geo->allocateData(); geo->allocateData();
uint8 *p; uint8 *p;
float32 *texcoord = geo->texCoords[0]; TexCoords *texcoord = geo->texCoords[0];
uint8 *color = geo->colors; RGBA *color = geo->colors;
float32 *vert = geo->morphTargets->vertices; V3d *vert = geo->morphTargets->vertices;
float32 *norm = geo->morphTargets->normals; V3d *norm = geo->morphTargets->normals;
float32 f[4]; float32 f[4];
InstanceDataHeader *header = (InstanceDataHeader*)geo->instData; InstanceDataHeader *header = (InstanceDataHeader*)geo->instData;
@ -471,24 +471,24 @@ uninstance(rw::ObjPipeline *rwpipe, Atomic *atomic)
switch(a->index){ switch(a->index){
case 0: // Vertices case 0: // Vertices
for(int32 i = 0; i < geo->numVertices; i++){ for(int32 i = 0; i < geo->numVertices; i++){
unpackattrib(vert, p, a); unpackattrib((float32*)vert, p, a);
vert += 3; vert++;
p += a->stride; p += a->stride;
} }
break; break;
case 1: // texCoords case 1: // texCoords
for(int32 i = 0; i < geo->numVertices; i++){ for(int32 i = 0; i < geo->numVertices; i++){
unpackattrib(texcoord, p, a, 512.0f); unpackattrib((float32*)texcoord, p, a, 512.0f);
texcoord += 2; texcoord++;
p += a->stride; p += a->stride;
} }
break; break;
case 2: // normals case 2: // normals
for(int32 i = 0; i < geo->numVertices; i++){ for(int32 i = 0; i < geo->numVertices; i++){
unpackattrib(norm, p, a); unpackattrib((float32*)norm, p, a);
norm += 3; norm++;
p += a->stride; p += a->stride;
} }
break; break;
@ -497,11 +497,11 @@ uninstance(rw::ObjPipeline *rwpipe, Atomic *atomic)
for(int32 i = 0; i < geo->numVertices; i++){ for(int32 i = 0; i < geo->numVertices; i++){
// TODO: this seems too complicated // TODO: this seems too complicated
unpackattrib(f, p, a); unpackattrib(f, p, a);
color[0] = f[0]*255.0f; color->red = f[0]*255.0f;
color[1] = f[1]*255.0f; color->green = f[1]*255.0f;
color[2] = f[2]*255.0f; color->blue = f[2]*255.0f;
color[3] = f[3]*255.0f; color->alpha = f[3]*255.0f;
color += 4; color++;
p += a->stride; p += a->stride;
} }
break; break;

72
src/pipeline.cpp
View File

@ -52,48 +52,48 @@ findMinVertAndNumVertices(uint16 *indices, uint32 numIndices, uint32 *minVert, i
} }
void void
instV4d(int type, uint8 *dst, float *src, uint32 numVertices, uint32 stride) instV4d(int type, uint8 *dst, V4d *src, uint32 numVertices, uint32 stride)
{ {
if(type == VERT_FLOAT4) if(type == VERT_FLOAT4)
for(uint32 i = 0; i < numVertices; i++){ for(uint32 i = 0; i < numVertices; i++){
memcpy(dst, src, 16); memcpy(dst, src, 16);
dst += stride; dst += stride;
src += 4; src++;
} }
else else
assert(0 && "unsupported instV3d type"); assert(0 && "unsupported instV4d type");
} }
void void
instV3d(int type, uint8 *dst, float *src, uint32 numVertices, uint32 stride) instV3d(int type, uint8 *dst, V3d *src, uint32 numVertices, uint32 stride)
{ {
if(type == VERT_FLOAT3) if(type == VERT_FLOAT3)
for(uint32 i = 0; i < numVertices; i++){ for(uint32 i = 0; i < numVertices; i++){
memcpy(dst, src, 12); memcpy(dst, src, 12);
dst += stride; dst += stride;
src += 3; src++;
} }
else if(type == VERT_COMPNORM) else if(type == VERT_COMPNORM)
for(uint32 i = 0; i < numVertices; i++){ for(uint32 i = 0; i < numVertices; i++){
uint32 n = ((((uint32)(src[2] * 511.0f)) & 0x3ff) << 22) | uint32 n = ((((uint32)(src->z * 511.0f)) & 0x3ff) << 22) |
((((uint32)(src[1] * 1023.0f)) & 0x7ff) << 11) | ((((uint32)(src->y * 1023.0f)) & 0x7ff) << 11) |
((((uint32)(src[0] * 1023.0f)) & 0x7ff) << 0); ((((uint32)(src->x * 1023.0f)) & 0x7ff) << 0);
*(uint32*)dst = n; *(uint32*)dst = n;
dst += stride; dst += stride;
src += 3; src++;
} }
else else
assert(0 && "unsupported instV3d type"); assert(0 && "unsupported instV3d type");
} }
void void
uninstV3d(int type, float *dst, uint8 *src, uint32 numVertices, uint32 stride) uninstV3d(int type, V3d *dst, uint8 *src, uint32 numVertices, uint32 stride)
{ {
if(type == VERT_FLOAT3) if(type == VERT_FLOAT3)
for(uint32 i = 0; i < numVertices; i++){ for(uint32 i = 0; i < numVertices; i++){
memcpy(dst, src, 12); memcpy(dst, src, 12);
src += stride; src += stride;
dst += 3; dst++;
} }
else if(type == VERT_COMPNORM) else if(type == VERT_COMPNORM)
for(uint32 i = 0; i < numVertices; i++){ for(uint32 i = 0; i < numVertices; i++){
@ -106,63 +106,63 @@ uninstV3d(int type, float *dst, uint8 *src, uint32 numVertices, uint32 stride)
if(normal[0] & 0x400) normal[0] |= ~0x7FF; if(normal[0] & 0x400) normal[0] |= ~0x7FF;
if(normal[1] & 0x400) normal[1] |= ~0x7FF; if(normal[1] & 0x400) normal[1] |= ~0x7FF;
if(normal[2] & 0x200) normal[2] |= ~0x3FF; if(normal[2] & 0x200) normal[2] |= ~0x3FF;
dst[0] = normal[0] / 1023.0f; dst->x = normal[0] / 1023.0f;
dst[1] = normal[1] / 1023.0f; dst->y = normal[1] / 1023.0f;
dst[2] = normal[2] / 511.0f; dst->z = normal[2] / 511.0f;
src += stride; src += stride;
dst += 3; dst++;
} }
else else
assert(0 && "unsupported uninstV3d type"); assert(0 && "unsupported uninstV3d type");
} }
void void
instV2d(int type, uint8 *dst, float *src, uint32 numVertices, uint32 stride) instTexCoords(int type, uint8 *dst, TexCoords *src, uint32 numVertices, uint32 stride)
{ {
assert(type == VERT_FLOAT2); assert(type == VERT_FLOAT2);
for(uint32 i = 0; i < numVertices; i++){ for(uint32 i = 0; i < numVertices; i++){
memcpy(dst, src, 8); memcpy(dst, src, 8);
dst += stride; dst += stride;
src += 2; src++;
} }
} }
void void
uninstV2d(int type, float *dst, uint8 *src, uint32 numVertices, uint32 stride) uninstTexCoords(int type, TexCoords *dst, uint8 *src, uint32 numVertices, uint32 stride)
{ {
assert(type == VERT_FLOAT2); assert(type == VERT_FLOAT2);
for(uint32 i = 0; i < numVertices; i++){ for(uint32 i = 0; i < numVertices; i++){
memcpy(dst, src, 8); memcpy(dst, src, 8);
src += stride; src += stride;
dst += 2; dst++;
} }
} }
bool32 bool32
instColor(int type, uint8 *dst, uint8 *src, uint32 numVertices, uint32 stride) instColor(int type, uint8 *dst, RGBA *src, uint32 numVertices, uint32 stride)
{ {
bool32 hasAlpha = 0; bool32 hasAlpha = 0;
if(type == VERT_ARGB){ if(type == VERT_ARGB){
for(uint32 i = 0; i < numVertices; i++){ for(uint32 i = 0; i < numVertices; i++){
dst[0] = src[2]; dst[0] = src->blue;
dst[1] = src[1]; dst[1] = src->green;
dst[2] = src[0]; dst[2] = src->red;
dst[3] = src[3]; dst[3] = src->alpha;
if(dst[3] != 0xFF) if(dst[3] != 0xFF)
hasAlpha = 1; hasAlpha = 1;
dst += stride; dst += stride;
src += 4; src++;
} }
}else if(type == VERT_RGBA){ }else if(type == VERT_RGBA){
for(uint32 i = 0; i < numVertices; i++){ for(uint32 i = 0; i < numVertices; i++){
dst[0] = src[0]; dst[0] = src->red;
dst[1] = src[1]; dst[1] = src->green;
dst[2] = src[2]; dst[2] = src->blue;
dst[3] = src[3]; dst[3] = src->alpha;
if(dst[3] != 0xFF) if(dst[3] != 0xFF)
hasAlpha = 1; hasAlpha = 1;
dst += stride; dst += stride;
src += 4; src++;
} }
}else }else
assert(0 && "unsupported color type"); assert(0 && "unsupported color type");
@ -170,16 +170,16 @@ instColor(int type, uint8 *dst, uint8 *src, uint32 numVertices, uint32 stride)
} }
void void
uninstColor(int type, uint8 *dst, uint8 *src, uint32 numVertices, uint32 stride) uninstColor(int type, RGBA *dst, uint8 *src, uint32 numVertices, uint32 stride)
{ {
assert(type == VERT_ARGB); assert(type == VERT_ARGB);
for(uint32 i = 0; i < numVertices; i++){ for(uint32 i = 0; i < numVertices; i++){
dst[0] = src[2]; dst->red = src[2];
dst[1] = src[1]; dst->green = src[1];
dst[2] = src[0]; dst->blue = src[0];
dst[3] = src[3]; dst->alpha = src[3];
src += stride; src += stride;
dst += 4; dst++;
} }
} }

62
src/ps2/ps2.cpp
View File

@ -400,14 +400,14 @@ uint32*
instanceNormal(uint32 *wp, Geometry *g, Mesh *m, uint32 idx, uint32 n) instanceNormal(uint32 *wp, Geometry *g, Mesh *m, uint32 idx, uint32 n)
{ {
uint16 j; uint16 j;
float *d = g->morphTargets[0].normals; V3d *d = g->morphTargets[0].normals;
uint8 *p = (uint8*)wp; uint8 *p = (uint8*)wp;
if((g->flags & Geometry::NORMALS)) if((g->flags & Geometry::NORMALS))
for(uint32 i = idx; i < idx+n; i++){ for(uint32 i = idx; i < idx+n; i++){
j = m->indices[i]; j = m->indices[i];
*p++ = d[j*3+0]*127.0f; *p++ = d[j].x*127.0f;
*p++ = d[j*3+1]*127.0f; *p++ = d[j].y*127.0f;
*p++ = d[j*3+2]*127.0f; *p++ = d[j].z*127.0f;
} }
else else
for(uint32 i = idx; i < idx+n; i++){ for(uint32 i = idx; i < idx+n; i++){
@ -872,57 +872,19 @@ ObjPipeline::ObjPipeline(uint32 platform)
this->impl.uninstance = objUninstance; this->impl.uninstance = objUninstance;
} }
/*
int32
findVertex(Geometry *g, uint32 flags[], uint32 mask, Vertex *v)
{
float32 *verts = g->morphTargets[0].vertices;
float32 *tex = g->texCoords[0];
float32 *tex1 = g->texCoords[1];
float32 *norms = g->morphTargets[0].normals;
uint8 *cols = g->colors;
for(int32 i = 0; i < g->numVertices; i++){
if(mask & flags[i] & 0x1 &&
!(verts[0] == v->p[0] && verts[1] == v->p[1] && verts[2] == v->p[2]))
goto cont;
if(mask & flags[i] & 0x10 &&
!(norms[0] == v->n[0] && norms[1] == v->n[1] && norms[2] == v->n[2]))
goto cont;
if(mask & flags[i] & 0x100 &&
!(cols[0] == v->c[0] && cols[1] == v->c[1] && cols[2] == v->c[2] && cols[3] == v->c[3]))
goto cont;
if(mask & flags[i] & 0x1000 &&
!(tex[0] == v->t[0] && tex[1] == v->t[1]))
goto cont;
if(mask & flags[i] & 0x2000 &&
!(tex1[0] == v->t1[0] && tex1[1] == v->t1[1]))
goto cont;
return i;
cont:
verts += 3;
tex += 2;
tex1 += 2;
norms += 3;
cols += 4;
}
return -1;
}
*/
void void
insertVertex(Geometry *geo, int32 i, uint32 mask, Vertex *v) insertVertex(Geometry *geo, int32 i, uint32 mask, Vertex *v)
{ {
if(mask & 0x1) if(mask & 0x1)
memcpy(&geo->morphTargets[0].vertices[i*3], v->p, 12); geo->morphTargets[0].vertices[i] = v->p;
if(mask & 0x10) if(mask & 0x10)
memcpy(&geo->morphTargets[0].normals[i*3], v->n, 12); geo->morphTargets[0].normals[i] = v->n;
if(mask & 0x100) if(mask & 0x100)
memcpy(&geo->colors[i*4], v->c, 4); geo->colors[i] = v->c;
if(mask & 0x1000) if(mask & 0x1000)
memcpy(&geo->texCoords[0][i*2], v->t, 8); geo->texCoords[0][i] = v->t;
if(mask & 0x2000) if(mask & 0x2000)
memcpy(&geo->texCoords[1][i*2], v->t1, 8); geo->texCoords[1][i] = v->t1;
} }
void void
@ -983,9 +945,9 @@ genericUninstanceCB(MatPipeline *pipe, Geometry *geo, uint32 flags[], Mesh *mesh
memcpy(&v.p, xyz ? xyz : xyzw, 12); memcpy(&v.p, xyz ? xyz : xyzw, 12);
if(mask & 0x10){ if(mask & 0x10){
// TODO: figure out scaling :/ // TODO: figure out scaling :/
v.n[0] = normals[0]/128.0f; v.n.x = normals[0]/128.0f;
v.n[1] = normals[1]/128.0f; v.n.y = normals[1]/128.0f;
v.n[2] = normals[2]/128.0f; v.n.z = normals[2]/128.0f;
} }
if(mask & 0x100) if(mask & 0x100)
memcpy(&v.c, rgba, 4); memcpy(&v.c, rgba, 4);

34
src/ps2/ps2skin.cpp
View File

@ -202,28 +202,23 @@ findVertexSkin(Geometry *g, uint32 flags[], uint32 mask, Vertex *v)
inds = skin->indices; inds = skin->indices;
} }
float32 *verts = g->morphTargets[0].vertices; V3d *verts = g->morphTargets[0].vertices;
float32 *tex = g->texCoords[0]; TexCoords *tex = g->texCoords[0];
float32 *tex1 = g->texCoords[1]; TexCoords *tex1 = g->texCoords[1];
float32 *norms = g->morphTargets[0].normals; V3d *norms = g->morphTargets[0].normals;
uint8 *cols = g->colors; RGBA *cols = g->colors;
for(int32 i = 0; i < g->numVertices; i++){ for(int32 i = 0; i < g->numVertices; i++){
uint32 flag = flags ? flags[i] : ~0; uint32 flag = flags ? flags[i] : ~0;
if(mask & flag & 0x1 && if(mask & flag & 0x1 && !equal(*verts, v->p))
!(verts[0] == v->p[0] && verts[1] == v->p[1] && verts[2] == v->p[2]))
goto cont; goto cont;
if(mask & flag & 0x10 && if(mask & flag & 0x10 && !equal(*norms, v->n))
!(norms[0] == v->n[0] && norms[1] == v->n[1] && norms[2] == v->n[2]))
goto cont; goto cont;
if(mask & flag & 0x100 && if(mask & flag & 0x100 && !equal(*cols, v->c))
!(cols[0] == v->c[0] && cols[1] == v->c[1] && cols[2] == v->c[2] && cols[3] == v->c[3]))
goto cont; goto cont;
if(mask & flag & 0x1000 && if(mask & flag & 0x1000 && !equal(*tex, v->t))
!(tex[0] == v->t[0] && tex[1] == v->t[1]))
goto cont; goto cont;
if(mask & flag & 0x2000 && if(mask & flag & 0x2000 && !equal(*tex1, v->t1))
!(tex1[0] == v->t1[0] && tex1[1] == v->t1[1]))
goto cont; goto cont;
if(mask & flag & 0x10000 && if(mask & flag & 0x10000 &&
!(wghts[0] == v->w[0] && wghts[1] == v->w[1] && !(wghts[0] == v->w[0] && wghts[1] == v->w[1] &&
@ -233,10 +228,11 @@ findVertexSkin(Geometry *g, uint32 flags[], uint32 mask, Vertex *v)
goto cont; goto cont;
return i; return i;
cont: cont:
verts += 3; verts++;
tex += 2; tex++;
norms += 3; tex1++;
cols += 4; norms++;
cols++;
wghts += 4; wghts += 4;
inds += 4; inds += 4;
} }

10
src/ps2/rwps2.h
View File

@ -121,11 +121,11 @@ public:
}; };
struct Vertex { struct Vertex {
float32 p[3]; V3d p;
float32 t[2]; TexCoords t;
float32 t1[2]; TexCoords t1;
uint8 c[4]; RGBA c;
float32 n[3]; V3d n;
// skin // skin
float32 w[4]; float32 w[4];
uint8 i[4]; uint8 i[4];

16
src/rwbase.h
View File

@ -55,6 +55,7 @@ struct RGBA
uint8 blue; uint8 blue;
uint8 alpha; uint8 alpha;
}; };
inline bool32 equal(const RGBA &c1, const RGBA &c2) { return c1.red == c2.red && c1.green == c2.green && c1.blue == c2.blue && c1.alpha == c2.alpha; }
struct RGBAf struct RGBAf
{ {
@ -63,6 +64,7 @@ struct RGBAf
float32 blue; float32 blue;
float32 alpha; float32 alpha;
}; };
inline bool32 equal(const RGBAf &c1, const RGBAf &c2) { return c1.red == c2.red && c1.green == c2.green && c1.blue == c2.blue && c1.alpha == c2.alpha; }
inline void convColor(RGBA *i, RGBAf *f){ inline void convColor(RGBA *i, RGBAf *f){
int32 c; int32 c;
@ -83,6 +85,12 @@ inline void convColor(RGBAf *f, RGBA *i){
f->alpha = i->alpha/255.0f; f->alpha = i->alpha/255.0f;
} }
struct TexCoords
{
float32 u, v;
};
inline bool32 equal(const TexCoords &t1, const TexCoords &t2) { return t1.u == t2.u && t1.v == t2.v; }
struct V2d; struct V2d;
struct V3d; struct V3d;
struct Quat; struct Quat;
@ -96,6 +104,7 @@ struct V2d
}; };
inline V2d makeV2d(float32 x, float32 y) { V2d v = { x, y }; return v; } inline V2d makeV2d(float32 x, float32 y) { V2d v = { x, y }; return v; }
inline bool32 equal(const V2d &v1, const V2d &v2) { return v1.x == v2.x && v1.y == v2.y; }
inline V2d neg(const V2d &a) { return makeV2d(-a.x, -a.y); } inline V2d neg(const V2d &a) { return makeV2d(-a.x, -a.y); }
inline V2d add(const V2d &a, const V2d &b) { return makeV2d(a.x+b.x, a.y+b.y); } inline V2d add(const V2d &a, const V2d &b) { return makeV2d(a.x+b.x, a.y+b.y); }
inline V2d sub(const V2d &a, const V2d &b) { return makeV2d(a.x-b.x, a.y-b.y); } inline V2d sub(const V2d &a, const V2d &b) { return makeV2d(a.x-b.x, a.y-b.y); }
@ -113,6 +122,7 @@ struct V3d
}; };
inline V3d makeV3d(float32 x, float32 y, float32 z) { V3d v = { x, y, z }; return v; } inline V3d makeV3d(float32 x, float32 y, float32 z) { V3d v = { x, y, z }; return v; }
inline bool32 equal(const V3d &v1, const V3d &v2) { return v1.x == v2.x && v1.y == v2.y && v1.z == v2.z; }
inline V3d neg(const V3d &a) { return makeV3d(-a.x, -a.y, -a.z); } inline V3d neg(const V3d &a) { return makeV3d(-a.x, -a.y, -a.z); }
inline V3d add(const V3d &a, const V3d &b) { return makeV3d(a.x+b.x, a.y+b.y, a.z+b.z); } inline V3d add(const V3d &a, const V3d &b) { return makeV3d(a.x+b.x, a.y+b.y, a.z+b.z); }
inline V3d sub(const V3d &a, const V3d &b) { return makeV3d(a.x-b.x, a.y-b.y, a.z-b.z); } inline V3d sub(const V3d &a, const V3d &b) { return makeV3d(a.x-b.x, a.y-b.y, a.z-b.z); }
@ -128,6 +138,12 @@ inline V3d lerp(const V3d &a, const V3d &b, float32 r){
a.z + r*(b.z - a.z)); a.z + r*(b.z - a.z));
}; };
struct V4d
{
float32 x, y, z, w;
};
inline bool32 equal(const V4d &v1, const V4d &v2) { return v1.x == v2.x && v1.y == v2.y && v1.z == v2.z && v1.w == v2.w; }
Quat makeQuat(float32 w, float32 x, float32 y, float32 z); Quat makeQuat(float32 w, float32 x, float32 y, float32 z);
Quat makeQuat(float32 w, const V3d &vec); Quat makeQuat(float32 w, const V3d &vec);

8
src/rwobjects.h
View File

@ -360,8 +360,8 @@ struct MeshHeader
struct MorphTarget struct MorphTarget
{ {
Sphere boundingSphere; Sphere boundingSphere;
float32 *vertices; V3d *vertices;
float32 *normals; V3d *normals;
}; };
struct InstanceDataHeader struct InstanceDataHeader
@ -401,8 +401,8 @@ struct Geometry : PluginBase<Geometry>
int32 numTexCoordSets; int32 numTexCoordSets;
Triangle *triangles; Triangle *triangles;
uint8 *colors; RGBA *colors;
float32 *texCoords[8]; TexCoords *texCoords[8];
MorphTarget *morphTargets; MorphTarget *morphTargets;
MaterialList matList; MaterialList matList;

14
src/rwpipeline.h
View File

@ -47,12 +47,12 @@ enum {
VERT_COMPNORM VERT_COMPNORM
}; };
void instV4d(int type, uint8 *dst, float *src, uint32 numVertices, uint32 stride); void instV4d(int type, uint8 *dst, V4d *src, uint32 numVertices, uint32 stride);
void instV3d(int type, uint8 *dst, float *src, uint32 numVertices, uint32 stride); void instV3d(int type, uint8 *dst, V3d *src, uint32 numVertices, uint32 stride);
void uninstV3d(int type, float *dst, uint8 *src, uint32 numVertices, uint32 stride); void uninstV3d(int type, V3d *dst, uint8 *src, uint32 numVertices, uint32 stride);
void instV2d(int type, uint8 *dst, float *src, uint32 numVertices, uint32 stride); void instTexCoords(int type, uint8 *dst, TexCoords *src, uint32 numVertices, uint32 stride);
void uninstV2d(int type, float *dst, uint8 *src, uint32 numVertices, uint32 stride); void uninstTexCoords(int type, TexCoords *dst, uint8 *src, uint32 numVertices, uint32 stride);
bool32 instColor(int type, uint8 *dst, uint8 *src, uint32 numVertices, uint32 stride); bool32 instColor(int type, uint8 *dst, RGBA *src, uint32 numVertices, uint32 stride);
void uninstColor(int type, uint8 *dst, uint8 *src, uint32 numVertices, uint32 stride); void uninstColor(int type, RGBA *dst, uint8 *src, uint32 numVertices, uint32 stride);
} }