C++ Vec3D函数代码示例

/*
 * Draws a Entity with optional offset from parent.
 * If an Animation is active, the frames transformation is added as well.
 * TODO: Shooting brings lags
 */
void Player::draw(Transformation transformation){
    glPushMatrix();

    for(auto& anim : m_PlayingAnimations){
        Transformation *animTransformation = anim.second->tick();
        if(animTransformation == NULL){
            map<string,Animation*>::iterator it = m_PlayingAnimations.find(anim.first);
            m_PlayingAnimations.erase(it);
            continue;
        }
        m_Transformation += *animTransformation;
        //cout << "Adding to scalex " << animTransformation->m_Scale.x << endl;
        //m_Transformation.m_Scale += animTransformation->m_Scale;
    }


    transformation += m_Transformation;
    transformation.m_Scale = m_Transformation.m_Scale;

    Vec3D parentScale = Vec3D(1,1,1);
    if(m_Parent != NULL){
        parentScale = m_Parent->getTransformation()->m_Scale;
    }


    glTranslatef(transformation.m_Translation.x, transformation.m_Translation.y , transformation.m_Translation.z );
    glRotatef(transformation.m_Angle, transformation.m_Rotation.x, transformation.m_Rotation.y , transformation.m_Rotation.z);
    glScalef(transformation.m_Scale.x,transformation.m_Scale.y,transformation.m_Scale.z);

    glColor3f(0.2,0.9,0.2);
//        drawBody();
    glutSolidSphere(1,30,30);

    // Cockpit
    //glPushMatrix();
    glTranslatef(0,0,10 / transformation.m_Scale.z);
    //glScalef(transformation.m_Scale.x / 20,transformation.m_Scale.y / 20, transformation.m_Scale.z / 20);
    glScalef(15 / transformation.m_Scale.x, 20 / transformation.m_Scale.y , 10 / transformation.m_Scale.z);
    glColor3f(0.2,0.2,0.9);
    glutSolidSphere(1,30,30);
    // glPopMatrix();

    glPopMatrix();

    for(auto& part : m_Parts){
        part->draw(transformation);
    }
    //glPopMatrix();
}

Frame::Frame()
    : _offx(0), _offy(0), _width(640), _height(480), 
      _fontsize(12.0), _titlespace(10.0), _cmlspace(10.0), _bg(Vec3D(1,1,1)), _fg(Vec3D(0,0,0)),
      _legend_enable(true), _legend_pos(LEGEND_POS_TOP_RIGHT), _cm_legend(NULL),
      _cml_enable(true), _fixedaspect(PLOT_FIXED_ASPECT_DISABLED), _automargin(true)
{
    _legend.set_font_size( _fontsize );

    // Ruler X1
    _ruler[0].set_coord_index( 0 );
    _ruler[0].set_indir( true );
    _fenable[0] = false;
    _autorange[0] = true;
    _autorange[1] = true;

    // Ruler Y1
    _ruler[1].set_coord_index( 1 );
    _ruler[1].set_indir( false );
    _fenable[1] = false;
    _autorange[2] = true;
    _autorange[3] = true;

    // Ruler X2
    _ruler[2].set_coord_index( 0 );
    _ruler[2].set_indir( false );
    _fenable[2] = false;
    _autorange[4] = true;
    _autorange[5] = true;

    // Ruler Y2
    _ruler[3].set_coord_index( 1 );
    _ruler[3].set_indir( true );
    _fenable[3] = false;
    _autorange[6] = true;
    _autorange[7] = true;
}

 TeteNode::TeteNode(Device* d, QGraphicsItem* parent, QGraphicsScene* scene) :
   RespondNode(d, parent, scene) {
   tete_ = NULL;
   x_vel_ = 0.0;
   y_vel_ = 0.0;
   frame_rect_ = QRectF(-1, -1, 2, 2);
   frame_rect_object_ = NULL;
   mouse_moved_ = true;
   velocity_ = Vec3D();
   dormant_ = false;
   frame_on_needed_ = false;
   frame_on_threshold_ = 1.001;
   setFlag(QGraphicsItem::ItemIsMovable);
   //setAcceptDrops(true); // Needed for drag and drop events (like dragEnterEvent)
 }

bool toxi::geom::AABB::planeBoxOverlap( Vec3D & normal, const float & d, const Vec3D & maxBox )
{
	Vec3D vmin = Vec3D();
	Vec3D vmax = Vec3D();

	if (normal.getX() > 0.0f) {
		vmin.setX( -maxBox.getX() );
		vmax.setX( maxBox.getX() );
	} else {
		vmin.setX( maxBox.getX() );
		vmax.setX( -maxBox.getX() );
	}

	if (normal.getY() > 0.0f) {
		vmin.setY( -maxBox.getY() );
		vmax.setY( maxBox.getY() );
	} else {
		vmin.setY( maxBox.getY() );
		vmax.setY( -maxBox.getY() );
	}

	if (normal.getZ() > 0.0f) {
		vmin.setZ( -maxBox.getZ() );
		vmax.setZ( maxBox.getZ() );
	} else {
		vmin.setZ( maxBox.getZ() );
		vmax.setZ( -maxBox.getZ() );
	}
	if (normal.dot(vmin) + d > 0.0f) {
		return false;
	}
	if (normal.dot(vmax) + d >= 0.0f) {
		return true;
	}
	return false;
}

void TSpawnZone::debugDraw( bool beDebug )
{
    if ( beDebug )
    {
        FnMaterial mat = UF_CreateMaterial();
        mat.SetEmissive( Vec3D(1,1,1) );
        m_dbgObj.Object( getLiveLevel()->getFlyScene().CreateObject() );
        UF_CreateBoxLine( &m_dbgObj , 5 , 5 , 10 , mat.Object());
        m_dbgObj.SetWorldPosition( pos );
    }
    else
    {
        UF_DestoryObject( m_dbgObj );
    }
}

  void setupInitialConditions()
  {	
    BaseParticle p0;
    p0.setRadius(0.005);
    p0.setPosition(Vec3D(0.5*getXMax(),0.5*getYMax(),0.0));
    p0.setVelocity(Vec3D(1.2,1.3,0.0));
    particleHandler.copyAndAddObject(p0);

//! [T7:infiniteWalls]
    InfiniteWall w0;

    w0.set(Vec3D(1.0,0.0,0.0),Vec3D(getXMax(),0.0,0.0));
    wallHandler.copyAndAddObject(w0);

    w0.set(Vec3D(-1.0,0.0,0.0),Vec3D(getXMin(),0.0,0.0));
    wallHandler.copyAndAddObject(w0);

    w0.set(Vec3D(0.0,1.0,0.0),Vec3D(0.0,getYMax(),0.0));
    wallHandler.copyAndAddObject(w0);

    w0.set(Vec3D(0.0,-1.0,0.0),Vec3D(0.0,getYMin(),0.0));
    wallHandler.copyAndAddObject(w0);
//! [T7:infiniteWalls]
  }

Sky::Sky(MPQFile &f)
{
	lightinfo li;
	f.read(&li, 64);

	pos = Vec3D(li.fa/skymul, li.fb/skymul, li.fc/skymul);
	r1 = li.fd / skymul;
	r2 = li.fe / skymul;

	strcpy(name,li.name);

	for (int i=0; i<36; i++) mmin[i] = -2;

	global = (li.ia==-1);
}

void CUIDisplayWorld::MoveCamera(int x, int y)
{
	Matrix mCameraRot;
	// ----
	Vec3D vPos = CGameCamera::getInstance().getTargetPos();
	// ----
	// # 基于摄像机的 yaw 创建旋转矩阵 (Warning ! huihui need translate)
	// ----
	mCameraRot.rotationYawPitchRoll(CGameCamera::getInstance().getYawAngle(), 0, 0);
	// ----
	vPos	+= mCameraRot * Vec3D(x, 0, y) * 0.001f * CGameCamera::getInstance().getRadius();
	// ----
	vPos.y	= CWorld::getInstance().getHeight(vPos.x, vPos.z);
	// ----
	CGameCamera::getInstance().setTargetPos(vPos);
}

Vec3D Sky::colorFor(int r, int t) const
{
    if (mmin[r]<0)
    {
        return Vec3D(0, 0, 0);
    }
    Vec3D c1, c2;
    int t1, t2;
    size_t last = colorRows[r].size() - 1;

    if (t<mmin[r])
    {
        // reverse interpolate
        c1 = colorRows[r][last].color;
        c2 = colorRows[r][0].color;
        t1 = colorRows[r][last].time;
        t2 = colorRows[r][0].time + 2880;
        t += 2880;
    }
    else
    {
        for (size_t i = last; true; i--)
        {   //! \todo iterator this.
            if (colorRows[r][i].time <= t)
            {
                c1 = colorRows[r][i].color;
                t1 = colorRows[r][i].time;

                if (i == last)
                {
                    c2 = colorRows[r][0].color;
                    t2 = colorRows[r][0].time + 2880;
                }
                else
                {
                    c2 = colorRows[r][i + 1].color;
                    t2 = colorRows[r][i + 1].time;
                }
                break;
            }
        }
    }

    float tt = static_cast<float>(t - t1) / static_cast<float>(t2 - t1);
    return c1*(1.0f - tt) + c2*tt;
}

void CFrustum::Build(Vec3D vecMin,Vec3D vecMax)
{
	m_vtx[0] = Vec3D(vecMin.x, vecMin.y,  vecMin.z); // xyz
	m_vtx[1] = Vec3D(vecMax.x, vecMin.y,  vecMin.z); // Xyz
	m_vtx[2] = Vec3D(vecMin.x, vecMax.y,  vecMin.z); // xYz
	m_vtx[3] = Vec3D(vecMax.x, vecMax.y,  vecMin.z); // XYz
	m_vtx[4] = Vec3D(vecMin.x, vecMin.y,  vecMax.z); // xyZ
	m_vtx[5] = Vec3D(vecMax.x, vecMin.y,  vecMax.z); // XyZ
	m_vtx[6] = Vec3D(vecMin.x, vecMax.y,  vecMax.z); // xYZ
	m_vtx[7] = Vec3D(vecMax.x, vecMax.y,  vecMax.z); // XYZ

	m_planes.resize(6);
	m_planes[0]=Plane(m_vtx[0], m_vtx[1], m_vtx[2]); // Near
	m_planes[1]=Plane(m_vtx[6], m_vtx[7], m_vtx[5]); // Far
	m_planes[2]=Plane(m_vtx[2], m_vtx[6], m_vtx[4]); // Left
	m_planes[3]=Plane(m_vtx[7], m_vtx[3], m_vtx[5]); // Right
	m_planes[4]=Plane(m_vtx[2], m_vtx[3], m_vtx[6]); // Top
	m_planes[5]=Plane(m_vtx[1], m_vtx[0], m_vtx[4]); // Bottom
}

CDMask::CDMask( Vec2i const& size , CFScene* scene )
	:size( size )
	,needShow( true )
{

	spr = scene->createObject( nullptr );
	
	spr->setOpacity( 0.5f );
	//spr->createPlane( NULL , 100 , 100 , Vec3D(1,0,0) );
	spr->setLocalPosition( Vec3D(0,0,10) );
	spr->enableVisibleTest( false );
	spr->setRenderOption( CFly::CFRO_CULL_FACE , CFly::CF_CULL_NONE );

	int geom = createMask( spr , nullptr );

	CFly::MeshBase* shape = spr->getElement( geom )->getMesh();
	mGoemBuf = shape->getVertexElement( CFly::CFV_XYZ , mGoemOffset );
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/// Method for finding boost to special r.f.
inline Vec3D Vec4D::SRFBoost() const
{
    VEC3D_T n=Norm2();
    if( n > 0.) {            // time-like vector
        // e.g. physical particle

        return r/r0;           // boost to r.f. where r=0
        // i.e. particle's rest frame

    } else if ( n < 0.) {    // space-like vector
        // e.g. tachyon

        return r0*r/(r*r);     // boost to r.f. where r0=0

    }
    // light-like
    return Vec3D();          // boost=0. is returned
}

TChestTrigger::TChestTrigger() :TBoxTrigger( Vec3D( 100 , 100 , 100 ) )
	,m_items( new TItemStorage(MaxItemNum) )
{
	m_DTime = 0.0f;

	OBJECTid objID = TResManager::instance().cloneModel( "bag" , true );

	modelObj.Object( objID );
	float scale = 20;
	modelObj.Scale( scale , scale , scale , LOCAL  );
	modelObj.Rotate( X_AXIS , 90 , LOCAL );
	modelObj.XForm();

	XForm trans;
	trans.setIdentity();
	TObjMotionState* motionState = new TObjMotionState( trans , objID );
	setMotionState( motionState );
}

void Skies::initSky(Vec3D pos, int t)
{
	if (numSkies==0) return;

	findSkyWeights(pos);

	for (int i=0; i<18; i++) colorSet[i] = Vec3D(0,0,0);

	// interpolation
	for (size_t j=0; j<skies.size(); j++) {
		if (skies[j].weight>0) {
			// now calculate the color rows
			for (int i=0; i<18; i++) {
				colorSet[i] += skies[j].colorFor(i,t) * skies[j].weight;
			}
		}
	}
}

  /* Part of the object has changed.  Broadcast a message to Grids that lets
       the server know of the change. */
  QVariant InputTextItem::itemChange(GraphicsItemChange change,
                                     const QVariant &value)
  {
    if (change == QGraphicsItem::ItemSelectedHasChanged)
      emit selectedChange(this);

    /* Check for text change. */

    /*d->getNoticeWindow()->write("change");*/

    /* Check for position change. */
    if(change == QGraphicsItem::ItemPositionChange) {
      //d->getNoticeWindow()->write("Pos change");
      updatePosition(d, Vec3D(value.toPointF().x(), value.toPointF().y(), zValue()));
    }
    return value;
    //return QGraphicsItem::itemChange(change, value);
  }