void *ThreeDeeApp (void *param)
{
queue *fifo;
int msg, buff = 0;
fifo = (queue *)param;
float Yrotation = 0;
assets = new Obj3d(true);
EGLinit(eglDisplay, eglSurface);
if (1==preRender())
{
EGLdeinit(eglDisplay);
exit(1);
}
assets->start(g_hTXShaderProgram, "resources/models/tumbler/BatMobil.obj", *assets);
if(!assets->getScene())
{
printf("scene could not be loaded\n");
exit(1);
}
printf("scene loaded\n");
for (;;)
{
if(!fifo->empty)
{
pthread_mutex_lock(fifo->mut);
queueDel(fifo, &msg);
pthread_mutex_unlock(fifo->mut);
pthread_cond_signal(fifo->notFull);
//printf("3D app: received %i\n", msg);
}
if (msg != buff)
{
Yrotation = msg - buff;
buff = msg;
Render(assets, 0, Yrotation*3, 0, 0);
} else
{
Render(assets, 0, 0, 0, 0);
}
Yrotation = 0;
//msg=0;
eglSwapBuffers(eglDisplay, eglSurface);
}
RenderCleanup(assets);
// cleanup
DestroyShaders();
EGLdeinit(eglDisplay);
return (NULL);
}
void CheckBox::render() {
if (parent == NULL) { preRender(); }
renderBackground();
if (m_checked) { renderTick(); }
renderOverlay();
if (parent == NULL) { postRender(); }
}
void TextField2::render(float dt)
{
if (!mVisible || mFont == NULL || !mFont->isLoaded())
{
return;
}
mCurrentLine = 0;
preRender(dt);
mFont->getAsset()->getTexture()->bindTexture();
glBegin(GL_QUADS);
while (mCurrentNode.get() != NULL)
{
if (mNewLineDirty)
{
Node::NodeHitboxList &list = mCurrentNode->getHitboxes();
list.clear();
Handle<NodeHitbox> hitbox(new NodeHitbox(mCurrentNode));
mTextHitboxes->addChild(hitbox.get());
hitbox->setPosition(mCurrXpos, mCurrYpos - mTextHitboxes->getPositionY());
hitbox->setHeight(mFont->getCharHeight());
hitbox->addEventListener(MOUSE_UP, this);
list.push_back(hitbox);
}
TextStyle currentStyle = mCurrentNode->getTextStyle();
GfxEngine::getEngine()->popColourStack();
if (currentStyle.hasColour())
{
GfxEngine::getEngine()->pushColourStack(currentStyle.getColour());
}
else
{
if (mGfxComponent)
{
GfxEngine::getEngine()->pushColourStack(mGfxComponent->getColour());
}
else
{
GfxEngine::getEngine()->pushColourStack(Colour::WHITE);
}
}
GfxEngine::getEngine()->applyColourStack();
renderText(mCurrentNode->getText());
mCurrentNode = mCurrentNode->nextSibling();
}
glEnd();
mScrollbar->setMaxValue(getTotalNumLines() - mDisplayNumLines - 1);
mNewLineDirty = false;
for (ChildList::iterator iter = mChildren.begin(); iter != mChildren.end(); ++iter)
{
if (mGfxComponent)
{
mGfxComponent->getColour().applyColour();
}
(*iter)->render(dt);
}
postRender(dt);
}
TexturePtr LinearGradient::createAsTexture(int width, int height)
{
const float w = static_cast<float>(width);
const float h = static_cast<float>(height);
const float sa = std::abs(std::sin(-angle_ / 180.0f * static_cast<float>(M_PI)));
const float ca = std::abs(std::cos(-angle_ / 180.0f * static_cast<float>(M_PI)));
//const float length = std::min(ca < FLT_EPSILON ? FLT_MAX : width / ca, sa < FLT_EPSILON ? FLT_MAX : height / sa);
//const float length = std::min(ca < FLT_EPSILON ? w : 2.0f * ca * w, sa < FLT_EPSILON ? h : 2.0f * sa * h);
WindowPtr wnd = WindowManager::getMainWindow();
CameraPtr cam = std::make_shared<Camera>("ortho_lg", 0, width, 0, height);
auto grad = createRenderable();
grad->setCamera(cam);
grad->setScale(ca < FLT_EPSILON ? w : 2.0f * w / ca, sa < FLT_EPSILON ? h : 2.0f * h / sa);
grad->setPosition(w/2.0f, h/2.0f);
RenderTargetPtr rt = RenderTarget::create(width, height);
rt->getTexture()->setFiltering(-1, Texture::Filtering::LINEAR, Texture::Filtering::LINEAR, Texture::Filtering::POINT);
rt->getTexture()->setAddressModes(-1, Texture::AddressMode::CLAMP, Texture::AddressMode::CLAMP);
rt->setCentre(Blittable::Centre::TOP_LEFT);
rt->setClearColor(Color(0,0,0,0));
{
RenderTarget::RenderScope rs(rt, rect(0, 0, width, height));
grad->preRender(wnd);
wnd->render(grad.get());
}
return rt->getTexture();
}
//-------------------------------------------------------------------------
// r u n
//-------------------------------------------------------------------------
void CApplication::run()
{
ITimer* timer = m_device->getTimer();
u32 current, last = timer->getRealTime();
u32 delta = 0;
m_running = true;
while(m_device->run() && m_running)
{
// calc seconds since last frame
current = timer->getRealTime();
delta = current-last;
last = current;
m_videoDriver->beginScene(true, true, SColor(255,100,101,140));
preRender(delta);
m_sceneManager->drawAll();
m_gui->drawAll();
postRender();
m_videoDriver->endScene();
}
logMessage("Exiting Run Loop");
stringc msg = "Frame Rate - Avg: ";
msg += m_fpsAvg;
msg += ", Min: ";
msg += m_fpsMin;
msg += ", Max: ";
msg += m_fpsMax;
logMessage(msg);
}
void RenderableTrailNew::render(const RenderData& data) {
_programObject->activate();
if (_renderFullTrail.value() == true) {
preRender(_vertexPositionArray.size());
preRenderSubPathGlobally(data);
// Easy but not beautiful solution to render all vertices with max alpha
_programObject->setUniform(
"vertexIDPadding", static_cast<int>(_vertexPositionArray.size()));
renderLines(_vaoGlobalID, _vertexPositionArray.size() - 1);
if (_showTimeStamps) {
renderPoints(_vaoGlobalID, _vertexPositionArray.size() - 1);
}
}
else { // Only render the trail up to the point of the object body
int nVerticesToDraw = glm::ceil(_vertexPositionArray.size() *
(_currentTimeClamped - _timeRange.start) / (_timeRange.end - _timeRange.start));
nVerticesToDraw = glm::min(
nVerticesToDraw, static_cast<int>(_vertexPositionArray.size())) - 1;
if (nVerticesToDraw > 1) {
preRender(nVerticesToDraw);
// Perform rendering of the bulk of the trail in single floating point precision
preRenderSubPathGlobally(data);
// The last vertex is drawn with higher precision after this
// Hence we subtract one vertex from the ones to draw globally
int nVerticesToDrawGlobally = nVerticesToDraw - 1;
renderLines(_vaoGlobalID, nVerticesToDrawGlobally);
if (_showTimeStamps) {
renderPoints(_vaoGlobalID, nVerticesToDrawGlobally);
}
// The last line segment is rendered relative to body to achieve high precision
preRenderSubPathLocally(data, nVerticesToDraw);
renderLines(_vaoLocalID, 2);
if (_showTimeStamps) {
renderPoints(_vaoLocalID, 2);
}
}
else if (_currentTimeClamped > _timeRange.start) {
preRenderSubPathLocally(data, 2);
renderLines(_vaoLocalID, 2);
}
}
_programObject->deactivate();
}
void
PhysicsDebugDrawer::drawAll
()
{
#ifdef DREAM_LOG
auto log = getLog();
log->debug( "Drawing {} lines" , mVertexBuffer.size()/2 );
#endif
preRender();
// Enable shader program
glUseProgram(mShaderProgram);
glBindVertexArray(mVAO);
ShaderRuntime::CurrentShaderProgram = mShaderProgram;
// Set the projection matrix
GLint projUniform = glGetUniformLocation(mShaderProgram, "projection");
if (projUniform == -1)
{
#ifdef DREAM_LOG
log->error( "Unable to find Uniform Location for projection" );
checkGLError();
#endif
return;
}
else
{
mat4 projectionMatrix = mCamera->getProjectionMatrix();
glUniformMatrix4fv(projUniform, 1, GL_FALSE, glm::value_ptr(projectionMatrix));
}
// Set the view matrix
GLint viewUniform = glGetUniformLocation(mShaderProgram, "view");
if (viewUniform == -1)
{
#ifdef DREAM_LOG
log->error( "Unable to find Uniform Location for view" );
checkGLError();
#endif
return;
}
else
{
mat4 viewMatrix = mCamera->getViewMatrix();
glUniformMatrix4fv(viewUniform, 1, GL_FALSE, glm::value_ptr(viewMatrix));
}
glBindBuffer(GL_ARRAY_BUFFER, mVBO);
glBufferData(GL_ARRAY_BUFFER, static_cast<GLint>(mVertexBuffer.size() * sizeof(PhysicsDebugVertex)), &mVertexBuffer[0], GL_STATIC_DRAW);
// Draw
glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(mVertexBuffer.size()));
// Unbind
postRender();
// Clear old buffer
mVertexBuffer.clear();
}
void Model::traverse(RenderContext &ctx, const std::string& operation)
{
if (operation == "render") {
preRender(ctx);
postRender(ctx);
}
else
Node::traverse(ctx,operation);
}
void MainCanvas::renderTree()
{
preRender();
glproc::BindFramebuffer(GL_FRAMEBUFFER, 0);
GLContext::checkError("Canvas::renderTree: BindFramebuffer()");
{
ScopeTimer Timer(RootRenderProfilingZone);
Canvas::render(m_pDisplayEngine->getWindowSize(), false);
}
}
void TextWidget::render() {
double ratioNow = SDL::Projector::getInstance()->getAspectRatio();
if(lastRenderedRatio != ratioNow) {
lastRenderedRatio = ratioNow;
dirty = true;
}
if(dirty) {
preRender();
}
if(data.empty() || !stringTexture.hasTexture()) {
return; // empty text, or error in pre-rendering
}
WidgetPoint corner = getBoundingRect().getCorner();
WidgetPoint dimensions = getBoundingRect().getDimensions();
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, stringTexture.getTextureID());
glColor3f(1.0f, 1.0f, 1.0f);
// comment this out to disable font transparency
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBegin(GL_QUADS);
double width = dimensions.getX() * widthFactor;
double height = dimensions.getY() * heightFactor;
// scale dimensions to take the larger power-of-2 texture into account
// this way it looks the same no matter how big the texture actually is
WidgetPoint topLeft = corner;
WidgetPoint lowerLeft = corner;
WidgetPoint topRight = corner;
WidgetPoint lowerRight = corner;
lowerLeft.addY(height);
lowerRight.addY(height);
topRight.addX(width);
lowerRight.addX(width);
glTexCoord2i(0, 0); WidgetRenderer::glVertex(topLeft);
glTexCoord2i(1, 0); WidgetRenderer::glVertex(topRight);
glTexCoord2i(1, 1); WidgetRenderer::glVertex(lowerRight);
glTexCoord2i(0, 1); WidgetRenderer::glVertex(lowerLeft);
glEnd();
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
}
void PerlinContent::render(const ci::Vec2i & screenOffset, const ci::Rectf & contentRect)
{
preRender();
TextureContent::render(screenOffset, contentRect);
/*
gl::bindStockShader(gl::ShaderDef().color());
gl::clear( ColorAf( 1.0f, 0.0f, 0.0f, 0.0f ) );
Rectf screenRect(0, 0, getWindowWidth(), getWindowHeight());
gl::draw(mTexture, screenRect);
*/
}
void Object::render()
{
preRender();
if (material) material->select();
draw();
if (material) material->unselect();
postRender();
}
void ModelObjectContainer::render()
{
preRender();
if (material) material->select();
draw();
postRender();
if (material) material->unselect();
}
TextWidget::TextWidget(const std::string &name, OpenGL::Color color,
const std::string &data, unsigned align)
: AbstractWidget(name) {
this->color = color;
this->data = data;
this->align = align;
dirty = true;
lastRenderedRatio = 0.0;
preRender();
}
void ParticleSystem::render(float dt)
{
preRender(dt);
unsigned int newParticles = 0;
if (mParticleList.size() < static_cast<unsigned int>(mMaxParticles))
{
mCurrentParticleCount += dt * mParticlesPerSecond;
newParticles = static_cast<unsigned int>(mCurrentParticleCount);
if (mParticleList.size() + newParticles > static_cast<unsigned int>(mMaxParticles))
{
newParticles = mMaxParticles - mParticleList.size();
}
mCurrentParticleCount -= static_cast<float>(newParticles);
}
else
{
mCurrentParticleCount = 0.0f;
}
if (newParticles > 0)
{
for (unsigned int i = 0; i < newParticles; i++)
{
newParticle();
}
}
float accX = getAccelerationX() * dt;
float accY = getAccelerationY() * dt;
float ageResp = 1.0f / mMaxAge;
float alphaRange = mEndAlpha - mStartAlpha;
for (size_t i = 0; i < mParticleList.size(); i++)
{
Particle *particle = mParticleList[i];
float t = particle->getAge() * ageResp;
particle->getGfxComponent()->setAlpha(t * alphaRange + mStartAlpha);
particle->preRender(*this, accX, accY, dt);
if (particle->getAge() >= mMaxAge)
{
particle->postRender(dt);
mParticleList.erase(mParticleList.begin() + i);
i--;
continue;
}
particle->render(dt);
particle->postRender(dt);
}
postRender(dt);
}
TextWidget::TextWidget(const std::string &name, const std::string &data,
unsigned align, const WidgetRect &bounds, OpenGL::Color color)
: AbstractWidget(name) {
this->color = color;
this->data = data;
this->align = align;
preRender();
dirty = false;
updateLayout(bounds);
}
void MainCanvas::renderTree()
{
preRender();
DisplayEngine* pDisplayEngine = getPlayer()->getDisplayEngine();
unsigned numWindows = pDisplayEngine->getNumWindows();
for (unsigned i=0; i<numWindows; ++i) {
ScopeTimer Timer(RootRenderProfilingZone);
WindowPtr pWindow = pDisplayEngine->getWindow(i);
IntRect viewport = pWindow->getViewport();
renderWindow(pWindow, MCFBOPtr(), viewport);
}
GLContextManager::get()->reset();
}
void Sprite::render(float dt)
{
if (!mVisible)
{
return;
}
if (mAsset == NULL || mAsset->getTexture() == NULL || !mAsset->getTexture()->isLoaded())
{
if (!mGfxComponent || (mGfxComponent && mGfxComponent->getColour().getAlpha() > 0.05f))
{
preRender(dt);
Texture::bindTexture(0);
if (mGfxComponent)
{
mGfxComponent->getColour().applyColour();
}
glBegin(GL_QUADS);
glVertex2f(0.0f, 0.0f);
glVertex2f(getWidth(), 0.0f);
glVertex2f(getWidth(), getHeight());
glVertex2f(0.0f, getHeight());
glEnd();
postRender(dt);
}
return;
}
preRender(dt);
updateSprite(dt);
renderSprite();
postRender(dt);
}
BOOL LLViewerTexLayerSetBuffer::requestUpdateImmediate()
{
mNeedsUpdate = TRUE;
BOOL result = FALSE;
if (needsRender())
{
preRender(FALSE);
result = render();
postRender(result);
}
return result;
}
void Charts::Chart::renderImpl(const RenderArgs & renderArgs) const
{
if (!TR_VERIFY(updated)) {
return;
}
preRender();
glClearColor(renderArgs.clearColor.x, renderArgs.clearColor.y, renderArgs.clearColor.z, renderArgs.clearColor.w);
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
if (fillColor.alpha > 0.0) {
const std::shared_ptr<TR3DUtils::QuadRenderer> quadRenderer = renderContext->getQuadRenderer();
quadRenderer->bind();
quadRenderer->bindModelViewProjection(renderArgs.projection);
quadRenderer->bindColor(Utils::colorToVec4(fillColor));
quadRenderer->drawQuad(glm::vec3(renderArgs.areaStart, 0.0), renderArgs.areaSize);
}
for (const auto axis : axisList) {
if (axis->isEnabled() && axis->isVisible()) {
axis->renderGrid(*renderContext, renderArgs);
}
}
std::vector<std::shared_ptr<ChartElement>> elements;
elements.insert(elements.end(), seriesList.begin(), seriesList.end());
elements.insert(elements.end(), decorationList.begin(), decorationList.end());
std::stable_sort(elements.begin(), elements.end(), [](const std::shared_ptr<ChartElement> & a, const std::shared_ptr<ChartElement> & b) -> bool {
return a->getDrawOrder() < b->getDrawOrder();
});
for (const auto element : elements) {
if (element->isEnabled() && element->isVisible()) {
element->render(*renderContext, renderArgs);
}
}
for (const auto axis : axisList) {
if (axis->isEnabled() && axis->isVisible()) {
axis->renderAxis(*renderContext, renderArgs);
}
}
glDisable(GL_BLEND);
}
int main(int argc, const char *argv[]) {
// Start up SDL, and make sure it went ok
//
uint32_t flags = SDL_INIT_TIMER | SDL_INIT_VIDEO | SDL_INIT_EVENTS;
if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
fprintf(stderr,
"\nUnable to initialize SDL: %s\n",
SDL_GetError());
return 1;
}
atexit(cleanup);
init();
bool quit = false;
while(!quit) {
preRender();
getInput();
updateTetris();
updateRender();
// Set to ~60 fps.
// 1000 ms/ 60 fps = 1/16 s^2/frame
SDL_Delay(16);
}
return 0;
}
void UIView::drawItself(GraphicsDevice* renderer, const mat4& transform )
{
// Invisible UIView, stop rendering itself or children
if(!m_visible)
{
return;
}
if(m_clipContents)
{
renderer->pushClippingRect(FloatRect(mRect.left,mRect.top,mRect.width, mRect.height));
}
mat4 absoluteTransform = mat4::identity;
mat4 localTransform = mat4::translate(position) * mat4::rotatey(rotation_y) * mat4::rotatex(rotation_x);
absoluteTransform = transform * localTransform;
// Tel
draw(renderer, absoluteTransform);
for(std::size_t i = 0; i < components.size(); ++i)
{
components[i]->onRender(renderer, this, absoluteTransform);
}
if(m_clipContents)
{
renderer->popClippingRect();
}
// -- Pre Render Step (Before Children)
preRender(renderer);
// clip the overflowing children
if(m_clipChildren)
{
if(getContext()->transformPointerCoordinates)
{
renderer->pushClippingRect(FloatRect(mRect.left / getContext()->targetWindowSize.x,mRect.top / getContext()->targetWindowSize.y,mRect.width / getContext()->targetWindowSize.x, mRect.height / getContext()->targetWindowSize.y), true);
}
else
{
renderer->pushClippingRect(FloatRect(mRect.left,mRect.top,mRect.width, mRect.height));
}
}
// Let children render as well
for(std::vector<UIView*>::const_iterator it = m_children.begin(); it != m_children.end(); it++)
{
(*it)->drawItself(renderer, absoluteTransform);
}
if(m_clipChildren)
renderer->popClippingRect();
// -- Post Render Step (After Children)
postRender(renderer);
}
bool ARenderable::preRenderDebug()
{
return preRender();
}
void AbstractScene::display(){
ShaderManager & shaderManager = ShaderManager::getInstance();
glClearColor(1, 1, 1, 1);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
m_pCam->lookAt();
//First we calculate everything we need to create the final scene
preRender();
//The final scene is render into the final FBO
finalFBO->activate();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
render();
finalFBO->desactivate();
if(m_bStereo){
if (m_bTexture)
ImageTool::SITS(finalFBO,200,m_iSIRDS);
else
ImageTool::SIRDS(finalFBO,200,m_iSIRDS);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,m_iSIRDS);
displayOnQuad(iWindowWidth,iWindowHeight);
glBindTexture(GL_TEXTURE_2D,0);
}
else{
glActiveTexture(GL_TEXTURE0);
finalFBO->activateTexture();
shaderManager.getShader("filters")->Activate();
shaderManager.getShader("filters")->setUniformi("choix",0);
displayOnQuad(iWindowWidth,iWindowHeight);
shaderManager.getShader("filters")->Desactivate();
glActiveTexture(GL_TEXTURE0);
finalFBO->desactivateTexture();
shaderManager.getShader("filters")->Desactivate();
}
//finalFBO->desactivateTexture();
/*//-----------------------------------------------Post Processing
//activate final color and depth textures
glActiveTexture(GL_TEXTURE0);
finalFBO->activateTexture();
glActiveTexture(GL_TEXTURE2);
finalFBO->activateDepthTexture();
glActiveTexture(GL_TEXTURE0);
//get effect queue
std::list<std::string> queue = EffectManager::getInstance().getQueue();
std::list<std::string>::iterator itFx = queue.begin();
int pass = 0;
//process effects
while(itFx != queue.end()){
bool evenPass = pass%2 == 0;
AbstractEffect* fx = EffectManager::getInstance().getEffect(*itFx);
fx->preProcess(iWindowWidth,iWindowHeight);
//we need to switch between 2 FBO's in order to use previous effect image in current effect
if(evenPass)
postProcessFBO0->activate();
else
postProcessFBO1->activate();
fx->process(iWindowWidth,iWindowHeight);
if(evenPass)
postProcessFBO0->desactivate();
else
postProcessFBO1->desactivate();
glActiveTexture(GL_TEXTURE0);
if(evenPass)
postProcessFBO0->activateTexture();
else
postProcessFBO1->activateTexture();
++itFx;
++pass;
}
//-----------------------------------------------Final Display
shaderManager.getShader("filters")->Activate();
shaderManager.getShader("filters")->setUniformi("choix",0);
displayOnQuad(iWindowWidth,iWindowHeight);
shaderManager.getShader("filters")->Desactivate();
glActiveTexture(GL_TEXTURE2);
finalFBO->desactivateDepthTexture();
glActiveTexture(GL_TEXTURE0);
finalFBO->desactivateTexture();
shaderManager.getShader("filters")->Desactivate();*/
}
void Geometry::render() {
preRender();
glDrawArrays(GL_TRIANGLES, 0, verticies.size());
postRender();
}
void GuiOffscreenCanvas::renderFrame(bool preRenderOnly, bool bufferSwap /* = true */)
{
if (!mTargetDirty)
return;
#ifdef TORQUE_ENABLE_GFXDEBUGEVENTS
char buf[256];
dSprintf(buf, sizeof(buf), "OffsceenCanvas %s", getName() ? getName() : getIdString());
GFXDEBUGEVENT_SCOPE_EX(GuiOffscreenCanvas_renderFrame, ColorI::GREEN, buf);
#endif
PROFILE_START(OffscreenCanvasPreRender);
#ifdef TORQUE_GFX_STATE_DEBUG
GFX->getDebugStateManager()->startFrame();
#endif
if (mTarget->getSize() != mTargetSize)
{
_setupTargets();
mNamedTarget.setViewport( RectI( Point2I::Zero, mTargetSize ) );
}
// Make sure the root control is the size of the canvas.
Point2I size = mTarget->getSize();
if(size.x == 0 || size.y == 0)
{
PROFILE_END();
return;
}
RectI screenRect(0, 0, size.x, size.y);
maintainSizing();
//preRender (recursive) all controls
preRender();
PROFILE_END();
// Are we just doing pre-render?
if(preRenderOnly)
{
return;
}
resetUpdateRegions();
PROFILE_START(OffscreenCanvasRenderControls);
GuiCursor *mouseCursor = NULL;
bool cursorVisible = true;
Point2I cursorPos((S32)mCursorPt.x, (S32)mCursorPt.y);
mouseCursor = mDefaultCursor;
mLastCursorEnabled = cursorVisible;
mLastCursor = mouseCursor;
mLastCursorPt = cursorPos;
// Set active target
GFX->pushActiveRenderTarget();
GFX->setActiveRenderTarget(mTarget);
// Clear the current viewport area
GFX->setViewport( screenRect );
GFX->clear( GFXClearTarget, ColorF(0,0,0,0), 1.0f, 0 );
resetUpdateRegions();
// Make sure we have a clean matrix state
// before we start rendering anything!
GFX->setWorldMatrix( MatrixF::Identity );
GFX->setViewMatrix( MatrixF::Identity );
GFX->setProjectionMatrix( MatrixF::Identity );
RectI contentRect(Point2I(0,0), mTargetSize);
{
// Render active GUI Dialogs
for(iterator i = begin(); i != end(); i++)
{
// Get the control
GuiControl *contentCtrl = static_cast<GuiControl*>(*i);
GFX->setClipRect( contentRect );
GFX->setStateBlock(mDefaultGuiSB);
contentCtrl->onRender(contentCtrl->getPosition(), contentRect);
}
// Fill Blue if no Dialogs
if(this->size() == 0)
GFX->clear( GFXClearTarget, ColorF(0,0,0,1), 1.0f, 0 );
GFX->setClipRect( contentRect );
// Draw cursor
//
if (mCursorEnabled && mouseCursor && mShowCursor)
{
Point2I pos((S32)mCursorPt.x, (S32)mCursorPt.y);
Point2I spot = mouseCursor->getHotSpot();
pos -= spot;
mouseCursor->render(pos);
}
GFX->getDrawUtil()->clearBitmapModulation();
}
mTarget->resolve();
GFX->popActiveRenderTarget();
PROFILE_END();
// Keep track of the last time we rendered.
mLastRenderMs = Platform::getRealMilliseconds();
mTargetDirty = mDynamicTarget;
onFrameRendered();
}
void PSystem ::render()
{
//世界变换
D3DXMATRIX world;
D3DXMatrixIdentity(&world);
_device->SetTransform(D3DTS_WORLD,&world);
//如果链表中有元素 ，则进入
if(!_particles.empty ())
{
preRender ();
_device->SetTexture (0,_tex); //设置材质
_device->SetFVF (D3DFVF_XYZ | D3DFVF_DIFFUSE); //设置顶点格式
_device->SetStreamSource (0,_vb,0,sizeof(Particle)); //设置资源流
//检测偏移量是否超过内存大小
if(_vbOffset>=_vbSize)
_vbOffset=0;
DWORD numParticlesInBatch =0;
Particle *v=0;
_vb->Lock (
_vbOffset *sizeof(Particle),
_vbBatchSize * sizeof(Particle),
(void **)&v,
_vbOffset? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD );
//遍历链表 开始画
std::list <Attribute>::iterator i;
for(i=_particles.begin();i!=_particles.end ();i++)
{
if(i->_isAlive==true)
{
v->_color=i->_color;
v->_position=i->_position;
v++;
numParticlesInBatch++;
if(numParticlesInBatch==_vbBatchSize)
{
_vb->Unlock ();
//所以，这里实际上只是把粒子画出来？和位置无关？
_device->DrawPrimitive(D3DPT_POINTLIST,_vbOffset,_vbBatchSize);
_vbOffset+=_vbBatchSize;
if(_vbOffset>=_vbSize)
_vbOffset=0;
numParticlesInBatch=0;
_vb->Lock (
_vbOffset *sizeof(Particle),
_vbBatchSize * sizeof(Particle),
(void **)&v,
_vbOffset? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD );
}
}
}
_vb->Unlock ();
//还要处理一种情况，当此次渲染中活着的粒子数不是_vbBatchSize的倍数，也即无法满足最后一个片段中（numParticlesInBatch==_vbBatchSize）的条件
//这时最后一个片段没有被绘制到，所以要来绘制最后一个片段
if(numParticlesInBatch) //最后一个片段中有粒子
{
_device->DrawPrimitive(D3DPT_POINTLIST,_vbOffset,numParticlesInBatch);
}
_vbOffset+=_vbBatchSize;
postRender();
}
}
