//Alterar
int Fill(object * ob, window * win, bufferdevice * dev, int color) {
bufferdevice * temp = CreateBuffer(dev->MaxX,dev->MaxY);
DrawObject(ob,win,temp);
FillObject(temp,color);
CopyBuffer2Device(temp,dev);
return 0;
}
void DrawIMGHDR_2(IMGHDR *img, int x, int y, int x2, int y2, int bleed_x, int bleed_y)
{
RECT rc;
DRWOBJ drwobj;
StoreXYXYtoRECT(&rc, x, y, x2, y2);
SetProp2ImageOrCanvas(&drwobj, &rc, 0, img, bleed_x, bleed_y);
SetColor(&drwobj, NULL, NULL);
DrawObject(&drwobj);
}
void DrawIMGHDR(IMGHDR *img, int x, int y, int w, int h)
{
RECT rc;
DRWOBJ drwobj;
StoreXYWHtoRECT(&rc, x, y, w, h);
SetPropTo_Obj5(&drwobj, &rc, 0, img);
SetColor(&drwobj, NULL, NULL);
DrawObject(&drwobj);
}
void RenderFrameDX9(void)
{
LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
device->BeginScene();
AddImpulse();
WaterSimulation();
HeightmapToNormal();
device->SetRenderTarget(0, g_pMainFramebuffer);
device->SetDepthStencilSurface(g_pMainDepthbuffer);
device->Clear(0, NULL, D3DCLEAR_ZBUFFER, 0x0, 1.0f, 0);
RenderWater();
DrawObject();
SwapHeightmaps();
float x = -1.0f;
float y = -1.0f;
float w = 0.4f;
float h = 0.4f;
if ( g_iMode & 0x01 )
{
DrawImage(g_pTextures[TEX_HEIGHT2], x, y, w, h, &g_ImageInfo);
x+=w;
}
if ( g_iMode & 0x02 )
{
D3DXHANDLE shader = g_pWaterEffect->GetTechniqueByName("Heightmap");
D3DXHANDLE heightmap_var = g_pWaterEffect->GetTechniqueByName("heightmap_current");
g_pWaterEffect->SetTechnique(shader);
g_pWaterEffect->SetTexture(heightmap_var, g_pTextures[TEX_HEIGHT2]);
g_pWaterEffect->Begin(NULL, 0);
g_pWaterEffect->BeginPass(0);
GutDrawScreenQuad_DX9(x, y, w, h, &g_ImageInfo);
g_pWaterEffect->EndPass();
g_pWaterEffect->End();
x+=w;
}
if ( g_iMode & 0x04 )
{
DrawImage(g_pTextures[TEX_NORMAL], x, y, w, h, &g_ImageInfo);
x+=w;
}
device->EndScene();
device->Present( NULL, NULL, NULL, NULL );
}
/*=========================================================================================
Name : LRFShow
Argument : IplImage* img : 表示に使うIplImage構造体
char* window_name : ウィンドウ名
long* lrf_data : LRF取得データ関数でコピーして使う
(オリジナルはそのまま)
int lrf_data_max : LRF取得データ数
int window_x : ウィンドウ表示位置x座標
int window_y : ウィンドウ表示位置y座標
Return : no return
About : LRFより取得したデータをOpenCVを用いて表示する
Author : Ryodo Tanaka
=========================================================================================*/
int LRFShow(const int id, const long lrf_data_max, const long *lrf_data, const long max_dist, const char* lrf_window_name)
{
cvZero(img[id]);
DrawObject(img[id], lrf_data_max, lrf_data, max_dist);
DrawFundamental(img[id]);
cvShowImage(lrf_window_name,img[id]);
return cvWaitKey(1);
}
void ProgressBar::drawInternal(Graphics* const Graphics, Real32 Opacity) const
{
//Draw The ProgressBar
UIDrawObjectCanvasRefPtr DrawObject(getDrawnDrawObject());
if(DrawObject != NULL)
{
if(DrawObject->getPosition() != _ProgressBarPosition)
{
DrawObject->setPosition(_ProgressBarPosition);
}
if(DrawObject->getSize() != _ProgressBarSize)
{
DrawObject->setSize(_ProgressBarSize);
}
DrawObject->draw(Graphics,getOpacity()*Opacity);
}
//Draw The Progress String
if(getEnableProgressString() && getFont() != NULL)
{
Pnt2f TopLeft, BottomRight;
getInsideBorderBounds(TopLeft, BottomRight);
//Draw the progress String
std::string StringToDraw;
if(getProgressString().compare("") == 0)
{
if(!getIndeterminate())
{
UInt32 Percent(static_cast<Int32>( osgFloor(getPercentComplete() * 100.0f) ));
std::stringstream TempSStream;
TempSStream << Percent;
StringToDraw = TempSStream.str() + std::string("%");
}
}
else
{
StringToDraw = getProgressString();
}
//Calculate Alignment
Pnt2f AlignedPosition;
Pnt2f TextTopLeft, TextBottomRight;
getFont()->getBounds(StringToDraw, TextTopLeft, TextBottomRight);
AlignedPosition = calculateAlignment(TopLeft, (BottomRight-TopLeft), (TextBottomRight - TextTopLeft),getAlignment().y(), getAlignment().x());
//Draw the Text
Graphics->drawText(AlignedPosition, StringToDraw, getFont(), getDrawnTextColor(), getOpacity()*Opacity);
}
}
static void
toggle_pin_selected (LibraryEntryType *entry)
{
ConnectionType conn;
if (!SeekPad (entry, &conn, false))
return;
AddObjectToFlagUndoList (conn.type, conn.ptr1, conn.ptr2, conn.ptr2);
TOGGLE_FLAG (SELECTEDFLAG, (AnyObjectType *)conn.ptr2);
DrawObject (conn.type, conn.ptr1, conn.ptr2);
}
int DrawGLScene(GLvoid) // Here's Where We Do All The Drawing|绘制过程：后台
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer|设置颜色为InitGL()中设置的背景色
glLoadIdentity(); // Reset The View|重置模型观察矩阵
if(RZ - (-15.0f) > 1e-1) // 加入一个入场动画
{
RZ -= 0.05f;
}
else
{
if(RX - (-5.5f) > 1e-1)
{
RX -= 0.01f;
}
if(3.2f - RY > 1e-1)
{
RY += 0.01f;
}
}
glTranslatef(0.0f,0.0f,RZ); // 移入屏幕深处15 单位
glTranslatef(RX,0.0f,0.0f); // 依据目前的全局X坐标重置Cube位置
glTranslatef(0.0,RY,0.0); // 依据目前的全局Y坐标重置Cube位置
glRotatef(xrot,1.0f,0.0f,0.0f); // 绕方向向量(1.0f, 0.0f, 0.0f)即X轴旋转xrot度
glRotatef(yrot,0.0f,1.0f,0.0f);
glRotatef(zrot,0.0f,0.0f,1.0f);
//glColor3f(1.0f, 1.0f, 1.0f); // 把当前颜色设为白色，否则颜色也与文字一起变化
// 每次锁定一个2D纹理并对一个Cube进行贴图
srand(0);
for(int i = 0; i < M3; i++)
{
int r = rand() % CTexture; // 纹理数量与待贴图四边形数量不一致，随机贴图
glBindTexture(GL_TEXTURE_2D, texture[r]);
DrawObject(i);
}
//设置每次沿3个轴转过的角度（整体旋转程序自动控制，全局坐标手动控制）
xrot += 0.05f;
yrot += 0.05f;
zrot += 0.05f;
glColor3f(0.85f-0.15f*float(cos(cnt1)),0.45f-0.05f*float(sin(cnt2)),0.85f-0.15f*float(cos(cnt1+cnt2)));
// Position The Text On The Screen
glRasterPos2f(0.5f+0.05f*float(cos(cnt1)), -0.7f+0.32f*float(sin(cnt2)));
glPrint(" Enjoy your online lifestyle - %7.2f", cnt1);
cnt1 += 0.051f; // Increase The First Counter
cnt2 += 0.005f; // Increase The First Counter
return TRUE; // Keep Going
}
static void scr_Display( void )
{
glClear( GL_COLOR_BUFFER_BIT );
glPushMatrix();
glRotatef(Xrot, 1.0, 0.0, 0.0);
glRotatef(Yrot, 0.0, 1.0, 0.0);
glRotatef(Zrot, 0.0, 0.0, 1.0);
DrawObject();
glPopMatrix();
}
void ShadowVolume::ProcessModel(const PolygonalModel& model, const MatrixHomogeneous& mTotal, const std::vector<Normals::PolygonNormalData>& normals, bool clip, const ClippingPlane& cp, const PolygonAdjacencyGraph& polygonAdj)
{
std::pair<PolygonalObject, std::vector<Normals::PolygonNormalData>> shadowObj = GenerateShadowVolume(model, normals, polygonAdj);
shadowObj.first = mTotal * shadowObj.first;
for (auto i = shadowObj.second.begin(); i != shadowObj.second.end(); ++i)
*i = mTotal * *i;
_shadowSurfaces.push_back(shadowObj.first.polygons);
_shadowSurfaceNormals.push_back(shadowObj.second);
for (auto p = shadowObj.first.polygons.begin(); p != shadowObj.first.polygons.end(); ++p)
{
p->color = _currPolyId;
p->colorValid = true;
++_currPolyId;
}
ModelAttr attr2;
attr2.removeBackFace = BACKFACE_REMOVE_BACK;
attr2.Shading = SHADING_NONE;
attr2.forceColor = true;
attr2.color = _currModelId++;
DrawingObject img;
img.shadowVolume = this;
img.active = DrawingObject::DRAWING_OBJECT_SV;
_currShadowMode = ShadowExit;
DrawObject(img, shadowObj.first, mTotal, attr2, shadowObj.second, 0, true, clip, cp);
_currShadowMode = ShadowEnter;
size_t normalsOffset = 0;
for (auto obj = model.begin(); obj != model.end(); ++obj)
{
DrawObject(img, *obj, mTotal, attr2, normals, normalsOffset, true, clip, cp);
normalsOffset += obj->polygons.size();
}
attr2.removeBackFace = BACKFACE_REMOVE_FRONT;
_currShadowMode = ShadowEnter;
DrawObject(img, shadowObj.first, mTotal, attr2, shadowObj.second, 0, true, clip, cp);
}
void CPaintDlg::DrawRobots()
{
Invalidate();
AfxGetApp()->PumpMessage();
OnPaint();
if (cameraLock > -1)
{
upperleftCellCoords[0] = robots[cameraLock]->x-fieldSide/2;
upperleftCellCoords[1] = robots[cameraLock]->y-fieldSide/2;
if (upperleftCellCoords[0]<0)
upperleftCellCoords[0]+=FieldParameters.fieldWidth;
if (upperleftCellCoords[0]>=FieldParameters.fieldWidth)
upperleftCellCoords[0]-=FieldParameters.fieldWidth;
if (upperleftCellCoords[1]<0)
upperleftCellCoords[1]+=FieldParameters.fieldHeight;
if (upperleftCellCoords[1]>=FieldParameters.fieldHeight)
upperleftCellCoords[1]-=FieldParameters.fieldHeight;
}
int xlocal = 0;
int ylocal = 0;
int xreal, yreal;
for (int x = upperleftCellCoords[0]; x < upperleftCellCoords[0]+n; x++)
{
xreal = x;
if (xreal<0)
xreal+=FieldParameters.fieldWidth;
if (xreal>=FieldParameters.fieldWidth)
xreal-=FieldParameters.fieldWidth;
for (int y = upperleftCellCoords[1]; y < upperleftCellCoords[1]+n; y++)
{
yreal = y;
if (yreal<0)
yreal+=FieldParameters.fieldHeight;
if (yreal>=FieldParameters.fieldHeight)
yreal-=FieldParameters.fieldHeight;
if (matrix[xreal][yreal] > -1)
DrawRobot(xlocal,ylocal,robots[matrix[xreal][yreal]]->color);
else if (matrix[xreal][yreal] == SEVERAL)
DrawRobot(xlocal,ylocal,Black);
else if (matrix[xreal][yreal] == OBJ_DEAD)
DrawRobot(xlocal,ylocal,White);
else if (matrix[xreal][yreal] < -1)
DrawObject(xlocal,ylocal,matrix[xreal][yreal]);
ylocal++;
}
xlocal++;
ylocal = 0;
}
}
void ZObjectManager::Draw()
{
m_nRenderedCnt = 0;
m_nOnDrawCnt = 0;
ZObject* pMyCharacter = (ZObject*)g_pGame->m_pMyCharacter;
for (iterator itor = begin(); itor != end(); ++itor)
{
ZObject* pObject = (*itor).second;
if (pObject == NULL) continue;
if (pObject == pMyCharacter) continue;
DrawObject(pObject);
}
if( pMyCharacter )
{
RVisualMesh* pVMesh = pMyCharacter->GetVisualMesh();
if(pVMesh) {
if(pVMesh->GetVisibility() != 1.f) {
pVMesh->SetSpRenderMode(1);
DrawObject( pMyCharacter );
pVMesh->SetSpRenderMode(2);
}
pMyCharacter->m_bRendered = DrawObject( pMyCharacter );
pVMesh->SetSpRenderMode(0);
}
}
}
//-------------------------------- Render -------------------------------------
// 렌더함수
//-----------------------------------------------------------------------------
void Snake_Game::Render()
{
//UI를 그린다.
this->DrawUI();
//뱀의 흔적을 받아온다.
Snake::SNAKE_TRACE dummy = snake_->GetTrace();
//흔적대로 뱀을 그린다.
for(Snake::SNAKE_TRACE::iterator it = dummy.begin(); it != dummy.end(); it++)
{
DrawObject((*it),'#');
}
//맨뒤는 ' '로 지워준다.
//이작업을 안한다면 흔적에는 없으나 화면에는 계속 뱀의 흔적이 보인다.
//만약 전체 화면을 지우고 다시 그리는 작업을 하면
//화면이 깜빡이는 현상이 일어난다.
DrawObject(dummy.back(),' ');
//현재위치에는 뱀의 머리를 그려준다.
DrawObject(snake_->GetPosition(),'S');
}
static void Display( void )
{
glClear( GL_COLOR_BUFFER_BIT );
glPushMatrix();
glRotatef(Xrot, 1.0, 0.0, 0.0);
glRotatef(Yrot, 0.0, 1.0, 0.0);
glRotatef(Zrot, 0.0, 0.0, 1.0);
glScalef(5.0, 5.0, 5.0);
DrawObject();
glPopMatrix();
glutSwapBuffers();
}
static void Display( void )
{
glClear( GL_COLOR_BUFFER_BIT );
glPushMatrix();
glTranslatef( -1.1, 0.0, -15.0 );
glRotatef(Xrot, 1.0, 0.0, 0.0);
glRotatef(Yrot, 0.0, 1.0, 0.0);
glRotatef(Zrot, 0.0, 0.0, 1.0);
glBindTexture(GL_TEXTURE_2D, yuvObj);
DrawObject();
glPopMatrix();
glPushMatrix();
glTranslatef( 1.1, 0.0, -15.0 );
glRotatef(Xrot, 1.0, 0.0, 0.0);
glRotatef(Yrot, 0.0, 1.0, 0.0);
glRotatef(Zrot, 0.0, 0.0, 1.0);
glBindTexture(GL_TEXTURE_2D, rgbObj);
DrawObject();
glPopMatrix();
glutSwapBuffers();
}
void Draw ( ESContext *esContext )
{
glViewport(0, 0, 1024, 1024);
glBindFramebuffer(GL_FRAMEBUFFER, fboId);
glClearColor ( 0.0f, 0.0f, 1.0f, 0.0f );
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
//draw terrain and sphere to FBO to make shadow map
//...
//draw scene's objects
DrawObject(objectList[0], mainCamera); //ligh buld
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0, 0, 1024, 1024);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
DrawObject(objectList[1], mainCamera); //terrain
DrawObject(objectList[2], mainCamera); //sphere
eglSwapBuffers ( esContext->eglDisplay, esContext->eglSurface );
}
//Draws the player to the screen
void DrawTortoise(SDL_Surface *screen)
{
DrawObject(screen, &player);
Uint32 color = SDL_MapRGB(screen->format, 255,255,255);
int left = player.location.x * TILE_WIDTH;
int right = left + 31;
int top = (14 - player.location.y) * TILE_HEIGHT;
int bottom = top + 31;
DrawPixel(screen, left, top, color);
DrawPixel(screen, left, bottom, color);
DrawPixel(screen, right, top, color);
DrawPixel(screen, right, bottom, color);
}
unsigned int Render_3DObject(unsigned int objnum)
{
char * iffed_label=0;
if ( objects[objnum].has_label!= 0 ) { iffed_label = objects[objnum].label; }
DrawObject(
objects[objnum].position.x,
objects[objnum].position.y,
objects[objnum].position.z,
objects[objnum].roll,
objects[objnum].width,
objects[objnum].height,
objects[objnum].hardcoded_shape,
iffed_label
);
return 1;
}
//--------------------------------------------------------------------------------------
// Name: DrawScene()
// Desc:
//--------------------------------------------------------------------------------------
VOID CSample42::DrawScene()
{
m_SharpRT.SetFramebuffer();
glClearColor( 0.04f, 0.04f, 0.04f, 1.0f );
glClearDepthf( 1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable( GL_CULL_FACE );
glCullFace( GL_BACK );
glEnable( GL_DEPTH_TEST );
glDisable( GL_BLEND );
glFrontFace( GL_CW );
DrawObject( &m_Object );
m_SharpRT.DetachFramebuffer();
}
void MainLoop(void)
{
ARUint8 *image;
ARMarkerInfo *marker_info;
int marker_num;
int j, k;
if ((image = (ARUint8 *)arVideoGetImage()) == NULL) {
arUtilSleep(2);
return;
}
argDrawMode2D();
argDispImage(image, 0, 0);
if (arDetectMarker(image, thresh, &marker_info, &marker_num) < 0) {
Cleanup();
exit(0);
}
arVideoCapNext();
k = -1;
for (j = 0; j < marker_num; j++) {
if (patt_id == marker_info[j].id) {
if (k == -1) k = j;
else if (marker_info[k].cf < marker_info[j].cf) k = j;
}
}
if (k != -1) {
arGetTransMat(&marker_info[k], patt_center, patt_width, patt_trans);
DrawObject();
}
argSwapBuffers();
}
void
RoomContainer::_DrawActors()
{
std::list<Reference<Object> >::const_iterator a;
std::list<Reference<Object> > actorsList;
Core::Get()->GetObjectList(actorsList);
for (a = actorsList.begin();
a != actorsList.end(); a++) {
if (Actor* actor = dynamic_cast<Actor*>(a->Target())) {
try {
DrawObject(*actor);
} catch (const char* string) {
//std::cerr << "_DrawActors: exception: " << string << std::endl;
continue;
} catch (...) {
std::cerr << "Caught exception on actor " << actor->Name() << std::endl;
continue;
}
}
}
}
bool SSvgWnd::OnPaint(SBaseDC *pDC)
{
// pDC->TextOutA(10,10,"My QT SVG!");
SSvgObject *pFirstObj = m_Document.GetRootObject();
if(pFirstObj != NULL)
pFirstObj = pFirstObj->GetChild();
// if(pFirstObj != NULL)
// pFirstObj = pFirstObj->GetNext();
if( pFirstObj != NULL)
{
YSRECT r = GetClientRect();
m_ViewRect.left =GetSvgCoord((double)-m_iOffsetX);
m_ViewRect.top = GetSvgCoord((double)-m_iOffsetY );
m_ViewRect.right = m_ViewRect.left + GetSvgCoord((double)(r.right-r.left/*-m_iOffsetX*/));
m_ViewRect.bottom = m_ViewRect.top + GetSvgCoord((double)(r.bottom-r.top/*-m_iOffsetY*/));
pDC->FillRect(0,0,r.right-r.left,r.bottom-r.top,
GetColorByString(pFirstObj->GetAttribute("fill")));
DrawObject(pDC,pFirstObj,m_iOffsetX,m_iOffsetY);
}
return true;
}
void
RoomContainer::_DrawAnimations(bool advanceFrame)
{
if (fAnimations.size() == 0)
return;
std::vector<Animation*>::const_iterator i;
for (i = fAnimations.begin(); i != fAnimations.end(); i++) {
try {
Animation* animation = *i;
if (animation->IsShown()) {
if (advanceFrame)
animation->Next();
const Bitmap* frame = animation->Bitmap();
DrawObject(frame, animation->Position(), false);
}
} catch (const char* string) {
std::cerr << string << std::endl;
continue;
} catch (...) {
continue;
}
}
}
void AI::GlutDisplay()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(1, 1, 1);
for (std::vector<GameObject *>::iterator it = m_goList.begin(); it != m_goList.end(); ++it)
{
GameObject *go = (GameObject *)*it;
if (go->active)
{
DrawObject(go);
}
}
//glColor3f(1.0, 1.0, 1.0);
char temp[64];
sprintf_s(temp, "Police Position: %.2f %.2f %.2f", m_goList.at(0)->pos.x, m_goList.at(0)->pos.y, m_goList.at(0)->pos.z);
//Testing for position
RenderStringOnScreen(0, 94, temp);
//sprintf_s(temp, "Alarm : %.1b", Alarm);
RenderStringOnScreen(0, 90, BooltoString(Alarm));
//sprintf_s(temp, "Mass: %.1f", m_ship->mass);
//RenderStringOnScreen(0, 86, temp);
////Exercise 4: Render m_lives and m_score
//sprintf_s(temp, "Lives: %d", m_lives);
//RenderStringOnScreen(100, 94, temp);
//sprintf_s(temp, "Score: %d", m_score);
//RenderStringOnScreen(100, 90, temp);
glutSwapBuffers();
glutPostRedisplay();
}
//------------------------------- InitGame ------------------------------------
// 게임을 초기화한다.
//-----------------------------------------------------------------------------
bool Snake_Game::InitGame()
{
SetCursorType(NOCURSOR);
this->LoadGame();
srand(time(NULL));
//남은 아이템만큼 아이템을 그려준다.
for (int i=item_num_; i<goal_item_num_; i++)
{
while(true)
{
Position dummy(rand()%kMaxItemPosWidth,rand()%kMaxItemPosHeigh);
if(Getchon(dummy) == ' ')
{
DrawObject(dummy,rand()%9+1);
break;
}
}
}
return true;
}
//--------------------------------------------------------------------------------------
// Name: Render()
// Desc:
//--------------------------------------------------------------------------------------
VOID CSample22::Render()
{
glViewport( 0, 0, m_nWidth, m_nHeight );
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
glClearColor( 0.04f, 0.04f, 0.04f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable( GL_CULL_FACE );
glCullFace( GL_BACK );
glEnable( GL_DEPTH_TEST );
DrawObject( &m_Object );
// Update the timer
m_Timer.MarkFrame();
// Render the user interface
m_UserInterface.Render( m_Timer.GetFrameRate() );
// Put the state back
glDisable( GL_CULL_FACE );
glDisable( GL_DEPTH_TEST );
}
/*
* InventoryDrawSingleItem: Draw given inventory item, at given row and col
* in relative coordinates.
*/
void InventoryDrawSingleItem(InvItem *item, int row, int col)
{
HDC hdc;
AREA area, obj_area;
char temp[MAXAMOUNT + 1];
Bool draw_cursor;
area.x = col * INVENTORY_BOX_WIDTH;
area.y = row * INVENTORY_BOX_HEIGHT;
area.cx = INVENTORY_BOX_WIDTH;
area.cy = INVENTORY_BOX_HEIGHT;
obj_area.x = area.x + INVENTORY_OBJECT_BORDER;
obj_area.y = area.y + INVENTORY_OBJECT_BORDER;
obj_area.cx = INVENTORY_OBJECT_WIDTH - 1;
obj_area.cy = INVENTORY_OBJECT_HEIGHT - 1;
hdc = GetDC(hwndInv);
// See if we should draw cursor here
draw_cursor = (GetFocus() == hwndInv && row == cursor_row - top_row && col == cursor_col);
if (draw_cursor)
OffscreenBitBlt(hdc, 0, 0, INVENTORY_BOX_WIDTH, INVENTORY_BOX_HEIGHT,
cursor_bits, 0, 0, INVENTORY_BOX_WIDTH, OBB_FLIP);
else OffscreenWindowBackground(&inventory_bkgnd,
inventory_area.x + area.x, inventory_area.y + area.y,
INVENTORY_BOX_WIDTH, INVENTORY_BOX_HEIGHT);
if (item->is_using)
OffscreenBitBlt(hdc, INVENTORY_OBJECT_BORDER, INVENTORY_OBJECT_BORDER,
INVENTORY_OBJECT_WIDTH, INVENTORY_OBJECT_HEIGHT,
inuse_bits, 0, 0, INVENTORY_OBJECT_WIDTH, OBB_FLIP | OBB_TRANSPARENT);
DrawObject(hdc, item->obj, item->obj->animate->group, True, &obj_area, NULL,
INVENTORY_OBJECT_BORDER, INVENTORY_OBJECT_BORDER, 0, False);
OffscreenCopy(hdc, area.x, area.y, INVENTORY_BOX_WIDTH, INVENTORY_BOX_HEIGHT, 0, 0);
// Draw numbers for number items
if (IsNumberObj(item->obj->id) && cinfo->config->inventory_num)
{
sprintf(temp, "%d", item->obj->amount);
SetBkMode(hdc, TRANSPARENT);
SelectObject(hdc, GetFont(FONT_STATNUM));
SetTextColor(hdc, GetColor(COLOR_INVNUMBGD));
TextOut(hdc, obj_area.x + 1, obj_area.y + 1, temp, strlen(temp));
SetTextColor(hdc, GetColor(COLOR_INVNUMFGD));
TextOut(hdc, obj_area.x, obj_area.y, temp, strlen(temp));
}
// Draw border around area to clear previous cursor (if any)
if (!draw_cursor)
{
DrawWindowBackgroundBorder(&inventory_bkgnd, hdc, &obj_area, INVENTORY_OBJECT_BORDER,
inventory_area.x + obj_area.x, inventory_area.y + obj_area.y, -1, NULL);
}
ReleaseDC(hwndInv, hdc);
}
void CImageView::ShowImage(QString &strPathName)
{
const CString &Path = strPathName;
Jpeg jpeg;
ZeroMemory(&jpeg, sizeof(jpeg));
if (!m_JpegCodec.GetJpegInformation((LPCTSTR) Path, &jpeg)) return;
if (m_dwBufferLength < jpeg.dwLength) {
if (m_pBuffer) _aligned_free(m_pBuffer);
m_pBuffer = (BYTE *) _aligned_malloc(jpeg.dwLength, 16);
m_dwBufferLength = jpeg.dwLength;
}
jpeg.pBuffer = (BYTE *) m_pBuffer;
if (!m_JpegCodec.Decode((LPCTSTR) Path, &jpeg)) {
return;
}
int width = (jpeg.bm.biWidth<= 360)?(2*jpeg.bm.biWidth):(jpeg.bm.biWidth);
int height = (jpeg.bm.biHeight<= 288)?(2*jpeg.bm.biHeight):(jpeg.bm.biHeight);
DWORD dwEngId = _ttoi(m_strEngId.GetBuffer());
CRect rcVCAROI;
VCA5_RECT rcROIEng = CAPPConfigure::Instance()->GetAPPEngineInfo( dwEngId )->tSourceData.rcROI;
rcVCAROI.left = rcROIEng.x;
rcVCAROI.top = rcROIEng.y;
rcVCAROI.right = rcROIEng.x + rcROIEng.w;
rcVCAROI.bottom = rcROIEng.y + rcROIEng.h;
if( rcVCAROI.Size() == CSize(0, 0) ) {
rcVCAROI.CopyRect(&m_ClientRect);
} else {
rcVCAROI.right = min(rcVCAROI.right-1, width);
rcVCAROI.bottom = min(rcVCAROI.bottom-1, height);
PIXELTOPERCENT(rcVCAROI.left, rcVCAROI.left, width);
PIXELTOPERCENT(rcVCAROI.top, rcVCAROI.top, height);
PIXELTOPERCENT(rcVCAROI.right, rcVCAROI.right, width);
PIXELTOPERCENT(rcVCAROI.bottom, rcVCAROI.bottom, height);
PERCENTTOPIXEL(rcVCAROI.left, rcVCAROI.left, m_ClientRect.right);
PERCENTTOPIXEL(rcVCAROI.top, rcVCAROI.top, m_ClientRect.bottom);
PERCENTTOPIXEL(rcVCAROI.right, rcVCAROI.right, m_ClientRect.right);
PERCENTTOPIXEL(rcVCAROI.bottom, rcVCAROI.bottom, m_ClientRect.bottom);
}
m_ClientRect.left = 0;
m_ClientRect.top = 0;
m_ClientRect.right = width;
m_ClientRect.bottom = height;
AdjustDlgRect(width, height);
RelocateControls(width, height);
DrawImage(jpeg.bm.biWidth, jpeg.bm.biHeight, jpeg.pImage, jpeg.bm);
DrawSingleZone(rcVCAROI, jpeg.pZone);
DrawObject(rcVCAROI, jpeg.bm.biWidth, jpeg.bm.biHeight, jpeg.pObject);
if(jpeg.pRule) DrawTimeStampAndRuleType(jpeg.bm.biWidth, jpeg.bm.biHeight, jpeg.i64TimeStamp, jpeg.pRule->usRuleType);
RECT ScreenRect;
ScreenRect = m_ClientRect;
ClientToScreen((POINT*)&ScreenRect.left );
ClientToScreen((POINT*)&ScreenRect.right );
m_pD3d->PrimaryPresentation(&ScreenRect, &m_ClientRect);
}
void FormView::Paint(Draw& w)
{
if (!IsLayout())
{
w.DrawRect(GetRect(), White());
return;
}
Rect r = Zoom(GetPageRect());
DrawGrid(w);
DrawRect(w, r, 1, LtBlue());
w.DrawRect(0, 0, r.left, 3000, White());
w.DrawRect(r.right + 1, 0, 3000, 3000, White());
w.DrawRect(r.left, 0, 5000, r.top, White());
w.DrawRect(r.left, r.bottom + 1, 3000, 3000, White());
// if (_showInfo)
// {
// r.SetSize( Zoom(Size(804, 604)) );
// DrawRect(w, r.Offseted( Zoom(Size(-2, -2)) ), 1, LtMagenta());
// r = Zoom(GetPageRect());
// }
if (GetObjectCount() > 0 && _showInfo == 2)
{
Rect b = Zoom(GetObjectsRect()).Offseted(1, 1);
b.SetSize( b.GetSize() + Size(-2, -2) );
DrawRect(w, b, 1, Yellow());
}
Vector<int> sel = GetSelected();
bool coloring = GetBool("View.Coloring");
int ci = 0;
if (sel.GetCount() > 0)
{
if (sel.GetCount() == 1)
{
for (int i = 0; i < GetObjectCount(); ++i)
{
if (ci++ == _colors.GetCount() - 1) ci = 0;
if (coloring && i != sel[0])
DrawObject(w, i, _colors[ci], false);
else
DrawObject(w, i, (!coloring && (i == sel[0])) ? _colors[ci] : LtGray(),
i == sel[0]);
}
}
else
{
for (int i = 0; i < GetObjectCount(); ++i)
{
if (ci++ == _colors.GetCount() - 1) ci = 0;
bool found = false;
for (int j = 0; j < sel.GetCount(); ++j)
if ( i == sel[j])
{
found = true;
break;
}
if (coloring && !found)
DrawObject(w, i, _colors[ci], false);
else
DrawObject(w, i, (!coloring && found) ? _colors[ci] : LtGray(), false);
}
Size g = GetGridSize();
Rect s = GetSelectionRect().Offseted(-g.cx / 2, -g.cy / 2);
s.SetSize(s.GetSize() + Size(g.cx, g.cy));
Vector<int> sel = GetSelected();
bool a1 = true; // allow horz align
bool a2 = true; // allow vert align
dword f1; // first horz align
dword f2; // first vert align
for (int i = 0; i < sel.GetCount(); ++i)
{
FormObject *pI = GetObject(sel[i]);
if (!pI) continue;
if (i == 0) { f1 = pI->GetHAlign(); f2 = pI->GetVAlign(); }
if (f1 != pI->GetHAlign()) { a1 = false; }
if (f2 != pI->GetVAlign()) { a2 = false; }
}
DrawSprings(w, Zoom(s), f1, f2, a1, a2, a1, a2, false);
DrawRect(w, Zoom(s), 1, LtRed());
s = GetSelectionRect().Offseted(-g.cx, -g.cy);
s.SetSize(s.GetSize() + Size(g.cx * 2, g.cy * 2));
DrawGroupTools(w, Zoom(s));
}
return;
}
for (int i = 0; i < GetObjectCount(); ++i)
{
if (ci++ == _colors.GetCount() - 1) ci = 0;
DrawObject(w, i, coloring ? _colors[ci] : LtGray());
}
if (sel.GetCount() == 0)
w.DrawImage(r.right, r.bottom, FormViewImg::SizerBR());
}
void Scene::Draw( glutil::MatrixStack &modelMatrix, int materialBlockIndex, float alphaTetra )
{
//Render the ground plane.
{
glutil::PushStack push(modelMatrix);
modelMatrix.RotateX(-90);
DrawObject(m_pTerrainMesh.get(), GetProgram(LP_VERT_COLOR_DIFFUSE), materialBlockIndex, 0,
modelMatrix);
}
//Render the tetrahedron object.
{
glutil::PushStack push(modelMatrix);
modelMatrix.Translate(75.0f, 5.0f, 75.0f);
modelMatrix.RotateY(360.0f * alphaTetra);
modelMatrix.Scale(10.0f, 10.0f, 10.0f);
modelMatrix.Translate(0.0f, sqrtf(2.0f), 0.0f);
modelMatrix.Rotate(glm::vec3(-0.707f, 0.0f, -0.707f), 54.735f);
DrawObject(m_pTetraMesh.get(), "lit-color", GetProgram(LP_VERT_COLOR_DIFFUSE_SPECULAR),
materialBlockIndex, 1, modelMatrix);
}
//Render the monolith object.
{
glutil::PushStack push(modelMatrix);
modelMatrix.Translate(88.0f, 5.0f, -80.0f);
modelMatrix.Scale(4.0f, 4.0f, 4.0f);
modelMatrix.Scale(4.0f, 9.0f, 1.0f);
modelMatrix.Translate(0.0f, 0.5f, 0.0f);
DrawObject(m_pCubeMesh.get(), "lit", GetProgram(LP_MTL_COLOR_DIFFUSE_SPECULAR),
materialBlockIndex, 2, modelMatrix);
}
//Render the cube object.
{
glutil::PushStack push(modelMatrix);
modelMatrix.Translate(-52.5f, 14.0f, 65.0f);
modelMatrix.RotateZ(50.0f);
modelMatrix.RotateY(-10.0f);
modelMatrix.Scale(20.0f, 20.0f, 20.0f);
DrawObject(m_pCubeMesh.get(), "lit-color", GetProgram(LP_VERT_COLOR_DIFFUSE_SPECULAR),
materialBlockIndex, 3, modelMatrix);
}
//Render the cylinder.
{
glutil::PushStack push(modelMatrix);
modelMatrix.Translate(-7.0f, 30.0f, -14.0f);
modelMatrix.Scale(15.0f, 55.0f, 15.0f);
modelMatrix.Translate(0.0f, 0.5f, 0.0f);
DrawObject(m_pCylMesh.get(), "lit-color", GetProgram(LP_VERT_COLOR_DIFFUSE_SPECULAR),
materialBlockIndex, 4, modelMatrix);
}
//Render the sphere.
{
glutil::PushStack push(modelMatrix);
modelMatrix.Translate(-83.0f, 14.0f, -77.0f);
modelMatrix.Scale(20.0f, 20.0f, 20.0f);
DrawObject(m_pSphereMesh.get(), "lit", GetProgram(LP_MTL_COLOR_DIFFUSE_SPECULAR),
materialBlockIndex, 5, modelMatrix);
}
}
