void FP_SingleColour::process(const FragmentProcessorInput* input, FragmentProcessorOutput* output) const
{
const PROCDATA_SINGLECOLOUR* inData = (const PROCDATA_SINGLECOLOUR*)input->user;
float shadowFactor = PuresoftSamplerProjection::get(m_shadowTex, inData->shadowcoord);
ALIGN16 float L[4];
mcemaths_sub_3_4(L, m_lightPos, inData->worldPos);
mcemaths_norm_3_4(L);
ALIGN16 float E[4];
mcemaths_sub_3_4(E, m_cameraPos, inData->worldPos);
mcemaths_norm_3_4(E);
ALIGN16 float H[4];
mcemaths_add_3_4(H, E, L);
mcemaths_norm_3_4(H);
enum {LAMBERT, SPECULAR};
ALIGN16 float factors[4];
factors[LAMBERT] = mcemaths_dot_3_4(L, inData->normal);
float yawOfLight = (float)acos(mcemaths_dot_3_4(L, m_lightDir));
factors[LAMBERT] *= yawOfLight < fieldOfLight ? 1.0f : (float)opt_pow(cos(yawOfLight - fieldOfLight), 150);
factors[SPECULAR] = opt_pow(mcemaths_dot_3_4(H, inData->normal), (unsigned int)*m_specularExponent);
mcemaths_clamp_3_4(factors, 0, 1.0f);
ALIGN16 float outputColour[4];
mcemaths_quatcpy(outputColour, m_diffuse);
mcemaths_mul_3_4(outputColour, factors[LAMBERT]);
ALIGN16 float specularColour[4];
mcemaths_quatcpy(specularColour, m_diffuse);
mcemaths_mulvec_3_4(specularColour, m_specularColour);
mcemaths_mul_3_4(specularColour, factors[SPECULAR]);
ALIGN16 float ambientColour[4];
mcemaths_quatcpy(ambientColour, m_diffuse);
mcemaths_mulvec_3_4(ambientColour, m_ambient);
mcemaths_add_3_4_ip(outputColour, specularColour);
mcemaths_mul_3_4(outputColour, shadowFactor);
mcemaths_add_3_4_ip(outputColour, ambientColour);
mcemaths_clamp_3_4(outputColour, 0, 1.0f);
mcemaths_mul_3_4(outputColour, 255.0f);
PURESOFTBGRA bytesColour;
bytesColour.elems.r = (unsigned char)outputColour[2];
bytesColour.elems.g = (unsigned char)outputColour[1];
bytesColour.elems.b = (unsigned char)outputColour[0];
bytesColour.elems.a = 0;
output->write4(0, &bytesColour);
}
void IP_SingleColour::correctInterpolation(void* interpolatedUserData, const void* interpolatedUserDataStart, float correctionFactor2) const
{
PROCDATA_SINGLECOLOUR* output = (PROCDATA_SINGLECOLOUR*)interpolatedUserData;
const PROCDATA_SINGLECOLOUR* start = (const PROCDATA_SINGLECOLOUR*)interpolatedUserDataStart;
copyUserDataSingleColour(output, start);
mcemaths_mul_3_4(output->normal, correctionFactor2);
mcemaths_mul_3_4(output->worldPos, correctionFactor2);
mcemaths_mul_3_4(output->shadowcoord, correctionFactor2);
}
void IP_Cloud::correctInterpolation(void* interpolatedUserData, const void* interpolatedUserDataStart, float correctionFactor2) const
{
PROCDATA_CLOUD* output = (PROCDATA_CLOUD*)interpolatedUserData;
const PROCDATA_CLOUD* start = (const PROCDATA_CLOUD*)interpolatedUserDataStart;
copyUserData(output, start);
mcemaths_mul_3_4(output->normal, correctionFactor2);
mcemaths_mul_3_4(output->worldPos, correctionFactor2);
mcemaths_mul_3_4(output->texcoord, correctionFactor2);
mcemaths_mul_3_4(output->shadowcoord, correctionFactor2);
}
void IP_DiffuseOnly::correctInterpolation(void* interpolatedUserData, const void* interpolatedUserDataStart, float correctionFactor2) const
{
PROCDATA_DIFFUSEONLY* output = (PROCDATA_DIFFUSEONLY*)interpolatedUserData;
const PROCDATA_DIFFUSEONLY* start = (const PROCDATA_DIFFUSEONLY*)interpolatedUserDataStart;
copyUserDataDiffuseOnly(output, start);
mcemaths_mul_3_4(output->normal, correctionFactor2);
mcemaths_mul_3_4(output->worldPos, correctionFactor2);
mcemaths_mul_3_4(output->texcoord, correctionFactor2);
mcemaths_mul_3_4(output->shadowcoord, correctionFactor2);
}
void IP_SingleColour::interpolateByContributes(void* interpolatedUserData, const void** vertexUserData, const float* correctedContributes) const
{
__declspec(align(16)) PROCDATA_SINGLECOLOUR temp[3];
copyUserDataSingleColour(temp, (PROCDATA_SINGLECOLOUR*)vertexUserData[0]);
copyUserDataSingleColour(temp + 1, (PROCDATA_SINGLECOLOUR*)vertexUserData[1]);
copyUserDataSingleColour(temp + 2, (PROCDATA_SINGLECOLOUR*)vertexUserData[2]);
mcemaths_mul_3_4(temp[0].normal, correctedContributes[0]);
mcemaths_mul_3_4(temp[0].worldPos, correctedContributes[0]);
mcemaths_mul_3_4(temp[0].shadowcoord, correctedContributes[0]);
mcemaths_mul_3_4(temp[1].normal, correctedContributes[1]);
mcemaths_mul_3_4(temp[1].worldPos, correctedContributes[1]);
mcemaths_mul_3_4(temp[1].shadowcoord, correctedContributes[1]);
mcemaths_mul_3_4(temp[2].normal, correctedContributes[2]);
mcemaths_mul_3_4(temp[2].worldPos, correctedContributes[2]);
mcemaths_mul_3_4(temp[2].shadowcoord, correctedContributes[2]);
PROCDATA_SINGLECOLOUR* output = (PROCDATA_SINGLECOLOUR*)interpolatedUserData;
mcemaths_quatcpy(output->normal, temp[0].normal);
mcemaths_quatcpy(output->worldPos, temp[0].worldPos);
mcemaths_quatcpy(output->shadowcoord, temp[0].shadowcoord);
mcemaths_add_3_4_ip(output->normal, temp[1].normal);
mcemaths_add_3_4_ip(output->worldPos, temp[1].worldPos);
mcemaths_add_3_4_ip(output->shadowcoord, temp[1].shadowcoord);
mcemaths_add_3_4_ip(output->normal, temp[2].normal);
mcemaths_add_3_4_ip(output->worldPos, temp[2].worldPos);
mcemaths_add_3_4_ip(output->shadowcoord, temp[2].shadowcoord);
}
void IP_SingleColour::calcStep(void* interpolatedUserDataStep, const void* interpolatedUserDataStart, const void* interpolatedUserDataEnd, int stepCount) const
{
PROCDATA_SINGLECOLOUR* start = (PROCDATA_SINGLECOLOUR*)interpolatedUserDataStart;
PROCDATA_SINGLECOLOUR* end = (PROCDATA_SINGLECOLOUR*)interpolatedUserDataEnd;
PROCDATA_SINGLECOLOUR* step = (PROCDATA_SINGLECOLOUR*)interpolatedUserDataStep;
float reciprocalStepCount = 0 == stepCount ? 1.0f : 1.0f / (float)stepCount;
mcemaths_sub_3_4(step->normal, end->normal, start->normal);
mcemaths_sub_3_4(step->worldPos, end->worldPos, start->worldPos);
mcemaths_sub_3_4(step->shadowcoord, end->shadowcoord, start->shadowcoord);
mcemaths_mul_3_4(step->normal, reciprocalStepCount);
mcemaths_mul_3_4(step->worldPos, reciprocalStepCount);
mcemaths_mul_3_4(step->shadowcoord, reciprocalStepCount);
}
void IP_CloudShadow::correctInterpolation(void* interpolatedUserData, const void* interpolatedUserDataStart, float correctionFactor2) const
{
PROCDATA_CLOUDSHADOW* output = (PROCDATA_CLOUDSHADOW*)interpolatedUserData;
const PROCDATA_CLOUDSHADOW* start = (const PROCDATA_CLOUDSHADOW*)interpolatedUserDataStart;
copyUserData(output, start);
mcemaths_mul_3_4(output->texcoord, correctionFactor2);
}
void IP_CloudShadow::interpolateByContributes(void* interpolatedUserData, const void** vertexUserData, const float* correctedContributes) const
{
__declspec(align(16)) PROCDATA_CLOUDSHADOW temp[3];
copyUserData(temp, (PROCDATA_CLOUDSHADOW*)vertexUserData[0]);
copyUserData(temp + 1, (PROCDATA_CLOUDSHADOW*)vertexUserData[1]);
copyUserData(temp + 2, (PROCDATA_CLOUDSHADOW*)vertexUserData[2]);
mcemaths_mul_3_4(temp[0].texcoord, correctedContributes[0]);
mcemaths_mul_3_4(temp[1].texcoord, correctedContributes[1]);
mcemaths_mul_3_4(temp[2].texcoord, correctedContributes[2]);
PROCDATA_CLOUDSHADOW* output = (PROCDATA_CLOUDSHADOW*)interpolatedUserData;
mcemaths_quatcpy(output->texcoord, temp[0].texcoord);
mcemaths_add_3_4_ip(output->texcoord, temp[1].texcoord);
mcemaths_add_3_4_ip(output->texcoord, temp[2].texcoord);
}
void IP_DiffuseOnly::calcStep(void* interpolatedUserDataStep, const void* interpolatedUserDataStart, const void* interpolatedUserDataEnd, int stepCount) const
{
PROCDATA_DIFFUSEONLY* start = (PROCDATA_DIFFUSEONLY*)interpolatedUserDataStart;
PROCDATA_DIFFUSEONLY* end = (PROCDATA_DIFFUSEONLY*)interpolatedUserDataEnd;
PROCDATA_DIFFUSEONLY* step = (PROCDATA_DIFFUSEONLY*)interpolatedUserDataStep;
float reciprocalStepCount = 0 == stepCount ? 1.0f : 1.0f / (float)stepCount;
mcemaths_sub_3_4(step->normal, end->normal, start->normal);
mcemaths_sub_3_4(step->worldPos, end->worldPos, start->worldPos);
mcemaths_sub_3_4(step->texcoord, end->texcoord, start->texcoord);
mcemaths_sub_3_4(step->shadowcoord, end->shadowcoord, start->shadowcoord);
mcemaths_mul_3_4(step->normal, reciprocalStepCount);
mcemaths_mul_3_4(step->worldPos, reciprocalStepCount);
mcemaths_mul_3_4(step->texcoord, reciprocalStepCount);
mcemaths_mul_3_4(step->shadowcoord, reciprocalStepCount);
}
void IP_CloudShadow::calcStep(void* interpolatedUserDataStep, const void* interpolatedUserDataStart, const void* interpolatedUserDataEnd, int stepCount) const
{
PROCDATA_CLOUDSHADOW* start = (PROCDATA_CLOUDSHADOW*)interpolatedUserDataStart;
PROCDATA_CLOUDSHADOW* end = (PROCDATA_CLOUDSHADOW*)interpolatedUserDataEnd;
PROCDATA_CLOUDSHADOW* step = (PROCDATA_CLOUDSHADOW*)interpolatedUserDataStep;
float reciprocalStepCount = 0 == stepCount ? 1.0f : 1.0f / (float)stepCount;
mcemaths_sub_3_4(step->texcoord, end->texcoord, start->texcoord);
mcemaths_mul_3_4(step->texcoord, reciprocalStepCount);
}
void FP_DiffuseOnly::process(const FragmentProcessorInput* input, FragmentProcessorOutput* output) const
{
PURESOFTBGRA bytesColour;
ALIGN16 float outputColour[4], ambiemtColour[4];
const PROCDATA_DIFFUSEONLY* inData = (const PROCDATA_DIFFUSEONLY*)input->user;
float shadowFactor = PuresoftSamplerProjection::get(m_shadowTex, inData->shadowcoord);
PuresoftSampler2D::get4(m_diffuseTex, inData->texcoord[0], inData->texcoord[1], &bytesColour);
outputColour[0] = bytesColour.elems.b;
outputColour[1] = bytesColour.elems.g;
outputColour[2] = bytesColour.elems.r;
outputColour[3] = bytesColour.elems.a;
mcemaths_quatcpy(ambiemtColour, outputColour);
mcemaths_mulvec_3_4(ambiemtColour, m_ambient);
ALIGN16 float L[4];
mcemaths_sub_3_4(L, m_lightPos, inData->worldPos);
mcemaths_norm_3_4(L);
ALIGN16 float E[4];
mcemaths_sub_3_4(E, m_cameraPos, inData->worldPos);
mcemaths_norm_3_4(E);
ALIGN16 float H[4];
mcemaths_add_3_4(H, E, L);
mcemaths_norm_3_4(H);
enum {LAMBERT, SPECULAR};
ALIGN16 float factors[4];
factors[LAMBERT] = mcemaths_dot_3_4(L, inData->normal);
float yawOfLight = acos(mcemaths_dot_3_4(L, m_lightDir));
factors[LAMBERT] *= yawOfLight < fieldOfLight ? 1.0f : opt_pow(cos(yawOfLight - fieldOfLight), 150);
factors[SPECULAR] = opt_pow(mcemaths_dot_3_4(H, inData->normal), (unsigned int)*m_specularExponent);
mcemaths_clamp_3_4(factors, 0, 1.0f);
mcemaths_mul_3_4(outputColour, (factors[LAMBERT] + factors[SPECULAR]) * shadowFactor);
mcemaths_add_3_4_ip(outputColour, ambiemtColour);
mcemaths_clamp_3_4(outputColour, 0, 255.0f);
bytesColour.elems.r = (unsigned char)outputColour[2];
bytesColour.elems.g = (unsigned char)outputColour[1];
bytesColour.elems.b = (unsigned char)outputColour[0];
bytesColour.elems.a = 0;
output->write4(0, &bytesColour);
}
void FP_SingleColourNoLighting::process(const FragmentProcessorInput* input, FragmentProcessorOutput* output) const
{
const PROCDATA_SINGLECOLOUR* inData = (const PROCDATA_SINGLECOLOUR*)input->user;
ALIGN16 float outputColour[4];
mcemaths_quatcpy(outputColour, m_diffuse);
mcemaths_mul_3_4(outputColour, 255.0f);
PURESOFTBGRA bytesColour;
bytesColour.elems.r = (unsigned char)outputColour[2];
bytesColour.elems.g = (unsigned char)outputColour[1];
bytesColour.elems.b = (unsigned char)outputColour[0];
bytesColour.elems.a = 0;
output->write4(0, &bytesColour);
}
void IP_Planet::correctInterpolation(void* interpolatedUserData, const void* interpolatedUserDataStart, float correctionFactor2) const
{
PROCDATA_PLANET* output = (PROCDATA_PLANET*)interpolatedUserData;
const PROCDATA_PLANET* start = (const PROCDATA_PLANET*)interpolatedUserDataStart;
copyUserData(output, start);
mcemaths_mul_3_4(output->tangent, correctionFactor2);
mcemaths_mul_3_4(output->binormal, correctionFactor2);
mcemaths_mul_3_4(output->normal, correctionFactor2);
mcemaths_mul_3_4(output->worldPos, correctionFactor2);
mcemaths_mul_3_4(output->texcoord, correctionFactor2);
mcemaths_mul_3_4(output->shadowcoord, correctionFactor2);
}
void IP_Planet::calcStep(void* interpolatedUserDataStep, const void* interpolatedUserDataStart, const void* interpolatedUserDataEnd, int stepCount) const
{
PROCDATA_PLANET* start = (PROCDATA_PLANET*)interpolatedUserDataStart;
PROCDATA_PLANET* end = (PROCDATA_PLANET*)interpolatedUserDataEnd;
PROCDATA_PLANET* step = (PROCDATA_PLANET*)interpolatedUserDataStep;
float reciprocalStepCount = 0 == stepCount ? 1.0f : 1.0f / (float)stepCount;
mcemaths_sub_3_4(step->tangent, end->tangent, start->tangent);
mcemaths_sub_3_4(step->binormal, end->binormal, start->binormal);
mcemaths_sub_3_4(step->normal, end->normal, start->normal);
mcemaths_sub_3_4(step->worldPos, end->worldPos, start->worldPos);
mcemaths_sub_3_4(step->texcoord, end->texcoord, start->texcoord);
mcemaths_sub_3_4(step->shadowcoord, end->shadowcoord, start->shadowcoord);
mcemaths_mul_3_4(step->tangent, reciprocalStepCount);
mcemaths_mul_3_4(step->binormal, reciprocalStepCount);
mcemaths_mul_3_4(step->normal, reciprocalStepCount);
mcemaths_mul_3_4(step->worldPos, reciprocalStepCount);
mcemaths_mul_3_4(step->texcoord, reciprocalStepCount);
mcemaths_mul_3_4(step->shadowcoord, reciprocalStepCount);
}
void IP_Planet::interpolateByContributes(void* interpolatedUserData, const void** vertexUserData, const float* correctedContributes) const
{
__declspec(align(16)) PROCDATA_PLANET temp[3];
copyUserData(temp, (PROCDATA_PLANET*)vertexUserData[0]);
copyUserData(temp + 1, (PROCDATA_PLANET*)vertexUserData[1]);
copyUserData(temp + 2, (PROCDATA_PLANET*)vertexUserData[2]);
mcemaths_mul_3_4(temp[0].tangent, correctedContributes[0]);
mcemaths_mul_3_4(temp[0].binormal, correctedContributes[0]);
mcemaths_mul_3_4(temp[0].normal, correctedContributes[0]);
mcemaths_mul_3_4(temp[0].worldPos, correctedContributes[0]);
mcemaths_mul_3_4(temp[0].texcoord, correctedContributes[0]);
mcemaths_mul_3_4(temp[0].shadowcoord, correctedContributes[0]);
mcemaths_mul_3_4(temp[1].tangent, correctedContributes[1]);
mcemaths_mul_3_4(temp[1].binormal, correctedContributes[1]);
mcemaths_mul_3_4(temp[1].normal, correctedContributes[1]);
mcemaths_mul_3_4(temp[1].worldPos, correctedContributes[1]);
mcemaths_mul_3_4(temp[1].texcoord, correctedContributes[1]);
mcemaths_mul_3_4(temp[1].shadowcoord, correctedContributes[1]);
mcemaths_mul_3_4(temp[2].tangent, correctedContributes[2]);
mcemaths_mul_3_4(temp[2].binormal, correctedContributes[2]);
mcemaths_mul_3_4(temp[2].normal, correctedContributes[2]);
mcemaths_mul_3_4(temp[2].worldPos, correctedContributes[2]);
mcemaths_mul_3_4(temp[2].texcoord, correctedContributes[2]);
mcemaths_mul_3_4(temp[2].shadowcoord, correctedContributes[2]);
PROCDATA_PLANET* output = (PROCDATA_PLANET*)interpolatedUserData;
mcemaths_quatcpy(output->tangent, temp[0].tangent);
mcemaths_quatcpy(output->binormal, temp[0].binormal);
mcemaths_quatcpy(output->normal, temp[0].normal);
mcemaths_quatcpy(output->worldPos, temp[0].worldPos);
mcemaths_quatcpy(output->texcoord, temp[0].texcoord);
mcemaths_quatcpy(output->shadowcoord, temp[0].shadowcoord);
mcemaths_add_3_4_ip(output->tangent, temp[1].tangent);
mcemaths_add_3_4_ip(output->binormal, temp[1].binormal);
mcemaths_add_3_4_ip(output->normal, temp[1].normal);
mcemaths_add_3_4_ip(output->worldPos, temp[1].worldPos);
mcemaths_add_3_4_ip(output->texcoord, temp[1].texcoord);
mcemaths_add_3_4_ip(output->shadowcoord, temp[1].shadowcoord);
mcemaths_add_3_4_ip(output->tangent, temp[2].tangent);
mcemaths_add_3_4_ip(output->binormal, temp[2].binormal);
mcemaths_add_3_4_ip(output->normal, temp[2].normal);
mcemaths_add_3_4_ip(output->worldPos, temp[2].worldPos);
mcemaths_add_3_4_ip(output->texcoord, temp[2].texcoord);
mcemaths_add_3_4_ip(output->shadowcoord, temp[2].shadowcoord);
}
bool write_face(HOBJXIO hobjxio, const string& name, const faces& fcs, const obj_mesh_data& dat, const material& mtl)
{
static vec4_coll vertices;
static vec4_coll normals;
static vec4_coll tangents;
static vec2_coll texcoords;
mesh_info mesh;
mesh.num_indices = 0;
mesh.indices = NULL;
for(int i = 0; i < faces::MAX; i++)
{
const face& fc = fcs.face_data[i];
// stat vertices
mesh.num_vertices = 0;
for(int i = 0; i < (int)fc.size(); i++)
// 3 indices for 1 triangle, 4 for 2, 5 for 3, ... n indices for n-2 triangles make (n-2)*3 vertices
mesh.num_vertices += (fc[i].vertIndices.size() - 2) * 3;
if(0 == mesh.num_vertices)
continue;
// prepare container
vertices.clear();
normals.clear();
tangents.clear();
texcoords.clear();
// for each facet
for(int i = 0; i < (int)fc.size(); i++)
{
const facet& f = fc[i];
// facet -> triangles
for(int j = 1; j < (int)f.vertIndices.size() - 1; j++)
{
vertices.push_back(dat.vertices[f.vertIndices[ 0]]);
vertices.push_back(dat.vertices[f.vertIndices[ j]]);
vertices.push_back(dat.vertices[f.vertIndices[j + 1]]);
}
}
ATLASSERT(vertices.size() > 0);
mesh.vertices = &vertices[0];
// for each facet
for(int i = 0; i < (int)fc.size(); i++)
{
const facet& f = fc[i];
// facet -> triangles
for(int j = 1; j < (int)f.normIndices.size() - 1; j++)
{
normals.push_back(dat.normals[f.normIndices[ 0]]);
normals.push_back(dat.normals[f.normIndices[ j]]);
normals.push_back(dat.normals[f.normIndices[j + 1]]);
}
}
// unlike vertices, normal data can be absent
if(0 == normals.size()) // if normal not exists, we generate
{
for(int i = 0; i < (int)vertices.size(); i += 3)
{
const vec4& a = vertices[ i];
const vec4& b = vertices[i + 1];
const vec4& c = vertices[i + 2];
vec4 edge1, edge2, n;
mcemaths_sub_3_4(edge1, c, b);
mcemaths_sub_3_4(edge2, a, b);
mcemaths_cross_3(n, edge1, edge2);
mcemaths_norm_3_4(n);
normals.push_back(n);
normals.push_back(n);
normals.push_back(n);
}
}
mesh.normals = &normals[0];
mesh.has_normals = true;
// for each facet
for(int i = 0; i < (int)fc.size(); i++)
{
const facet& f = fc[i];
// facet -> triangles
for(int j = 1; j < (int)f.texIndices.size() - 1; j++)
{
texcoords.push_back(dat.texcoords[f.texIndices[ 0]]);
texcoords.push_back(dat.texcoords[f.texIndices[ j]]);
texcoords.push_back(dat.texcoords[f.texIndices[j + 1]]);
}
}
mesh.texcoords = NULL;
mesh.tangents = NULL;
mesh.has_texcoords = mesh.has_tangents = false;
if(texcoords.size() > 0) // unlike vertices, texture coordinate can also be absent
{
mesh.texcoords = &texcoords[0];
mesh.has_texcoords = true;
// if texcoords exist, generate tangents (save time for game initialization as much as possible)
for(int i = 0; i < (int)vertices.size(); i += 3)
{
const vec4& a = vertices [ i];
const vec4& b = vertices [i + 1];
const vec4& c = vertices [i + 2];
const vec2& ta2 = texcoords[ i];
const vec2& tb2 = texcoords[i + 1];
const vec2& tc2 = texcoords[i + 2];
vec4 ta(ta2.x, ta2.y, 0, 0);
vec4 tb(tb2.x, tb2.y, 0, 0);
vec4 tc(tc2.x, tc2.y, 0, 0);
vec4 modvec1(0.0f), modvec4(0.0f), texvec1(0.0f), texvec4(0.0f);
mcemaths_sub_3_4(modvec1, c , a);
mcemaths_sub_3_4(modvec4, b , a);
mcemaths_sub_3_4(texvec1, tc, ta);
mcemaths_sub_3_4(texvec4, tb, ta);
mcemaths_mul_3_4(modvec1, texvec4.y);
mcemaths_mul_3_4(modvec4, texvec1.y);
mcemaths_sub_3_4_ip(modvec1, modvec4);
mcemaths_div_3_4(modvec1, texvec1.x * texvec4.y - texvec4.x * texvec1.y);
mcemaths_norm_3_4(modvec1);
tangents.push_back(modvec1);
tangents.push_back(modvec1);
tangents.push_back(modvec1);
}
mesh.tangents = &tangents[0];
mesh.has_tangents = true;
}
mesh.mesh_name = name;
mesh.ambient_colour = vec4(mtl.ambientColour.x, mtl.ambientColour.y, mtl.ambientColour.z, 1.0f);
mesh.diffuse_colour = vec4(mtl.diffuseColour.x, mtl.diffuseColour.y, mtl.diffuseColour.z, 1.0f);
mesh.specular_colour = vec4(mtl.specularColour.x, mtl.specularColour.y, mtl.specularColour.z, 1.0f);
mesh.specular_exponent = mtl.specularExponent;
mesh.diffuse_file = mtl.diffuseFile;
mesh.bump_file = mtl.bumpFile;
mesh.spc_file = mtl.spcFile;
mesh.spe_file = mtl.speFile;
mesh.programme = mtl.programmeName;
if(!write_mesh(hobjxio, mesh))
return false;
}
return true;
}
void IP_DiffuseOnly::interpolateByContributes(void* interpolatedUserData, const void** vertexUserData, const float* correctedContributes) const
{
__declspec(align(16)) PROCDATA_DIFFUSEONLY temp[3];
copyUserDataDiffuseOnly(temp, (PROCDATA_DIFFUSEONLY*)vertexUserData[0]);
copyUserDataDiffuseOnly(temp + 1, (PROCDATA_DIFFUSEONLY*)vertexUserData[1]);
copyUserDataDiffuseOnly(temp + 2, (PROCDATA_DIFFUSEONLY*)vertexUserData[2]);
mcemaths_mul_3_4(temp[0].normal, correctedContributes[0]);
mcemaths_mul_3_4(temp[0].worldPos, correctedContributes[0]);
mcemaths_mul_3_4(temp[0].texcoord, correctedContributes[0]);
mcemaths_mul_3_4(temp[0].shadowcoord, correctedContributes[0]);
mcemaths_mul_3_4(temp[1].normal, correctedContributes[1]);
mcemaths_mul_3_4(temp[1].worldPos, correctedContributes[1]);
mcemaths_mul_3_4(temp[1].texcoord, correctedContributes[1]);
mcemaths_mul_3_4(temp[1].shadowcoord, correctedContributes[1]);
mcemaths_mul_3_4(temp[2].normal, correctedContributes[2]);
mcemaths_mul_3_4(temp[2].worldPos, correctedContributes[2]);
mcemaths_mul_3_4(temp[2].texcoord, correctedContributes[2]);
mcemaths_mul_3_4(temp[2].shadowcoord, correctedContributes[2]);
PROCDATA_DIFFUSEONLY* output = (PROCDATA_DIFFUSEONLY*)interpolatedUserData;
mcemaths_quatcpy(output->normal, temp[0].normal);
mcemaths_quatcpy(output->worldPos, temp[0].worldPos);
mcemaths_quatcpy(output->texcoord, temp[0].texcoord);
mcemaths_quatcpy(output->shadowcoord, temp[0].shadowcoord);
mcemaths_add_3_4_ip(output->normal, temp[1].normal);
mcemaths_add_3_4_ip(output->worldPos, temp[1].worldPos);
mcemaths_add_3_4_ip(output->texcoord, temp[1].texcoord);
mcemaths_add_3_4_ip(output->shadowcoord, temp[1].shadowcoord);
mcemaths_add_3_4_ip(output->normal, temp[2].normal);
mcemaths_add_3_4_ip(output->worldPos, temp[2].worldPos);
mcemaths_add_3_4_ip(output->texcoord, temp[2].texcoord);
mcemaths_add_3_4_ip(output->shadowcoord, temp[2].shadowcoord);
}
const vec4& vec4::mul(float scalar)
{
mcemaths_mul_3_4(&x, scalar);
return *this;
}
void FP_Satellite::process(const FragmentProcessorInput* input, FragmentProcessorOutput* output) const
{
ALIGN16 float outputColour[4];
ALIGN16 float bumpNormal[4];
PURESOFTBGRA bytesColour;
const PROCDATA_PLANET* inData = (const PROCDATA_PLANET*)input->user;
PuresoftSampler2D::get4(m_diffuseTex, inData->texcoord[0], inData->texcoord[1], &bytesColour);
outputColour[0] = bytesColour.elems.b;
outputColour[1] = bytesColour.elems.g;
outputColour[2] = bytesColour.elems.r;
outputColour[3] = bytesColour.elems.a;
PuresoftSampler2D::get4(m_bumpTex, inData->texcoord[0], inData->texcoord[1], &bytesColour);
bumpNormal[0] = bytesColour.elems.r;
bumpNormal[1] = bytesColour.elems.g;
bumpNormal[2] = bytesColour.elems.b;
bumpNormal[3] = 0;
float shadowFactor = PuresoftSamplerProjection::get(m_shadowTex, inData->shadowcoord);
mcemaths_div_3_4(bumpNormal, 255.0f);
mcemaths_mul_3_4(bumpNormal, 2.0f);
mcemaths_sub_4by1(bumpNormal, 1.0f);
ALIGN16 float tbn[16];
mcemaths_make_tbn(tbn, inData->tangent, inData->binormal, inData->normal);
mcemaths_transform_m4v4_ip(bumpNormal, tbn);
mcemaths_norm_3_4(bumpNormal);
ALIGN16 float L[4];
mcemaths_sub_3_4(L, m_lightPos, inData->worldPos);
float distance = mcemaths_len_3_4(L);
mcemaths_div_3_4(L, distance);
ALIGN16 float E[4];
mcemaths_sub_3_4(E, m_cameraPos, inData->worldPos);
mcemaths_norm_3_4(E);
ALIGN16 float H[4];
mcemaths_add_3_4(H, E, L);
mcemaths_norm_3_4(H);
float lambert = mcemaths_dot_3_4(L, bumpNormal);
float specular = mcemaths_dot_3_4(H, bumpNormal);
specular = specular < 0 ? 0 : specular;
//specular = pow(specular, 50.0f);
specular = opt_pow(specular, 50);
mcemaths_add_1to4(outputColour, 255.0f * specular);
mcemaths_mul_3_4(outputColour, lambert);
mcemaths_mul_3_4(outputColour, shadowFactor);
mcemaths_clamp_3_4(outputColour, 0, 255.0f);
bytesColour.elems.r = (unsigned char)outputColour[2];
bytesColour.elems.g = (unsigned char)outputColour[1];
bytesColour.elems.b = (unsigned char)outputColour[0];
bytesColour.elems.a = 0;
output->write4(0, &bytesColour);
}
