Sunday, December 20, 2020

Java Programming sinhala tutorial - 2D, 3D, ND Arrays - Part 23

2D, 3D, ND Arrays/ Multidimensional Arrays

    කලින් ලිපි වලින් අපි 1D arrays ගැන දැනගත්තනේ. අද අපි multidimensional arrays ගැන බලමු.

    එකම data type එකක් පවතින array කිහිපයක් single unit එකක් ලෙස represent කිරීම 2D Arrays කියලා සරලවම කියන්න පුළුවන්.



    2D array භාවිතා කිරීම මගින් data tabular format එකෙන් store කල හැක. ඉහත 2D array උදාහරණය අනුව N මගින් පේළි ගණන ද M මගින් තීරු ගණන ද ලබා ගත හැක. සියලු element ගණන M * N වේ. Nested loop භාවිතයෙන් 2D arrays පහසුවෙන් හැසිරවිය හැක.



    2D array එකක් int[][] y; ලෙස command කල විට variable stack එකේ array reference variable එක නිර්මාණය වේ. 
    y = new int[4][3]; ලෙස command කල විට variable 4 ක් සහිත array එකක් නිර්මාණය වේ. එසේම variable 3 ක් සහිත array 4 ක් එකක් නිර්මාණය වන අතර එම array වලට අදාල array address කලින් නිර්මාණය වූ variable 4 ක් සහිත array එකෙහි එක් එක් variable වල store වේ. variable 4 ක් සහිත array එකෙහි address එක y reference variable එකෙහි store වේ.




    3D array එකක variables RAM එකෙහි නිර්මාණය  වන ආකාරය පහත පරිදි වේ.

int[][][] z = new int[4][3][2];


    2D, 3D, ND array reference පහත පරිදි ලිවිය හැක.



    2D, 3D, ND array constructors පහත පරිදි ලිවිය හැක.



    2D array එකක length එක පහත පරිදි සෙවිය හැක. 2D array එකක length එක යනු එහි array ගණන වන අතර එහි එක් array එකක length එක යනු එම array එකෙහි element ගණන වේ.



    2D, 3D, ND array වල එක් එක් variable වල අගයන් පහත පරිදි assign කල හැක. Literals store කල හැකි variable වල literals පමණක් store කල හැකි අතර array reference tore කල හැකි variable වල array reference පමණක් store කල හැකි.


අපි ඊලග ලිපියෙන් Java ගැන තවත් විස්තර ඉගෙන ගනිමු.

- චමෝදි -

Wednesday, December 9, 2020

Java Programming sinhala tutorial - Array Sorting - Part 22

Array Sorting

    අද අපි බලමු array sorting කියන්නේ මොකද්ද කියලා. Array එකක variable වල value කුඩා අගයේ සිට විශාල අගය දක්වා සකස් කිරීම array sorting කියලා සරලවම කියන්න පුළුවන්. Sorting algorithms ගොඩක් තිබුනත් මම මේ ලිපියෙන් අද කියන්න යන්නේ ක්‍රම 2 ක් ගැන විතරයි. ඒ bubble sort හා selection sort ගැන.

Bubble Sort

    මෙහිදී array එකක එක ලග පවතින element 2 ක value සංසන්දනය කරමින් විශාල value එක සහිත element එක 2 වන element එක ලෙස swap කරයි. මෙම ක්‍රියාවලිය මුළු array එකම sort වන තෙක් සිදු කරයි.



Selection Sort

    Array එකක variable වල value sort කරන දෙවන ක්‍රමය මෙයයි. වැඩිම අගය සහිත index එක සොයා එය අවසාන variable එකට ද එම අවසාන variable එකේ අගය, විශාලම අගය පවතී variable එකටද මාරු කරයි. ඉන් පසු ඊළගට වැඩිම අගය සහිත index එක සොයා එය අවසාන variable එකට පෙර variable එකටද එම variable එකේ අගය, දෙවන විශාලම අගය පවතී variable එකටද මාරු කරයි. මෙලෙස මුළු array එකම sort වන තෙක් සිදු කරයි.


අපි ඊලග ලිපියෙන් Java ගැන තවත් විස්තර ඉගෙන ගනිමු.

- චමෝදි -

Saturday, December 5, 2020

Java Programming sinhala tutorial - Array Search - Part 21

Array Search

    අද අපි බලමු යම් කිසි array එකක දෙන ලද value එකක් තිබේද නැද්ද යන්න හා එම value එක පවතී නම් එය පවතින array index එක කොහොමද සොයාගන්නේ කියලා. සරලවම for loop එකක් භාවිතයෙන් අපිට මේ task එක කරන්න පුළුවන්.


    Array එකෙහි සොයනු ලබන අගය එක් වාරයකට වඩා පවතින විට එම අගය අවසන් වරට පවතින index එක ඉහත ක්‍රමය මගින් ලැබේ.

    පහත ක්‍රමය මගින් array එකෙහි සොයනු ලබන අගය එක් වාරයකට වඩා පවතින විට එම අගය පළමු වරට පවතින index එක ලබා ගත හැක. ඒ සදහා break keyword හෝ return keyword එක භාවිතා කළ හැක.

Using break Keyword
Using break Keyword

Using return Keyword
Using return Keyword

Binary Search

    Binary search ක්‍රමය පිලිවලට සකස් කල array එකක් (sorted array) සදහා පමණක් භාවිතා කල හැක. Array sorting algorithm ගැන අපි ඊළග ලිපියෙන් දැන ගමු. 

    මෙහිදී search කරනු ලබන value එක array එකෙහි භාගයක් සලකමින් නැවත නැවතත් සොයනු ලබයි. search කරනු ලබන value එක array එකෙහි මැද අගයට වඩා අඩු නම් array එකෙහි මුල් භාගය ඊළග වාරයේදී array එක ලෙස සලකනු ලබයි. එසේ නොමැති නම් array එකෙහි අග භාගය ඊළග වාරයේදී array එක ලෙස සලකනු ලබයි.





අපි ඊලග ලිපියෙන් Java sort ගැන විස්තර ඉගෙන ගනිමු.

- චමෝදි -

Sunday, November 29, 2020

Docker - Part 1 Introduction




Docker - Part 1 Introduction

අද මං කියලා දෙන්නම් container management service එකක් වෙන Docker ගැන. ඊට කලින් අපි බලමු මොනවද මේ container management service කියන්නෙ කියලා.  


Container management කියන්නෙ ගොඩක් software containers, organizing කරලා ඒවා එකට එකතු කරන්වා හෝ replace කරන වැඩේට. එතකොට මොනවද මේ container එකක් කියන්නෙ. container එකක් කියන්නෙ සරලවම කිව්වොත් aplications එකක් run කරන්න ඕනි වෙන code,files  සහ එහි සියලු  libraries, dependencies store කරන සම්මත software unit එකක්. එම නිසා application එකක් එක operating system ඉදලා තවත්  operating system  එකක වේගයෙන් හා විශ්වාසදායක ලෙස ක්‍රියාත්මක වෙන්න පුලුවන්. Linux සහ Windows මත පදනම් වූ applications සඳහා මේ  container ලබා ගත ගන්න පුලුවන්. ඒ වගේම computer එකේ තියෙන infrastuctures නොසලකා container එකකට සෑම විටම එකම ආකාරයකින් ක්‍රියාත්මක වෙන්නත් පුලුවන්. 


Container management කිර්‍රිම තුලින් අපිට enterprise applications deploy කිර්‍ර්ම් හා update කිර්‍ර්ම වේගවත් ලෙස කරගන්න පුලුවන්. Kubernetes සහ  Docker Swarm කියන්නෙ Container management software වලට උදාහරණ දෙකක්. 


හරී.


දැන් බලමු මොකක්ද මේ Docker කියන්නෙ කියලා. මං කලින් කිව්වා වගේ Docker කියන්නෙ container management service එකක්. Docker පාවිච්චි කරලා developersලට පුලුවන් application ලේසියෙන්ම develop කරලා ඕනිම තැනක deploy  කරන්න පුලුවන් වෙන විදියට containers වලට ඇතුල් කරන්න.


Docker පාවිච්චි කිරීමෙන් ලැබෙන වාසි


1. Container මගින් application develop කිර්‍ර්මට operating system එක තුල වැය වෙන ඉඩ අවකාශ   ප්‍රමාණය අඩු කරයි.
 
2. Container භාවිතා කිරීම මගින් විවිධ පද්දති(units) හරහා  development, QA සහ Operations කිරීමේ හැකියාව ලැබේ.


3. ඕනිම computer space එකක් තුල Docker container එකක් deploy කරන්න පුලුවන්. ඒ කියන්නෙ physcial machine එකක නැත්තන් virthual machine එකක එහෙමත් නැත්තන් computer cloud space එකක උනත් Docker container deploy එකක් කරන්න පුලුවන්.


4.  Docker container  එකක් සැහැල්ලු ඒ කිව්වෙ lightweighted නිසා අපිට ලේසියෙන් size එක අඩු වැඩි කර ගන්න පුලුවන්. පාවිච්චි කරන්න ලේසී.


Docker වල සං‍රචක(components)

  • Docker for Mac − Docker containers, Mac OS තුල run කිර්‍ර්මට උදව් වේ.
  • Docker for Linux − Docker containers, Linux OS තුල run කිර්‍ර්මට උදව් වේ. 
  • Docker for Windows − Docker containers, Windows OS තුල run කිර්‍ර්මට උදව් වේ. 
  • Docker Engine − Docker images සහ Docker containers සෑදීමට උදව් වේ.
  • Docker Hub −  විවිධ වර්ගයේ Docker images ඉදීරිපත් කිර්‍ර්මට උදව් වේ.
  • Docker Compose −  Docker containers ගොඩක් පාවිච්චි කරලා appliation define කිර්‍ර්මට උදව් වේ.
හරී.


මේ post එකෙන් මම ඔයාලට කියලා දුන්නෙ Docker කියන්නෙ මොකක්ද කියන එක. එහෙනම් ඊලග post වලදි Docker ගැන වැඩි විස්තර කතා කරමු.


--පියුමි--


Wednesday, November 25, 2020

Java Programming sinhala tutorial - For-each Loop - Part 20

Java Flow Control "For-each Loop"/ "Enhance Loop"

    Loops ගැන කලින් ලිපියක (part 11) විස්තර කරන අතර තුර For-each loop ගැන සදහන් කලත් වැඩිපුර විස්තර මේ ලිපියෙන් අපි අද දැනගමු. මිට කලින් ලිපි 2 මගින් අපි arrays ගැන දැනගත්තානේ. For-each loop භාවිතා කරනුයේ arrays පහසුවෙන් හැසිරවිමටයි. 

    For-each loop එක මගින් එම loop එකේ සදහන් කර ඇති array එකෙහි element වල value, index අනුපිළිවලින්, loop එක run වන වාරයක් පාසා loop body එකට ලබා දෙයි.


    For-each loop එකේදී අනුපිලිවලින් array එකෙහි value, loop එකෙහි variable එකට assign වේ. එම නිසා loop එක තුලදී එම අගයට වෙනස්කම් කලද array එකෙහි element එකෙහි value එකට බලපෑමක් ඇති නොවේ. ඊට හේතුව loop එක තුලදී modify කරනුයේ array element එකෙහි value එක පමණක් සහිත වෙනත් variable එකක් නිසාය.


    For-each loop එකෙහි variable type එක array එකෙහි array type එකට ගැලපීමට අවශ්‍ය වේ. එනම් loop එකෙහි variable එහෙහි data type එකෙහි range එක, array type එහෙහි range එකට වඩා විශාල හෝ සමාන විය යුතුය.



    For-each loop එකෙහි variable එක loop එක නිර්මාණය කරන විටම නිර්මාණය කල යුතු වේ.



අපි ඊලග ලිපියෙන් Java ගැන තවත් විස්තර ඉගෙන ගනිමු.

- චමෝදි -

Tuesday, November 24, 2020

JMonkey Engine - How to apply texture

අද අපි බලමු කොහොමද  texture  එකක්  apply  කර ගන්නේ කියල. මුලින්ම වෙනදා වගේ අළුත්  class එකක් හදා ගන්න. ඊට පස්සේ මේ පහළ තියෙන  code  එක copy paste කරන්න. මේ  code  එකින් කරන්නේ  box  එකක් හදලා එකට material  එකක් දාගෙන ඊට පස්සේ  texture එකක්  apply කරන එක. 

package hello3D.test;

import com.jme3.app.SimpleApplication;
import com.jme3.light.DirectionalLight;
import com.jme3.material.Material;
import com.jme3.util.TangentBinormalGenerator;
import com.jme3.scene.Geometry;
import com.jme3.scene.shape.Box;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Vector3f;

public class HelloMaterial extends SimpleApplication {

    public static void main(String[] args) {
        HelloMaterial app = new HelloMaterial();
        app.start();
    }

    @Override
    public void simpleInitApp() {

        Box cubeMesh = new Box(1f, 1f, 1f);
        Geometry cube1Geo = new Geometry("Shiny rock", cubeMesh);
        TangentBinormalGenerator.generate(cubeMesh);           // for lighting effect
        Material cubeMat = new Material(assetManager,
                "Common/MatDefs/Light/Lighting.j3md");
        cubeMat.setTexture("DiffuseMap",
                assetManager.loadTexture("Textures/Terrain/Pond/Pond.jpg"));
        cubeMat.setTexture("NormalMap",
                assetManager.loadTexture("Textures/Terrain/Pond/Pond_normal.png"));
        cubeMat.setBoolean("UseMaterialColors", true);
        cubeMat.setColor("Diffuse", ColorRGBA.White);
        cubeMat.setColor("Specular", ColorRGBA.White);
        cubeMat.setFloat("Shininess", 64f);  // [0,128]
        cube1Geo.setMaterial(cubeMat);
        cube1Geo.setLocalTranslation(0, 0, 2); // Move it a bit
        cube1Geo.rotate(1.6f, 5f, 2f);          // Rotate it a bit
        rootNode.attachChild(cube1Geo);
        /**
         * Must add a light to make the lit object visible!
         */
        DirectionalLight sun = new DirectionalLight();
        sun.setDirection(new Vector3f(1, 0, -2).normalizeLocal());
        sun.setColor(ColorRGBA.White);
        rootNode.addLight(sun);

    }
}

මෙන්න මේ ආකාරයට තමයි  cube  එක දිස් වෙන්නේ.






මම හිතනවා ඔයාලා දෙයක් ඉගෙන ගන්න ඇති කියල. තව පොස්ට් එකකින් හම්බ වෙමු.

-Hasini Senanayaka-

Sunday, November 22, 2020

Java Programming sinhala tutorial - Passing an Array into a Method - Part 19

Passing an Array into a Method

    අපි කලින් ලිපියෙන් arrays ගැන දැන ගත්තනේ. අද අපි බලමු method එකකට කොහොමද array එකක් යවන්නේ එහෙමත් නැත්තම් pass කරන්නේ කියලා.

    Method එකකට array එකක් pass කිරීම සදහා method එකට call කරන statement එකෙහි argument සදහා array address එක එහෙමත් නැත්තම් array name එක ලියනු ලබයි. Method එකේ parameter සදහා array reference variable එකක් නිර්මාණය  යුතු වේ.


Method Call by Value vs Reference

    Method එකට call කරන statement (method calling statement) එකෙහි argument සදහා array එකක variable යෙදු විට එම variable එකේ value එක පමණක් method එකට pass වේ. මෙමගින් array එකට බලපෑමක් ඇති නොවේ.



    Method calling statement එකෙහි argument සදහා array එකේ  address එක එහෙමත් නැත්තම් array name එක යෙදු විට  array එක modify කල හැක. ඊට හේතුව වනුයේ method එකට යැවු array address එකම method එක විසින් භාවිතා කරන නිසාත් එම array address එක එකම array object එක refer කිරීමත්ය.



තවත් Java ගැන ඉගෙන ගන්න ඊලග ලිපියෙන් හමුවෙමු.

- චමෝදි -

Sunday, November 15, 2020

Java Programming sinhala tutorial - Java Arrays - Part 18

 Java Arrays

    එකම data type එකේ variable කිහිපයක් single unit එකකින් represent කිරීමට java arrays භාවිතා කරයි. Program එකකදී int x0, x1, x2, x3; ලෙස command එක ලියු විට memory එක x0, x1, x2, x3 සදහා වෙන වෙනම space වෙන් කරයි. (variable stack එකේ වෙන වෙනම space වෙන් කරයි)

    මෙසේ නිර්මාණය කරන variable වෙන් වෙන් වශයෙන් පවතින නිසා loop එකකදී body එක run වන වාරය අනුව variable වෙනස් කළ නොහැක. 


මෙම ගැටලුව විසදීම සදහා java arrays නිර්මාණය කරයි.

ඉහත දක්වා ඇති command එක පරිදි x[0], x[1], x[2], ... ලෙස variable 10 ක් නිර්මාණය කල හැක.


    x යනු array name එක වේ. x හි array reference address එක store වන අතර array එකෙහි element වල value store කල යුතුය.


Memory Representation of an Array

    Array එකක් int[] x; හා x = new int[5]; ලෙස command 2 කින් නිර්මාණය කල හැක. මෙහිදී int[] x; command එක මගින් variable stack එකෙහි x නමින් reference variable එක තුල array address එක store  වේ. x = new int[5]; command එක මගින් memory heap එක තුල variable 5 ක් නිර්මාණය වන අතර එයට අදාල array address එක x නම් reference variable එක තුල store වේ.


Define an Array

  1. int[] x;   ➤   variable stack එකෙහි x නමින් reference variable එකක් නිර්මාණය වන අතර එහි reference address එක store  වේ.
  2. x = new int[5];   ➤   memory heap එක තුල variable/ element 5 ක් නිර්මාණය වන අතර x නම් reference variable එක තුල ඊට අදාල reference value එක store වේ.
  3. x[0] = 25;   ➤   x නම් reference variable එකෙන් refer කරනු ලබන address එකට අදාල 0 index එක තුල 25 value එක store වේ.

Array Reference & Constructions

    පහත පරිදි array declaration හා array construction කල හැක. 


Default Value

    Array object එකක් නිර්මාණය කරන විටදීම එය initialization වේ. එලෙස array element වලට store වන්නේ array object එකේ data type එකට අදාල default value එක වේ.

Array Length

    ඕනෑම array එකකට size එකක් පවතී. Size එක යනු එහි variable/ element ගණන වේ. මෙය runtime සොයා ගැනීම සදහා array_name.length ලෙස command කල යුතුය. මෙය predefine variable එකකි.


Array Index Error

    Array එකකට size එක compile කිරීමේදී සැලකිල්ලට නොගනී. Array එකක index එක 0 සිට array size එකට (variable ගණනට) වඩා 1ක් අඩු වන සංඛ්‍යාව දක්වා පවතී. Runtime array index ලිවීමේදී මෙය පිලිබදව සැලකිලිමත් විය යුතු වේ.


Array Reference Type

    Array එකක් නිර්මාණය කිරීමේදී array type එක array reference type එකට අනිවාර්යෙන්ම සමාන විය යුතු වේ.

Casting

    Primitive types හා reference types variable භාවිතයේදී පහත example එකේ පරිදි casting ගැන සැලකිලිමත් විය යුතු වේ.


Maximum array size and array index types

  • උපරිම array size එක int data type එකෙහි උපරිම අගය වේ. (2,147,483,647)
  • Array size එක සෘණ අගයක් ලෙස ලබා දුන් විට සෘණ ලකුණ නොසලකා එය ධන අගයක් ලෙස සලකයි.
  • Array size එක සදහා දශම සංඛ්‍යා ලබා දිය නොහැක. ඊට හේතු වනුයේ array size එකෙහි ප්‍රමාණයට අනුව array එකට අදාල variable නිර්මාණය කරන නිසාය.
  • Array index සදහා byte, short, int, char data type පමණක් භාවිතා කල හැකි අතර long, float, double, boolean data type භාවිතා කල නොහැක.

තවත් Java ගැන ඉගෙන ගන්න ඊලග ලිපියෙන් හමුවෙමු.

- චමෝදි -

Friday, November 6, 2020

Java Programming sinhala tutorial - Recursive Method Calling - Part 17

Recursive Method Calling

    Method එකක් තමන්ටම නැවත නැවතත් call කිරීමේ ක්‍රියාවලිය recursive method calling ලෙස හදුන්වනවා. මෙලෙස call කරනු ලබන method එක recursive method ලෙස හදුනා ගන්න පුළුවන්.

Recursion with infinite time

Recursion with finite time

Recursion with factorial number


තවත් Java ගැන ඉගෙන ගන්න ඊලග ලිපියෙන් හමුවෙමු.

- චමෝදි -

Wednesday, November 4, 2020

Game Development - JmonkeyEngine - Adding GUI

3D games සාමාන්යයෙන් full-screen window එකක play කරන්නේ. කෙසේ වෙතත් standard Swing application එකක jME 3 canvas කැන්වස් එකක් embed කරන්න පුළුවන්. ඒක තමයි අද අපි මේ කරන්න යන්නේ. මේක ප්‍රයෝජනවත් වන්නේ ඔයා user interface එකක interactive 3D viewer එකක් වගේ දානවානම්. උදාහරණයක් ලෙස interactive scientific demo එකක්, level editor එකක් හෝ  game character designer එකක් ගන්න පුළුවන්.
මේ පහළ තියෙන්නේ interactive scientific demo එකක්. එකේ 3D viewer එකක් UI ඇතුලේ embed කරලා තියෙනවා.

Code city - Used to visualize source code 3 dimensionally.


SimpleApplication හි කැමරාව mouse එක මගින් වෙනස් කරන්න පුළුවන් උනත් swing application එකක එහෙම කරන්න බැහැ. ඒ නිසා වෙනම camera action එක define කරන්න ඕනේ මේ වගේ.

public void simpleInitApp() {

// activate windowed input behaviour flyCam.setDragToRotate(true); // Set up inputs and load your scene as usual ... }

මෙහිදී වෙනස් වන ප්‍රධාන දෙය වන්නේ main() method එකය. අපි සුපුරුදු විදියට start() method එක call කරන්නේ නැහැ. ඒ වෙනුවට අපි Runnable()  එකක් හදල ඒකින් Swing jFrame නිර්මාණය කරනවා.ඊට පස්සේ jFrame එකට Canvas එකක් එකතු කරලා startCanvas() මගින් game එක run කරනවා.

Swing එක thread-safe නැහැ. ඒ නිසා canvas එකත් up-to-date නැහැ. ඒ නිසා තමයි runnable එකක් යොදා ගන්නේ.

public static void main(String[] args) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() { // ... see below ... } }); }

Here in the run() method, we start the jME application, create its canvas, create a Swing frame, and add everything together.
 com.jme3.system.AppSettings වලින් Swing panel එකේ size එක specify  කරන්න ඕනේ. 

AppSettings settings = new AppSettings(true); settings.setWidth(640); settings.setHeight(480);


මෙහෙම තමයි canvas එකක් හදන්නේ. com.jme3.system.JmeCanvasContext මගින් canvas එක configure කරගන්න පුළුවන්. setSystemListener() මගින් canvas එක අදාළ events(creation , destroy, update) Listener එකට යැවීම සිදු කරනවා..

SwingCanvasTest canvasApplication = new SwingCanvasTest();
canvasApplication.setSettings(settings);
canvasApplication.createCanvas(); // create canvas!
JmeCanvasContext ctx = (JmeCanvasContext) canvasApplication.getContext();
ctx.setSystemListener(canvasApplication);
Dimension dim = new Dimension(640, 480);
ctx.getCanvas().setPreferredSize(dim);

මෙහම තමයි jFrame එකක් හදන්නේ. 

JFrame window = new JFrame("Swing Application");
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

ඊට පස්සේ JPanel එකක් create කර ගන්න ඕනේ JFrame එක ඇතුලේ.

JPanel panel = new JPanel(new FlowLayout()); // a panel
// add all your Swing components ...
panel.add(new JButton("Some Swing Component"));
...
// add the JME canvas
panel.add(ctx.getCanvas());JPanel එක JFrame එක ඇතුලට add කරන්නේ මේ විදියට.
window.add(panel);
window.pack();
window.setVisible(true);

application එක start කරන්න startCanvas() method එක call කරන්න ඕනේ. 

canvasApplication.startCanvas();

මේ පහල තියෙන්නේ full code එක. එහෙනම් compile කරලා බලන්නකෝ. මොනවා හරි ප්‍රශ්නයක් ආවොත් පහලින් comment එකක් දාන්න. එහෙනම් මම නවතිනවා. අලුත් පෝස්ට් එකකින් හම්බ වෙමු.

package hello3D.test;

import com.jme3.app.SimpleApplication;

import com.jme3.material.Material;

import com.jme3.scene.Geometry;

import com.jme3.scene.shape.Box;

import com.jme3.math.ColorRGBA;

import com.jme3.app.LegacyApplication;

import com.jme3.system.AppSettings;

import com.jme3.system.JmeCanvasContext;

import com.jme3.util.JmeFormatter;

import java.awt.BorderLayout;

import java.awt.Canvas;

import java.awt.Container;

import java.awt.Dimension;

import java.awt.FlowLayout;


import java.awt.Panel;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import java.util.concurrent.Callable;

import java.util.logging.ConsoleHandler;

import java.util.logging.Handler;

import java.util.logging.Logger;

import javax.swing.*;


public class HelloWorld extends SimpleApplication {


    public static void main(String[] args) {

        java.awt.EventQueue.invokeLater(new Runnable() {

            public void run() {

                // create new JME appsettings

                AppSettings settings = new AppSettings(true);

                settings.setWidth(640);

                settings.setHeight(480);


                // create new canvas application

                HelloWorld canvasApplication = new HelloWorld();

                canvasApplication.setSettings(settings);

                canvasApplication.createCanvas(); // create canvas!


                JmeCanvasContext ctx = (JmeCanvasContext) canvasApplication.getContext();


                ctx.setSystemListener(canvasApplication);


                Dimension dim = new Dimension(640, 480);


                ctx.getCanvas().setPreferredSize(dim);

                JFrame window = new JFrame("Swing Application");

                window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                JPanel panel = new JPanel(new FlowLayout()); // a panel

                // add all your Swing components ...

                panel.add(new JButton("Some Swing Component"));


                // add the JME canvas

                panel.add(ctx.getCanvas());


                window.add(panel);

                window.pack();

                window.setVisible(true);

                canvasApplication.startCanvas();

            }

        });

    }


    @Override


    public void simpleInitApp() {

        // activate windowed input behaviour

        flyCam.setDragToRotate(true);


        // Set up inputs and load your scene as usual

        Box b = new Box(1, 1, 1); // create cube shape

        Geometry geom = new Geometry("Box", b);  // create cube geometry from the shape

        Material mat = new Material(assetManager,

                "Common/MatDefs/Misc/Unshaded.j3md");  // create a simple material

        mat.setColor("Color", ColorRGBA.Blue);   // set color of material to blue

        geom.setMaterial(mat);                   // set the cube's material

        rootNode.attachChild(geom);              // make the cube appear in the scene

    }

}


Monday, November 2, 2020

Blender Sinhala Tutorial - Doughnut - Part1

Blender වල ගොඩක් famous tutorial  එකක් තමයි මේ doughnut එකක් හදන එක. ඉතින් මමත් එක ඔයාලට කියලා දෙන්න හිතුව.



මුලින් ඉතින් blender open කරගන්න. ඊට පස්සේ එන cube එක delete button එක ප්‍රෙස් කරල ඩිලීට් කරගන්න. ඊට පස්සේ Shift + A click කරන්න. ඊට පස්සේ එන menu එකෙන් Torus තෝරන්න. මොකද doughnut එකකට සමාන shape එකක් තියෙන්නේ torus එකට නිසා.

Torus මෙන්න මේ ආකාරයෙන් තමයි දිස් වෙන්නේ.


දකුණු පැත්තෙ තියෙන menu එකේ ඔයාට පේනවා major radius සහ minor radius කියලා දෙකක් තියේනවා.


Major radius කියන්නේ torus එකේ පිටින්ම තියන රවූමේ radius එක.

Major radius = 1.24 

Minor radius කියන්නේ torus එකේ ඇතුළතින් තියන රවූමේ radius එක.

Minor radius = 0.40 

ඉතින් මේ radius දෙක වෙනස් කරමින් doughnut එකක shape එකක් create කරගන්න. මේ තියෙන්නෙ මං හදාගත්ත  ඩෝනට් එක.



හැබැයි මේක තාම doughnut එකක් වගේ නම් නැහැ. මොකද smooth ගතියක් නැහැ තාම. ඒත් smooth ගතිය ගොඩක්මත් වැඩි කරන්න බැහැ අපිට. මොකද smooth ගතිය වැඩි වෙන්න වෙන්න process කරන්න යන වෙලාව වැඩි වෙන නිසා.smooth ගතිය වැඩි කර ගන්න පුළුවන් මේ දකුණු පැත්තේ පහල තියෙන segments ගාන වැඩි කරලා.

කොහොම නමුත් මම segments ගාන මේ ආකාරයෙන් තියා ගන්නවා.

Major segments = 28 |  Minor segments =10


ඉතින් පොස්ට් එක තවත් දික් වෙන නිසා අදට නවතිනවා. ඊලග කොටසින් හම්බ වෙමු.


-Hasini Senanayaka-