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;
}
