Any Entity::toAny() const { Any a = m_sourceAny; debugAssert(! a.isNil()); if (a.isNil()) { // Fallback for release mode failure return a; } if (m_movedSinceLoad) { a["frame"] = m_frame; } const shared_ptr<SplineTrack>& splineTrack = dynamic_pointer_cast<SplineTrack>(m_track); if (notNull(splineTrack) && splineTrack->changed()) { // Update the spline const PhysicsFrameSpline& spline = splineTrack->spline(); if (spline.control.size() == 1) { // Write out in short form for the single control point const PhysicsFrame& p = spline.control[0]; if (p.rotation == Quat()) { // No rotation a["track"] = p.translation; } else { // Full coordinate frame a["track"] = CFrame(p); } } else { // Write the full spline a["track"] = spline; } } a.setName("Entity"); return a; }
void App::playSculpture(const Ray& playRay) { int maxDistance = 0; int startIndex = g_sampleWindowIndex; for (auto piece : m_sonicSculpturePieces) { const shared_ptr<AudioSample>& sample = piece->getAudioSampleFromRay(playRay); if (sample->buffer.size() > 0) { maxDistance = max(maxDistance, (int)ceil(sample->buffer.size() / 512.0f)); Synthesizer::global->queueSound(sample); m_lastInterestingEventTime = System::time(); } } if (maxDistance > 0) { PlayPlane pp; pp.direction = playRay.direction(); pp.origin = playRay.origin(); pp.beginWindowIndex = startIndex; pp.endWindowIndex = startIndex + maxDistance; Vector3 zAxis = -playRay.direction(); Vector3 xAxis; if (abs(zAxis.dot(Vector3::unitY())) < 0.9f) { xAxis = zAxis.unitCross(Vector3::unitY()); } else { xAxis = zAxis.unitCross(Vector3::unitX()); } Vector3 yAxis = zAxis.cross(xAxis); pp.frame = CFrame(Matrix3::fromColumns(xAxis, yAxis, zAxis), pp.origin); m_playPlanes.append(pp); } }
void ArticulatedViewer::onGraphics3D(RenderDevice* rd, App* app, const shared_ptr<LightingEnvironment>& lighting, Array<shared_ptr<Surface> >& allSurfaces) { // app->gbuffer()->setSpecification(m_gbufferSpecification); app->gbuffer()->resize(app->framebuffer()->width(), app->framebuffer()->height()); app->gbuffer()->prepare(rd, app->activeCamera(), 0, -(float)app->previousSimTimeStep(), app->settings().depthGuardBandThickness, app->settings().colorGuardBandThickness); app->renderer()->render(rd, app->framebuffer(), app->depthPeelFramebuffer(), *lighting, app->gbuffer(), allSurfaces); Array<Point3> skeletonLines; m_model->getSkeletonLines(m_pose, m_offset, skeletonLines); rd->pushState(); { rd->setObjectToWorldMatrix(CFrame()); rd->setDepthTest(RenderDevice::DEPTH_ALWAYS_PASS); for (int i = 0; i < skeletonLines.size(); i += 2) { Draw::lineSegment(LineSegment::fromTwoPoints(skeletonLines[i], skeletonLines[i + 1]), rd, Color3::red()); } } rd->popState(); //Surface::renderWireframe(rd, posed3D); if (m_selectedMesh != NULL) { // Find the index array that matches the selected mesh and render it for (int p = 0; p < allSurfaces.size(); ++p) { const shared_ptr<UniversalSurface>& s = dynamic_pointer_cast<UniversalSurface>(allSurfaces[p]); if (s->gpuGeom()->index == m_selectedMesh->gpuIndexArray) { // These have the same index array, so they must be the same surface s->renderWireframeHomogeneous(rd, Array<shared_ptr<Surface> >(s), Color3::green(), false); break; } } } float x, y, z, yaw, pitch, roll; app->activeCamera()->frame().getXYZYPRDegrees(x,y,z,yaw, pitch, roll); screenPrintf("[Camera position: Translation(%f, %f, %f) Rotation(%f, %f, %f)]\n", x,y,z,yaw,pitch,roll); screenPrintf("[Shown scaled by %f and offset by (%f, %f, %f)]\n", m_scale, m_offset.x, m_offset.y, m_offset.z); screenPrintf("Model Faces: %d, Vertices: %d\n", m_numFaces, m_numVertices); if (m_selectedPart != NULL) { screenPrintf(" Selected Part `%s', Mesh `%s', Material `%s', cpuIndexArray[%d...%d]\n", m_selectedPart->name.c_str(), m_selectedMesh->name.c_str(), m_selectedMesh->material->name().c_str(), m_selectedTriangleIndex, m_selectedTriangleIndex + 2); screenPrintf(" Selected part->cframe = %s\n", m_selectedPart->cframe.toXYZYPRDegreesString().c_str()); } screenPrintf("Hierarchy:"); // Hierarchy (could do this with a PartCallback) for (int i = 0; i < m_model->rootArray().size(); ++i) { printHierarchy(m_model, m_model->rootArray()[i], ""); } }
virtual CFrame computeFrame(SimTime time) const override { shared_ptr<Entity> e = m_scene->entity(m_entityName); if (notNull(e)) { return e->frame(); } else { // Maybe during initialization and the other entity does not yet exist return CFrame(); } }
std::ostream& operator<< (std::ostream &out, Frame &CFrame) { for(size_t j=0; j<CFrame.GetNRow(); j++) { for(size_t i=0; i<CFrame.GetNCol(); i++) { out << CFrame(i,j) << " "; } out << std::endl; } return out; }
void PhysicsFrameSplineEditor::addControlPoint() { if (m_spline.control.size() == 0) { m_spline.append(CFrame()); } else if (m_spline.control.size() == 1) { // Adding the 2nd point CFrame f = m_spline.control.last(); f.translation += f.lookVector(); m_spline.append(f); resizeControlPointDropDown(m_spline.control.size()); // Select the new point setSelectedControlPointIndex(m_selectedControlPointIndex + 1); } else { // Adding between two points float t0 = m_spline.time[m_selectedControlPointIndex]; float newT = t0; float evalT = 0; if (m_selectedControlPointIndex < m_spline.control.size() - 1) { // Normal interval newT = m_spline.time[m_selectedControlPointIndex + 1]; evalT = (t0 + newT) / 2; } else if (m_spline.extrapolationMode == SplineExtrapolationMode::CYCLIC) { // After the end on a cyclic spline newT = m_spline.getFinalInterval() + t0; evalT = (t0 + newT) / 2; } else { // After the end on a non-cyclic spline of length at least // 2; assume that we want to step the distance of the previous // interval newT = evalT = 2.0f * t0 - m_spline.time[m_selectedControlPointIndex - 1]; } const PhysicsFrame f = m_spline.evaluate(evalT); m_spline.control.insert(m_selectedControlPointIndex + 1, f); m_spline.time.insert(m_selectedControlPointIndex + 1, newT); // Select the new point resizeControlPointDropDown(m_spline.control.size()); setSelectedControlPointIndex(m_selectedControlPointIndex + 1); // Fix the rest of the times to be offset by the inserted duration float shift = newT - t0; for (int i = m_selectedControlPointIndex + 1; i < m_spline.time.size(); ++i) { m_spline.time[i] += shift; } } }
Matrix4::Matrix4(const Any& any) { any.verifyNameBeginsWith("Matrix4", "CFrame", "CoordinateFrame"); any.verifyType(Any::ARRAY); const std::string& name = any.name(); if (name == "Matrix4") { any.verifySize(16); for (int r = 0; r < 4; ++r) { for (int c = 0; c < 4; ++c) { elt[r][c] = any[r * 4 + c]; } } } else if (name == "Matrix4::scale") { if (any.size() == 1) { *this = scale(any[0].floatValue()); } else if (any.size() == 3) { *this = scale(any[0], any[1], any[2]); } else { any.verify(false, "Matrix4::scale() takes either 1 or 3 arguments"); } } else if (name == "Matrix4::rollDegrees") { any.verifySize(1); *this = rollDegrees(any[0].floatValue()); } else if (name == "Matrix4::yawDegrees") { any.verifySize(1); *this = yawDegrees(any[0].floatValue()); } else if (name == "Matrix4::pitchDegrees") { any.verifySize(1); *this = pitchDegrees(any[0].floatValue()); } else if (name == "Matrix4::translation") { if (any.size() == 3) { *this = translation(any[0], any[1], any[2]); } else { any.verify(false, "Matrix4::translation() requires 3 arguments"); } } else if (name == "Matrix4::diagonal") { any.verifySize(4); *this = diagonal(any[0], any[1], any[2], any[3]); } else if (name == "Matrix4::identity") { *this = identity(); } else if (beginsWith(name, "CFrame") || beginsWith(name, "CoordinateFrame")) { *this = CFrame(any); } else { any.verify(false, "Expected Matrix4 constructor"); } }
void VisibleEntity::debugDrawVisualization(RenderDevice* rd, VisualizationMode mode) { alwaysAssertM(mode == SKELETON, "Bounds visualization not implemented"); Array<Point3> skeletonLines; switch (m_modelType) { case ARTICULATED_MODEL: m_artModel->getSkeletonLines(m_artPose, m_frame, skeletonLines); break; default: break; } rd->pushState(); { rd->setObjectToWorldMatrix(CFrame()); rd->setDepthTest(RenderDevice::DEPTH_ALWAYS_PASS); for (int i = 0; i < skeletonLines.size(); i += 2) { Draw::lineSegment(LineSegment::fromTwoPoints(skeletonLines[i], skeletonLines[i+1]), rd, Color3::red()); } } rd->popState(); }
std::string PhysicsFrameSplineEditor::selectedNodePFrameAsString() const { if (m_selectedControlPointIndex >= 0 && m_selectedControlPointIndex < m_spline.control.size()) { const PhysicsFrame& pframe = m_spline.control[m_selectedControlPointIndex]; // Cache the string so that we don't have to reparse it for every rendering if (m_cachedPhysicsFrameValue != pframe) { m_cachedPhysicsFrameValue = pframe; m_cachedPhysicsFrameString = CFrame(m_cachedPhysicsFrameValue).toAny().unparse(); } return m_cachedPhysicsFrameString; } else { return "Point3(0, 0, 0)"; } }
CoordinateFrame::CoordinateFrame(const Any& any) { *this = CFrame(); const std::string& n = toUpper(any.name()); if (beginsWith(n, "VECTOR3")) { translation = any; } else if (beginsWith(n, "MATRIX3")) { rotation = any; } else if ((n == "CFRAME") || (n == "COORDINATEFRAME")) { any.verifyType(Any::TABLE, Any::ARRAY); if (any.type() == Any::ARRAY) { any.verifySize(2); rotation = any[0]; translation = any[1]; } else { for (Any::AnyTable::Iterator it = any.table().begin(); it.hasMore(); ++it) { const std::string& n = toLower(it->key); if (n == "translation") { translation = Vector3(it->value); } else if (n == "rotation") { rotation = Matrix3(it->value); } else { any.verify(false, "Illegal table key: " + it->key); } } } } else if (beginsWith(n, "PHYSICSFRAME") || beginsWith(n, "PFRAME")) { *this = PhysicsFrame(any); } else { any.verifyName("CFrame::fromXYZYPRDegrees", "CoordinateFrame::fromXYZYPRDegrees"); any.verifyType(Any::ARRAY); any.verifySize(3, 6); int s = any.size(); *this = fromXYZYPRDegrees(any[0], any[1], any[2], (s > 3) ? any[3].number() : 0.0f, (s > 4) ? any[4].number() : 0.0f, (s > 5) ? any[5].number() : 0.0f); } }
void App::onInit() { tick(); message("Loading..."); renderDevice->setSwapBuffersAutomatically(true); m_world = new World(m_worldScene); // Create one random number generator per thread m_rng.resize(GThread::numCores()); for (int i = 0; i < m_rng.size(); ++i) { //m_rng[i].reset(0xF018A4D2 ^ i, false); //m_rng[i].reset(uint32(System::time()) ^ i); } Array<Plane,10> clipPlanes; float a,b,c,d; showRenderingStats = false; createDeveloperHUD(); developerWindow->setVisible(false); developerWindow->cameraControlWindow->setVisible(false); m_debugCamera->filmSettings().setAntialiasingEnabled(false); m_debugCamera->filmSettings().setAntialiasingHighQuality(false); m_debugCamera->filmSettings().setBloomStrength(0.0f); m_debugCamera->setFrame(m_world->frame); m_debugCamera->setFieldOfView(m_world->FOVDeg*pi()/180.0,FOVDirection::VERTICAL); m_debugCamera->getClipPlanes(Rect2D(Vector2(window()->width(),window()->height())),clipPlanes); clipPlanes[0].getEquation(a,b,c,d); m_focalPlane = Plane::fromEquation(-a,-b,-c,-(d-(m_world->focalDist))); makeGUI(); // Force re-render on first frame m_prevCFrame = CFrame(Matrix3::zero()); float time = tock("Loading scene"); //Initialize StatsData class m_featureData.init(m_imgWidth,m_imgHeight,m_sampleBudget,m_samplesPerIteration); //Initialize filter with the features data pointers; m_CBFilter.init(&m_featureData); }
void App::onInit() { message("Loading..."); m_world = new World(); showRenderingStats = false; createDeveloperHUD(); developerWindow->setVisible(false); developerWindow->cameraControlWindow->setVisible(false); m_debugCamera->filmSettings().setAntialiasingEnabled(true); m_debugCamera->filmSettings().setContrastToneCurve(); // Starting position m_debugCamera->setFrame(CFrame::fromXYZYPRDegrees(24.3f, 0.4f, 2.5f, 68.7f, 1.2f, 0.0f)); m_debugCamera->frame(); makeGUI(); // Force re-render on first frame m_prevCFrame = CFrame(Matrix3::zero()); }
CoordinateFrame::CoordinateFrame(const Any& any) { *this = CFrame(); const String& n = toUpper(any.name()); if (beginsWith(n, "VECTOR3") || beginsWith(n, "POINT3")) { translation = Point3(any); } else if (beginsWith(n, "MATRIX3")) { rotation = Matrix3(any); } else if (beginsWith(n, "MATRIX4")) { *this = Matrix4(any).approxCoordinateFrame(); } else if ((n == "CFRAME") || (n == "COORDINATEFRAME")) { any.verifyType(Any::TABLE, Any::ARRAY); if (any.type() == Any::ARRAY) { any.verifySize(2); rotation = any[0]; translation = any[1]; } else { AnyTableReader r(any); r.getIfPresent("translation", translation); r.getIfPresent("rotation", rotation); r.verifyDone(); } } else if (beginsWith(n, "PHYSICSFRAME") || beginsWith(n, "PFRAME")) { *this = PhysicsFrame(any); // } else if (beginsWith(n, "UPRIGHTFRAME") || beginsWith(n, "UFRAME")) { // *this = UprightFrame(any); } else { any.verifyName("CFrame::fromXYZYPRDegrees", "CoordinateFrame::fromXYZYPRDegrees"); any.verifyType(Any::ARRAY); any.verifySize(3, 6); int s = any.size(); *this = fromXYZYPRDegrees(any[0], any[1], any[2], (s > 3) ? (float)any[3].number() : 0.0f, (s > 4) ? (float)any[4].number() : 0.0f, (s > 5) ? (float)any[5].number() : 0.0f); } }
Box Frustum::boundingBox(float minObjectSpaceDepth) const { debugAssert(minObjectSpaceDepth > 0); const float minFarPlaneZ = -minObjectSpaceDepth; AABox aabb; // Object space axes; we don't care about translation because we move back to world space at the end const Vector3& X = (vertexPos[1] - vertexPos[0]).xyz().direction(); const Vector3& Y = (vertexPos[2] - vertexPos[1]).xyz().direction(); const Vector3& Z = X.cross(Y); const Point3& C = vertexPos[0].xyz(); // Compute the world-to-object matrix, which is the transpose // of the object const Matrix3& M = Matrix3::fromRows(X, Y, Z); for (int v = 0; v < 8; ++v) { // World-space point const Vector4& P = vertexPos[v]; // Object-space point (ignoring translation) const Point3& Q = M * P.xyz() - C; // Project the point if infinite if ((P.w == 0.0f) || (Q.z < minFarPlaneZ)) { // Project onto z = minFarPlaneZ const float s = minFarPlaneZ / Q.z; aabb.merge(Point3(Q.x * s, Q.y * s, minFarPlaneZ)); } else { // World-space point aabb.merge( M * (Q / P.w) ); } } // Transform box to world space return CFrame(M.transpose(), C).toWorldSpace(aabb); }
void ArticulatedModel::loadHeightfield(const Specification& specification) { Part* part = addPart("root"); Geometry* geom = addGeometry("geom"); Mesh* mesh = addMesh("mesh", part, geom); mesh->material = UniversalMaterial::create(); shared_ptr<Image1> im = Image1::fromFile(specification.filename); geom->cpuVertexArray.hasTangent = false; geom->cpuVertexArray.hasTexCoord0 = true; const bool spaceCentered = true; const bool generateBackFaces = specification.heightfieldOptions.generateBackfaces; const Vector2& textureScale = specification.heightfieldOptions.textureScale; Array<Point3> vertex; Array<Point2> texCoord; MeshAlg::generateGrid (vertex, texCoord, mesh->cpuIndexArray, im->width(), im->height(), textureScale, spaceCentered, generateBackFaces, CFrame(Matrix4::scale((float)im->width(), 1.0, (float)im->height()).upper3x3()), im); // Copy the vertex data into the mesh geom->cpuVertexArray.vertex.resize(vertex.size()); CPUVertexArray::Vertex* vertexPtr = geom->cpuVertexArray.vertex.getCArray(); for (uint32 i = 0; i < (uint32)vertex.size(); ++i) { CPUVertexArray::Vertex& v = vertexPtr[i]; v.position = vertex[i]; v.texCoord0 = texCoord[i]; v.tangent.x = v.normal.x = fnan(); } // for }
#include "Local.h" #include "Monsters/Bitch.h" CMaiden::CMaiden (uint32 ID) : IMonster(ID) { } void CMaiden::Moan () { Entity->PlaySound (CHAN_VOICE, (frand() < 0.5) ? Sounds[SOUND_IDLE1] : Sounds[SOUND_IDLE2], 255, ATTN_IDLE); } CFrame ChickFramesFidget [] = { CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0, ConvertDerivedFunction(&CMaiden::Moan)), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0),
CFrame::CFrame(CFrame& Frame) { CFrame(Frame.m_sx,Frame.m_sy); memcpy(m_pFrame, Frame.m_pFrame, sizeof(PIXEL)*m_sx*m_sy); }
PhysicsFrameSplineEditor::PhysicsFrameSplineEditor(const GuiText& caption, GuiPane* dockPane, shared_ptr<GuiTheme> theme) : GuiWindow(caption, theme, Rect2D::xywh(0,0,100,40), GuiTheme::TOOL_WINDOW_STYLE, GuiWindow::HIDE_ON_CLOSE), m_selectedControlPointIndex(0), m_isDocked(dockPane != NULL) { m_cachedPhysicsFrameString = CFrame(m_cachedPhysicsFrameValue).toAny().unparse(); m_spline.append(CFrame()); m_surface.reset(new SplineSurface(this)); m_nodeManipulator = ThirdPersonManipulator::create(); m_nodeManipulator->setEnabled(false); GuiPane* p = dockPane; if (p == NULL) { // Place into the window p = pane(); } else { // No need to show the window setVisible(false); } GuiPane* cpPane = p->addPane("Control Point", GuiTheme::ORNATE_PANE_STYLE); cpPane->moveBy(0, -15); Array<std::string> indexList; getIndexRange(1, indexList); m_selectedControlPointDropDown = cpPane->addDropDownList("Control point: ", indexList, &m_selectedControlPointIndex, GuiControl::Callback(this, &PhysicsFrameSplineEditor::controlPointDropDownCallback)); cpPane->addNumberBox("Time", Pointer<float>(this, &PhysicsFrameSplineEditor::selectedNodeTime, &PhysicsFrameSplineEditor::setSelectedNodeTime), "s"); cpPane->addTextBox("", Pointer<std::string>(this, &PhysicsFrameSplineEditor::selectedNodePFrameAsString, &PhysicsFrameSplineEditor::setSelectedNodePFrameFromString)); cpPane->beginRow(); { GuiButton* b = cpPane->addButton("Add new", this, &PhysicsFrameSplineEditor::addControlPoint); b->moveBy(-2, -7); m_removeSelectedButton = cpPane->addButton("Remove", this, &PhysicsFrameSplineEditor::removeSelectedControlPoint); } cpPane->endRow(); cpPane->pack(); GuiPane* exPane = p->addPane("Extrapolation Mode", GuiTheme::NO_PANE_STYLE); exPane->beginRow(); { GuiControl* linearButton = exPane->addRadioButton("Linear", SplineExtrapolationMode::LINEAR, this, &PhysicsFrameSplineEditor::extrapolationMode, &PhysicsFrameSplineEditor::setExtrapolationMode); GuiControl* clampedButton = exPane->addRadioButton("Clamped", SplineExtrapolationMode::CLAMP, this, &PhysicsFrameSplineEditor::extrapolationMode, &PhysicsFrameSplineEditor::setExtrapolationMode); clampedButton->moveRightOf(linearButton); clampedButton->moveBy(-145, 0); GuiControl* cyclicButton = exPane->addRadioButton("Cyclic", SplineExtrapolationMode::CYCLIC, this, &PhysicsFrameSplineEditor::extrapolationMode, &PhysicsFrameSplineEditor::setExtrapolationMode); cyclicButton->moveRightOf(clampedButton); cyclicButton->moveBy(-140, 0); } exPane->endRow(); exPane->pack(); GuiPane* inPane = p->addPane("Interpolation Mode", GuiTheme::NO_PANE_STYLE); inPane->beginRow(); { GuiControl* linearButton = inPane->addRadioButton("Linear", SplineInterpolationMode::LINEAR, this, &PhysicsFrameSplineEditor::interpolationMode, &PhysicsFrameSplineEditor::setInterpolationMode); GuiControl* cubicButton = inPane->addRadioButton("Cubic", SplineInterpolationMode::CUBIC, this, &PhysicsFrameSplineEditor::interpolationMode, &PhysicsFrameSplineEditor::setInterpolationMode); cubicButton->moveRightOf(linearButton); cubicButton->moveBy(-145, 0); } inPane->endRow(); inPane->pack(); GuiPane* finalIntervalPane = p->addPane("Final Interval", GuiTheme::NO_PANE_STYLE); finalIntervalPane->moveRightOf(exPane); finalIntervalPane->moveBy(-100, -5); static int m_explicitFinalInterval = 0; m_finalIntervalChoice[0] = finalIntervalPane->addRadioButton("automatic", 0, &m_explicitFinalInterval); finalIntervalPane->beginRow(); { m_finalIntervalChoice[1] = finalIntervalPane->addRadioButton("", 1, &m_explicitFinalInterval); m_finalIntervalBox = finalIntervalPane->addNumberBox("", &m_spline.finalInterval, "s", GuiTheme::NO_SLIDER, -1.0f, 10000.0f, 0.001f); m_finalIntervalBox->setWidth(76); m_finalIntervalBox->moveBy(-2, 0); } finalIntervalPane->endRow(); pack(); setEnabled(false); }
PhysicsFrameSplineEditor::PhysicsFrameSplineEditor(const GuiText& caption, GuiPane* dockPane, GuiTheme::Ref theme) : GuiWindow(caption, theme, Rect2D::xywh(0,0,100,40), GuiTheme::TOOL_WINDOW_STYLE, GuiWindow::HIDE_ON_CLOSE), m_selectedControlPointIndex(0), m_isDocked(dockPane != NULL) { m_cachedPhysicsFrameString = CFrame(m_cachedPhysicsFrameValue).toAny().unparse(); m_spline.append(CFrame()); m_surface = new SplineSurface(this); m_nodeManipulator = ThirdPersonManipulator::create(); m_nodeManipulator->setEnabled(false); GuiPane* p = dockPane; if (p == NULL) { // Place into the window p = pane(); } else { // No need to show the window setVisible(false); } GuiPane* cpPane = p->addPane("Control Point", GuiTheme::ORNATE_PANE_STYLE); cpPane->moveBy(0, -15); if (false) { static float x,y,z; //static const float translationControlWidth = 80; static const float rotationControlWidth = 40; //static const float captionWidth = 10; static const float rotationPrecision = 0.1; //static const float translationPrecision = 0.001; static const std::string degrees = "\xba"; cpPane->beginRow(); { GuiNumberBox<float>* c = NULL; static std::string s = "100.0, 100.0, 100.0"; GuiControl* t = cpPane->addTextBox("xyz (", &s); t->setWidth(155); t->setCaptionWidth(26); cpPane->addLabel(") m"); c = cpPane->addNumberBox("", &x, degrees, GuiTheme::NO_SLIDER, -finf(), finf(), rotationPrecision); c->moveBy(20, 0); c->setCaptionWidth(0); c->setWidth(rotationControlWidth); c->setUnitsSize(8); c = cpPane->addNumberBox("", &y, degrees, GuiTheme::NO_SLIDER, -finf(), finf(), rotationPrecision); c->setCaptionWidth(0); c->setWidth(rotationControlWidth); c->setUnitsSize(8); c = cpPane->addNumberBox("", &z, degrees, GuiTheme::NO_SLIDER, -finf(), finf(), rotationPrecision); c->setCaptionWidth(0); c->setWidth(rotationControlWidth); c->setUnitsSize(8); } cpPane->endRow(); } cpPane->addLabel("Control point: 0"); cpPane->addNumberBox("Time", Pointer<float>(this, &PhysicsFrameSplineEditor::selectedNodeTime, &PhysicsFrameSplineEditor::setSelectedNodeTime), "s"); cpPane->addTextBox("", Pointer<std::string>(this, &PhysicsFrameSplineEditor::selectedNodePFrameAsString, &PhysicsFrameSplineEditor::setSelectedNodePFrameFromString)); cpPane->beginRow(); { GuiButton* b = cpPane->addButton("Add new", this, &PhysicsFrameSplineEditor::addControlPoint); b->moveBy(-2, -7); m_removeSelectedButton = cpPane->addButton("Remove", this, &PhysicsFrameSplineEditor::removeSelectedControlPoint); } cpPane->endRow(); cpPane->pack(); GuiControl* prev = p->addCheckBox("Loop with final interval", Pointer<bool>(this, &PhysicsFrameSplineEditor::cyclic, &PhysicsFrameSplineEditor::setCyclic)); GuiPane* finalIntervalPane = p->addPane("", GuiTheme::NO_PANE_STYLE); finalIntervalPane->moveRightOf(prev); finalIntervalPane->moveBy(-1, -5); static int m_explicitFinalInterval = 0; m_finalIntervalChoice[0] = finalIntervalPane->addRadioButton("automatic", 0, &m_explicitFinalInterval); finalIntervalPane->beginRow(); { m_finalIntervalChoice[1] = finalIntervalPane->addRadioButton("", 1, &m_explicitFinalInterval); m_finalIntervalBox = finalIntervalPane->addNumberBox("", &m_spline.finalInterval, "s", GuiTheme::NO_SLIDER, -1.0f, 10000.0f, 0.001f); m_finalIntervalBox->setWidth(76); m_finalIntervalBox->moveBy(-2, 0); } finalIntervalPane->endRow(); pack(); setEnabled(false); }
virtual CFrame computeFrame(SimTime time) const override { return CFrame (m_rotation->computeFrame(time).rotation, m_translation->computeFrame(time).translation); }
Entity->PlaySound (CHAN_WEAPON, Sounds[SOUND_SIGHT]); } void CParasite::Tap () { Entity->PlaySound (CHAN_WEAPON, Sounds[SOUND_TAP], 255, ATTN_IDLE); } void CParasite::Scratch () { Entity->PlaySound (CHAN_WEAPON, Sounds[SOUND_SCRATCH], 255, ATTN_IDLE); } CFrame ParasiteFramesStartFidget [] = { CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0) }; CAnim ParasiteMoveStartFidget (CParasite::FRAME_stand18, CParasite::FRAME_stand21, ParasiteFramesStartFidget, ConvertDerivedFunction(&CParasite::DoFidget)); CFrame ParasiteFramesFidget [] = { CFrame (&IMonster::AI_Stand, 0, ConvertDerivedFunction(&CParasite::Scratch)), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0, ConvertDerivedFunction(&CParasite::Scratch)), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0) };
void ArticulatedViewer::onInit(const String& filename) { ArticulatedModel::clearCache(); Texture::clearCache(); m_filename = filename; m_selectedPart = NULL; m_selectedMesh = NULL; m_selectedTriangleIndex = -1; m_numFaces = 0; m_numVertices = 0; m_shadowMapDirty = true; UniversalMaterial::clearCache(); const RealTime start = System::time(); if (toLower(FilePath::ext(filename)) == "any") { if ((toLower(FilePath::ext(FilePath::base(filename))) == "material") || (toLower(FilePath::ext(FilePath::base(filename))) == "universalmaterial")) { // Assume that this is an .UniversalMaterial.Any file. Load a square and apply the material Any any(Any::TABLE, "ArticulatedModel::Specification"); any["filename"] = "model/crate/crate4xtex.obj"; any["stripMaterials"] = true; any["preprocess"] = Any(Any::ARRAY); Any arg(Any::ARRAY, "setMaterial"); arg.append(Any(Any::ARRAY, "all")); arg.append(Any::fromFile(filename)); any["preprocess"].append(arg); Any arg2(Any::ARRAY, "setTwoSided"); arg2.append(Any(Any::ARRAY, "all")); arg2.append(true); any["preprocess"].append(arg2); m_model = ArticulatedModel::create(ArticulatedModel::Specification(any)); } else { // Assume that this is an .ArticulatedModel.Any file Any any; any.load(filename); m_model = ArticulatedModel::create(ArticulatedModel::Specification(any)); } } else { m_model = ArticulatedModel::fromFile(filename); } debugPrintf("%s loaded in %f seconds\n", filename.c_str(), System::time() - start); Array<shared_ptr<Surface> > arrayModel; if (m_model->usesSkeletalAnimation()) { Array<G3D::String> animationNames; m_model->getAnimationNames(animationNames); // TODO: Add support for selecting animations. m_model->getAnimation(animationNames[0], m_animation); m_animation.getCurrentPose(0.0f, m_pose); } m_model->pose(arrayModel, CFrame(), m_pose); m_model->countTrianglesAndVertices(m_numFaces, m_numVertices); m_scale = 1; m_offset = Vector3::zero(); bool overwrite = true; // Find the size of the bounding box of the entire model AABox bounds; if (arrayModel.size() > 0) { for (int x = 0; x < arrayModel.size(); ++x) { //merges the bounding boxes of all the seperate parts into the bounding box of the entire object AABox temp; CFrame cframe; arrayModel[x]->getCoordinateFrame(cframe); arrayModel[x]->getObjectSpaceBoundingBox(temp); Box partBounds = cframe.toWorldSpace(temp); // Some models have screwed up bounding boxes if (partBounds.extent().isFinite()) { if (overwrite) { partBounds.getBounds(bounds); overwrite = false; } else { partBounds.getBounds(temp); bounds.merge(temp); } } } if (overwrite) { // We never found a part with a finite bounding box bounds = AABox(Vector3::zero()); } Vector3 extent = bounds.extent(); Vector3 center = bounds.center(); // Scale to X units float scale = 1.0f / max(extent.x, max(extent.y, extent.z)); if (scale <= 0) { scale = 1; } if (! isFinite(scale)) { scale = 1; } m_scale = scale; scale *= VIEW_SIZE; m_offset = -scale * center; if (! center.isFinite()) { center = Vector3(); } // Transform parts in-place m_model->scaleWholeModel(scale); ArticulatedModel::CleanGeometrySettings csg; // Merging vertices is slow and topology hasn't changed at all, so preclude vertex merging csg.allowVertexMerging = false; m_model->cleanGeometry(csg); } // Get the newly transformed animation if (m_model->usesSkeletalAnimation()) { Array<String> animationNames; m_model->getAnimationNames(animationNames); // TODO: Add support for selecting animations. m_model->getAnimation(animationNames[0], m_animation); m_animation.getCurrentPose(0.0f, m_pose); } // saveGeometry(); }
IdealYaw = AngleModf(enemy_yaw - 30); break; case 1: IdealYaw = AngleModf(enemy_yaw); break; case 2: IdealYaw = AngleModf(enemy_yaw + 30); break; }; MachineGun (); } CFrame CarrierFramesStand [] = { CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0), CFrame (&IMonster::AI_Stand, 0) }; CAnim CarrierMoveStand (CCarrier::FRAME_search01, CCarrier::FRAME_search13, CarrierFramesStand);
void RayTracer::debugDrawPhotonMap(RenderDevice* rd) { rd->setObjectToWorldMatrix(CFrame()); for (PhotonMap::CellIterator cell = m_photonMap.beginCell(); cell.isValid(); ++cell) { Draw::box(cell.bounds(), rd); } }