Viewing

Aug 14, 20171 like452 views

This document discusses graphics programming and concepts such as viewing, transformations, projection, animation, and examples. It covers translation, rotation, and scaling transformations, as well as viewing transformations like gluLookAt. It also discusses projection transformations including perspective and orthographic projection. Finally, it provides examples of animating a spinning rectangle and building a solar system and robot arm.

CSC 307 1.0
Graphics Programming
Budditha Hettige
Department of Statistics and Computer Science

Graphics Programming
Viewing
2Budditha Hettige

Translate
? void glTranslate{fd}(TYPE x, TYPE y, TYPE z);
3Budditha Hettige

Rotate
void glRotate{fd}(TYPE angle, TYPE x, TYPE y, TYPE z);
glRotatef(45.0, 0.0, 0.0, 1.0) - rotation of 45 degrees
about the z-axis
4Budditha Hettige

Scale
void glScale{fd}(TYPE x, TYPE y, TYPE z);
Example: glScalef(2.0, �C0.5, 1.0)
5Budditha Hettige

Viewing and Modeling
Transformations
? Rotating First or Translating First
6Budditha Hettige

Viewpoint
? Object and Viewpoint at the Origin
7Budditha Hettige

Viewpoint and the Object
? Separating the Viewpoint and the Object
? glTranslatef(0.0, 0.0, -5.0);
8Budditha Hettige

Using the gluLookAt()
void gluLookAt
(
GLdouble eyex, GLdouble eyey, GLdouble eyez,
GLdouble centerx, GLdouble centery, GLdouble centerz,
GLdouble upx, GLdouble upy, GLdouble upz
);
9Budditha Hettige

Default Camera Position
10
gluLookAt(0.0, 0.0, 0.0, 0.0, 0.0, -100.0, 0.0, 1.0, 0.0);
Budditha Hettige

Using gluLookAt()
gluLookAt(4.0, 2.0, 1.0, 2.0, 4.0, -3.0, 2.0, 2.0, -1.0);
11Budditha Hettige

Projection Transformations
? Perspective Projection
void glFrustum(GLdouble left, GLdouble right,
GLdouble bottom, GLdouble top,
GLdouble near, GLdouble far);
12Budditha Hettige

Orthographic Projection
void glOrtho(GLdouble left, GLdouble right,
GLdouble bottom, GLdouble top,
GLdouble near, GLdouble far);
13Budditha Hettige

Viewport Transformation
? Defining the Viewport
? void glViewport(GLint x, GLint y,
GLsizei width, GLsizei height);
14Budditha Hettige

The Transformed Depth Coordinate
? void glDepthRange(GLclampd near,
GLclampd far);
15Budditha Hettige

Animation
? Is an important part of computer graphics
? Taking a sequence of pictures and projecting
them at 24 frames per second on the screen
? void glutSwapBuffers(void);
16Budditha Hettige

$Example # include <windows.h> #include <GL/glut.h> #include <stdlib.h> static GLfloat spin = 0.0; void spinDisplay(void) { spin = spin + 0.05; if (spin > 360.0) spin = spin - 360.0; glutPostRedisplay(); } 17 void display(void) { glClear(GL_COLOR_BUFFER_BIT); glPushMatrix(); glRotatef(spin, 0.0, 0.0, 1.0); glColor3f(1.0, 1.0, 1.0); glRectf(-25.0, -25.0, 25.0, 25.0); glPopMatrix(); glutSwapBuffers(); spinDisplay(); } void reshape(int w, int h) { glViewport(0, 0, (GLsizei) w, (GLsizei) h); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-50.0, 50.0, -50.0, 50.0, -1.0, 1.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); }Budditha Hettige$

$Example int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(250, 250); glutInitWindowPosition(100, 100); glutCreateWindow(argv[0]); glClearColor(0.0, 0.0, 0.0, 0.0); glShadeModel(GL_FLAT); glutDisplayFunc(display); glutReshapeFunc(reshape); glutMainLoop(); return 0; } 18Budditha Hettige$

Building a Solar System
? planet example (planet.cpp)
19Budditha Hettige

Building an Articulated Robot Arm
? robotArm.cpp
20Budditha Hettige

With the introduction of multi-touch and gesture support coming in Qt, application developers now have the possibility of introducing new types of input and interaction to their applications. We will examine the various types of devices that one can expect to encounter in the multi-touch and gesture "world". This presentation will also introduce and explain the new API, walk through some example code, and show some demos of some of the possibilities we foresee with this technology. Presentation by Jens Bache-Wiig held during Qt Developer Days 2009. http://qt.nokia.com/developer/learning/elearning

NavAsesino Dog

This document provides an introduction to the history and principles of the Nomina Anatomica Veterinaria (N.A.V.), the international standard for veterinary anatomical nomenclature. It outlines how earlier terminology systems lacked consistency across countries and species. The first efforts in 1895 aimed to standardize human anatomy, but were not applicable to veterinary species. Subsequent revisions in the early 20th century also failed to achieve international consensus for veterinary anatomy. The current N.A.V. was established in 1955 to address this need, using principles oriented to animal body positions rather than the human form. It has since been revised periodically under the guidance of an international committee to maintain relevance and consistency in veterinary anatomical terminology globally

��֧�ѧ�ڧ�ߧߧ�� ާ֧��է� ��֧�֧ߧڧ� ��Theoretical mechanics department

01 estruturas l��gicas e diagramas l��gicosAledson Martins

C++20 Coroutine?? ?

2D DrawingBudditha Hettige

OpenGL 3D DrawingBudditha Hettige

This document discusses 3D graphics programming in OpenGL. It covers topics like projections, transformations, object composition, hidden surface removal, and drawing basic 3D objects like cubes and spheres. Code examples are provided to demonstrate drawing a 3D tetrahedral fractal using subdivision and the z-buffer algorithm for hidden surface removal. The document also discusses locating the camera using functions like gluLookAt and displaying a cube with different camera positions.

Tutorial Open GL (Listing Code)Aila Gema Safitri

The document contains listings of OpenGL programs for drawing 2D and 3D shapes using various functions like glBegin, glVertex, glColor. Program 1 draws a 2D rectangle, Program 2 draws a pink triangle. Later programs demonstrate drawing polygons, setting vertex colors, 3D rendering with perspective projection, handling window resizing, object transformations and drawing a cube with different colors on each face. The programs illustrate basic 3D graphics and OpenGL functions.

CGLabLec6.pptxMohammad7Abudosh7

This document discusses 3D graphics and OpenGL. It begins with an introduction to 3D concepts in OpenGL like using glVertex3f to specify 3D coordinates and constructing 3D objects from triangles. It then discusses several built-in OpenGL functions for drawing common 3D objects like cubes, spheres and cylinders. The document also covers key 3D transformations like projection, viewing and modeling transformations. It includes code examples for a basic 3D cube program and another drawing a cone. It ends with an example program demonstrating different projection transformations across four windows.

201707 SER332 Lecture 06 Javier Gonzalez-Sanchez

This document discusses transformations in OpenGL graphics. It explains that transformations are applied in reverse order and can include translation, rotation, and scaling. The key stages are the model-view transformation, which combines the model and view, and the projection transformation, which maps the scene to the screen. Examples show how to apply transformations using OpenGL functions like glTranslate, glRotate, and glScale to manipulate 3D objects. Readings are recommended from graphics books and specifications to better understand 2D and 3D transformations and viewing.

opengl.pptSubiksha57

OpenGL is a graphics rendering API that can be used to render 2D and 3D graphics. It uses graphics primitives like points, lines, polygons, and textures to render high-quality images. GLUT is a library that provides windowing and input functions to simplify OpenGL program development. An OpenGL program initializes graphics state, registers callback functions for events like display and input, and enters a main loop to process events. Within callbacks, primitives are specified using vertices between glBegin and glEnd commands to render graphics.

Intro to Computer Graphics.pptadil104135

Rotate an object in open gl(glut) sample example with sourcekunalashutosh92

transformation in open GL. why use open GL modesjawadsafee

Programa de objetos 3 d wireRen�� Dom��nguez

The document contains code for a 3D wireframe object program in C++ using OpenGL and GLUT. The code defines functions for initialization, drawing, and window resizing. It sets up the display mode, window position and size, and registers callbacks for drawing, resizing, and the main loop. The drawing function clears the screen, sets color, applies transformations, and draws a wire cube using GLUT functions.

Ass day2 1_checkerboard...copy in cppRobi Parvez

This code defines functions to initialize and display a checkerboard pattern using OpenGL. The init() function sets the display window properties and projection. The CheckerBoard() function uses nested for loops to draw 64 colored squares arranged in an 8x8 checkerboard pattern by alternating orange and brown colors. It draws each square as a quad using GL_QUADS. The Display() function clears the display and calls CheckerBoard() before flushing the buffer. The main() function initializes GLUT and creates a window, then registers the display callback and enters the main loop.

01.Opengl_intro-2.pptEngrZamaan

This document provides an introduction to OpenGL and GLUT (OpenGL Utility Toolkit). It discusses OpenGL as a graphics rendering API that is device, window system, and operating system independent. GLUT is introduced as a toolkit that provides window system-independent functions, mostly for user interface purposes in OpenGL programs. The document outlines a typical GLUT program structure of configuring a window, initializing OpenGL, registering callback functions, and entering an event loop. It provides examples of OpenGL geometric primitives, rendering steps, and using GLUT functions.

september11.pptCharlesMatu2

This document provides an introduction and overview of OpenGL programming concepts including: - OpenGL is a cross-platform graphics library that interfaces with the graphics system through an API. - Programs use matrices to transform 3D vertices through modeling and viewing transformations to 2D screen coordinates. - Geometry is defined through vertex lists and rendered as primitives like triangles and lines. State variables control properties like color. - Common tasks like camera placement, projections, lighting and textures are demonstrated.

Opengl (1)ch samaram

This document provides an introduction to OpenGL. It discusses the history and evolution of OpenGL, its core components and libraries, basic programming concepts like coordinate systems and transformations, and how to set up an OpenGL development environment in both Unix and Windows systems. It also covers OpenGL programming concepts like the display callback, event handling, and GLUT functions. Finally, it provides information on submitting assignments and office hours for questions.

Ujug07presentationBill Adams

201707 SER332 Lecture10 Javier Gonzalez-Sanchez

This document discusses 3D graphics transformation and projection. It explains how to set up a 3D scene using the z-buffer for visibility resolution. It covers setting the projection to orthographic or perspective, and using gluLookAt to define the camera view through eye, lookat and up vectors. Display lists are introduced to efficiently render complex objects by compiling draw commands into a list.

Working with CallbacksSyed Zaid Irshad

Research: Automatic Diabetic Retinopathy DetectionMadhawa Gunasekara

Bai 1Ch?u Thanh Ch??ng

The document introduces OpenGL and GLUT (OpenGL Utility Toolkit). It discusses that OpenGL is a graphics library for rendering 2D and 3D graphics, while GLUT provides a windowing and input framework. It then covers OpenGL fundamentals like rendering primitives, transformations, lighting and texture mapping. The goals are to demonstrate enough OpenGL to create interactive 3D graphics and introduce advanced topics. Sample code shows basic GLUT and OpenGL usage.

OpenGL L03-UtilitiesMohammad Shaker

The document discusses various OpenGL graphics techniques including viewports, depth buffering, handling input, using 3D models, drawing primitives, fog, displaying text, collision detection, picking objects, lens flares, and particle systems. Specifically, it provides code examples for setting the viewport, depth testing, handling keyboard input, loading and drawing 3D models, drawing spheres and cylinders using GLU functions, applying fog, displaying text, approximating collision detection using spheres, picking objects using the picking matrix, creating lens flares using the projection matrix, and generating particle systems for effects like dust and fire.

201707 SER332 Lecture 07 Javier Gonzalez-Sanchez

This document discusses viewport transformations in OpenGL. It explains that the viewport defines the size and location of the screen area available for rendering. The gluViewport function sets the viewport, specifying the x and y coordinates of the lower-left corner as well as the width and height. An example demonstrates drawing two triangles in separate viewports on the same screen. The document also discusses how the viewport setting must work with the projection transformation and how to handle window resizing. It provides reading recommendations for further understanding 2D and 3D transformations and viewing in OpenGL.

GPGPU Programming @DroidconNL 2012 by AltenArjan Somers

This document discusses using graphics processing units (GPUs) to perform general purpose calculations on Android devices. It begins with an introduction to GPGPU programming and its history using GPUs for parallel processing. The document then covers how to parallelize code, pack data, implement OpenGL ES 2.0 shaders, and perform input/output operations for GPGPU on Android. It provides an example of using a GPU to implement the AES encryption algorithm on an Android device in parallel compared to a non-parallel CPU implementation. The document aims to explain what GPGPU is, how it can be done on Android, and when it is useful to use a GPU for general computations.

Algorithm analysisBudditha Hettige

SortingBudditha Hettige

More Related Content

Similar to Viewing (20)

Tutorial Open GL (Listing Code)Aila Gema Safitri

CGLabLec6.pptxMohammad7Abudosh7

201707 SER332 Lecture 06 Javier Gonzalez-Sanchez

opengl.pptSubiksha57

Intro to Computer Graphics.pptadil104135

Rotate an object in open gl(glut) sample example with sourcekunalashutosh92

transformation in open GL. why use open GL modesjawadsafee

Programa de objetos 3 d wireRen�� Dom��nguez

Ass day2 1_checkerboard...copy in cppRobi Parvez

01.Opengl_intro-2.pptEngrZamaan

september11.pptCharlesMatu2

Opengl (1)ch samaram

Ujug07presentationBill Adams

201707 SER332 Lecture10 Javier Gonzalez-Sanchez

Working with CallbacksSyed Zaid Irshad

Research: Automatic Diabetic Retinopathy DetectionMadhawa Gunasekara

Bai 1Ch?u Thanh Ch??ng

OpenGL L03-UtilitiesMohammad Shaker

201707 SER332 Lecture 07 Javier Gonzalez-Sanchez

GPGPU Programming @DroidconNL 2012 by AltenArjan Somers

Tutorial Open GL (Listing Code)Aila Gema Safitri

CGLabLec6.pptxMohammad7Abudosh7

201707 SER332 Lecture 06 Javier Gonzalez-Sanchez

opengl.pptSubiksha57

Intro to Computer Graphics.pptadil104135

Rotate an object in open gl(glut) sample example with sourcekunalashutosh92

transformation in open GL. why use open GL modesjawadsafee

Programa de objetos 3 d wireRen�� Dom��nguez

Ass day2 1_checkerboard...copy in cppRobi Parvez

01.Opengl_intro-2.pptEngrZamaan

september11.pptCharlesMatu2

Opengl (1)ch samaram

Ujug07presentationBill Adams

201707 SER332 Lecture10 Javier Gonzalez-Sanchez

Working with CallbacksSyed Zaid Irshad

Research: Automatic Diabetic Retinopathy DetectionMadhawa Gunasekara

Bai 1Ch?u Thanh Ch??ng

OpenGL L03-UtilitiesMohammad Shaker

201707 SER332 Lecture 07 Javier Gonzalez-Sanchez

GPGPU Programming @DroidconNL 2012 by AltenArjan Somers

More from Budditha Hettige (20)

Algorithm analysisBudditha Hettige

SortingBudditha Hettige

Link ListBudditha Hettige

QueueBudditha Hettige

02 StackBudditha Hettige

Data Structures 01Budditha Hettige

Drawing FontsBudditha Hettige

Texture Mapping Budditha Hettige

This document discusses texture mapping in computer graphics. Texture mapping involves applying 1D, 2D, or 3D images to geometric primitives. Textures can be used to simulate materials, reduce geometric complexity, perform image warping, and create reflections. Texture mapping works by flowing image and geometry data through separate pipelines that join at the rasterization stage. The document outlines steps for applying textures including specifying the texture, assigning texture coordinates to vertices, and setting texture parameters like wrapping and filtering modes.

LightingBudditha Hettige

- The document discusses lighting principles in computer graphics and OpenGL, including how OpenGL simulates lighting using the Phong lighting model. - It describes common light properties like ambient, diffuse, and specular components. Types of lights include directional lights, point lights, and spotlights. - Material properties and light properties are defined through OpenGL calls by passing color values in arrays. Normals also affect how surfaces reflect light. - The document provides examples of setting up lighting and materials, and compares flat and Gouraud shading approaches.

Graphics Programming OpenGL & GLUT in Code::BlocksBudditha Hettige

This document provides instructions for setting up OpenGL and GLUT projects in Code::Blocks. It discusses downloading Code::Blocks and the necessary GLUT files, and saving them in the appropriate directories. It then outlines the steps to create a new GLUT project in Code::Blocks, including selecting the compiler and building the application. The document also provides examples of OpenGL code using geometric primitives, transformations, and GLUT functions.

Introduction to Computer GraphicsBudditha Hettige

Computer System Architecture Lecture Note 9 IO fundamentalsBudditha Hettige

This document discusses computer I/O fundamentals including: - The three main functions of a computer system are the CPU, memory, and I/O. - I/O devices can be input, output, or storage devices and vary in data rate. - Buses are shared communication links that connect multiple subsystems using a single set of wires. - Interrupts and polling are methods for I/O devices to notify the operating system of completed operations or errors.

Computer System Architecture Lecture Note 8.1 primary MemoryBudditha Hettige

Computer System Architecture Lecture Note 8.2 Cache MemoryBudditha Hettige

Cache memory is a small, high-speed memory located close to the processor that stores frequently accessed instructions and data. When the CPU requests data, it first checks the cache and if the data is present it is retrieved from cache, otherwise it is retrieved from main memory. There are different types of cache mapping including direct mapping, associative mapping, and set-associative mapping that determine how data is stored in cache. Cache performance is improved through techniques such as write-back caching that only write data to cache on write operations.

Computer System Architecture Lecture Note 7 addressingBudditha Hettige

This document discusses various aspects of computer system architecture and instruction types. It describes different addressing modes like immediate, direct, register, register indirect, indexed, and based-indexed addressing. It also explains different types of instructions such as data movement, dyadic operations, monadic operations, comparison/conditional branch, procedure call, loop control, and input/output instructions. Direct memory access (DMA) is described as a method of I/O where a DMA controller facilitates high-speed transfer of data between memory and peripherals without involving the CPU.

Computer System Architecture Lecture Note 6: hardware performanceBudditha Hettige

This document discusses various methods for improving computer performance, including increasing clock speed, parallelism through instruction-level parallelism and processor-level parallelism, pipelining, and superscalar architectures. It also covers metrics for measuring performance such as execution time, throughput, CPU time, and MIPS/MFLOPS. Amdahl's law and the CPU performance equation are explained as ways to analyze and compare the performance of different computer designs and implementations.

Computer System Architecture Lecture Note 5: microprocessor technologyBudditha Hettige

This document discusses various processor modes, instructions, and features used in computer systems. It describes the real mode, protected mode, and 64-bit modes that processors can run in. It outlines the evolution of x86 processor instructions from the 80386 to modern processors. It also explains various processor features like MMX, SSE, hyper-threading, virtualization, and more. It discusses techniques for fixing bugs in processors through microcode updates.

Computer System Architecture Lecture Note 3: computer architectureBudditha Hettige

The document provides an overview of computer system architecture. It begins by defining computer architecture as the set of data types, operations, and features that are visible to a computer's users at a particular level of abstraction. The document then discusses why computer architecture is important for optimizing performance within cost constraints. It describes the basic components of a simple computer system, including the CPU, memory, I/O devices, and bus. The document explains in detail the role of the CPU, including its main components like the control unit, ALU, and registers. It provides examples of how a simple CPU would execute instructions on a 4-bit system. Finally, it illustrates how the bus is used to connect the CPU and other devices to allow

Computer System Architecture Lecture Note 2: HistoryBudditha Hettige

The document discusses the history and development of computer system architectures from the earliest mechanical computers through six generations defined by their underlying technologies. It covers the evolution from early mechanical and vacuum tube-based computers of the 1940s-1950s, to transistor-based systems of the 1950s-1960s, integrated circuits of the 1960s-1970s, microprocessors of the 1970s-1980s, and advances in parallel processing and artificial intelligence that define the potential of fifth-generation systems. Key systems discussed for each generation include the ENIAC, UNIVAC, IBM 7090, IBM 360, Intel 4004, and modern multi-core microprocessors.

Computer System Architecture Lecture Note 1: introductionBudditha Hettige

This document discusses computer system architecture and the different levels of a computer system. It begins by defining a computer and machine language, which consists of binary instructions. It then describes different levels of a computer from the digital logic level up to the problem-oriented language level. These levels include the microarchitecture, instruction set architecture, operating system, and assembly language levels. The document also discusses the relationship between hardware and software and how the boundary between them has blurred over time with the addition of new levels. It concludes with exercises about machine language, interpretation vs. translation, multilevel machines, and differences between two-level and six-level machines.