Color Scene::lanceRayon(const Rayon& ray, int iteration) const
{
this->addObjectsTabToBinder();
Color result(0.0,0.0,0.0);
float minDist(1000.0) ;
float dist (0.0) ;
Hit hit ;
if (binder->intersect(ray,0.0,100.0,hit))
{
//result = hit.getObject()->getOptic()->getColor(hit.getU(),hit.getV());
//result = hit.getObject()->getOptic()->getColor(0.5,0.5);
Color coulObj(hit.getObject()->getOptic()->getColor(hit.getU(),hit.getV()));
for ( std::vector<std::shared_ptr<LightSource>>::const_iterator it = lightsTab.begin(); it != lightsTab.end() ; ++it)
// pour chaque source
{
//d = calcul distance point intersection source
Vector directi(it->get()->getOrigin()-hit.getImpactPoint());
float distInterSource = directi.getNorm() ;
directi.normalize();
//initialiser Ray : point intersect, direction(point intersect, source), couleur = on s'en fout
Color c(0.0,0.0,0.0);
Color resultNorm(0.0,0.0,0.0);
Rayon ray(hit.getImpactPoint(),directi,c);
if (! binder->intersect(ray, 0, distInterSource))
{
Color diff(it->get()->getColor()*coulObj*(dotProduct(hit.getNormal(),ray.getDirect())));
Vector moinsV(-directi.getX(),-directi.getY(),-directi.getZ());
Vector miroirV(moinsV + hit.getNormal()*(2*(dotProduct(directi,hit.getNormal()))));
//Vmir = V symétrique par rapport à N
//spec = coulspec(obj)* (tronquerAZero(RayS.Vmir))^n * coul(source)
Color spec(it->get()->getColor()*coulObj*dotProduct(ray.getDirect(),miroirV));
resultNorm = diff + spec ;
if ( iteration < 2)
{
//Res2 = influence rayon réfléchi
Rayon reflected(hit.getImpactPoint(),miroirV,c);
Color reflectedColor(0.0,0.0,0.0);
reflectedColor = this->lanceRayon(reflected,iteration+1);
//return pourcent1*Res + ourcent2*Res2
result = resultNorm*0.8 + reflectedColor*0.2 ;
}
else
{
result = resultNorm ;
}
}
}
}
return result;
}
// http://sourceforge.net/projects/assimp/forums/forum/817654/topic/3880745
void ofxAssimpModelLoader::updateGLResources(){
// update mesh position for the animation
for (unsigned int i = 0; i < modelMeshes.size(); ++i){
// current mesh we are introspecting
const aiMesh* mesh = modelMeshes[i].mesh;
// calculate bone matrices
std::vector<aiMatrix4x4> boneMatrices( mesh->mNumBones);
for( size_t a = 0; a < mesh->mNumBones; ++a)
{
const aiBone* bone = mesh->mBones[a];
// find the corresponding node by again looking recursively through the node hierarchy for the same name
aiNode* node = scene->mRootNode->FindNode(bone->mName);
// start with the mesh-to-bone matrix
boneMatrices[a] = bone->mOffsetMatrix;
// and now append all node transformations down the parent chain until we're back at mesh coordinates again
const aiNode* tempNode = node;
while( tempNode)
{
// check your matrix multiplication order here!!!
boneMatrices[a] = tempNode->mTransformation * boneMatrices[a];
// boneMatrices[a] = boneMatrices[a] * tempNode->mTransformation;
tempNode = tempNode->mParent;
}
}
// all using the results from the previous code snippet
std::vector<aiVector3D> resultPos( mesh->mNumVertices);
std::vector<aiVector3D> resultNorm( mesh->mNumVertices);
// loop through all vertex weights of all bones
for( size_t a = 0; a < mesh->mNumBones; ++a)
{
const aiBone* bone = mesh->mBones[a];
const aiMatrix4x4& posTrafo = boneMatrices[a];
// 3x3 matrix, contains the bone matrix without the translation, only with rotation and possibly scaling
aiMatrix3x3 normTrafo = aiMatrix3x3( posTrafo);
for( size_t b = 0; b < bone->mNumWeights; ++b)
{
const aiVertexWeight& weight = bone->mWeights[b];
size_t vertexId = weight.mVertexId;
const aiVector3D& srcPos = mesh->mVertices[vertexId];
const aiVector3D& srcNorm = mesh->mNormals[vertexId];
resultPos[vertexId] += weight.mWeight * (posTrafo * srcPos);
resultNorm[vertexId] += weight.mWeight * (normTrafo * srcNorm);
}
}
// now upload the result position and normal along with the other vertex attributes into a dynamic vertex buffer, VBO or whatever
// get mesh helper for this mesh;
ofxAssimpMeshHelper meshHelper = modelMeshes[i];
glBindBuffer(GL_ARRAY_BUFFER, meshHelper.vertexBuffer);
aiVertex* verts = (aiVertex*)glMapBuffer(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
for (unsigned int x = 0; x < mesh->mNumVertices; ++x)
{
//verts->vPosition = mesh->mVertices[x];
verts->vPosition = resultPos[x];
if (NULL == mesh->mNormals)
verts->vNormal = aiVector3D(0.0f,0.0f,0.0f);
else
verts->vNormal = resultNorm[x];
if (mesh->HasVertexColors(0))
{
verts->dColorDiffuse = mesh->mColors[0][x];
}
else
verts->dColorDiffuse = aiColor4D(1.0, 1.0, 1.0, 1.0);
// This varies slightly form Assimp View, we support the 3rd texture component.
if (mesh->HasTextureCoords(0))
verts->vTextureUV = mesh->mTextureCoords[0][x];
else
verts->vTextureUV = aiVector3D(0.5f,0.5f, 0.0f);
// No longer in aiVertex VBO structure
/*
if (NULL == mesh->mTangents)
{
verts->vTangent = aiVector3D(0.0f,0.0f,0.0f);
verts->vBitangent = aiVector3D(0.0f,0.0f,0.0f);
}
else
{
verts->vTangent = mesh->mTangents[x];
verts->vBitangent = mesh->mBitangents[x];
}
if (mesh->HasTextureCoords(1))
verts->vTextureUV2 = mesh->mTextureCoords[1][x];
else
verts->vTextureUV2 = aiVector3D(0.5f,0.5f, 0.0f);
if( mesh->HasBones()){
unsigned char boneIndices[4] = { 0, 0, 0, 0 };
unsigned char boneWeights[4] = { 0, 0, 0, 0 };
ai_assert( weightsPerVertex[x].size() <= 4);
for( unsigned int a = 0; a < weightsPerVertex[x].size(); a++){
boneIndices[a] = weightsPerVertex[x][a].mVertexId;
boneWeights[a] = (unsigned char) (weightsPerVertex[x][a].mWeight * 255.0f);
}
memcpy( verts->mBoneIndices, boneIndices, sizeof( boneIndices));
memcpy( verts->mBoneWeights, boneWeights, sizeof( boneWeights));
}
else{
// memset( verts->mBoneIndices, 0, sizeof( verts->mBoneIndices));
// memset( verts->mBoneWeights, 0, sizeof( verts->mBoneWeights));
}
*/
++verts;
}
glUnmapBufferARB(GL_ARRAY_BUFFER_ARB); //invalidates verts
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
}