forked from bartvdbraak/blender
cb89decfdc
the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
213 lines
5.7 KiB
C++
213 lines
5.7 KiB
C++
/**
|
|
* $Id$
|
|
*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
* All rights reserved.
|
|
*
|
|
* The Original Code is: all of this file.
|
|
*
|
|
* Contributor(s): none yet.
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
#ifdef WIN32
|
|
#pragma warning (disable : 4786)
|
|
#endif //WIN32
|
|
|
|
#include "BL_SkinDeformer.h"
|
|
#include "GEN_Map.h"
|
|
#include "STR_HashedString.h"
|
|
#include "RAS_IPolygonMaterial.h"
|
|
#include "BL_SkinMeshObject.h"
|
|
|
|
//#include "BL_ArmatureController.h"
|
|
#include "DNA_armature_types.h"
|
|
#include "DNA_action_types.h"
|
|
#include "DNA_mesh_types.h"
|
|
#include "DNA_meshdata_types.h"
|
|
#include "BKE_armature.h"
|
|
#include "BKE_action.h"
|
|
#include "MT_Point3.h"
|
|
|
|
extern "C"{
|
|
#include "BKE_lattice.h"
|
|
}
|
|
#include "BKE_utildefines.h"
|
|
|
|
#include "BLI_blenlib.h"
|
|
#include "BLI_arithb.h"
|
|
|
|
#define __NLA_DEFNORMALS
|
|
//#undef __NLA_DEFNORMALS
|
|
|
|
BL_SkinDeformer::BL_SkinDeformer(BL_DeformableGameObject *gameobj,
|
|
struct Object *bmeshobj,
|
|
class BL_SkinMeshObject *mesh,
|
|
BL_ArmatureObject* arma)
|
|
: //
|
|
BL_MeshDeformer(gameobj, bmeshobj, mesh),
|
|
m_armobj(arma),
|
|
m_lastArmaUpdate(-1),
|
|
m_defbase(&bmeshobj->defbase),
|
|
m_releaseobject(false),
|
|
m_poseApplied(false)
|
|
{
|
|
Mat4CpyMat4(m_obmat, bmeshobj->obmat);
|
|
};
|
|
|
|
BL_SkinDeformer::BL_SkinDeformer(
|
|
BL_DeformableGameObject *gameobj,
|
|
struct Object *bmeshobj_old, // Blender object that owns the new mesh
|
|
struct Object *bmeshobj_new, // Blender object that owns the original mesh
|
|
class BL_SkinMeshObject *mesh,
|
|
bool release_object,
|
|
BL_ArmatureObject* arma) :
|
|
BL_MeshDeformer(gameobj, bmeshobj_old, mesh),
|
|
m_armobj(arma),
|
|
m_lastArmaUpdate(-1),
|
|
m_defbase(&bmeshobj_old->defbase),
|
|
m_releaseobject(release_object)
|
|
{
|
|
// this is needed to ensure correct deformation of mesh:
|
|
// the deformation is done with Blender's armature_deform_verts() function
|
|
// that takes an object as parameter and not a mesh. The object matrice is used
|
|
// in the calculation, so we must use the matrix of the original object to
|
|
// simulate a pure replacement of the mesh.
|
|
Mat4CpyMat4(m_obmat, bmeshobj_new->obmat);
|
|
}
|
|
|
|
BL_SkinDeformer::~BL_SkinDeformer()
|
|
{
|
|
if(m_releaseobject && m_armobj)
|
|
m_armobj->Release();
|
|
}
|
|
|
|
void BL_SkinDeformer::Relink(GEN_Map<class GEN_HashedPtr, void*>*map)
|
|
{
|
|
if (m_armobj) {
|
|
void **h_obj = (*map)[m_armobj];
|
|
|
|
if (h_obj)
|
|
SetArmature( (BL_ArmatureObject*)(*h_obj) );
|
|
else
|
|
m_armobj=NULL;
|
|
}
|
|
|
|
BL_MeshDeformer::Relink(map);
|
|
}
|
|
|
|
bool BL_SkinDeformer::Apply(RAS_IPolyMaterial *mat)
|
|
{
|
|
RAS_MeshSlot::iterator it;
|
|
RAS_MeshMaterial *mmat;
|
|
RAS_MeshSlot *slot;
|
|
size_t i;
|
|
|
|
// update the vertex in m_transverts
|
|
Update();
|
|
|
|
// The vertex cache can only be updated for this deformer:
|
|
// Duplicated objects with more than one ploymaterial (=multiple mesh slot per object)
|
|
// share the same mesh (=the same cache). As the rendering is done per polymaterial
|
|
// cycling through the objects, the entire mesh cache cannot be updated in one shot.
|
|
mmat = m_pMeshObject->GetMeshMaterial(mat);
|
|
if(!mmat->m_slots[(void*)m_gameobj])
|
|
return true;
|
|
|
|
slot = *mmat->m_slots[(void*)m_gameobj];
|
|
|
|
// for each array
|
|
for(slot->begin(it); !slot->end(it); slot->next(it)) {
|
|
// for each vertex
|
|
// copy the untransformed data from the original mvert
|
|
for(i=it.startvertex; i<it.endvertex; i++) {
|
|
RAS_TexVert& v = it.vertex[i];
|
|
v.SetXYZ(m_transverts[v.getOrigIndex()]);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
RAS_Deformer *BL_SkinDeformer::GetReplica()
|
|
{
|
|
BL_SkinDeformer *result;
|
|
|
|
result = new BL_SkinDeformer(*this);
|
|
result->ProcessReplica();
|
|
return result;
|
|
}
|
|
|
|
void BL_SkinDeformer::ProcessReplica()
|
|
{
|
|
}
|
|
|
|
//void where_is_pose (Object *ob);
|
|
//void armature_deform_verts(Object *armOb, Object *target, float (*vertexCos)[3], int numVerts, int deformflag);
|
|
bool BL_SkinDeformer::Update(void)
|
|
{
|
|
/* See if the armature has been updated for this frame */
|
|
if (PoseUpdated()){
|
|
float obmat[4][4]; // the original object matrice
|
|
|
|
/* XXX note: where_is_pose() (from BKE_armature.h) calculates all matrices needed to start deforming */
|
|
/* but it requires the blender object pointer... */
|
|
Object* par_arma = m_armobj->GetArmatureObject();
|
|
|
|
/* store verts locally */
|
|
VerifyStorage();
|
|
|
|
/* duplicate */
|
|
for (int v =0; v<m_bmesh->totvert; v++)
|
|
VECCOPY(m_transverts[v], m_bmesh->mvert[v].co);
|
|
|
|
m_armobj->ApplyPose();
|
|
|
|
// save matrix first
|
|
Mat4CpyMat4(obmat, m_objMesh->obmat);
|
|
// set reference matrix
|
|
Mat4CpyMat4(m_objMesh->obmat, m_obmat);
|
|
|
|
armature_deform_verts( par_arma, m_objMesh, NULL, m_transverts, NULL, m_bmesh->totvert, ARM_DEF_VGROUP, NULL, NULL );
|
|
|
|
// restore matrix
|
|
Mat4CpyMat4(m_objMesh->obmat, obmat);
|
|
|
|
#ifdef __NLA_DEFNORMALS
|
|
RecalcNormals();
|
|
#endif
|
|
|
|
/* Update the current frame */
|
|
m_lastArmaUpdate=m_armobj->GetLastFrame();
|
|
|
|
/* indicate that the m_transverts and normals are up to date */
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/* XXX note: I propose to drop this function */
|
|
void BL_SkinDeformer::SetArmature(BL_ArmatureObject *armobj)
|
|
{
|
|
// only used to set the object now
|
|
m_armobj = armobj;
|
|
}
|