static public void Create()
{
Glu.GLUquadric quadratic = Glu.gluNewQuadric(); //Create the quadric object
Glu.gluQuadricNormals(quadratic, Glu.GLU_SMOOTH);
Glu.gluQuadricTexture(quadratic, Gl.GL_TRUE);
list = Gl.glGenLists(1); // Create list
Gl.glNewList(list, Gl.GL_COMPILE);
Gl.glPushMatrix();
Gl.glRotated(270, 1, 0, 0);
Glu.gluSphere(quadratic, 1, 5, 5); //the sphere
Gl.glPopMatrix();
Gl.glEndList();
}
private void SetupViewport()
{
int w = glControl1.Width;
int h = glControl1.Height;
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
//GL.Ortho(-1, 1, -1, 1, -1, 1);
Glu.gluPerspective(60.0, glControl1.Width / glControl1.Height, 0.01, 1000000);
// GL.Viewport(0, 0, w, h);
GL.ClearColor(0.9f, 0.9f, 0.9f, 1);
Gl.glClearColor(1f, 1f, 1f, 1);
Gl.glEnable(Gl.GL_DEPTH_TEST);
}
public void zoom(double new_R)
{
R = new_R;
eye[0] = R * Math.Cos(_phi) * Math.Cos(_psi);
eye[1] = R * Math.Sin(_phi) * Math.Cos(_psi);
eye[2] = R * Math.Sin(_psi);
Gl.glLoadIdentity();
Glu.gluLookAt(
eye[0], eye[1], eye[2] + _height,
pivot[0], pivot[1], pivot[2] + _height,
up[0], up[1], up[2]);
}
public void reset()
{
phi = 45.0; psi = 30.0; R = 11.0; height = 4.2;
eye[0] = R * Math.Cos(_phi) * Math.Cos(_psi);
eye[1] = R * Math.Sin(_phi) * Math.Cos(_psi);
eye[2] = R * Math.Sin(_psi);
Gl.glLoadIdentity();
Glu.gluLookAt(
eye[0], eye[1], eye[2] + _height,
pivot[0], pivot[1], pivot[2] + _height,
up[0], up[1], up[2]);
}
public void rotate(double new_phi, double new_psi)
{
phi = new_phi; psi = new_psi;
eye[0] = R * Math.Cos(_phi) * Math.Cos(_psi);
eye[1] = R * Math.Sin(_phi) * Math.Cos(_psi);
eye[2] = R * Math.Sin(_psi);
Gl.glLoadIdentity();
Glu.gluLookAt(
eye[0], eye[1], eye[2] + _height,
pivot[0], pivot[1], pivot[2] + _height,
up[0], up[1], up[2]);
}
public void AffectResize(int width, int height)
{
if (width == 0 || height == 0)
{
return;
}
GL.Viewport(0, 0, width, height);
var aspectRatio = width / (double)height;
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
Glu.Perspective(CameraFovy, aspectRatio, CameraZnear, CameraZfar);
}
static public void Crear()
{
Glu.GLUquadric quadratic = Glu.gluNewQuadric(); //crear el objeto cuadric
Glu.gluQuadricNormals(quadratic, Glu.GLU_SMOOTH);
Glu.gluQuadricTexture(quadratic, Gl.GL_TRUE);
list = Gl.glGenLists(1); // crear la lista
Gl.glNewList(list, Gl.GL_COMPILE);
Gl.glPushMatrix();
Gl.glRotated(270, 1, 0, 0);
Glu.gluSphere(quadratic, 1, 5, 5); //creo la esfera
Gl.glPopMatrix();
Gl.glEndList();
}
/// <summary>
/// Draws everything.
/// </summary>
/// <returns>
/// Returns <c>true</c> on success, otherwise <c>false</c>.
/// </returns>
private static bool DrawGLScene()
{
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer
Gl.glLoadIdentity(); // Reset The Matrix
Glu.gluLookAt(212, 60, 194, 186, 55, 171, 0, 1, 0); // This Determines Where The Camera's Position And View Is
Gl.glScalef(scaleValue, scaleValue * HEIGHT_RATIO, scaleValue);
if (!RenderHeightMap(heightMap)) // Render The Height Map
{
return(false);
}
return(true); // Everything Went OK
}
private static void Reshape(int w, int h)
{
Gl.glViewport(0, 0, w, h);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
if (w <= h)
{
Glu.gluOrtho2D(0.0, 1.0, 0.0, 1.0 * h / w);
}
else
{
Glu.gluOrtho2D(0.0, 1.0 * w / h, 0.0, 1.0);
}
}
public void Dispose()
{
if (_Tess != IntPtr.Zero)
{
Glu.DeleteTess(_Tess);
_Tess = IntPtr.Zero;
}
foreach (GCHandle delegatePin in _DelegatePins)
{
delegatePin.Free();
}
_DelegatePins.Clear();
}
/// <summary>
/// Resizes and initializes the GL window.
/// </summary>
/// <param name="width">
/// The new window width.
/// </param>
/// <param name="height">
/// The new window height.
/// </param>
private static void ReSizeGLScene(int width, int height)
{
if (height == 0) // Prevent A Divide By Zero...
{
height = 1; // By Making Height Equal To One
}
Gl.glViewport(0, 0, width, height); // Reset The Current Viewport
Gl.glMatrixMode(Gl.GL_PROJECTION); // Select The Projection Matrix
Gl.glLoadIdentity(); // Reset The Projection Matrix
Glu.gluPerspective(45, width / (double)height, 0.1, 200); // Calculate The Aspect Ratio Of The Window
Gl.glMatrixMode(Gl.GL_MODELVIEW); // Select The Modelview Matrix
Gl.glLoadIdentity(); // Reset The Modelview Matrix
}
public override void Draw()
{
Gl.glPushMatrix();
//Gl.glBindTexture(Gl.GL_TEXTURE_2D, SDL_Main.TextureArray[7]);
Gl.glTranslatef(XMax - XMin, YMax - YMin, ZMax + ZMin);
Gl.glRotatef(XRotation, 1.0f, 0.0f, 0.0f);
Glu.gluSphere(m_quadric, m_radius, 500, 500);
Gl.glPopMatrix();
}
// --- Application Methods ---
#region Init()
private static void Init()
{
Gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
Gl.glShadeModel(Gl.GL_FLAT);
tess = Glu.gluNewTess();
Glu.gluTessCallback(tess, Glu.GLU_TESS_VERTEX, new Glu.TessVertexCallback1(Gl.glVertex3dv));
Glu.gluTessCallback(tess, Glu.GLU_TESS_BEGIN, new Glu.TessBeginCallback(Begin));
Glu.gluTessCallback(tess, Glu.GLU_TESS_END, new Glu.TessEndCallback(End));
Glu.gluTessCallback(tess, Glu.GLU_TESS_ERROR, new Glu.TessErrorCallback(Error));
Glu.gluTessCallback(tess, Glu.GLU_TESS_COMBINE, new Glu.TessCombineCallback1(Combine));
list = Gl.glGenLists(4);
MakeNewLists();
}
///////////////////////////////////////////////
/////////////////CONSTRUCTORS//////////////////
///////////////////////////////////////////////
/*********************************************/
///////////////////////////////////////////////
////////////////////METHODS////////////////////
///////////////////////////////////////////////
public override void InitGlSetting()
{
int size = Math.Min(DrawContext.Width, DrawContext.Height);
Glut.glutInit();//initialize glut
Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE);
Gl.glEnable(Gl.GL_TEXTURE_2D);
Gl.glClearColor(255, 255, 255, 1);
Gl.glViewport(0, 0, size, size); // активация проекционной матрицы
Gl.glMatrixMode(Gl.GL_PROJECTION);
Glu.gluPerspective((360 * Math.Atan(size / 2) / Math.PI) % 90, 1, 1, 100);
Gl.glMatrixMode(Gl.GL_MODELVIEW);
}
void InitializeValues()
{
height = simpleOpenGlControl1.Height;
width = simpleOpenGlControl1.Width;
simpleOpenGlControl1.InitializeContexts();
Gl.glViewport(0, 0, width, height);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
Glu.gluOrtho2D(0, width, height, 0);
mode = Mode.Serial;
mesh = new Mesh(width, height, 20);
mesh.targetType = CellType.Block;
}
private void set_Bt_Click(object sender, EventArgs e)
{
b1 = b1 - 0.1f;
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT); //화면과 깊이 버퍼를 지운다.
Gl.glLoadIdentity(); //뷰 리셋
Glu.gluLookAt(0.0, 0.0, a1--, 0.0, 0.0, 0.0, b1, 15.0, 0.0); //카메라 시점 조정
Draw_Grid(); //좌표 그리드 그리기
Delay(50);
Gl.glTranslatef(-20.0f, -7.0f, -20.0f);
//Gl.glRotatef(xrot, 1, 0, 0); //그릴 화면 회전
//Gl.glRotatef(yrot, 0, 1, 0);
//Gl.glRotatef(zrot, 0, 0, 1);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, texture[0]); //텍스쳐 바인딩
Gl.glBegin(Gl.GL_QUADS); //사각형을 그린다.
//원점 기준으로 맞추는 함수
for (int i = 0; i < noOfPoint - 2; i++)
{
Set_Coordinate(i); //시작 점 인덱스
}
for (int i = 0; i < 11; i += 2) //\포인트를 이용하여 벽을 그린다. ex) 0,1,2,3번 사각형, 다음은 2,3,4,5번 사각형
{
Gl.glTexCoord2f(0, 0); Gl.glVertex3f(coordSet[i].x, coordSet[i].y, coordSet[i].z); //사각형 좌표위치 선택
Gl.glTexCoord2f(1, 0); Gl.glVertex3f(coordSet[i + 2].x, coordSet[i + 2].y, coordSet[i + 2].z);
Gl.glTexCoord2f(1, 1); Gl.glVertex3f(coordSet[i + 3].x, coordSet[i + 3].y, coordSet[i + 3].z);
Gl.glTexCoord2f(0, 1); Gl.glVertex3f(coordSet[i + 1].x, coordSet[i + 1].y, coordSet[i + 1].z);
}
Gl.glEnd(); //사각형 그리기를 끝낸다.
Gl.glColor3f(255, 0, 0); //색깔을 바꾼다.
Gl.glTranslatef(20.0f, -20.0f, 5.0f); //그릴 위치 변경
Glut.glutWireSphere(2, 50, 10); //와이어 구를 그린다.(원점 역할)
Gl.glTranslatef(-20.0f, 20.0f, -5.0f); //그릴 위치 변경
Gl.glTranslatef(-20.0f, -7.0f, -20.0f); // 화면 뷰 다시 전환
simpleOpenGlControl.Invalidate(); //openGL화면 컨트롤 비활성화
}
public void Create()
{
Glu.GLUquadric quadratic = Glu.gluNewQuadric();
Glu.gluQuadricNormals(quadratic, Glu.GLU_SMOOTH);
Glu.gluQuadricTexture(quadratic, Gl.GL_TRUE);
list = Gl.glGenLists(1);
Gl.glNewList(list, Gl.GL_COMPILE);
Gl.glPushMatrix();
Gl.glRotated(90, 1, 0, 0);
Glu.gluSphere(quadratic, radio, 32, 32);
Gl.glPopMatrix();
Gl.glEndList();
}
private void SwitchToProjectionView()
{
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
if (_remoteDrawingList.VisualiserController.FullScreen)
{
Glu.gluPerspective(45.0f, (m_screen.Width / m_screen.Height), NEAR_CLIPPING_PLANE_DISTANCE, FAR_CLIPPING_PLANE_DISTANCE);
Gl.glRotatef(-90.0f, 0.0f, 0.0f, 1.0f);
}
else
{
Glu.gluPerspective(45.0f, (m_screen.Height / m_screen.Width), NEAR_CLIPPING_PLANE_DISTANCE, FAR_CLIPPING_PLANE_DISTANCE);
}
}
public static bool FS = false; //включен ли полноэкранный режим
public static void Init(SimpleOpenGlControl AnT)
{
Glut.glutInit(); // инициализация бибилиотеки glut
Glut.glutInitDisplayMode(Glut.GLUT_RGBA | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH); // инициализация режима экрана
Gl.glClearColor(1, 1, 1, 1); // установка цвета очистки экрана (RGBA)
Gl.glViewport(0, 0, AnT.Width, AnT.Height); // установка порта вывода
Gl.glMatrixMode(Gl.GL_PROJECTION); // активация проекционной матрицы
Gl.glLoadIdentity(); // очистка матрицы
Glu.gluPerspective(45, (float)AnT.Width / AnT.Height, 1, 500); // установка перспективы
Gl.glMatrixMode(Gl.GL_MODELVIEW); // установка объектно-видовой матрицы
Gl.glLoadIdentity(); // очистка матрицы
// начальные настройки OpenGL
Gl.glEnable(Gl.GL_DEPTH_TEST);
Gl.glEnable(Gl.GL_LIGHTING);
Gl.glEnable(Gl.GL_LIGHT0);
Gl.glEnable(Gl.GL_LIGHT1);
Gl.glEnable(Gl.GL_LIGHT2);
Gl.glEnable(Gl.GL_LIGHT3);
Gl.glLightModeli(Gl.GL_LIGHT_MODEL_TWO_SIDE, Gl.GL_TRUE);
Gl.glLightModelfv(Gl.GL_LIGHT_MODEL_AMBIENT, new float[] { 1.0f, 1.0f, 1.0f, 1.0f });
////////////////////
//Разрешить плавное цветовое сглаживание;
Gl.glShadeModel(Gl.GL_SMOOTH);
// Слегка улучшим вывод перспективы;
Gl.glHint(Gl.GL_PERSPECTIVE_CORRECTION_HINT, Gl.GL_NICEST);
// Разрешаем смешивание;
Gl.glEnable(Gl.GL_BLEND);
// Устанавливаем тип смешивания;
Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA);
//вклюючить текстурирование
Gl.glEnable(Gl.GL_TEXTURE_2D);
///////////////////
//туман
Gl.glEnable(Gl.GL_FOG); // Включает туман (GL_FOG)
Gl.glFogi(Gl.GL_FOG_MODE, Gl.GL_LINEAR); // Выбираем тип тумана
Gl.glFogfv(Gl.GL_FOG_COLOR, new float[] { 0.9f, 0.9f, 0.9f }); // Устанавливаем цвет тумана
Gl.glFogf(Gl.GL_FOG_DENSITY, 0.05f); // Насколько густым будет туман
Gl.glHint(Gl.GL_FOG_HINT, Gl.GL_NICEST); // Вспомогательная установка тумана
Gl.glFogf(Gl.GL_FOG_START, 0.0f); // Глубина, с которой начинается туман
Gl.glFogf(Gl.GL_FOG_END, 4000.0f); // Глубина, где туман заканчивается.
}
public void PickFigure(int x, int y)
{
int selectedId = -1;
Gl.glSelectBuffer(128 * 4, selectBuffer);
Gl.glRenderMode(Gl.GL_SELECT);
Gl.glInitNames();
Gl.glPushName(0);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glPushMatrix();
int[] viewport = new int[4];
Gl.glGetIntegerv(Gl.GL_VIEWPORT, viewport);
double[] doubleArray = new double[16];
Gl.glGetDoublev(Gl.GL_PROJECTION_MATRIX, doubleArray);
Gl.glLoadIdentity();
Glu.gluPickMatrix(x, y, 0.001f, 0.001f, viewport);
Gl.glMultMatrixd(doubleArray);
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Render(true);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glPopMatrix();
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glFlush();
int hits = Gl.glRenderMode(Gl.GL_RENDER);
uint closest = uint.MaxValue;
for (int i = 0; i < hits; i++)
{
uint distance = (uint)selectBuffer[i * 4 + 1];
if (closest >= distance)
{
closest = distance;
selectedId = (int)selectBuffer[i * 4 + 3];
}
}
SelectFigure(Figs.Find(f => f.ID == selectedId));
}
private void Form1_Load(object sender, EventArgs e)
{
// Glut.glutInit();
// Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_SINGLE); не забыть
// устанавливаем цвет очистки окна
Gl.glClearColor(255, 255, 255, 1);
// устанавливаем порт вывода, основываясь на размерах элемента управления AnT
Gl.glViewport(0, 0, AnT.Width, AnT.Height);
// устанавливаем проекционную матрицу
Gl.glMatrixMode(Gl.GL_PROJECTION);
// очищаем ее
Gl.glLoadIdentity();
if ((float)AnT.Width <= (float)AnT.Height)
{
ScreenW = 500.0;
ScreenH = 500.0 * (float)AnT.Height / (float)AnT.Width;
Glu.gluOrtho2D(0.0, ScreenW, 0.0, ScreenH);
}
else
{
ScreenW = 500.0 * (float)AnT.Width / (float)AnT.Height;
ScreenH = 500.0;
Glu.gluOrtho2D(0.0, 500.0 * (float)AnT.Width / (float)AnT.Height, 0.0, 500.0);
}
devX = (float)ScreenW / (float)AnT.Width;
devY = (float)ScreenH / (float)AnT.Height;
Glu.gluOrtho2D(0.0, AnT.Width, 0.0, AnT.Height);
// переходим к объектно-видовой матрице
Gl.glMatrixMode(Gl.GL_MODELVIEW);
ProgrammDrawingEngine = new anEngine(AnT.Width, AnT.Height, AnT.Width, AnT.Height);
RenderTimer.Start();
comboBox1.SelectedIndex = 0;
// добавление элемента, отвечающего за управления главным слоем в объект LayersControl
Слои.Items.Add("Главный слой", true);
}
// --- Callbacks ---
#region Display()
/// <summary>
/// Called to draw the client area.
/// </summary>
private static void Display()
{
int buffer = 0;
float[] p = lightPosition;
// get the current color buffer being drawn to
Gl.glGetIntegerv(Gl.GL_DRAW_BUFFER, out buffer);
// clear the color and depth buffer
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT);
Gl.glPushMatrix();
Gl.glRotatef(angle1 += increment, 0.0f, 1.0f, 0.0f);
// set the position of the light
Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, lightPosition);
// switch to viewpoint of light
Gl.glPushMatrix();
// disable drawing into color buffer
Gl.glDrawBuffer(Gl.GL_NONE);
// set the camera to the viewpoint of the light
Gl.glLoadIdentity();
Glu.gluLookAt(p[0], p[1], p[2], 0, 0, 0, 0, 1, 0);
// draw scene
Render();
// save the depth buffer
Gl.glReadPixels(0, 0, windowWidth, windowHeight, Gl.GL_DEPTH_COMPONENT, Gl.GL_FLOAT, depthLight);
// enable drawing into color buffer
Gl.glDrawBuffer(buffer);
Gl.glPopMatrix();
// clear the depth buffer
Gl.glClear(Gl.GL_DEPTH_BUFFER_BIT);
// draw scene
Render();
// draw the shadow
Shadows();
Gl.glPopMatrix();
Gl.glFlush();
Glut.glutSwapBuffers();
}
public TextureObject(string bitmapFilepath, int textureNumberToOverwrite)
{
m_filepath = Path.GetFileName(bitmapFilepath);
System.Diagnostics.Debug.WriteLine("Currently generating texture from file: " + bitmapFilepath);
//Load the bitmap into memory
Bitmap currentBitmap = new Bitmap(bitmapFilepath);
currentBitmap.RotateFlip(RotateFlipType.Rotate180FlipNone);
//Create locked storage space for image data
Rectangle imageStorageSpace = new Rectangle(0, 0, currentBitmap.Width, currentBitmap.Height);
//Populate storage space
BitmapData currentBitmapData = new BitmapData();
currentBitmapData = currentBitmap.LockBits(imageStorageSpace, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
//Overwrite current texture ID
m_textureID = textureNumberToOverwrite;
Gl.glBindTexture(Gl.GL_TEXTURE_2D, m_textureID);
//Enable hardware generation of all mipmap levels
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_GENERATE_MIPMAP, Gl.GL_TRUE);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_S, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_T, Gl.GL_REPEAT);
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_WRAP_R, Gl.GL_REPEAT);
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 10, Gl.GL_RGB, currentBitmap.Width, currentBitmap.Height, 0, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, currentBitmapData.Scan0);
//Use maximum Anisotropic filtering if available
if (((string)Gl.glGetString(Gl.GL_EXTENSIONS)).Contains("GL_EXT_texture_filter_anisotropic"))
{
float maxAnisotropy;
Gl.glGetFloatv(Gl.GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, out maxAnisotropy);
Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy);
}
Glu.gluBuild2DMipmaps(Gl.GL_TEXTURE_2D, Gl.GL_RGB, currentBitmap.Width, currentBitmap.Height, Gl.GL_BGR, Gl.GL_UNSIGNED_BYTE, currentBitmapData.Scan0);
currentBitmap.UnlockBits(currentBitmapData);
currentBitmap.Dispose();
}
private void drawTextInfo()
{
//Iscrtavanje teksta
Gl.glViewport(0, 0, width, height);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
Glu.gluOrtho2D(0, 0, width, height);
Gl.glColor3f(224.0f, 224.0f, 224.0f);
Gl.glScalef(0.06f, 0.06f, 0.06f);
Gl.glTranslatef(2.0f, -16.0f, 0.0f);
//predmet
Gl.glPushMatrix();
Gl.glTranslatef(0.0f, 4.0f, 0.0f);
//font.DrawText(text[0]);
Gl.glPopMatrix();
//ime
Gl.glPushMatrix();
Gl.glTranslatef(0.0f, 3.0f, 0.0f);
font.DrawText(text[1]);
Gl.glPopMatrix();
//prezime
Gl.glPushMatrix();
Gl.glTranslatef(0.0f, 2.0f, 0.0f);
font.DrawText(text[2]);
Gl.glPopMatrix();
//skolska godina
Gl.glPushMatrix();
Gl.glTranslatef(0.0f, 1.0f, 0.0f);
font.DrawText(text[3]);
Gl.glPopMatrix();
//sifra
Gl.glPushMatrix();
Gl.glTranslatef(0.0f, 0.0f, 0.0f);
font.DrawText(text[4]);
Gl.glPopMatrix();
Gl.glLoadIdentity();
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Resize();
}
protected override void Particular()
{
Gl.glBindTexture(Gl.GL_TEXTURE_2D, GlUtils.Texture("WOOD2"));
//Gl.glColor3d(0.5,0.25,0);
Glu.GLUquadric q = Glu.gluNewQuadric();
Glu.gluQuadricNormals(q, Glu.GLU_SMOOTH);
Glu.gluQuadricTexture(q, Gl.GL_TRUE);
Gl.glColor3d(0.5, 0.25, 0);
Gl.glPushMatrix();
Gl.glTranslated(0.8f * 20, 0, 0);
GlUtils.PintaOrtoedro(0.8f * 20, 1f * 20, 0.4f * 40);
Gl.glTranslated(0, 0, 0.45f * 40);
GlUtils.PintaOrtoedro(0.8f * 20, 1f * 20, 0.05f * 40);
Gl.glTranslated(-0.7f * 20, 4, 0.06f * 40);
//Glut.glutSolidSphere(0.05f*20,10,10);
Gl.glColor3d(0.25, 0.25 / 2, 0);
Glu.gluSphere(q, 1, 10, 10);
Gl.glPopMatrix();
Gl.glPushMatrix();
Gl.glColor3d(0.5, 0.25, 0);
Gl.glTranslated(-0.8f * 20, 0, 0);
GlUtils.PintaOrtoedro(0.8f * 20, 1f * 20, 0.4f * 40);
Gl.glTranslated(0, 0, 0.45f * 40);
GlUtils.PintaOrtoedro(0.8f * 20, 1f * 20, 0.05f * 40);
Gl.glTranslated(0.7f * 20, 4, 0.06f * 40);
Gl.glColor3d(0.25, 0.25 / 2, 0);
Glu.gluSphere(q, 1, 10, 10);
Gl.glPopMatrix();
Gl.glPushMatrix();
Gl.glColor3d(0.5, 0.25, 0);
Gl.glTranslated(-26, -20, 12);
Gl.glRotated(90, 1, 0, 0);
Gl.glColor3d(0.25, 0.25 / 2, 0);
Glu.gluCylinder(q, 3, 2, 12, 20, 20);
Gl.glTranslated(52, 0, 0);
Glu.gluCylinder(q, 3, 2, 12, 20, 20);
Gl.glTranslated(0, -22, 0);
Glu.gluCylinder(q, 3, 2, 12, 20, 20);
Gl.glTranslated(-52, 0, 0);
Glu.gluCylinder(q, 3, 2, 12, 20, 20);
Gl.glRotated(-90, 1, 0, 0);
Gl.glTranslated(-26, 20, 2);
Gl.glPopMatrix();
yInc = 32;
Gl.glColor3d(1, 1, 1);
Glu.gluDeleteQuadric(q);
Gl.glBindTexture(Gl.GL_TEXTURE_2D, GlUtils.Texture("WOOD1"));
}
public override void ApplyProjection()
{
v3f lookat = new v3f();
lookat.z = -(float)Math.Sin(pitch / 180.0 * Math.PI);
float horiz = (float)Math.Cos(pitch / 180.0 * Math.PI);
lookat.x = horiz * (float)Math.Sin(yaw / 180.0 * Math.PI);
lookat.y = horiz * (float)Math.Cos(yaw / 180.0 * Math.PI);
lookat = lookat + location;
Glu.gluPerspective(45.0, aspect, .01, 1000);
Glu.gluLookAt(location.x, location.y, location.z, lookat.x, lookat.y, lookat.z, up.x, up.y, up.z);
}
public override void Render(float delta, float mouseX, float mouseY)
{
var size = EditorWindow.Instance.ClientSize;
/*
* if (bgImg)
* {
* GL.Color4(Color.FromArgb(255, 255, 255, 255));
* Glu.RenderTexturedQuad(0, 0, size.Width, size.Height, 0, 0, 1, 1, _textureId);
* }
*/
Glu.RenderTexturedQuad(ClientRectangle.Width / 2 - 400 / 2, ClientRectangle.Height / 2 - 300, 400, 400, 0, 0, 1, 1, logoTxt);
base.Render(delta, mouseX, mouseY);
}
protected override void Particular()
{
Gl.glBindTexture(Gl.GL_TEXTURE_2D, GlUtils.Texture("cream"));
Glu.GLUquadric q = Glu.gluNewQuadric();
Glu.gluQuadricNormals(q, Glu.GLU_SMOOTH);
Glu.gluQuadricTexture(q, Gl.GL_TRUE);
Gl.glColor3d(1, 1, 1);
GlUtils.GambarBangun(0.7f * 5, 1.0f * 160, 0.7f * 10);
Gl.glPopMatrix();
Gl.glEnable(Gl.GL_TEXTURE_2D);
yInc = 20;
}
static void Vaizdavimas1()
{
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT); //išvalomas ekramas
Gl.glColor3f(102 / 256f, 225 / 256f, 118 / 256f); //nustatoma piešimo spalva
//IV lango ketvirtis
//Nustatomas vaizdavimo plokštumos dydis ir padėtis lango koordinatėmis
Gl.glViewport(0, aukstis / 2, plotis / 2, aukstis / 2);
Gl.glMatrixMode(Gl.GL_PROJECTION); //Nustatoma einamoji matrica
Gl.glLoadIdentity(); //Išvaloma projekcijų matrica
Glu.gluOrtho2D(-1.0, 1.0, -1.0, 1.0); //Nustatomas naujas iškirpimo langas
Gl.glRectd(-1, -1, 1, 1);
Gl.glPolygonMode(Gl.GL_FRONT_AND_BACK, Gl.GL_LINE);
Gl.glColor3f(191 / 256f, 250 / 256f, 190 / 256f);
figura(); //vaizduojama figūra
}
private void glControl_Resize(object sender, EventArgs e)
{
Gl.glClearColor(0.39f, 0.58f, 0.93f, 1.0f);
Gl.glViewport(0, 0, glControl.Width, glControl.Height);
Gl.glPushMatrix();
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
Glu.gluPerspective(50.0d, 1.0d, 0.1d, 50d);
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glPopMatrix();
}
/// <summary>
/// Generates a vertex in the tesselator
/// </summary>
private void Vertex( Glu.GLUtesselator tess, Point2 pt )
{
ms_Pt[ 0 ] = pt.X;
ms_Pt[ 1 ] = 0;
ms_Pt[ 2 ] = pt.Y;
int index = m_Points.Count;
m_Points.Add( pt );
Glu.gluTessVertex( tess, ms_Pt, new IntPtr( index ) );
}
