static void camera_init()
{
camera.position[_X] = 0;
camera.position[_Y] = 0;
camera.position[_Z] = 0;
MatrixIdentity(xRotMatrix);
MatrixIdentity(yRotMatrix);
MatrixIdentity(zRotMatrix);
MatrixIdentity(translateMatrix);
}
void CModelObject::Init( int nParts )
{
memset( &m_Element[nParts], 0, sizeof(O3D_ELEMENT) );
m_Element[nParts].m_nParentIdx = -1;
MatrixIdentity( m_Element[nParts].m_mLocalRH );
MatrixIdentity( m_Element[nParts].m_mLocalLH );
MatrixIdentity( m_Element[nParts].m_mLocalShield );
MatrixIdentity( m_Element[nParts].m_mLocalKnuckle );
MatrixIdentity( m_Element[nParts].m_mLocalTM );
}
//コンストラクタ(読み込み)
XFrame::XFrame(XModel *model)
{
index = model->Frame.size(); //フレーム番号を格納
model->Frame.push_back(this); //フレームをベクターに追加
//行列の初期化
MatrixIdentity(TransformMatrix);
MatrixIdentity(OffsetMatrix);
//フレーム名の取得
GetToken();
name = new char[strlen(Token)+1];
strcpy(name, Token);
//フレームからうまく抜けるため、現在のノード記憶
int node = Node;
//次のトークンが"{"であると確認する
GetToken("{");
//変換行列と子フレーム読み込み
while (*Pointer!='\0') {
GetToken();
//ノードが終わったらループを抜ける
if ( node == Node ) break;
//フレームの場合、子フレームを作成
if ( CheckToken("Frame") ) {
child.push_back(new XFrame(model));
}
// 変換行列を読み込む
else if ( CheckToken("FrameTransformMatrix") ) {
GetToken("{");
for(int g=0; g<4; g++)
for(int r=0; r<4; r++)
TransformMatrix[g][r]=GetFloatToken();
GetToken("}");
}
// 子フレームと変換行列以外の時
else {
//要素を識別して読み込み
if( !model->Load_element() )
model->loaded |= 1; //エラー検出
}
}
}
void CRender::BeginRender()
{
_pCoreRenderer->Clear();
_pCoreRenderer->SetMatrix(MatrixIdentity());
_pRender2D->BeginFrame();
}
/* Animation system initialization function.
* ARGUMENTS:
* - window:
* HWND hWnd;
* RETURNS: None.
*/
VOID DS1_AnimInit( HWND hWnd )
{
INT i;
PIXELFORMATDESCRIPTOR pfd = {0};
LARGE_INTEGER t;
memset(&DS1_Anim, 0, sizeof(ds1ANIM));
/* Store window and create memory device context */
DS1_Anim.hWnd = hWnd;
DS1_Anim.hDC = GetDC(hWnd);
DS1_Anim.NumOfUnits = 0;
/* OpenGL init: pixel format setup */
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL;
pfd.cColorBits = 32;
pfd.cDepthBits = 32;
i = ChoosePixelFormat(DS1_Anim.hDC, &pfd);
DescribePixelFormat(DS1_Anim.hDC, i, sizeof(pfd), &pfd);
SetPixelFormat(DS1_Anim.hDC, i, &pfd);
/* OpenGL init: setup rendering context */
DS1_Anim.hGLRC = wglCreateContext(DS1_Anim.hDC);
wglMakeCurrent(DS1_Anim.hDC, DS1_Anim.hGLRC);
/* OpenGL init: setup extensions: GLEW library */
if (glewInit() != GLEW_OK ||
!(GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader))
{
wglMakeCurrent(NULL, NULL);
wglDeleteContext(DS1_Anim.hGLRC);
ReleaseDC(DS1_Anim.hWnd, DS1_Anim.hDC);
exit(0);
}
/* Timer initialization */
QueryPerformanceFrequency(&t);
DS1_TimePerSec = t.QuadPart;
QueryPerformanceCounter(&t);
DS1_StartTime = DS1_OldTime = DS1_OldTimeFPS = t.QuadPart;
DS1_PauseTime = 0;
DS1_RndMatrWorld = MatrixIdentity();
DS1_RndMatrProj = MatrFrustum(-1, 1, -1, 1, 1, 100);
DS1_RndMatrView = MatrView(VecSet(0, 0, 3), VecSet(0, 0, 0), VecSet(0, 1, 0));
/* OpenGL specific initialization */
glClearColor((FLT)100 / 255, (FLT)200 / 255, (FLT)150 / 255, 1);
/*
RGB(100, 200, 150)
glClearColor(0.3, 0.5, 0.7, 1);
*/
DS1_Anim.ShNo = 1;
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
DS1_RndPrg = DS1_RndShaderLoad( (DS1_Anim.ShNo == 1) ? DS1_SHADER_NAME_1 : DS1_SHADER_NAME_2);
/* glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); */
} /* End of 'DS1_ANIMInit' function */
CLUSTER *
MRISclusterKMeans(MRI_SURFACE *mris, MRI *mri_profiles, int k, char *start_fname, MRI_SURFACE *mris_ico) {
int i, nsamples, iter, done, nchanged ;
char fname[STRLEN] ;
CLUSTER *ct ;
nsamples = mri_profiles->nframes ;
ct = calloc(k, sizeof(CLUSTER)) ;
for (i = 0 ; i < k ; i++) {
ct[i].v_mean = VectorAlloc(nsamples, MATRIX_REAL) ;
ct[i].m_cov = MatrixIdentity(nsamples, NULL) ;
ct[i].npoints = 0 ;
}
initialize_kmeans_centers(mris, mri_profiles, ct, k) ;
done = iter = 0 ;
do {
nchanged = mark_clusters(mris, mri_profiles, ct, k) ;
if (nchanged == 0)
done = 1 ;
compute_cluster_statistics(mris, mri_profiles, ct, k) ;
sprintf(fname, "%s.clusters%6.6d.annot",
mris->hemisphere == LEFT_HEMISPHERE ? "lh" : "rh", iter) ;
printf("%6.6d: writing %s\n", iter, fname) ;
MRISwriteAnnotation(mris, fname) ;
sprintf(fname, "./%s.clusters%6.6d.indices",
mris->hemisphere == LEFT_HEMISPHERE ? "lh" : "rh", iter) ;
MRISwriteCurvature(mris, fname) ;
if (iter++ > max_iterations)
done = 1 ;
} while (!done) ;
return(ct) ;
}
VOID ViewRotate(MATRIX M, REAL x, REAL y, REAL z)
{
REAL r, rx;
rx = sqrt(x*x + z*z);
if (ABS(rx) < RAYEPS)
{
MatrixIdentity(M);
Rotate(X_AXIS, M, PI_over_2 * (Sign(y)));
return;
}
r = sqrt(x*x + y*y + z*z);
M[0][0] = z/rx;
M[0][1] = -x*y/(r*rx);
M[0][2] = x/r;
M[0][3] = 0.0;
M[1][0] = 0.0;
M[1][1] = rx/r;
M[1][2] = y/r;
M[1][3] = 0.0;
M[2][0] = -x/rx;
M[2][1] = -y*z/(r*rx);
M[2][2] = z/r;
M[2][3] = 0.0;
M[3][0] = 0.0;
M[3][1] = 0.0;
M[3][2] = 0.0;
M[3][3] = 1.0;
}
/*
* The idea is to push all the prepared on client side to pipeline before draw():
* i.e. this needs to be called just before drawing
* Delivers current matrix stack snapshot to shader (through matrix uniforms @sa vert and frag shader programs),
* updates uniform and vertex variables used by shader so that shader has all needed info
* before draw method (following this).
*/
void PiperGL20::setupChangedVariables()
{
MATRIX mView;
MatrixIdentity(mView);
const MATRIX &mViewProjection = modeMatrix[Piper::PROJECTION].top();
const MATRIX &mModel = modeMatrix[Piper::MODEL].top();
const MATRIX &mModelView = mModel;
// not used - view is always identity
// MatrixMultiply(mViewProjection, mView, modeMatrix[Piper::PROJECTION].top());
// MatrixMultiply(mModelView, mModel, mView);
// Calculate model view projection matrix
MATRIX mMVP;
MatrixMultiply(mMVP, mModel, mViewProjection);
MATRIX mTIM;
MatrixInverse(mTIM, mModel);
MatrixTranspose(mTIM, mTIM);
ShaderData *shader = shaderManager->shaderAt(active_shader);
// Then passes the matrix to that variable
glUniformMatrix4fv( shader->PMVMatrixHandle, 1, GL_FALSE, mMVP.f);
glUniformMatrix4fv( shader->MVMatrixHandle, 1, GL_FALSE, mModelView.f);
glUniformMatrix4fv( shader->ModelMatrixHandle, 1, GL_FALSE, mModel.f);
glUniformMatrix4fv( shader->ViewMatrixHandle, 1, GL_FALSE, mView.f);
glUniformMatrix4fv( shader->TIMMatrixHandle, 1, GL_FALSE, mTIM.f);
if (memcmp(color, previousSetColor, 4 * sizeof(GLfloat))) {
glUniform4f(shader->ColorHandle, color[0], color[1], color[2], color[3]);
memcpy(previousSetColor, color, 4 * sizeof(GLfloat));
}
}
void MatrixInverse( Matrix matOut, const Matrix matSrc )
{
Matrix matTemp;
memcpy( matTemp, matSrc, sizeof(Matrix) );
MatrixIdentity( matOut );
//掃き出し法
for( int i = 0 ; i < 4 ; i++ )
{
float buf = 1 / matTemp[i][i];
for( int j = 0 ; j < 4 ; j++ )
{
matTemp[i][j] *= buf;
matOut[i][j] *= buf;
}
for( int j = 0 ; j < 4 ; j++ )
{
if( i != j )
{
buf = matTemp[j][i];
for( int k = 0 ; k < 4 ; k++ )
{
matTemp[j][k] -= matTemp[i][k] * buf;
matOut[j][k] -= matOut[i][k] * buf;
}
}
}
}
}
/*-----------------------------------------------------
Parameters:
Returns value:
Description
------------------------------------------------------*/
static int
init_translation(MRI *mri_in, MRI *mri_ref, MATRIX *m_L) {
MATRIX *m_translation ;
float in_means[4], ref_means[4] ;
double dx, dy, dz ;
m_translation = MatrixIdentity(4, NULL) ;
MRIfindCenterOfBrain(mri_in, in_means, in_means+1, in_means+2) ;
MRIfindCenterOfBrain(mri_ref, ref_means, ref_means+1, ref_means+2) ;
dx = (double)(ref_means[0] - in_means[0]) * mri_in->thick ;
dy = (double)(ref_means[1] - in_means[1]) * mri_in->thick ;
dz = (double)(ref_means[2] - in_means[2]) * mri_in->thick ;
if (Gdiag & DIAG_SHOW) {
fprintf(stderr, "centering template around (%d,%d,%d) and input around"
" (%d,%d,%d)\n",
(int)ref_means[0], (int)ref_means[1], (int)ref_means[2],
(int)in_means[0], (int)in_means[1], (int)in_means[2]) ;
fprintf(stderr, "initial translation = (%2.0f, %2.0f, %2.0f).\n",dx,dy,dz);
}
*MATRIX_RELT(m_translation, 1, 4) = dx ;
*MATRIX_RELT(m_translation, 2, 4) = dy ;
*MATRIX_RELT(m_translation, 3, 4) = dz ;
MatrixMultiply(m_translation, m_L, m_L) ;
MatrixFree(&m_translation) ;
return(NO_ERROR) ;
}
void CRender::OnResize(uint uiWidth, uint uiHeight)
{
_pCoreRenderer->SetViewport(0, 0, uiWidth, uiHeight);
_SetPerspectiveMatrix(uiWidth, uiHeight);
_pCoreRenderer->SetMatrix(MatrixIdentity());
}
Matrix TranslationMatrix(Vector displacement)
{
Matrix matrix=MatrixIdentity();
matrix.Data[12]-=displacement.X;
matrix.Data[13]-=displacement.Y;
matrix.Data[14]-=displacement.Z;
return matrix;
}
void
MatrixScaling(Matrix &out, float x, float y, float z)
{
MatrixIdentity(out);
out.m[0][0] = x;
out.m[1][1] = y;
out.m[2][2] = z;
}
void
MatrixTranslation(Matrix &out, float x, float y, float z)
{
MatrixIdentity(out);
out.m[3][0] = x;
out.m[3][1] = y;
out.m[3][2] = z;
}
MATRIX MatrixScale(float x, float y, float z)
{
MATRIX result = MatrixIdentity();
result.data[0][0] = x;
result.data[1][1] = y;
result.data[2][2] = z;
return result;
}
MATRIX MatrixTranslation(float x, float y, float z)
{
MATRIX result = MatrixIdentity();
result.data[3][0] = x;
result.data[3][1] = y;
result.data[3][2] = z;
return result;
}
SkinControllerImpl::SkinControllerImpl(Scene *s, size_t weightedJointCount, size_t bindingCount)
: BaseImpl(s)
, m_pBaseMesh(NULL)
, m_isBindingLocked(false)
, m_isJointsLocked(false)
{
assert(bindingCount && weightedJointCount);
MatrixIdentity(&m_bindShape);
m_weightedJoints.resize(weightedJointCount);
m_weightBinding.resize(bindingCount);
}
//======================
// 各変数の初期値を設定
//======================
void cPMDBone::reset( void )
{
m_vec3Position.x = m_vec3Position.y = m_vec3Position.z = 0.0f;
m_vec4Rotation.x = m_vec4Rotation.y = m_vec4Rotation.z = 0.0f; m_vec4Rotation.w = 1.0f;
m_vec4LookRotation = m_vec4Rotation;
MatrixIdentity( m_matLocal );
m_matLocal[3][0] = m_vec3OrgPosition.x;
m_matLocal[3][1] = m_vec3OrgPosition.y;
m_matLocal[3][2] = m_vec3OrgPosition.z;
}
void
MatrixRotationZ(Matrix &out, float theta)
{
MatrixIdentity(out);
theta *= 3.141592653589793f / 180;
out.m[0][0] = (float)cos(theta);
out.m[1][1] = out.m[0][0];
out.m[0][1] = (float)sin(theta);
out.m[1][0] = -out.m[0][1];
}
void CRender3D::BeginFrame()
{
_ui64DrawDelay = GetPerfTimer();
_bFrCalculated = false;
_uiObjsDrawnCount = 0;
while (!_stackStates.empty())
_stackStates.pop();
_stCurState.matrixStack.Clear(MatrixIdentity());
_pCoreRenderer->SetMatrix(_stCurState.matrixStack.Top());
}
//==========================
// ボーンを指定座標へ向ける
//==========================
void cPMDBone::lookAt( const Vector3 *pvecTargetPos, float fLimitXD, float fLimitXU, float fLimitY )
{
// どうもおかしいので要調整
Matrix matTemp;
MatrixIdentity( matTemp );
matTemp[3][0] = m_vec3Position.x + m_vec3Offset.x;
matTemp[3][1] = m_vec3Position.y + m_vec3Offset.y;
matTemp[3][2] = m_vec3Position.z + m_vec3Offset.z;
if( m_pParentBone )
{
Matrix matInvTemp;
MatrixInverse( matInvTemp, m_pParentBone->m_matLocal );
matInvTemp[3][0] = m_pParentBone->m_matLocal[3][0];
matInvTemp[3][1] = m_pParentBone->m_matLocal[3][1];
matInvTemp[3][2] = -m_pParentBone->m_matLocal[3][2];
MatrixMultiply( matTemp, matTemp, matInvTemp );
}
MatrixInverse( matTemp, matTemp );
Vector3 vec3LocalTgtPosZY;
Vector3 vec3LocalTgtPosXZ;
Vector3Transform( &vec3LocalTgtPosZY, pvecTargetPos, matTemp );
vec3LocalTgtPosXZ = vec3LocalTgtPosZY;
vec3LocalTgtPosXZ.y = 0.0f;
Vector3Normalize( &vec3LocalTgtPosXZ, &vec3LocalTgtPosXZ );
vec3LocalTgtPosZY.x = 0.0f;
Vector3Normalize( &vec3LocalTgtPosZY, &vec3LocalTgtPosZY );
Vector3 vec3Angle = { 0.0f, 0.0f, 0.0f };
vec3Angle.x = asinf( vec3LocalTgtPosZY.y );
if( vec3LocalTgtPosXZ.x < 0.0f ) vec3Angle.y = acosf( vec3LocalTgtPosXZ.z );
else vec3Angle.y = -acosf( vec3LocalTgtPosXZ.z );
if( vec3Angle.x < RAD(fLimitXD) ) vec3Angle.x = RAD(fLimitXD);
if( RAD(fLimitXU) < vec3Angle.x ) vec3Angle.x = RAD(fLimitXU);
if( vec3Angle.y < RAD(-fLimitY) ) vec3Angle.y = RAD(-fLimitY);
if( RAD(fLimitY) < vec3Angle.y ) vec3Angle.y = RAD( fLimitY);
Vector4 vec4RotTemp;
QuaternionCreateEuler( &vec4RotTemp, &vec3Angle );
QuaternionSlerp( &m_vec4LookRotation, &m_vec4LookRotation, &vec4RotTemp, 0.5f ); // 0.3f ); // 視線の動きを高速化
m_vec4Rotation = m_vec4LookRotation;
}
MATRIX MatrixRotationZ(float angle)
{
MATRIX result = MatrixIdentity();
float fcos = cosf(-angle), fsin = sinf(-angle);
result.data[0][0] = fcos;
result.data[1][0] = -fsin;
result.data[0][1] = fsin;
result.data[1][1] = fcos;
return result;
}
void CRender3D::SetDefaultStates()
{
uint vp_x, vp_y, vp_width, vp_height;
_pCoreRenderer->GetViewport(vp_x, vp_y, vp_width, vp_height);
_stCurState.fFovAngle = 60.f;
_stCurState.fZNear = 0.25f;
_stCurState.fZFar = 1000.f;
_SetPerspectiveMatrix(vp_width, vp_height);
_stCurState.matrixStack.Clear(MatrixIdentity());
_pCoreRenderer->SetMatrix(_stCurState.matrixStack.Top());
_stCurState.isLightingEnabled = false;
_stCurState.stGlobalAmbient = TColor4(50, 50, 50, 255);
_stCurState.stFogDesc.bEnabled = false;
_stCurState.stFogDesc.stColor = ColorGray();
_stCurState.stFogDesc.fStart = 500.f;
_stCurState.stFogDesc.fEnd = 1000.f;
if (_pFFP)
{
_pFFP->ToggleGlobalLighting(_stCurState.isLightingEnabled);
_pFFP->SetGloablAmbientLight(_stCurState.stGlobalAmbient);
_pFFP->SetFogEnabled(_stCurState.stFogDesc.bEnabled);
_pFFP->SetFogColor(_stCurState.stFogDesc.stColor);
_pFFP->ConfigureFog(_stCurState.stFogDesc.fStart, _stCurState.stFogDesc.fEnd);
}
_stCurState.eBlendingMode = BE_NORMAL;
_stCurState.stBlendStateDesc = TBlendStateDesc();
_pCoreRenderer->SetBlendState(_stCurState.stBlendStateDesc);
_stCurState.stDepthStencilDesc = TDepthStencilDesc();
_pCoreRenderer->SetDepthStencilState(_stCurState.stDepthStencilDesc);
_stCurState.stRasterStateDesc = TRasterizerStateDesc();
_stCurState.stRasterStateDesc.eCullMode = PCM_BACK;
_pCoreRenderer->SetRasterizerState(_stCurState.stRasterStateDesc);
_stCurState.stColor = ColorWhite();
_pCoreRenderer->SetColor(_stCurState.stColor);
_stCurState.pCurMat = INVALID_MATERIAL;
Core()->pRender()->Unbind(EOT_UNKNOWN);
}
void Ortho(float left, float right, float bottom, float top, float zNear, float zFar, float *out)
{
float m[16];
MatrixIdentity(m);
m[0*4+0]=2/(right-left);
m[1*4+1]=2/(top-bottom);
m[2*4+2]=-2/(zFar-zNear);
m[3*4+0]=-(right+left)/(right-left);
m[3*4+1]=-(top+bottom)/(top-bottom);
m[3*4+2]=-(zFar+zNear)/(zFar-zNear);
MatrixMult(m, out, out);
}
OGModelNode* COGModelSkeleton::BuildSG ()
{
bool bRootCreated = false;
OGModelNode* pRoot = NULL;
size_t n = m_Nodes.size();
for (size_t i = 0; i < n; ++i)
{
OGModelNode* pCurNode = m_Nodes[i];
pCurNode->nIdx = i;
int curParent = pCurNode->nIdxParent;
if (curParent == -1)
{
if (pRoot != NULL)
{
if (bRootCreated)
{
AttachChild(pRoot, pCurNode);
}
else
{
OGModelNode* pSingleRootNode = new OGModelNode();
OGMatrix mIdentity;
MatrixIdentity(mIdentity);
pSingleRootNode->mTransformList.push_back(mIdentity);
pSingleRootNode->BodyType = OG_SUBMESH_DUMMY;
pSingleRootNode->nIdx = n;
pSingleRootNode->nIdxParent = -1;
AttachChild(pSingleRootNode, pCurNode);
AttachChild(pSingleRootNode, pRoot);
pRoot = pSingleRootNode;
m_Nodes.push_back(pSingleRootNode);
bRootCreated = true;
}
}
else
{
pRoot = pCurNode;
}
}
else
{
OGModelNode* pNodeParent = m_Nodes[curParent];
pNodeParent->nIdx = curParent;
AttachChild(pNodeParent, pCurNode);
}
}
return pRoot;
}
//コンストラクタ
boxOBJ::boxOBJ() {
DisplayList = 0;
texturePNG = 0;
laston = 0;
laston_i = 0;
r = 0.0;
MatrixIdentity(mat.m);
//行列初期化
for(int i=0; i<16; i++){
if(i%5 == 0){
Matrix[i] = 1.0;
}else{
Matrix[i] = 0.0;
}
}
isSet = false;
}
static FUNC *ConvertTransform( FUNC *func, EDAT xform[16] )
{
int d, which ;
FUNC *loop ;
static EDAT gnew[16] = ZERO_EDAT_16 ;
EXPR *arg, *expr ;
MatrixMultiInit(4) ;
for( loop = func ; loop ; loop = OpticForward( FuncNext(loop) ) )
{
which = (int) ( ExprValue( FuncArg( loop, 0 ) ) + 0.49 ) ;
if( which > 5 ) /* surface */
break ;
arg = Copy( FuncArg( loop, 1 ) ) ;
if( FuncIsReversed( loop ) )
arg = Ecc( arg, "u-", Garbage() ) ;
MatrixIdentity( 4, gnew ) ;
if( which < 3 )
gnew[ RC( which, 3 ) ].E = ECc( arg, "u-", Garbage() ) ;
else
{
d = which - 3 ;
expr = ECc( arg, "cos", Garbage() ) ;
gnew[ RC( (d+1)%3, (d+1)%3 ) ].E = Copy( expr ) ;
gnew[ RC( (d+2)%3, (d+2)%3 ) ].E = expr ;
expr = ECc( arg, "sin", Garbage() ) ;
gnew[ RC( (d+1)%3, (d+2)%3 ) ].E = Copy( expr ) ;
expr = Ecc( expr, "u-", Garbage() ) ;
gnew[ RC( (d+2)%3, (d+1)%3 ) ].E = expr ;
}
Free( arg ) ;
MatrixMultiNew( 4, gnew ) ;
MatrixZero( 4, gnew ) ; /* free it up */
}
MatrixMultiResult( 4, xform ) ;
MatrixMultiInit(4) ;
return loop ;
}
static int
init_scaling(MRI *mri_in, MRI *mri_ref, MATRIX *m_L) {
MATRIX *m_scaling ;
float sx, sy, sz, dx, dy, dz ;
MRI_REGION in_bbox, ref_bbox ;
m_scaling = MatrixIdentity(4, NULL) ;
MRIboundingBox(mri_in, 60, &in_bbox) ;
MRIboundingBox(mri_ref, 60, &ref_bbox) ;
sx = (float)ref_bbox.dx / (float)in_bbox.dx ;
sy = (float)ref_bbox.dy / (float)in_bbox.dy ;
sz = (float)ref_bbox.dz / (float)in_bbox.dz ;
dx = (ref_bbox.x+ref_bbox.dx-1)/2 - (in_bbox.x+in_bbox.dx-1)/2 ;
dy = (ref_bbox.y+ref_bbox.dy-1)/2 - (in_bbox.y+in_bbox.dy-1)/2 ;
dz = (ref_bbox.z+ref_bbox.dz-1)/2 - (in_bbox.z+in_bbox.dz-1)/2 ;
if (sx > MAX_DX)
sx = MAX_DX ;
if (sx < MIN_DX)
sx = MIN_DX ;
if (sy > MAX_DY)
sy = MAX_DY ;
if (sy < MIN_DY)
sy = MIN_DY ;
if (sz > MAX_DZ)
sz = MAX_DZ ;
if (sz < MIN_DZ)
sz = MIN_DZ ;
if (Gdiag & DIAG_SHOW)
fprintf(stderr, "initial scaling: (%2.2f, %2.2f, %2.2f) <-- "
"(%d/%d,%d/%d,%d/%d)\n",
sx,sy,sz, ref_bbox.dx, in_bbox.dx, ref_bbox.dy, in_bbox.dy,
ref_bbox.dz, in_bbox.dz) ;
*MATRIX_RELT(m_scaling, 1, 1) = sx ;
*MATRIX_RELT(m_scaling, 2, 2) = sy ;
*MATRIX_RELT(m_scaling, 3, 3) = sz ;
#if 0
*MATRIX_RELT(m_L, 1, 4) = dx ;
*MATRIX_RELT(m_L, 2, 4) = dy ;
*MATRIX_RELT(m_L, 3, 4) = dz ;
#endif
MatrixMultiply(m_scaling, m_L, m_L) ;
return(NO_ERROR) ;
}
//========
// 初期化
//========
void cPMDBone::initialize( const PMD_Bone *pPMDBoneData, const cPMDBone pBoneArray[] )
{
// ボーン名のコピー
strncpy( m_szName, pPMDBoneData->szName, 20 );
m_szName[20] = '\0';
// 位置のコピー
m_vec3OrgPosition = pPMDBoneData->vec3Position;
// 親ボーンの設定
if( pPMDBoneData->nParentNo != -1 )
{
m_pParentBone = &(pBoneArray[pPMDBoneData->nParentNo]);
Vector3Sub( &m_vec3Offset, &m_vec3OrgPosition, &m_pParentBone->m_vec3OrgPosition );
}
else
{
// 親なし
m_vec3Offset = m_vec3OrgPosition;
}
// 子ボーンの設定
if( pPMDBoneData->nChildNo != -1 )
{
m_pChildBone = (cPMDBone *)&(pBoneArray[pPMDBoneData->nChildNo]);
}
MatrixIdentity( m_matInvTransform );
m_matInvTransform[3][0] = -m_vec3OrgPosition.x;
m_matInvTransform[3][1] = -m_vec3OrgPosition.y;
m_matInvTransform[3][2] = -m_vec3OrgPosition.z;
m_bIKLimitAngle = false;
// 2009/08/07 Ru--en
m_cbKind = pPMDBoneData->cbKind; // ボーン種類を記憶
m_cbRigidType = 0; // このボーンに関連付いた剛体タイプ
// 各変数の初期値を設定
reset();
}
mat4 MatrixRotate(float ang, float x, float y, float z){
mat4 temp = MatrixIdentity();
const float cosa = cosf(ang*CONST_DEG2RAD);
const float sina = sinf(ang*CONST_DEG2RAD);
const float M = 1.0f - cosa;
float tmp1 = x*y*M;
float tmp2 = z*sina;
temp.m[0] = cosa + x*x*M;
temp.m[5] = cosa + y*y*M;
temp.m[10]= cosa + z*z*M;
temp.m[4] = tmp1 + tmp2;
temp.m[1] = tmp1 - tmp2;
tmp1 = x*z*M;
tmp2 = y*sina;
temp.m[8] = tmp1 - tmp2;
temp.m[2] = tmp1 + tmp2;
tmp1 = y*z*M;
tmp2 = x*sina;
temp.m[9] = tmp1 + tmp2;
temp.m[6] = tmp1 - tmp2;
return temp;
}
