//================================================================
// Function : Convert_Presentation::drawSurfaceAndItsBSpline
// Purpose :
//================================================================
void Convert_Presentation::drawSurfaceAndItsBSpline(Handle_Geom_Surface theSurface,
const Standard_CString theName,
TCollection_AsciiString& theText)
{
TCollection_AsciiString aTitle ("Converting ");
aTitle += theName;
aTitle += " to BSpline surface";
theText += EOL
" Handle_Geom_BSplineSurface aBSplineSurface = " EOL
" GeomConvert::SurfaceToBSplineSurface(aSurface);" EOL;
setResultTitle (aTitle.ToCString());
setResultText (theText.ToCString());
drawSurface (theSurface, SurfaceColor);
if (WAIT_A_LITTLE) return;
Handle_Geom_BSplineSurface aBSplineSurface = GeomConvert::SurfaceToBSplineSurface(theSurface);
_ASSERTE(!aBSplineSurface.IsNull());
drawSurface (aBSplineSurface, BSplineSurfaceColor);
}
void CCRenderSurface::drawLayer(LayerRendererChromium* layerRenderer, CCLayerImpl* maskLayer, const TransformationMatrix& drawTransform)
{
TransformationMatrix renderMatrix = drawTransform;
// Apply a scaling factor to size the quad from 1x1 to its intended size.
renderMatrix.scale3d(m_contentRect.width(), m_contentRect.height(), 1);
TransformationMatrix deviceMatrix = TransformationMatrix(layerRenderer->windowMatrix() * layerRenderer->projectionMatrix() * renderMatrix).to2dTransform();
// Can only draw surface if device matrix is invertible.
if (!deviceMatrix.isInvertible())
return;
FloatQuad quad = deviceMatrix.mapQuad(layerRenderer->sharedGeometryQuad());
CCLayerQuad layerQuad = CCLayerQuad(quad);
#if defined(OS_CHROMEOS)
// FIXME: Disable anti-aliasing to workaround broken driver.
bool useAA = false;
#else
// Use anti-aliasing programs only when necessary.
bool useAA = (!quad.isRectilinear() || !quad.boundingBox().isExpressibleAsIntRect());
#endif
if (useAA)
layerQuad.inflateAntiAliasingDistance();
bool useMask = false;
if (maskLayer && maskLayer->drawsContent())
if (!maskLayer->bounds().isEmpty())
useMask = true;
if (useMask) {
if (useAA) {
const MaskProgramAA* program = layerRenderer->renderSurfaceMaskProgramAA();
drawSurface(layerRenderer, maskLayer, drawTransform, deviceMatrix, layerQuad, program, program->fragmentShader().maskSamplerLocation(), program->vertexShader().pointLocation(), program->fragmentShader().edgeLocation());
} else {
const MaskProgram* program = layerRenderer->renderSurfaceMaskProgram();
drawSurface(layerRenderer, maskLayer, drawTransform, deviceMatrix, layerQuad, program, program->fragmentShader().maskSamplerLocation(), -1, -1);
}
} else {
if (useAA) {
const ProgramAA* program = layerRenderer->renderSurfaceProgramAA();
drawSurface(layerRenderer, maskLayer, drawTransform, deviceMatrix, layerQuad, program, -1, program->vertexShader().pointLocation(), program->fragmentShader().edgeLocation());
} else {
const Program* program = layerRenderer->renderSurfaceProgram();
drawSurface(layerRenderer, maskLayer, drawTransform, deviceMatrix, layerQuad, program, -1, -1, -1);
}
}
}
void CCRenderSurface::drawLayer(LayerRendererChromium* layerRenderer, CCLayerImpl* maskLayer, const TransformationMatrix& drawTransform, int contentsTextureId)
{
TransformationMatrix deviceMatrix = computeDeviceTransform(layerRenderer, drawTransform);
// Can only draw surface if device matrix is invertible.
if (!deviceMatrix.isInvertible())
return;
// Draw the background texture if there is one.
if (m_backgroundTexture && m_backgroundTexture->isReserved())
copyTextureToFramebuffer(layerRenderer, m_backgroundTexture->textureId(), m_contentRect.size(), drawTransform);
FloatQuad quad = deviceMatrix.mapQuad(layerRenderer->sharedGeometryQuad());
CCLayerQuad deviceRect = CCLayerQuad(FloatQuad(quad.boundingBox()));
CCLayerQuad layerQuad = CCLayerQuad(quad);
// Use anti-aliasing programs only when necessary.
bool useAA = (!quad.isRectilinear() || !quad.boundingBox().isExpressibleAsIntRect());
if (useAA) {
deviceRect.inflateAntiAliasingDistance();
layerQuad.inflateAntiAliasingDistance();
}
bool useMask = false;
if (maskLayer && maskLayer->drawsContent())
if (!maskLayer->bounds().isEmpty())
useMask = true;
// FIXME: pass in backgroundTextureId and blend the background in with this draw instead of having a separate drawBackground() pass.
if (useMask) {
if (useAA) {
const LayerRendererChromium::RenderSurfaceMaskProgramAA* program = layerRenderer->renderSurfaceMaskProgramAA();
drawSurface(layerRenderer, maskLayer, drawTransform, deviceMatrix, deviceRect, layerQuad, contentsTextureId, program, program->fragmentShader().maskSamplerLocation(), program->vertexShader().pointLocation(), program->fragmentShader().edgeLocation());
} else {
const LayerRendererChromium::RenderSurfaceMaskProgram* program = layerRenderer->renderSurfaceMaskProgram();
drawSurface(layerRenderer, maskLayer, drawTransform, deviceMatrix, deviceRect, layerQuad, contentsTextureId, program, program->fragmentShader().maskSamplerLocation(), -1, -1);
}
} else {
if (useAA) {
const LayerRendererChromium::RenderSurfaceProgramAA* program = layerRenderer->renderSurfaceProgramAA();
drawSurface(layerRenderer, maskLayer, drawTransform, deviceMatrix, deviceRect, layerQuad, contentsTextureId, program, -1, program->vertexShader().pointLocation(), program->fragmentShader().edgeLocation());
} else {
const LayerRendererChromium::RenderSurfaceProgram* program = layerRenderer->renderSurfaceProgram();
drawSurface(layerRenderer, maskLayer, drawTransform, deviceMatrix, deviceRect, layerQuad, contentsTextureId, program, -1, -1, -1);
}
}
}
void BaseRenderOSystem::fadeToColor(byte r, byte g, byte b, byte a, Common::Rect *rect) {
Common::Rect fillRect;
if (rect) {
fillRect.left = rect->left;
fillRect.top = rect->top;
fillRect.setWidth(rect->width());
fillRect.setHeight(rect->height());
} else {
Rect32 rc;
_gameRef->getCurrentViewportRect(&rc);
fillRect.left = (int16)rc.left;
fillRect.top = (int16)rc.top;
fillRect.setWidth((int16)(rc.right - rc.left));
fillRect.setHeight((int16)(rc.bottom - rc.top));
}
modTargetRect(&fillRect);
//TODO: This is only here until I'm sure about the final pixelformat
uint32 col = _renderSurface->format.ARGBToColor(a, r, g, b);
Graphics::Surface surf;
surf.create((uint16)fillRect.width(), (uint16)fillRect.height(), _renderSurface->format);
Common::Rect sizeRect(fillRect);
sizeRect.translate(-fillRect.top, -fillRect.left);
surf.fillRect(fillRect, col);
TransformStruct temp = TransformStruct();
temp._alphaDisable = false;
drawSurface(nullptr, &surf, &sizeRect, &fillRect, temp);
surf.free();
//SDL_SetRenderDrawColor(_renderer, r, g, b, a);
//SDL_SetRenderDrawBlendMode(_renderer, SDL_BLENDMODE_BLEND);
//SDL_RenderFillRect(_renderer, &fillRect);
}
//the game loop, calls all of the supplemental
//methods of the application to continuously
//update and maintain the functionality of the
//game
void Application::gameLoop()
{
while(gameRunning)
{
handleEnvironment();
updateMonsters();
handleEvents();
updatePlayer();
handleArrows();
handlePhysics();
delta.start();
checkBoundaries();
updateFPS();
updatePoints();
drawSurface();
if(finished)
{
showFinal();
}
}
}
void display() {
glEnable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/*
* See drawing.c for the definition of these routines.
*
* Note: Only one should be called at a time (based on the
* display mode).
*/
if (drawing3D()) {
lightSource(true);
draw3DModel();
} // if
else {
lightSource(false);
drawSurface();
} // else
glFlush(); /* Flush all executed OpenGL ops finish */
onResize();
/*
* Since we are using double buffers, we need to call the swap
* function every time we are done drawing.
*/
glutSwapBuffers();
}
void Curve::draw()
{
if(0 == vDegree) {
drawCurve();
} else {
drawSurface();
}
}
void PaintedWidget::paintEvent(QPaintEvent *event) {
QPainter painter(this);
img.fill(Qt::white);
double minZ=0;
for(int i=0;i<8;i++)if(node[i][2]<minZ)minZ=node[i][2];
for(int i=0;i<6;i++)if(!ishide(minZ,i)) {
color=colors[i].lighter(int(fact(i)));
drawSurface(i,&painter);
}
painter.drawImage(0,0,img);
}
void Screen::drawAnimFrame(uint16 animIndex, int16 x, int16 y, int16 frameNum, int16 flipX, int16 flipY, const ClipInfo &clipInfo) {
if (frameNum < 0)
return;
AnimationResource *anim = _vm->_res->getAnimation(animIndex);
Graphics::Surface *sourceSurface = anim->getFrame(frameNum);
drawSurface(sourceSurface, x, y, flipX, flipY, 0, clipInfo);
_vm->_res->freeResource(anim);
}
void WorldUIView::draw() {
if(isVisible()){
drawBg();
drawSurface();
drawObjects();
drawBorder();
drawParams();
UIView::draw();
}
}
void RenderSurfaceChromium::draw(const IntRect&)
{
if (m_skipsDraw || !m_contentsTexture)
return;
// FIXME: By using the same RenderSurface for both the content and its reflection,
// it's currently not possible to apply a separate mask to the reflection layer
// or correctly handle opacity in reflections (opacity must be applied after drawing
// both the layer and its reflection). The solution is to introduce yet another RenderSurface
// to draw the layer and its reflection in. For now we only apply a separate reflection
// mask if the contents don't have a mask of their own.
CCLayerImpl* replicaMaskLayer = m_maskLayer;
if (!m_maskLayer && m_owningLayer->replicaLayer())
replicaMaskLayer = m_owningLayer->replicaLayer()->maskLayer();
layerRenderer()->setScissorToRect(m_scissorRect);
// Reflection draws before the layer.
if (m_owningLayer->replicaLayer())
drawSurface(replicaMaskLayer, m_replicaDrawTransform);
drawSurface(m_maskLayer, m_drawTransform);
}
void PaintedWidget::paintEvent(QPaintEvent *event) {
sortSurface();
observe();
QPainter painter(this);
img.fill(Qt::white);
//double minZ=0; for(int i=0;i<8;i++)if(node[i][2]<minZ)minZ=node[i][2];
for(int k=0;k<6;k++) { //if(!ishide(minZ,surfaceId[k])) {
int i = surfaceId[k];
color=colors[i].lighter(int(fact(i)));
drawSurface(i,sNode,&painter);
}
painter.drawImage(0,0,img);
frame.push_back(QDateTime::currentMSecsSinceEpoch());
while(!frame.empty() && frame.back()-frame.front()>1000)frame.pop_front();
painter.drawText(100,100,QString::number(frame.size()));
}
void display()
{
// Set up material (surface) property
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 50.0 };
// Set up light
GLfloat light_ambient[] = { 0.0, 1.0, 0.0, 1.0 };
GLfloat light_diffuse[] = { 0.1, 1.0, 0.1, 1.0 };
GLfloat light_specular[] = { 0.4, 0.5, 0.8, 1.0 };
GLfloat light_position[] = { 50.0, 50.0, 50.0, 0.0 };
glEnable(GL_DEPTH_TEST);
glEnable(GL_COLOR_MATERIAL);
//if(!solid) /* dont cull face in wireframe mode */
// glDisable(GL_CULL_FACE);
//else
// glEnable(GL_CULL_FACE);
//glCullFace(GL_BACK);
glFrontFace(GL_CW); /* verticies are drawn clockwise */
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glPushMatrix();
glLoadIdentity();
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glPopMatrix();
drawSurface();
glFlush(); /* Flush all executed OpenGL ops finish */
/*
* Since we are using double buffers, we need to call the swap
* function every time we are done drawing.
*/
glutSwapBuffers();
}
void PaintedWidget::paintEvent(QPaintEvent *event) {
sortSurface();
observe();
QFont font;
font.setPointSize(64);
QPainter painter(this);
painter.setFont(font);
img.fill(Qt::white);
for(int k=3;k<6;k++) {
int i = surfaceId[k];
color=colors[i].lighter(int(fact(i)));
drawSurface(i,sNode,&painter);
}
painter.drawImage(0,0,img);
frame.push_back(QDateTime::currentMSecsSinceEpoch());
while(!frame.empty() && frame.back()-frame.front()>1000)frame.pop_front();
painter.drawText(100,100,"fps:"+QString::number(frame.size()));
}
void BaseRenderOSystem::repeatLastDraw(int offsetX, int offsetY, int numTimesX, int numTimesY) {
if (_previousTicket && _lastAddedTicket != _renderQueue.end()) {
RenderTicket *origTicket = _previousTicket;
// Make sure drawSurface WILL start from the correct _lastAddedTicket
if (!_tempDisableDirtyRects && !_disableDirtyRects && *_lastAddedTicket != origTicket) {
RenderQueueIterator it;
RenderQueueIterator endIterator = _renderQueue.end();
for (it = _renderQueue.begin(); it != endIterator; ++it) {
if ((*it) == _previousTicket) {
_lastAddedTicket = it;
break;
}
}
}
Common::Rect srcRect(0, 0, 0, 0);
srcRect.setWidth(origTicket->getSrcRect()->width());
srcRect.setHeight(origTicket->getSrcRect()->height());
Common::Rect dstRect = origTicket->_dstRect;
int initLeft = dstRect.left;
int initRight = dstRect.right;
TransformStruct temp = TransformStruct(kDefaultZoomX, kDefaultZoomY, kDefaultAngle, kDefaultHotspotX, kDefaultHotspotY, BLEND_NORMAL, kDefaultRgbaMod, false, false, kDefaultOffsetX, kDefaultOffsetY);
for (int i = 0; i < numTimesY; i++) {
if (i == 0) {
dstRect.translate(offsetX, 0);
}
for (int j = (i == 0 ? 1 : 0); j < numTimesX; j++) {
drawSurface(origTicket->_owner, origTicket->getSurface(), &srcRect, &dstRect, temp);
dstRect.translate(offsetX, 0);
}
dstRect.left = initLeft;
dstRect.right = initRight;
dstRect.translate(0, offsetY);
}
} else {
error("Repeat-draw failed (did you forget to draw something before this?)");
}
}
uint16 Screen::drawFlex(uint16 flexIndex, int16 x, int16 y, int16 flipX, int16 flipY, int16 mask, const ClipInfo &clipInfo) {
if (flexIndex == 0)
return 0;
PictureResource *flex = _vm->_res->getPicture(flexIndex);
Graphics::Surface *sourceSurface = flex->getPicture();
drawSurface(sourceSurface, x, y, flipX, flipY, mask, clipInfo);
// Palette is set in showPage
if (flex->hasPalette() && !_paletteLock && _needPalette) {
byte *flexPalette = flex->getPalette();
_oldPaletteColorCount = _paletteColorCount;
_paletteColorCount = flex->getPaletteColorCount();
memcpy(_newPalette, _palette, _oldPaletteColorCount * 3);
memcpy(_palette, flexPalette, _paletteColorCount * 3);
_needPalette = false;
}
_vm->_res->freeResource(flex);
return 0;
}
bool DX11ViewportRenderer::drawScene(const MRenderingInfo &renderInfo)
//
// Description:
// Draw the Maya scene, using a custom traverser.
//
{
bool useDrawTraversal = true;
float groundPlaneColor[3] = { 0.8f, 0.8f, 0.8f };
if (useDrawTraversal)
{
const MDagPath &cameraPath = renderInfo.cameraPath();
if (cameraPath.isValid())
{
// You can actually keep the traverser classes around
// if desired. Here we just create temporary traversers
// on the fly.
//
MDrawTraversal *trav = new MDrawTraversal;
if (!trav)
{
MGlobal::displayWarning("DX11 renderer : failed to create a traversal class !\n");
return true;
}
trav->enableFiltering( false );
const MRenderTarget &renderTarget = renderInfo.renderTarget();
trav->setFrustum( cameraPath, renderTarget.width(),
renderTarget.height() );
if (!trav->frustumValid())
{
MGlobal::displayWarning("DX11 renderer : Frustum is invalid !\n");
return true;
}
trav->traverse();
unsigned int numItems = trav->numberOfItems();
unsigned int i;
for (i=0; i<numItems; i++)
{
MDagPath path;
trav->itemPath(i, path);
if (path.isValid())
{
bool drawIt = false;
// Default traverer may have view manips showing up.
// This is currently a known Maya bug.
if ( path.hasFn( MFn::kViewManip ))
continue;
//
// Draw surfaces (polys, nurbs, subdivs)
//
bool active = false;
bool templated = false;
if ( path.hasFn( MFn::kMesh) ||
path.hasFn( MFn::kNurbsSurface) ||
path.hasFn( MFn::kSubdiv) )
{
drawIt = true;
if (trav->itemHasStatus( i, MDrawTraversal::kActiveItem ))
{
active = true;
}
if (trav->itemHasStatus( i, MDrawTraversal::kTemplateItem ))
{
templated = true;
}
}
//
// Draw the ground plane
//
else if (path.hasFn( MFn::kSketchPlane ) ||
path.hasFn( MFn::kGroundPlane ))
{
MMatrix matrix = path.inclusiveMatrix();
MFnDagNode dagNode(path);
MBoundingBox box = dagNode.boundingBox();
drawBounds( matrix, box, groundPlaneColor );
}
if (drawIt)
{
drawSurface( path, active, templated );
}
}
}
if (trav)
delete trav;
// Cleanup any unused resource items
bool onlyInvalidItems = true;
clearResources( onlyInvalidItems, false );
}
}
else
{
// Draw some poly bounding boxes
//
MItDag::TraversalType traversalType = MItDag::kDepthFirst;
MFn::Type filter = MFn::kMesh;
MStatus status;
MItDag dagIterator( traversalType, filter, &status);
for ( ; !dagIterator.isDone(); dagIterator.next() )
{
MDagPath dagPath;
status = dagIterator.getPath(dagPath);
if ( !status ) {
status.perror("MItDag::getPath");
continue;
}
MFnDagNode dagNode(dagPath, &status);
if ( !status ) {
status.perror("MFnDagNode constructor");
continue;
}
MMatrix matrix = dagPath.inclusiveMatrix();
MBoundingBox box = dagNode.boundingBox();
drawBounds( matrix, box, groundPlaneColor );
}
}
return true;
}
//----------------------------------------------------------
void GroundMetalSegment::drawGL()
{
Config *config = Config::instance();
static float c0_clr[4] = { 0.65, 0.62, 0.53, 1.0 };
static float c1_clr[4] = { 0.79, 0.82, 0.69, 1.0 };
static float r0_clr[4] = { 0.07, 0.07, 0.13, 1.0 };
static float r1_clr[4] = { 0.31, 0.30, 0.30, 1.0 };
static float r2_clr[4] = { 0.31, 0.30, 0.30, 1.0 };
float S;
float tmp;
float rep;
float tilt;
float clr_sin;
bool blipMirrorT = false;
age += 1.0;
clr_sin = 0.5*sin(parent->game->gameFrame*0.001);
r1_clr[0] = 0.15+clr_sin;
r2_clr[0] = 0.15+clr_sin;
clr_sin = 0.2*sin(parent->game->gameFrame*0.0005);
c0_clr[0] = 0.28+clr_sin;
c0_clr[1] = 0.25+clr_sin;
c0_clr[2] = 0.16+clr_sin;
c1_clr[0] = 0.42+clr_sin;
c1_clr[1] = 0.45+clr_sin;
c1_clr[2] = 0.34+clr_sin;
switch(parent->variation)
{
default:
case 0:
rep = 0.26;
tilt = 0.1;
S = -parent->game->frame*0.001;
blipMirrorT = false;
break;
case 1:
rep = 0.4;
tilt = 0.2;
S = -parent->game->frame*0.001;
blipMirrorT = true;
break;
case 2:
S = -parent->game->frame*0.005;
tmp = sin(S);
rep = 0.7+tmp;
tilt = 0.5+tmp;
blipMirrorT = true;
break;
}
#ifdef EXPERIMENTAL
drawMultiTex(rep, S, tilt, blipMirrorT,
c0_clr,
c1_clr,
r0_clr,
r1_clr,
r2_clr);
#else // EXPERIMENTAL
if(config->gfxLevel() > 1)
{
drawBlip(rep, S, tilt, blipMirrorT);
}
if(true)
{
drawSurface(c0_clr,
c1_clr,
r0_clr,
r1_clr,
r2_clr);
}
#endif // EXPERIMENTAL
}
void IntroCloud::draw(SDL_Surface *screen){
if( cloudImage != NULL ){
drawSurface( cloudImage, screen, x, y);
}
}
void GameSurface::draw(int x, int y, int width, int height) {
bufferToSurface();
drawSurface(x, y, width, height);
}
