విషయము

• సీన్‌ఫార్మ్ ప్లగిన్‌తో 3D మోడళ్లను దిగుమతి చేస్తోంది
• దృశ్య రూప ప్లగ్‌ఇన్‌ను ఇన్‌స్టాల్ చేస్తోంది
• దృశ్య రూప UX మరియు జావా 8: మీ ప్రాజెక్ట్ డిపెండెన్సీలను నవీకరిస్తోంది
• ఆర్ఫ్రాగ్‌మెంట్‌తో అనుమతులను అభ్యర్థిస్తోంది
• AR అవసరం లేదా ఐచ్ఛికమా?
• 1. AR అవసరం
• 2. AR ఐచ్ఛికం
• మీ లేఅవుట్కు అర్ఫ్రాగ్మెంట్ జోడించండి
• Google పాలిని ఉపయోగించి 3D మోడళ్లను డౌన్‌లోడ్ చేస్తోంది
• ఆండ్రాయిడ్ స్టూడియోలోకి 3 డి మోడళ్లను దిగుమతి చేస్తోంది
• మీ 3D మోడల్‌ను ప్రదర్శించండి
• 1. ఆర్ఫ్రాగ్మెంట్ సభ్యుల వేరియబుల్ సృష్టించండి
• 2. మోడల్‌రెండరబుల్‌ను రూపొందించండి
• 3. వినియోగదారు ఇన్‌పుట్‌కు ప్రతిస్పందించండి
• 4. మీ మోడల్‌ను ఎంకరేజ్ చేయండి
• 5. కదిలే, స్కేలింగ్ మరియు తిరిగే మద్దతును జోడించండి
• పూర్తయిన మెయిన్ యాక్టివిటీ
• మీ Google ARCore ఆగ్మెంటెడ్ రియాలిటీ అనువర్తనాన్ని పరీక్షిస్తోంది
• Android వర్చువల్ పరికరంలో ARCore ని పరీక్షిస్తోంది
• చుట్టి వేయు

సీన్‌ఫార్మ్ ప్లగిన్‌తో 3D మోడళ్లను దిగుమతి చేస్తోంది

సాధారణంగా, 3 డి మోడళ్లతో పనిచేయడానికి నిపుణుల జ్ఞానం అవసరం, అయితే సీన్‌ఫార్మ్ ప్లగ్ఇన్ విడుదలతో గూగుల్ జావా ఉపయోగించి 3 డి మోడళ్లను అందించడం సాధ్యం చేసింది - మరియు లేకుండా OpenGL నేర్చుకోవాలి.

సీన్ఫార్మ్ ప్లగ్ఇన్ మీరు ప్రామాణిక Android విడ్జెట్‌లు, ఆకారాలు లేదా సామగ్రి నుండి లేదా .OBJ లేదా .FBX ఫైల్స్ వంటి 3D ఆస్తుల నుండి రెండర్‌డబుల్స్ సృష్టించడానికి ఉపయోగించే అధిక-స్థాయి API ని అందిస్తుంది.

మా ప్రాజెక్ట్‌లో, మేము .OBJ ఫైల్‌ను Android స్టూడియోలోకి దిగుమతి చేయడానికి సీన్‌ఫార్మ్ ప్లగిన్‌ను ఉపయోగిస్తాము. మీరు సీన్‌ఫార్మ్ ఉపయోగించి ఫైల్‌ను దిగుమతి చేసుకున్నప్పుడల్లా, ఈ ప్లగ్ఇన్ స్వయంచాలకంగా అవుతుంది:

• ఆస్తి ఫైల్‌ను .sfb ఫైల్‌గా మార్చండి. ఇది రన్‌టైమ్-ఆప్టిమైజ్ చేసిన సీన్‌ఫార్మ్ బైనరీ ఫార్మాట్ (.sfb), ఇది మీ APK కి జోడించబడి, ఆపై రన్‌టైమ్‌లో లోడ్ అవుతుంది. మెషెస్, మెటీరియల్స్ మరియు అల్లికలను కలిగి ఉన్న రెండరబుల్ సృష్టించడానికి మేము ఈ .sfb ఫైల్‌ను ఉపయోగిస్తాము మరియు వృద్ధి చెందిన సన్నివేశంలో ఎక్కడైనా ఉంచవచ్చు.
• .Sfa ఫైల్‌ను రూపొందించండి. ఇది ఆస్తి వివరణ ఫైలు, ఇది .sfb ఫైల్ యొక్క మానవ-చదవగలిగే వివరణను కలిగి ఉన్న టెక్స్ట్ ఫైల్. మోడల్‌పై ఆధారపడి, మీరు .sfa ఫైల్‌లోని వచనాన్ని సవరించడం ద్వారా దాని రూపాన్ని మార్చవచ్చు.

వ్రాసే సమయంలో, సీన్‌ఫార్మ్ ప్లగ్ఇన్ ఇంకా బీటాలో ఉందని తెలుసుకోండి, కాబట్టి ఈ ప్లగ్‌ఇన్‌ను ఉపయోగిస్తున్నప్పుడు మీరు దోషాలు, లోపాలు లేదా ఇతర వింత ప్రవర్తనను ఎదుర్కొంటారు.

దృశ్య రూప ప్లగ్‌ఇన్‌ను ఇన్‌స్టాల్ చేస్తోంది

సీన్‌ఫార్మ్ ప్లగిన్‌కు Android స్టూడియో 3.1 లేదా అంతకంటే ఎక్కువ అవసరం. మీరు ఉపయోగిస్తున్న Android స్టూడియో యొక్క ఏ వెర్షన్ మీకు తెలియకపోతే, టూల్ బార్ నుండి “Android స్టూడియో> Android స్టూడియో గురించి” ఎంచుకోండి. తరువాతి పాపప్‌లో మీ Android స్టూడియో ఇన్‌స్టాలేషన్ గురించి దాని సంస్కరణ సంఖ్యతో సహా కొన్ని ప్రాథమిక సమాచారం ఉంది.

దృశ్య రూప ప్లగ్‌ఇన్‌ను ఇన్‌స్టాల్ చేయడానికి:

• మీరు Mac లో ఉంటే, Android స్టూడియో టూల్ బార్ నుండి “Android స్టూడియో> ప్రాధాన్యతలు…” ఎంచుకోండి, ఆపై ఎడమ చేతి మెను నుండి “ప్లగిన్లు” ఎంచుకోండి. మీరు Windows PC లో ఉంటే, “ఫైల్> సెట్టింగులు> ప్లగిన్లు> రిపోజిటరీలను బ్రౌజ్ చేయండి” ఎంచుకోండి.
• “సీన్‌ఫార్మ్” కోసం శోధించండి. “గూగుల్ సీన్‌ఫార్మ్ టూల్స్” కనిపించినప్పుడు, “ఇన్‌స్టాల్ చేయి” ఎంచుకోండి.
• ప్రాంప్ట్ చేసినప్పుడు Android స్టూడియోని పున art ప్రారంభించండి మరియు మీ ప్లగ్ఇన్ ఉపయోగించడానికి సిద్ధంగా ఉంటుంది.

దృశ్య రూప UX మరియు జావా 8: మీ ప్రాజెక్ట్ డిపెండెన్సీలను నవీకరిస్తోంది

ఈ ప్రాజెక్ట్ అంతటా మేము ఉపయోగిస్తున్న డిపెండెన్సీలను జోడించడం ద్వారా ప్రారంభిద్దాం. మీ మాడ్యూల్-స్థాయి బిల్డ్.గ్రాడిల్ ఫైల్‌ను తెరిచి, మా లేఅవుట్‌లో మేము ఉపయోగిస్తున్న ఆర్‌ఫ్రాగ్‌మెంట్‌ను కలిగి ఉన్న సీన్‌ఫార్మ్ యుఎక్స్ లైబ్రరీని జోడించండి:

డిపెండెన్సీలు {ఇంప్లిమెంటేషన్ ఫైల్ ట్రీ (dir: libs, include :) అమలు androidx.appcompat: appcompat: 1.0.2 అమలు androidx.constraintlayout: constintlayout: 1.1.3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: ఎస్ప్రెస్సో-కోర్: 3.1.1 // సీన్‌ఫార్మ్ UX UX వనరులను అందిస్తుంది, వీటిలో అర్ఫ్రాగ్మెంట్ // అమలు "com.google.ar.sceneform.ux: దృశ్య రూపం- ux: 1.7.0" అమలు "com. android.support:appcompat-v7:28.0.0 "}

సీన్ఫార్మ్ జావా 8 నుండి భాషా నిర్మాణాలను ఉపయోగిస్తుంది, కాబట్టి మేము మా ప్రాజెక్ట్ యొక్క మూల అనుకూలత మరియు లక్ష్య అనుకూలతను జావా 8 కు నవీకరించాలి:

కంపైల్ ఆప్షన్స్ {సోర్స్ కాంపాబిలిటీ జావావర్షన్. VERSION_1_8 టార్గెట్ కాంపాబిలిటీ జావావర్షన్. VERSION_1_8}

చివరగా, మేము సీన్ఫార్మ్ ప్లగిన్ను వర్తింపజేయాలి:

ప్లగ్ఇన్ వర్తించు: com.google.ar.sceneform.plugin

మీరు పూర్తి చేసిన బిల్డ్.గ్రాడిల్ ఫైల్ ఇలా ఉండాలి:

ప్లగ్‌ఇన్‌ను వర్తింపజేయండి: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.arcoredemo" minSdkVersion 23 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "androidx.test.runc. JavaVersion.VERSION_1_8} buildTypes {release {minifyEnabled false proguardFiles getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} డిపెండెన్సీలు {అమలు ఫైల్ ట్రీ (dir: libs, include :) అమలు androidx.appcompat .2 అమలు androidx.constraintlayout: constintlayout: 1.1.3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1 అమలు "com.google. ar.sceneform.ux: sceneform-ux: 1.7.0 "అమలు" com.android.support:appcompat-v7:28.0.0 "plug ప్లగ్ఇన్ వర్తించు: com.google.ar .sceneform.plugin

ఆర్ఫ్రాగ్‌మెంట్‌తో అనుమతులను అభ్యర్థిస్తోంది

మా అనువర్తనం పరికరం యొక్క కెమెరాను దాని పరిసరాలను విశ్లేషించడానికి మరియు 3D మోడళ్లను వాస్తవ ప్రపంచంలో ఉంచడానికి ఉపయోగిస్తుంది. మా అప్లికేషన్ కెమెరాను యాక్సెస్ చేయడానికి ముందు, దీనికి కెమెరా అనుమతి అవసరం, కాబట్టి మీ ప్రాజెక్ట్ యొక్క మానిఫెస్ట్ తెరిచి, కింది వాటిని జోడించండి:

ఆండ్రాయిడ్ 6.0 వినియోగదారులకు అనుమతి-అనుమతి అనుమతి ఆధారంగా అనుమతులను మంజూరు, తిరస్కరించడం మరియు ఉపసంహరించుకునే సామర్థ్యాన్ని ఇచ్చింది. ఇది వినియోగదారు అనుభవాన్ని మెరుగుపరిచినప్పటికీ, Android డెవలపర్లు ఇప్పుడు రన్‌టైమ్‌లో మాన్యువల్‌గా అనుమతులను అభ్యర్థించాలి మరియు వినియోగదారు ప్రతిస్పందనను నిర్వహించాలి. శుభవార్త ఏమిటంటే, Google ARCore లో పనిచేసేటప్పుడు, కెమెరా అనుమతి కోసం అభ్యర్థించే మరియు వినియోగదారు ప్రతిస్పందనను నిర్వహించే ప్రక్రియ అమలు చేయబడుతుంది స్వయంచాలకంగా.

ARFragment భాగం మీ అనువర్తనానికి కెమెరా అనుమతి ఉందో లేదో స్వయంచాలకంగా తనిఖీ చేస్తుంది మరియు AR సెషన్‌ను సృష్టించే ముందు అవసరమైతే దాన్ని అభ్యర్థిస్తుంది. మేము మా అనువర్తనంలో అర్ఫ్రాగ్‌మెంట్‌ను ఉపయోగిస్తున్నందున, కెమెరా అనుమతి కోసం అభ్యర్థించడానికి మేము ఏ కోడ్‌ను వ్రాయవలసిన అవసరం లేదు.

AR అవసరం లేదా ఐచ్ఛికమా?

AR కార్యాచరణను ఉపయోగించే రెండు రకాల అనువర్తనాలు ఉన్నాయి:

1. AR అవసరం

మంచి యూజర్ అనుభవాన్ని అందించడానికి మీ అప్లికేషన్ Google ARCore పై ఆధారపడినట్లయితే, అది ARCore కి మద్దతిచ్చే పరికరాలకు మాత్రమే డౌన్‌లోడ్ చేయబడిందని మీరు నిర్ధారించుకోవాలి. మీరు మీ అనువర్తనాన్ని “AR అవసరం” అని గుర్తించినట్లయితే, పరికరం ARCore కి మద్దతు ఇస్తే అది Google Play స్టోర్‌లో మాత్రమే కనిపిస్తుంది.

మా అప్లికేషన్ నుండి చేస్తుంది ARCore అవసరం, మానిఫెస్ట్ తెరిచి కింది వాటిని జోడించండి:

సిద్ధాంతంలో ARCore కి మద్దతిచ్చే పరికరానికి మీ అప్లికేషన్ డౌన్‌లోడ్ అయ్యే అవకాశం కూడా ఉంది, అయితే వాస్తవానికి ARCore ఇన్‌స్టాల్ చేయబడలేదు. మేము మా అనువర్తనాన్ని “AR అవసరం” అని గుర్తించిన తర్వాత, Google Play మీ అనువర్తనంతో పాటు ARCore ను స్వయంచాలకంగా డౌన్‌లోడ్ చేసి, ఇన్‌స్టాల్ చేస్తుంది, ఇది లక్ష్య పరికరంలో ఇప్పటికే లేనట్లయితే.

మీ అనువర్తనం Android అయినప్పటికీ: అవసరం = ”true” అని మీరు తెలుసుకోండి ఇప్పటికీ మీ అనువర్తనాన్ని డౌన్‌లోడ్ చేసినప్పటి నుండి వినియోగదారు ARCore ని అన్‌ఇన్‌స్టాల్ చేసే అవకాశం ఉన్నందున, లేదా ARCore యొక్క సంస్కరణ పాతది అని రన్‌టైమ్‌లో ARCore ఉందో లేదో తనిఖీ చేయాలి.

శుభవార్త ఏమిటంటే, మేము ఆర్ఫ్రాగ్‌మెంట్‌ను ఉపయోగిస్తున్నాము, ఇది ARCore ఇన్‌స్టాల్ చేయబడిందని మరియు సృష్టించే ముందు తాజాగా ఉందని స్వయంచాలకంగా తనిఖీ చేస్తుంది ప్రతి AR సెషన్ - కాబట్టి మరోసారి, ఇది మేము మానవీయంగా అమలు చేయవలసిన అవసరం లేదు.

2. AR ఐచ్ఛికం

మీ అనువర్తనం AR యొక్క లక్షణాలను కలిగి ఉంటే, దాని ప్రధాన కార్యాచరణను అందించడానికి అవసరం లేదు, అప్పుడు మీరు ఈ అనువర్తనాన్ని “AR ఐచ్ఛికం” అని గుర్తించవచ్చు. మీ అనువర్తనం Google ARCore రన్‌టైమ్‌లో ఉందో లేదో తనిఖీ చేయవచ్చు మరియు దాని డిసేబుల్ చెయ్యండి ARCore కు మద్దతు ఇవ్వని పరికరాల్లో AR లక్షణాలు.

మీరు “AR ఆప్షనల్” అనువర్తనాన్ని సృష్టిస్తే, ARCore అవుతుంది కాదు ARCore కు మద్దతు ఇవ్వడానికి అవసరమైన అన్ని హార్డ్‌వేర్ మరియు సాఫ్ట్‌వేర్‌లను పరికరం కలిగి ఉన్నప్పటికీ, మీ అనువర్తనంతో పాటు స్వయంచాలకంగా ఇన్‌స్టాల్ చేయండి. మీ “AR ఆప్షనల్” అనువర్తనం ARCore ఉందా మరియు తాజాగా ఉందో లేదో తనిఖీ చేయాలి మరియు అవసరమైనప్పుడు మరియు తాజా వెర్షన్‌ను డౌన్‌లోడ్ చేయండి.

ARCore మీ అనువర్తనానికి కీలకం కాకపోతే, మీరు ఈ క్రింది వాటిని మీ మానిఫెస్ట్‌లో చేర్చవచ్చు:

నేను మానిఫెస్ట్ తెరిచినప్పుడు, మెయిన్ఆక్టివిటీ ధోరణి మార్పులను సరసముగా నిర్వహిస్తుందని నిర్ధారించడానికి నేను Android: configChanges మరియు android: screenOrientation ను కూడా జతచేస్తున్నాను.

ఇవన్నీ మీ మానిఫెస్ట్‌లో జోడించిన తర్వాత, పూర్తి చేసిన ఫైల్ ఇలా ఉండాలి:

మీ లేఅవుట్కు అర్ఫ్రాగ్మెంట్ జోడించండి

నేను ARCore యొక్క ArFragment ను ఉపయోగిస్తాను, ఎందుకంటే ఇది ప్రతి AR సెషన్ ప్రారంభంలో అనేక కీలకమైన ARCore పనులను స్వయంచాలకంగా నిర్వహిస్తుంది. మరీ ముఖ్యంగా, ARCore యొక్క అనుకూలమైన సంస్కరణ పరికరంలో ఇన్‌స్టాల్ చేయబడిందని మరియు అనువర్తనానికి ప్రస్తుతం కెమెరా అనుమతి ఉందని అర్ఫ్రాగ్మెంట్ తనిఖీ చేస్తుంది.

పరికరం మీ అనువర్తనం యొక్క AR లక్షణాలకు మద్దతు ఇస్తుందని ArFragment ధృవీకరించిన తర్వాత, ఇది ArSceneView ARCore సెషన్‌ను సృష్టిస్తుంది మరియు మీ అనువర్తనం యొక్క AR అనుభవం వెళ్ళడానికి సిద్ధంగా ఉంది!

మీరు సాధారణ Android ఫ్రాగ్మెంట్ మాదిరిగానే ఆర్ఫ్రాగ్మెంట్ భాగాన్ని లేఅవుట్ ఫైల్‌కు జోడించవచ్చు, కాబట్టి మీ activity_main.xml ఫైల్‌ను తెరిచి “com.google.ar.sceneform.ux.ArFragment” భాగాన్ని జోడించండి.

Google పాలిని ఉపయోగించి 3D మోడళ్లను డౌన్‌లోడ్ చేస్తోంది

మీరు రెండరబుల్స్ సృష్టించడానికి అనేక మార్గాలు ఉన్నాయి, కానీ ఈ వ్యాసంలో మేము 3D ఆస్తి ఫైల్‌ని ఉపయోగిస్తాము.

యానిమేషన్లతో లేదా లేకుండా .OBJ, .glTF మరియు .FBX ఫార్మాట్లలో 3 డి ఆస్తులకు సీన్ఫార్మ్ మద్దతు ఇస్తుంది. ఈ మద్దతు ఉన్న ఫార్మాట్లలో ఒకదానిలో మీరు 3D మోడళ్లను పొందగల స్థలాలు చాలా ఉన్నాయి, కానీ ఈ ట్యుటోరియల్‌లో నేను గూగుల్ పాలీ రిపోజిటరీ నుండి డౌన్‌లోడ్ చేసిన .OBJ ఫైల్‌ను ఉపయోగిస్తాను.

పాలీ వెబ్‌సైట్‌కు వెళ్ళండి మరియు మీరు ఉపయోగించాలనుకుంటున్న ఆస్తిని .OBJ ఆకృతిలో డౌన్‌లోడ్ చేయండి (నేను ఈ టి-రెక్స్ మోడల్‌ను ఉపయోగిస్తున్నాను).

• మీ మోడల్ యొక్క మూల ఆస్తి ఫైల్ (.OBJ, .FBX, లేదా .glTF) కలిగి ఉన్న ఫోల్డర్‌ను అన్జిప్ చేయండి. మోడల్‌పై ఆధారపడి, ఈ ఫోల్డర్‌లో .mtl, .bin, .png, లేదా .jpeg ఫార్మాట్లలోని ఫైల్‌లు వంటి కొన్ని మోడల్ డిపెండెన్సీలు కూడా ఉండవచ్చు.

ఆండ్రాయిడ్ స్టూడియోలోకి 3 డి మోడళ్లను దిగుమతి చేస్తోంది

మీరు మీ ఆస్తిని కలిగి ఉంటే, మీరు దానిని సీన్ఫార్మ్ ప్లగ్ఇన్ ఉపయోగించి Android స్టూడియోలోకి దిగుమతి చేయాలి. ఇది మీకు అవసరమైన బహుళ-దశల ప్రక్రియ:

• “నమూనా డేటా” ఫోల్డర్‌ను సృష్టించండి. నమూనా సమయం అనేది మీ APK లో చేర్చబడని డిజైన్ సమయం నమూనా డేటా కోసం కొత్త ఫోల్డర్ రకం, కానీ Android స్టూడియో ఎడిటర్‌లో అందుబాటులో ఉంటుంది.
• అసలు .OBJ ఆస్తి ఫైల్‌ను మీ “నమూనా డేటా” ఫోల్డర్‌లోకి లాగండి.
• .OBJ ఫైల్‌లో దృశ్య రూప దిగుమతి మరియు మార్పిడిని జరుపుము, ఇది .sfa మరియు .sfb ఫైళ్ళను ఉత్పత్తి చేస్తుంది.

ఇది మరింత సూటిగా అనిపించినప్పటికీ, లేదు .OBJ ఫైల్‌ను నేరుగా మీ ప్రాజెక్ట్ యొక్క “res” డైరెక్టరీలోకి లాగండి మరియు డ్రాప్ చేయండి, ఎందుకంటే ఇది మోడల్‌ను మీ APK లో అనవసరంగా చేర్చడానికి కారణమవుతుంది.

Android స్టూడియో ప్రాజెక్ట్‌లు డిఫాల్ట్‌గా “నమూనాడేటా” ఫోల్డర్‌ను కలిగి ఉండవు, కాబట్టి మీరు మానవీయంగా ఒకదాన్ని సృష్టించాలి:

• మీ ప్రాజెక్ట్ యొక్క “అనువర్తనం” ఫోల్డర్‌ను నియంత్రించండి-క్లిక్ చేయండి.
• “క్రొత్త> నమూనా డేటా డైరెక్టరీ” ఎంచుకోండి మరియు “నమూనా డేటా” అనే ఫోల్డర్‌ను సృష్టించండి.
• మీరు ఇంతకు ముందు డౌన్‌లోడ్ చేసిన 3D మోడల్ ఫైల్‌లకు నావిగేట్ చేయండి. మూల ఆస్తి ఫైల్‌ను (.OBJ, .FBX, లేదా .glTF) కనుగొని, ఆపై దాన్ని “నమూనా డేటా” డైరెక్టరీలోకి లాగండి.
• మీ మోడల్‌కు ఏదైనా డిపెండెన్సీలు ఉన్నాయా అని తనిఖీ చేయండి (.mtl, .bin, .png, లేదా .jpeg ఫార్మాట్లలోని ఫైల్‌లు వంటివి). మీరు ఈ ఫైళ్ళలో దేనినైనా కనుగొంటే, వాటిని “నమూనా డేటా” ఫోల్డర్‌లోకి లాగండి.
• Android స్టూడియోలో, మీ 3D మోడల్ సోర్స్ ఫైల్‌ను (.OBJ, .FBX, లేదా .glTF) కంట్రోల్-క్లిక్ చేసి, ఆపై “దిగుమతి దృశ్య ఆస్తులను” ఎంచుకోండి.

• తరువాతి విండో సీన్ఫార్మ్ ఉత్పత్తి చేయబోయే ఫైళ్ళ గురించి కొంత సమాచారాన్ని ప్రదర్శిస్తుంది, ఫలితంగా .sfa ఫైల్ మీ ప్రాజెక్ట్‌లో నిల్వ చేయబడుతుంది; నేను “ముడి” డైరెక్టరీని ఉపయోగించబోతున్నాను.
• మీరు నమోదు చేసిన సమాచారంతో మీరు సంతోషంగా ఉన్నప్పుడు, “ముగించు” క్లిక్ చేయండి.

ఈ దిగుమతి మీ ప్రాజెక్ట్‌లో కొన్ని మార్పులు చేస్తుంది. మీరు మీ బిల్డ్.గ్రాడిల్ ఫైల్‌ను తెరిస్తే, అప్పుడు సీన్ఫార్మ్ ప్లగ్ఇన్ ప్రాజెక్ట్ డిపెండెన్సీగా జోడించబడిందని మీరు చూస్తారు:

డిపెండెన్సీలు {క్లాస్‌పాత్ com.android.tools.build:gradle:3.5.0-alpha06 క్లాస్‌పాత్ com.google.ar.sceneform: ప్లగ్ఇన్: 1.7.0 // గమనిక: మీ అప్లికేషన్ డిపెండెన్సీలను ఇక్కడ ఉంచవద్దు; అవి వ్యక్తిగత మాడ్యూల్ బిల్డ్.గ్రాడిల్ ఫైళ్ళలో // చెందినవి}}

మీ మాడ్యూల్-స్థాయి బిల్డ్.గ్రాడిల్ ఫైల్‌ను తెరవండి మరియు మీరు దిగుమతి చేసుకున్న 3 డి మోడల్ కోసం కొత్త సీన్‌ఫార్మ్.సెట్ () ఎంట్రీని కనుగొంటారు:

ప్లగ్‌ఇన్‌ను వర్తింపజేయండి: com.google.ar.sceneform.plugin // దిగుమతి సమయంలో మీరు పేర్కొన్న “మూల ఆస్తి మార్గం” // sceneform.asset (sampledata / dinosaur.obj, // దిగుమతి సమయంలో మీరు పేర్కొన్న “మెటీరియల్ మార్గం” // డిఫాల్ట్ , // దిగుమతి సమయంలో మీరు పేర్కొన్న “.sfa అవుట్పుట్ మార్గం” // sampledata / dinosaur.sfa, // దిగుమతి సమయంలో మీరు పేర్కొన్న “.sfb అవుట్పుట్ మార్గం” // src / main / assets / dinosaur)

మీరు మీ “నమూనా డేటా” మరియు “ముడి” ఫోల్డర్‌లను పరిశీలించినట్లయితే, అవి వరుసగా కొత్త .sfa మరియు .sfb ఫైళ్ళను కలిగి ఉన్నాయని మీరు చూస్తారు.

Android స్టూడియో యొక్క క్రొత్త దృశ్య రూప వీక్షకుడిలో మీరు .sfa ఫైల్‌ను ప్రివ్యూ చేయవచ్చు:

• Android స్టూడియో మెను బార్ నుండి “వీక్షణ> సాధనాలు విండోస్> వ్యూయర్” ఎంచుకోండి.
• ఎడమ చేతి మెనులో, మీ .sfa ఫైల్‌ను ఎంచుకోండి. మీ 3D మోడల్ ఇప్పుడు వ్యూయర్ విండోలో కనిపిస్తుంది.

మీ 3D మోడల్‌ను ప్రదర్శించండి

మా తదుపరి పని దాని పరిసరాలను అర్థం చేసుకునే AR సెషన్‌ను సృష్టించడం మరియు 3 డి మోడళ్లను వృద్ధి చెందిన సన్నివేశంలో ఉంచడానికి వినియోగదారుని అనుమతిస్తుంది.

దీనికి మేము ఈ క్రింది వాటిని చేయాల్సిన అవసరం ఉంది:

1. ఆర్ఫ్రాగ్మెంట్ సభ్యుల వేరియబుల్ సృష్టించండి

AR సెషన్‌ను రూపొందించడంలో భారీగా ఎత్తే పనిని ఆర్ఫ్రాగ్‌మెంట్ చేస్తుంది, కాబట్టి మేము ఈ భాగాన్ని మా మెయిన్ యాక్టివిటీ క్లాస్ అంతటా ప్రస్తావిస్తాము.

కింది స్నిప్పెట్‌లో, నేను అర్ఫ్రాగ్మెంట్ కోసం సభ్యుల వేరియబుల్‌ను సృష్టిస్తున్నాను మరియు దానిని ఆన్‌క్రియేట్ () పద్ధతిలో ప్రారంభిస్తున్నాను:

ప్రైవేట్ ఆర్ఫ్రాగ్మెంట్ arCoreFragment; Ver ఓవర్రైడ్ రక్షిత శూన్యత ఆన్‌క్రియేట్ (బండిల్ సేవ్ఇన్‌స్టాన్స్‌స్టేట్) {super.onCreate (saveInstanceState); ... ... ...} setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // శకలం నిర్వాహకుడిని ఉపయోగించి భాగాన్ని కనుగొనండి // getSupportFragmentManager (). findFragmentById (R.id.main_fragment);

2. మోడల్‌రెండరబుల్‌ను రూపొందించండి

మేము ఇప్పుడు మా .sfb ఫైల్‌ను మోడల్‌రెండరబుల్‌గా మార్చాలి, ఇది చివరికి మా 3D ఆబ్జెక్ట్‌ను అందిస్తుంది.

ఇక్కడ, నేను నా ప్రాజెక్ట్ యొక్క res / raw / dinosaur .sfb ఫైల్ నుండి మోడల్‌రెండరబుల్‌ను సృష్టిస్తున్నాను.

ప్రైవేట్ మోడల్‌రెండరబుల్ డైనోరెండరబుల్; ... ... ... ModelRenderable.builder () .సెట్‌సోర్స్ (ఇది, R.raw.dinosaur) .బిల్డ్ () .అప్పుడు అంగీకరించు (రెండరబుల్ -> dinoRenderable = రెండరబుల్). అసాధారణంగా (త్రోయబుల్ -> {Log.e ( TAG, "రెండరబుల్‌ను లోడ్ చేయడం సాధ్యం కాలేదు"); శూన్యంగా తిరిగి;}); }

3. వినియోగదారు ఇన్‌పుట్‌కు ప్రతిస్పందించండి

ట్యాప్, డ్రాగ్, చిటికెడు మరియు ట్విస్ట్ హావభావాలకు ఆర్ఫ్రాగ్మెంట్ అంతర్నిర్మిత మద్దతును కలిగి ఉంది.

మా అనువర్తనంలో, వినియోగదారు ఆ విమానానికి ట్యాప్ ఇవ్వడం ద్వారా ARCore విమానానికి 3D మోడల్‌ను జోడిస్తారు.

ఈ కార్యాచరణను అందించడానికి, విమానం ట్యాప్ చేయబడినప్పుడల్లా మేము బ్యాక్‌బ్యాక్‌ను నమోదు చేయాలి:

arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plane plane, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;}

4. మీ మోడల్‌ను ఎంకరేజ్ చేయండి

ఈ దశలో, మేము ఆర్స్సీన్ వ్యూను తిరిగి పొందబోతున్నాము మరియు దానిని యాంకర్నోడ్కు అటాచ్ చేయబోతున్నాము, ఇది దృశ్యం యొక్క మాతృ నోడ్ వలె ఉపయోగపడుతుంది.

పరికరం యొక్క కెమెరా చిత్రాలను రెండరింగ్ చేయడం మరియు AR అనుభవాన్ని ప్రారంభించడానికి వినియోగదారు వారి పరికరాన్ని ఎలా పట్టుకోవాలి మరియు తరలించాలో చూపించే ఒక సీన్ఫార్మ్ UX యానిమేషన్‌ను ప్రదర్శించడం వంటి అనేక ముఖ్యమైన ARCore పనులను నిర్వహించడానికి ArSceneView బాధ్యత వహిస్తుంది. ArSceneView అది కనుగొన్న ఏ విమానాలను కూడా హైలైట్ చేస్తుంది, వినియోగదారు వారి 3D మోడళ్లను సన్నివేశంలో ఉంచడానికి సిద్ధంగా ఉంది.

ARSceneView భాగం దానికి ఒక దృశ్యం జతచేయబడింది, ఇది అన్వయించాల్సిన అన్ని నోడ్‌లను కలిగి ఉన్న తల్లిదండ్రుల-పిల్లల డేటా నిర్మాణం.

యాంకర్నోడ్ రకం నోడ్‌ను సృష్టించడం ద్వారా మేము ప్రారంభించబోతున్నాము, ఇది మా ఆర్స్‌సీన్ వ్యూ యొక్క మాతృ నోడ్‌గా పనిచేస్తుంది.

అన్ని యాంకర్ నోడ్‌లు ఒకే వాస్తవ ప్రపంచ స్థితిలో ఉంటాయి, కాబట్టి యాంకర్ నోడ్‌ను సృష్టించడం ద్వారా మా 3D నమూనాలు వృద్ధి చెందిన సన్నివేశంలో స్థిరంగా ఉంటాయని మేము నిర్ధారిస్తున్నాము.

మన యాంకర్ నోడ్‌ను సృష్టిద్దాం:

యాంకర్నోడ్ యాంకర్నోడ్ = కొత్త యాంకర్నోడ్ (యాంకర్);

GetArSceneView () ను ఉపయోగించి మేము ఒక ArSceneView ని తిరిగి పొందవచ్చు మరియు దానిని యాంకర్నోడ్‌కు అటాచ్ చేయవచ్చు:

anchorNode.setParent (arCoreFragment.getArSceneView () getScene ().);

5. కదిలే, స్కేలింగ్ మరియు తిరిగే మద్దతును జోడించండి

తరువాత, నేను ట్రాన్స్ఫార్మబుల్ నోడ్ రకం నోడ్ని సృష్టించబోతున్నాను. వినియోగదారు హావభావాల ఆధారంగా నోడ్‌లను తరలించడానికి, స్కేలింగ్ చేయడానికి మరియు తిప్పడానికి ట్రాన్స్ఫార్మబుల్నోడ్ బాధ్యత వహిస్తుంది.

మీరు ట్రాన్స్‌ఫార్మబుల్ నోడ్‌ను సృష్టించిన తర్వాత, మీరు దీన్ని రెండరబుల్‌గా అటాచ్ చేయవచ్చు, ఇది వినియోగదారు ఇంటరాక్షన్ ఆధారంగా మోడల్‌కు స్కేల్ మరియు కదిలే సామర్థ్యాన్ని ఇస్తుంది. చివరగా, మీరు ట్రాన్స్ఫార్మబుల్ నోడ్ను యాంకర్నోడ్కు కనెక్ట్ చేయాలి, పిల్లల-తల్లిదండ్రుల సంబంధంలో, ఇది ట్రాన్స్ఫార్మబుల్ నోడ్ను నిర్ధారిస్తుంది మరియు విస్తరించిన సన్నివేశంలో రెండరబుల్ స్థిరంగా ఉంటుంది.

ట్రాన్స్ఫార్మబుల్నోడ్ ట్రాన్స్ఫార్మబుల్నోడ్ = కొత్త ట్రాన్స్ఫార్మబుల్నోడ్ (arCoreFragment.getTransformationSystem ()); // ట్రాన్స్‌ఫార్మబుల్ నోడ్‌ను యాంకర్‌నోడ్‌కు కనెక్ట్ చేయండి // ట్రాన్స్‌ఫార్మబుల్నోడ్.సెట్ పేరెంట్ (యాంకర్‌నోడ్); transformableNode.setRenderable (dinoRenderable); // నోడ్‌ను ఎంచుకోండి // ట్రాన్స్‌ఫార్మబుల్నోడ్.సెలెక్ట్ (); }); }

పూర్తయిన మెయిన్ యాక్టివిటీ

పైన పేర్కొన్నవన్నీ చేసిన తర్వాత, మీ మెయిన్ యాక్టివిటీ ఇలా ఉండాలి:

android.app.Activity దిగుమతి; android.app.ActivityManager దిగుమతి; androidx.appcompat.app.AppCompatActivity దిగుమతి; android.content.Context దిగుమతి; android.net.Uri దిగుమతి; android.os.Build దిగుమతి; android.os.Build.VERSION_CODES ను దిగుమతి చేయండి; android.os.Bundle దిగుమతి; android.util.Log దిగుమతి; android.view.MotionEvent దిగుమతి; androidx.annotation.RequiresApi దిగుమతి; దిగుమతి com.google.ar.core.Anchor; దిగుమతి com.google.ar.core.HitResult; దిగుమతి com.google.ar.core.Plane; దిగుమతి com.google.ar.sceneform.AnchorNode; దిగుమతి com.google.ar.sceneform.rendering.ModelRenderable; దిగుమతి com.google.ar.sceneform.ux.ArFragment; దిగుమతి com.google.ar.sceneform.ux.TransformableNode; పబ్లిక్ క్లాస్ మెయిన్ఆక్టివిటీ AppCompatActivity ని విస్తరిస్తుంది {ప్రైవేట్ స్టాటిక్ ఫైనల్ స్ట్రింగ్ TAG = MainActivity.class.getSimpleName (); ప్రైవేట్ స్టాటిక్ ఫైనల్ డబుల్ MIN_OPENGL_VERSION = 3.0; // మోడల్‌రెండరబుల్ // ప్రైవేట్ మోడల్‌రెండరబుల్ డైనోరెండరబుల్ కోసం సభ్యుల వేరియబుల్‌ను సృష్టించండి; // ఆర్ఫ్రాగ్మెంట్ కోసం సభ్యుల వేరియబుల్ సృష్టించండి // ప్రైవేట్ ఆర్ఫ్రాగ్మెంట్ ఆర్కోర్ ఫ్రాగ్మెంట్; EquRequiresApi (api = VERSION_CODES.N) ver ఓవర్‌రైడ్ రక్షిత శూన్యత onCreate (బండిల్ సేవ్ఇన్‌స్టాన్స్‌స్టేట్) {super.onCreate (saveInstanceState); if (! checkDevice ((ఇది))) {తిరిగి; } setContentView (R.layout.activity_main); arCoreFragment = (ArFragment) // శకలం నిర్వాహకుడిని ఉపయోగించి భాగాన్ని కనుగొనండి // getSupportFragmentManager (). findFragmentById (R.id.main_fragment); if (Build.VERSION.SDK_INT> = VERSION_CODES.N) {// మోడల్‌రెండరబుల్‌ను నిర్మించండి // ModelRenderable.builder () .సెట్‌సోర్స్ (ఇది, R.raw.dinosaur) .బిల్డ్ () ). అసాధారణంగా (// లోపం సంభవించినట్లయితే ... // విసిరివేయదగినది -> {//... తరువాత కింది వాటిని లాగ్‌క్యాట్ // లాగ్.ఇకి ముద్రించండి (TAG, "రెండరబుల్‌ను లోడ్ చేయడం సాధ్యం కాలేదు"); శూన్యంగా తిరిగి;} ); } // ఆన్‌టాప్ ఈవెంట్‌ల కోసం వినండి // arCoreFragment.setOnTapArPlaneListener ((HitResult hitResult, Plane plane, MotionEvent motionEvent) -> {if (dinoRenderable == null) {return;} యాంకర్ యాంకర్ = hitResult.createAnchor (); టైప్ యొక్క నోడ్ యాంకర్నోడ్ // యాంకర్నోడ్ యాంకర్నోడ్ = కొత్త యాంకర్నోడ్ (యాంకర్); // యాంకర్నోడ్ను దృశ్యానికి కనెక్ట్ చేయండి // anchorNode.setParent (arCoreFragment.getArSceneView (). getScene ()); // ట్రాన్స్ఫార్మబుల్ నోడ్ // ట్రాన్స్ఫార్మబుల్నోడ్ ట్రాన్స్ఫార్మబుల్నోడ్ = కొత్త ట్రాన్స్ఫార్మబుల్నోడ్ (arCoreFragment.getTransformationSystem ()); // ట్రాన్స్ఫార్మబుల్ నోడ్ను యాంకర్నోడ్కు కనెక్ట్ చేయండి // ట్రాన్స్ఫార్మబుల్నోడ్.సెట్ పేరెంట్ (యాంకర్నోడ్); // రెండరబుల్ అటాచ్ చేయండి // ట్రాన్స్ఫార్మబుల్నోడ్ / ట్రాన్స్‌ఫార్మబుల్ నోడ్.సెలెక్ట్ ();}); } పబ్లిక్ స్టాటిక్ బూలియన్ చెక్‌డెవిస్ (తుది కార్యాచరణ కార్యాచరణ) {// పరికరం ఆండ్రాయిడ్ మార్ష్‌మల్లో లేదా అంతకుముందు నడుస్తుంటే ... // if (Build.VERSION.SDK_INT <VERSION_CODES.N) {//...ఈ క్రింది వాటిని ప్రింట్ చేయండి లాగ్‌క్యాట్ // Log.e (TAG, "దృశ్య రూపానికి Android N లేదా అంతకంటే ఎక్కువ అవసరం"); activity.finish (); తప్పుడు తిరిగి; } స్ట్రింగ్ openGlVersionString = ((ActivityManager) activity.getSystemService (Context.ACTIVITY_SERVICE)) .getDeviceConfigurationInfo () // OpenGL ES // .getGlEsVersion (); // పరికరం OpenGL ES 3.0 కన్నా తక్కువ ఏదైనా నడుస్తుంటే ... // if (Double.parseDouble (openGlVersionString) <MIN_OPENGL_VERSION) {//..అప్పుడు కింది వాటిని Logcat // Log.e (TAG, " OpenGL ES 3.0 లేదా అంతకంటే ఎక్కువ అవసరం "); activity.finish (); తప్పుడు తిరిగి; true తిరిగి రావడం; }}

మీరు పూర్తి చేసిన ప్రాజెక్ట్‌ను గిట్‌హబ్ నుండి డౌన్‌లోడ్ చేసుకోవచ్చు.

మీ Google ARCore ఆగ్మెంటెడ్ రియాలిటీ అనువర్తనాన్ని పరీక్షిస్తోంది

మీరు ఇప్పుడు మీ అనువర్తనాన్ని భౌతిక, మద్దతు ఉన్న Android పరికరంలో పరీక్షించడానికి సిద్ధంగా ఉన్నారు. మీరు ARCore కి మద్దతిచ్చే పరికరాన్ని కలిగి ఉండకపోతే, మీ AR అనువర్తనాన్ని Android ఎమ్యులేటర్‌లో పరీక్షించడం సాధ్యమవుతుంది (కొంచెం అదనపు కాన్ఫిగరేషన్‌తో, మేము తదుపరి విభాగంలో కవర్ చేస్తాము).

మీ ప్రాజెక్ట్ను పరీక్షించడానికి a భౌతిక Android పరికరం:

• లక్ష్య పరికరంలో మీ అనువర్తనాన్ని ఇన్‌స్టాల్ చేయండి.
• ప్రాంప్ట్ చేసినప్పుడు, మీ పరికర కెమెరాకు అనువర్తన ప్రాప్యతను ఇవ్వండి.
• ARCore అనువర్తనాన్ని ఇన్‌స్టాల్ చేయడానికి లేదా నవీకరించమని ప్రాంప్ట్ చేయబడితే, “కొనసాగించు” నొక్కండి, ఆపై మీరు ARCore యొక్క తాజా మరియు గొప్ప సంస్కరణను నడుపుతున్నారని నిర్ధారించుకోవడానికి సంభాషణను పూర్తి చేయండి.
• మీరు ఇప్పుడు కెమెరా వీక్షణను చూడాలి, పరికరాన్ని పట్టుకున్న చేతి యానిమేషన్‌తో పూర్తి చేయండి. కెమెరాను చదునైన ఉపరితలం వద్ద సూచించండి మరియు యానిమేషన్ ద్వారా ప్రదర్శించబడినట్లుగా మీ పరికరాన్ని వృత్తాకార కదలికలో తరలించండి. కొన్ని క్షణాల తరువాత, ఒక విమానం కనుగొనబడిందని సూచిస్తూ వరుస చుక్కలు కనిపించాలి.

• ఈ చుక్కల స్థానం గురించి మీరు సంతోషంగా ఉన్న తర్వాత, వారికి నొక్కండి - మీ 3D మోడల్ ఇప్పుడు మీరు ఎంచుకున్న విమానంలో కనిపిస్తుంది!

• మోడల్ చుట్టూ భౌతికంగా కదలడానికి ప్రయత్నించండి; మీ పరిసరాలను బట్టి, మీరు దాని చుట్టూ 360 డిగ్రీలు పూర్తి చేయగలరు. వాస్తవ ప్రపంచ కాంతి వనరులకు అనుగుణమైన నీడను వస్తువు ప్రసారం చేస్తుందో లేదో మీరు తనిఖీ చేయాలి.

Android వర్చువల్ పరికరంలో ARCore ని పరీక్షిస్తోంది

Android వర్చువల్ పరికరం (AVD) లో మీ ARCore అనువర్తనాలను పరీక్షించడానికి, మీకు Android Emulator వెర్షన్ 27.2.9 లేదా అంతకంటే ఎక్కువ అవసరం. మీరు మీ AVD లోని Google Play స్టోర్‌లోకి కూడా సైన్ ఇన్ చేయాలి మరియు OpenGL ES 3.0 లేదా అంతకంటే ఎక్కువ ఎనేబుల్ చెయ్యాలి.

మీ AVD లో ప్రస్తుతం OpenGL ES 3.0 లేదా అంతకంటే ఎక్కువ ప్రారంభించబడిందో లేదో తనిఖీ చేయడానికి:

• మీ AVD ను సాధారణమైనదిగా ప్రారంభించండి.
• క్రొత్త టెర్మినల్ విండో (మాక్) లేదా కమాండ్ ప్రాంప్ట్ (విండోస్) తెరవండి.
• డైరెక్టరీని మార్చండి (“సిడి”) కాబట్టి టెర్మినల్ / కమాండ్ ప్రాంప్ట్ మీ Android SDK యొక్క “adb” ప్రోగ్రామ్ యొక్క స్థానాన్ని సూచిస్తుంది, ఉదాహరణకు నా ఆదేశం ఇలా ఉంటుంది:

Cd / Users / jessicathornsby / Library / Android / sdk / platform-tools

• మీ కీబోర్డ్‌లోని “ఎంటర్” కీని నొక్కండి.
• తదుపరి ఆదేశాన్ని టెర్మినల్‌లోకి కాపీ / పేస్ట్ చేసి, ఆపై “ఎంటర్” కీని నొక్కండి:

./adb లాగ్‌క్యాట్ | grep eglMakeCurrent

టెర్మినల్ “ver 3 0” లేదా అంతకంటే ఎక్కువ తిరిగి ఇస్తే, OpenGL ES సరిగ్గా కాన్ఫిగర్ చేయబడింది. టెర్మినల్ లేదా కమాండ్ ప్రాంప్ట్ 3.0 కంటే ముందు ఏదైనా ప్రదర్శిస్తే, మీరు OpenGL ES 3.0 ను ప్రారంభించాలి:

• మీ AVD కి తిరిగి మారండి.
• Android ఎమ్యులేటర్‌తో పాటు తేలియాడే “ఎక్స్‌టెండెడ్ కంట్రోల్” బటన్ల స్ట్రిప్‌ను కనుగొని, ఆపై “సెట్టింగులు> అధునాతన” ఎంచుకోండి.
• “OpenGL ES API స్థాయి> రెండరర్ గరిష్టంగా (OpenGL ES 3.1 వరకు)” నావిగేట్ చేయండి.
• ఎమ్యులేటర్ను పున art ప్రారంభించండి.

టెర్మినల్ / కమాండ్ ప్రాంప్ట్ విండోలో, కింది ఆదేశాన్ని కాపీ / పేస్ట్ చేసి, ఆపై “ఎంటర్” కీని నొక్కండి

./adb లాగ్‌క్యాట్ | grep eglMakeCurrent

మీరు ఇప్పుడు “ver 3 0” లేదా అంతకంటే ఎక్కువ ఫలితాన్ని పొందాలి, అంటే OpenGL ES సరిగ్గా కాన్ఫిగర్ చేయబడింది.

చివరగా, మీ AVD ARCore యొక్క సరికొత్త సంస్కరణను నడుపుతోందని నిర్ధారించుకోండి:

• ARCore యొక్క GitHub పేజీకి వెళ్ళండి మరియు ఎమ్యులేటర్ కోసం ARCore యొక్క తాజా విడుదలను డౌన్‌లోడ్ చేయండి. ఉదాహరణకు, ఇటీవలి విడుదల సమయంలో “ARCore_1.7.0.x86_for_emulator.apk”
• మీ నడుస్తున్న AVD లోకి APK ని లాగండి.

మీ ప్రాజెక్ట్‌ను AVD లో పరీక్షించడానికి, మీ అప్లికేషన్‌ను ఇన్‌స్టాల్ చేసి, ప్రాంప్ట్ చేసినప్పుడు AVD యొక్క “కెమెరా” కి ప్రాప్యతను ఇవ్వండి.

మీరు ఇప్పుడు అనుకరణ గది యొక్క కెమెరా వీక్షణను చూడాలి. మీ అనువర్తనాన్ని పరీక్షించడానికి, ఈ వర్చువల్ స్థలం చుట్టూ తిరగండి, అనుకరణ ఫ్లాట్ ఉపరితలాన్ని కనుగొని, ఈ ఉపరితలంపై ఒక నమూనాను ఉంచడానికి క్లిక్ చేయండి.

“ఆప్షన్” (మాకోస్) లేదా “ఆల్ట్” (లైనక్స్ లేదా విండోస్) కీలను నొక్కడం మరియు పట్టుకోవడం ద్వారా మీరు వర్చువల్ కెమెరాను వర్చువల్ గది చుట్టూ తరలించవచ్చు, ఆపై కింది కీబోర్డ్ సత్వరమార్గాలలో దేనినైనా ఉపయోగించవచ్చు:

• ఎడమ లేదా కుడి వైపుకు తరలించండి. A లేదా D నొక్కండి.
• క్రిందికి లేదా పైకి కదలండి. Q లేదా E నొక్కండి.
• ముందుకు లేదా వెనుకకు కదలండి. W లేదా S. నొక్కండి.

“ఆప్షన్” లేదా “ఆల్ట్” నొక్కడం ద్వారా మీ మౌస్ ఉపయోగించి మీరు వర్చువల్ సన్నివేశం చుట్టూ “కదలవచ్చు”. ఇది మొదట కొంచెం చిలిపిగా అనిపించవచ్చు, కానీ ఆచరణతో మీరు వర్చువల్ స్థలాన్ని విజయవంతంగా అన్వేషించగలుగుతారు. మీరు అనుకరణ విమానం కనుగొన్న తర్వాత, మీ 3D మోడల్‌ను ఈ ఉపరితలంపై ఉంచడానికి తెలుపు చుక్కలను క్లిక్ చేయండి.

చుట్టి వేయు

ఈ వ్యాసంలో, మేము ARCore మరియు Sceneform ప్లగ్‌ఇన్‌ను ఉపయోగించి సరళమైన ఆగ్మెంటెడ్ రియాలిటీ అనువర్తనాన్ని సృష్టించాము.

మీరు మీ స్వంత ప్రాజెక్టులలో Google ARCore ను ఉపయోగించాలని నిర్ణయించుకుంటే, ఈ క్రింది వ్యాఖ్యలలో మీ సృష్టిని ఖచ్చితంగా పంచుకోండి!