int main(int argc, char* argv[]) { // Get device singleton instance. auto device = RenderDevice::getInstance(); device->init(); device->setQuitOnStart(true); Text text(20.0f); text.setPosition(0, 0); text.setColor(Color::White); text.setString("Hello Text"); // Create the render texture, make it 100x100 RenderTexture renderTexture; renderTexture.create(100, 100); // Start drawing on the texture renderTexture.startFrame(); // Draw the text text.draw(); // End drawing to the texture renderTexture.endFrame(); // Save the render texture to a file renderTexture.save("out.png"); // Main loop while(device->isRunning()) { device->setTargetScreen(Screen::Top); device->clear(Color::Black); device->startFrame(); // Draw the text text.draw(); device->endFrame(); device->setTargetScreen(Screen::Bottom); device->clear(Color::Black); device->startFrame(); device->endFrame(); device->swapBuffers(); } // DON'T FORGET TO CALL THIS OR THE 3DS WILL CRASH AT EXIT device->destroy(); return 0; }
void draw() { startFrame(); sceGuDisable(GU_TEXTURE); // Different formats - throughmode. sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_TRANSFORM_2D, 4, NULL, vertices_nofmt); sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_VERTEX_8BIT | GU_TRANSFORM_2D, 4, NULL, vertices_s8); sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, NULL, vertices_s16); sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_VERTEX_32BITF | GU_TRANSFORM_2D, 4, NULL, vertices_f32); // Different formats - transform. sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_TRANSFORM_3D, 4, NULL, vertices_nofmt); sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_VERTEX_8BIT | GU_TRANSFORM_3D, 4, NULL, vertices_s8x); sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 4, NULL, vertices_s16x); sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_VERTEX_32BITF | GU_TRANSFORM_3D, 4, NULL, vertices_f32x); // Wrong order (CCW.) sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_VERTEX_32BITF | GU_TRANSFORM_2D, 4, NULL, vertices_rev); sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_VERTEX_32BITF | GU_TRANSFORM_3D, 4, NULL, vertices_revx); // Incomplete (only one prim.) sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_VERTEX_32BITF | GU_TRANSFORM_2D, 1, NULL, vertices_incomp); sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_VERTEX_32BITF | GU_TRANSFORM_3D, 1, NULL, vertices_incompx); endFrame(); }
bool MasterConfig::run( co::Object* frameData ) { LBASSERT( _objects ); if( frameData ) LBCHECK( _objects->register_( frameData, OBJECTTYPE_FRAMEDATA )); _objects->setFrameData( frameData ); seq::Application* const app = getApplication(); while( isRunning( )) { startFrame(); if( getError( )) LBWARN << "Error during frame start: " << getError() << std::endl; finishFrame(); while( !needRedraw( )) // wait for an event requiring redraw { if( app->hasCommands( )) // execute non-critical pending commands { app->processCommand(); handleEvents(); // non-blocking } else // no pending commands, block on user event { const eq::EventCommand& event = getNextEvent(); if( !handleEvent( event )) LBVERB << "Unhandled " << event << std::endl; } } handleEvents(); // process all pending events } finishAllFrames(); return true; }
void draw() { startFrame(); setSimpleTexture(); // Different formats - throughmode. sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_TRANSFORM_2D, 2, NULL, vertices_nofmt); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_8BIT | GU_TRANSFORM_2D, 2, NULL, vertices_s8); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 2, NULL, vertices_s16); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_32BITF | GU_TRANSFORM_2D, 2, NULL, vertices_f32); // Different formats - transform. sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_TRANSFORM_3D, 2, NULL, vertices_nofmt); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_8BIT | GU_TRANSFORM_3D, 2, NULL, vertices_s8x); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 2, NULL, vertices_s16x); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_32BITF | GU_TRANSFORM_3D, 2, NULL, vertices_f32x); // Rotated (not TL - BR.) sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_32BITF | GU_TRANSFORM_2D, 2, NULL, vertices_trbl); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_32BITF | GU_TRANSFORM_2D, 2, NULL, vertices_brtl); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_32BITF | GU_TRANSFORM_3D, 2, NULL, vertices_trblx); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_32BITF | GU_TRANSFORM_3D, 2, NULL, vertices_brtlx); // Incomplete (only one prim.) sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_32BITF | GU_TRANSFORM_2D, 1, NULL, vertices_incomp); sceGuDrawArray(GU_SPRITES, GU_TEXTURE_16BIT | GU_VERTEX_32BITF | GU_TRANSFORM_3D, 1, NULL, vertices_incompx); endFrame(); }
int main(int argc, char* argv[]) { // Get device singleton instance. auto device = RenderDevice::getInstance(); device->init(); device->setQuitOnStart(true); // Create a rectangle shape RectangleShape rect(100, 60, 100, 100); // And we set it's color to blue rect.setColor(Color::Blue); rect.setOutlineColor(Color::Red); rect.setOutlineThickness(2); // Create a line LineShape line(0, 0, BOTTOM_SCREEN_WIDTH, BOTTOM_SCREEN_HEIGHT); // And set its color to yellow line.setColor(Color::Yellow); // Main loop while(device->isRunning()) { device->setTargetScreen(Screen::Top); device->clear(Color::Black); device->startFrame(); // Draw the rectangle to top screen rect.draw(); device->endFrame(); device->setTargetScreen(Screen::Bottom); device->clear(Color::Black); device->startFrame(); // Draw a diagonal line on bottom screen line.draw(); device->endFrame(); device->swapBuffers(); } // DON'T FORGET TO CALL THIS OR THE 3DS WILL CRASH AT EXIT device->destroy(); return 0; }
int main(int argc, char* argv[]) { auto device = RenderDevice::getInstance(); device->init(); device->setQuitOnStart(true); Text text(30.0f); text.setString("Random color"); // Create a thread that changes the text color every second Thread thread([&](void*) { while(device->isRunning()) { text.setColor(Color::Random()); Thread::sleep(Time::seconds(1)); } }); // Start the thread thread.start(); while(device->isRunning()) { device->setTargetScreen(Screen::Top); device->clear(Color::Black); device->startFrame(); text.draw(); device->endFrame(); device->setTargetScreen(Screen::Bottom); device->clear(Color::Black); device->startFrame(); device->endFrame(); device->swapBuffers(); } // Wait the thread end thread.join(); // DON'T FORGET TO CALL THIS OR THE 3DS WILL CRASH AT EXIT device->destroy(); return 0; }
void runloadscreen(){ Display d=newDisplay(); startFrame(d); LoadScreen(d); quit(d); }
void SaslServer::completed(bool succeeded) { void* frameToken = startFrame(); void* listToken = encoder.startList8(&SASL_OUTCOME); encoder.writeUByte(succeeded ? 0 : 1); encoder.endList8(1, listToken); endFrame(frameToken); QPID_LOG_CAT(debug, protocol, id << " Sent SASL-OUTCOME(" << (succeeded ? 0 : 1) << ") " << encoder.getPosition()); }
void SaslClient::response(const std::string* r) { void* frame = startFrame(); void* token = encoder.startList32(&SASL_RESPONSE); if (r) encoder.writeBinary(*r); else encoder.writeNull(); encoder.endList32(1, token); endFrame(frame); QPID_LOG_CAT(debug, protocol, id << " Sent SASL-RESPONSE(" << (r ? *r : "null") << ")"); }
void SaslServer::challenge(const std::string* c) { void* frameToken = startFrame(); void* listToken = encoder.startList32(&SASL_CHALLENGE); if (c) encoder.writeBinary(*c); else encoder.writeNull(); encoder.endList32(1, listToken); endFrame(frameToken); QPID_LOG_CAT(debug, protocol, id << " Sent SASL-CHALLENGE(" << (c ? *c : NULL_) << ") " << encoder.getPosition()); }
/** * @brief MainWindow::on_pushButton_clicked * @return * */ void MainWindow::on_pushButton_clicked() { if(test_connect == false) { qDebug() << "Erreur Non Connecte !"; } else { //timer pour lancer en boucle l'envoie de la trame connect(timer, SIGNAL(timeout()), this, SLOT(startFrame())); timer->start(500); } }
void SaslClient::init(const std::string& mechanism, const std::string* response, const std::string* hostname) { void* frame = startFrame(); void* token = encoder.startList32(&SASL_INIT); encoder.writeSymbol(mechanism); if (response) encoder.writeBinary(*response); else encoder.writeNull(); if (hostname) encoder.writeString(*hostname); else encoder.writeNull(); encoder.endList32(3, token); endFrame(frame); QPID_LOG_CAT(debug, protocol, id << " Sent SASL-INIT(" << mechanism << ", " << (response ? *response : "null") << ", " << (hostname ? *hostname : "null") << ")"); }
void ManipTool::renderMovementAngle( Finger const &aFinger, U16 aIndex ) { if( !aFinger.mPartner || aFinger.mPartner < aIndex ) return; U16 prevFrame = getPrevFrameNo( mNextRenderedFrame ); Finger *prevFinger = mFingersPerFrame[ prevFrame ].getFinger( aFinger.mId ); U16 startFrame(mNextRenderedFrame); while( prevFinger && prevFinger->mTimestamp < aFinger.mTimestamp && (aFinger.mTimestamp - prevFinger->mTimestamp ) < getMaxBacktrackMicroseconds() && prevFinger->mPartner ) { startFrame = prevFrame; prevFrame = getPrevFrameNo( prevFrame ); prevFinger = mFingersPerFrame[ prevFrame ].getFinger( aFinger.mId ); } if( mNextRenderedFrame == startFrame ) return; Finger const *startFinger( mFingersPerFrame[ startFrame ].getFinger( aFinger.mId ) ); Finger const *startPartner( mFingersPerFrame[ startFrame ].at( startFinger->mPartner ) ); Finger const *endFinger( &aFinger ); Finger const *endPartner( mFingersPerFrame[ startFrame ].at( endFinger->mPartner ) ); float vecStart[3], vecEnd[3]; subtract( startFinger->mTip, startPartner->mTip, vecStart ); subtract( endFinger->mTip, endPartner->mTip, vecEnd ); float lenStart = normalize( vecStart ); float lenEnd = normalize( vecEnd ); float radius = lenStart>lenEnd?lenStart:lenEnd; float alpha = dot( vecStart, vecEnd ); float ptStart[3], ptEnd[3]; move( startFinger->mTip, vecStart, radius/2, ptStart ); ptEnd[0] = ptStart[0]*cos(alpha) - ptStart[1]*sin(alpha); ptEnd[1] = ptStart[1]*cos(alpha) + ptStart[0]*sin(alpha); ptEnd[2] = ptStart[2]; gGL.vertex3fv( ptStart ); gGL.vertex3fv( ptEnd ); }
void draw() { startFrame(); sceGuDisable(GU_TEXTURE); sceGuDrawArray(GU_POINTS, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 1, NULL, vertices1); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 3, NULL, vertices1 + 1); sceGuDrawArray(GU_POINTS, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 1, NULL, vertices1x); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 3, NULL, vertices1x + 1); sceGuDrawArray(GU_LINES, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 1, NULL, vertices2); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 3, NULL, vertices2 + 1); sceGuDrawArray(GU_LINES, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 1, NULL, vertices2x); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 3, NULL, vertices2x + 1); sceGuDrawArray(GU_LINE_STRIP, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 1, NULL, vertices3); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 3, NULL, vertices3 + 1); sceGuDrawArray(GU_LINE_STRIP, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 1, NULL, vertices3x); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 3, NULL, vertices3x + 1); sceGuDrawArray(GU_TRIANGLES, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 1, NULL, vertices4); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 3, NULL, vertices4 + 1); sceGuDrawArray(GU_TRIANGLES, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 1, NULL, vertices4x); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 3, NULL, vertices4x + 1); sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 1, NULL, vertices5); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 3, NULL, vertices5 + 1); sceGuDrawArray(GU_TRIANGLE_STRIP, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 1, NULL, vertices5x); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 3, NULL, vertices5x + 1); sceGuDrawArray(GU_TRIANGLE_FAN, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 1, NULL, vertices6); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 3, NULL, vertices6 + 1); sceGuDrawArray(GU_TRIANGLE_FAN, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 1, NULL, vertices6x); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 3, NULL, vertices6x + 1); sceGuDrawArray(GU_SPRITES, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 1, NULL, vertices7); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 1, NULL, vertices7 + 1); sceGuDrawArray(GU_SPRITES, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 1, NULL, vertices7x); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 1, NULL, vertices7x + 1); // Verify that it also works when auto-increasing the vertex pointer. sceGuDrawArray(GU_TRIANGLE_FAN, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 1, NULL, vertices8); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 3, NULL, NULL); sceGuDrawArray(GU_TRIANGLE_FAN, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 1, NULL, vertices8x); sceGuDrawArray(GU_CONTINUE, GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_3D, 3, NULL, NULL); endFrame(); }
void Node::frameStart( const uint128_t&, const uint32_t frameNumber ) { startFrame( frameNumber ); // unlock pipe threads switch( getIAttribute( IATTR_THREAD_MODEL )) { case ASYNC: // Don't wait for pipes to release frame locally, sync not needed releaseFrameLocal( frameNumber ); break; case DRAW_SYNC: // Sync and release in frameDrawFinish case LOCAL_SYNC: // Sync and release in frameTasksFinish break; default: LBUNIMPLEMENTED; } }
void SaslServer::mechanisms(const std::string& mechanisms) { void* frameToken = startFrame(); std::vector<std::string> parts = split(mechanisms, SPACE); void* listToken = encoder.startList32(&SASL_MECHANISMS); if (parts.size() > 1) { void* arrayToken = encoder.startArray8(Constructor(SYMBOL8)); for (std::vector<std::string>::const_iterator i = parts.begin();i != parts.end(); ++i) { uint8_t size = i->size() > std::numeric_limits<uint8_t>::max() ? std::numeric_limits<uint8_t>::max() : i->size(); encoder.write(size); encoder.writeBytes(i->data(), size); } encoder.endArray8(parts.size(), arrayToken); } else { encoder.writeSymbol(mechanisms); } encoder.endList32(1, listToken); endFrame(frameToken); QPID_LOG_CAT(debug, protocol, id << " Sent SASL-MECHANISMS(" << mechanisms << ") " << encoder.getPosition()); }
void Pipe::frameStart( const uint128_t&, const uint32_t frameNumber ) { LB_TS_THREAD( _pipeThread ); const Node* node = getNode(); switch( node->getIAttribute( Node::IATTR_THREAD_MODEL )) { case ASYNC: // No sync, release immediately releaseFrameLocal( frameNumber ); break; case DRAW_SYNC: // Sync, release in frameDrawFinish case LOCAL_SYNC: // Sync, release in frameFinish node->waitFrameStarted( frameNumber ); break; default: LBUNIMPLEMENTED; } startFrame( frameNumber ); }
bool CDVDSubtitleParserMPL2::Open(CDVDStreamInfo &hints) { if (!CDVDSubtitleParserText::Open()) return false; // MPL2 is time-based, with 0.1s accuracy m_framerate = DVD_TIME_BASE / 10.0; char line[1024]; CRegExp reg; if (!reg.RegComp("\\[([0-9]+)\\]\\[([0-9]+)\\]")) return false; CDVDSubtitleTagMicroDVD TagConv; while (m_pStream->ReadLine(line, sizeof(line))) { if ((strlen(line) > 0) && (line[strlen(line) - 1] == '\r')) line[strlen(line) - 1] = 0; int pos = reg.RegFind(line); if (pos > -1) { const char* text = line + pos + reg.GetFindLen(); std::string startFrame(reg.GetMatch(1)); std::string endFrame (reg.GetMatch(2)); CDVDOverlayText* pOverlay = new CDVDOverlayText(); pOverlay->Acquire(); // increase ref count with one so that we can hold a handle to this overlay pOverlay->iPTSStartTime = m_framerate * atoi(startFrame.c_str()); pOverlay->iPTSStopTime = m_framerate * atoi(endFrame.c_str()); TagConv.ConvertLine(pOverlay, text, strlen(text)); m_collection.Add(pOverlay); } } return true; }
int main(int argc, char** argv) { typedef std::unique_ptr<Object> ObjectPtr; std::vector<ObjectPtr> objects; World theWorld; std::shared_ptr<RenderSystem> render; render.reset(new RenderSystem()); theWorld.AddSystem(render); std::shared_ptr<System> input; input.reset(new InputSystem()); theWorld.AddSystem(std::static_pointer_cast<System>(input)); render->LoadDataFile("data/data.txt"); //create an object { ObjectPtr myObject; myObject.reset(new Object(&theWorld)); std::unique_ptr<Component> component; component.reset(new LivingComponent(myObject.get())); myObject->AddComponent(component); std::unique_ptr<Component> component2; component2.reset(new HealingEffect(myObject.get())); Event buffness("set_property"); buffness.SetValueString("property", "duration"); buffness.SetValueString("value", "5"); component2->HandleEvent(buffness); buffness.SetValueString("property", "quantity"); buffness.SetValueString("value", "20"); component2->HandleEvent(buffness); myObject->AddComponent(component2); std::unique_ptr<Component> component3; component3.reset(new RenderComponent(myObject.get())); myObject->AddComponent(component3); objects.emplace_back(std::move(myObject)); } //create an object 2 { ObjectPtr myObject; myObject.reset(new Object(&theWorld)); std::unique_ptr<Component> component; component.reset(new LivingComponent(myObject.get())); myObject->AddComponent(component); std::unique_ptr<Component> component2; component2.reset(new DamageReductionEffect(myObject.get())); Event buffness("set_property"); buffness.SetValueString("property", "max_health"); buffness.SetValueString("value", "150"); component2->HandleEvent(buffness); buffness.SetValueString("property", "health"); buffness.SetValueString("value", "150"); component2->HandleEvent(buffness); myObject->AddComponent(component2); objects.emplace_back(std::move(myObject)); } Event debug("debug"); for(auto &obj : objects) { obj->HandleEvent(debug); } Event startFrame("event_start_frame"); for(uint32_t ii=0; ii<2000; ++ii) { printf("==========[ %5d ]==========\n", ii); for(auto& object : objects) { Event damage("take_damage"); damage.SetValueInteger("damage", 20); object->HandleEvent(startFrame); object->HandleEvent(damage); //object->HandleEvent(debug); } theWorld.Update(ii, 1.0/60.0); } return 0; }
void draw() { startFrame(); sceGuTexMode(GU_PSM_T8, 0, 0, GU_FALSE); sceGuTexFilter(GU_NEAREST, GU_NEAREST); sceGuTexFunc(GU_TFX_DECAL, GU_TCC_RGB); sceGuClutMode(GU_PSM_8888, 0, 0xFF, 0); sceGuTexImage(0, 2, 2, 16, imageDataPatch); sceGuClutLoad(1, clutRGBY); sceGuPatchPrim(GU_TRIANGLE_STRIP); sceGuPatchDivide(16, 16); sceGuPatchFrontFace(GU_CW); sceGuDisable(GU_TEXTURE_2D); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices1_simple); // Let's see how UVs are interpolated. Simple bilinear will fail here. sceGuEnable(GU_TEXTURE_2D); sceGuDrawBezier(GU_TEXTURE_16BIT | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices2_uvs); sceGuDisable(GU_TEXTURE_2D); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices3_colors); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices4_pos); // Other primitive types. sceGuSendCommandi(55, 1); sceGuPatchDivide(4, 4); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices5_lines); sceGuSendCommandi(55, 2); sceGuPatchDivide(4, 4); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices6_points); sceGuSendCommandi(55, 3); sceGuPatchDivide(4, 4); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices7_prim3); sceGuSendCommandi(55, 4); sceGuPatchDivide(4, 4); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices8_prim4); sceGuPatchPrim(GU_TRIANGLE_STRIP); sceGuShadeModel(GU_FLAT); sceGuPatchDivide(1, 1); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices9_div1); sceGuPatchDivide(1, 2); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices10_div1_2); sceGuPatchDivide(2, 2); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices11_div2); sceGuPatchDivide(4, 4); sceGuShadeModel(GU_SMOOTH); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 2, NULL, vertices12_4x2); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 5, NULL, vertices13_4x5); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 8, NULL, vertices14_4x8); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D | GU_INDEX_8BIT, 4, 4, indices15_inds8, vertices15_inds8); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D | GU_INDEX_16BIT, 4, 4, indices16_inds16, vertices16_inds16); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D | GU_INDEX_BITS, 4, 4, indices17_inds32, vertices17_inds32); // Does the vertex pointer increment? sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, vertices18_19_inc); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D, 4, 4, NULL, NULL); // And indices? sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D | GU_INDEX_8BIT, 4, 4, indices20_21_ind_inc, vertices20_21_ind_inc); sceGuDrawBezier(GU_COLOR_8888 | GU_VERTEX_16BIT | GU_TRANSFORM_2D | GU_INDEX_8BIT, 4, 4, NULL, NULL); endFrame(); }
void Window::frameStart( const uint128_t&, const uint32_t frameNumber ) { startFrame( frameNumber ); }
/** main() - where all the setup happens. */ int main(){ int RXbypass; // Bypass rx? unsigned char input, checksum; serialInit(115200); // Startup serial port // setup variables count = 0; servoSetPosition(PIN_SERVO, -80); // setup sensors gp2longInit(PIN_PAN_IR); gp2d12Init(PIN_LEFT_IR); gp2d12Init(PIN_RIGHT_IR); gp2d12Init(PIN_L_REAR_IR); gp2d12Init(PIN_R_REAR_IR); servoInit(PIN_SERVO,-15,1); // RX bypass enabled? digitalSetDirection(PIN_NO_RX, AVRRA_INPUT); digitalSetData(PIN_NO_RX, AVRRA_HIGH); if(digitalGetData(PIN_NO_RX) == AVRRA_LOW){ // bypass RX; RXbypass = TRUE; TXgo = TRUE; startFrame(); delayms(5000); }else{ RXbypass = FALSE; Print("MechDAR V1.0 Alive\n"); TXgo = FALSE; } // setup a 60Hz clock on Timer/Counter 2 TCNT2 = 0; OCR2A = 240; // this defines 60 Hz Clock TCCR2A = 0x03; // no A|B compare, mode7 fast pwm TCCR2B = 0x0F; // clock/1024 TIMSK2 |= 0x01; // interrupt on overflow // start clock sei(); while(1){ if((RXbypass == FALSE) && (serialAvailable() > 0)){ // process incoming if(serialRead() == -1){ // 0xFF while(serialAvailable() == 0); input = (unsigned char) serialRead(); while(serialAvailable() == 0); checksum = (unsigned char) serialRead(); PrintNumber(input); PrintNumber(checksum); // if a valid packet... if((255 - ((input + checksum)%256)) == 0){ // process the data switch(input){ case REG_LEFT_IR: PrintNumber(gp2d12GetData(PIN_LEFT_IR)); Print("\n"); break; case REG_RIGHT_IR: PrintNumber(gp2d12GetData(PIN_LEFT_IR)); Print("\n"); break; case REG_L_REAR_IR: PrintNumber(gp2d12GetData(PIN_LEFT_IR)); Print("\n"); break; case REG_R_REAR_IR: PrintNumber(gp2d12GetData(PIN_LEFT_IR)); Print("\n"); break; case REG_STOP: TXgo = FALSE; break; case REG_GO: TXgo = TRUE; startFrame(); break; default: // Send a reading from the data frame PrintNumber(data[(input-REG_PAN_BASE)%10]); Print("\n"); break; } } } } asm("nop"); } return 0; };
int main(int argc, char* argv[]) { // Get device singleton instance. auto device = RenderDevice::getInstance(); // We use a class called InputManager for checking input. // It's a singleton so we need to get the instance. auto input = InputManager::getInstance(); device->init(); Text text(20.0f); text.setPosition(100, 100); text.setColor(Color::White); // Main loop while(device->isRunning()) { std::string key; if(input->isKeyDown(Keys::A)) { key = "A"; } else if(input->isKeyDown(Keys::B)) { key = "B"; } else if(input->isKeyDown(Keys::X)) { key = "X"; } else if(input->isKeyDown(Keys::Y)) { key = "Y"; } else if(input->isKeyDown(Keys::L)) { key = "L"; } else if(input->isKeyDown(Keys::R)) { key = "R"; } else if(input->isKeyDown(Keys::Select)) { key = "Select"; } else // ... You should check other buttons too { key = "Nothing"; } // Quit if the start button is pressed if(input->isKeyDown(Keys::Start)) { device->quit(); } text.setString(key + " pressed."); device->setTargetScreen(Screen::Top); device->clear(Color::Black); device->startFrame(); text.draw(); device->endFrame(); device->setTargetScreen(Screen::Bottom); device->clear(Color::Black); device->startFrame(); device->endFrame(); device->swapBuffers(); } // DON'T FORGET TO CALL THIS OR THE 3DS WILL CRASH AT EXIT device->destroy(); return 0; }
int main(int argc, char* argv[]) { // Get device singleton instance. auto device = RenderDevice::getInstance(); auto input = InputManager::getInstance(); device->init(); Text text(20.0f); text.setPosition(0, 30); text.setColor(Color::White); text.setLineWidth(BOTTOM_SCREEN_WIDTH); std::string str = "Press A to take a screenshot of top screen.\n\n" "Press B to take a screenshot of bottom screen.\n"; text.setString(str); // Setup a basic scene CircleShape circle(60); circle.setPosition(100, 50); circle.setColor(Color::Yellow); circle.setSegments(20); TriangleShape triangle(Vec2(110, 60), Vec2(140, 10), Vec2(180, 60)); triangle.setColor(Color::Red); // Main loop while(device->isRunning()) { if(input->isKeyDown(Keys::A)) { device->takeScreenshot("top.png", ImageFormat::Png, Screen::Top); } else if(input->isKeyDown(Keys::B)) { device->takeScreenshot("bot.png", ImageFormat::Png, Screen::Bottom); } if(input->isKeyDown(Keys::Start)) { device->quit(); } triangle.setScale((float)std::sin(device->getTicks())); circle.setAngle(circle.getAngle() + 20.0f * device->getDeltaTime()); device->setTargetScreen(Screen::Top); device->clear(Color::Cyan); device->startFrame(); circle.draw(); triangle.draw(); device->endFrame(); device->setTargetScreen(Screen::Bottom); device->clear(Color::Black); device->startFrame(); text.draw(); device->endFrame(); device->swapBuffers(); } // DON'T FORGET TO CALL THIS OR THE 3DS WILL CRASH AT EXIT device->destroy(); return 0; }