void DrawObjects(Shader &s) {
// 平面描画
s.SetUniformMatrix4x4("uModel", Matrix().m);
glColor4f(0.7f, 0.7f, 0.7f, 1.0f);
DrawPlane(20.0f);
// 立方体
// ModelMatrix
s.SetUniformMatrix4x4("uModel", Matrix().m);
glColor4f(1, 0.4f, 0.5f, 1.0f);
DrawCube(1.0f, 1.0f, 1.0f);
// ModelMatrix
s.SetUniformMatrix4x4("uModel", Matrix::TranslateMatrix(0.85f, 0.7f, 0.3f).m);
glColor4f(0.98f, 0.98f, 0.98f, 1.0f);
DrawCube(1.0f, 1.0f, 1.0f);
// ModelMatrix
s.SetUniformMatrix4x4("uModel", Matrix::TranslateMatrix(-0.3f, -0.5f, 2.5f).m);
glColor4f(0.2f, 0.3f, 1, 1.0f);
DrawCube(1.0f, 1.0f, 1.0f);
// ModelMatrix
s.SetUniformMatrix4x4("uModel", Matrix::TranslateMatrix(2.0f, 0.6f, 1.5f).m);
glColor4f(0.2f, 1.0f, 0.3f, 1.0f);
DrawCube(1.0f, 1.0f, 1.0f);
// ModelMatrix
s.SetUniformMatrix4x4("uModel", Matrix::TranslateMatrix(-1.85f, -0.5f, -1.3f).m);
glColor4f(0.98f, 0.98f, 0.98f, 1.0f);
DrawCube(1.0f, 1.0f, 1.0f);
}
int main (void)
{
int move=FALSE;
Init();
DrawCube();
unsigned char r;
while ( (r=scr.Read(&w)) != kEND )
{
switch (r)
{
//case kUP : cout << (s.focal += step) << kCR; s = w; break;
//case kDN : cout << (s.focal -= step) << kCR; s = w; break;
//case kLE : cout << (s.eyedist += step) << kCR; s = w; break;
//case kRI : cout << (s.eyedist -= step) << kCR; s = w; break;
case kSP : move = TRUE; break;
case kLO : move = FALSE; break;
}
DrawCube();
if (move==TRUE)
{
//cout << "bouge de la" << kCR;
p-=5;
w.Clear(0,150);
w.Box(PointZ(350,p,2,80), 100, 100);
w.Box(PointZ(200,150,1,100), 200, 200);
//s.AleaSource();
//s = w;
}
}
return 0;
}
void DrawScene() {
//The Desk
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture[1]);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
DrawCube(0, 0, 5.5, 5, 4, 1);
DrawCube(1.5, 1, 2.5, 1, 1, 5);
DrawCube(-1.5, 1, 2.5, 1, 1, 5);
DrawCube(1.5, -1, 2.5, 1, 1, 5);
DrawCube(-1.5, -1, 2.5, 1, 1, 5);
glDisable(GL_TEXTURE_2D);
//The Door
door1.draw(texture[1]);
door1.approach_notice(eye[0], eye[1], texture[2]);
door2.draw(texture[1]);
door2.approach_notice(eye[0], eye[1], texture[2]);
door3.draw(texture[1]);
door3.approach_notice(eye[0], eye[1], texture[2]);
door4.draw(texture[1]);
door4.approach_notice(eye[0], eye[1], texture[2]);
}
static void Display(void)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
/* Drehung um y-Achse, Neigung und Platzierung auf dem Tisch */
glTranslatef (0.0, -1.0 ,-4.4);
glRotatef (spinAngle, 0.0, 1.0, 0.0);
glRotatef (baseAngle, 1.0, 0.0, 0.0);
/* Ausgabe des Oberarms */
glPushMatrix();
/* Wuerfel aus Bsp. 1 durch asymetrische Skalierung zu einem */
/* Quader deformieren */
glScalef (0.2, 1.0, 0.2);
glTranslatef (-0.5, 0.0 , -0.5);
DrawCube ();
glPopMatrix();
/* Lampenkopf + Unterarm an Spitze Oberarm verschieben */
glTranslatef (0.0, 1.0 , 0.0);
/* Kippen des Kopfes + Unterarms um Ellenbogenwinkel */
glRotatef (elbowAngle, 1.0, 0.0, 0.0);
/* Ausgabe des Unterarms */
glPushMatrix();
glScalef (0.2, 1.0, 0.2);
glTranslatef (-0.5, 0.0 , -0.5);
DrawCube ();
glPopMatrix();
glColor3f(0.5, 0.0, 1.0);
/* Lampenkopf an Spitze Unterarm verschieben */
glTranslatef (0.0, 1.0 , 0.0);
/* Lampenkopf kippen: */
glRotatef (headAngle, 1.0, 0.0, 0.0);
/* Ausgabe des Lampenkopfes */
glPushMatrix();
gluCylinder (cone, 0.2, 0.2, 0.2, 20, 4);
glPopMatrix();
glTranslatef (0.0, 0.0 , 0.2);
gluCylinder (cone, 0.2, 0.4, 0.2, 20, 4);
glutSwapBuffers();
}
void DrawState()
{
Short x;
Char msg[MaxName+4];
DrawCurrScore();
// Fill the fields
x = 0;
if ( stor.currplayer > -1 ) {
// If there is a game on, fill in the names and scores
for ( ; x < stor.numplayers ; x++ ) {
StrPrintF( msg, "%d. %s", x+1, stor.player[x].name, NULL );
SetFieldTextFromStr( fieldNamePlayer[x], msg );
DrawPlayerScore( x );
}
}
// Clears the rest if the fields
for ( ; x < MaxPlayers ; x++ ) {
ClearFieldText( fieldNamePlayer[x] );
ClearFieldText( fieldScorePlayer[x] );
ClearFieldText( fieldMarkPlayer[x] );
}
for ( x = 0 ; x < NumCubes ; x++ ) {
DrawCube(x);
DrawKeepBit(x);
}
DrawStayButton();
DrawRollButton();
DrawStatus();
DrawTopStatusButton();
}
void Render(float timeDelta)
{
if (!g_bActive)
{
Sleep(50) ;
}
//SetupMatrix() ;
// Clear the back-buffer to a RED color
g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,0), 1.0f, 0 );
// Begin the scene
if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
{
// Draw teapot
DrawCube();
// End the scene
g_pd3dDevice->EndScene();
}
// Present the back-buffer contents to the display
g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}
void DrawRow(int x1, int y, int x2)
{
glPushMatrix();
for(int x = x1; x <= x2; x++)
{
Uint8 Data;
if(Data = Map[x][y])
{
Uint8 LeftData = (x > 0) ? Map[x-1][y] : 0;
Uint8 RightData = (x < 127) ? Map[x+1][y] : 0;
Uint8 TopData = (y > 0) ? Map[x][y-1] : 0;
Uint8 BottomData = (y < 127) ? Map[x][y+1] : 0;
Data = (Data << 1) | 1;
glPushMatrix();
while(Data&~1)
{
if(Data&2)
DrawCube(LeftData, RightData, TopData, BottomData, Data);
Data >>= 1;
LeftData >>= 1;
RightData >>= 1;
TopData >>= 1;
BottomData >>= 1;
glTranslatef(0, 0, -1);
}
glPopMatrix();
}
glTranslatef(1, 0, 0);
}
void RenderObjects(void)
{
float colorBronzeDiff[4] = { 0.8, 0.6, 0.0, 1.0 };
float colorBronzeSpec[4] = { 1.0, 1.0, 0.4, 1.0 };
float colorBlue[4] = { 0.0, 0.2, 1.0, 1.0 };
float colorNone[4] = { 0.0, 0.0, 0.0, 0.0 };
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
// Main object (cube) ... transform to its coordinates, and render
glRotatef(15, 1, 0, 0);
glRotatef(45, 0, 1, 0);
glRotatef(g_fTeapotAngle, 0, 0, 1);
glMaterialfv(GL_FRONT, GL_DIFFUSE, colorBlue);
glMaterialfv(GL_FRONT, GL_SPECULAR, colorNone);
glColor4fv(colorBlue);
DrawCube(1.0);
// Child object (teapot) ... relative transform, and render
glPushMatrix();
glTranslatef(2, 0, 0);
glRotatef(g_fTeapotAngle2, 1, 1, 0);
glMaterialfv(GL_FRONT, GL_DIFFUSE, colorBronzeDiff);
glMaterialfv(GL_FRONT, GL_SPECULAR, colorBronzeSpec);
glMaterialf(GL_FRONT, GL_SHININESS, 50.0);
glColor4fv(colorBronzeDiff);
glutSolidTeapot(0.3);
// glutSolidSphere(1,20,20);
glPopMatrix();
glPopMatrix();
}
void animation(void)
{
yRotated += 0.01;
xRotated += 0.02;
DrawCube();
}
/*
* Function: LabelCube
* -------------------
* Exported function used to draw letters on cubes. Set the 2-d array
* at this position to hold the letter and then draw the cube in the un-highlighted
* version with the letter added.
*/
void LabelCube(int row, int col, char letter)
{
if (row < 0 || row >= gState.numRows || col < 0 || col >= gState.numCols)
Error("LabelCube called with invalid row, col arguments.");
gState.letters[row][col] = letter;
DrawCube(row, col, letter, false);
}
void SimpleDraw::DrawArrow( Vec3d from, Vec3d to, bool isForward /*= true*/ , bool isFilledBase, float width /*= 1.0f */)
{
if(!isForward){
Vec3d temp = from;
from = to;
to = temp;
}
if(isFilledBase)
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
else
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
float length = (from-to).norm();
float radius = length * 0.05f;
if (radius < 0.0) radius = 0.05 * length;
// draw cube base
DrawCube(from, radius * 3);
glPushMatrix();
glTranslatef(from[0],from[1],from[2]);
glMultMatrixd(qglviewer::Quaternion(qglviewer::Vec(0,0,1), qglviewer::Vec(to-from)).matrix());
static GLUquadric* quadric = gluNewQuadric();
const float head = 2.5*(radius / length) + 0.1;
const float coneRadiusCoef = 4.0 - 5.0 * head;
gluCylinder(quadric, radius, radius, length * (1.0 - head/coneRadiusCoef), 16, 1);
glTranslatef(0.0, 0.0, length * (1.0 - head));
gluCylinder(quadric, coneRadiusCoef * radius, 0.0, head * length, 16, 1);
glPopMatrix();
}
//------------------------------------------------------------------------------
// void DrawSpacecraft(float radius, GlColorType *color1, GlColorType *color2,
// bool drawSphere = true)
//------------------------------------------------------------------------------
void DrawSpacecraft(float radius, GlColorType *color1, GlColorType *color2,
bool drawSphere)
{
if (drawSphere)
{
glColor3ub(color1->red, color1->green, color1->blue);
DrawSphere(radius, 50, 50, GLU_FILL);
}
else
{
glColor3ub(color1->red, color1->green, color1->blue);
DrawCube(radius, radius, radius*2);
glColor3ub(color2->red, color2->green, color2->blue);
DrawCube(radius/4, radius*4, radius*1.5);
}
}
//
// This function is called when the window needs redrawing.
//
static void Display(void)
{
int i;
// Select correct buffer for this context.
glDrawBuffer(GL_BACK);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear the buffers for new frame.
arglPixelBufferDataUpload(gArglSettings, gARTImage);
arglDispImage(gArglSettings);
gARTImage = NULL; // Invalidate image data.
// Set up 3D mode.
glMatrixMode(GL_PROJECTION);
#ifdef ARDOUBLE_IS_FLOAT
glLoadMatrixf(cameraLens);
#else
glLoadMatrixd(cameraLens);
#endif
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_DEPTH_TEST);
// Set any initial per-frame GL state you require here.
// --->
// Lighting and geometry that moves with the camera should be added here.
// (I.e. should be specified before marker pose transform.)
// --->
for (i = 0; i < markersNFTCount; i++) {
if (markersNFT[i].valid) {
#ifdef ARDOUBLE_IS_FLOAT
glLoadMatrixf(markersNFT[i].pose.T);
#else
glLoadMatrixd(markersNFT[i].pose.T);
#endif
// All lighting and geometry to be drawn relative to the marker goes here.
// --->
DrawCube();
}
}
// Set up 2D mode.
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, (GLdouble)gWindowW, 0, (GLdouble)gWindowH, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
// Add your own 2D overlays here.
// --->
glutSwapBuffers();
}
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d mode");
// Define the camera to look into our 3d world
Camera camera;
camera.position = (Vector3){ 0.0f, 10.0f, 10.0f }; // Camera position
camera.target = (Vector3){ 0.0f, 0.0f, 0.0f }; // Camera looking at point
camera.up = (Vector3){ 0.0f, 1.0f, 0.0f }; // Camera up vector (rotation towards target)
camera.fovy = 45.0f; // Camera field-of-view Y
Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
// TODO: Update your variables here
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(RAYWHITE);
Begin3dMode(camera);
DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
DrawGrid(10, 1.0f);
End3dMode();
DrawText("Welcome to the third dimension!", 10, 40, 20, DARKGRAY);
DrawFPS(10, 10);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}
void BatchRenderer::DrawAABB( const rxAABB& box, const FColor& color )
{
XMMATRIX matWorld = XMMatrixScaling( box.Extents.x, box.Extents.y, box.Extents.z );
XMVECTOR position = XMLoadFloat3( &box.Center );
matWorld.r[3] = XMVectorSelect( matWorld.r[3], position, XMVectorSelectControl( 1, 1, 1, 0 ) );
DrawCube( matWorld, color );
}
void RenderFunction (void)
{
++FrameCount;
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
DrawCube ();
glutSwapBuffers ();
glutPostRedisplay ();
}
static void BuildCube(void)
{
GLint i;
glNewList(lists[CUBE], GL_COMPILE);
DrawCube();
glEndList();
}
static void
draw(void)
{
float ar;
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0, 0.0, -40.0);
glDisable(GL_SCISSOR_TEST);
glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_SCISSOR_TEST);
/* draw gears */
glViewport(0, 0, TexWidth, TexHeight);
glScissor(0, 0, TexWidth, TexHeight);
glClearColor(0.5, 0.5, 0.8, 0.0);
glClearColor(1, 1, 1, 0);
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-1.0, 1.0, -1.0, 1.0, 5.0, 60.0);
glMatrixMode(GL_MODELVIEW);
DrawGears();
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, TexWidth, TexHeight);
/* draw textured cube */
glViewport(TexWidth, 0, WinWidth - TexWidth, WinHeight);
glScissor(TexWidth, 0, WinWidth - TexWidth, WinHeight);
glClearColor(0.5, 0.5, 0.8, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
ar = (float) (WinWidth - TexWidth) / WinHeight;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-ar, ar, -1.0, 1.0, 5.0, 60.0);
glMatrixMode(GL_MODELVIEW);
DrawCube();
/* finish up */
glutSwapBuffers();
Frames++;
{
GLint t = glutGet(GLUT_ELAPSED_TIME);
if (t - T0 >= 5000) {
GLfloat seconds = (t - T0) / 1000.0;
GLfloat fps = Frames / seconds;
printf("%d frames in %6.3f seconds = %6.3f FPS\n", Frames, seconds, fps);
T0 = t;
Frames = 0;
}
}
}
void Robot::DrawHead(float xPos, float yPos, float zPos)
{
glPushMatrix();
glColor3f(1.0f, 1.0f, 1.0f); // white
glTranslatef(xPos, yPos, zPos);
glScalef(2.0f, 2.0f, 2.0f); // head is a 2x2x2 cube
DrawCube(0.0f, 0.0f, 0.0f);
glPopMatrix();
}
void Robot::DrawArm(float xPos, float yPos, float zPos)
{
glPushMatrix();
glColor3f(1.0f, 0.0f, 0.0f); // red
glTranslatef(xPos, yPos, zPos);
glScalef(1.0f, 4.0f, 1.0f); // arm is a 1x4x1 cube
DrawCube(0.0f, 0.0f, 0.0f);
glPopMatrix();
}
void Robot::DrawFoot(float xPos, float yPos, float zPos)
{
glPushMatrix();
glColor3f(1.0f, 1.0f, 1.0f);
glTranslatef(xPos, yPos, zPos);
glScalef(1.0f, 0.5f, 3.0f);
DrawCube(0.0f, 0.0f, 0.0f);
glPopMatrix();
}
void Robot::DrawTorso(float xPos, float yPos, float zPos)
{
glPushMatrix();
glColor3f(0.0f, 0.0f, 1.0f); // blue
glTranslatef(xPos, yPos, zPos);
glScalef(3.0f, 5.0f, 2.0f); // torso is a 3x5x2 cube
DrawCube(0.0f, 0.0f, 0.0f);
glPopMatrix();
}
void DrawCenterCube(float size)
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
DrawCube(size * 0.2f);
glDisable(GL_BLEND);
}
void BatchRenderer::DrawOBB( const rxOOBB& box, const FColor& color )
{
XMMATRIX matWorld = XMMatrixRotationQuaternion( XMLoadFloat4( &box.Orientation ) );
XMMATRIX matScale = XMMatrixScaling( box.Extents.x, box.Extents.y, box.Extents.z );
matWorld = XMMatrixMultiply( matScale, matWorld );
XMVECTOR position = XMLoadFloat3( &box.Center );
matWorld.r[3] = XMVectorSelect( matWorld.r[3], position, XMVectorSelectControl( 1, 1, 1, 0 ) );
DrawCube( matWorld, color );
}
//
// This function is called when the window needs redrawing.
//
static void Display(void)
{
ARdouble p[16];
ARdouble m[16];
// Select correct buffer for this context.
glDrawBuffer(GL_BACK);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear the buffers for new frame.
arglPixelBufferDataUpload(gArglSettings, gARTImage);
arglDispImage(gArglSettings);
gARTImage = NULL; // Invalidate image data.
// Projection transformation.
arglCameraFrustumRH(&(gCparamLT->param), VIEW_DISTANCE_MIN, VIEW_DISTANCE_MAX, p);
glMatrixMode(GL_PROJECTION);
#ifdef ARDOUBLE_IS_FLOAT
glLoadMatrixf(p);
#else
glLoadMatrixd(p);
#endif
glMatrixMode(GL_MODELVIEW);
// Viewing transformation.
glLoadIdentity();
// Lighting and geometry that moves with the camera should go here.
// (I.e. must be specified before viewing transformations.)
//none
if (gPatt_found) {
// Calculate the camera position relative to the marker.
// Replace VIEW_SCALEFACTOR with 1.0 to make one drawing unit equal to 1.0 ARToolKit units (usually millimeters).
arglCameraViewRH(gPatt_trans, m, VIEW_SCALEFACTOR);
#ifdef ARDOUBLE_IS_FLOAT
glLoadMatrixf(m);
#else
glLoadMatrixd(m);
#endif
// Before drawing any geometry, mask out the area occupied by the cube marker itself.
// This makes for a nicer visual presentation, but obviously only applies for this particular
// shape of marker.
DrawCubeMarkerMask();
// All lighting and geometry to be drawn relative to the marker goes here.
DrawCube();
} // gPatt_found
// Any 2D overlays go here.
//none
glutSwapBuffers();
}
void z_perspective(int dist)
{
int i;
for(i=0;i<8;i++)
{
vertex[i][2]=vertex[i][2]/(vertex[i][2]/dist+1);
vertex[i][0]=vertex[i][0]/(vertex[i][2]/dist+1);
vertex[i][1]=vertex[i][1]/(vertex[i][2]/dist+1);
}
DrawCube();
}
void DrawManager::DrawCollisionCube(CollisionDetection* collision, const GLint pTexture,
const float pTexCoordX, const float pTexCoordY, const Vector3D& pPosition, const Vector3D& pSize) const
{
glPushMatrix();
DrawCube(pTexture, pTexCoordX, pTexCoordY, pPosition, pSize.x, pSize.y, pSize.z);
Vector3D position = pPosition;
position.z -= pSize.z;
Vector3D size(pPosition.x+pSize.x, pPosition.y+pSize.y, pPosition.z);
collision->AddCollisionBox(position, size);
glPopAttrib();
}
void CD3DRenderer::ProcessPlay()
{
HRESULT hr;
hr = m_pD3DDevice9->Clear(0,nullptr,D3DCLEAR_TARGET,0x0,0,0);
if(SUCCEEDED(m_pD3DDevice9->BeginScene()))
{
DrawCube();
m_pD3DDevice9->EndScene();
}
hr = m_pD3DDevice9->Present(nullptr, nullptr, nullptr, nullptr);
}
void GlPreviewer::Render(int width, int height, Geometry* geo, Material3D mat, float zoom, float rotation)
{
// USE OLD OPENGL 1 code
glClearColor(0.0,0.0,0.0,1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glViewport(0, 0, width, height);
// Isometric
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-10.0f + zoom, 10.0f - zoom, -10.0f + zoom, 10.0f - zoom, -10.0f, 10.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glRotatef(35.264f, 1.0f, 0.0f, 0.0f);
glRotatef(-45.0f, 0.0f, 1.0f, 0.0f);
glRotatef(rotation,0.0f,1.0f,0.0f);
// Draw AXIS
glColor3f(1.0,0.0,0.0);
glBegin(GL_LINES);
glVertex3f(0.0,0.0,0.0);
glVertex3f(100.0,0.0,0.0);
glEnd();
glColor3f(0.0,1.0,0.0);
glBegin(GL_LINES);
glVertex3f(0.0,0.0,0.0);
glVertex3f(0.0,100.0,0.0);
glEnd();
glColor3f(0.0,0.0,1.0);
glBegin(GL_LINES);
glVertex3f(0.0,0.0,0.0);
glVertex3f(0.0,0.0,100.0);
glEnd();
for(short i=0;i<geo->g;i++){
for(short j=0;j<geo->g;j++){
for(short k=0;k<geo->g;k++){
if(geo->GetGrid(i,j,k)==1){
DrawCube(i,j,k,mat[i][j][k]);
}
}
}
}
}
int C_TestTraceline::DrawModel( int flags )
{
trace_t tr;
Vector forward, right, up, endpos, hitpos;
AngleVectors (GetAbsAngles(), &forward, &right, &up);
endpos = GetAbsOrigin() + forward * MAX_TRACE_LENGTH;
UTIL_TraceLine( GetAbsOrigin(), endpos, MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr );
CMatRenderContextPtr pRenderContext( materials );
IMesh* pMesh = pRenderContext->GetDynamicMesh( true, NULL, NULL, m_pWireframe );
CMeshBuilder meshBuilder;
meshBuilder.Begin( pMesh, MATERIAL_LINES, 1 );
meshBuilder.Position3fv( GetAbsOrigin().Base() );
meshBuilder.Color3ub( 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.Position3fv( tr.endpos.Base() );
meshBuilder.Color3ub( 255, 255, 255 );
meshBuilder.AdvanceVertex();
meshBuilder.End();
pMesh->Draw();
// Didn't hit anything
if ( tr.fraction != 1.0 )
{
unsigned char color[] = { 0, 255, 0 };
DrawCube( tr.endpos, color );
}
if ( (!tr.allsolid) && (tr.fractionleftsolid != 0.0) )
{
unsigned char color[] = { 255, 0, 0 };
DrawCube( tr.startpos, color );
}
return 1;
}
