Computer Graphics and Multimedia Software - Knowledge Sharing

Monday, November 20, 2017

openframeworks basic tutorial LeapMotion gesture recognition

The following repository version could be built without problems or you could also receive directly from openframeworks addon.
First of all, as a Hello World-like sample, try to recognize and display the hand. Only the fingertip could be detected independently! Easy!
There are two ways available for ofxLeapMotion. The first method is to use a simple hand model called ofxLeapMotionSimpleHand defined in ofxLeapMotion. The second method is to access and display functions provided by LeapMotion's SDK.
First of all, I try to draw by using a simple ofxLeapMotionSimpleHand. The way of doing it is very simple, once you have recognized ofxLeapMotionSimpleHand, calling a method called debugDraw () on that instance will display a simple 3D model of the hand.

testApp.cpp

#include "testApp.h"

void testApp::setup(){
ofSetFrameRate(60);
ofSetVerticalSync(true);
ofBackground(31);

ofEnableLighting();
light.setPosition(200, 300, 50);
light.enable();
cam.setOrientation(ofPoint(-20, 0, 0));

glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
leap.open();
}

void testApp::update(){

simpleHands = leap.getSimpleHands();

if( leap.isFrameNew() && simpleHands.size() ){
fingerPos.clear();

leap.setMappingX(-230, 230, -ofGetWidth()/2, ofGetWidth()/2);
leap.setMappingY(90, 490, -ofGetHeight()/2, ofGetHeight()/2);
leap.setMappingZ(-150, 150, -200, 200);

for(int i = 0; i < simpleHands.size(); i++){
for(int j = 0; j < simpleHands[i].fingers.size(); j++){
ofVec3f pos = simpleHands[i].fingers[j].pos;
fingerPos.push_back(pos);
}
}
}
leap.markFrameAsOld();
}

void testApp::draw(){
cam.begin();
for(int i = 0; i < fingerPos.size(); i++){
ofBoxPrimitive box;
box.setPosition(fingerPos[i].x, fingerPos[i].y, fingerPos[i].z);
box.set(20);
box.draw();
}
cam.end();
}

testApp.h

#include "ofMain.h"
#include "ofxLeapMotion.h"

class testApp : public ofBaseApp{

public:
void setup();
void update();
void draw();

void keyPressed (int key);
void keyReleased(int key);
void mouseMoved(int x, int y );
void mouseDragged(int x, int y, int button);
void mousePressed(int x, int y, int button);
void mouseReleased(int x, int y, int button);
void windowResized(int w, int h);
void dragEvent(ofDragInfo dragInfo);
void gotMessage(ofMessage msg);
void exit();

ofxLeapMotion leap;
vector simpleHands;
ofEasyCam cam;
ofLight light;
vector fingerPos;
};

The output : 


Share:

openFrameworks with Leap Motion example

ofxLeapMotion is an addon to work with openFrameworks and makes it very easy to get hand coordinates by using the prepared ofxLeapMotionSimpleHand class. Nonetheless, it seems that it is not fulfilling enough to utilize the full function provided by Leap Motion's SDK.
However, ofxLeapMotion also provides a way to directly obtain information on the Leap Motion SDK. Using this makes it possible to acquire more varied information.For details, refer to Documentation provided by Leap Motion .
Here I am providing the sample below, we first acquire the hand of Leap, obtain the position of each finger, then obtain and display information on the virtual sphere wrapped around the whole finger.

testApp.h

#include "ofMain.h"
#include "ofxLeapMotion.h"

class testApp: public ofBaseApp {

public:
void setup();
void update();
void draw();

void keyPressed (int key);
void keyReleased(int key);
void mouseMoved(int x, int y );
void mouseDragged(int x, int y, int button);
void mousePressed(int x, int y, int button);
void mouseReleased(int x, int y, int button);
void windowResized(int w, int h);
void dragEvent(ofDragInfo dragInfo);
void gotMessage(ofMessage msg);
void exit();

// the main class of Leap Motion
// vector simpleHands;

// vector array of simple hand model
ofEasyCam cam; // Camera
ofLight light; // Write
vector fingerPos; / / Array of position of fingers
vector spherePos; // array of positions of spheres surrounded by hands
vector sphereSize; // Array of sphere sizes surrounded by hands
};


testApp.cpp

#include "testApp.h"

void testApp::setup(){

ofSetFrameRate(60);
ofSetVerticalSync(true);
ofBackground(31);
ofEnableLighting();
light.setPosition(200, 300, 50);
light.enable();
cam.setOrientation(ofPoint(-20, 0, 0));
glEnable(GL_DEPTH_TEST);

// Leap Motion
leap.open();
}

void testApp::update(){
vector hands = leap.getLeapHands();
if( leap.isFrameNew() && hands.size() ){
fingerPos.clear();
spherePos.clear();
sphereSize.clear();

leap.setMappingX(-230, 230, -ofGetWidth()/2, ofGetWidth()/2);
leap.setMappingY(90, 490, -ofGetHeight()/2, ofGetHeight()/2);
leap.setMappingZ(-150, 150, -200, 200);

for(int i = 0; i < hands.size(); i++){
for(int j = 0; j < hands[i].fingers().count(); j++){
ofVec3f pt;
const Finger & finger = hands[i].fingers()[j];
pt = leap.getMappedofPoint( finger.tipPosition() );
fingerPos.push_back(pt);
}

ofVec3f sp = leap.getMappedofPoint(hands[i].sphereCenter());
float r = hands[i].sphereRadius();
spherePos.push_back(sp);
sphereSize.push_back(r);
}
}
leap.markFrameAsOld();
}

void testApp::draw(){
cam.begin();
for(int i = 0; i < fingerPos.size(); i++){
ofSpherePrimitive sphere;
sphere.setPosition(fingerPos[i].x, fingerPos[i].y, fingerPos[i].z);
sphere.draw();
}

for(int i = 0; i < spherePos.size(); i++){
ofSpherePrimitive sphere;
sphere.setPosition(spherePos[i].x, spherePos[i].y, spherePos[i].z);
sphere.setRadius(sphereSize[i]*1.5);
sphere.draw();
}
cam.end();
}

The output : 



Share:

Wednesday, November 16, 2016

Create UE4 Projects From File Examples

From the Epic Games Launcher, there are a lot of example files you can access and download for free. But once you download, what do you do with them?
Anytime you download any of the project examples from the Learn Section or Marketplace Section, you will find these files inside Library > Vault Section.
Here is how to create projects from these downloaded files. 

1. DOWNLOAD PROJECT EXAMPLE FILES


First you want to navigate to Learn or Marketplace section and download any of the available Engine Feature Samples, Gameplay Concept Examples, Example Game Projects or Marketplace Content.
Learn Section:


2. LIBRARY: VAULT SECTION
You will find all the downloaded files under Library tab and under Vault section. Just scroll down to find them.

3. CREATE PROJECT FROM DOWNLOADED PROJECTS

You can't open these downloaded files directly. You need to Create Project from them. This is to make sure that you always have access to a clean downloaded project example.
In Library > Vault section, click on Create Project:

4. CHOOSE PROJECT NAME AND LOCATION

After you click on Create Project, you have to set up where you want to store this project.
Choose folder where you want to store this project. Default location will be on your C drive. Under: "C:\Users \UserName \Documents \Unreal Projects" but if you have a second hard drive like me and you don't want to have huge Unreal Project file size on your main drive, click Browse and navigate where you want to store your project at.
  • Name the project
  • Set storage location on your computer
  • Create project

5. PROJECT CREATED AND READY TO BE LAUNCHED

You will now see this new project appear under your "My Projects" section in the Library tab.

You can now open this project from here by double clicking on the thumbnail icon or Right Clicking and choosing Open.





6. WHERE TO FIND DOWNLOADED VAULT CONTENT

Download project example files that you see inside Vault section are stored in "C:\Program Files \Epic Games \Launcher \VaultCache":

These downloaded Vault files get very large. So once you have created a project from them or added these assets into a project, you can move and store these Vault files somewhere else or delete them.
I often back them up on a larger drive and not on my main SSD hard drive, which isn't very large.
Once deleted or moved, these Vault files no longer will appear inside Library > Vault section.

7. CONTENT ADDED INTO PROJECTS

If you happen to download assets such as static meshes, sounds or materials you won't creating a project from these. You can add these into a project you already have created and are working on.
Click on "Add to Project":

Choose which project you want to add these assets into:

The assets will appear in Content Browser, when you launch this project.
Share:

Tutorial Third person game for Unreal Engine 4 Using C++


Third-person survival game for Unreal Engine 4 made entirely in C++. Originally built as a 6 section tutorial series, now available as open-source C++ sample project.

NEW: Mod Support
Includes two small mod examples including a Pink Rifle extension and Flashlight replacement mod. Check out the Modding Sample Project for guidelines & cooker profile setup
Example commandline arg to load the Mod gamemode with the built-in level "CoopLandscape" in a cooked game build: SurvivalGame.exe /Game/Maps/CoopLandscape_Map?game=/ExtendedRifleMod/SurvivalGameMode_PinkRifle.SurvivalGameMode_PinkRifle_C
There is currently no supporting UI to load up specific mod content, please note that the modding pipeline is a experimental and intended for early adopters only!
Section 1
This section sets up the third person character movement with animation, object interaction, simple hunger system, all with networking support.

Section 2

Adds weapon support for the character, a flashlight, UT-style inventory with on-character visual representation of the carried items and deals with damage, death and respawns for players.

Section 3

Introduces AI "Zombie" enemy to our game using PawnSensing and Behavior Tree.
Section 4
Introduces a gameloop with enemies, items, scoring and a time of day.

Section 5 

Introduces the ability to carry around objects like barriers and discusses game networking.

Section 6

The final section in the series focuses on bug fixing and a bit of polish to the existing features. This section is compatible with the 4.8 release.
Share:

Tuesday, November 8, 2016

Develop a working osgART application

What is a Scene Graph?

Tree-like structure for organising a virtual world, e.g. VRML
Hierarchy of nodes that define: Groups (and Switches, Sequences etc…) Transformations, Projections, Geometry …

And states and attributes that define:

  •  Materials and textures
  •  Lighting and blending
Benefits for performance

  •   Structuring data facilitates 
    • optimization:- Culling, state management, etc
What is a Open Scene Graph (OSG)?

Open-source scene graph implementation
Based on OpenGL
Object-oriented C++ following design pattern principles
Used for simulation, games, research, and industrial projects
Maintained by Robert Osfield | Documentation project: www.osgbooks.com
Uses the OSG Public License (similar to LGPL)

What is a osgART?

OSG + ARTookit = osgART
osgART adds AR to Open Scene Graph
Current version 2.0, Open Source

To add Video see-through AR:
  •  Integrate live video
  •  Apply correct projection matrix
  •  Update tracked transformations in real-time
Develop a working osgART application from scratch?

Use ARToolKit 2.72 
     library for tracking and 
     video capture
Install OSG

Tutorial 1 : Basic OSG Viewer | OSG 
Install osg (.exe) to your computer
Run basic viewer - located in osg folder in C:\\Program Files (Windows)

Tutorial 2: Adding Video | OSG + ARToolkit
Add a video plugin
Load, configure, start video capture…
Add a video background
Create, link to video, add to scene-graph

Tutorial 3: Tracking | OSG + ARToolkit
Add a Tracker plugin
 Load, configure, link to video
 Add a Marker to track
 Load, activate
 Tracked node
 Create, link with marker via tracking callbacks
 Print out the tracking data

Tutorial 4: Adding Content | OSG + ARToolkit
Now put the tracking data to use!
Add content to the tracked transform 
Basic cube code
e.g. Wavefront (.obj), OpenFlight (.flt), 3D Studio (.3ds), COLLADA
Replace the simple cube with a 3D model
Models are loaded using the osgDB::readNodeFile() function


OSGART sample project by other researchers


Share:

Friday, October 24, 2014

Malaysia UTM 2-Days Professional Course | Developing Mobile Augmented Reality Apps 2014

Hello Malaysia,

Grab this opportunity to learn and develop augmented reality application. This short-course will teach you the fundamental principle of Augmented Reality and the mobile AR apps development techniques.

Ever wondered what an interactive mobile application would look like when viewed through its camera,  virtual object will immersively overlay onto our real world? It looks cool and very impressive. How you would like to make sense of what you encounter? This is a new dimension to mobile experiences where    augmented reality technology will flourish the most. 

We bring to you an expert in Augmented Reality (AR) to guide you in developing your own mobile AR apps. The expert and most knowledgeable professor. 

Date : 29 NOVEMBER - 30 NOVEMBER 2014
Time : 10.00 AM - 05.00 PM
Venue : UTMSPACE KUALA LUMPUR

Contact :
comp.utm.my/mivielab

Booking Now!
Next training : December 2016 | February 2017 | April 2016
* subject to change, please whatapps to confirm





Share:

Monday, February 4, 2013

Exporting Android AR app with Vuforia and Unity3D

Unity Pro or Unity Android required?

Even the extension compatible for both. This is a Unity Pro only Features. It does not work with the Unity Basic version. Sure unfortunately, the limitation from Unity which only allows native plugins in the Pro version of the editor. However there are a few ways to acquire it. But it might require technical aspects.

Unity3D and Vuforia – Tutorial Exporting Android AR App

In this tutorial using Unity3D and Vuforia we show how to export augmented reality app

Unity3D is also available to download from here
Download # Download and Import Unity3D Extension v4.2.3  (*.unitypackage file)
Unity3D extension is also available to download from here
Stand-Alone Android SDK is also available to download based on your OS from here
Download # Money Images for Tracking (Euros)  (*.rar file)
Download # All Money Models with Textures  (*.rar file)


NOTE :

The Vuforia™ SDK allows you to build vision-based augmented reality applications. It is available for Android, iOS and as an Extension to Unity - a cross-platform game engine.

A Vuforia SDK-based AR application uses the display of the mobile device as a "magic lens" or looking glass into an augmented world where the real and virtual worlds appear to coexist. The application renders the live camera preview image on the display to represent a view of the physical world. Virtual 3D objects are then superimposed on the live camera preview and they appear to be tightly coupled in the real world.

For more information see www.vuforia.com.

An application developed for Vuforia will give your users a more compelling experience:
  • Faster local detection of targets
  • Cloud recognition of up to 1 million targets simultaneously
  • User-defined target for run-time target generation
  • Robust tracking – augmentations stick to the target and are not easily lost as the device moves
  • Simultaneous tracking of up to five targets
  • Better results in real world conditions – low light, partially covered target
  • Optimizations that ensure better and more realistic graphics rendered on the target
The diagram below gives you an overview of the application development process with the Vuforia platform. The platform consists of the Vuforia Engine (inside the SDK), the Target Management System hosted on the developer portal (Target Manager), and optionally the Cloud Target Database.

How do you run the Android Extension?
You’ll be able to use Play Mode for Vuforia, in Unity by following these steps:
  1. Install the Vuforia AR Extension for Unity release 2.0 into your project.  It will be available from the Unity Asset Store and from the Vuforia developer portal, as usual.
  2. Build your AR app.
  3. When you’re ready to test, click the play button in the editor and hold your target in front of the webcam.  Your scene will run in the game view as if you were running the app on a mobile device.
Share:

Thursday, September 8, 2011

Augmented Reality for Computer games Unity3D and Vuforia

Unity3D and Vuforia

Vuforia is an Augmented Reality Software Development Kit (SDK) for mobile devices that enables the creation of Augmented Reality applications. It uses Computer Vision technology to recognize and track planar images (Image Targets) and simple 3D objects, such as boxes, in real-time

Augmented Reality tutorial using Unity3D and Vuforia

This is one of the simplest Augmented Reality tutorial using Unity3D and Vuforia. Camera is pointed to the image target, which is recognized, tracked and virtual character added on top of it.

Download # Unity3D (download and install it) (*.exe file)
Unity3D is also available to download from here
Download # Download and Import Unity3D Extension (*.unitypackage file)
Unity3D extension is also available to download from here
Download # Download and Import EdgarasArt tracker in Unity3D  (*.unitypackage file)
You can create your own tracker here
Download # Print this image to augment the content  (*.jpg file)


Just wanna share some knowledge after I deliver a talk a few months ago. It was about Augmented Reality (AR) for Computer games. A brief about game art and concept and detail out the state of the ARt.


Qualcomm - the winners of its 2010 Augmented Reality Developer Challenge at Mobile World Congress. Qualcomm SDK - for the web, iPhone, iPad, PC, Mac, Wii, Xbox 360 and PlayStation 3, as well as Android. Qualcomm's AR SDK for Android and iOS smartphones and tablets is now available for download. This SDK will enable a new generation of AR applications that enable interactive 3D experiences to take place on everyday objects.

Current trends for games:

• Apple iPad2 is the second generation iPad for Apple with iOS 4.3 (upgradeable to iOS 4.3.1) platform. Nitro JavaScript engine / No Adobe Flash.
• The good features of Galaxy Tab is the voice and video calling and video conferencing facility, communicate through speakerphone or your Bluetooth headset. Support to Adobe Flash Flayer - platform Android 2.2
• Motorola Xoom the first device to run on Google’s next generation mobile operating system Android OS 3.0 Honeycomb, which is entirely designed for tablets
• Acer Aspire Iconia Tab A501 uses Android 3.0 with a redesigned UI. Honeycomb is more futuristic - resembles with Motorola Xoom in internal specification
Share:

Wednesday, May 4, 2011

ARTag : SDK demonstrating AR

Demo AR Programs using ARTag

There are four main programs demonstrating AR (augmented reality) using ARTag; , <3d_augmentations>, and . The first two have two versions, one with “_usb.exe” for most cameras such as USB webcams, and the second “_dragonfly.exe” is for the Point Grey Dragonfly camera from Point Grey Research (www.ptgrey.com) often used in university labs that gives better performance and was used by myself in ARTag development.

1. The program uses the “base0” image and just draws a few graphics primitives and a textured logo image relative to the marker array, its purpose is to be a simple example for people programming with the SDK.

2. The <3d_augmentations> demo is more interesting, it was used to create the images at the first page of this document. This program uses the “base0” array, and the individual toolbars. To save space in the download, and for permission reasons, only 5 models are provided in the demo and SDK download; fish, Chihuahua, car, frog, and can of asparagus model.

If you run this application, aim the camera at the base0 and toolbar arrays and you should see 3D virtual objects rendered relative to them.

Fiala (2004) has developed new system called ARTag was inspired by ARToolkit. ARTag was taking advantage of the increased computing processing power available. ARTag uses more complex image processing and digital symbol processing to achieve a higher reliability and immunity to lighting





Share:

Camera Resolution : Setting Resolution Problems

Camera Resolution: Bigger = Better Performance, Setting Resolution Problems

The larger the input camera image is, the smaller the markers can be and still be detected, and the less the JPEG artefacts will disturb the detection. Unfortunately the OpenCV cvcam interface that was used in these demos is not able to properly set the camera resolution, it usually defaults to a lower resolution such as 160x120 or 320x240.

The camera resolution should not be confused with the resolution of the graphics window, the demo program window can be 640x480 when the camera resolution is only 160x120. The picture of the background will just appear grainer and more pixelated. The system will work better if the camera can be set to a higher resolution.

Some users have found that if they run another program where you can set the camera resolution first, then it will run with a higher resolution when you run the ARTag demos. For some, the programs downloaded from http://www.shrinkwrapvb.com/ezvidcap.htm seem to do the trick on some computers.




Share:

Monday, March 21, 2011

Google SketchUp : 3D modeling for architecture

Google SketchUp

...is a 3D modeling program that can be used to make models that integrate with Google Earth. Like Google Earth, SketchUp is a software download.

...currently upgraded SketchUp 6 Pro to SketchUp 8. The pro version comes with additional export options and support.

Do not expect Google SketchUp to compete with professional products like Autodesk Maya. SketchUp is nowhere near this level of sophistication. However, SketchUp does not require years of constant use to master.

Creating a model for Google Earth is easy. With both Google Earth and SketchUp open, the view from Google Earth can be imported into SketchUp with the touch of a button. Once modeling is complete, press the place model button, and the model moves into your copy of Google Earth.




Models created in CAD software can be imported to SketchUp and SketchUp models can be ported to CAD software. In theory, there can be a two way street. In this article, we will show that while CAD models can be moved into SketchUp and worked on, it is not feasible to go in the opposite direction.


SketchUp feels like an architectural modeling program. SketchUp even offers a variety of "sketchy" textures for models, and SketchUp Pro has a rendering option to make 2D renders look like they're architect's sketches.

Google SketchUp is a great tool for beginners or anyone looking for a simple way to make simple 3D objects. It's ideal for students in areas like interior design, where 3D models would enhance their presentations.


Downloaded material :

Tutorial Introduction to SketchUP

Exporting SketchUp models to CAD software
Share:

Tuesday, December 21, 2010

Using ARToolkit to develop Augmented Reality

There are two parts to developing Augmented Reality applications that use ARToolKit; writing the application, and training image-processing routines on the real world markers that will be used in the application.

Developing the application

In writing an ARToolKit application the following steps must be taken:

1. Initialize the video path and read in the marker pattern files and camera parameters.
2. Grab a video input frame.
3. Detect the markers and recognized patterns in the video input frame.
4. Calculate the camera transformation relative to the detected patterns.
5. Draw the virtual objects on the detected patterns.
6. Close the video path down.

Steps 2 through 5 are repeated continuously until the application quits, while steps 1 and 6 are just performed on initialization and shutdown of the application respectively. In addition to these steps the application may need to respond to mouse, keyboard or other application specific events.

To show in detail how to develop an application we will step through the source code for the simpleTest program. This is found in the directory examples/simple/ The file we will be looking at is simpleTest.c. This program simply consists of a main routine and several graphics drawing routines. The main routine is shown below:


int main (int argc, char **argv)
{

glutInit (&argc, argv);
init();
arVideoCapStart();
argMainLoop (NULL, keyEvent, mainLoop);
return (0);

}

This routine calls an init initialization routine that contains code for initialization of the video path, reading in the marker and camera parameters and setup of the graphics window. This corresponds to step 1 above.

Next, the function arVideoCapStart() starts video image capture.
Finally, the argMainLoop function is called which starts the main program loop and associates the function keyEvent with any keyboard events and mainLoop with the main graphics rendering loop. The definition of argMainLoop is contained in the file gsub.c that can be found in the directory lib/Src/Gl/

In simpleTest.c the functions which correspond to the six application steps above. The functions corresponding to steps 2 through 5 are called within the mainLoop function.

Recognizing different patterns

The simpleTest program uses template matching to recognize the different patterns inside the marker squares. Squares in the video input stream are matched against pre-trained patterns.

These patterns are loaded at run time and are contained in the Data directory of the bin directory. In this directory, the text file object_data specifies which marker objects are to be recognized and the patterns associated with each object. The object_data file begins with the number of objects to be specified and then a text data structure for each object. Each of
the markers in the object_data file are specified by the following structure:

Name
Pattern Recognition File Name
Width of tracking marker

For example the structure corresponding to the marker with the virtual cube is:

#pattern 1
cone
Data/hiroPatt
80.0

Note that lines beginning with a # character are comment lines and are ignored by the file reader. In order to change the patterns that are recognized the sampPatt1 filename must be replaced with a different template file name.

These template files are simply a set of sample images of the desired pattern. The program to create these template files is called mk_patt and is contained in the bindirectory. The source code for mk_patt is in the mk_patt.c file in the util directory.


ARToolkit tutorial for beginersDownload latest version ARToolkit 2.7.2.1
Rujuk Documentation provided in HitLab website for more information/additional note.
Must know how to configure and setting up ARToolkit – set directories “Option properties” visual studio pada linker, include dll, path.

Download Tutorial 1 (.pdf)

Download Tutorial 2 (.pdf)



Share:

Tuesday, December 14, 2010

How to import VRML model in ARToolkit

Each pattern is associated with an image.
The mapping between pattern and image is found in
C:\ARToolkit\bin\data\vrml_data for simpleVRML.exe program
and C:\ARToolkit\bin\data\multi_vrml_data for the multiVRML.exe program.


For the simpleVRML.exe program, the patterns to be recognized and their associated models are specified in the Data/vrml_data file. In this file you will see a set of lines like this:

#pattern 1
VRML Wrl/bud_B.dat
Data/patt.hiro
80.0 0.0 0.0

In order to import your own model you will have to follow this pattern (Using your_file as example name):

1. Copy your_file.wrl into the Wrl directory

2. Make a your_file.dat file and associate it with your_file.wrl by typing Wrl/ your_file.wrl on the first line. (You may take a copy of one the existing .dat files and edit it to fit your wrl file). Place it in the Wrl directory.

3. Make a new marker (Se section 3.2) or use one that is not yet in use.

4. Edit the Data/vrml_data file by adding a new paragraph:
#pattern 3
VRML Wrl/ your_file.dat
Data/patt.sample1 -- Alternatively your new marker (See on How to make your own marker) 80.0
0.0 0.0

Start the simpleVRML.exe program. When the camera recognizes the pattern associated with your model, the model will be loaded and rendered.


Share:

Malaysia Augmented Reality

Its incredibly difficult to discover the undiscovered. Here will see how I can help you. Cheers - Ajune (comp.utm.my/ajune)
ajune@utm.my. Powered by Blogger.