static int PubCamera_viewrect(PState state,PubFunction_t *f, int n)
{
static lxMatrix44SIMD mat;
Reference ref;
int axis;
float dist;
float t;
lxVector3 rays[4];
Camera_t *cam;
List3DNode_t *l3dcam;
int i;
if (n!=3 || 3!=FunctionPublish_getArg(state,3,LUXI_CLASS_L3D_CAMERA,&ref,LUXI_CLASS_INT,&axis,LUXI_CLASS_FLOAT,&dist) ||
!Reference_get(ref,l3dcam))
return FunctionPublish_returnError(state,"1 l3dcamera 1 int(0-2) 1 float required.");
cam = l3dcam->cam;
lxVector3Set(rays[0],0,1,0);
lxMatrix44Identity(mat);
lxVector3Set(rays[1],cam->fov/g_Window.ratio,0,-cam->fov);
lxMatrix44FromEulerZYXdeg(mat,rays[1]);
lxMatrix44VectorRotate(mat,rays[0]);
lxVector3Set(rays[1],-rays[0][0],rays[0][1], rays[0][2]);
lxVector3Set(rays[2],-rays[0][0],rays[0][1],-rays[0][2]);
lxVector3Set(rays[3], rays[0][0],rays[0][1],-rays[0][2]);
// rays set, now transform
for (i = 0; i < 4; i++)
lxMatrix44VectorRotate(cam->finalMatrix,rays[i]);
// hittest with plane
for (i = 0; i < 4; i++){
if (!rays[i][axis])
return 0;
// t * ray + cam.pos = axis*dist
t = (dist - cam->pos[axis])/rays[i][axis];
if (t < 0)
return 0;
lxVector3ScaledAdd(rays[i],cam->pos,t,rays[i]);
}
return FunctionPublish_setRet(state,12,FNPUB_FROMVECTOR3(rays[0]),FNPUB_FROMVECTOR3(rays[1]),FNPUB_FROMVECTOR3(rays[2]),FNPUB_FROMVECTOR3(rays[3]));
}
List2DNode_t *List2DNode_new(const char *name)
{
List2DNode_t *node = genzallocSIMD(sizeof(List2DNode_t));
LUX_SIMDASSERT(((size_t)((List2DNode_t*)node)->finalMatrix) % 16 == 0);
lxVector4Set(node->color,1,1,1,1);
lxVector3Set(node->scale, 1, 1, 1);
lxListNode_init(node);
node->type = LUXI_CLASS_L2D_NODE;
node->parent = NULL;
if (name)
gennewstrcpy(node->name,name);
lxMatrix44IdentitySIMD(node->finalScaled);
lxMatrix44IdentitySIMD(node->finalMatrix);
return node;
}
// TODO a second function using SSE
static int PubStaticFloatArray_prop_FPU(PState pstate,PubFunction_t *fn, int n)
{
StaticArray_t *self,*a,*b;
Reference ref;
int i;
int index;
float *pOut;
float *pPos;
float f;
int valint;
lxVector4 vec4;
switch ((StaticArrayUp_t)fn->upvalue)
{
case VA_VEC3:
{
FNPUB_CHECKOUTREF(pstate,n,0,LUXI_CLASS_FLOATARRAY,ref,self);
FNPUB_CHECKOUT(pstate,n,1,LUXI_CLASS_INT,index);
if (index<0 || index>=self->count/3)
return FunctionPublish_returnErrorf(pstate,"index out of bounds (%i/%i)",
index,self->count/3);
pOut = &self->floats[3*index];
if (n==2){
return FunctionPublish_setRet(pstate,3,FNPUB_FROMVECTOR3(pOut));
}
else if (3!= FunctionPublish_getArgOffset(pstate,2,3,FNPUB_TOVECTOR3(pOut)))
return FunctionPublish_returnError(pstate,"1 floatarray 1 index 3 floats required");
return 0;
}
case VA_VEC3_ALL:
{
FNPUB_CHECKOUTREF(pstate,n,0,LUXI_CLASS_FLOATARRAY,ref,self);
index = 0;
valint = 0;
i = 65536;
if (3>FunctionPublish_getArgOffset(pstate,1,6,FNPUB_TOVECTOR3(vec4),LUXI_CLASS_INT,(void*)&index,LUXI_CLASS_INT,(void*)&i,LUXI_CLASS_INT,(void*)&valint))
return FunctionPublish_returnError(pstate,"1 floatarray 3 floats [1 int] required");
pOut = self->floats + index;
pPos = LUX_MIN(self->floats + self->count,pOut+(i*(3+ valint)));
for (;pOut < pPos; pOut+=(3+valint)){
lxVector3Copy(pOut,vec4);
}
return 0;
}
case VA_VEC4_ALL:
{
FNPUB_CHECKOUTREF(pstate,n,0,LUXI_CLASS_FLOATARRAY,ref,self);
index = 0;
valint = 0;
i = 65536;
if (4>FunctionPublish_getArgOffset(pstate,1,7,FNPUB_TOVECTOR4(vec4),LUXI_CLASS_INT,(void*)&index,LUXI_CLASS_INT,(void*)&i,LUXI_CLASS_INT,(void*)&valint))
return FunctionPublish_returnError(pstate,"1 floatarray 4 floats [1 int] required");
pOut = self->floats + index;
pPos = LUX_MIN(self->floats + self->count,pOut+(i*(4+ valint)));
for (;pOut < pPos; pOut+=(4+valint)){
lxVector4Copy(pOut,vec4);
}
return 0;
}
case VA_VEC4:
{
FNPUB_CHECKOUTREF(pstate,n,0,LUXI_CLASS_FLOATARRAY,ref,self);
FNPUB_CHECKOUT(pstate,n,1,LUXI_CLASS_INT,index);
if (index<0 || index>=self->count/4)
return FunctionPublish_returnErrorf(pstate,"index out of bounds (%i/%i)",
index,self->count/4);
pOut = &self->floats[4*index];
if (n==2){
return FunctionPublish_setRet(pstate,4,FNPUB_FROMVECTOR4(pOut));
}
else if (4!= FunctionPublish_getArgOffset(pstate,2,4,FNPUB_TOVECTOR4(pOut)))
return FunctionPublish_returnError(pstate,"1 floatarray 1 index 4 floats required");
return 0;
}
case VA_LERP:
{
float fracc;
float step;
float lrp;
int outcount;
int incount;
FNPUB_CHECKOUTREF(pstate,n,0,LUXI_CLASS_FLOATARRAY,ref,self);
FNPUB_CHECKOUTREF(pstate,n,1,LUXI_CLASS_FLOATARRAY,ref,a);
incount = outcount = a->count;
FunctionPublish_getNArg(pstate,2,LUXI_CLASS_INT,(void*)&incount);
incount = LUX_MIN(outcount,incount);
outcount = self->count;
if (outcount <= incount || incount < 2)
return FunctionPublish_returnError(pstate,"not enough floats given, need at least 2");
step = 1.0f/(float)(incount-1);
fracc = 1.0f/(float)(outcount-1);
pOut = self->floats;
pPos = a->floats;
f = 0;
for (i = 0; i < outcount; i++, pOut++,f+=fracc){
if (f > step){
f-=step;
pPos++;
}
lrp = f/step;
*pOut = LUX_LERP(lrp,*pPos,*(pPos+1));
}
return 0;
}
case VA_LERP3:
{
float fracc;
float step;
float lrp;
int outcount;
int incount;
FNPUB_CHECKOUTREF(pstate,n,0,LUXI_CLASS_FLOATARRAY,ref,self);
FNPUB_CHECKOUTREF(pstate,n,1,LUXI_CLASS_FLOATARRAY,ref,a);
incount = outcount = a->count/3;
FunctionPublish_getNArg(pstate,2,LUXI_CLASS_INT,(void*)&incount);
incount = LUX_MIN(outcount,incount);
outcount = self->count/3;
if (outcount <= incount || incount < 2)
return FunctionPublish_returnError(pstate,"not enough floats given, need at least 6");
step = 1.0f/(float)(incount-1);
fracc = 1.0f/(float)(outcount-1);
pOut = self->floats;
pPos = a->floats;
f = 0;
for (i = 0; i < outcount; i++, pOut+=3,f+=fracc){
if (f > step){
f-=step;
pPos+=3;
}
lrp = f/step;
lxVector3Lerp(pOut,lrp,pPos,pPos+3);
}
return 0;
}
case VA_LERP4:
{
float fracc;
float step;
float lrp;
int outcount;
int incount;
FNPUB_CHECKOUTREF(pstate,n,0,LUXI_CLASS_FLOATARRAY,ref,self);
FNPUB_CHECKOUTREF(pstate,n,1,LUXI_CLASS_FLOATARRAY,ref,a);
incount = outcount = a->count/4;
FunctionPublish_getNArg(pstate,2,LUXI_CLASS_INT,(void*)&incount);
incount = LUX_MIN(outcount,incount);
outcount = self->count/4;
if (outcount <= incount || incount < 2)
return FunctionPublish_returnError(pstate,"not enough floats given, need at least 8");
step = 1.0f/(float)(incount-1);
fracc = 1.0f/(float)(outcount-1);
pOut = self->floats;
pPos = a->floats;
f = 0;
for (i = 0; i < outcount; i++, pOut+=4,f+=fracc){
if (f > step){
f-=step;
pPos+=4;
}
lrp = f/step;
lxVector4Lerp(pOut,lrp,pPos,pPos+4);
}
return 0;
}
case VA_SPLINE4:
{
lxVector4 startvec,endvec;
float fracc;
float step;
float lrp;
float *endpos;
float *startpos;
int outcount;
int incount;
FNPUB_CHECKOUTREF(pstate,n,0,LUXI_CLASS_FLOATARRAY,ref,self);
FNPUB_CHECKOUTREF(pstate,n,1,LUXI_CLASS_FLOATARRAY,ref,a);
incount = outcount = a->count/4;
FunctionPublish_getNArg(pstate,2,LUXI_CLASS_INT,(void*)&incount);
incount = LUX_MIN(outcount,incount);
outcount = self->count/4;
if (outcount <= incount || incount < 2)
return FunctionPublish_returnError(pstate,"not enough vectors given, need at least 2");
pPos = &a->floats[4];
lxVector4Sub(startvec,pPos,pPos-4);
lxVector4Sub(startvec,pPos-4,startvec);
pPos = &a->floats[4*(incount-1)];
lxVector4Sub(endvec,pPos,pPos-4);
lxVector4Add(endvec,pPos,endvec);
step = 1.0f/(float)(incount-1);
fracc = 1.0f/(float)(outcount-1);
pOut = self->floats;
pPos = a->floats;
index = 0;
f = 0;
startpos = startvec;
endpos = (index < incount-1) ? pPos+8 : endvec;
for (i = 0; i < outcount-1; i++, pOut+=4,f+=fracc){
if (f > step){
f-=step;
pPos+=3;
index++;
endpos = (index < incount-2) ? pPos+8 : endvec;
startpos = pPos-4;
}
lrp = f/step;
lxVector4CatmullRom(pOut,lrp,startpos,pPos,pPos+4,endpos);
}
lxVector4Copy(pOut,pPos+4);
return 0;
}
case VA_SPLINE3:
{
lxVector3 startvec,endvec;
float fracc;
float step;
float lrp;
float *endpos;
float *startpos;
int outcount;
int incount;
FNPUB_CHECKOUTREF(pstate,n,0,LUXI_CLASS_FLOATARRAY,ref,self);
FNPUB_CHECKOUTREF(pstate,n,1,LUXI_CLASS_FLOATARRAY,ref,a);
incount = outcount = a->count/3;
FunctionPublish_getNArg(pstate,2,LUXI_CLASS_INT,(void*)&incount);
incount = LUX_MIN(outcount,incount);
outcount = self->count/3;
if (outcount <= incount || incount < 2)
return FunctionPublish_returnError(pstate,"not enough vectors given, need at least 2");
pPos = &a->floats[3];
lxVector3Sub(startvec,pPos,pPos-3);
lxVector3Sub(startvec,pPos-3,startvec);
pPos = &a->floats[3*(incount-1)];
lxVector3Sub(endvec,pPos,pPos-3);
lxVector3Add(endvec,pPos,endvec);
step = 1.0f/(float)(incount-1);
fracc = 1.0f/(float)(outcount-1);
pOut = self->floats;
pPos = a->floats;
index = 0;
f = 0;
startpos = startvec;
endpos = (index < incount-1) ? pPos+6 : endvec;
for (i = 0; i < outcount-1; i++, pOut+=3,f+=fracc){
if (f > step){
f-=step;
pPos+=3;
index++;
endpos = (index < incount-2) ? pPos+6 : endvec;
startpos = pPos-3;
}
lrp = f/step;
lxVector3CatmullRom(pOut,lrp,startpos,pPos,pPos+3,endpos);
}
lxVector3Copy(pOut,pPos+3);
return 0;
}
case VA_TONEXT3:
{
FNPUB_CHECKOUTREF(pstate,n,0,LUXI_CLASS_FLOATARRAY,ref,self);
index = self->count/3;
pOut = self->floats;
for (i = 0; i < index-1; i++,pOut+=3)
{
lxVector3Sub(pOut,pOut+3,pOut);
}
lxVector3Set(pOut,0,0,0);
return 0;
}
case VA_OPLIT:
{
float *pNormal;
lxVector3 latt;
lxVector3 lambi;
lxVector3 lpos;
lxVector3 ldiff;
lxVector3 intens;
lxVector3 ldir;
lxVector3 dist;
float dot;
FNPUB_CHECKOUTREF(pstate,n,0,LUXI_CLASS_FLOATARRAY,ref,self);
i = self->count/4;
pOut = self->floats;
FNPUB_CHECKOUTREF(pstate,n,1,LUXI_CLASS_FLOATARRAY,ref,self);
if (i != self->count/3)
return FunctionPublish_returnError(pstate,"position array does not match size");
pPos = self->floats;
FNPUB_CHECKOUTREF(pstate,n,2,LUXI_CLASS_FLOATARRAY,ref,self);
if (i != self->count/3)
return FunctionPublish_returnError(pstate,"normal array does not match size");
pNormal = self->floats;
if (n < 15 || 12>FunctionPublish_getArgOffset(pstate,3,12,FNPUB_TOVECTOR3(lpos),FNPUB_TOVECTOR3(ldiff),FNPUB_TOVECTOR3(lambi),FNPUB_TOVECTOR3(latt)))
return FunctionPublish_returnError(pstate,"3 floatarrays 12 floats required.");
dist[0] = 1.0f;
for (i = 0; i < self->count/3; i++,pOut+=4,pPos+=3,pNormal+=3)
{ // compute per vertex lighting
// pos 2 light
lxVector3Sub(ldir,lpos,pPos);
dist[1] = lxVector3Normalized(ldir);
dist[2] = dist[1]*dist[1];
// N.L
dot = LUX_MAX(0,lxVector3Dot(ldir,pNormal));
// lightintesities
lxVector3ScaledAdd(intens,lambi,dot,ldiff);
// attenuate
dot = 1.0f/(lxVector3Dot(dist,latt));
lxVector3Scale(pOut,intens,dot);
pOut[3] = 1.0f;
}
return 0;
}
case VA_OPSET:
case VA_OPSUB:
case VA_OPMUL:
case VA_OPADD:
case VA_OPDIV:
case VA_OPMIN:
case VA_OPMAX:
{
FNPUB_CHECKOUTREF(pstate,n,0,LUXI_CLASS_FLOATARRAY,ref,self);
if (n==2 && FunctionPublish_getNArg(pstate,1,LUXI_CLASS_FLOAT,(void*)&f)==1) {
switch ((StaticArrayUp_t)fn->upvalue) {
case VA_OPSET: for (i=0;i<self->count;i++) self->floats[i] = f; break;
case VA_OPSUB: for (i=0;i<self->count;i++) self->floats[i] -= f; break;
case VA_OPDIV: for (i=0;i<self->count;i++) self->floats[i] /= f; break;
case VA_OPMUL: for (i=0;i<self->count;i++) self->floats[i] *= f; break;
case VA_OPADD: for (i=0;i<self->count;i++) self->floats[i] += f; break;
case VA_OPMIN:
for (i=0;i<self->count;i++) self->floats[i] = LUX_MIN(self->floats[i],f); break;
case VA_OPMAX:
for (i=0;i<self->count;i++) self->floats[i] = LUX_MAX(self->floats[i],f); break;
default:
return 0;
}
}
return 0;
}
FNPUB_CHECKOUTREF(pstate,n,1,LUXI_CLASS_FLOATARRAY,ref,a);
if (n>=3){
FNPUB_CHECKOUTREF(pstate,n,2,LUXI_CLASS_FLOATARRAY,ref,b)
}
else {
b = a;
a = self;
}
if (self->count>a->count || self->count>b->count)
return FunctionPublish_returnError(pstate,"the arrays must be larger then destination");
switch ((StaticArrayUp_t)fn->upvalue) {
case VA_OPSET:
if (n==3) return FunctionPublish_returnError(pstate,"accepts only 2 arguments");
for (i=0;i<self->count;i++) self->floats[i] = a->floats[i];
break;
case VA_OPSUB:
for (i=0;i<self->count;i++) self->floats[i] = a->floats[i]-b->floats[i];
break;
case VA_OPMUL:
for (i=0;i<self->count;i++) self->floats[i] = a->floats[i]*b->floats[i];
break;
case VA_OPADD:
for (i=0;i<self->count;i++) self->floats[i] = a->floats[i]+b->floats[i];
break;
case VA_OPDIV:
for (i=0;i<self->count;i++) self->floats[i] = a->floats[i]/b->floats[i];
break;
case VA_OPMIN:
for (i=0;i<self->count;i++) self->floats[i] = LUX_MIN(a->floats[i],b->floats[i]);
break;
case VA_OPMAX:
for (i=0;i<self->count;i++) self->floats[i] = LUX_MAX(a->floats[i],b->floats[i]);
break;
}
return 0;
}
return 0;
}
static void fileLoadF3DMesh(uint type, uint count, uint offset)
{
lxFSFile_t *file = l_F3DData.file;
Bone_t *bone;
MeshObject_t *meshobj;
Mesh_t *mesh;
lxVertex64_t *vert64;
lxVertex32_t *vert32;
float buffer[16];
char name[4096];
char *curname;
uint i;
uint n;
uint len;
uint uintCnt;
ushort ushortCnt;
ushort ushort1;
uchar uchar;
/*
<[2] Eltern ID>
<[2] String länge > [<[1] Name des Objekts>]
<[4 * 16] 4*4 Float Matrix44, relativ zum Elternteil>
<[12] RefPose(x,y,z)> <[16] RefRot(x,y,z,w)> <[12] RefScale (x,y,z)>
*/
for (n = 0; n < count; n++){
// Generic Info
// id
bone = (type != IMESH_INST_SHRD_VERT_PARENT_MAT) ? &l_F3DData.model->bonesys.bones[l_F3DData.curbone++] : NULL;
meshobj = (type != IMESH_HELPER) ? &l_F3DData.model->meshObjects[n+offset] : NULL;
lxFS_read(&ushort1,sizeof(ushort),1,file);
if (bone)
bone->parentID = f3dFixBoneID(ushort1);
// name
lxFS_read(&ushort1,sizeof(ushort),1,file);
lxFS_read(&name,sizeof(uchar),ushort1,file);
LUX_ASSERT(ushort1 < 4096);
name[ushort1]=0;
resnewstrcpy(curname,name);
if (meshobj){
meshobj->name = curname;
meshobj->bone = bone;
meshobj->skinID = -1;
}
if (bone)
bone->name = curname;
// matrix
lxFS_read(buffer,sizeof(float),16,file);
if (bone){
lxMatrix44Copy(bone->refMatrix,buffer);
}
// Ref Pos, Rot, Scale
lxFS_read(buffer,sizeof(float),3,file);
if (bone){
lxVector3Copy(bone->refPRS.pos,buffer);
}
lxFS_read(buffer,sizeof(float),4,file);
if (bone){
lxVector4Copy(bone->refPRS.rot,buffer);
}
lxFS_read(buffer,sizeof(float),3,file);
if (bone){
lxVector3Copy(bone->refPRS.scale,buffer);
if (bone->refPRS.scale[0] && bone->refPRS.scale[1] && bone->refPRS.scale[2] &&
bone->refPRS.scale[0]!=1.0f && bone->refPRS.scale[1]!=1.0f && bone->refPRS.scale[2]!=1.0f){
bone->refInvScale[0] = 1.0f/bone->refPRS.scale[0];
bone->refInvScale[1] = 1.0f/bone->refPRS.scale[1];
bone->refInvScale[2] = 1.0f/bone->refPRS.scale[2];
// rebuild matrix without scale
// rot
lxQuatToMatrixIdentity(bone->refPRS.rot,bone->refMatrix);
//pos
lxMatrix44SetTranslation(bone->refMatrix,bone->refPRS.pos);
}
else
lxVector3Set(bone->refInvScale,1,1,1);
}
switch (type){
case IMESH_HELPER:
break;
case IMESH_MESH:
/* <[2] Material ID>
<[2] Anzahl der Punkte>
[ <[16] tx,ty,tz,tw> <[8] (u,v)> <[4] (r,g,b,a)> <[12] (nx,ny,nz)> <[12] (x,y,z)> ]
<1> Primitve Type
{
0: Points
1: Triangle List
2: Triangle Strip
3: Quad List
4: Quad Strip
}
<[2] Total Indices>
<[2] Primitivelistencount>
[
<[2] Material ID> IGNORED
<[2] Anzahl der Indices> ## z.b Triangle List : indices = tris * 3, Triangle Strip indices = tris - 2
[<[2] Vertex ID>]
]*/
mesh = meshobj->mesh = reszalloc(sizeof(Mesh_t));
mesh->instanceType = f3dInstanceType(type);
mesh->vertextype = l_F3DData.model->vertextype;
// material
lxFS_read(&ushort1,sizeof(ushort),1,file);
meshobj->texRID = ushort1;
// number of Vertices
uintCnt = 0;
lxFS_read(&uintCnt,(l_F3DData.f3dversion >= F3D_VERSION_26) ? sizeof(uint) : sizeof(ushort),1,file);
switch (l_F3DData.model->vertextype){
case VERTEX_64_TEX4:
case VERTEX_64_SKIN:
vert64 = mesh->vertexData = reszallocaligned(sizeof(lxVertex64_t)*uintCnt,32);
mesh->numAllocVertices = mesh->numVertices = uintCnt;
switch(l_F3DData.f3dversion)
{
case F3D_VERSION_23:
for (i = 0; i < uintCnt; i++){
lxFS_read(vert64->tex2,sizeof(float),4,file);
lxFS_read(vert64->tex,sizeof(float),2,file);
lxFS_read(vert64->color,sizeof(uchar),4,file);
lxFS_read(buffer,sizeof(float),3,file);
lxVector3short_FROM_float(vert64->normal,buffer);
lxFS_read(vert64->pos,sizeof(float),3,file);
vert64++;
}
break;
case F3D_VERSION_24:
for (i = 0; i < uintCnt; i++){
// tex,tex2 user4
lxFS_read(vert64->tex,sizeof(float),8,file);
// normal
lxFS_read(buffer,sizeof(float),3,file);
lxVector3short_FROM_float(vert64->normal,buffer);
// color
lxFS_read(vert64->color,sizeof(uchar),4,file);
lxFS_read(vert64->pos,sizeof(float),3,file);
// pad
lxFS_read(buffer,sizeof(float),1,file);
vert64++;
}
break;
case F3D_VERSION_25:
default:
lxFS_read(vert64,sizeof(lxVertex64_t),mesh->numVertices,file);
break;
}
break;
case VERTEX_32_TEX2:
vert32 = mesh->vertexData = reszallocaligned(sizeof(lxVertex32_t)*uintCnt,32);
mesh->numAllocVertices = mesh->numVertices = uintCnt;
switch(l_F3DData.f3dversion)
{
case F3D_VERSION_23:
for (i = 0; i < uintCnt; i++){
lxFS_read(vert32->tex1,sizeof(float),2,file);
lxFS_read(buffer,sizeof(float),2,file);
lxFS_read(vert32->tex,sizeof(float),2,file);
lxFS_read(vert32->color,sizeof(uchar),4,file);
lxFS_read(buffer,sizeof(float),3,file);
lxFS_read(vert32->pos,sizeof(float),3,file);
vert32++;
}
break;
case F3D_VERSION_24:
for (i = 0; i < uintCnt; i++){
// tex, tex2
lxFS_read(vert32->tex,sizeof(float),4,file);
//FS_read(vert32->tex2,sizeof(float),2,file);
// user4, normal
lxFS_read(buffer,sizeof(float),7,file);
lxFS_read(vert32->color,sizeof(uchar),4,file);
lxFS_read(vert32->pos,sizeof(float),3,file);
lxFS_read(buffer,sizeof(float),1,file);
vert32++;
}
break;
case F3D_VERSION_25:
default:
for (i = 0; i < uintCnt; i++){
// tex, tex2
lxFS_read(vert32->tex,sizeof(float),4,file);
//FS_read(vert32->tex2,sizeof(float),2,file);
// user4, normal,tangent
lxFS_read(buffer,sizeof(float),8,file);
lxFS_read(vert32->pos,sizeof(float),3,file);
lxFS_read(vert32->color,sizeof(uchar),4,file);
vert32++;
}
break;
}
break;
case VERTEX_32_NRM:
vert32 = mesh->vertexData = reszallocaligned(sizeof(lxVertex32_t)*uintCnt,32);
mesh->numAllocVertices = mesh->numVertices = uintCnt;
switch(l_F3DData.f3dversion)
{
case F3D_VERSION_23:
for (i = 0; i < uintCnt; i++){
// user4
lxFS_read(buffer,sizeof(float),4,file);
lxFS_read(vert32->tex,sizeof(float),2,file);
lxFS_read(vert32->color,sizeof(uchar),4,file);
//normal
lxFS_read(buffer,sizeof(float),3,file);
lxVector3short_FROM_float(vert32->normal,buffer);
lxFS_read(vert32->pos,sizeof(float),3,file);
vert32++;
}
break;
case F3D_VERSION_24:
for (i = 0; i < uintCnt; i++){
// tex
lxFS_read(vert32->tex,sizeof(float),2,file);
// tex2, user4
lxFS_read(buffer,sizeof(float),6,file);
// normal
lxFS_read(buffer,sizeof(float),3,file);
lxVector3short_FROM_float(vert32->normal,buffer);
lxFS_read(vert32->color,sizeof(uchar),4,file);
lxFS_read(vert32->pos,sizeof(float),3,file);
lxFS_read(buffer,sizeof(float),1,file);
vert32++;
}
break;
default:
case F3D_VERSION_25:
for (i = 0; i < uintCnt; i++){
// tex
lxFS_read(vert32->tex,sizeof(float),2,file);
// tex2, user4
lxFS_read(buffer,sizeof(float),6,file);
// normal
lxFS_read(vert32->normal,sizeof(short),4,file);
// tangent
lxFS_read(buffer,sizeof(short),4,file);
lxFS_read(vert32->pos,sizeof(float),3,file);
lxFS_read(vert32->color,sizeof(uchar),4,file);
vert32++;
}
break;
}
break;
default:
LUX_ASSERT(0);
break;
}
// primitive type
lxFS_read(&uchar,sizeof(uchar),1,file);
mesh->primtype = f3dPrimType(uchar);
// total indices count
uintCnt = 0;
lxFS_read(&uintCnt,(l_F3DData.f3dversion >= F3D_VERSION_26) ? sizeof(uint) : sizeof(ushort),1,file);
mesh->index16 = mesh->numAllocVertices <= BIT_ID_FULL16;
if (mesh->index16)
mesh->indicesData16 = reszalloc(sizeof(ushort)*uintCnt);
else
mesh->indicesData32 = reszalloc(sizeof(uint)*uintCnt);
mesh->numIndices = mesh->numAllocIndices = uintCnt;
// group count
lxFS_read(&ushortCnt,sizeof(ushort),1,file);
mesh->indicesGroupLength = reszalloc(sizeof(uint)*ushortCnt);
mesh->numGroups = ushortCnt;
len = 0;
for (i = 0; i < ushortCnt; i++){
// material id (ignored)
lxFS_read(&ushort1,sizeof(ushort),1,file);
// indices
uintCnt = 0;
lxFS_read(&uintCnt,(l_F3DData.f3dversion >= F3D_VERSION_26) ? sizeof(uint) : sizeof(ushort),1,file);
mesh->indicesGroupLength[i] = uintCnt;
if (mesh->numAllocVertices > BIT_ID_FULL16)
lxFS_read(&mesh->indicesData32[len],sizeof(uint),uintCnt,file);
else
lxFS_read(&mesh->indicesData16[len],sizeof(ushort),uintCnt,file);
len += uintCnt;
}
break;
case IMESH_INST_SHRD_VERT:
case IMESH_INST_SHRD_VERT_PARENT_MAT:
/* <[2] Objekt ID als instanz>
<[2] Material ID>
<[2] Total Indices>
<[2] Polygonlistencount>
[
<[2] Material ID>
<[2] Anzahl der Indices>
[<[2] Vertex ID>]*/
mesh = meshobj->mesh = reszalloc(sizeof(Mesh_t));
mesh->instanceType = f3dInstanceType(type);
mesh->vertextype = l_F3DData.model->vertextype;
// instance
lxFS_read(&ushort1,sizeof(ushort),1,file);
if (!ushort1){
LUX_ASSERT(0);
}
else{
mesh->instance = l_F3DData.model->meshObjects[((int)ushort1)-1].mesh;
if (type == IMESH_INST_SHRD_VERT_PARENT_MAT){
meshobj->bone = l_F3DData.model->meshObjects[((int)ushort1)-1].bone;
}
}
uchar = (l_F3DData.model->meshObjects[ushort1-1].mesh->numAllocVertices > BIT_ID_FULL16);
// material
lxFS_read(&ushort1,sizeof(ushort),1,file);
meshobj->texRID = ushort1;
// total indices count
uintCnt = 0;
lxFS_read(&uintCnt,(l_F3DData.f3dversion >= F3D_VERSION_26) ? sizeof(uint) : sizeof(ushort),1,file);
if (uchar)
mesh->indicesData32 = reszalloc(sizeof(uint)*uintCnt);
else
mesh->indicesData16 = reszalloc(sizeof(ushort)*uintCnt);
mesh->index16 = !uchar;
mesh->numIndices = mesh->numAllocIndices = uintCnt;
// group count
lxFS_read(&ushortCnt,sizeof(ushort),1,file);
mesh->indicesGroupLength = reszalloc(sizeof(uint)*ushortCnt);
mesh->numGroups = ushortCnt;
len = 0;
for (i = 0; i < ushortCnt; i++){
// material id
lxFS_read(&ushort1,sizeof(ushort),1,file);
// indices
uintCnt = 0;
lxFS_read(&uintCnt,(l_F3DData.f3dversion >= F3D_VERSION_26) ? sizeof(uint) : sizeof(ushort),1,file);
mesh->indicesGroupLength[i] = uintCnt;
if (uchar)
lxFS_read(&mesh->indicesData32[len],sizeof(uint),uintCnt,file);
else
lxFS_read(&mesh->indicesData16[len],sizeof(ushort),uintCnt,file);
len += uintCnt;
}
break;
case IMESH_INST_SHRD_VERT_TRIS:
mesh = meshobj->mesh = reszalloc(sizeof(Mesh_t));
mesh->instanceType = f3dInstanceType(type);
mesh->vertextype = l_F3DData.model->vertextype;
// instance
lxFS_read(&ushort1,sizeof(ushort),1,file);
if (!ushort1){
// ERROR
}
mesh->instance = l_F3DData.model->meshObjects[((int)ushort1)-1].mesh;
mesh->index16 = mesh->instance->index16;
// material
lxFS_read(&ushort1,sizeof(ushort),1,file);
meshobj->texRID = ushort1;
break;
}
}
}
int onInit(int argc, const char** argv) {
// scene
updateGeometry(4,4,4);
lxBoundingBox_t bbox;
lxVector3Set(bbox.min,-1,-1,-1);
lxVector3Set(bbox.max, 1, 1, 1);
lxCVector3 up(0,1,0);
m_rh.init(up);
m_rh.cameraPerspective(&bbox, 30.0f);
m_rh.cameraOrtho(&bbox);
m_texture = RenderHelper::generateUVTexture(256,256);
// context
lxgContext_init(&m_ctx);
// vertices
size_t vsize = sizeof(VertexDefault) * m_box.numVertices();
lxgBuffer_init(&m_vbo, &m_ctx, LUXGL_STATIC_DRAW, vsize, NULL);
uint voffset = lxgBuffer_alloc(&m_vbo, vsize, sizeof(VertexDefault));
VertexDefault* vertices = (VertexDefault*)lxgBuffer_map(&m_vbo, LUXGFX_ACCESS_WRITEDISCARDALL, NULL);
m_box.fillVerts(vertices);
lxgBuffer_unmap(&m_vbo);
// indices
size_t trisize = sizeof(uint32) * m_box.numIndicesTris();
size_t linesize = sizeof(uint32) * m_box.numIndicesLines();
lxgBuffer_init(&m_ibo, &m_ctx, LUXGL_STATIC_DRAW, trisize + linesize, NULL);
uint trioffset = lxgBuffer_alloc(&m_ibo, trisize, sizeof(uint32));
uint32* indicesTris = (uint32*)lxgBuffer_mapRange(&m_ibo, trioffset, trisize,
LUXGFX_ACCESS_WRITEDISCARDALL,0,0,NULL);
m_box.fillIndices(LUX_MESH_INDEX_UINT32, indicesTris, voffset / sizeof(VertexDefault));
lxgBuffer_unmap(&m_ibo);
uint lineoffset = lxgBuffer_alloc(&m_ibo, linesize, sizeof(uint32));
uint32* indicesLines = (uint32*)lxgBuffer_mapRange(&m_ibo, lineoffset, linesize,
LUXGFX_ACCESS_WRITEDISCARDALL,0,0,NULL);
m_box.fillIndices(LUX_MESH_INDEX_UINT32, indicesLines, voffset / sizeof(VertexDefault), LUX_TRUE);
lxgBuffer_unmap(&m_ibo);
// vertexdecl
m_vattribs =
lxgVertexAttrib_bit(LUXGFX_VERTEX_ATTRIB_POS) |
lxgVertexAttrib_bit(LUXGFX_VERTEX_ATTRIB_NORMAL) |
lxgVertexAttrib_bit(LUXGFX_VERTEX_ATTRIB_TEXCOORD0);
m_vdecl.available = m_vattribs;
m_vdecl.streams = 1;
VertexDefault* vertex = NULL;
m_vdecl.table[LUXGFX_VERTEX_ATTRIB_POS] =
lxgVertexElement_set(3,LUX_SCALAR_FLOAT32,LUX_FALSE,LUX_FALSE,sizeof(VertexDefault),(size_t)&vertex->pos,0);
m_vdecl.table[LUXGFX_VERTEX_ATTRIB_NORMAL] =
lxgVertexElement_set(3,LUX_SCALAR_FLOAT32,LUX_TRUE,LUX_FALSE,sizeof(VertexDefault),(size_t)&vertex->normal,0);
m_vdecl.table[LUXGFX_VERTEX_ATTRIB_TEXCOORD0] =
lxgVertexElement_set(2,LUX_SCALAR_FLOAT32,LUX_FALSE,LUX_FALSE,sizeof(VertexDefault),(size_t)&vertex->uv,0);
// stream
m_stream.buffer = &m_vbo;
m_stream.offset = 0;
m_stream.len = vsize;
return 0;
}
