// ***************************************************************************
bool CTransformShape::clip()
{
H_AUTO( NL3D_TrShape_Clip );
CClipTrav &clipTrav= getOwnerScene()->getClipTrav();
if(Shape)
{
// first test DistMax (faster).
float maxDist = getDistMax();
// if DistMax test enabled
if(maxDist!=-1)
{
// Calc the distance
float sqrDist = (clipTrav.CamPos - getWorldMatrix().getPos()).sqrnorm ();
maxDist*=maxDist;
// if dist > maxDist, skip
if (sqrDist > maxDist)
{
// Ok, not shown
return false;
}
}
// Else finer clip with pyramid, only if needed
if(clipTrav.ForceNoFrustumClip)
return true;
else
return Shape->clip(clipTrav.WorldPyramid, getWorldMatrix());
}
else
return false;
}
type_result HierarchySubReferer::_render( D3DMATERIAL9& material )
{
_initializeMesh();
// main:
// DX9 바인딩:
DX9& dx9 = getDependent();
if( ! &dx9)
{
ALERT_ERROR(" : 디바이스 바인딩 실패로 중지");
return RESULT_TYPE_ERROR;
}
LPDIRECT3DDEVICE9 device = dx9.getDevice();
// 월드좌표 갱신:
D3DXMATRIX& world = getWorldMatrix();
D3DXMATRIX origin;
device->GetTransform(D3DTS_WORLD, &origin);
device->SetTransform(D3DTS_WORLD, &world);
device->SetRenderState(D3DRS_AMBIENT, 0xffffffff);
//device->SetTexture(0, NULL);
device->SetMaterial(&material);
device->SetTexture(0, 0);
if(_ball)
{
_ball->DrawSubset(0);
}
// 자식과 선을 잇기:
device->SetTransform(D3DTS_WORLD, &origin);
_searchModuleSet(getConnector().getModuleCodeSetKey().getValue(), &ThisClass::_renderLineBetweenChild); // 월드 좌표 복귀:
return RESULT_SUCCESS;
}
// ***************************************************************************
void CTransformShape::traverseLoadBalancingPass0()
{
CLoadBalancingTrav &loadTrav= getOwnerScene()->getLoadBalancingTrav();
CSkeletonModel *skeleton= getSkeletonModel();
// World Model position
const CVector *modelPos;
// If this isntance is binded or skinned to a skeleton, take the world matrix of this one as
// center for LoadBalancing Resolution.
if(skeleton)
{
// Take the root bone of the skeleton as reference (bone 0)
// And so get our position.
modelPos= &skeleton->Bones[0].getWorldMatrix().getPos();
}
else
{
// get our position from
modelPos= &getWorldMatrix().getPos();
}
// Then compute distance from camera.
float modelDist= ( loadTrav.CamPos - *modelPos).norm();
// Get the number of triangles this model use now.
_FaceCount= getNumTriangles(modelDist);
_LoadBalancingGroup->addNbFacesPass0(_FaceCount);
}
bool
Shape::pointInShape(boost::int32_t x, boost::int32_t y) const
{
SWFMatrix wm = getWorldMatrix();
wm.invert();
point lp(x, y);
wm.transform(lp);
// FIXME: if the shape contains non-scaled strokes
// we can't rely on boundary itself for a quick
// way out. Bounds supposedly already include
// thickness, so we might keep a flag telling us
// whether *non_scaled* strokes are present
// and if not still use the boundary check.
// NOTE: just skipping this test breaks a corner-case
// in DrawingApiTest (kind of a fill-leakage making
// the collision detection find you inside a self-crossing
// shape).
if (_def) {
if (!_def->bounds().point_test(lp.x, lp.y)) return false;
return _def->pointTestLocal(lp.x, lp.y, wm);
}
assert(_shape.get());
if (!_shape->getBounds().point_test(lp.x, lp.y)) return false;
return _shape->pointTestLocal(lp.x, lp.y, wm);
}
void SceneManager::vist(const NodePtr &node)
{
if (node->getEntity()->getTransform()->refreshFlags & Transform::RF_LOCAL_TRANSFORM) {
this->sceneTransformUpdateBucket.push_back(node);
}
if (node->isVisible()) {
auto renderElement = node->getComponent<RenderElement>();
if (renderElement) {
auto transform = node->getEntity()->getTransform();
auto material = renderElement->getMaterial();
auto mesh = renderElement->getMesh();
this->renderManger.getRenderQueue().addRenderable(transform->getWorldMatrix(),
material, mesh->getMeshData(), material->getQueueID());
} else if (node->getComponent<ui::ElementBatcher>()) {
auto batcher = node->getComponent<ui::ElementBatcher>();
batcher->Render();
}
for (auto& child : node->getChildren()) {
this->vist(child);
}
}
}
void ATOM_LightNode::updateLightParams (const ATOM_Matrix4x4f &projMatrix, const ATOM_Matrix4x4f &viewMatrix)
{
if (_transformChanged)
{
_transformChanged =false;
const ATOM_Matrix4x4f &worldMatrix = getWorldMatrix ();
ATOM_Light::LightType type = _light->getLightType ();
if (type == ATOM_Light::Point || type == ATOM_Light::Spot)
{
_light->setPosition (ATOM_Vector3f(worldMatrix.m30, worldMatrix.m31, worldMatrix.m32));
}
if (type == ATOM_Light::Directional || type == ATOM_Light::Spot)
{
_light->setDirection (worldMatrix.transformVector (ATOM_Vector3f(0.f, 0.f, 1.f)));
}
_light->setRange (getScale ());
}
//const ATOM_Vector4f &colorFactor = _useGlobalColorKeys ? ATOM_RenderSettings::getLightTimeFactor () : _colorKeys.getCurrentValue ();
_light->setColor4f (_color);
}
void ShaderParamSet::setupGlobalParam( IShaderParamInput* input , ShaderParamGroup& paramGroup )
{
for ( ShaderParamList::iterator iter( paramGroup.paramList.begin() ),
itEnd( paramGroup.paramList.end() );
iter != itEnd ; ++iter )
{
switch( iter->content )
{
case SP_WORLD:
input->setUniform( iter->varName.c_str() , getWorldMatrix() );
break;
case SP_VIEW :
input->setUniform( iter->varName.c_str() , getViewMatrix() );
break;
case SP_PROJ :
input->setUniform( iter->varName.c_str() , getProjectMatrix() );
break;
case SP_WORLD_INV :
input->setUniform( iter->varName.c_str() , getInvWorldMatrix() );
break;
case SP_VIEW_PROJ :
input->setUniform( iter->varName.c_str() , getViewProjMatrix() );
break;
case SP_WVP :
input->setUniform( iter->varName.c_str() , getWVPMatrix() );
break;
case SP_WORLD_VIEW:
input->setUniform( iter->varName.c_str() , getWorldViewMatrix() );
break;
//case SP_AMBIENT_LIGHT:
// input->setUniform( iter->varName.c_str() , scene->setAmbientLight() );
}
}
}
void CMyObject::drawSubset(IDirect3DDevice9* pd3dDevice, ULONG AttributeID, ID3DXEffect * effect, UINT numPass, D3DXMATRIX ViewProj)
{
ULONG * pAtrributeMap;
ULONG nAttributeCount;
//int wtf;
if (m_useCustomAttribMap)//check if to use custom attributes for this object or the default ones used in mesh creation
{
pAtrributeMap = m_pCustomAtribbMap;
nAttributeCount = m_customAtrribCount;
}
else
{
pAtrributeMap = m_pMesh->getAtrributeMap();
nAttributeCount = m_pMesh->getAttributeCount();
}
for (ULONG i = 0 ; i < nAttributeCount ; i++)
{
if (pAtrributeMap[i] == AttributeID)//check for the corresponding attribute in the attribute map
{
if (pd3dDevice)// if there was given a d3d device function should also set world transformation
{
// pd3dDevice->SetTransform( D3DTS_WORLD, &getWorldMatrix() );
// pd3dDevice->SetFVF( m_pMesh->GetFVF() );
//wtf = pd3dDevice->Release();
}
effect->SetMatrix(m_matWorldViewProjH, &(getWorldMatrix() * ViewProj) );
effect->SetMatrix(m_matWorldH, &getWorldMatrix());
D3DXMATRIX worldInverseTranspose;
D3DXMatrixInverse(&worldInverseTranspose, 0, &getWorldMatrix());
D3DXMatrixTranspose(&worldInverseTranspose, &worldInverseTranspose);
effect->SetMatrix(m_matWorldTH, &worldInverseTranspose);
//effect->SetMatrix("matWorldViewProj", &(getWorldMatrix() * ViewProj) );
//effect->SetMatrix("matWorld", &getWorldMatrix());
effect->BeginPass(numPass);
m_pMesh->DrawSubset(i);//found the correct attribute draw it
effect->EndPass();
break;//no need to keep scaning as we have found the attribute
}
}
}
mat3f Transformable::getWorldNormalMatrix()
{
mat4f w = getWorldMatrix();
return mat3f(w.a, w.b, w.c,
w.e, w.f, w.g,
w.i, w.j, w.k);
}
//矩阵变换
void RenderTargetD3D9::setWorldMatrix(const Matrix4 & mtx)
{
//if( m_RenderState.m_mtxWorld == mtx) return; //这种情况很少出现
m_RenderState.m_mtxWorld = mtx;
m_RenderState.m_mtxModelView = m_RenderState.m_mtxView * mtx;
D3DXMATRIX mtxD3D;
getWorldMatrix(mtxD3D);
m_pRenderSystem->getD3D9Device()->getDevice()->SetTransform( D3DTS_WORLD, &mtxD3D);
}
Matrix4 const& ShaderParamSet::getWorldViewMatrix()
{
if ( mDirtyBit & DIRTY_WORLD_VIEW )
{
mWorldView = getWorldMatrix() * getViewMatrix();
mDirtyBit &= ~DIRTY_WORLD_VIEW;
}
return mWorldView;
}
//-----------------------------------------------------------------------------
const Matrix4& AutoParamDataSource::getInverseWorldMatrix(void) const
{
if (mInverseWorldMatrixDirty)
{
mInverseWorldMatrix = getWorldMatrix().inverseAffine();
mInverseWorldMatrixDirty = false;
}
return mInverseWorldMatrix;
}
//-----------------------------------------------------------------------------
const Matrix4& AutoParamDataSource::getWorldViewMatrix(void) const
{
if (mWorldViewMatrixDirty)
{
mWorldViewMatrix = getViewMatrix().concatenateAffine(getWorldMatrix());
mWorldViewMatrixDirty = false;
}
return mWorldViewMatrix;
}
//-----------------------------------------------------------------------------
const Affine3& AutoParamDataSource::getWorldViewMatrix(void) const
{
if (mWorldViewMatrixDirty)
{
mWorldViewMatrix = getViewMatrix() * getWorldMatrix();
mWorldViewMatrixDirty = false;
}
return mWorldViewMatrix;
}
// ZS-->16/03/2015 added Draw function
//ALEX OWEN - 10/04/15 - draw function now passes a world matrix instead of individual values. That
// way the gameobject can decide whether the world matrix needs to be recalculated or not
bool GameObject::Draw( ID3D11DeviceContext* device_context, ID3D11Buffer* world_const_buffer )
{
if (m_display_object)
{
return m_display_object->Draw( device_context, world_const_buffer, getWorldMatrix() );
}
return false;
}
void CMeshCoordinate::render(const Vec3D& vCoordShow)
{
{
init();
}
CRenderSystem& R = CRenderSystem::getSingleton();
CGraphics& G=GetGraphics();
R.setWorldMatrix(getWorldMatrix());
R.SetShader("Coordinate1");
SetMeshSource();
draw();
G.DrawLine3D(m_CoordLines[CLT_X].vBegin,m_CoordLines[CLT_X].vEnd,vCoordShow.x>0?COORD_SELECT_COLOR:COORD_X_COLOR);
G.DrawLine3D(m_CoordLines[CLT_X_Y].vBegin,m_CoordLines[CLT_X_Y].vEnd,(vCoordShow.x>0&&vCoordShow.y>0)?COORD_SELECT_COLOR:COORD_X_COLOR);
G.DrawLine3D(m_CoordLines[CLT_X_Z].vBegin,m_CoordLines[CLT_X_Z].vEnd,(vCoordShow.x>0&&vCoordShow.z>0)?COORD_SELECT_COLOR:COORD_X_COLOR);
G.DrawLine3D(m_CoordLines[CLT_Y].vBegin,m_CoordLines[CLT_Y].vEnd,vCoordShow.y>0?COORD_SELECT_COLOR:COORD_Y_COLOR);
G.DrawLine3D(m_CoordLines[CLT_Y_X].vBegin,m_CoordLines[CLT_Y_X].vEnd,(vCoordShow.x>0&&vCoordShow.y>0)?COORD_SELECT_COLOR:COORD_Y_COLOR);
G.DrawLine3D(m_CoordLines[CLT_Y_Z].vBegin,m_CoordLines[CLT_Y_Z].vEnd,(vCoordShow.y>0&&vCoordShow.z>0)?COORD_SELECT_COLOR:COORD_Y_COLOR);
G.DrawLine3D(m_CoordLines[CLT_Z].vBegin,m_CoordLines[CLT_Z].vEnd,vCoordShow.z>0?COORD_SELECT_COLOR:COORD_Z_COLOR);
G.DrawLine3D(m_CoordLines[CLT_Z_X].vBegin,m_CoordLines[CLT_Z_X].vEnd,(vCoordShow.x>0&&vCoordShow.z>0)?COORD_SELECT_COLOR:COORD_Z_COLOR);
G.DrawLine3D(m_CoordLines[CLT_Z_Y].vBegin,m_CoordLines[CLT_Z_Y].vEnd,(vCoordShow.y>0&&vCoordShow.z>0)?COORD_SELECT_COLOR:COORD_Z_COLOR);
R.SetShader("Coordinate2");
if (vCoordShow.x>0&&vCoordShow.y>0)
{
// G.fillQuad(Vec3D(0,0,0),m_CoordLines[CLT_X_Y].vBegin,m_CoordLines[CLT_X_Y].vEnd,m_CoordLines[CLT_Y_X].vBegin,COORD_PLANE_COLOR);
}
if (vCoordShow.y>0&&vCoordShow.z>0)
{
// G.fillQuad(Vec3D(0,0,0),m_CoordLines[CLT_Y_Z].vBegin,m_CoordLines[CLT_Y_Z].vEnd,m_CoordLines[CLT_Z_Y].vBegin,COORD_PLANE_COLOR);
}
if (vCoordShow.z>0&&vCoordShow.x>0)
{
// G.fillQuad(Vec3D(0,0,0),m_CoordLines[CLT_Z_X].vBegin,m_CoordLines[CLT_Z_X].vEnd,m_CoordLines[CLT_X_Z].vBegin,COORD_PLANE_COLOR);
}
// R.SetBlendFunc(true);
// R.SetTextureColorOP(0,TBOP_MODULATE);
// R.SetTextureAlphaOP(0,TBOP_MODULATE);
//int nFontHeight = GetTextRender().GetCharHeight();
//Pos2D posScreen;
//R.world2Screen(getWorldMatrix()*Vec3D(1.0f,0.0f,0.0f),posScreen);
//GetTextRender().drawText(L"X",posScreen.x,posScreen.y-nFontHeight,vCoordShow.x>0?COORD_SELECT_COLOR:COORD_X_COLOR);
//R.world2Screen(getWorldMatrix()*Vec3D(0.0f,1.0f,0.0f),posScreen);
//GetTextRender().drawText(L"Y",posScreen.x,posScreen.y-nFontHeight,vCoordShow.y>0?COORD_SELECT_COLOR:COORD_Y_COLOR);
//R.world2Screen(getWorldMatrix()*Vec3D(0.0f,0.0f,1.0f),posScreen);
//GetTextRender().drawText(L"Z",posScreen.x,posScreen.y-nFontHeight,vCoordShow.z>0?COORD_SELECT_COLOR:COORD_Z_COLOR);
}
vec3f Transformable::getWorldRight()
{
mat4f w;
vec4f v;
w = getWorldMatrix();
v = w.getCol(0);
return v.xyz();
}
vec3f Transformable::getWorldFront()
{
mat4f w;
vec4f v;
w = getWorldMatrix();
v = w.getCol(2);
return - v.xyz();
}
const Matrix& C3DCamera::getViewMatrix()
{
if (_dirtyBits & CAMERA_DIRTY_VIEW)
{
getWorldMatrix().invert(&_view);
_dirtyBits &= ~CAMERA_DIRTY_VIEW;
}
return _view;
}
//================================================================================
//! メソッド名 CSKIN_MESH::getWorldCenter
//
// 機能 ワールド座標系中心点を受け取る
// 戻り値 ワールド座標系中心点
// 更新 2007/12/08 <新規>
//================================================================================
VEC3
CSKIN_MESH::getWorldCenter(void)
{
// ワールド座標系中心点
VEC3 aCenter;
// ワールド座標系の演算
D3DXVec3TransformCoord(&aCenter, &sd_ptr->mesh->localCenter, getWorldMatrix());
// ワールド座標系中心点を返す
return aCenter;
}
Matrix4 const& ShaderParamSet::getInvWorldMatrix()
{
if ( mDirtyBit & DIRTY_INV_WORLD )
{
float det;
getWorldMatrix().inverse( mInvWorld , det );
mDirtyBit &= ~DIRTY_INV_WORLD;
}
return mInvWorld;
}
vec3f Transformable::getWorldPosition(
vec3f pos
)
{
vec4f v = vec4f(pos.x, pos.y, pos.z, 1.0f);
mat4f w = getWorldMatrix();
v = w * v;
return v.xyz();
}
void ShadedModel::updateLightPositions() {
if(hasAllLights) {
mat4 mat = getWorldMatrix();
std::vector<Light*>::iterator it;
int index = 0;
for(it = lights.begin(); it != lights.end(); it++) {
prog->setUniform(mat * (*it)->getPosition(), "lights[%d].Position",
index);
index++;
}
}
}
void Enemy::render(D3DXMATRIX& p_view, D3DXMATRIX& p_projection)
{
m_device->IASetPrimitiveTopology( D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
D3DXMATRIX worldViewProj = getWorldMatrix() * p_view * p_projection;
m_model->m_vertexBuffer->apply(0);
m_model->m_indexBuffer->apply(0);
m_shader->setMatrix("g_mWorldViewProj", worldViewProj);
D3D10_TECHNIQUE_DESC techDesc;
m_shader->getTechnique()->GetDesc( &techDesc );
for( UINT p = 0; p < techDesc.Passes; p++ )
{
m_shader->apply(p);
m_device->DrawIndexed( m_model->m_size,0, 0);
}
m_volume->draw( getWorldMatrix(), p_view, p_projection );
}
void
Bitmap::add_invalidated_bounds(InvalidatedRanges& ranges, bool force)
{
if (!force && !invalidated()) return;
ranges.add(m_old_invalidated_ranges);
SWFRect bounds;
bounds.expand_to_transformed_rect(getWorldMatrix(*this), getBounds());
ranges.add(bounds.getRange());
}
void
Video::add_invalidated_bounds(InvalidatedRanges& ranges, bool force)
{
if (!force && !invalidated()) return; // no need to redraw
ranges.add(m_old_invalidated_ranges);
assert(m_def);
SWFRect bounds;
bounds.expand_to_transformed_rect(getWorldMatrix(*this), m_def->bounds());
ranges.add(bounds.getRange());
}
void TMIP::process() {
auto volumes = inport_.getData();
if (volumes->empty()) {
return;
}
auto firstVol = volumes->at(0);
if (inport_.isChanged()) {
const DataFormatBase* format = firstVol->getDataFormat();
volume0_ = std::make_shared<Volume>(firstVol->getDimensions(), format);
volume0_->setModelMatrix(firstVol->getModelMatrix());
volume0_->setWorldMatrix(firstVol->getWorldMatrix());
// pass on metadata
volume0_->copyMetaDataFrom(*firstVol);
volume0_->dataMap_ = firstVol->dataMap_;
volume1_ = std::shared_ptr<Volume>(volume0_->clone());
}
int iterations = static_cast<int>(std::ceil(volumes->size() / static_cast<float>(maxSamplers_)));
LogInfo(iterations);
std::shared_ptr<Volume> readVol = volume0_;
std::shared_ptr<Volume> writeVol = volume1_;
int offset = 0;
for (int i = 0; i < iterations; i++) {
bool firstIT = i == 0;
bool lastIT = i != 0 && iterations;
auto startVolIT = volumes->begin() + offset + 1;
if (firstIT) {
auto endVolIT = volumes->begin() + offset + maxSamplers_;
iteration(shader_, volumes->at(0), writeVol, startVolIT, endVolIT);
}
else if (!lastIT) {
auto endVolIT = volumes->begin() + offset + maxSamplers_;
iteration(shader_, readVol, writeVol, startVolIT, endVolIT);
} else {
iteration(shaderLast_, readVol, writeVol, startVolIT, volumes->end());
}
std::swap(readVol, writeVol);
offset += maxSamplers_;
}
outport_.setData(readVol);
}
//================================================================================
//! メソッド名 CSKIN_MESH::draw
//
// 機能 描画
// 機能概要 スキンメッシュの描画を行う
// 引数 inDev Direct3Dデバイス
// 戻り値 TRUE 描画成功
// FALSE 描画失敗
// 更新 2008/05/30 <追加> コメント
//================================================================================
BOOL
CSKIN_MESH::draw(CONST DEV inDev)
{
// 描画の無効性を調べて、無効の時
if( !getVisible())
{
// 描画失敗を返す
return FALSE;
}
// モデルを前向きにする
MAT16 matrix = (*getWorldMatrixInversed()) * (*getWorldMatrix());
return drawSkin(inDev, &matrix);
}
//-----------------------------------------------------------------------------
const Matrix4& AutoParamDataSource::getTextureWorldViewProjMatrix(size_t index) const
{
if (index < OGRE_MAX_SIMULTANEOUS_LIGHTS)
{
if (mTextureWorldViewProjMatrixDirty[index] && mCurrentTextureProjector[index])
{
mTextureWorldViewProjMatrix[index] =
getTextureViewProjMatrix(index) * getWorldMatrix();
mTextureWorldViewProjMatrixDirty[index] = false;
}
return mTextureWorldViewProjMatrix[index];
}
else
return Matrix4::IDENTITY;
}
/* Draws the ground according to the height map provided
* @param void
* @return void
*/
void Ground::draw() {
Renderer::setShader(2);//set current shader to the ground shader
glUseProgram(Renderer::getShader());
glm::mat4 view = glm::lookAt(glm::vec3(0, 250, 1000), glm::vec3(0, 0, 0), glm::vec3(0.0f, 1.0f, 0.0f));
glm::mat4 projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 1000.0f);
GLuint viewID = glGetUniformLocation(Renderer::getShader(), "viewMatrix");
GLuint projID = glGetUniformLocation(Renderer::getShader(), "projectionMatrix");
GLuint worldID = glGetUniformLocation(Renderer::getShader(), "worldMatrix");
GLuint TextureID = glGetUniformLocation(Renderer::getShader(), "myTextureSampler");
GLuint hmScaleID = glGetUniformLocation(Renderer::getShader(), "scaleMatrix");
glm::mat4 scaleMat = glm::scale(glm::mat4(1.f), hmScale);
glUniformMatrix4fv(viewID, 1, GL_FALSE, &view[0][0]);
glUniformMatrix4fv(projID, 1, GL_FALSE, &projection[0][0]);
glUniformMatrix4fv(worldID, 1, GL_FALSE, &getWorldMatrix()[0][0]);
glUniformMatrix4fv(hmScaleID, 1, GL_FALSE, &scaleMat[0][0]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureID);
glUniform1i(TextureID, 0);
glBindVertexArray(vertexArrayID);
glEnable(GL_PRIMITIVE_RESTART);
glPrimitiveRestartIndex(hmRows * hmCols);
int iNumIndices = (hmRows-1)*hmCols*2 + hmRows-1;
glDrawElements(GL_TRIANGLE_STRIP, iNumIndices, GL_UNSIGNED_INT, 0);
//glDrawElements(GL_TRIANGLE_STRIP, HM_SIZE_X*(HM_SIZE_Y-1)*2+HM_SIZE_Y-2, GL_UNSIGNED_INT, 0);
}